/*******************************************************************************
* Copyright (c) 1998, 2015 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);
}
}