diff options
author | lresende <lresende@13f79535-47bb-0310-9956-ffa450edef68> | 2009-11-10 21:17:39 +0000 |
---|---|---|
committer | lresende <lresende@13f79535-47bb-0310-9956-ffa450edef68> | 2009-11-10 21:17:39 +0000 |
commit | eb11fd83f7908876fe6041086d6025c9468de672 (patch) | |
tree | 7475c93a5adceca4829d5c7bf6631d4b09749f4b /sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/util/CTSUtil.java | |
parent | 39a3e278e786438a92428fe13646d09f3441d2e6 (diff) |
Moving SDO CTS
git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@834672 13f79535-47bb-0310-9956-ffa450edef68
Diffstat (limited to 'sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/util/CTSUtil.java')
-rw-r--r-- | sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/util/CTSUtil.java | 207 |
1 files changed, 207 insertions, 0 deletions
diff --git a/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/util/CTSUtil.java b/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/util/CTSUtil.java new file mode 100644 index 0000000000..4b734a2ee3 --- /dev/null +++ b/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/util/CTSUtil.java @@ -0,0 +1,207 @@ +/** + * + * 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. + */ +package test.sdo21.tests.util; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.util.List; + +import test.sdo21.framework.TestHelper; + +import commonj.sdo.DataObject; +import commonj.sdo.Property; +import commonj.sdo.Type; +import commonj.sdo.helper.HelperContext; + +public class CTSUtil { + /** + * Convenience method for creating a unique name that can be used for a + * property or type. + * + * @return String containing a unique name + */ + public static DataObject createTypeDef(String uri, String name, boolean open, + HelperContext helperContext) { + DataObject typeDef = helperContext.getDataFactory().create("commonj.sdo", + "Type"); + typeDef.set("uri", uri); + typeDef.set("name", name); + typeDef.set("open", Boolean.valueOf(open)); + return typeDef; + } + + public static DataObject createPropertyDef(DataObject typeDef, String propertyName, + Type type, boolean isMany, boolean isContainment) { + DataObject propertyDef = typeDef.createDataObject("property"); + propertyDef.set("name", propertyName); + propertyDef.set("type", type); + propertyDef.set("many", isMany); + propertyDef.set("containment", isContainment); + return propertyDef; + } + + public static DataObject createPropertyDef(DataObject typeDef, String propertyName, + String typeName, boolean isMany, boolean isContainment, + HelperContext helperContext) { + int pos = typeName.indexOf('#'); + String uri = ""; + String name; + if (pos > 0) { + uri = typeName.substring(0, pos); + name = typeName.substring(pos + 1); + } else { + name = typeName; + } + Type propertyType = helperContext.getTypeHelper().getType(uri, name); + return createPropertyDef(typeDef, propertyName, propertyType, isMany, + isContainment); + } + + public static String createUniqueName() { + return "name-" + System.currentTimeMillis() + "-" + + ((int) (1000 * Math.random())); + } + + /** + * areEqualTypes is used to determine of two Types are equivalent even if + * not identically equal. The names of the Types are compared, as well as + * the Types of each of the Properties making up the Type. + * + * @param type1 + * @param type2 + * @return + */ + public static boolean areEqualTypes(Type type1, Type type2) { + List properties1, properties2; + Property property1, property2; + int size = 0, j = 0, k; + boolean found; + + // Equivalent Types have the same name + + if (!(type1.getName().equals(type2.getName()))) + return false; + + // Equivalent Types have the same number of Properties + + properties1 = type1.getProperties(); + properties2 = type2.getProperties(); + size = properties1.size(); + + if (size != properties2.size()) + return false; + + // Equivalent Types have Properties of the same name and Type + + for (int i = 0; i < size; i++) { + property1 = (Property)properties1.get(i); + k = 0; + found = false; + + while (k < size && !found) { + // j is used to prevent the initial Properties in properties2 + // from being checked every time + // j is particularly useful when the Types have Properties in + // the order + + property2 = (Property)properties2.get((k + j) % size); + + if (property1.getName().equals(property2.getName())) { + j++; + found = true; + + // Should not use recursion here to compare the Types of the + // Properties, because + // it is possible that a Type may recursively contain + // itself. + + if (!(property1.getType().getName().equals(property2.getType().getName()))) + return false; + } + k++; + } + if (!found) + return false; + } + return true; + } + + /** + * Uses the XMLHelper to serialize the input DataObject + * + * @param dataObject + * @param baos + * @param helperContexgt + * @throws IOException + */ + public static void serializeDataObjectXML(DataObject dataObject, ByteArrayOutputStream baos, HelperContext helperContext) throws IOException { + Type type = dataObject.getType(); + helperContext.getXMLHelper().save(dataObject, type.getURI(), type.getName(), baos); + } + + /** + * Uses the XMLHelper to deserialize the input XML file + * + * @param bais + * @param helperContext + * @return + * @throws IOException + * @throws ClassNotFoundException + */ + public static DataObject deserializeDataObjectXML(ByteArrayInputStream bais, HelperContext helperContext) throws IOException, ClassNotFoundException { + return helperContext.getXMLHelper().load(bais).getRootObject(); + } + + /** + * Uses Java serialization to serialize the input DataObject + * + * @param dataObject + * @param baos + * @param helperContext + * @throws IOException + */ + public static void serializeDataObjectJava(TestHelper testHelper, DataObject dataObject, ByteArrayOutputStream baos, HelperContext helperContext) throws IOException { + ObjectOutputStream out = testHelper.createObjectOutputStream(baos, helperContext); + out.writeObject(dataObject); + out.close(); + } + + /** + * Uses Java deserialization to deserialize the input XML file + * + * @param bais + * @param helperContext + * @return + * @throws IOException + * @throws ClassNotFoundException + */ + public static DataObject deserializeDataObjectJava(TestHelper testHelper, ByteArrayInputStream bais, HelperContext helperContext) throws IOException, ClassNotFoundException { + ObjectInputStream input = testHelper.createObjectInputStream(bais, helperContext); + DataObject dataObject = (DataObject)input.readObject(); + input.close(); + return dataObject; + } + + + +} |