diff options
Diffstat (limited to 'sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/api/CopyHelper/CopyEqualityTest.java')
-rw-r--r-- | sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/api/CopyHelper/CopyEqualityTest.java | 148 |
1 files changed, 148 insertions, 0 deletions
diff --git a/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/api/CopyHelper/CopyEqualityTest.java b/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/api/CopyHelper/CopyEqualityTest.java new file mode 100644 index 0000000000..7c49576557 --- /dev/null +++ b/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/api/CopyHelper/CopyEqualityTest.java @@ -0,0 +1,148 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + * + * $Rev$ $Date$ + */ +package test.sdo21.tests.api.CopyHelper; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import test.sdo21.tests.TestData.StandardDynamicFactory; +import test.sdo21.tests.TestData.StandardFactory; +import test.sdo21.tests.TestData.StandardXSDFactory; +import test.sdo21.tests.TestData.TestDataFactory; +import test.sdo21.tests.api.CTSConsistencyBase; + +import commonj.sdo.DataObject; +import commonj.sdo.helper.EqualityHelper; + +/** + * TestCase tests shallow and deep copy functions of CopyHelper utilizing the + * EqualityHelper class. Can be used to test dynamic, mixed and static + * DataObjects + * TODO this would be better as a test of CopyHelper alone, having established + * EqualityHelper as a trusted base by independent testing. As it stands it + * does not identify whether issues exist in the copy helper or the equality helper + */ +public abstract class CopyEqualityTest extends CTSConsistencyBase { + private DataObject testDO; + + public CopyEqualityTest() { + } + + public static class DynamicMetadata extends CopyEqualityTest { + public DynamicMetadata() { + + } + public TestDataFactory createTestDataFactory() { + + return new StandardDynamicFactory(); + } + } + + public static class XSDMetadata extends CopyEqualityTest { + + public XSDMetadata() { + } + + public TestDataFactory createTestDataFactory() { + + return new StandardXSDFactory(); + } + } + + + @After + public void tearDown() throws Exception { + super.tearDown(); + } + + + @Before + public void setUp () throws Exception { + super.setUp(); + testDO = factory.createTestData(getScope(), StandardFactory.API_TYPE); + ((StandardFactory)factory).populateFields(testDO, getScope()); + } + + /** + * Performs a shallow copy and verifies that shallow equality is true + * between the source and output for the copy. + */ + @Test + public void testShallowCopyShallowEquality() { + assertNotNull("data object not created correctly", testDO); + DataObject shallowCopy = getScope().getCopyHelper().copyShallow(testDO); + + EqualityHelper equalityH = getScope().getEqualityHelper(); + + assertTrue("Shallow copy did not result in shallow equality", equalityH.equalShallow(testDO, shallowCopy)); + } + + /** + * Performs a shallow copy and verifies that deep equality is false + * (assuming passed DO includes a containment reference) between the source + * and output for the copy. + */ + @Test + public void testShallowCopyDeepEquality() { + assertNotNull("data object not created correctly", testDO); + DataObject shallowCopy = getScope().getCopyHelper().copyShallow(testDO); + + EqualityHelper equalityH = getScope().getEqualityHelper(); + + // TODO: Determine why Deep equality results when Type is sequenced. + + assertFalse("Shallow copy should not result in deep equality for this Type.", equalityH.equal(testDO, + shallowCopy)); + } + + /** + * Performs a deep copy and verifies that shallow equality exists between + * the source and output from the copy. + */ + @Test + public void testDeepCopyShallowEquality() { + assertNotNull("data object not created correctly", testDO); + DataObject deepCopy = getScope().getCopyHelper().copy(testDO); + + EqualityHelper equalityH = getScope().getEqualityHelper(); + + assertTrue("Deep copy did not result in shallow equality.", equalityH.equalShallow(testDO, deepCopy)); + } + + /** + * Performs a deep copy and verifies that deep equality exists between the + * source and output from the copy. + */ + @Test + public void testDeepCopyDeepEquality() { + assertNotNull("data object not created correctly", testDO); + DataObject deepCopy = getScope().getCopyHelper().copy(testDO); + + EqualityHelper equalityH = getScope().getEqualityHelper(); + + assertTrue("Deep copy did not result in deep equality.", equalityH.equal(testDO, deepCopy)); + } +} |