tuscany-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From gw...@apache.org
Subject svn commit: r501803 [2/5] - in /incubator/tuscany/java/cts/sdo2.1/src/main: java/test/sdo21/ java/test/sdo21/framework/ java/test/sdo21/paramatizedTests/ java/test/sdo21/paramatizedTests/api/ java/test/sdo21/paramatizedTests/conversion/ java/test/sdo21...
Date Wed, 31 Jan 2007 11:18:48 GMT
Added: incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/api/TypeHelperTest.java
URL: http://svn.apache.org/viewvc/incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/api/TypeHelperTest.java?view=auto&rev=501803
==============================================================================
--- incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/api/TypeHelperTest.java (added)
+++ incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/api/TypeHelperTest.java Wed Jan 31 03:18:45 2007
@@ -0,0 +1,237 @@
+/*
+ *  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.paramatizedTests.api;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+import test.sdo21.CTSSuite;
+import test.sdo21.paramatizedTests.BaseSDOParamatizedTest;
+import test.sdo21.paramatizedTests.util.ParamatizedTestUtil;
+
+import commonj.sdo.DataObject;
+import commonj.sdo.Type;
+import commonj.sdo.helper.TypeHelper;
+import commonj.sdo.impl.HelperProvider;
+
+/**
+ * Junit 4.1 test case. Tests TypeHelper API
+ * 
+ */
+@RunWith(Parameterized.class)
+public class TypeHelperTest extends BaseSDOParamatizedTest {
+
+    public TypeHelperTest(DataObject testDO, String description) {
+        super(testDO, description);
+    }
+
+    /**
+     * testTypeHelperAPI tests the methods in the TypeHelper API
+     */
+    @Test
+    public void testTypeHelperAPI() {
+        Type testType = testDO.getType();
+
+        TypeHelper types = HelperProvider.getTypeHelper();
+        Type stringType = types.getType("commonj.sdo", "String");
+        Type intType = types.getType("commonj.sdo", "Int");
+        boolean errorCaught;
+
+        /**
+         * Verify the performance of TypeHelper.getType(URI, Name) and
+         * TypeHelper.getType(Class)
+         */
+
+        Type returnedType = types.getType(testType.getURI(), testType.getName());
+
+        assertTrue("TypeHelper.getType(URI, Name) did not return the expected Type.", ParamatizedTestUtil
+            .areEqualTypes(returnedType, testType));
+        // TODO: should there be an else clause here ?
+        if (testType.getInstanceClass() != null) {
+            returnedType = types.getType(testType.getInstanceClass());
+            assertTrue("TypeHelper.getType(Class) did not return the expected Type.", ParamatizedTestUtil
+                .areEqualTypes(returnedType, testType));
+        }
+
+        /**
+         * Verify the proper performance of TypeHelper.getType(Class) when a
+         * non-SDO class is passed to TypeHelper.getType(Class)
+         */
+        assertNull("Types.getType(Class) should return null when no Type was defined for the interface Class.", types
+            .getType(TypeHelperTest.class));
+
+        /**
+         * Verify the proper performance of TypeHelper.getClass(URI, Name) when
+         * the namespace for URI does not include Name
+         */
+        assertNull("Types.getType(URI, Name) should return null when no Type has the indicated Name in the URI namespace.",
+                   types.getType(testDO.getType().getURI(), "UndefinedName"));
+
+        /**
+         * Verify the proper performance of TypeHelper.getClass(URI, Name) when
+         * the Name exists but not in the namespace of the URI
+         */
+
+        assertNull("Types.getType(URI, Name) should return null when no Type has the indicated Name in the URI namespace.",
+                   types.getType("UndefinedURI", testDO.getType().getName()));
+
+        /**
+         * Verify the performance of TypeHelper.define(DataObject)
+         */
+
+        DataObject defineTypeDO = CTSSuite.getTestHelper().getDataFactory().create("commonj.sdo", "Type");
+        defineTypeDO.set("uri", ParamatizedTestUtil.TEST_NAMESPACE);
+        defineTypeDO.set("name", "DefinedType");
+        DataObject IDProperty = defineTypeDO.createDataObject("property");
+        IDProperty.set("name", "ID");
+        IDProperty.set("type", stringType);
+        Type definedType = types.define(defineTypeDO);
+
+        /**
+         * Attempt to create an instance of the newly defined Type.
+         */
+
+        DataObject result = CTSSuite.getTestHelper().getDataFactory().create(ParamatizedTestUtil.TEST_NAMESPACE, defineTypeDO.getString("name"));
+        assertNotNull("CTSSuite.getTestHelper().getDataFactory() returned null", result);
+        assertEquals("CTSSuite.getTestHelper().getDataFactory()e did not create a Type that could be instantiated.", result.getType()
+            .getName(), "DefinedType");
+        assertNotNull("CTSSuite.getTestHelper().getDataFactory() did not create a Type that could be instantiated, getProperty(ID) was null",
+                      result.getProperty("ID"));
+
+        result = CTSSuite.getTestHelper().getDataFactory().create(definedType);
+        assertNotNull("TypeHelper.define(DataObject) returned null", result);
+        assertEquals("TypeHelper.define(DataObject) did not create a Type that could be instantiated.", result
+            .getType().getName(), "DefinedType");
+        assertNotNull("TypeHelper.define(DataObject) did not create a Type that could be instantiated, getProperty(ID) was null",
+                      result.getProperty("ID"));
+
+        /**
+         * Verify the performance of TypeHelper.define(List)
+         */
+
+        DataObject define1 = CTSSuite.getTestHelper().getDataFactory().create("commonj.sdo", "Type");
+        define1.set("uri", ParamatizedTestUtil.TEST_NAMESPACE);
+        define1.set("name", "Define1Type");
+        DataObject firstNameProperty = define1.createDataObject("property");
+        firstNameProperty.set("name", "firstName");
+        firstNameProperty.set("type", stringType);
+
+        DataObject define2 = CTSSuite.getTestHelper().getDataFactory().create("commonj.sdo", "Type");
+        define2.set("uri", ParamatizedTestUtil.TEST_NAMESPACE);
+        define2.set("name", "Define2Type");
+        DataObject lastNameProperty = define2.createDataObject("property");
+        lastNameProperty.set("name", "lastName");
+        lastNameProperty.set("type", stringType);
+
+        List DOList = new ArrayList();
+        DOList.add(define1);
+        DOList.add(define2);
+
+        types.define(DOList);
+
+        result = CTSSuite.getTestHelper().getDataFactory().create(ParamatizedTestUtil.TEST_NAMESPACE, define1.getString("name"));
+        assertNotNull("TypeHelper.define(List) did not create a Type that could be instantiated.  result is null.",
+                      result);
+        assertEquals("TypeHelper.define(List) did not create a Type that could be instantiated.  getType() incorrect",
+                     result.getType().getName(),
+                     "Define1Type");
+        assertNotNull("TypeHelper.define(List) did not create a Type that could be instantiated.  firstName property returned null",
+                      result.getProperty("firstName"));
+
+        result = CTSSuite.getTestHelper().getDataFactory().create(ParamatizedTestUtil.TEST_NAMESPACE, define2.getString("name"));
+
+        assertNotNull("TypeHelper.define(List) did not create a Type that could be instantiated.  result is null.",
+                      result);
+        assertEquals("TypeHelper.define(List) did not create a Type that could be instantiated.  getType() incorrect",
+                     result.getType().getName(),
+                     "Define2Type");
+        assertNotNull("TypeHelper.define(List) did not create a Type that could be instantiated.  lastName property returned null",
+                      result.getProperty("lastName"));
+
+        // TODO: Determine what should happen when a Type is redefined (same URI
+        // & Name, but different properties).
+        // When this is known, uncomment the following and supply the
+        // appropriate test.
+        // While it's not clear to what should happen (from the spec), what is
+        // happening is that there is no
+        // notification of the duplication, and the originally defined Type is
+        // returned by the define() in the latter instance.
+
+        /*
+         * DataObject define3 = CTSSuite.getTestHelper().getDataFactory().create("commonj.sdo",
+         * "Type"); define3.set("uri", ParamatizedTestUtil.TEST_NAMESPACE);
+         * define3.set("name", "Define2Type"); DataObject numProperty =
+         * define3.createDataObject("property"); numProperty.set("name", "num");
+         * numProperty.set("type",intType); definedType = types.define(define3);
+         */
+
+        /**
+         * Attempt TypeHelper.define(List) when a member of the List is not a
+         * DataObject.
+         */
+
+        DataObject define4 = CTSSuite.getTestHelper().getDataFactory().create("commonj.sdo", "Type");
+        define4.set("uri", ParamatizedTestUtil.TEST_NAMESPACE);
+        define4.set("name", "Define4Type");
+        DataObject ID1Property = define4.createDataObject("property");
+        ID1Property.set("name", "ID1");
+        ID1Property.set("type", intType);
+
+        DataObject define5 = CTSSuite.getTestHelper().getDataFactory().create("commonj.sdo", "Type");
+        define5.set("uri", ParamatizedTestUtil.TEST_NAMESPACE);
+        define5.set("name", "Define5Type");
+        DataObject ID2Property = define5.createDataObject("property");
+        ID2Property.set("name", "ID2");
+        ID2Property.set("type", intType);
+
+        DOList.clear();
+        DOList.add(define4);
+        DOList.add("A");
+        DOList.add(define5);
+
+        try {
+            errorCaught = false;
+            types.define(DOList);
+        } catch (Exception e) {
+            errorCaught = true;
+        }
+        assertTrue("TypeHelper.define(List) should throw an Exception when the List contains a member " + "that is not a DataObject",
+                   errorCaught);
+
+        // TODO: Determine whether the other members of the list (particularly
+        // those preceeding the non DataObject) should
+        // now be defined Types. Not clear in the spec what should happen. What
+        // currently happens is that those members
+        // before the Exception are defined, but those after (in the List) are
+        // not. Because of the Exception, there is no
+        // return value from define(List). This would require some involved
+        // error-case checking by the user to recover from.
+    }
+}

