/*******************************************************************************
* 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
******************************************************************************/
package org.eclipse.persistence.testing.sdo.helper.equalityhelper;
import commonj.sdo.DataObject;
import org.eclipse.persistence.sdo.SDOConstants;
import org.eclipse.persistence.sdo.SDODataObject;
import org.eclipse.persistence.sdo.SDOProperty;
import org.eclipse.persistence.sdo.SDOType;
public class SDOEqualityHelperTest extends SDOEqualityHelperEqualTestCases {
public SDOEqualityHelperTest(String name) {
super(name);
}
// compare a DataObject with itself by deep equal --- true
// see SDOEqualityHelperBidirectionalTest.java for a complete bidirectional model
public void testDeepEqualWithADataObjectToItself() {
assertTrue(equalityHelper.equal(root, root));
}
// compare a DataObject with its Deep copy by deep equal --- true
// see SDOEqualityHelperBidirectionalTest.java for a complete bidirectional model
public void testDeepEqualWithADataObjectToItsDeepCopy() {
DataObject deepCopy = copyHelper.copy(root);
assertTrue(equalityHelper.equal(root, deepCopy));
}
// compare a DataObject with another DataObject with the same contents --- true
public void testDeepEqualWithADataObjectToItsSameContentObject() {
this.assertTrue(equalityHelper.equal(root, root1));
}
// comapre a DataObject with its Shallow copy by deep equal --- false
public void testDeepEqualWithADataObjectToItsShallowCopy() {
DataObject shallowCopy = copyHelper.copyShallow(root);
this.assertFalse(equalityHelper.equal(root, shallowCopy));
}
// comapre a DataObject with its Shallow copy by deep equal --- false
public void testDeepEqualWithADataObjectToItsChild() {
this.assertFalse(equalityHelper.equal(root, containedDataObject));
}
// compare a DataObject with another different DataObject --- false
public void testDeepEqualWithADataObjectToAnotherDataObject() {
this.assertFalse(equalityHelper.equal(root, containedDataObject));
}
// !! this test case base on the following and Now its meaning is still not sure !!
// Note that properties to a containing DataObject are not compared which
// means two DataObject trees can be equal even if their containers are not equal.
public void testDeepEqualWithADataObjectToAnotherDataObjectWithDifferentParents() {
this.assertTrue(equalityHelper.equal(containedDataObject, containedDataObject_1));
}
// purpose: one has open content datatype property while another doesn't
public void testDeepEqualWithADataObjectToAnotherOpenContentProperties() {
SDOProperty openP = new SDOProperty(aHelperContext);
openP.setName("open");
openP.setContainment(false);
openP.setMany(false);
openP.setType(SDOConstants.SDO_STRING);
containedType.setOpen(true);
containedDataObject.set(openP, "test");
this.assertFalse(equalityHelper.equal(root, root1));
}
// purpose: one has open content datatype property while another does too
public void testDeepEqualWithADataObjectToAnotherOpenContentPropertiesBoth() {
SDOProperty openP = new SDOProperty(aHelperContext);
openP.setName("open");
openP.setContainment(false);
openP.setMany(false);
openP.setType(SDOConstants.SDO_STRING);
containedType.setOpen(true);
containedDataObject.set(openP, "test");
containedDataObject_1.set(openP, "test");
this.assertTrue(equalityHelper.equal(root, root1));
containedDataObject.set(openP, "test");
containedDataObject_1.set(openP, "test1");
this.assertFalse(equalityHelper.equal(root, root1));
}
// purpose: one has open content datatype property while another doesn't
public void testDeepEqualWithADataObjectToAnotherOpenContentPropertiesNotDataType() {
SDOProperty openP = new SDOProperty(aHelperContext);
openP.setName("open");
openP.setContainment(true);
openP.setMany(false);
openP.setType(new SDOType("", ""));
containedType.setOpen(true);
SDOType mockType = new SDOType("uri", "name");
DataObject d1 = dataFactory.create(mockType);
containedDataObject.set(openP, d1);
this.assertFalse(equalityHelper.equal(root, root1));
}
// purpose: one has open content datatype property while another doesn't
public void testDeepEqualWithADataObjectToAnotherOpenContentPropertiesNotDataTypeBoth() {
SDOProperty openP = new SDOProperty(aHelperContext);
openP.setName("open");
openP.setContainment(true);
openP.setMany(false);
openP.setType(new SDOType("", ""));
containedType.setOpen(true);
SDOType mockType = new SDOType("uri", "name");
DataObject d1 = dataFactory.create(mockType);
DataObject d2 = dataFactory.create(mockType);
containedDataObject.set(openP, d1);
containedDataObject_1.set(openP, d2);
this.assertTrue(equalityHelper.equal(root, root1));
}
// compare DataObject with properties as many
public void testDeepEqualWithTwoDataObjectsHavingManyTypeProperties() {
rootProperty4.setContainment(false);
rootProperty4.setType(SDOConstants.SDO_STRING);
objects.add("test");
objects1.add("test");
root.set(rootProperty4, objects);
root1.set(rootProperty4, objects1);
this.assertTrue(equalityHelper.equal(root, root1));
}
// compare DataObject with properties as many
public void testDeepEqualWithTwoDataObjectsHavingManyTypePropertiesDataObjects() {
//rootProperty4.setContainment(false);
//SDOType rootProperty4_type = new SDOType("", "");
//rootProperty4.setType(SDOConstants.SDO_STRING);
SDOType mockType = new SDOType("uri", "name");
DataObject d1 = dataFactory.create(mockType);
DataObject d2 = dataFactory.create(mockType);
objects.add(d1);
objects1.add(d2);
rootProperty4.setMany(true);
root.set(rootProperty4, objects);
root1.set(rootProperty4, objects1);
this.assertTrue(equalityHelper.equal(root, root1));
}
// compare DataObject with properties as many
public void testDeepEqualWithTwoDataObjectsHavingManyTypePropertiesDataObjectsFail() {
//rootProperty4.setContainment(false);
//SDOType rootProperty4_type = new SDOType("", "");
//rootProperty4.setType(SDOConstants.SDO_STRING);
SDOType mockType = new SDOType("uri", "name");
SDOProperty p = new SDOProperty(aHelperContext);
p.setContainment(false);
p.setMany(false);
p.setName("fortest");
p.setType(SDOConstants.SDO_STRING);
mockType.addDeclaredProperty(p);
DataObject d1 = dataFactory.create(mockType);
DataObject d2 = dataFactory.create(mockType);
DataObject d3 = dataFactory.create(mockType);
DataObject d4 = dataFactory.create(mockType);
objects.add(d1);
objects.add(d3);
objects1.add(d4);
objects1.add(d2);
d4.set(p, "fail");
rootProperty4.setMany(true);
root.set(rootProperty4, objects);
root1.set(rootProperty4, objects1);
this.assertFalse(equalityHelper.equal(root, root1));
}
// compare DataObject with properties as many
public void testDeepEqualWithTwoDataObjectsHavingManyTypePropertiesDataObjectsFailListSizeUnequal() {
//rootProperty4.setContainment(false);
//SDOType rootProperty4_type = new SDOType("", "");
//rootProperty4.setType(SDOConstants.SDO_STRING);
SDOType mockType = new SDOType("uri", "name");
SDOProperty p = new SDOProperty(aHelperContext);
p.setContainment(false);
p.setMany(false);
p.setName("fortest");
p.setType(SDOConstants.SDO_STRING);
mockType.addDeclaredProperty(p);
DataObject d1 = dataFactory.create(mockType);
DataObject d2 = dataFactory.create(mockType);
DataObject d3 = dataFactory.create(mockType);
DataObject d4 = dataFactory.create(mockType);
objects.add(d1);
objects.add(d3);
//objects1.add(d4);
objects1.add(d2);
//d4.set(p, "fail");
rootProperty4.setMany(true);
root.set(rootProperty4, objects);
root1.set(rootProperty4, objects1);
this.assertFalse(equalityHelper.equal(root, root1));
}
// compare DataObject with properties as many
public void testDeepEqualWithTwoDataObjectsHavingManyTypePropertiesDataObjectsFailOnePropertyNotSet() {
//rootProperty4.setContainment(false);
//SDOType rootProperty4_type = new SDOType("", "");
//rootProperty4.setType(SDOConstants.SDO_STRING);
SDOType mockType = new SDOType("uri", "name");
SDOProperty p = new SDOProperty(aHelperContext);
p.setContainment(false);
p.setMany(false);
p.setName("fortest");
p.setType(SDOConstants.SDO_STRING);
mockType.addDeclaredProperty(p);
DataObject d1 = dataFactory.create(mockType);
DataObject d2 = dataFactory.create(mockType);
DataObject d3 = dataFactory.create(mockType);
DataObject d4 = dataFactory.create(mockType);
objects.add(d1);
objects.add(d3);
objects1.add(d4);
objects1.add(d2);
//d4.set(p, "fail");
rootProperty4.setMany(true);
root.set(rootProperty4, objects);
//root1.set(rootProperty4, objects1);
this.assertFalse(equalityHelper.equal(root, root1));
}
/**
* Test whether EqualityHelper.compareProperty() handles nested objects that are null but isSet=true
* (Where we do not have a bidirectional child property)
* See SDOCopyHelperDeepTest for the same test with the bidirectional child
*/
public void testDeepEqualWithUnsetComplexChild() {
// clear complex child
root.unset("rootproperty2-notdatatype");
SDODataObject copyOfRoot = (SDODataObject)copyHelper.copy(root);
assertFalse(root.isSet("rootproperty2-notdatatype"));
assertNotNull(copyOfRoot);
assertTrue(equalityHelper.equal(root, copyOfRoot));
}
// TODO: process non-containment side of bidirectionals see #5853175
public void testDeepEqualWithSetNullComplexChild() {
// clear complex child
root.set("rootproperty2-notdatatype", null);
SDODataObject copyOfRoot = (SDODataObject)copyHelper.copy(root);
assertFalse(root.isSet("rootproperty2-notdatatype"));
assertNotNull(copyOfRoot);
// this assertion previously failed before fix for #5852525
assertTrue(equalityHelper.equal(root, copyOfRoot));
}
// compare DataObject with properties as many
public void testDeepEqualWithTwoDataObjectsHavingManyTypeDataTypePropertiesDataObjectsFail() {
//rootProperty4.setContainment(false);
//SDOType rootProperty4_type = new SDOType("", "");
//rootProperty4.setType(SDOConstants.SDO_STRING);
//SDOType mockType = new SDOType("uri", "name");
//SDOProperty p = new SDOProperty(aHelperContext);
//p.setContainment(false);
//p.setMany(false);
//p.setName("fortest");
//p.setType(SDOConstants.SDO_STRING);
//mockType.addDeclaredProperty(p);
//DataObject d1 = dataFactory.create(mockType);
//DataObject d2 = dataFactory.create(mockType);
//DataObject d3 = dataFactory.create(mockType);
//DataObject d4 = dataFactory.create(mockType);
objects.add("test");
objects.add("test1");
objects1.add("test");
objects1.add("test1");
//d4.set(p, "fail");
rootProperty4.setMany(true);
rootProperty4.setContainment(false);
rootProperty4.setType(SDOConstants.SDO_STRING);
root.set(rootProperty4, objects);
root1.set(rootProperty4, objects1);
this.assertTrue(equalityHelper.equal(root, root1));
}
// compare a DataObject with itself by shallow equal --- true
public void testShallowEqualWithDataObjectToItself() {
this.assertTrue(equalityHelper.equalShallow(root, root));
}
// compare a DataObject with its Deep copy by shallow equal --- true
public void testShallowEqualWithADataObjectToItsDeepCopy() {
DataObject deepCopy = copyHelper.copy(root);
this.assertTrue(equalityHelper.equalShallow(root, deepCopy));
}
// compare a DataObject with its Shallow copy by shallow equal --- true
public void testShallowEqualWithADataObjectToItsShallowCopy() {
DataObject shallowCopy = copyHelper.copyShallow(root);
this.assertTrue(equalityHelper.equalShallow(root, shallowCopy));
}
// compare a DataObject with another different DataObject by shallow equal --- false
public void testShallowEqualWithADataObjectToAnotherDataObject() {
this.assertFalse(equalityHelper.equalShallow(root, containedDataObject));
}
// compare null with null by deep equal --- true
public void testDeepEqualWithNullToNull() {
this.assertTrue(equalityHelper.equal(null, null));
}
// compare a DataObject with null by deep equal --- false
public void testDeepEqualWithADataObjectToNull() {
this.assertFalse(equalityHelper.equal(root, null));
}
// compare null with null by shallow equal --- true
public void testShallowEqualWithNullToNull() {
this.assertTrue(equalityHelper.equalShallow(null, null));
}
// compare a DataObject with shallow null --- false
public void testShallowEqualWithADataObjectToNull() {
this.assertFalse(equalityHelper.equalShallow(root, null));
}
// compare DataObject with properties as many
public void testDeepEqualWithTwoDataObjectsHavingManyTypePropertiesDataObjectsFailShallow() {
SDOProperty rootProperty5 = new SDOProperty(aHelperContext);
rootProperty5.setContainment(false);
//SDOType rootProperty4_type = new SDOType("", "");
rootProperty5.setType(SDOConstants.SDO_STRING);
objects.add("test");
objects.add("test1");
objects1.add("test");
//objects1.add(d2);
//d4.set(p, "fail");
rootProperty5.setMany(true);
root.set(rootProperty5, objects);
root1.set(rootProperty5, objects1);
this.assertFalse(equalityHelper.equalShallow(root, root1));
}
// compare DataObject with properties as many
public void testDeepEqualWithTwoDataObjectsHavingManyTypePropertiesDataObjectsFailShallowOnePropertyNotSet() {
SDOProperty rootProperty5 = new SDOProperty(aHelperContext);
rootProperty5.setContainment(false);
//SDOType rootProperty4_type = new SDOType("", "");
rootProperty5.setType(SDOConstants.SDO_STRING);
rootType.addDeclaredProperty(rootProperty5);
root._setType(rootType);
objects.add("test");
objects.add("test1");
objects1.add("test");
//objects1.add(d2);
//d4.set(p, "fail");
rootProperty5.setMany(true);
root.set(rootProperty5, objects);
//root1.set(rootProperty5, objects1);
this.assertFalse(equalityHelper.equalShallow(root, root1));
}
}