Return-Path: Delivered-To: apmail-ws-tuscany-commits-archive@locus.apache.org Received: (qmail 17062 invoked from network); 31 Jan 2007 11:19:17 -0000 Received: from hermes.apache.org (HELO mail.apache.org) (140.211.11.2) by minotaur.apache.org with SMTP; 31 Jan 2007 11:19:17 -0000 Received: (qmail 94020 invoked by uid 500); 31 Jan 2007 11:19:23 -0000 Delivered-To: apmail-ws-tuscany-commits-archive@ws.apache.org Received: (qmail 93935 invoked by uid 500); 31 Jan 2007 11:19:23 -0000 Mailing-List: contact tuscany-commits-help@ws.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: tuscany-dev@ws.apache.org Delivered-To: mailing list tuscany-commits@ws.apache.org Received: (qmail 93924 invoked by uid 99); 31 Jan 2007 11:19:23 -0000 Received: from herse.apache.org (HELO herse.apache.org) (140.211.11.133) by apache.org (qpsmtpd/0.29) with ESMTP; Wed, 31 Jan 2007 03:19:23 -0800 X-ASF-Spam-Status: No, hits=-9.4 required=10.0 tests=ALL_TRUSTED,NO_REAL_NAME X-Spam-Check-By: apache.org Received: from [140.211.11.3] (HELO eris.apache.org) (140.211.11.3) by apache.org (qpsmtpd/0.29) with ESMTP; Wed, 31 Jan 2007 03:19:11 -0800 Received: by eris.apache.org (Postfix, from userid 65534) id 651D21A9820; Wed, 31 Jan 2007 03:18:51 -0800 (PST) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit 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 -0000 To: tuscany-commits@ws.apache.org From: gwinn@apache.org X-Mailer: svnmailer-1.1.0 Message-Id: <20070131111851.651D21A9820@eris.apache.org> X-Virus-Checked: Checked by ClamAV on apache.org 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.
+ * (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 @@ + + + +Contains paramatized test cases for API test. + + 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, but within + // the array exist the get(index), get(property), and + // get(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____(). 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 @@ + + + +Contains paramatized test cases for conversion test. + + 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