From eb11fd83f7908876fe6041086d6025c9468de672 Mon Sep 17 00:00:00 2001 From: lresende Date: Tue, 10 Nov 2009 21:17:39 +0000 Subject: Moving SDO CTS git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@834672 13f79535-47bb-0310-9956-ffa450edef68 --- .../tests/TestData/StandardDynamicFactory.java | 226 +++++++++++++++++++++ .../test/sdo21/tests/TestData/StandardFactory.java | 72 +++++++ .../sdo21/tests/TestData/StandardXSDFactory.java | 39 ++++ .../test/sdo21/tests/TestData/TestDataFactory.java | 9 + 4 files changed, 346 insertions(+) create mode 100644 sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/TestData/StandardDynamicFactory.java create mode 100644 sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/TestData/StandardFactory.java create mode 100644 sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/TestData/StandardXSDFactory.java create mode 100644 sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/TestData/TestDataFactory.java (limited to 'sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/TestData') diff --git a/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/TestData/StandardDynamicFactory.java b/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/TestData/StandardDynamicFactory.java new file mode 100644 index 0000000000..872325b059 --- /dev/null +++ b/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/TestData/StandardDynamicFactory.java @@ -0,0 +1,226 @@ +package test.sdo21.tests.TestData; + +import java.util.ArrayList; +import java.util.List; + +import commonj.sdo.DataObject; +import commonj.sdo.Type; +import commonj.sdo.helper.HelperContext; +import commonj.sdo.helper.TypeHelper; + +public class StandardDynamicFactory extends StandardFactory { + + public void defineMetaData(HelperContext hc) { + TypeHelper types = hc.getTypeHelper(); + + Type t = types.getType(TEST_NAMESPACE, "Abstract"); + if (t != null) { + // the test types have already been defined in this HelperContext (this will happen when the + // implementation being tested does not support multiple contexts, which is not a 2.1 requirement). + return; + } + + Type stringType = types.getType("commonj.sdo", "String"); + Type intType = types.getType("commonj.sdo", "Int"); + Type booleanType = types.getType("commonj.sdo", "Boolean"); + Type byteType = types.getType("commonj.sdo", "Byte"); + Type decimalType = types.getType("commonj.sdo", "Decimal"); + Type floatType = types.getType("commonj.sdo", "Float"); + Type doubleType = types.getType("commonj.sdo", "Double"); + Type dateType = types.getType("commonj.sdo", "Date"); + Type shortType = types.getType("commonj.sdo", "Short"); + Type longType = types.getType("commonj.sdo", "Long"); + Type bytesType = types.getType("commonj.sdo", "Bytes"); + Type integerType = types.getType("commonj.sdo", "Integer"); + Type charType = types.getType("commonj.sdo", "Character"); + + DataObject abstractTypeDO = hc.getDataFactory().create("commonj.sdo", "Type"); + abstractTypeDO.set("uri", TEST_NAMESPACE); + abstractTypeDO.set("name", "Abstract"); + abstractTypeDO.setBoolean("abstract", true); + + DataObject firstProperty = abstractTypeDO.createDataObject("property"); + firstProperty.set("name", "firstName"); + firstProperty.set("type", stringType); + + DataObject lastProperty = abstractTypeDO.createDataObject("property"); + lastProperty.set("name", "lastName"); + lastProperty.set("type", stringType); + + Type abstractType = types.define(abstractTypeDO); + + DataObject extendedTypeDO = hc.getDataFactory().create("commonj.sdo", "Type"); + extendedTypeDO.set("uri", TEST_NAMESPACE); + extendedTypeDO.set("name", EXT_TYPE); + + List baseTypes = new ArrayList(); + baseTypes.add(abstractType); + extendedTypeDO.setList("baseType", baseTypes); + + DataObject middleName = extendedTypeDO.createDataObject("property"); + middleName.set("name", "middleName"); + middleName.set("type", stringType); + + DataObject nickName = extendedTypeDO.createDataObject("property"); + nickName.set("name", "nickName"); + nickName.set("type", stringType); + + Type extendedType = types.define(extendedTypeDO); + + DataObject sequenceTypeDO = hc.getDataFactory().create("commonj.sdo", "Type"); + sequenceTypeDO.set("uri", TEST_NAMESPACE); + sequenceTypeDO.set("name", SEQ_TYPE); + sequenceTypeDO.setBoolean("sequenced", true); + + // TODO: Uncomment the following when SDOUtil.addAliasName is + // implemented + /* + * aliases.clear(); aliases.add("Seq2"); sequenceTypeDO.set("aliasName", + * aliases); + */ + + DataObject Letters = sequenceTypeDO.createDataObject("property"); + Letters.set("name", "Letters"); + Letters.set("type", stringType); + Letters.setBoolean("many", true); + + DataObject Numbers = sequenceTypeDO.createDataObject("property"); + Numbers.set("name", "Numbers"); + Numbers.set("type", intType); + Numbers.setBoolean("many", true); + + DataObject containManySeq = sequenceTypeDO.createDataObject("property"); + containManySeq.set("name", "containMany"); + containManySeq.set("type", sequenceTypeDO); + containManySeq.setBoolean("many", true); + containManySeq.setBoolean("containment", true); + + DataObject containSeq = sequenceTypeDO.createDataObject("property"); + containSeq.set("name", "contain"); + containSeq.set("type", sequenceTypeDO); + containSeq.setBoolean("containment", true); + + Type sequenceType = types.define(sequenceTypeDO); + + DataObject openTypeDO = hc.getDataFactory().create("commonj.sdo", "Type"); + openTypeDO.set("uri", TEST_NAMESPACE); + openTypeDO.set("name", "Open"); + openTypeDO.setBoolean("open", true); + + DataObject definedElem = openTypeDO.createDataObject("property"); + definedElem.set("name", "defined"); + definedElem.set("type", stringType); + + Type openType = types.define(openTypeDO); + + DataObject testType = hc.getDataFactory().create("commonj.sdo", "Type"); + testType.set("uri", TEST_NAMESPACE); + testType.set("name", API_TYPE); + + DataObject stringProperty = testType.createDataObject("property"); + stringProperty.set("name", "stringVal"); + stringProperty.set("type", stringType); + + DataObject booleanProperty = testType.createDataObject("property"); + booleanProperty.set("name", "booleanVal"); + booleanProperty.set("type", booleanType); + + DataObject boolean2Property = testType.createDataObject("property"); + boolean2Property.set("name", "booleanVal2"); + boolean2Property.set("type", booleanType); + + DataObject byteProperty = testType.createDataObject("property"); + byteProperty.set("name", "byteVal"); + byteProperty.set("type", byteType); + + DataObject string2Property = testType.createDataObject("property"); + string2Property.set("name", "stringVal2"); + string2Property.set("type", stringType); + + DataObject decimalProperty = testType.createDataObject("property"); + decimalProperty.set("name", "decimalVal"); + decimalProperty.set("type", decimalType); + + DataObject decimal2Property = testType.createDataObject("property"); + decimal2Property.set("name", "decimalVal2"); + decimal2Property.set("type", decimalType); + + // TODO: Uncomment the following when SDOUtil.addAliasName is + // implemented + /* + * aliases.clear(); aliases.add("Dec2"); + * decimal2Property.set("aliasName", aliases); + */ + DataObject intProperty = testType.createDataObject("property"); + intProperty.set("name", "intVal"); + intProperty.set("type", intType); + + DataObject floatProperty = testType.createDataObject("property"); + floatProperty.set("name", "floatVal"); + floatProperty.set("type", floatType); + + DataObject doubleProperty = testType.createDataObject("property"); + doubleProperty.set("name", "doubleVal"); + doubleProperty.set("type", doubleType); + + DataObject dateProperty = testType.createDataObject("property"); + dateProperty.set("name", "dateVal"); + dateProperty.set("type", dateType); + + DataObject shortProperty = testType.createDataObject("property"); + shortProperty.set("name", "shortVal"); + shortProperty.set("type", shortType); + + DataObject longProperty = testType.createDataObject("property"); + longProperty.set("name", "longVal"); + longProperty.set("type", longType); + + DataObject containManyProperty = testType.createDataObject("property"); + containManyProperty.set("name", "containMany"); + containManyProperty.setBoolean("many", true); + containManyProperty.setBoolean("containment", true); + containManyProperty.set("type", testType); + + DataObject bytesProperty = testType.createDataObject("property"); + bytesProperty.set("name", "bytesVal"); + bytesProperty.set("type", bytesType); + + DataObject integerProperty = testType.createDataObject("property"); + integerProperty.set("name", "integerVal"); + integerProperty.set("type", integerType); + + DataObject charProperty = testType.createDataObject("property"); + charProperty.set("name", "charVal"); + charProperty.set("type", charType); + + DataObject readOnlyProperty = testType.createDataObject("property"); + readOnlyProperty.set("name", "readOnlyVal"); + readOnlyProperty.set("type", stringType); + readOnlyProperty.setBoolean("readOnly", true); + + DataObject sequenceProperty = testType.createDataObject("property"); + sequenceProperty.set("name", "sequencedElem"); + sequenceProperty.set("type", sequenceType); + sequenceProperty.setBoolean("containment", true); + + DataObject extendProperty = testType.createDataObject("property"); + extendProperty.set("name", "extendedElem"); + extendProperty.set("type", extendedType); + extendProperty.setBoolean("containment", true); + + DataObject openProperty = testType.createDataObject("property"); + openProperty.set("name", "openElem"); + openProperty.set("type", openType); + openProperty.setBoolean("containment", true); + + DataObject containProperty = testType.createDataObject("property"); + containProperty.set("name", "contain"); + containProperty.setBoolean("containment", true); + containProperty.set("type", testType); + + types.define(testType); + + } + + +} diff --git a/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/TestData/StandardFactory.java b/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/TestData/StandardFactory.java new file mode 100644 index 0000000000..eee92ee366 --- /dev/null +++ b/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/TestData/StandardFactory.java @@ -0,0 +1,72 @@ +package test.sdo21.tests.TestData; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.util.ArrayList; +import java.util.Date; +import java.util.List; + +import test.sdo21.framework.DataObjectFactory; +import commonj.sdo.DataObject; +import commonj.sdo.helper.HelperContext; + +/** + * Abstract base class for creating tests data of an specific nature. + * Concrete specializations of this class may create the metadata by various means, + * e.g. the SDO Dynamic API or XSD to SDO conversion, or some other implementation + * specific means, e.g. generation of static classes. + * + * All derived classes must create equivalent metatdata by whatever means is chosen. + * + */ +public abstract class StandardFactory implements TestDataFactory { + + public static final String TEST_NAMESPACE = "http://www.example.com/api_test"; + public static final String API_TYPE = "APITest"; + public final static String SEQ_TYPE = "Sequenced"; + public final static String EXT_TYPE = "Extended"; + public static final String ABSTRACT_TYPE = "Abstract"; + + /** + * this factory currently simple makes the assumption that the variant string is the + * name of a type for which an empty instance is required + */ + public DataObject createTestData(HelperContext scope, String variantString) throws Exception { + return scope.getDataFactory().create(TEST_NAMESPACE, variantString); + } + + /** + * populateFields uses set to set each of the fields in the + * DataObject. It is used to ensure a known set of expected values that are + * not other than the default values for the various fields. + * + * @param testDO + * @param helperContext + * @throws ExpectedConditionError + */ + public void populateFields(DataObject testDO, HelperContext scope) throws Exception { + testDO.setString("stringVal", "String 1"); + testDO.setBoolean("booleanVal", true); + testDO.setBoolean("booleanVal2", false); + testDO.setByte("byteVal", (byte)-127); + testDO.setString("stringVal2", "Second string!"); + testDO.setBigDecimal("decimalVal", new BigDecimal(-3.00003)); + testDO.setBigDecimal("decimalVal2", new BigDecimal(18883.999999)); + testDO.setInt("intVal", (int)33333); + testDO.setFloat("floatVal", (float)0.88881); + testDO.setDouble("doubleVal", (double)119.13813); + testDO.setDate("dateVal", new Date(System.currentTimeMillis())); + testDO.setShort("shortVal", (short)-800); + testDO.setLong("longVal", (long)88881113); + testDO.setBytes("bytesVal", new byte[] {120, 80, -40}); + testDO.setBigInteger("integerVal", new BigInteger("88819313")); + testDO.setChar("charVal", '*'); + testDO.setDataObject("sequencedElem", createTestData(scope, SEQ_TYPE)); + testDO.setDataObject("extendedElem", createTestData(scope, EXT_TYPE)); + testDO.setDataObject("contain", createTestData(scope, API_TYPE)); + List containMany = new ArrayList(); + containMany.add(createTestData(scope, API_TYPE)); + testDO.setList("containMany", containMany); + } + +} diff --git a/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/TestData/StandardXSDFactory.java b/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/TestData/StandardXSDFactory.java new file mode 100644 index 0000000000..828b0117e6 --- /dev/null +++ b/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/TestData/StandardXSDFactory.java @@ -0,0 +1,39 @@ +package test.sdo21.tests.TestData; + +import java.io.IOException; +import java.io.InputStream; +import java.net.URL; + +import commonj.sdo.helper.HelperContext; +import commonj.sdo.Type; + +/** + * + * Concrete specialization of the StandardFactory test data creation factory + * which uses an XSD to create the required metadata. + * + */ +public class StandardXSDFactory extends StandardFactory { + + public final static String TEST_MODEL = "/api_test.xsd"; + + + public void defineMetaData(HelperContext hc) throws IOException { + + Type t = hc.getTypeHelper().getType(TEST_NAMESPACE, "Abstract"); + if (t != null) { + // the test types have already been defined in this HelperContext (this will happen when the + // implementation being tested does not support multiple contexts, which is not a 2.1 requirement). + return; + } + + // Populate the meta data for the test model (APITest) + URL url = this.getClass().getResource(TEST_MODEL); + InputStream inputStream = url.openStream(); + hc.getXSDHelper().define(inputStream, url.toString()); + inputStream.close(); + + } + + +} diff --git a/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/TestData/TestDataFactory.java b/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/TestData/TestDataFactory.java new file mode 100644 index 0000000000..bb84374784 --- /dev/null +++ b/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/TestData/TestDataFactory.java @@ -0,0 +1,9 @@ +package test.sdo21.tests.TestData; + +import commonj.sdo.DataObject; +import commonj.sdo.helper.HelperContext; + +public interface TestDataFactory { + public void defineMetaData(HelperContext scope) throws Exception; + public DataObject createTestData(HelperContext scope, String variant) throws Exception; +} -- cgit v1.2.3