/******************************************************************************* | |
* Copyright (c) 1998, 2013 Oracle and/or its affiliates. All rights reserved. | |
* This program and the accompanying materials are made available under the | |
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 | |
* which accompanies this distribution. | |
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html | |
* and the Eclipse Distribution License is available at | |
* http://www.eclipse.org/org/documents/edl-v10.php. | |
* | |
* Contributors: | |
* Oracle - initial API and implementation from Oracle TopLink | |
******************************************************************************/ | |
/* | |
DESCRIPTION | |
Test SDOCopyHelper for deep and shallow copy | |
References: | |
SDO59-DeepCopy.doc | |
SDO_Ref_BiDir_Relationships_DesignSpec.doc | |
PRIVATE CLASSES | |
NOTES | |
MODIFIED (MM/DD/YY) | |
mfobrien 05/16/07 - | |
dmahar 04/23/07 - | |
mfobrien 07/31/06 - As part of the refactor of SDODataObject.properties <Map> into | |
the ValueStore interfaces, these tests require non-Map specific tests. | |
Currently testing is hardcoded to additional values() and keySet() functions | |
on our RI MapValueStore | |
dmahar 08/18/06 - | |
mfobrien 08/19/06 - Remove special handling - getProperties() has returned as a Pluggable interface | |
mfobrien 09/09/06 - Add bidirectional support to SDOCopyHelper - see SDO57/59 | |
mfobrien 09/18/06 - Subclass off common copy/equality testCases model | |
- Add bidirectional testcases for the following cases | |
- verify all properties that are bi-directional are type.dataType=false - spec 8.4 | |
- test bi-directional with one end at containment=true - spec 8.4 | |
- test bi-directional where both ends have the same value for readOnly = true - spec 8.4 | |
- test bi-directional where both ends have the same value for readOnly = false - spec 8.4 | |
- test bi-directional with containment where the non-containment Property has many=false. - spec 8.4 | |
mfobrien 03/19/07 - 5853175: bidirectional link between disjoint trees (as a result of an unset on one side) | |
are spec compliant and will result in inequality between an original and copy of the root | |
*/ | |
package org.eclipse.persistence.testing.sdo.helper.copyhelper; | |
import commonj.sdo.Type; | |
import java.util.HashSet; | |
import java.util.Iterator; | |
import java.util.List; | |
import java.util.Set; | |
import org.eclipse.persistence.sdo.SDOChangeSummary; | |
import org.eclipse.persistence.sdo.SDODataObject; | |
import org.eclipse.persistence.sdo.SDOProperty; | |
import org.eclipse.persistence.sdo.SDOType; | |
import org.eclipse.persistence.sdo.helper.ListWrapper; | |
import org.eclipse.persistence.sdo.helper.SDOCopyHelper; | |
import org.eclipse.persistence.sdo.helper.SDOTypeHelper; | |
import org.eclipse.persistence.testing.sdo.helper.SDOCopyEqualityHelperTestCases; | |
import commonj.sdo.ChangeSummary; | |
import commonj.sdo.DataObject; | |
import commonj.sdo.Property; | |
public class SDOCopyHelperDeepCopyTest extends SDOCopyEqualityHelperTestCases { | |
public SDOCopyHelperDeepCopyTest(String name) { | |
super(name); | |
} | |
public static void main(String[] args) { | |
junit.textui.TestRunner.run(SDOCopyHelperDeepCopyTest.class); | |
} | |
private int getPropertiesSize(SDODataObject anObject) { | |
int size = 0; | |
for (int i = 0; i < anObject.getInstanceProperties().size(); i++) { | |
Property next = (Property)anObject.getInstanceProperties().get(i); | |
if (anObject.isSet(next)) { | |
size++; | |
} | |
} | |
return size; | |
} | |
public SDOChangeSummary getChangeSummary() { | |
return null; | |
} | |
private Set getPropertiesKeySet(SDODataObject anObject) { | |
HashSet aSet = new HashSet(); | |
if (anObject != null) { | |
for (int i = 0; i < anObject.getType().getProperties().size(); i++) { | |
//boolean isSet = anObject.getTypePropertiesIsSetStatus()[i]; | |
boolean isSet = anObject.isSet(i); | |
if (isSet) { | |
aSet.add(((Property)anObject.getType().getProperties().get(i)).getName()); | |
} | |
} | |
for (int i = 0; i < anObject._getOpenContentProperties().size(); i++) { | |
aSet.add(((Property)anObject._getOpenContentProperties().get(i)).getName()); | |
} | |
return aSet; | |
} else { | |
return new HashSet(); | |
} | |
} | |
/** | |
* Spec 8.4 "Properties that are bi-directional require that no more than one end has containment=true" | |
* @param oppositeProperty1 | |
* @param oppositeProperty2 | |
* @return | |
*/ | |
private boolean areBothBidirectionalOppositePropertiesContainmentTrue(// | |
SDOProperty oppositeProperty1, SDOProperty oppositeProperty2) { | |
return oppositeProperty1.isContainment() && oppositeProperty2.isContainment(); | |
} | |
/** | |
* Test whether EqualityHelper.compareProperty() handles nested objects that are null but isSet=true | |
* (Where we also have a bidirectional child property) | |
* See SDOEqualityHelperTest for the same tests without the bidirectional child | |
* | |
* Disjoint trees can maintain a bidirectional link | |
* | |
* Results: This test will verify that the bidirectional property is left unchanged | |
* after an unset on its parent - in effect creating a nc link between 2 separate dataobject trees. | |
* See SDO_Ref_BiDir_Relationships_DesignSpec.doc section 4.2.2 | |
* See spec 3.1.7. If other DataObjects have one-way, non-containment properties that refer to deleted DataObjects, | |
* then these references are not modified. - we retain both sides of the bidirectional link here. | |
* See spec 3.1.7. However, these properties can need changing to other values, | |
* in order to restore closure to the data graph? - the implementer will need to be aware and fix any set/reset issues | |
* - the SDO API will not attempt to remove any of these NC references for deleted objects. | |
* No code changes are required because non-equality is expected in this case. | |
* Leaving a bidirectional property set between two trees that do not share a common root is not an invalid state (step 2 above) | |
* | |
* root | |
* rp2 -> cdo (unset this one - placing it outside the copy tree) | |
* cp2 -> cbcdo | |
* cbcp1 -> cdo1 (bidir) | |
* c1p3 -> cdo1 (bidir) | |
* cp3 -> cbcdo3 | |
* cpcs -> cs | |
* rp3 -> cdo1 | |
* c1p1 -> cbcdo (bidir) | |
* rp4 -> lw | |
*/ | |
public void testDeepCopyAfterUnsetComplexChildWithBidirectionalChild_generatingLinkedDisjointTrees() { | |
int aRootsize = preOrderTraversalDataObjectList(root).size(); | |
assertEquals(7, aRootsize); | |
// save cdo before we unset it | |
DataObject aCDO = (DataObject)root.get("rootproperty2-notdatatype"); | |
assertNotNull(aCDO); | |
int aCDOsize = preOrderTraversalDataObjectList((SDODataObject)aCDO).size(); | |
// save child of cdo | |
DataObject aCDO_CBCDO = (DataObject)aCDO.get("containedProperty2-notdataType"); | |
assertNotNull(aCDO_CBCDO); | |
int aCDO_CBCDOsize = preOrderTraversalDataObjectList((SDODataObject)aCDO_CBCDO).size(); | |
// save bidirectional partner of cdo | |
DataObject aCDO1 = (DataObject)root.get("rootproperty3-notdatatype"); | |
assertNotNull(aCDO1); | |
int aCDO1size = preOrderTraversalDataObjectList((SDODataObject)aCDO1).size(); | |
// get a list of nodes (NC references do not recursively iterate) | |
List<DataObject> rootPreOrderListBeforeUnset = preOrderTraversalDataObjectList(root); | |
assertNotNull(rootPreOrderListBeforeUnset); | |
assertEquals(aRootsize, rootPreOrderListBeforeUnset.size()); | |
rootPreOrderListBeforeUnset.contains(aCDO_CBCDO); | |
rootPreOrderListBeforeUnset.contains(aCDO1); | |
// NOTE: unset does not affect bidirectional properties between disjoint trees of dataObjects | |
// the remaining unidirectional property is left unaffected. | |
root.unset("rootproperty2-notdatatype"); | |
// verify that bidirectional property is still set | |
DataObject aCDO1_CBCDO = (DataObject)aCDO1.get("contained1Property1-notdataType"); | |
assertNotNull(aCDO1_CBCDO); | |
assertEquals(aCDO1_CBCDO, aCDO_CBCDO); | |
DataObject aCBCDO_CDO1 = (DataObject)aCDO_CBCDO.get("containedByContainedProperty1-notdataType"); | |
assertNotNull(aCBCDO_CDO1); | |
assertEquals(aCBCDO_CDO1, aCDO1); | |
// get a list of nodes (NC references do not recursively iterate) | |
List<DataObject> rootPreOrderListAfterUnset = preOrderTraversalDataObjectList(root); | |
assertNotNull(rootPreOrderListAfterUnset); | |
// 4 not 3 because we shallow iterate to the non-contaiment property c1p1 | |
assertEquals(aRootsize - aCDOsize, rootPreOrderListAfterUnset.size()); | |
rootPreOrderListAfterUnset.contains(aCDO_CBCDO); | |
rootPreOrderListAfterUnset.contains(aCDO1); | |
// get a list of nodes (NC references do not recursively iterate) | |
List<DataObject> cdoPreOrderListAfterUnset = preOrderTraversalDataObjectList((SDODataObject)aCDO); | |
assertNotNull(cdoPreOrderListAfterUnset); | |
// 4 not 3 because we shallow iterate to the non-contaiment property c1p1 | |
assertEquals(aCDOsize, cdoPreOrderListAfterUnset.size()); | |
cdoPreOrderListAfterUnset.contains(aCDO_CBCDO); | |
SDODataObject copyOfRoot = (SDODataObject)((SDOCopyHelper)copyHelper).copy(root, getChangeSummary()); | |
assertFalse(root.isSet("rootproperty2-notdatatype")); | |
assertNotNull(copyOfRoot); | |
DataObject aCDOc = (DataObject)copyOfRoot.get("rootproperty2-notdatatype"); | |
assertNull(aCDOc); | |
DataObject aCDO1c = (DataObject)copyOfRoot.get("rootproperty3-notdatatype"); | |
assertNotNull(aCDO1c); | |
int aCDO1sizec = preOrderTraversalDataObjectList((SDODataObject)aCDO1c).size(); | |
// 2 not 1 because the bidirectional property was not copied | |
assertEquals(1, aCDO1sizec); | |
// test copy helper results outside of equality helper (to keep equality helper issues outside of copyhelper testing) | |
// get non-containment property between original cdo1 and unset cdo/cbcdo | |
// verify that bidirectional property is not set on copy | |
DataObject aCDO1_CBCDOc = (DataObject)aCDO1c.get("contained1Property1-notdataType"); | |
assertNull(aCDO1_CBCDOc); | |
// lastly use equality helper to test copy helper | |
assertFalse(equalityHelper.equal(root, copyOfRoot)); | |
// we need a diff function on cs or equalityHelper to show us that aCDO (copy) is not on copyOfRoot | |
} | |
// see same comments for testDeepCopyAfterUnsetComplexChildWithBidirectionalChild_generatingLinkedDisjointTrees() above | |
public void testDeepCopyAfterSetNullComplexChildWithBidirectionalChild_generatingLinkedDisjointTrees() { | |
// clear complex child | |
root.set("rootproperty2-notdatatype", null); | |
SDODataObject copyOfRoot = (SDODataObject)((SDOCopyHelper)copyHelper).copy(root, getChangeSummary()); | |
assertFalse(root.isSet("rootproperty2-notdatatype")); | |
assertNotNull(copyOfRoot); | |
// this assertion previously failed before fix for #5852525 | |
assertFalse(equalityHelper.equal(root, copyOfRoot)); | |
} | |
// test R21 p44 3.9.4 For each Property where property.getType().isDataType() is false | |
// the value is copied if it is a DataObject contained by the source dataObject. | |
public void testR21P44Sect3_9_4_NonContainedDOsAreNotCopied() { | |
} | |
// test R22 p44 3.9.4 If a DataObject is outside the copy tree and the property is bidirectional then // | |
// the DataObject is not copied and references to the object are also not copied. | |
public void testR22P44Sect3_9_4_DOisOutsideCopyTreeWithBidirectionalPropertyNotCopied() { | |
// cdo/cbcdo (depth2) and cdo1 (depth1) are bidirectional with each other | |
// create copy of cdo1 and verify that cdo/cbcdo was not copied since it is outside the copy tree | |
SDODataObject copy = (SDODataObject)((SDOCopyHelper)copyHelper).copy(containedDataObject, getChangeSummary()); | |
// verify that container is null | |
assertNull(copy.getContainer()); | |
// get bidirectional node from the copy root | |
SDODataObject bidirCopyViaCopyRoot = (SDODataObject)copy.get(// | |
"containedProperty2-notdataType/containedByContainedProperty1-notdataType"); | |
assertNull(bidirCopyViaCopyRoot); | |
// get bidirectional start node via opposite property | |
SDODataObject bidirCopyStart = (SDODataObject)copy.get(// | |
"containedProperty2-notdataType"); | |
assertNotNull(bidirCopyStart); | |
// get property containing opposite property link (inside copy tree) | |
SDOProperty bidirCopyOppositeStartProp = (SDOProperty)bidirCopyStart.getType().getProperty(// | |
"containedByContainedProperty1-notdataType"); | |
assertNotNull(bidirCopyOppositeStartProp); | |
// Spec 8.4 "Properties that are bi-directional require type.dataType=false" | |
assertFalse(bidirCopyOppositeStartProp.getType().isDataType()); | |
// get bidir property outside of copy tree | |
SDOProperty bidirCopyViaOpposite = (SDOProperty)bidirCopyOppositeStartProp.getType()// | |
.getProperty("contained1Property1-notdataType"); | |
assertNull(bidirCopyViaOpposite); | |
SDODataObject bidirCopyViaOppositeDO = (SDODataObject)copy.get(// | |
"rootproperty3-notdatatype/contained1Property1-notdataType"); | |
assertNull(bidirCopyViaOppositeDO); | |
} | |
// test R23 p44 3.9.4 If a DataObject is outside the copy tree and the property is unidirectional then // | |
// the same DataObject is referenced. | |
public void testR23P44Sect3_9_4_DOisOutsideCopyTreeWithUnidirectionalPropertyThenSameDOreferenced() { | |
} | |
// we dont want changes to occur during the embedded set() calls in copy() | |
// this test needs a deeper model in order to fully test the bug see ChangeSummaryXSDWithCSonChildUndoTestCases.testDeepCopyObjectWithCSLoggingOnDoesNotLogChangesInTheDeepCopy() | |
public void testDeepCopyObjectWithCSLoggingOnDoesNotLogChangesInTheDeepCopy() { | |
// verify logging is on | |
assertNotNull(containedDataObject.getChangeSummary()); | |
assertTrue(containedDataObject.getChangeSummary().isLogging()); | |
//containedDataObject.getChangeSummary().endLogging(); | |
// take an object with CS on and deep copy it | |
SDODataObject copy = (SDODataObject)((SDOCopyHelper)copyHelper).copy(containedDataObject, getChangeSummary()); | |
//containedDataObject.getChangeSummary().beginLogging(); | |
// verify that logging is still on | |
assertTrue(containedDataObject.getChangeSummary().isLogging()); | |
assertTrue(copy.getChangeSummary().isLogging()); | |
ChangeSummary cs = copy.getChangeSummary(); | |
// verify that we have not logged changes during the copy | |
assertEquals(0, cs.getChangedDataObjects().size()); | |
} | |
// we dont want changes to occur during the embedded set() calls in copy() | |
// #5878436 12-FEB-07 do not recurse into a non-containment relationship | |
public void testNoInfiniteLoopTurningLoggingBackOnAfterADeepCopyObjectWithCSLoggingOff() { | |
// verify logging is on | |
assertNotNull(containedDataObject.getChangeSummary()); | |
assertTrue(containedDataObject.getChangeSummary().isLogging()); | |
containedDataObject.getChangeSummary().endLogging(); | |
// take an object with CS on and deep copy it | |
SDODataObject copy = (SDODataObject)((SDOCopyHelper)copyHelper).copy(containedDataObject, getChangeSummary()); | |
containedDataObject.getChangeSummary().beginLogging();// infinite loop on resetChanges() | |
} | |
public void testUC010xDeepCopy1_1BidirectionalPropOutsideCopyTreeNotCopied() { | |
// cdo/cbcdo (depth2) and cdo1 (depth1) are bidirectional with each other | |
// create copy of cdo1 and verify that cdo/cbcdo was not copied since it is outside the copy tree | |
SDODataObject copy = (SDODataObject)((SDOCopyHelper)copyHelper).copy(containedDataObject, getChangeSummary()); | |
// verify that container is null | |
assertNull(copy.getContainer()); | |
// get bidirectional node from the copy root | |
SDODataObject bidirCopyViaCopyRoot = (SDODataObject)copy.get(// | |
"containedProperty2-notdataType/containedByContainedProperty1-notdataType"); | |
assertNull(bidirCopyViaCopyRoot); | |
// get bidirectional start node via opposite property | |
SDODataObject bidirCopyStart = (SDODataObject)copy.get(// | |
"containedProperty2-notdataType"); | |
assertNotNull(bidirCopyStart); | |
// get property containing opposite property link (inside copy tree) | |
SDOProperty bidirCopyOppositeStartProp = (SDOProperty)bidirCopyStart.getType().getProperty(// | |
"containedByContainedProperty1-notdataType"); | |
assertNotNull(bidirCopyOppositeStartProp); | |
// Spec 8.4 "Properties that are bi-directional require type.dataType=false" | |
assertFalse(bidirCopyOppositeStartProp.getType().isDataType()); | |
// get bidir property outside of copy tree | |
SDOProperty bidirCopyViaOpposite = (SDOProperty)bidirCopyOppositeStartProp.getType()// | |
.getProperty("contained1Property1-notdataType"); | |
assertNull(bidirCopyViaOpposite); | |
SDODataObject bidirCopyViaOppositeDO = (SDODataObject)copy.get(// | |
"rootproperty3-notdatatype/contained1Property1-notdataType"); | |
assertNull(bidirCopyViaOppositeDO); | |
} | |
public void testUC030xDeepCopy1_1BidirectionalPropInsideCopyTreeCopiedContTreeSameAsCopyTree() { | |
// cdo/cbcdo (depth2) and cdo1 (depth1) are bidirectional with each other | |
// create copy of the root and verifyt that both cdo1 and cdo/cbcdo were both copied as they are inside the copy tree | |
SDODataObject copy = (SDODataObject)((SDOCopyHelper)copyHelper).copy(root, getChangeSummary()); | |
// verify that container is null | |
assertNull(copy.getContainer()); | |
// get bidirectional node from the copy root (direction 1) | |
SDODataObject bidirCopyViaCopyRoot = (SDODataObject)copy.get(// | |
"rootproperty2-notdatatype/containedProperty2-notdataType/containedByContainedProperty1-notdataType"); | |
assertNotNull(bidirCopyViaCopyRoot); | |
// get bidirectional start node via opposite property | |
SDODataObject bidirCopyStart = (SDODataObject)copy.get(// | |
"rootproperty2-notdatatype/containedProperty2-notdataType"); | |
assertNotNull(bidirCopyStart); | |
// verify changeSummary is set on opposites | |
ChangeSummary aCS2 = bidirCopyStart.getChangeSummary(); | |
assertNotNull(aCS2); | |
// get property containing opposite property link (inside copy tree) | |
SDOProperty bidirCopyOppositeStartProp = (SDOProperty)bidirCopyStart.getType().getProperty(// | |
"containedByContainedProperty1-notdataType"); | |
assertNotNull(bidirCopyOppositeStartProp); | |
// Spec 8.4 "Properties that are bi-directional require type.dataType=false" | |
assertFalse(bidirCopyOppositeStartProp.getType().isDataType()); | |
// get bidir property inside copy tree | |
SDOProperty oppositeEndProp = (SDOProperty)((SDODataObject)copy.get(// | |
"rootproperty3-notdatatype")).getType().getProperty("contained1Property1-notdataType").getOpposite(); | |
assertNotNull(oppositeEndProp); | |
// Spec 8.4 "Properties that are bi-directional require type.dataType=false" | |
assertFalse(oppositeEndProp.getType().isDataType()); | |
// get opposite DO (direction 2) | |
SDODataObject bidirCopyViaOppositeDO = (SDODataObject)copy.get(// | |
"rootproperty3-notdatatype/contained1Property1-notdataType"); | |
assertNotNull(bidirCopyViaOppositeDO); | |
// verify changeSummary is set on opposites | |
ChangeSummary aCS1 = bidirCopyViaOppositeDO.getChangeSummary(); | |
assertNotNull(aCS1); | |
// Constraint C3 - Spec 3.9.4 | |
// verify there are no object pointers between source and copy (all objects are instance independent) | |
// ie: a' != a - or there are no references to "root" from "copy" | |
assertNotSame((SDODataObject)root.get("rootproperty2-notdatatype/containedProperty2-notdataType"),// | |
(SDODataObject)copy.get("rootproperty2-notdatatype/containedProperty2-notdataType")); | |
assertNotSame((SDODataObject)root.get("rootproperty3-notdatatype"),// | |
(SDODataObject)copy.get("rootproperty3-notdatatype")); | |
assertNotSame((SDODataObject)root.get(// | |
"rootproperty2-notdatatype/containedProperty2-notdataType/containedByContainedProperty1-notdataType"),// | |
(SDODataObject)copy.get("//" +// | |
"rootproperty2-notdatatype/containedProperty2-notdataType/containedByContainedProperty1-notdataType")); | |
// Spec 8.4 "Properties that are bi-directional require that no more than one end has containment=true" | |
assertFalse(areBothBidirectionalOppositePropertiesContainmentTrue(// | |
bidirCopyOppositeStartProp, oppositeEndProp)); | |
} | |
public void testUC0302DeepCopy1_1BidirectionalPropInsideCopyTreeCopiedContTreeSameAsCopyTree() { | |
// create copy of the root | |
SDODataObject copy = (SDODataObject)((SDOCopyHelper)copyHelper).copy(rootUC4, getChangeSummary()); | |
// verify that container is null | |
assertNull(copy.getContainer()); | |
// get bidirectional node from the copy root (direction 1) | |
SDODataObject bidirCopyViaCopyRoot = (SDODataObject)copy.get(// | |
"rootHome/homeAddress/addressWork"); | |
assertNotNull(bidirCopyViaCopyRoot); | |
// get bidirectional start node via opposite property | |
SDODataObject bidirCopyStart = (SDODataObject)copy.get(// | |
"rootHome/homeAddress"); | |
assertNotNull(bidirCopyStart); | |
// verify changeSummary is set on opposites | |
//ChangeSummary aCS2 = bidirCopyStart.getChangeSummary(); | |
//assertNotNull(aCS2); | |
// get property containing opposite property link (inside copy tree) | |
SDOProperty bidirCopyOppositeStartProp = (SDOProperty)bidirCopyStart.getType().getProperty(// | |
"addressWork"); | |
assertNotNull(bidirCopyOppositeStartProp); | |
// Spec 8.4 "Properties that are bi-directional require type.dataType=false" | |
assertFalse(bidirCopyOppositeStartProp.getType().isDataType()); | |
// get bidir property inside copy tree | |
SDOProperty oppositeEndProp = (SDOProperty)((SDODataObject)copy.get(// | |
"rootWork")).getType().getProperty("workAddress").getOpposite(); | |
assertNotNull(oppositeEndProp); | |
// Spec 8.4 "Properties that are bi-directional require type.dataType=false" | |
assertFalse(oppositeEndProp.getType().isDataType()); | |
// get opposite DO (direction 2) | |
SDODataObject bidirCopyViaOppositeDO = (SDODataObject)copy.get(// | |
"rootWork/workAddress"); | |
assertNotNull(bidirCopyViaOppositeDO); | |
// verify changeSummary is set on opposites | |
//ChangeSummary aCS1 = bidirCopyViaOppositeDO.getChangeSummary(); | |
//assertNotNull(aCS1); | |
// Constraint C3 - Spec 3.9.4 | |
// verify there are no object pointers between source and copy (all objects are instance independent) | |
// ie: a' != a - or there are no references to "root" from "copy" | |
assertNotSame((SDODataObject)rootUC4.get("rootHome/homeAddress"),// | |
(SDODataObject)copy.get("rootHome/homeAddress")); | |
assertNotSame((SDODataObject)rootUC4.get("rootWork"),// | |
(SDODataObject)copy.get("rootWork")); | |
assertNotSame((SDODataObject)rootUC4.get(// | |
"rootHome/homeAddress/addressWork"),// | |
(SDODataObject)copy.get("//" +// | |
"rootHome/homeAddress/addressWork")); | |
// Spec 8.4 "Properties that are bi-directional require that no more than one end has containment=true" | |
assertFalse(areBothBidirectionalOppositePropertiesContainmentTrue(// | |
bidirCopyOppositeStartProp, (SDOProperty)bidirCopyOppositeStartProp.getOpposite())); | |
} | |
// bidirectional property target is cached during containment iteration | |
public void testUC0312DeepCopy1_nBidirectionalPropInsideCopyTreeCopiedContTreeSameAsCopyTree2ndNodeIsMany() { | |
// set containment so that the bidirectional target is cached | |
rootWorkm.setContainment(true); | |
// create copy of the root | |
SDODataObject copy = (SDODataObject)((SDOCopyHelper)copyHelper).copy(rootUC4m, getChangeSummary()); | |
// verify that container is null | |
assertNull(copy.getContainer()); | |
// get bidirectional node from the copy root (direction 1) | |
ListWrapper bidirCopyViaCopyRoot = (ListWrapper)copy.get(// | |
"rootHome/homeAddress/addressWork"); | |
assertNotNull(bidirCopyViaCopyRoot); | |
// get bidirectional start node via opposite property | |
SDODataObject bidirCopyStart = (SDODataObject)copy.get(// | |
"rootHome/homeAddress"); | |
assertNotNull(bidirCopyStart); | |
// verify changeSummary is set on opposites | |
//ChangeSummary aCS2 = bidirCopyStart.getChangeSummary(); | |
//assertNotNull(aCS2); | |
// get property containing opposite property link (inside copy tree) | |
SDOProperty bidirCopyOppositeStartProp = (SDOProperty)bidirCopyStart.getType().getProperty(// | |
"addressWork"); | |
assertNotNull(bidirCopyOppositeStartProp); | |
// Spec 8.4 "Properties that are bi-directional require type.dataType=false" | |
assertFalse(bidirCopyOppositeStartProp.getType().isDataType()); | |
// get bidir property inside copy tree | |
SDOProperty oppositeEndProp = (SDOProperty)((SDODataObject)copy.get(// | |
"rootHome/homeAddress")).getType().getProperty("addressWork");//.getOpposite(); | |
assertNotNull(oppositeEndProp); | |
// Spec 8.4 "Properties that are bi-directional require type.dataType=false" | |
assertFalse(oppositeEndProp.getType().isDataType()); | |
// get opposite DO (direction 2) | |
SDODataObject bidirCopyViaOppositeDO = (SDODataObject)copy.get(// | |
"rootWork/workAddress"); | |
//assertNotNull(bidirCopyViaOppositeDO); | |
// verify changeSummary is set on opposites | |
//ChangeSummary aCS1 = bidirCopyViaOppositeDO.getChangeSummary(); | |
//assertNotNull(aCS1); | |
// Constraint C3 - Spec 3.9.4 | |
// verify there are no object pointers between source and copy (all objects are instance independent) | |
// ie: a' != a - or there are no references to "root" from "copy" | |
assertNotSame((SDODataObject)rootUC4m.get("rootHome/homeAddress"),// | |
(SDODataObject)copy.get("rootHome/homeAddress")); | |
// verify isMany objects are distinct | |
ListWrapper do1 = (ListWrapper)rootUC4m.get("rootWork"); | |
ListWrapper do2 = (ListWrapper)copy.get("rootWork"); | |
// verify we are not just getting back empty lists for a null object lookup | |
assertTrue(do1.size() > 0); | |
assertTrue(do2.size() > 0); | |
// verify lists are different (shallow check) | |
assertNotSame(do1, do2); | |
// verify list elements are different (deep check) | |
assertNotNull(do1.get(0)); | |
assertNotNull(do2.get(0)); | |
assertFalse(do1.get(0) == do2.get(0)); | |
//assertNotSame((SDODataObject)rootUC4m.get(// | |
//"rootHome/homeAddress/addressWork"),// | |
// (SDODataObject)copy.get("//" +// | |
// "rootHome/homeAddress/addressWork")); | |
// Spec 8.4 "Properties that are bi-directional require that no more than one end has containment=true" | |
assertFalse(areBothBidirectionalOppositePropertiesContainmentTrue(// | |
bidirCopyOppositeStartProp, (SDOProperty)bidirCopyOppositeStartProp.getOpposite())); | |
} | |
// bidirectional property target is not cached during containment iteration - original unidirectional is cached | |
public void testUC0313DeepCopy1_nBidirectionalPropInsideCopyTreeCopiedContTreeSameAsCopyTree2ndNodeIsManyNotPreCached() { | |
// set containment so that the bidirectional target is notcached | |
rootWorkm.setContainment(false); | |
// create copy of the root | |
SDODataObject copy = (SDODataObject)((SDOCopyHelper)copyHelper).copy(rootUC4m, getChangeSummary()); | |
// verify that container is null | |
assertNull(copy.getContainer()); | |
// get bidirectional node from the copy root (direction 1) | |
ListWrapper bidirCopyViaCopyRoot = (ListWrapper)copy.get(// | |
"rootHome/homeAddress/addressWork"); | |
assertNotNull(bidirCopyViaCopyRoot); | |
// get bidirectional start node via opposite property | |
SDODataObject bidirCopyStart = (SDODataObject)copy.get(// | |
"rootHome/homeAddress"); | |
assertNotNull(bidirCopyStart); | |
// verify changeSummary is set on opposites | |
//ChangeSummary aCS2 = bidirCopyStart.getChangeSummary(); | |
//assertNotNull(aCS2); | |
// get property containing opposite property link (inside copy tree) | |
SDOProperty bidirCopyOppositeStartProp = (SDOProperty)bidirCopyStart.getType().getProperty(// | |
"addressWork"); | |
assertNotNull(bidirCopyOppositeStartProp); | |
// Spec 8.4 "Properties that are bi-directional require type.dataType=false" | |
assertFalse(bidirCopyOppositeStartProp.getType().isDataType()); | |
// get bidir property inside copy tree | |
SDOProperty oppositeEndProp = (SDOProperty)((SDODataObject)copy.get(// | |
"rootHome/homeAddress")).getType().getProperty("addressWork");//.getOpposite(); | |
assertNotNull(oppositeEndProp); | |
// Spec 8.4 "Properties that are bi-directional require type.dataType=false" | |
assertFalse(oppositeEndProp.getType().isDataType()); | |
// get opposite DO (direction 2) | |
SDODataObject bidirCopyViaOppositeDO = (SDODataObject)copy.get(// | |
"rootWork/workAddress"); | |
//assertNotNull(bidirCopyViaOppositeDO); | |
// verify changeSummary is set on opposites | |
//ChangeSummary aCS1 = bidirCopyViaOppositeDO.getChangeSummary(); | |
//assertNotNull(aCS1); | |
// Constraint C3 - Spec 3.9.4 | |
// verify there are no object pointers between source and copy (all objects are instance independent) | |
// ie: a' != a - or there are no references to "root" from "copy" | |
assertNotSame((SDODataObject)rootUC4m.get("rootHome/homeAddress"),// | |
(SDODataObject)copy.get("rootHome/homeAddress")); | |
// verify isMany objects are distinct | |
ListWrapper do1 = (ListWrapper)rootUC4m.get("rootWork"); | |
ListWrapper do2 = (ListWrapper)copy.get("rootWork"); | |
// verify we are not just getting back empty lists for a null object lookup | |
assertTrue(do1.size() > 0); | |
assertTrue(do2.size() > 0); | |
// verify lists are different (shallow check) | |
assertNotSame(do1, do2); | |
// verify list elements are different (deep check) | |
assertNotNull(do1.get(0)); | |
assertNotNull(do2.get(0)); | |
// the unidirectional property rootWork gives us the original list in the copy | |
assertTrue(do1.get(0) == do2.get(0)); | |
//assertNotSame((SDODataObject)rootUC4m.get(// | |
//"rootHome/homeAddress/addressWork"),// | |
// (SDODataObject)copy.get("//" +// | |
// "rootHome/homeAddress/addressWork")); | |
// Spec 8.4 "Properties that are bi-directional require that no more than one end has containment=true" | |
assertFalse(areBothBidirectionalOppositePropertiesContainmentTrue(// | |
bidirCopyOppositeStartProp, (SDOProperty)bidirCopyOppositeStartProp.getOpposite())); | |
} | |
// bidirectional property target is not cached during containment iteration - it is unset | |
public void testUC0314DeepCopy1_nBidirectionalPropInsideCopyTreeCopiedContTreeSameAsCopyTree2ndNodeIsMany_unidirectionalUnset() { | |
// set containment so that the bidirectional target is notcached | |
//rootWorkm.setContainment(false); | |
rootUC4m.unset(rootWorkm); | |
// create copy of the root | |
SDODataObject copy = (SDODataObject)((SDOCopyHelper)copyHelper).copy(rootUC4m, getChangeSummary()); | |
// verify that container is null | |
assertNull(copy.getContainer()); | |
// get bidirectional node from the copy root (direction 1) | |
ListWrapper bidirCopyViaCopyRoot = (ListWrapper)copy.get(// | |
"rootHome/homeAddress/addressWork"); | |
assertNotNull(bidirCopyViaCopyRoot); | |
// get bidirectional start node via opposite property | |
SDODataObject bidirCopyStart = (SDODataObject)copy.get(// | |
"rootHome/homeAddress"); | |
assertNotNull(bidirCopyStart); | |
// verify changeSummary is set on opposites | |
//ChangeSummary aCS2 = bidirCopyStart.getChangeSummary(); | |
//assertNotNull(aCS2); | |
// get property containing opposite property link (inside copy tree) | |
SDOProperty bidirCopyOppositeStartProp = (SDOProperty)bidirCopyStart.getType().getProperty(// | |
"addressWork"); | |
assertNotNull(bidirCopyOppositeStartProp); | |
// Spec 8.4 "Properties that are bi-directional require type.dataType=false" | |
assertFalse(bidirCopyOppositeStartProp.getType().isDataType()); | |
// get bidir property inside copy tree | |
SDOProperty oppositeEndProp = (SDOProperty)((SDODataObject)copy.get(// | |
"rootHome/homeAddress")).getType().getProperty("addressWork");//.getOpposite(); | |
assertNotNull(oppositeEndProp); | |
// Spec 8.4 "Properties that are bi-directional require type.dataType=false" | |
assertFalse(oppositeEndProp.getType().isDataType()); | |
// get opposite DO (direction 2) | |
SDODataObject bidirCopyViaOppositeDO = (SDODataObject)copy.get(// | |
"rootWork/workAddress"); | |
//assertNotNull(bidirCopyViaOppositeDO); | |
// verify changeSummary is set on opposites | |
//ChangeSummary aCS1 = bidirCopyViaOppositeDO.getChangeSummary(); | |
//assertNotNull(aCS1); | |
// Constraint C3 - Spec 3.9.4 | |
// verify there are no object pointers between source and copy (all objects are instance independent) | |
// ie: a' != a - or there are no references to "root" from "copy" | |
assertNotSame((SDODataObject)rootUC4m.get("rootHome/homeAddress"),// | |
(SDODataObject)copy.get("rootHome/homeAddress")); | |
// verify isMany objects are distinct | |
ListWrapper do1 = (ListWrapper)rootUC4m.get("rootWork"); | |
ListWrapper do2 = (ListWrapper)copy.get("rootWork"); | |
// Verify that bidirectional outside the copytree is not set | |
assertTrue(do2.size() == 0); | |
assertTrue(do1.size() == 0); | |
// verify lists are different (shallow check) | |
assertNotSame(do1, do2); | |
// verify list elements are different (deep check) | |
assertNull(do2.get(0)); | |
assertNull(do1.get(0)); | |
// the unidirectional property rootWork (unset) gives us no copy of the list | |
//assertFalse(do1.get(0) == do2.get(0)); | |
//assertNotSame((SDODataObject)rootUC4m.get(// | |
//"rootHome/homeAddress/addressWork"),// | |
// (SDODataObject)copy.get("//" +// | |
// "rootHome/homeAddress/addressWork")); | |
// Spec 8.4 "Properties that are bi-directional require that no more than one end has containment=true" | |
assertFalse(areBothBidirectionalOppositePropertiesContainmentTrue(// | |
bidirCopyOppositeStartProp, (SDOProperty)bidirCopyOppositeStartProp.getOpposite())); | |
} | |
public void testUC0102DeepCopy1_1BidirectionalPropSubTreeOutsideCopyTreeNotCopied() { | |
// create copy of home and verify that rw was not copied since it is outside the copy tree | |
SDODataObject copy = (SDODataObject)((SDOCopyHelper)copyHelper).copy(homeObject, getChangeSummary()); | |
// verify that container is null | |
assertNull(copy.getContainer()); | |
// get bidirectional node from the copy root | |
SDODataObject bidirCopyViaCopyRoot = (SDODataObject)copy.get(// | |
"homeAddress/addressWork"); | |
assertNotNull(bidirCopyViaCopyRoot); | |
// get bidirectional start node via opposite property | |
SDODataObject bidirCopyStart = (SDODataObject)copy.get(// | |
"homeAddress"); | |
assertNotNull(bidirCopyStart); | |
// get property containing opposite property link (inside copy tree) | |
SDOProperty bidirCopyOppositeStartProp = (SDOProperty)bidirCopyStart.getType().getProperty(// | |
"addressWork"); | |
assertNotNull(bidirCopyOppositeStartProp); | |
// Spec 8.4 "Properties that are bi-directional require type.dataType=false" | |
assertFalse(bidirCopyOppositeStartProp.getType().isDataType()); | |
// get bidir property outside of copy tree | |
SDOProperty bidirCopyViaOpposite = (SDOProperty)bidirCopyOppositeStartProp.getType()// | |
.getProperty("workAddress"); | |
assertNull(bidirCopyViaOpposite); | |
SDODataObject bidirCopyViaOppositeDO = (SDODataObject)copy.get(// | |
"rootWork/workAddress"); | |
assertNull(bidirCopyViaOppositeDO); | |
} | |
// purpose: copy and source reference same type and properties | |
// TODO: 20060906 bidirectional/reference | |
public void testCopySourceHaveSameType() { | |
SDODataObject copy = (SDODataObject)((SDOCopyHelper)copyHelper).copy(root, getChangeSummary()); | |
assertFalse(copy.equals(root)); | |
assertEquals(copy.getType(), root.getType()); | |
assertEqualityHelperEqual(root, copy); | |
} | |
// purpose: copy and source have same map if source has no properties having not null opposite | |
// or if source has but these properties are not set. | |
// TODO: this tests only tests the MapValueStore impl, separate generic test required | |
public void testCopySourceHaveSameMap() { | |
SDODataObject copy = (SDODataObject)((SDOCopyHelper)copyHelper).copy(root, getChangeSummary()); | |
int copySize = getPropertiesSize(copy); | |
assertEquals(copySize, getPropertiesSize(root)); | |
testCopySourceMap(root, copy); | |
assertEqualityHelperEqual(root, copy); | |
} | |
// recursively compare source and copy DataObjects when they both contain othe DataObject | |
// otherwise, just compare their primitive value and containment properties in the map | |
// purpose: test case 1 and test case 2 : in tree dataobject and datatype value | |
// TODO: this tests only tests the MapValueStore impl, separate generic test required | |
private void testCopySourceMap(SDODataObject source, SDODataObject copy) { | |
assertFalse(source.equals(copy));// make sure copy source are not the same object | |
Set copyKeys = getPropertiesKeySet(copy); | |
Set keys = getPropertiesKeySet(source); | |
Iterator iterKeys = copyKeys.iterator(); | |
while (iterKeys.hasNext()) { | |
String propertyName = (String)iterKeys.next(); | |
assertTrue(keys.contains(propertyName)); | |
Object s = source.get(propertyName); | |
Object c = copy.get(propertyName); | |
Property cProperty = copy.getInstanceProperty(propertyName); | |
if (!(c instanceof SDODataObject) && !(c instanceof SDOChangeSummary) &&// | |
!cProperty.isMany()) { | |
assertEquals(c, s);// DataType, then value should equals | |
} else { | |
if (c instanceof SDODataObject) { | |
if (cProperty.isContainment()) { | |
testCopySourceMap((SDODataObject)s, (SDODataObject)c);// contained DataObject, recursive | |
} | |
} | |
if (c instanceof SDOChangeSummary) {// ChangeSummary Type | |
assertEquals(((SDOChangeSummary)c).isLogging(),// | |
((SDOChangeSummary)s).isLogging()); | |
assertEquals(copy, ((SDOChangeSummary)c).getRootObject()); | |
} | |
if (cProperty.isMany()) { | |
Iterator iterList = ((List)c).iterator(); | |
int i = 0; | |
while (iterList.hasNext()) { | |
SDODataObject cO = (SDODataObject)iterList.next(); | |
SDODataObject sO = (SDODataObject)((List)s).get(i); | |
testCopySourceMap(sO, cO); | |
i++; | |
} | |
} | |
} | |
} | |
} | |
// purpose: source add a new not containment property with null opposite and set its value, | |
// then copy and source should still have same map. | |
// Test case 4: unidirectional | |
// TODO: this tests only tests the DefaultValueStore impl, separate generic test required | |
// TODO: 20060906 bidirectional/reference | |
public void testUnidirectionalOutsideCopyTreeReferencesSameDO() { | |
// set this property value to containedDataObject | |
//root.set("rootProperty_NotContainment", containedDataObject); | |
SDODataObject copyOriginal = (SDODataObject)rootUCUniOutside.get("rootHome"); | |
SDODataObject copy = (SDODataObject)((SDOCopyHelper)copyHelper).copy(copyOriginal, getChangeSummary()); | |
int copySize = getPropertiesSize(copy); | |
assertTrue(copySize == getPropertiesSize(copyOriginal)); | |
// unidirectional, reference the same DataObject outside the tree | |
// Constraint C4 - Spec 3.9.4 | |
assertTrue(copy.get("rootWork") == copyOriginal.get("rootWork")); | |
assertEqualityHelperEqual(copyOriginal, copy); | |
} | |
public void testUnidirectionalInsideCopyTreeReferencesCopyDO() { | |
// set this property value to containedDataObject | |
root.set("rootProperty_NotContainment", containedDataObject); | |
SDODataObject copy = (SDODataObject)((SDOCopyHelper)copyHelper).copy(root, getChangeSummary()); | |
int copySize = getPropertiesSize(copy); | |
assertTrue(copySize == getPropertiesSize(root)); | |
// unidirectional, reference the the copy DataObject inside the tree | |
// Constraint C4 - Spec 3.9.4 | |
assertTrue(copy.get("rootProperty_NotContainment") != root.get("rootProperty_NotContainment")); | |
assertEqualityHelperEqual(root, copy); | |
} | |
// purpose: test case 6 about changesummary | |
public void testSourceHasPropertyWithChangeSummaryValue() { | |
SDODataObject copy = (SDODataObject)((SDOCopyHelper)copyHelper).copy(root, getChangeSummary()); | |
SDODataObject copyContainedDataObject = (SDODataObject)copy.get(rootProperty2.getName()); | |
assertEqualityHelperEqual(root, copy); | |
assertNotNull(copyContainedDataObject); | |
SDOChangeSummary copyChSum = (SDOChangeSummary)copyContainedDataObject.get(containedProperty_ChangeSummary.getName()); | |
assertNotNull(copyChSum); | |
ChangeSummary originalChSum = root.getDataObject("rootproperty2-notdatatype").getChangeSummary(); | |
assertFalse(copyChSum.equals(originalChSum)); | |
assertEquals(originalChSum.isLogging(), copyChSum.isLogging());// logging status is same | |
// their root dataObject have the same setting | |
testCopySourceMap(containedDataObject, (SDODataObject)copyChSum.getRootObject()); | |
} | |
// Test case 3: for bidirectional property, skip it and no value will be referenced or copied. | |
// TODO: 20060906 bidirectional/reference | |
public void testBiDirectionalRelationInDeepCopy() { | |
SDODataObject copyRoot = (SDODataObject)((SDOCopyHelper)copyHelper).copy(root, getChangeSummary()); | |
SDODataObject copyContainedByContainedDataObject = (SDODataObject)copyRoot// | |
.get("rootproperty2-notdatatype/containedProperty2-notdataType"); | |
assertNotNull(copyContainedByContainedDataObject); | |
assertFalse(copyContainedByContainedDataObject.equals(containedDataObject));// make sure not the same | |
SDODataObject oppositeObject = (SDODataObject)copyContainedByContainedDataObject// | |
.get("containedByContainedProperty1-notdataType"); | |
//assertNull(oppositeObject); | |
assertNotNull(oppositeObject);// 20060906: bidirectional support added | |
SDODataObject copyContainedDataObject1 = (SDODataObject)copyRoot.get(rootProperty3); | |
assertNotNull(copyContainedDataObject1); | |
assertFalse(copyContainedDataObject1.equals(containedDataObject1)); | |
SDODataObject oppositeObject1 = (SDODataObject)copyContainedDataObject1// | |
.get(contained1Property1); | |
//assertNull(oppositeObject1); | |
assertNotNull(oppositeObject1);// 20060906: bidirectional support added | |
assertEqualityHelperEqual(root, copyRoot); | |
} | |
// purpose: test case 5: not in containment tree | |
public void testDataObjectNotInContainmentTree() { | |
// create DataObject dataObjectNotInTreeroot contains another not in tree DataObject | |
// dataObjectNotInTree | |
SDOType notInTreeRootType = new SDOType((SDOTypeHelper) aHelperContext.getTypeHelper()); | |
SDOProperty notInTreeProperty = new SDOProperty(aHelperContext); | |
notInTreeProperty.setName("notInTreeProperty"); | |
SDOType notInTreePropertyType = new SDOType((SDOTypeHelper) aHelperContext.getTypeHelper()); | |
notInTreePropertyType.setDataType(false); | |
notInTreeProperty.setContainment(true); | |
notInTreeProperty.setType(notInTreePropertyType); | |
notInTreeRootType.addDeclaredProperty(notInTreeProperty); | |
//SDODataObject dataObjectNotInTree = new SDODataObject(); | |
SDODataObject dataObjectNotInTree = (SDODataObject)dataFactory.create(notInTreeRootType); | |
SDODataObject dataObjectNotInTreeroot = (SDODataObject)dataFactory.create(notInTreeRootType); | |
dataObjectNotInTreeroot.set(notInTreeProperty, dataObjectNotInTree); | |
// set dataObjectNotInTree as not containment property's value | |
containedByContainedDataObject.set(containedByContainedProperty2, dataObjectNotInTree); | |
SDODataObject copyRoot = null; | |
try { | |
copyRoot = (SDODataObject)((SDOCopyHelper)copyHelper).copy(root, getChangeSummary()); | |
//fail("IllegalArgumentException should be thrown."); | |
} catch (IllegalArgumentException e) { | |
assertNull(copyRoot); | |
} | |
} | |
// purpose: negative test by passed in null value | |
public void testCopyWithNullValue() { | |
DataObject source = null; | |
DataObject o = ((SDOCopyHelper)copyHelper).copy(source, getChangeSummary()); | |
assertNull(o); | |
} | |
// purpose: test containment property is many | |
public void testCopyWithContainmentPropertyIsMany() { | |
SDODataObject c = (SDODataObject)((SDOCopyHelper)copyHelper).copy(root, getChangeSummary()); | |
assertEqualityHelperEqual(root, c); | |
List cL = (List)c.get(rootProperty4); | |
List sL = (List)root.get(rootProperty4); | |
assertFalse(cL == sL); | |
assertTrue(cL.size() == sL.size()); | |
// check that items in the copied list are distinct objects from their original - same as !.equals | |
assertNotNull(sL.get(0)); | |
assertNotNull(cL.get(0)); | |
assertFalse(sL.get(0) == cL.get(0)); | |
testCopySourceMap(root, c); | |
} | |
// purpose: test non-containment property is many (unidirectional) | |
public void testCopyWithNotContainmentPropertyIsMany() { | |
rootProperty4.setContainment(false); | |
SDODataObject c = (SDODataObject)((SDOCopyHelper)copyHelper).copy(root, getChangeSummary()); | |
assertEqualityHelperEqual(root, c); | |
List cL = (List)c.get(rootProperty4); | |
List sL = (List)root.get(rootProperty4); | |
assertFalse(cL == sL); | |
//System.out.println(cL.size()); | |
assertTrue(sL.size() > 0); | |
assertEquals(sL.size(), cL.size()); | |
assertEquals(sL.get(0), cL.get(0)); | |
// check that items in the copied list are not distinct objects from their original - same as .equals | |
assertTrue(sL.get(0) == cL.get(0)); | |
} | |
// purpose: test containment property is many | |
public void testCopyWithNotContainmentPropertyIsManyValueNotInTree() { | |
Type testType = new SDOType("uri", "name"); | |
SDODataObject test = (SDODataObject)dataFactory.create(testType); | |
objects.add(test); | |
root.set(rootProperty4, objects); | |
rootProperty4.setContainment(false); | |
//rootProperty4.setContainment(true); | |
test._setContainer(null); | |
SDODataObject c = null; | |
try { | |
c = (SDODataObject)((SDOCopyHelper)copyHelper).copy(root, getChangeSummary()); | |
//fail("IllegalArgumentException should be thrown."); | |
} catch (IllegalArgumentException e) { | |
assertNull(c); | |
} | |
} | |
public void testShallowCopySourceHaveSameType() { | |
SDODataObject copy = (SDODataObject)((SDOCopyHelper)copyHelper).copyShallow(root); | |
assertEquals(copy.getType(), root.getType()); | |
} | |
// TODO: this tests only tests the MapValueStore impl, separate generic test required | |
public void testShallowCopySourceHaveDifferentMap() { | |
SDODataObject copy = (SDODataObject)((SDOCopyHelper)copyHelper).copyShallow(root); | |
int copySize = getPropertiesSize(copy); | |
assertFalse(copySize == getPropertiesSize(root)); | |
//testCopySourceMap(root, copy); | |
} | |
// TODO: this tests only tests the MapValueStore impl, separate generic test required | |
public void testShallowCopySourceMapsHaveSameDataTypeObj() { | |
SDODataObject copy = (SDODataObject)((SDOCopyHelper)copyHelper).copyShallow(root); | |
int copySize = getPropertiesSize(copy); | |
assertFalse(copySize == getPropertiesSize(root)); | |
Set copyKeys = getPropertiesKeySet(copy); | |
Set keys = getPropertiesKeySet(root); | |
Iterator iterKeys = copyKeys.iterator(); | |
while (iterKeys.hasNext()) { | |
String propertyName = (String)iterKeys.next(); | |
assertTrue(keys.contains(propertyName)); | |
Object s = root.get(propertyName); | |
Object c = copy.get(propertyName); | |
if (!(c instanceof SDODataObject) && !(c instanceof SDOChangeSummary)) { | |
assertEquals(c, s); | |
} | |
} | |
} | |
public void testShallowCopySourceHasPropertyWithChangeSummaryValue() { | |
SDODataObject copy = (SDODataObject)copyHelper.copyShallow(containedDataObject); | |
assertNotNull(copy); | |
SDOChangeSummary copyChSum = (SDOChangeSummary)copy// | |
.get(containedProperty_ChangeSummary.getName()); | |
assertNotNull(copyChSum); | |
ChangeSummary originalChSum = root.getDataObject("rootproperty2-notdatatype").getChangeSummary(); | |
assertEquals(originalChSum.isLogging(), copyChSum.isLogging());// loggin status is same | |
} | |
public void testShallowCopyWithNullValue() { | |
DataObject source = null; | |
DataObject o = copyHelper.copyShallow(source); | |
assertNull(o); | |
} | |
// add oc test | |
public void assertEqualityHelperEqual(DataObject root, DataObject copy) { | |
assertTrue(equalityHelper.equal(root, copy)); | |
} | |
public void testDeleteLeaf() { | |
assertEquals(containedByContainedDataObject, containedDataObject.get(containedProperty2)); | |
containedByContainedDataObject.getChangeSummary().endLogging(); | |
containedByContainedDataObject.unset(containedByContainedProperty1); | |
containedByContainedDataObject.getChangeSummary().beginLogging(); | |
containedByContainedDataObject.delete(); | |
assertNull(containedDataObject.get(containedProperty2)); | |
DataObject deepCopy = ((SDOCopyHelper)copyHelper).copy(containedDataObject, getChangeSummary()); | |
assertEqualityHelperEqual(containedDataObject, deepCopy); | |
} | |
} |