1 files changed, 354 insertions, 0 deletions
diff --git a/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/api/TypeTest.java b/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/api/TypeTest.java
new file mode 100644
index 0000000000..5f5c23ad5f
--- /dev/null
+++ b/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/api/TypeTest.java
@@ -0,0 +1,354 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ *  
+ *  $Rev$  $Date$
+ */
+package test.sdo21.tests.api;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import test.sdo21.tests.TestData.StandardDynamicFactory;
+import test.sdo21.tests.TestData.StandardFactory;
+import test.sdo21.tests.TestData.StandardXSDFactory;
+import test.sdo21.tests.TestData.TestDataFactory;
+
+import commonj.sdo.Property;
+import commonj.sdo.Type;
+
+
+public abstract class TypeTest extends CTSConsistencyBase {
+    public TypeTest() {
+    } 
+
+    public static class DynamicMetadata extends TypeTest {
+      public DynamicMetadata() {
+        
+      }
+      public TestDataFactory createTestDataFactory() {
+  
+        return new StandardDynamicFactory();
+      }
+    }
+  
+    public static class XSDMetadata extends TypeTest {
+      
+      public XSDMetadata() {
+      }
+      
+      public TestDataFactory createTestDataFactory() {
+  
+        return new StandardXSDFactory();
+      }
+    }
+    
+    
+    @Before
+    public void setUp () throws Exception {
+      super.setUp();
+    }
+    
+    @After
+    public void tearDown() throws Exception {
+      super.tearDown();
+    }
+    
+    /**
+     * Verify the value returned by Type.getName()
+     */
+    @Test
+    public void typeGetName() {
+        Type type = testDO.getType();
+        assertEquals("Type.getName() returned an unexpected value.", StandardFactory.API_TYPE, type.getName());
+    }
+
+    /**
+     * Verify the value returned by Type.getURI()
+     */
+    @Test
+    public void typeGetURI() {
+        Type type = testDO.getType();
+        assertEquals("Type.getURI() returned an unexpected value.", StandardFactory.TEST_NAMESPACE, type.getURI());
+    }
+
+
+    /**
+     * Verify the value returned by Type.isInstance() == true
+     */
+    @Test
+    public void typeIsInstanceTrue() {
+        Type type = testDO.getType();
+
+        assertTrue("Type.getInstance() returned an unexpected value.", type.isInstance(testDO));
+    }
+
+    /**
+     * Verify the value returned by Type.isInstance() == false
+     */
+    @Test
+    public void typeIsInstanceFalse() {
+        Type booleanType = testDO.getInstanceProperty("booleanVal").getType();
+        Type type = testDO.getType();
+
+        assertFalse("Type.getInstance() returned an unexpected value.", type.isInstance(booleanType));
+    }
+
+    /**
+     * Verify the value returned by Type.isDataType() == true
+     */
+    @Test
+    public void typeIsDataTypeTrue() {
+        Type booleanType = testDO.getInstanceProperty("booleanVal").getType();
+
+        assertTrue("Type.isDataType() returned an unexpected value.", booleanType.isDataType());
+    }
+
+    /**
+     * Verify the value returned by Type.isDataType() == False
+     */
+    @Test
+    public void typeIsDataTypeFalse() {
+        Type type = testDO.getType();
+
+        assertFalse("Type.isDataType() returned an unexpected value.", type.isDataType());
+    }
+
+    /**
+     * Verify the value returned by Type.isSequenced() == true
+     */
+    @Test
+    public void typeIsSequencedTrue() {
+        Type sequencedType = testDO.getInstanceProperty("sequencedElem").getType();
+
+        assertTrue("Type.isSequenced() returned an unexpected value.", sequencedType.isSequenced());
+    }
+
+    /**
+     * Verify the value returned by Type.isSequenced() == False
+     */
+    @Test
+    public void typeIsSequencedFalse() {
+        Type type = testDO.getType();
+
+        assertFalse("Type.isSequenced() returned an unexpected value.", type.isSequenced());
+    }
+
+    /**
+     * Verify the value returned by Type.isOpen() == true
+     */
+    @Test
+    public void typeIsOpenTrue() {
+       Type type = testDO.getInstanceProperty("openElem").getType();
+       assertTrue("Type.isOpen() returned an unexpected value.", type.isOpen());
+    }
+
+    /**
+     * Verify the value returned by Type.isOpen() == False
+     */
+    @Test
+    public void typeIsOpenFalse() {
+        Type type = testDO.getType();
+
+        assertFalse("Type.isOpen() returned an unexpected value.", type.isOpen());
+    }
+
+    /**
+     * Verify the value returned by Type.isAbstract() == true
+     */
+    @Test
+    public void typeIsAbstractTrue() {
+        Type abstractType =
+            getScope().getTypeHelper().getType(StandardFactory.TEST_NAMESPACE, StandardFactory.ABSTRACT_TYPE);
+
+        assertTrue("Type.isAbstract() returned an unexpected value.", abstractType.isAbstract());
+    }
+
+    /**
+     * Verify the value returned by Type.isAbstract() == False
+     */
+    @Test
+    public void typeIsAbstractFalse() {
+        Type type = testDO.getType();
+
+        assertFalse("Type.isAbstract() returned an unexpected value.", type.isAbstract());
+    }
+
+    /**
+     * Verify the value returned by Type.getBaseTypes() when there are no base
+     * types
+     */
+    @Test
+    public void typeGetBaseTypesNone() {
+        Type type = testDO.getType();
+
+        assertEquals("Type.getBaseTypes() returned a List of unexpected size.", 0, type.getBaseTypes().size());
+    }
+
+    /**
+     * Verify the value returned by Type.getBaseTypes() when there are base
+     * Types to return
+     */
+    @Test
+    public void typeGetBaseTypes() {
+        Type extendedType = testDO.getInstanceProperty("extendedElem").getType();
+
+        assertNotSame("Type.getBaseTypes() did not return the expected base type.", 0, extendedType.getBaseTypes()
+            .size());
+    }
+
+    /**
+     * Verify the value returned by Type.getAliasNames() when there are no alias
+     * names
+     */
+    @Test
+    public void typeGetAliasNamesNone() {
+        Type type = testDO.getType();
+
+        assertEquals("Type.getAliasNames() returned a List of unexpected size.", 0, type.getAliasNames().size());
+    }
+
+    /**
+     * Verify the List returned by Type.getProperties()
+     */
+    @Test
+    public void typeGetProperties() {
+        Type type = testDO.getType();
+
+        assertTrue("Type.getProperties() did not return the expected List.", verifyPropertyList(type.getProperties()));
+    }
+
+    /**
+     * Verify the List returned by Type.getDeclaredProperties()
+     */
+    @Test
+    public void typeGetDeclaredProperties() {
+        Type type = testDO.getType();
+
+        assertTrue("Type.getProperties() did not return the expected List.", verifyPropertyList(type
+            .getDeclaredProperties()));
+    }
+
+    /**
+     * Verify the value returned by Type.getProperty()
+     */
+    @Test
+    public void typeGetProperty() {
+        Type type = testDO.getType();
+
+        assertEquals("Type.getProperty() returned an unexpected Property.", "booleanVal", type
+            .getProperty("booleanVal").getName());
+    }
+
+    /**
+     * Verify the handling of an inaccurate name by Type.getProperty()
+     */
+    @Test
+    public void typeGetPropertyInvalidString() {
+        Type type = testDO.getType();
+
+        assertNull("Type.getProperty() returned an unexpected Property.", type.getProperty("madeUpName"));
+    }
+
+    /**
+     * verifyPropertyList is a private method used to ensure that all expected
+     * Properties are contained in the input List
+     * 
+     * @param properties
+     * @return
+     */
+    private static boolean verifyPropertyList(List properties) {
+        boolean stringValFound = false, booleanValFound = false, booleanVal2Found = false, byteValFound = false;
+        boolean stringVal2Found = false, decimalValFound = false, decimalVal2Found = false, intValFound = false;
+        boolean floatValFound = false, doubleValFound = false, dateValFound = false, shortValFound = false, longValFound =
+            false;
+        boolean containManyFound = false, bytesValFound = false, integerValFound = false, charValFound = false, sequencedElemFound =
+            false;
+
+        Property currProperty;
+        for (int i = 0; i < properties.size(); i++) {
+            currProperty = (Property)properties.get(i);
+
+            if (!stringValFound && currProperty.getName().equals("stringVal"))
+                stringValFound = true;
+            else if (!booleanValFound && currProperty.getName().equals("booleanVal"))
+                booleanValFound = true;
+            else if (!booleanVal2Found && currProperty.getName().equals("booleanVal2"))
+                booleanVal2Found = true;
+            else if (!byteValFound && currProperty.getName().equals("byteVal"))
+                byteValFound = true;
+            else if (!stringVal2Found && currProperty.getName().equals("stringVal2"))
+                stringVal2Found = true;
+            else if (!decimalValFound && currProperty.getName().equals("decimalVal"))
+                decimalValFound = true;
+            else if (!decimalVal2Found && currProperty.getName().equals("decimalVal2"))
+                decimalVal2Found = true;
+            else if (!intValFound && currProperty.getName().equals("intVal"))
+                intValFound = true;
+            else if (!floatValFound && currProperty.getName().equals("floatVal"))
+                floatValFound = true;
+            else if (!doubleValFound && currProperty.getName().equals("doubleVal"))
+                doubleValFound = true;
+            else if (!dateValFound && currProperty.getName().equals("dateVal"))
+                dateValFound = true;
+            else if (!shortValFound && currProperty.getName().equals("shortVal"))
+                shortValFound = true;
+            else if (!longValFound && currProperty.getName().equals("longVal"))
+                longValFound = true;
+            else if (!containManyFound && currProperty.getName().equals("containMany"))
+                containManyFound = true;
+            else if (!bytesValFound && currProperty.getName().equals("bytesVal"))
+                bytesValFound = true;
+            else if (!integerValFound && currProperty.getName().equals("integerVal"))
+                integerValFound = true;
+            else if (!charValFound && currProperty.getName().equals("charVal"))
+                charValFound = true;
+            else if (!sequencedElemFound && currProperty.getName().equals("sequencedElem"))
+                sequencedElemFound = true;
+        }
+
+        if (stringValFound && booleanValFound
+            && booleanVal2Found
+            && byteValFound
+            && stringVal2Found
+            && decimalValFound
+            && decimalVal2Found
+            && intValFound
+            && floatValFound
+            && doubleValFound
+            && dateValFound
+            && shortValFound
+            && longValFound
+            && containManyFound
+            && bytesValFound
+            && integerValFound
+            && charValFound
+            && sequencedElemFound)
+            return true;
+        else
+            return false;
+    }
+}