diff options
Diffstat (limited to 'sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/scenarios/DataObjectListTest.java')
-rw-r--r-- | sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/scenarios/DataObjectListTest.java | 542 |
1 files changed, 542 insertions, 0 deletions
diff --git a/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/scenarios/DataObjectListTest.java b/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/scenarios/DataObjectListTest.java new file mode 100644 index 0000000000..af586ee358 --- /dev/null +++ b/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/scenarios/DataObjectListTest.java @@ -0,0 +1,542 @@ +/* + * 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.scenarios; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; +import java.util.ListIterator; + +import test.sdo21.framework.junit3_8.CTSTestCase; + +import commonj.sdo.DataObject; +import commonj.sdo.Property; +import commonj.sdo.Type; +import commonj.sdo.helper.DataFactory; +import commonj.sdo.helper.TypeHelper; +import commonj.sdo.helper.XMLDocument; +import commonj.sdo.helper.XMLHelper; + +/** + * Test cases for the DataObject SDO implementation. + */ +public class DataObjectListTest extends CTSTestCase { + + /** + * Number of iterations for data type tests (sets and retrieves random + * values for each data type) + */ + + public static final int DATA_TYPE_ITERATIONS = 10; + private static int unique = 0; + + public DataObjectListTest(String title) { + super(title); + } + + public void setUp() throws Exception { + super.setUp(); + } + + /** + * Helper function for converions tests. + */ + private DataObject createType(String uri, String name) { + DataObject newType = DataFactory.INSTANCE.create("commonj.sdo", "Type"); + newType.set("uri", uri); + newType.set("name", name); + return newType; + } + + /** + * Helper function for converions tests. Creates a new type property with + * unique name and data hold property + * + * @return the property DataObject. + */ + private DataObject createTestObjectType() { + String uri = "http://example.com/DataObjectImplTest/" + unique; + String name = "DataObjectImplTest" + unique; + unique++; + // create new DataType + DataObject newType = createType(uri, name); + + // define the type + TypeHelper types = TypeHelper.INSTANCE; + types.define(newType); + return newType; + } + + /** + * Helper function. + */ + private Type getNewTestType() { + String uri = "http://example.com/DataObjectImplTest/" + (unique - 1); + String name = "DataObjectImplTest" + (unique - 1); + + return TypeHelper.INSTANCE.getType(uri, name); + } + + /** + * Helper function. Creates a new DataObject with unique Name and URI + * + * @return the created DataObject. + */ + private DataObject createTestObject() { + String uri = "http://example.com/DataObjectImplTest/" + (unique - 1); + String name = "DataObjectImplTest" + (unique - 1); + + // create DataObject with new Type + DataObject newObj = DataFactory.INSTANCE.create(uri, name); + return newObj; + } + + /** + * See SDO Spec 2.1.0 3.1.13 DataObject Accessor Exceptions General + * get(String path) returns null if path does not exist + */ + public void testGetInvalidInstanceProperty() { + createTestObjectType(); + + DataObject testObj = createTestObject(); + assertNotNull(testObj); + commonj.sdo.Property property = testObj.getInstanceProperty("nonexistentProperty"); + assertNull("testObj.getInstanceProperty(\"nonexistentProperty\") should return null", property); + } + + private void createTestObjectTypes() { + Type typeCheck = TypeHelper.INSTANCE.getType("", "catalog2"); + if (typeCheck == null) { + /* + * create type system catalog2 - product2:DataObject[isMany:true] + * product2 - nameTest:String my guess is that the intention is + * catalog2 - product2:product2(isMany:true) - nameTest:String + */ + DataObject newType = createType("", "catalog2"); + + TypeHelper types = TypeHelper.INSTANCE; + + DataObject newType2 = createType("", "product2"); + + Property xmlElementProp = getScope().getXSDHelper().getGlobalProperty("commonj.sdo/xml", "xmlElement", false); + DataObject property = newType2.createDataObject("property"); + property.set("name", "name"); + property.set("type", TypeHelper.INSTANCE.getType("commonj.sdo", "String")); + property.setBoolean(xmlElementProp, false); + + + Type nt2 = types.define(newType2); + + DataObject property2 = newType.createDataObject("property"); + property2.set("name", "product2"); + property2.set("type", nt2); + property2.setBoolean("many", true); + + types.define(newType); + + } + } + + private XMLDocument loadDocFromString(String strXML) { + createTestObjectTypes(); + return XMLHelper.INSTANCE.load(strXML); + } + + private List createTestObj(XMLDocument doc) { + return doc.getRootObject().getList("product2"); + } + + + public void testClear() { + XMLDocument doc = loadDocFromString("<catalog2><product2/><product2/></catalog2>"); + List listTest = createTestObj(doc); + assertNotNull(listTest); + + assertEquals(2, listTest.size()); + listTest.clear(); + assertEquals(0, listTest.size()); + } + + public void testIsEmpty() { + XMLDocument doc = loadDocFromString("<catalog2><product2/><product2/></catalog2>"); + List listTest = createTestObj(doc); + assertNotNull(listTest); + + assertEquals(2, listTest.size()); + assertFalse(listTest.isEmpty()); + + XMLDocument doc2 = loadDocFromString("<catalog2></catalog2>"); + List listTest2 = createTestObj(doc2); + assertNotNull(listTest2); + assertEquals(0, listTest2.size()); + assertTrue(listTest2.isEmpty()); + } + + public void testToArray() { + String xmldoc = + "<catalog2><product2 name=\"name1\"/><product2 name=\"name2\"/></catalog2>"; + // "<catalog2><product2 nameTest=\"name1\"/><product2 + // nameTest=\"name2\"/></catalog2>" + XMLDocument doc = loadDocFromString(xmldoc); + List listTest = createTestObj(doc); + assertNotNull(listTest); + + Object[] objArray = listTest.toArray(); + + assertNotNull(objArray); + assertEquals(2, objArray.length); + // assertEquals("name1",((DataObject)objArray[0]).getString("nameTest")); + assertEquals("name2", ((DataObject)objArray[1]).getString("name")); + } + + public void testAddNull() { + XMLDocument doc = loadDocFromString("<catalog2><product2/><product2/></catalog2>"); + List listTest = createTestObj(doc); + assertNotNull(listTest); + + try { + listTest.add(null); + fail("no exception were thrown"); + } + // TODO investigate interoperability issue + catch (java.lang.NullPointerException e) { + // RogueWave success + } catch (IllegalArgumentException e) { + // Tuscany success + } + } + + public void testAddObject() { + XMLDocument doc = loadDocFromString("<catalog2></catalog2>"); + List listTest = createTestObj(doc); + assertNotNull(listTest); + assertEquals(0, listTest.size()); + + DataObject doInsert = DataFactory.INSTANCE.create("", "product2"); + assertNotNull(doInsert); + doInsert.setString("name", "aname"); + listTest.add(0, doInsert); + + assertEquals(1, listTest.size()); + DataObject doRes = (DataObject)listTest.get(0); + assertEquals("aname", doRes.getString("name")); + } + + public void testAddAll() { + XMLDocument doc = loadDocFromString("<catalog2><product2/><product2/></catalog2>"); + List listTest = createTestObj(doc); + assertNotNull(listTest); + assertEquals(2, listTest.size()); + + DataObject doInsert1 = DataFactory.INSTANCE.create("", "product2"); + assertNotNull(doInsert1); + doInsert1.setString("name", "aname1"); + + DataObject doInsert2 = DataFactory.INSTANCE.create("", "product2"); + assertNotNull(doInsert2); + doInsert2.setString("name", "aname2"); + + ArrayList arraylist2 = new ArrayList(); + arraylist2.add(doInsert1); + arraylist2.add(doInsert2); + + listTest.addAll(0, arraylist2); + + assertEquals(4, listTest.size()); + DataObject doRes = (DataObject)listTest.get(0); + assertEquals("aname1", doRes.getString("name")); + } + + public void testAddAllCollection() { + XMLDocument doc = loadDocFromString("<catalog2><product2/><product2/></catalog2>"); + List listTest = createTestObj(doc); + assertNotNull(listTest); + assertEquals(2, listTest.size()); + + DataObject doInsert1 = DataFactory.INSTANCE.create("", "product2"); + assertNotNull(doInsert1); + doInsert1.setString("name", "aname1"); + + DataObject doInsert2 = DataFactory.INSTANCE.create("", "product2"); + assertNotNull(doInsert2); + doInsert2.setString("name", "aname2"); + + ArrayList arraylist2 = new ArrayList(); + arraylist2.add(doInsert1); + arraylist2.add(doInsert2); + + boolean bRes = listTest.addAll(arraylist2); + + assertTrue(bRes); + assertEquals(4, listTest.size()); + DataObject doRes = (DataObject)listTest.get(2); + assertEquals("aname1", doRes.getString("name")); + } + + public void testAddAllCollectionEmpty() { + XMLDocument doc = loadDocFromString("<catalog2><product2/><product2/></catalog2>"); + List listTest = createTestObj(doc); + assertNotNull(listTest); + assertEquals(2, listTest.size()); + + ArrayList arraylist2 = new ArrayList(); + + boolean bRes = listTest.addAll(arraylist2); + + assertFalse(bRes); + assertEquals(2, listTest.size()); + } + + public void testIndexOf() { + XMLDocument doc = loadDocFromString("<catalog2><product2/><product2/></catalog2>"); + List listTest = createTestObj(doc); + assertNotNull(listTest); + assertEquals(2, listTest.size()); + + DataObject do1 = (DataObject)listTest.get(1); + assertNotNull(do1); + + int nIdx = listTest.indexOf(do1); + + assertEquals(1, nIdx); + } + + public void testLastIndexOf() { + XMLDocument doc = loadDocFromString("<catalog2><product2/><product2/></catalog2>"); + List listTest = createTestObj(doc); + assertNotNull(listTest); + assertEquals(2, listTest.size()); + + DataObject do1 = (DataObject)listTest.get(1); + assertNotNull(do1); + + int nIdx = listTest.lastIndexOf(do1); + + assertEquals(1, nIdx); + } + + public void testContains() { + XMLDocument doc = loadDocFromString("<catalog2><product2/><product2/></catalog2>"); + List listTest = createTestObj(doc); + assertNotNull(listTest); + assertEquals(2, listTest.size()); + + DataObject do1 = (DataObject)listTest.get(1); + assertNotNull(do1); + + boolean bRes = listTest.contains(do1); + + assertTrue(bRes); + + DataObject doTest = DataFactory.INSTANCE.create("", "product2"); + assertNotNull(doTest); + + bRes = listTest.contains(doTest); + + assertFalse(bRes); + } + + public void testRemoveObject() { + XMLDocument doc = loadDocFromString("<catalog2><product2/><product2/></catalog2>"); + List listTest = createTestObj(doc); + assertNotNull(listTest); + assertEquals(2, listTest.size()); + + DataObject do1 = (DataObject)listTest.get(1); + assertNotNull(do1); + + boolean bRes = listTest.remove(do1); + assertTrue(bRes); + assertEquals(1, listTest.size()); + + DataObject doTest = DataFactory.INSTANCE.create("", "product2"); + assertNotNull(doTest); + + bRes = listTest.remove(doTest); + assertFalse(bRes); + assertEquals(1, listTest.size()); + } + + public void testContainsAll() { + XMLDocument doc = loadDocFromString("<catalog2><product2/><product2/></catalog2>"); + List listTest = createTestObj(doc); + assertNotNull(listTest); + assertEquals(2, listTest.size()); + + DataObject do1 = (DataObject)listTest.get(1); + assertNotNull(do1); + + ArrayList arraylist1 = new ArrayList(); + arraylist1.add(do1); + + boolean bRes = listTest.containsAll(arraylist1); + + assertTrue(bRes); + + DataObject doTest = DataFactory.INSTANCE.create("", "product2"); + assertNotNull(doTest); + arraylist1.add(doTest); + + bRes = listTest.containsAll(arraylist1); + + assertFalse(bRes); + } + + public void testRemoveAll() { + XMLDocument doc = loadDocFromString("<catalog2><product2/><product2/></catalog2>"); + List listTest = createTestObj(doc); + assertNotNull(listTest); + assertEquals(2, listTest.size()); + + DataObject do1 = (DataObject)listTest.get(1); + assertNotNull(do1); + + ArrayList arraylist1 = new ArrayList(); + arraylist1.add(do1); + + boolean bRes = listTest.removeAll(arraylist1); + + assertTrue(bRes); + assertEquals(1, listTest.size()); + } + + public void testRetainAll() { + XMLDocument doc = loadDocFromString("<catalog2><product2/><product2/></catalog2>"); + List listTest = createTestObj(doc); + assertNotNull(listTest); + assertEquals(2, listTest.size()); + + DataObject do1 = (DataObject)listTest.get(1); + assertNotNull(do1); + + ArrayList arraylist1 = new ArrayList(); + arraylist1.add(do1); + + boolean bRes = listTest.retainAll(arraylist1); + + assertTrue(bRes); + assertEquals(1, listTest.size()); + } + + public void testIterator() { + XMLDocument doc = loadDocFromString("<catalog2><product2/><product2/></catalog2>"); + List listTest = createTestObj(doc); + assertNotNull(listTest); + assertEquals(2, listTest.size()); + + Iterator iterRes = listTest.iterator(); + + assertNotNull(iterRes); + DataObject doRes = (DataObject)iterRes.next(); + assertNotNull(doRes); + } + + public void testSubList() { + XMLDocument doc = loadDocFromString("<catalog2><product2/><product2/><product2/></catalog2>"); + List listTest = createTestObj(doc); + assertNotNull(listTest); + assertEquals(3, listTest.size()); + + List listRes = listTest.subList(0, 1); + + assertNotNull(listRes); + assertEquals("listTest.subList(0,1)", 1, listRes.size()); + DataObject doRes = (DataObject)listRes.get(0); + assertNotNull(doRes); + } + + public void testListIterator() { + XMLDocument doc = loadDocFromString("<catalog2><product2/><product2/></catalog2>"); + List listTest = createTestObj(doc); + assertNotNull(listTest); + assertEquals(2, listTest.size()); + + ListIterator iterRes = listTest.listIterator(); + + assertNotNull(iterRes); + DataObject doRes = (DataObject)iterRes.next(); + assertNotNull(doRes); + } + + public void testListIteratorIndex() { + XMLDocument doc = loadDocFromString("<catalog2><product2/><product2/></catalog2>"); + List listTest = createTestObj(doc); + assertNotNull(listTest); + assertEquals(2, listTest.size()); + + ListIterator iterRes = listTest.listIterator(0); + + assertNotNull(iterRes); + DataObject doRes = (DataObject)iterRes.next(); + assertNotNull(doRes); + } + + public void testSetIndexObject() { + XMLDocument doc = + loadDocFromString("<catalog2><product2 name=\"aname1\"/><product2 name=\"aname2\"/></catalog2>"); + List listTest = createTestObj(doc); + assertNotNull(listTest); + assertEquals(2, listTest.size()); + + DataObject doTest = DataFactory.INSTANCE.create("", "product2"); + assertNotNull(doTest); + doTest.setString("name", "aname3"); + + Object objRes = listTest.set(0, doTest); + + assertNotNull(objRes); + assertTrue(objRes instanceof DataObject); + } + + public void testToArrayObject() { + XMLDocument doc = + loadDocFromString("<catalog2><product2 name=\"aname1\"/><product2 name=\"aname2\"/></catalog2>"); + List listTest = createTestObj(doc); + assertNotNull(listTest); + assertEquals(2, listTest.size()); + + DataObject do1 = (DataObject)listTest.get(1); + assertNotNull(do1); + + ArrayList arraylist2 = new ArrayList(); + + Object[] objRes = listTest.toArray(arraylist2.toArray()); + + assertNotNull(objRes); + assertEquals(2, objRes.length); + } + + public void testToString() { + XMLDocument doc = + loadDocFromString("<catalog2><product2 name=\"aname1\"/><product2 name=\"aname2\"/></catalog2>"); + List listTest = createTestObj(doc); + assertNotNull(listTest); + assertEquals(2, listTest.size()); + + String strRes = listTest.toString(); + + assertNotNull(strRes); + assertTrue(strRes.length() > 0); + // assertEquals("List: [DataObjectImpl[ <sss> ]]",strRes); + } + +} |