1 files changed, 435 insertions, 0 deletions
diff --git a/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/api/SequenceAddOpenTest.java b/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/api/SequenceAddOpenTest.java
new file mode 100644
index 0000000000..73ea84f0d2
--- /dev/null
+++ b/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/api/SequenceAddOpenTest.java
@@ -0,0 +1,435 @@
+/*
+ *  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 junit.framework.TestCase;
+import test.sdo21.framework.TestHelper;
+import test.sdo21.framework.junit3_8.CTSTestCase;
+import test.sdo21.CTSSuite;
+import commonj.sdo.DataObject;
+import commonj.sdo.Property;
+import commonj.sdo.Sequence;
+import commonj.sdo.Type;
+import commonj.sdo.helper.HelperContext;
+import commonj.sdo.helper.TypeHelper;
+import commonj.sdo.helper.DataFactory;
+
+/**
+ * Tests adding objects to a sequence. Note: the tests in this test case must be run sequentially as each test
+ * depends on state from the previous test.
+ */
+public class SequenceAddOpenTest extends CTSTestCase {
+
+    protected TestHelper testHelper;
+    protected DataFactory dataFactory;
+    protected TypeHelper typeHelper;
+    protected DataObject testOpenDataObject;
+
+    public SequenceAddOpenTest(String string) {
+        super(string);
+    }
+
+    public void setUp() throws Exception {
+        super.setUp();
+
+        HelperContext scope = getScope();
+        testHelper = getTestHelper();
+        dataFactory = scope.getDataFactory();
+        typeHelper = scope.getTypeHelper();
+
+        // define an open type if it is not already defined in the HelperContext provided
+        // by the implementation being tested
+        String typeURI = "http://www.example.com/cts/SequenceAddOpenTest";
+        String typeName = "OpenDataObject";
+        Type openType = typeHelper.getType(typeURI, typeName);
+        if (openType == null) {
+          DataObject typeDef = dataFactory.create("commonj.sdo", "Type");
+          typeDef.set("uri", typeURI);
+          typeDef.set("name", typeName);
+          typeDef.set("open", true);
+          typeDef.set("sequenced", true);
+          openType = typeHelper.define(typeDef);
+        }
+
+        testOpenDataObject = dataFactory.create( openType );
+    }
+
+    /**
+     * Tests the SDO 2.1 Sequence method for the
+     * java type of Boolean
+     * <p/>
+     * boolean add(String propertyName, Object value)
+     */
+    public void testAddBooleanByName() throws Exception {
+
+        //Get a sequence to add to
+        Sequence testSequence = testOpenDataObject.getSequence();
+
+        //Add 3 proprerties
+        testSequence.add("testBoolean1", Boolean.TRUE);
+        testSequence.add("testBoolean2", Boolean.FALSE);
+        testSequence.add("testBoolean3", Boolean.TRUE);
+
+        //Check that the size is reported correctly
+        //with the size of 3.
+        assertEquals(3, testSequence.size());
+
+        //Check the values that were added
+        assertEquals(Boolean.TRUE, testSequence.getValue(0));
+        assertEquals(Boolean.FALSE, testSequence.getValue(1));
+        assertEquals(Boolean.TRUE, testSequence.getValue(2));
+
+        Property prop = testSequence.getProperty(0);
+
+        //OnDemand property should be a string
+        //Checking only the first property
+        assertEquals("testBoolean1", prop.getName());
+        assertEquals("BooleanObject", prop.getType().getName());
+
+    }
+
+    /**
+     * Tests the SDO 2.1 Sequence method for the
+     * java type of Boolean
+     * <p/>
+     * boolean add(Property property, Object value)
+     */
+    public void testAddBooleanByProperty() throws Exception {
+
+        DataObject prop = dataFactory.create("commonj.sdo", "Property");
+        prop.set("type", typeHelper.getType("commonj.sdo", "Boolean"));
+        prop.set("name", "testBoolean1");
+
+        Property openProp = typeHelper.defineOpenContentProperty(null, prop);
+        Sequence testSequence = testOpenDataObject.getSequence();
+        testSequence.add(openProp, new Boolean(false));
+        assertEquals(Boolean.FALSE, testSequence.getValue(0));
+
+        openProp = testSequence.getProperty(0);
+
+        //OnDemand property should be a string
+        //Checking only the first property
+        assertEquals("testBoolean1", openProp.getName());
+        assertEquals("Boolean", openProp.getType().getName());
+
+    }
+
+    /**
+     * Tests the SDO 2.1 Sequence method for the
+     * java type of Boolean
+     * <p/>
+     * boolean add(int propertyIndex, Object value)
+     */
+    public void testAddBooleanByPropertyIndex() throws Exception {
+
+        Sequence testSequence = testOpenDataObject.getSequence();
+        testSequence.add("testBoolean", new Boolean(true));
+        testSequence.add("testBoolean", new Boolean(false));
+
+        //Actual value to test from sequence
+        testSequence.add(0, new Boolean(false));
+        assertEquals(Boolean.FALSE, testSequence.getValue(2));
+
+    }
+
+    /**
+     * Tests the SDO 2.1 Sequence method for the
+     * java type of Boolean
+     * <p/>
+     * boolean add(int index, String propertyName, Object value)
+     */
+    public void testAddBooleanByIndexAndPropertyName() throws Exception {
+
+        //Get a sequence from the test fixture DataObject
+        Sequence testSequence = testOpenDataObject.getSequence();
+
+        testSequence.add(0, "testBoolean", new Boolean(true));
+        assertEquals(Boolean.TRUE, testSequence.getValue(0));
+
+    }
+
+    /**
+     * Tests the SDO 2.1 Sequence method for the
+     * java type of Boolean
+     * <p/>
+     * boolean add(int index, Property property, Object value)
+     */
+    public void testAddBooleanByIndexAndProperty() throws Exception {
+
+        DataObject prop = dataFactory.create("commonj.sdo", "Property");
+        prop.set("type", typeHelper.getType("commonj.sdo", "Boolean"));
+        prop.set("name", "testBoolean");
+
+        Property openProp = typeHelper.defineOpenContentProperty(null, prop);
+        Sequence testSequence = testOpenDataObject.getSequence();
+        testSequence.add(0, openProp, new Boolean(false));
+        assertEquals(Boolean.FALSE, testSequence.getValue(0));
+
+    }
+
+    /**
+     * Tests the SDO 2.1 Sequence method for the
+     * java type of Boolean
+     * <p/>
+     * boolean add(int index, int propertyIndex, Object value)
+     */
+    public void testSequenceAddBooleanByIndexAndPropertyIndex() throws Exception {
+
+        Sequence testSequence = testOpenDataObject.getSequence();
+        testSequence.add("testBoolean", new Boolean(true));
+        testSequence.add("testBoolean", new Boolean(false));
+
+        //Actual value to test from sequence
+        testSequence.add(0, 0, new Boolean(false));
+        assertEquals(Boolean.FALSE, testSequence.getValue(2));
+
+    }
+
+    /**
+     * Tests the SDO 2.1 Sequence method for the
+     * java type of String
+     * <p/>
+     * boolean add(String propertyName, Object value)
+     */
+    public void testAddStringByName() throws Exception {
+
+        //Get a sequence to add to
+        Sequence testSequence = testOpenDataObject.getSequence();
+
+        testSequence.add("testString", new String("testString"));
+        assertEquals("testString", testSequence.getValue(0));
+
+    }
+
+    /**
+     * Tests the SDO 2.1 Sequence method for the
+     * java type of String
+     * <p/>
+     * boolean add(Property property, Object value)
+     */
+    public void testAddStringByProperty() throws Exception {
+
+        DataObject prop = dataFactory.create("commonj.sdo", "Property");
+        prop.set("type", typeHelper.getType("commonj.sdo", "String"));
+        prop.set("name", "testString");
+
+        Property openProp = typeHelper.defineOpenContentProperty(null, prop);
+        Sequence testSequence = testOpenDataObject.getSequence();
+
+        //Actual value to test
+        testSequence.add(openProp, new String("testString"));
+        assertEquals("testString", testSequence.getValue(0));
+
+    }
+
+    /**
+     * Tests the SDO 2.1 Sequence method for the
+     * java type of String
+     * <p/>
+     * boolean add(int propertyIndex, Object value)
+     */
+    public void testAddStringByPropertyIndex() throws Exception {
+
+        Sequence testSequence = testOpenDataObject.getSequence();
+
+        //Add additional duplicate properties
+        testSequence.add("testString", new String("testString"));
+        testSequence.add("testString", new String("testString1"));
+
+        //Actual value to check
+        testSequence.add(0, (Object)new String("testString2"));
+        assertEquals("testString2", testSequence.getValue(2));
+
+
+    }
+
+    /**
+     * Tests the SDO 2.1 Sequence method for the
+     * java type of String
+     * <p/>
+     * boolean add(int index, String propertyName, Object value)
+     */
+    public void testAddStringByIndexAndPropertyName() throws Exception {
+
+        //Get a sequence from the test fixture DataObject
+        Sequence testSequence = testOpenDataObject.getSequence();
+
+        //Actual value to test
+        testSequence.add(0, "testString", new String("testString"));
+        assertEquals("testString", testSequence.getValue(0));
+
+    }
+
+    /**
+     * Tests the SDO 2.1 Sequence method for the
+     * java type of String
+     * <p/>
+     * boolean add(int index, Property property, Object value)
+     */
+    public void testAddStringByIndexAndProperty() throws Exception {
+
+        DataObject prop = dataFactory.create("commonj.sdo", "Property");
+        prop.set("type", typeHelper.getType("commonj.sdo", "String"));
+        prop.set("name", "testString");
+
+        Property openProp = typeHelper.defineOpenContentProperty(null, prop);
+        Sequence testSequence = testOpenDataObject.getSequence();
+
+        //Actual value to test
+        testSequence.add(0, openProp, new String("testString"));
+        assertEquals("testString", testSequence.getValue(0));
+
+    }
+
+    /**
+     * Tests the SDO 2.1 Sequence method for the
+     * java type of String
+     * <p/>
+     * boolean add(int index, int propertyIndex, Object value)
+     */
+    public void testSequenceAddStringByIndexAndPropertyIndex() throws Exception {
+
+        Sequence testSequence = testOpenDataObject.getSequence();
+        testSequence.add("testString", new String("testString1"));
+        testSequence.add("testString", new String("testString2"));
+
+        //Actual value to test from the sequence
+        testSequence.add(0, 0, new String("testString"));
+        assertEquals("testString2", testSequence.getValue(2));
+
+    }
+
+    /**
+     * Tests the SDO 2.1 Sequence method for the
+     * java type of Character
+     * <p/>
+     * boolean add(Character propertyName, Object value)
+     */
+    public void testAddCharacterByName() throws Exception {
+
+        //Get a sequence to add to
+        Sequence testSequence = testOpenDataObject.getSequence();
+
+        testSequence.add("testCharacter", new Character('A'));
+        assertEquals('A', testSequence.getValue(0));
+
+    }
+
+    /**
+     * Tests the SDO 2.1 Sequence method for the
+     * java type of Character
+     * <p/>
+     * boolean add(Property property, Object value)
+     */
+    public void testAddCharacterByProperty() throws Exception {
+
+        DataObject prop = dataFactory.create("commonj.sdo", "Property");
+        prop.set("type", typeHelper.getType("commonj.sdo", "Character"));
+        prop.set("name", "testCharacter");
+
+        Property openProp = typeHelper.defineOpenContentProperty(null, prop);
+        Sequence testSequence = testOpenDataObject.getSequence();
+
+        //Actual value to test
+        testSequence.add(openProp, new Character('A'));
+        assertEquals('A', testSequence.getValue(0));
+
+    }
+
+    /**
+     * Tests the SDO 2.1 Sequence method for the
+     * java type of Character
+     * <p/>
+     * boolean add(int propertyIndex, Object value)
+     */
+    public void testAddCharacterByPropertyIndex() throws Exception {
+
+        Sequence testSequence = testOpenDataObject.getSequence();
+
+        //Add additional duplicate properties
+        testSequence.add("testCharacter", new Character('A'));
+        testSequence.add("testCharacter", new Character('B'));
+
+        //Actual value to check
+        testSequence.add(0, new Character('C'));
+        assertEquals('C', testSequence.getValue(2));
+
+
+    }
+
+    /**
+     * Tests the SDO 2.1 Sequence method for the
+     * java type of Character
+     * <p/>
+     * boolean add(int index, Character propertyName, Object value)
+     */
+    public void testAddCharacterByIndexAndPropertyName() throws Exception {
+
+        //Get a sequence from the test fixture DataObject
+        Sequence testSequence = testOpenDataObject.getSequence();
+
+        //Actual value to test
+        testSequence.add(0, "testCharacter", new Character('A'));
+        assertEquals('A', testSequence.getValue(0));
+
+    }
+
+    /**
+     * Tests the SDO 2.1 Sequence method for the
+     * java type of Character
+     * <p/>
+     * boolean add(int index, Property property, Object value)
+     */
+    public void testAddCharacterByIndexAndProperty() throws Exception {
+
+        DataObject prop = dataFactory.create("commonj.sdo", "Property");
+        prop.set("type", typeHelper.getType("commonj.sdo", "Character"));
+        prop.set("name", "testCharacter");
+
+        Property openProp = typeHelper.defineOpenContentProperty(null, prop);
+        Sequence testSequence = testOpenDataObject.getSequence();
+
+        //Actual value to test
+        testSequence.add(0, openProp, new Character('A'));
+        assertEquals('A', testSequence.getValue(0));
+
+    }
+
+    /**
+     * Tests the SDO 2.1 Sequence method for the
+     * java type of Character
+     * <p/>
+     * boolean add(int index, int propertyIndex, Object value)
+     */
+    public void testSequenceAddCharacterByIndexAndPropertyIndex() throws Exception {
+
+        Sequence testSequence = testOpenDataObject.getSequence();
+        testSequence.add("testCharacter", new Character('A'));
+        testSequence.add("testCharacter", new Character('B'));
+
+        //Actual value to test from the sequence
+        testSequence.add(0, 0, new Character('C'));
+        assertEquals('C', testSequence.getValue(0));
+        assertEquals('A', testSequence.getValue(1));
+        assertEquals('B', testSequence.getValue(2));
+
+    }
+}