Propchange: incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/api/TypeHelperTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/api/TypeHelperTest.java
------------------------------------------------------------------------------
    svn:keywords = Rev Date

Added: incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/api/TypeTest.java
URL: http://svn.apache.org/viewvc/incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/api/TypeTest.java?view=auto&rev=501803
==============================================================================
--- incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/api/TypeTest.java (added)
+++ incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/api/TypeTest.java Wed Jan 31 03:18:45 2007
@@ -0,0 +1,241 @@
+/*
+ *  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.paramatizedTests.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.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+import test.sdo21.CTSSuite;
+import test.sdo21.paramatizedTests.BaseSDOParamatizedTest;
+import test.sdo21.paramatizedTests.util.ParamatizedTestUtil;
+
+import commonj.sdo.DataObject;
+import commonj.sdo.Property;
+import commonj.sdo.Type;
+
+/**
+ * Junit 4.1 test case. Tests Type API
+ * 
+ */
+@RunWith(Parameterized.class)
+public class TypeTest extends BaseSDOParamatizedTest {
+
+    public TypeTest(DataObject testDO, String description) {
+        super(testDO, description);
+    }
+
+    /**
+     * testTypeAPI is used to test the methods of the Type object their return
+     * values.
+     * 
+     * @param testDO
+     * @throws ReturnValueError
+     */
+    @Test
+    public void testTypeAPI() {
+        Type type = testDO.getType();
+        Type booleanType = testDO.getProperty("booleanVal").getType();
+        Type sequencedType = testDO.getProperty("sequencedElem").getType();
+        Type abstractType = CTSSuite.getTestHelper().getTypeHelper().getType(ParamatizedTestUtil.TEST_NAMESPACE, "Abstract");
+        Class instanceClass;
+
+        /**
+         * Verify the accuracy of Type.getName() and Type.getURI()
+         */
+
+        assertEquals("Type.getName() returned an unexpected value.", type.getName(), ParamatizedTestUtil.TEST_TYPE);
+        assertEquals("Type.getURI() returned an unexpected value.", type.getURI(), ParamatizedTestUtil.TEST_NAMESPACE);
+
+        /**
+         * Verify the accuracy of Type.getInstanceClass(). For the dynamic cases
+         * it will return null. For the static case it will return
+         * test.sdo21.generated.staticSdo.APITest.
+         */
+
+        instanceClass = type.getInstanceClass();
+        if (instanceClass != null) {
+            assertEquals("Type.getInstanceClass() did not return the instance class with the expected name.",
+                         "test.sdo21.vendorSpecific.tuscany.generated.staticSdo.api.APITest", instanceClass.getName());
+        }
+        /**
+         * Verify Type.isInstance() == true and == false
+         */
+        assertFalse("Type.getInstance() returned an unexpected value.", type.isInstance(booleanType));
+        assertTrue("Type.getInstance() returned an unexpected value.", type.isInstance(testDO));
+        /**
+         * Verify Type.isDataType() == true and == false
+         */
+        assertFalse("Type.isDataType() returned an unexpected value.", type.isDataType());
+        assertTrue("Type.isDataType() returned an unexpected value.", booleanType.isDataType());
+
+        /**
+         * Verify Type.isSequenced() == true and == false
+         */
+        assertFalse("Type.isSequenced() returned an unexpected value.", type.isSequenced());
+        assertTrue("Type.isSequenced() returned an unexpected value.", sequencedType.isSequenced());
+
+        /**
+         * Verify Type.isOpen() == true and == false
+         */
+        // TODO Verify isOpen == true
+        assertFalse("Type.isOpen() returned an unexpected value.", type.isOpen());
+
+        /**
+         * Verify Type.isAbstract() == true and == false
+         */
+        assertFalse("Type.isAbstract() returned an unexpected value.", type.isAbstract());
+        assertTrue("Type.isAbstract() returned an unexpected value.", abstractType.isAbstract());
+
+        /**
+         * Verify Type.getBaseTypes() for empty and nonempty Lists of BaseTypes.
+         */
+        assertEquals("Type.getBaseTypes() returned a List of unexpected size.", type.getBaseTypes().size(), 0);
+        assertNotSame("Type.getBaseTypes() did not return the expected base type.",
+                      sequencedType.getBaseTypes().size(),
+                      0);
+
+        /**
+         * Verify Type.getAliasNames for empty and nonempty Lists of alias
+         * names.
+         */
+        assertEquals("Type.getAliasNames() returned a List of unexpected size.", type.getAliasNames().size(), 0);
+
+        // TODO: Uncomment the following when SDOUtil.addAliasName is
+        // implemented
+        /*
+         * aliases = sequencedType.getAliasNames(); if (aliases.size() != 1)
+         * throw new ReturnValueError("Type.getAliasNames() returned a List of
+         * unexpected size.", Integer.valueOf(1),
+         * Integer.valueOf(aliases.size())); else if
+         * (aliases.get(1).equals("Seq2")) throw new
+         * ReturnValueError("Type.getAliasNames() returned a List with
+         * unexpected contents.", "Seq2", aliases.get(0));;
+         */
+
+        /**
+         * Verify the Lists returned by Type.getProperties() and
+         * Type.getDeclaredProperties()
+         */
+        assertTrue("Type.getProperties() did not return the expected List.", verifyPropertyList(type.getProperties()));
+        assertTrue("Type.getProperties() did not return the expected List.", verifyPropertyList(type
+            .getDeclaredProperties()));
+
+        /**
+         * Verify the accuracy of Type.getProperty()
+         */
+        assertEquals("Type.getProperty() returned an unexpected Property.",
+                     type.getProperty("booleanVal").getName(),
+                     "booleanVal");
+
+        /**
+         * Verify the handling of an inaccurate name by Type.getProperty()
+         */
+        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 childrenFound = 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 (!childrenFound && currProperty.getName().equals("children"))
+                childrenFound = 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
+            && childrenFound
+            && bytesValFound
+            && integerValFound
+            && charValFound
+            && sequencedElemFound)
+            return true;
+        else
+            return false;
+    }
+}

Propchange: incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/api/TypeTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/api/TypeTest.java
------------------------------------------------------------------------------
    svn:keywords = Rev Date

Added: incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/api/XMLHelperTest.java
URL: http://svn.apache.org/viewvc/incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/api/XMLHelperTest.java?view=auto&rev=501803
==============================================================================
--- incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/api/XMLHelperTest.java (added)
+++ incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/api/XMLHelperTest.java Wed Jan 31 03:18:45 2007
@@ -0,0 +1,84 @@
+/*
+ *  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.paramatizedTests.api;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+import test.sdo21.CTSSuite;
+import test.sdo21.paramatizedTests.BaseSDOParamatizedTest;
+import test.sdo21.paramatizedTests.util.ParamatizedTestUtil;
+
+import commonj.sdo.DataObject;
+
+/**
+ * Junit 4.1 test case. Tests XMLHelper methods.
+ * 
+ */
+@RunWith(Parameterized.class)
+public class XMLHelperTest extends BaseSDOParamatizedTest {
+
+    public XMLHelperTest(DataObject testDO, String description) {
+        super(testDO, description);
+    }
+
+    /**
+     * Serialize the DataObject then Deserialize the output. Result should be
+     * equivalent to testDO.
+     */
+    @Test
+    public void testSerializeDeserialize() {
+        try {
+            ParamatizedTestUtil.populateFields(testDO);
+            ParamatizedTestUtil.serializeDataObject(testDO, "temporaryFile");
+            DataObject tempDO = ParamatizedTestUtil.deserializeDataObject("temporaryFile");
+
+            // TODO: Remove the unsets and return equalShallow to equal when
+            // CMVC defect 404384 is resolved.
+            // NOTE: The temporary masks (unset and equal->equalShallow) seem
+            // only to work for the dynamic case.
+
+            tempDO.unset("bytesVal");
+            testDO.unset("bytesVal");
+
+            assertTrue("Serialization and deserialization resulted in a nonequivalent DataObject.",
+                       CTSSuite.getTestHelper().getEqualityHelper().equalShallow(testDO, tempDO));
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("unexpected exception serializing xml " + e.toString());
+        }
+    }
+
+    /**
+     * Verifies that appropriate exception is thrown when an
+     * invalid XML document is specified. It will also test the condition that
+     * an XML document is in itself valid, but does not comply with the XSD.<br>
+     * (To be implemented)
+     */
+    @org.junit.Ignore
+    public static void testFaultyXML(DataObject testDO) {
+        // TODO: complete
+    }
+}

