path: root/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/scenarios/DataObjectListTest.java

/*
 *  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);
    }

}