Propchange: incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/api/XMLHelperTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/api/XMLHelperTest.java
------------------------------------------------------------------------------
    svn:keywords = Rev Date

Added: incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/api/package.html
URL: http://svn.apache.org/viewvc/incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/api/package.html?view=auto&rev=501803
==============================================================================
--- incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/api/package.html (added)
+++ incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/api/package.html Wed Jan 31 03:18:45 2007
@@ -0,0 +1,25 @@
+<html>
+<!--
+  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$
+-->
+<body>
+Contains paramatized test cases for API test.
+</body>
+</html>

Propchange: incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/api/package.html
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/api/package.html
------------------------------------------------------------------------------
    svn:keywords = Rev Date

Propchange: incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/api/package.html
------------------------------------------------------------------------------
    svn:mime-type = text/html

Added: incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/conversion/TypeConversionTest.java
URL: http://svn.apache.org/viewvc/incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/conversion/TypeConversionTest.java?view=auto&rev=501803
==============================================================================
--- incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/conversion/TypeConversionTest.java (added)
+++ incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/conversion/TypeConversionTest.java Wed Jan 31 03:18:45 2007
@@ -0,0 +1,1289 @@
+/*
+ *  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.paramatizedTests.conversion;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+import java.lang.reflect.Method;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.text.SimpleDateFormat;
+import java.util.Comparator;
+import java.util.Date;
+import java.util.List;
+import java.util.TimeZone;
+
+import org.junit.Before;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+import test.sdo21.paramatizedTests.BaseSDOParamatizedTest;
+
+import commonj.sdo.DataObject;
+import commonj.sdo.Property;
+import commonj.sdo.Type;
+
+/**
+ * Junit 4.1 test case. Tests that each of the permitted Type conversions
+ * performs properly.
+ * 
+ */
+
+@RunWith(Parameterized.class)
+public class TypeConversionTest extends BaseSDOParamatizedTest {
+
+    public TypeConversionTest(DataObject testDO, String description) {
+        super(testDO, description);
+    }
+
+    // The following constants describe the index for the fields in
+    // api_test.xsd.
+
+    private static int STRING_VAL_INDEX;
+
+    private static int BOOLEAN_VAL_INDEX;
+
+    private static int BYTE_VAL_INDEX;
+
+    private static int DECIMAL_VAL_INDEX;
+
+    private static int INT_VAL_INDEX;
+
+    private static int FLOAT_VAL_INDEX;
+
+    private static int DOUBLE_VAL_INDEX;
+
+    private static int DATE_VAL_INDEX;
+
+    private static int SHORT_VAL_INDEX;
+
+    private static int LONG_VAL_INDEX;
+
+    private static int BYTES_VAL_INDEX;
+
+    private static int INTEGER_VAL_INDEX;
+
+    private static int CHAR_VAL_INDEX;
+
+    // TODO: these properties are not used . . . should they be ?
+    private static Property STRING_VAL_PROP;
+
+    private static Property BOOLEAN_VAL_PROP;
+
+    private static Property BYTE_VAL_PROP;
+
+    private static Property DECIMAL_VAL_PROP;
+
+    private static Property INT_VAL_PROP;
+
+    private static Property FLOAT_VAL_PROP;
+
+    private static Property DOUBLE_VAL_PROP;
+
+    private static Property DATE_VAL_PROP;
+
+    private static Property SHORT_VAL_PROP;
+
+    private static Property LONG_VAL_PROP;
+
+    private static Property BYTES_VAL_PROP;
+
+    private static Property INTEGER_VAL_PROP;
+
+    private static Property CHAR_VAL_PROP;
+
+    // The following variables are Method arrays. Each array refers to a
+    // specific get<Type>, but within
+    // the array exist the get<Type>(index), get<Type>(property), and
+    // get<Type>(path). Rather than
+    // referring to each of the three in every circumstance, the more compact
+    // array appears.
+
+    private static ConversionType TO_BOOLEAN = new ConversionType("getBoolean");
+
+    private static ConversionType TO_BYTE = new ConversionType("getByte");
+
+    private static ConversionType TO_CHAR = new ConversionType("getChar");
+
+    private static ConversionType TO_DOUBLE = new ConversionType("getDouble");
+
+    private static ConversionType TO_FLOAT = new ConversionType("getFloat");
+
+    private static ConversionType TO_INT = new ConversionType("getInt");
+
+    private static ConversionType TO_LONG = new ConversionType("getLong");
+
+    private static ConversionType TO_SHORT = new ConversionType("getShort");
+
+    private static ConversionType TO_BYTES = new ConversionType("getBytes");
+
+    private static ConversionType TO_BIGDECIMAL = new ConversionType("getBigDecimal");
+
+    private static ConversionType TO_BIGINTEGER = new ConversionType("getBigInteger");
+
+    private static ConversionType TO_DATAOBJECT = new ConversionType("getDataObject");
+
+    private static ConversionType TO_DATE = new ConversionType("getDate");
+
+    private static ConversionType TO_STRING = new ConversionType("getString");
+
+    private static ConversionType TO_LIST = new ConversionType("getList");
+
+    private static ConversionType TO_SEQUENCE = new ConversionType("getSequence");
+
+    private static GeneralComparator COMPARE_ANY;
+
+    // There will be several instances where a Property must be passed as a
+    // parameter. Have available the Type
+    // to call getProperty() as needed.
+
+    private static Type API_TEST_TYPE;
+
+    /**
+     * Sets up indices for various property types
+     */
+    @Before
+    public void setPropertyTypeIndices() {
+        COMPARE_ANY = new GeneralComparator();
+        API_TEST_TYPE = testDO.getType();
+
+        List properties = API_TEST_TYPE.getProperties();
+        Property property;
+        String name;
+
+        for (int i = 0; i < properties.size(); i++) {
+            property = (Property)properties.get(i);
+            name = property.getName();
+
+            if (name.equals("booleanVal")) {
+                BOOLEAN_VAL_INDEX = i;
+                BOOLEAN_VAL_PROP = property;
+            } else if (name.equals("stringVal")) {
+                STRING_VAL_INDEX = i;
+                STRING_VAL_PROP = property;
+            } else if (name.equals("byteVal")) {
+                BYTE_VAL_INDEX = i;
+                BYTE_VAL_PROP = property;
+            } else if (name.equals("decimalVal")) {
+                DECIMAL_VAL_INDEX = i;
+                DECIMAL_VAL_PROP = property;
+            } else if (name.equals("intVal")) {
+                INT_VAL_INDEX = i;
+                INT_VAL_PROP = property;
+            } else if (name.equals("floatVal")) {
+                FLOAT_VAL_INDEX = i;
+                FLOAT_VAL_PROP = property;
+            } else if (name.equals("doubleVal")) {
+                DOUBLE_VAL_INDEX = i;
+                DOUBLE_VAL_PROP = property;
+            } else if (name.equals("dateVal")) {
+                DATE_VAL_INDEX = i;
+                DATE_VAL_PROP = property;
+            } else if (name.equals("shortVal")) {
+                SHORT_VAL_INDEX = i;
+                SHORT_VAL_PROP = property;
+            } else if (name.equals("longVal")) {
+                LONG_VAL_INDEX = i;
+                LONG_VAL_PROP = property;
+            } else if (name.equals("bytesVal")) {
+                BYTES_VAL_INDEX = i;
+                BYTES_VAL_PROP = property;
+            } else if (name.equals("integerVal")) {
+                INTEGER_VAL_INDEX = i;
+                INTEGER_VAL_PROP = property;
+            } else if (name.equals("charVal")) {
+                CHAR_VAL_INDEX = i;
+                CHAR_VAL_PROP = property;
+            }
+        }
+    }
+
+    private static class ConversionType {
+        // The following constants are used because the getMethod function
+        // requires an Class
+        // array describing the parameters to the functions.
+
+        private static final Class[] INT_CLASS_ARRAY = {int.class};
+
+        private static final Class[] PROPERTY_CLASS_ARRAY = {Property.class};
+
+        private static final Class[] STRING_CLASS_ARRAY = {String.class};
+
+        Method index_method;
+
+        Method property_method;
+
+        Method path_method;
+
+        public ConversionType(String method_name) {
+            try {
+                this.index_method = DataObject.class.getMethod(method_name, INT_CLASS_ARRAY);
+                this.property_method = DataObject.class.getMethod(method_name, PROPERTY_CLASS_ARRAY);
+                this.path_method = DataObject.class.getMethod(method_name, STRING_CLASS_ARRAY);
+            } catch (NoSuchMethodException e) {
+                this.index_method = null;
+                this.property_method = null;
+                this.path_method = null;
+            }
+        }
+
+        public Method getIndexMethod() {
+            return this.index_method;
+        }
+
+        public Method getPropertyMethod() {
+            return this.property_method;
+        }
+
+        public Method getPathMethod() {
+            return this.path_method;
+        }
+    }
+
+    // Each instance of Test describes a convert-from type. The index, property
+    // and path parms
+    // will refer to the same field, which is a field of the convert-from type.
+
+    private static class Test {
+        Object[] index_parm;
+
+        Object[] property_parm;
+
+        Object[] path_parm;
+
+        Object expected_value;
+
+        String from_type;
+
+        // The constructor prepares a test DataObject and determines how to
+        // access the field
+        // in three different ways - index, property, and path.
+
+        Test(String path, int index) {
+            this.index_parm = new Object[] {new Integer(index)};
+            this.property_parm = new Object[] {API_TEST_TYPE.getProperty(path)};
+            this.path_parm = new Object[] {path};
+            this.expected_value = null;
+        }
+
+        /**
+         * initialize() is a private method that establishes the initial value
+         * of the test field.
+         * 
+         * @return
+         */
+
+        private void initialize(Class type, String type_name, Object initial_value, DataObject testDO) {
+            try {
+                Class[] classArray = {int.class, type};
+                Object[] initValueArray = new Object[] {this.index_parm[0], initial_value};
+
+                Method setter = DataObject.class.getMethod("set" + type_name, classArray);
+                setter.invoke(testDO, initValueArray);
+
+                this.expected_value = initial_value;
+                this.from_type = type_name;
+            } catch (Exception e) {
+                e.printStackTrace();
+                fail("Exception using reflection to establish initial value for test : " + e.toString());
+            }
+        }
+
+        /**
+         * checkConversionException verifies that for a particular to and from
+         * Type pairing, the expected Exceptoin is thrown.
+         * 
+         * @param to_type
+         * @param expected_exception
+         * @param testDO
+         */
+
+        private void checkConversionException(ConversionType to_type, Class expected_exception, DataObject testDO) {
+            try {
+                boolean index_err, path_err, property_err, consistency_err = false;
+
+                index_err = executeExceptionCase(to_type.getIndexMethod(), this.index_parm, expected_exception, testDO);
+                path_err = executeExceptionCase(to_type.getPathMethod(), this.path_parm, expected_exception, testDO);
+                property_err =
+                    executeExceptionCase(to_type.getPropertyMethod(), this.property_parm, expected_exception, testDO);
+
+                assertEquals("Testing that expected exception for index paramater is equal to path paramater exception ",
+                             index_err,
+                             path_err);
+                assertEquals("Testing that expected exception for path paramater is equal to property paramater exception ",
+                             property_err,
+                             path_err);
+
+                // TODO: test case needs reworking
+                /*
+                 * else if (index_err == false) attemptConversion(to_type,
+                 * testDO);
+                 */
+                if (!index_err) {
+                    attemptConversion(to_type, testDO);
+                }
+
+                // TODO: test for unexpected consistency
+                /*
+                 * if (consistency_err) throw new ExpectedConditionError("An
+                 * exception inconsistency exists for " +
+                 * to_type.getPathMethod().getName() + " when called " + "for a " +
+                 * this.from_type + " property.");
+                 */
+            } catch (Exception e) {
+                e.printStackTrace();
+                fail("exception caught : " + e.toString());
+            }
+        }
+
+        /**
+         * attemptConversion is a private method that attempts the conversion to
+         * the specified type, using DataObject.get____(). The get___() function
+         * can be called with an index, path, and property. attemptConversion()
+         * calls each of those three.
+         * 
+         * @param to_type
+         * @param testDO
+         */
+
+        private void attemptConversion(ConversionType to_type, DataObject testDO) {
+
+            try {
+                performConversion(to_type.getIndexMethod(), this.index_parm, testDO);
+                performConversion(to_type.getPathMethod(), this.path_parm, testDO);
+                performConversion(to_type.getPropertyMethod(), this.property_parm, testDO);
+            } catch (Exception e) {
+                e.printStackTrace();
+                fail("Exception caught invoking attemptConversion for " + to_type + " : " + e.toString());
+            }
+        }
+
+        /**
+         * performConversion is a private method that is called by
+         * attemptConversion for each of the Property identification mechanisms.
+         * (Property, index, or name.)
+         * 
+         * @param convert
+         * @param parm
+         * @param testDO
+         */
+
+        private void performConversion(Method convert, Object[] parm, DataObject testDO) throws Exception {
+
+            assertEquals("Conversion did not yield expected value for " + convert.getName()
+                + " on a "
+                + this.from_type
+                + " property.", COMPARE_ANY.compare(convert.invoke(testDO, parm), this.expected_value), 0);
+        }
+
+        /**
+         * executeExceptionCase is a private method that insures a particular to
+         * and from Type pairing will throw the expected Exception when an a
+         * conversion is attempted using get____(<x>). executeExceptionCase is
+         * called by checkConversionException for each mechanism of identifying
+         * the Property. (Property, name, or index.)
+         * 
+         * @param convert
+         * @param parm
+         * @param expected_exception
+         * @param testDO
+         * @return whether or not the expected exception was thrown and caught
+         */
+        private boolean executeExceptionCase(Method convert, Object[] parm, Class expected_exception, DataObject testDO) {
+            boolean exception_thrown = false;
+            try {
+                convert.invoke(testDO, parm);
+            } catch (Exception e) {
+
+                exception_thrown = true;
+                Throwable cause = e.getCause();
+                if (cause == null) {
+                    assertEquals("An unexpected exception occurred while performing " + convert.getName()
+                        + " on a "
+                        + this.from_type
+                        + " property.", expected_exception, e.getClass());
+                } else {
+                    assertEquals("An unexpected exception occurred while performing " + convert.getName()
+                        + " on a "
+                        + this.from_type
+                        + " property.", expected_exception, cause.getClass());
+                }
+            }
+
+            return exception_thrown;
+        }
+    }
+
+    private static class GeneralComparator implements Comparator {
+        /**
+         * The compare method fo the GeneralComparator class is used to compare
+         * two of any Types between which a covnersion is permitted in SDO.
+         */
+
+        public int compare(Object obj1, Object obj2) {
+            if (obj1.getClass() == obj2.getClass()) {
+                if (obj1.equals(obj2))
+                    return 0;
+                else
+                    return 1;
+            }
+
+            else if (obj1.getClass() == Date.class) {
+                if (obj2.getClass() == String.class) {
+                    try {
+                        SimpleDateFormat sdf = new SimpleDateFormat("yyyy'-'MM'-'dd'T'H':'mm':'ss.S");
+
+                        sdf.setTimeZone(TimeZone.getTimeZone("UTC"));
+                        obj2 = sdf.parse((String)obj2);
+
+                        if (obj1.equals(obj2))
+                            return 0;
+                    } catch (Exception e) {
+                        System.out.println(e.getMessage());
+                    }
+
+                    return 1;
+                }
+
+                else {
+                    Date temp = (Date)obj1;
+
+                    return compare(new Long(temp.getTime()), obj2);
+                }
+
+            }
+
+            else if (obj2.getClass() == Date.class) {
+                return compare(obj2, obj1);
+            }
+
+            else if (obj1.getClass() == Boolean.class) {
+                Boolean temp = (Boolean)obj1;
+
+                if (temp.booleanValue()) {
+                    if (obj2.toString().equalsIgnoreCase("true"))
+                        return 0;
+                    else
+                        return 1;
+                }
+
+                else {
+                    if (obj2.toString().equalsIgnoreCase("true"))
+                        return 1;
+                    else
+                        return 0;
+                }
+            }
+
+            else if (obj2.getClass() == Boolean.class)
+                return compare(obj2, obj1);
+
+            else if (obj1.getClass() == Byte.class || obj2.getClass() == Byte.class) {
+                byte b1 = (Double.valueOf(obj1.toString())).byteValue();
+                byte b2 = (Double.valueOf(obj2.toString())).byteValue();
+
+                if (b1 == b2)
+                    return 0;
+                else if (b1 < b2)
+                    return -1;
+                else
+                    return 1;
+            }
+
+            else if (obj1.getClass().toString().charAt(6) == '[') {
+                long result = 0;
+                long multiplier = 1;
+
+                byte[] array = (byte[])obj1;
+                for (int i = 0; i < array.length; i++) {
+                    result += array[array.length - i - 1] * multiplier;
+                    multiplier *= 256;
+                }
+
+                return compare(obj2, new Long(result));
+            }
+
+            else if (obj2.getClass().toString().charAt(6) == '[') {
+                return compare(obj2, obj1);
+            }
+
+            else if (obj1.getClass() == Short.class || obj2.getClass() == Short.class) {
+                short s1 = (Double.valueOf(obj1.toString())).shortValue();
+                short s2 = (Double.valueOf(obj2.toString())).shortValue();
+
+                if (s1 == s2)
+                    return 0;
+                else if (s1 < s2)
+                    return -1;
+                else
+                    return 1;
+            }
+
+            else if (obj1.getClass() == Integer.class || obj2.getClass() == Integer.class) {
+                int i1 = (Double.valueOf(obj1.toString())).intValue();
+                int i2 = (Double.valueOf(obj2.toString())).intValue();
+
+                if (i1 == i2)
+                    return 0;
+                else if (i1 < i2)
+                    return -1;
+                else
+                    return 1;
+            }
+
+            else if (obj1.getClass() == Long.class || obj2.getClass() == Long.class
+                || obj1.getClass() == BigInteger.class
+                || obj2.getClass() == BigInteger.class) {
+                long l1 = (Double.valueOf(obj1.toString())).longValue();
+                long l2 = (Double.valueOf(obj2.toString())).longValue();
+
+                if (l1 == l2)
+                    return 0;
+                else if (l1 < l2)
+                    return -1;
+                else
+                    return 1;
+            }
+
+            else if (obj1.getClass() == Float.class || obj2.getClass() == Float.class) {
+                float f1 = (Double.valueOf(obj1.toString())).floatValue();
+                float f2 = (Double.valueOf(obj2.toString())).floatValue();
+
+                if (f1 == f2)
+                    return 0;
+                else if (f1 < f2)
+                    return -1;
+                else
+                    return 1;
+            }
+
+            else if (obj1.getClass() == Double.class || obj2.getClass() == Double.class) {
+                Double b1 = Double.valueOf(obj1.toString());
+                Double b2 = Double.valueOf(obj2.toString());
+
+                return b1.compareTo(b2);
+            }
+
+            else if (obj1.getClass() == BigDecimal.class || obj2.getClass() == BigDecimal.class) {
+                BigDecimal b1 = new BigDecimal(obj1.toString());
+                BigDecimal b2 = new BigDecimal(obj2.toString());
+
+                return b1.compareTo(b2);
+            }
+
+            else {
+                if (obj1.toString().equals(obj2.toString()))
+                    return 0;
+                else
+                    return 1;
+            }
+        }
+
+    }
+
+    /**
+     * TODO: Uncomment below as appropriate when TUSCANY-581 is resolved. In the
+     * following test cases, several instances are commented out. For these
+     * cases, the test case currently fails. A JIRA issue (TUSCANY-581) has been
+     * opened to either correct the behavior (then uncomment the lines) or to
+     * alter the specification against which the test cases were designed (and
+     * then remove the lines - assuming the alteration is to remove stating the
+     * nature of the exception).
+     */
+
+    /**
+     * testBooleanConversion verifies the conversion from boolean to each of the
+     * allowed types.
+     */
+    @org.junit.Test
+    public void testBooleanConversion() {
+        Test FromBoolean = new Test("booleanVal", BOOLEAN_VAL_INDEX);
+
+        FromBoolean.initialize(boolean.class, "Boolean", Boolean.valueOf(true), testDO);
+
+        try {
+            FromBoolean.attemptConversion(TO_BOOLEAN, testDO);
+            FromBoolean.attemptConversion(TO_STRING, testDO);
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("Unexpected exception " + e.toString());
+
+        }
+    }
+
+    /**
+     * testBooleanExceptions verifies that the appropriate Exceptions are thrown
+     * when an unpermitted conversion from boolean is attempted.
+     */
+    @org.junit.Test
+    public void testBooleanExceptions() {
+        try {
+            Test FromBoolean = new Test("booleanVal", BOOLEAN_VAL_INDEX);
+
+            FromBoolean.initialize(boolean.class, "Boolean", Boolean.valueOf(true), testDO);
+
+            // FromBoolean.checkConversionException(TO_BYTE,
+            // ClassCastException.class, testDO);
+            // FromBoolean.checkConversionException(TO_CHAR,
+            // ClassCastException.class, testDO);
+            // FromBoolean.checkConversionException(TO_DOUBLE,
+            // ClassCastException.class, testDO);
+            // FromBoolean.checkConversionException(TO_FLOAT,
+            // ClassCastException.class, testDO);
+            // FromBoolean.checkConversionException(TO_INT,
+            // ClassCastException.class, testDO);
+            // FromBoolean.checkConversionException(TO_LONG,
+            // ClassCastException.class, testDO);
+            // FromBoolean.checkConversionException(TO_SHORT,
+            // ClassCastException.class, testDO);
+            // FromBoolean.checkConversionException(TO_BYTES,
+            // ClassCastException.class, testDO);
+            // FromBoolean.checkConversionException(TO_BIGDECIMAL,
+            // ClassCastException.class, testDO);
+            // FromBoolean.checkConversionException(TO_BIGINTEGER,
+            // ClassCastException.class, testDO);
+            FromBoolean.checkConversionException(TO_DATAOBJECT, ClassCastException.class, testDO);
+            // FromBoolean.checkConversionException(TO_DATE,
+            // ClassCastException.class, testDO);
+            FromBoolean.checkConversionException(TO_LIST, ClassCastException.class, testDO);
+            FromBoolean.checkConversionException(TO_SEQUENCE, ClassCastException.class, testDO);
+
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("Unexpected exception " + e.toString());
+
+        }
+    }
+
+    /**
+     * testByteConversion verifies the conversion from byte to each of the
+     * allowed types.
+     */
+    @org.junit.Test
+    public void testByteConversion() {
+        try {
+            Test FromByte = new Test("byteVal", BYTE_VAL_INDEX);
+
+            FromByte.initialize(byte.class, "Byte", Byte.valueOf("-127"), testDO);
+
+            FromByte.attemptConversion(TO_BYTE, testDO);
+            FromByte.attemptConversion(TO_DOUBLE, testDO);
+            FromByte.attemptConversion(TO_FLOAT, testDO);
+            FromByte.attemptConversion(TO_INT, testDO);
+            FromByte.attemptConversion(TO_LONG, testDO);
+            FromByte.attemptConversion(TO_SHORT, testDO);
+            FromByte.attemptConversion(TO_STRING, testDO);
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("Unexpected exception " + e.toString());
+
+        }
+    }
+
+    /**
+     * testByteExceptions verifies that the appropriate Exceptions are thrown
+     * when an unpermitted conversion from byte is attempted.
+     */
+    @org.junit.Test
+    public void testByteExceptions() {
+        try {
+            Test FromByte = new Test("byteVal", BYTE_VAL_INDEX);
+
+            FromByte.initialize(byte.class, "Byte", Byte.valueOf("-127"), testDO);
+
+            // FromByte.checkConversionException(TO_BOOLEAN,
+            // ClassCastException.class, testDO);
+            // FromByte.checkConversionException(TO_CHAR,
+            // ClassCastException.class,
+            // testDO);
+            // FromByte.checkConversionException(TO_BYTES,
+            // ClassCastException.class,
+            // testDO);
+            FromByte.checkConversionException(TO_BIGDECIMAL, ClassCastException.class, testDO);
+            FromByte.checkConversionException(TO_BIGINTEGER, ClassCastException.class, testDO);
+            FromByte.checkConversionException(TO_DATAOBJECT, ClassCastException.class, testDO);
+            // FromByte.checkConversionException(TO_DATE,
+            // ClassCastException.class,
+            // testDO);
+            FromByte.checkConversionException(TO_LIST, ClassCastException.class, testDO);
+            FromByte.checkConversionException(TO_SEQUENCE, ClassCastException.class, testDO);
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("Unexpected exception " + e.toString());
+
+        }
+    }
+
+    /**
+     * testCharConversion verifies the conversion from char to each of the
+     * allowed types.
+     */
+    @org.junit.Test
+    public void testCharConversion() {
+        try {
+            Test FromChar = new Test("charVal", CHAR_VAL_INDEX);
+
+            FromChar.initialize(char.class, "Char", new Character('?'), testDO);
+
+            FromChar.attemptConversion(TO_CHAR, testDO);
+            FromChar.attemptConversion(TO_STRING, testDO);
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("Unexpected exception " + e.toString());
+
+        }
+    }
+
+    /**
+     * testCharExceptions verifies that the appropriate Exceptions are thrown
+     * when an unpermitted conversion from char is attempted.
+     */
+    @org.junit.Test
+    public void testCharExceptions() {
+        try {
+            Test FromChar = new Test("charVal", CHAR_VAL_INDEX);
+
+            FromChar.initialize(char.class, "Char", new Character('?'), testDO);
+
+            // FromChar.checkConversionException(TO_BOOLEAN,
+            // ClassCastException.class, testDO);
+            // FromChar.checkConversionException(TO_BYTE,
+            // ClassCastException.class,
+            // testDO);
+            // FromChar.checkConversionException(TO_DOUBLE,
+            // ClassCastException.class, testDO);
+            // FromChar.checkConversionException(TO_FLOAT,
+            // ClassCastException.class,
+            // testDO);
+            // FromChar.checkConversionException(TO_INT,
+            // ClassCastException.class,
+            // testDO);
+            // FromChar.checkConversionException(TO_LONG,
+            // ClassCastException.class,
+            // testDO);
+            // FromChar.checkConversionException(TO_SHORT,
+            // ClassCastException.class,
+            // testDO);
+            // FromChar.checkConversionException(TO_BYTES,
+            // ClassCastException.class,
+            // testDO);
+            // FromChar.checkConversionException(TO_BIGDECIMAL,
+            // ClassCastException.class, testDO);
+            // FromChar.checkConversionException(TO_BIGINTEGER,
+            // ClassCastException.class, testDO);
+            FromChar.checkConversionException(TO_DATAOBJECT, ClassCastException.class, testDO);
+            // FromChar.checkConversionException(TO_DATE,
+            // ClassCastException.class,
+            // testDO);
+            FromChar.checkConversionException(TO_LIST, ClassCastException.class, testDO);
+            FromChar.checkConversionException(TO_SEQUENCE, ClassCastException.class, testDO);
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("Unexpected exception " + e.toString());
+
+        }
+    }
+
+    /**
+     * testDoubleConversion verifies the conversion from double to each of the
+     * allowed types.
+     */
+    @org.junit.Test
+    public void testDoubleConversion() {
+        try {
+            Test FromDouble = new Test("doubleVal", DOUBLE_VAL_INDEX);
+
+            FromDouble.initialize(double.class, "Double", new Double(Double.MAX_VALUE), testDO);
+
+            FromDouble.attemptConversion(TO_BYTE, testDO);
+            FromDouble.attemptConversion(TO_DOUBLE, testDO);
+            FromDouble.attemptConversion(TO_FLOAT, testDO);
+            FromDouble.attemptConversion(TO_INT, testDO);
+            FromDouble.attemptConversion(TO_LONG, testDO);
+            FromDouble.attemptConversion(TO_SHORT, testDO);
+            FromDouble.attemptConversion(TO_BIGDECIMAL, testDO);
+            FromDouble.attemptConversion(TO_BIGINTEGER, testDO);
+            FromDouble.attemptConversion(TO_STRING, testDO);
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("Unexpected exception " + e.toString());
+
+        }
+    }
+
+    /**
+     * testDoubleExceptions verifies that the appropriate Exceptions are thrown
+     * when an unpermitted conversion from double is attempted.
+     */
+    @org.junit.Test
+    public void testDoubleExceptions() {
+        try {
+            Test FromDouble = new Test("doubleVal", DOUBLE_VAL_INDEX);
+
+            FromDouble.initialize(double.class, "Double", new Double(Double.MAX_VALUE), testDO);
+
+            // FromDouble.checkConversionException(TO_BOOLEAN,
+            // ClassCastException.class, testDO);
+            // FromDouble.checkConversionException(TO_CHAR,
+            // ClassCastException.class, testDO);
+            // FromDouble.checkConversionException(TO_BYTES,
+            // ClassCastException.class, testDO);
+            FromDouble.checkConversionException(TO_DATAOBJECT, ClassCastException.class, testDO);
+            // FromDouble.checkConversionException(TO_DATE,
+            // ClassCastException.class, testDO);
+            FromDouble.checkConversionException(TO_LIST, ClassCastException.class, testDO);
+            FromDouble.checkConversionException(TO_SEQUENCE, ClassCastException.class, testDO);
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("Unexpected exception " + e.toString());
+
+        }
+    }
+
+    /**
+     * testFloatConversion verifies the conversion from float to each of the
+     * allowed types.
+     */
+    @org.junit.Test
+    public void testFloatConversion() {
+        try {
+            Test FromFloat = new Test("floatVal", FLOAT_VAL_INDEX);
+
+            FromFloat.initialize(float.class, "Float", new Float(Float.MIN_VALUE), testDO);
+
+            FromFloat.attemptConversion(TO_BYTE, testDO);
+            FromFloat.attemptConversion(TO_DOUBLE, testDO);
+            FromFloat.attemptConversion(TO_FLOAT, testDO);
+            FromFloat.attemptConversion(TO_INT, testDO);
+            FromFloat.attemptConversion(TO_LONG, testDO);
+            FromFloat.attemptConversion(TO_SHORT, testDO);
+            FromFloat.attemptConversion(TO_BIGDECIMAL, testDO);
+            FromFloat.attemptConversion(TO_BIGINTEGER, testDO);
+            FromFloat.attemptConversion(TO_STRING, testDO);
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("Unexpected exception " + e.toString());
+
+        }
+    }
+
+    /**
+     * testFloatExceptions verifies that the appropriate Exceptions are thrown
+     * when an unpermitted conversion from float is attempted.
+     */
+    @org.junit.Test
+    public void testFloatExceptions() {
+        try {
+            Test FromFloat = new Test("floatVal", FLOAT_VAL_INDEX);
+
+            FromFloat.initialize(float.class, "Float", new Float(Float.MIN_VALUE), testDO);
+
+            // FromFloat.checkConversionException(TO_BOOLEAN,
+            // ClassCastException.class, testDO);
+            // FromFloat.checkConversionException(TO_CHAR,
+            // ClassCastException.class,
+            // testDO);
+            // FromFloat.checkConversionException(TO_BYTES,
+            // ClassCastException.class, testDO);
+            FromFloat.checkConversionException(TO_DATAOBJECT, ClassCastException.class, testDO);
+            // FromFloat.checkConversionException(TO_DATE,
+            // ClassCastException.class,
+            // testDO);
+            FromFloat.checkConversionException(TO_LIST, ClassCastException.class, testDO);
+            FromFloat.checkConversionException(TO_SEQUENCE, ClassCastException.class, testDO);
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("Unexpected exception " + e.toString());
+
+        }
+    }
+
+    /**
+     * testIntConversion verifies the conversion from int to each of the allowed
+     * types.
+     */
+    @org.junit.Test
+    public void testIntConversion() {
+        Test FromInt = new Test("intVal", INT_VAL_INDEX);
+
+        FromInt.initialize(int.class, "Int", new Integer(5), testDO);
+
+        FromInt.attemptConversion(TO_BYTE, testDO);
+        FromInt.attemptConversion(TO_DOUBLE, testDO);
+        FromInt.attemptConversion(TO_FLOAT, testDO);
+        FromInt.attemptConversion(TO_INT, testDO);
+        FromInt.attemptConversion(TO_LONG, testDO);
+        FromInt.attemptConversion(TO_SHORT, testDO);
+        FromInt.attemptConversion(TO_BIGDECIMAL, testDO);
+        FromInt.attemptConversion(TO_BIGINTEGER, testDO);
+        FromInt.attemptConversion(TO_STRING, testDO);
+    }
+
+    /**
+     * testIntExceptions verifies that the appropriate Exceptions are thrown
+     * when an unpermitted conversion from int is attempted.
+     */
+    @org.junit.Test
+    public void testIntExceptions() {
+
+        Test FromInt = new Test("intVal", INT_VAL_INDEX);
+
+        FromInt.initialize(int.class, "Int", new Integer(5), testDO);
+
+        // FromInt.checkConversionException(TO_BOOLEAN,
+        // ClassCastException.class, testDO);
+        // FromInt.checkConversionException(TO_CHAR, ClassCastException.class,
+        // testDO);
+        // FromInt.checkConversionException(TO_BYTES, ClassCastException.class,
+        // testDO);
+        FromInt.checkConversionException(TO_DATAOBJECT, ClassCastException.class, testDO);
+        // FromInt.checkConversionException(TO_DATE, ClassCastException.class,
+        // testDO);
+        FromInt.checkConversionException(TO_LIST, ClassCastException.class, testDO);
+        FromInt.checkConversionException(TO_SEQUENCE, ClassCastException.class, testDO);
+    }
+
+    /**
+     * testLongConversion verifies the conversion from long to each of the
+     * allowed types.
+     */
+    @org.junit.Test
+    public void testLongConversion() {
+        Test FromLong = new Test("longVal", LONG_VAL_INDEX);
+
+        FromLong.initialize(long.class, "Long", new Long(7000L), testDO);
+
+        FromLong.attemptConversion(TO_BYTE, testDO);
+        FromLong.attemptConversion(TO_DOUBLE, testDO);
+        FromLong.attemptConversion(TO_FLOAT, testDO);
+        FromLong.attemptConversion(TO_INT, testDO);
+        FromLong.attemptConversion(TO_LONG, testDO);
+        FromLong.attemptConversion(TO_SHORT, testDO);
+        FromLong.attemptConversion(TO_BIGDECIMAL, testDO);
+        FromLong.attemptConversion(TO_BIGINTEGER, testDO);
+        FromLong.attemptConversion(TO_DATE, testDO);
+        FromLong.attemptConversion(TO_STRING, testDO);
+    }
+
+    /**
+     * testLongExceptions verifies that the appropriate Exceptions are thrown
+     * when an unpermitted conversion from long is attempted.
+     */
+    @org.junit.Test
+    public void testLongExceptions() {
+        Test FromLong = new Test("longVal", LONG_VAL_INDEX);
+
+        FromLong.initialize(long.class, "Long", new Long(7000L), testDO);
+
+        // FromLong.checkConversionException(TO_BOOLEAN,
+        // ClassCastException.class, testDO);
+        // FromLong.checkConversionException(TO_CHAR, ClassCastException.class,
+        // testDO);
+        // FromLong.checkConversionException(TO_BYTES, ClassCastException.class,
+        // testDO);
+        FromLong.checkConversionException(TO_DATAOBJECT, ClassCastException.class, testDO);
+        FromLong.checkConversionException(TO_LIST, ClassCastException.class, testDO);
+        FromLong.checkConversionException(TO_SEQUENCE, ClassCastException.class, testDO);
+    }
+
+    /**
+     * testShortConversion verifies the conversion from short to each of the
+     * allowed types.
+     */
+    @org.junit.Test
+    public void testShortConversion() {
+        Test FromShort = new Test("shortVal", SHORT_VAL_INDEX);
+
+        FromShort.initialize(short.class, "Short", new Short("-8000"), testDO);
+
+        FromShort.attemptConversion(TO_BYTE, testDO);
+        FromShort.attemptConversion(TO_DOUBLE, testDO);
+        FromShort.attemptConversion(TO_FLOAT, testDO);
+        FromShort.attemptConversion(TO_INT, testDO);
+        FromShort.attemptConversion(TO_LONG, testDO);
+        FromShort.attemptConversion(TO_SHORT, testDO);
+        FromShort.attemptConversion(TO_STRING, testDO);
+    }
+
+    /**
+     * testShortExceptions verifies that the appropriate Exceptions are thrown
+     * when an unpermitted conversion from short is attempted.
+     */
+    @org.junit.Test
+    public void testShortExceptions() {
+        Test FromShort = new Test("shortVal", SHORT_VAL_INDEX);
+
+        FromShort.initialize(short.class, "Short", new Short("-8000"), testDO);
+
+        // FromShort.checkConversionException(TO_BOOLEAN,
+        // ClassCastException.class, testDO);
+        // FromShort.checkConversionException(TO_CHAR, ClassCastException.class,
+        // testDO);
+        // FromShort.checkConversionException(TO_BYTES,
+        // ClassCastException.class, testDO);
+        FromShort.checkConversionException(TO_BIGDECIMAL, ClassCastException.class, testDO);
+        FromShort.checkConversionException(TO_BIGINTEGER, ClassCastException.class, testDO);
+        FromShort.checkConversionException(TO_DATAOBJECT, ClassCastException.class, testDO);
+        // FromShort.checkConversionException(TO_DATE, ClassCastException.class,
+        // testDO);
+        FromShort.checkConversionException(TO_LIST, ClassCastException.class, testDO);
+        FromShort.checkConversionException(TO_SEQUENCE, ClassCastException.class, testDO);
+    }
+
+    /**
+     * testStringConversion verifies the conversion from String to each of the
+     * allowed types.
+     */
+    @org.junit.Test
+    public void testStringConversion() {
+        Test FromString = new Test("stringVal", STRING_VAL_INDEX);
+
+        FromString.initialize(String.class, "String", "5", testDO);
+
+        FromString.attemptConversion(TO_BOOLEAN, testDO);
+        FromString.attemptConversion(TO_BYTE, testDO);
+        FromString.attemptConversion(TO_CHAR, testDO);
+        FromString.attemptConversion(TO_DOUBLE, testDO);
+        FromString.attemptConversion(TO_FLOAT, testDO);
+        FromString.attemptConversion(TO_INT, testDO);
+        FromString.attemptConversion(TO_LONG, testDO);
+        FromString.attemptConversion(TO_SHORT, testDO);
+        FromString.attemptConversion(TO_BIGDECIMAL, testDO);
+        FromString.attemptConversion(TO_BIGINTEGER, testDO);
+        FromString.attemptConversion(TO_STRING, testDO);
+
+        FromString.initialize(String.class, "String", "1999-07-25T8:50:14.33Z", testDO);
+        FromString.attemptConversion(TO_DATE, testDO);
+    }
+
+    /**
+     * testStringExceptions verifies that the appropriate Exceptions are thrown
+     * when an unpermitted conversion from String is attempted.
+     */
+    @org.junit.Test
+    public void testStringExceptions() {
+        Test FromString = new Test("stringVal", STRING_VAL_INDEX);
+
+        FromString.initialize(String.class, "String", "5", testDO);
+
+        // FromString.checkConversionException(TO_BYTES,
+        // ClassCastException.class, testDO);
+        FromString.checkConversionException(TO_DATAOBJECT, ClassCastException.class, testDO);
+        FromString.checkConversionException(TO_LIST, ClassCastException.class, testDO);
+        FromString.checkConversionException(TO_SEQUENCE, ClassCastException.class, testDO);
+    }
+
+    /**
+     * testBytesConversion verifies the conversion from Bytes to each of the
+     * allowed types.
+     */
+    @org.junit.Test
+    public void testBytesConversion() {
+        Test FromBytes = new Test("bytesVal", BYTES_VAL_INDEX);
+
+        FromBytes.initialize(byte[].class, "Bytes", new byte[] {10, 100}, testDO);
+
+        FromBytes.attemptConversion(TO_BYTES, testDO);
+        FromBytes.attemptConversion(TO_BIGINTEGER, testDO);
+    }
+
+    /**
+     * testBytesExceptions verifies that the appropriate Exceptions are thrown
+     * when an unpermitted conversion from Bytes is attempted.
+     */
+    @org.junit.Test
+    public void testBytesExceptions() {
+        Test FromBytes = new Test("bytesVal", BYTES_VAL_INDEX);
+
+        FromBytes.initialize(byte[].class, "Bytes", new byte[] {10, 100}, testDO);
+
+        // FromBytes.checkConversionException(TO_BOOLEAN,
+        // ClassCastException.class, testDO);
+        // FromBytes.checkConversionException(TO_BYTE, ClassCastException.class,
+        // testDO);
+        // FromBytes.checkConversionException(TO_CHAR, ClassCastException.class,
+        // testDO);
+        // FromBytes.checkConversionException(TO_DOUBLE,
+        // ClassCastException.class, testDO);
+        // FromBytes.checkConversionException(TO_FLOAT,
+        // ClassCastException.class, testDO);
+        // FromBytes.checkConversionException(TO_INT, ClassCastException.class,
+        // testDO);
+        // FromBytes.checkConversionException(TO_LONG, ClassCastException.class,
+        // testDO);
+        // FromBytes.checkConversionException(TO_SHORT,
+        // ClassCastException.class, testDO);
+        // FromBytes.checkConversionException(TO_BIGDECIMAL,
+        // ClassCastException.class, testDO);
+        FromBytes.checkConversionException(TO_DATAOBJECT, ClassCastException.class, testDO);
+        // FromBytes.checkConversionException(TO_DATE, ClassCastException.class,
+        // testDO);
+        // FromBytes.checkConversionException(TO_STRING,
+        // ClassCastException.class, testDO);
+        FromBytes.checkConversionException(TO_LIST, ClassCastException.class, testDO);
+        FromBytes.checkConversionException(TO_SEQUENCE, ClassCastException.class, testDO);
+    }
+
+    /**
+     * testBigDecimalConversion verifies the conversion from BigDecimal to each
+     * of the allowed types.
+     */
+    @org.junit.Test
+    public void testBigDecimalConversion() {
+        Test FromBigDecimal = new Test("decimalVal", DECIMAL_VAL_INDEX);
+
+        FromBigDecimal.initialize(BigDecimal.class, "BigDecimal", new BigDecimal("-3"), testDO);
+
+        FromBigDecimal.attemptConversion(TO_DOUBLE, testDO);
+        FromBigDecimal.attemptConversion(TO_FLOAT, testDO);
+        FromBigDecimal.attemptConversion(TO_INT, testDO);
+        FromBigDecimal.attemptConversion(TO_LONG, testDO);
+        FromBigDecimal.attemptConversion(TO_BIGDECIMAL, testDO);
+        FromBigDecimal.attemptConversion(TO_BIGINTEGER, testDO);
+        FromBigDecimal.attemptConversion(TO_STRING, testDO);
+    }
+
+    /**
+     * testBigDecimalExceptions verifies that the appropriate Exceptions are
+     * thrown when an unpermitted conversion from BigDecimal is attempted.
+     */
+    @org.junit.Test
+    public void testBigDecimalExceptions() {
+        Test FromBigDecimal = new Test("decimalVal", DECIMAL_VAL_INDEX);
+
+        FromBigDecimal.initialize(BigDecimal.class, "BigDecimal", new BigDecimal("-3"), testDO);
+
+        // FromBigDecimal.checkConversionException(TO_BOOLEAN,
+        // ClassCastException.class, testDO);
+        // FromBigDecimal.checkConversionException(TO_BYTE,
+        // ClassCastException.class, testDO);
+        // FromBigDecimal.checkConversionException(TO_CHAR,
+        // ClassCastException.class, testDO);
+        // FromBigDecimal.checkConversionException(TO_SHORT,
+        // ClassCastException.class, testDO);
+        // FromBigDecimal.checkConversionException(TO_BYTES,
+        // ClassCastException.class, testDO);
+        FromBigDecimal.checkConversionException(TO_DATAOBJECT, ClassCastException.class, testDO);
+        // FromBigDecimal.checkConversionException(TO_DATE,
+        // ClassCastException.class, testDO);
+        FromBigDecimal.checkConversionException(TO_LIST, ClassCastException.class, testDO);
+        FromBigDecimal.checkConversionException(TO_SEQUENCE, ClassCastException.class, testDO);
+    }
+
+    /**
+     * testBigIntegerConversion verifies the conversion from BigInteger to each
+     * of the allowed types.
+     */
+    @org.junit.Test
+    public void testBigIntegerConversion() {
+        Test FromBigInteger = new Test("integerVal", INTEGER_VAL_INDEX);
+
+        FromBigInteger.initialize(BigInteger.class, "BigInteger", new BigInteger("31500"), testDO);
+
+        FromBigInteger.attemptConversion(TO_DOUBLE, testDO);
+        FromBigInteger.attemptConversion(TO_FLOAT, testDO);
+        FromBigInteger.attemptConversion(TO_INT, testDO);
+        FromBigInteger.attemptConversion(TO_LONG, testDO);
+        FromBigInteger.attemptConversion(TO_SHORT, testDO);
+        FromBigInteger.attemptConversion(TO_BYTES, testDO);
+        FromBigInteger.attemptConversion(TO_BIGDECIMAL, testDO);
+        FromBigInteger.attemptConversion(TO_BIGINTEGER, testDO);
+        FromBigInteger.attemptConversion(TO_STRING, testDO);
+    }
+
+    /**
+     * testBigIntegerExceptions verifies that the appropriate Exceptions are
+     * thrown when an unpermitted conversion from BigInteger is attempted.
+     * 
+     * @param testDO
+     * @throws Exception
+     */
+    @org.junit.Test
+    public void testBigIntegerExceptions() {
+        Test FromBigInteger = new Test("integerVal", INTEGER_VAL_INDEX);
+
+        FromBigInteger.initialize(BigInteger.class, "BigInteger", new BigInteger("31500"), testDO);
+
+        // FromBigInteger.checkConversionException(TO_BOOLEAN,
+        // ClassCastException.class, testDO);
+        // FromBigInteger.checkConversionException(TO_BYTE,
+        // ClassCastException.class, testDO);
+        // FromBigInteger.checkConversionException(TO_CHAR,
+        // ClassCastException.class, testDO);
+        FromBigInteger.checkConversionException(TO_DATAOBJECT, ClassCastException.class, testDO);
+        // FromBigInteger.checkConversionException(TO_DATE,
+        // ClassCastException.class, testDO);
+        FromBigInteger.checkConversionException(TO_LIST, ClassCastException.class, testDO);
+        FromBigInteger.checkConversionException(TO_SEQUENCE, ClassCastException.class, testDO);
+    }
+
+    /**
+     * testDateConversion verifies the conversion from Date to each of the
+     * allowed types.
+     */
+    @org.junit.Test
+    public void testDateConversion() {
+        Test FromDate = new Test("dateVal", DATE_VAL_INDEX);
+
+        FromDate.initialize(Date.class, "Date", new Date(System.currentTimeMillis()), testDO);
+
+        FromDate.attemptConversion(TO_LONG, testDO);
+        FromDate.attemptConversion(TO_DATE, testDO);
+        FromDate.attemptConversion(TO_STRING, testDO);
+    }
+
+    /**
+     * testDateExceptions verifies that the appropriate Exceptions are thrown
+     * when an unpermitted conversion from Date is attempted.
+     */
+    @org.junit.Test
+    public void testDateExceptions() {
+
+        Test FromDate = new Test("dateVal", DATE_VAL_INDEX);
+
+        FromDate.initialize(Date.class, "Date", new Date(System.currentTimeMillis()), testDO);
+
+        // FromDate.checkConversionException(TO_BOOLEAN,
+        // ClassCastException.class, testDO);
+        // FromDate.checkConversionException(TO_BYTE, ClassCastException.class,
+        // testDO);
+        // FromDate.checkConversionException(TO_CHAR, ClassCastException.class,
+        // testDO);
+        // FromDate.checkConversionException(TO_DOUBLE,
+        // ClassCastException.class, testDO);
+        // FromDate.checkConversionException(TO_FLOAT, ClassCastException.class,
+        // testDO);
+        // FromDate.checkConversionException(TO_INT, ClassCastException.class,
+        // testDO);
+        // FromDate.checkConversionException(TO_SHORT, ClassCastException.class,
+        // testDO);
+        // FromDate.checkConversionException(TO_BYTES, ClassCastException.class,
+        // testDO);
+        // FromDate.checkConversionException(TO_BIGDECIMAL,
+        // ClassCastException.class, testDO);
+        // FromDate.checkConversionException(TO_BIGINTEGER,
+        // ClassCastException.class, testDO);
+        FromDate.checkConversionException(TO_DATAOBJECT, ClassCastException.class, testDO);
+        FromDate.checkConversionException(TO_LIST, ClassCastException.class, testDO);
+        FromDate.checkConversionException(TO_SEQUENCE, ClassCastException.class, testDO);
+    }
+}

Propchange: incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/conversion/TypeConversionTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/conversion/TypeConversionTest.java
------------------------------------------------------------------------------
    svn:keywords = Rev Date

Added: incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/conversion/package.html
URL: http://svn.apache.org/viewvc/incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/conversion/package.html?view=auto&rev=501803
==============================================================================
--- incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/conversion/package.html (added)
+++ incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/conversion/package.html Wed Jan 31 03:18:45 2007
@@ -0,0 +1,25 @@
+<html>
+<!--
+  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$
+-->
+<body>
+Contains paramatized test cases for conversion test.
+</body>
+</html>

Propchange: incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/conversion/package.html
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/conversion/package.html
------------------------------------------------------------------------------
    svn:keywords = Rev Date

Propchange: incubator/tuscany/java/cts/sdo2.1/src/main/java/test/sdo21/paramatizedTests/conversion/package.html
------------------------------------------------------------------------------
    svn:mime-type = text/html



---------------------------------------------------------------------
To unsubscribe, e-mail: tuscany-commits-unsubscribe@ws.apache.org
For additional commands, e-mail: tuscany-commits-help@ws.apache.org


Mime
View raw message