Skip to content

Commit 2271bf3

Browse files
unknownunknown
unknown
authored and
unknown
committed
Signed-off-by: unknown <jonathan.lee@WKS-E32.hq.vistair.com>
1 parent 1d0b4c4 commit 2271bf3

13 files changed

+338
-34
lines changed

‎src/main/java/de/danielbechler/diff/BeanDiffer.java‎

Lines changed: 11 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -49,6 +49,17 @@ public final Node compare(final Node parentNode, final Instances instances)
4949
{
5050
beanNode.setState(Node.State.IGNORED);
5151
}
52+
else if (nodeInspector.isWithMethodEquals(beanNode)){
53+
String method = nodeInspector.getWithMethodEqualsMethod(beanNode);
54+
if (instances.areMethodResultEqual(method))
55+
{
56+
beanNode.setState(Node.State.UNTOUCHED);
57+
}
58+
else
59+
{
60+
beanNode.setState(Node.State.CHANGED);
61+
}
62+
}
5263
else if (instances.areNull() || instances.areSame())
5364
{
5465
beanNode.setState(Node.State.UNTOUCHED);

‎src/main/java/de/danielbechler/diff/Configuration.java‎

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -78,10 +78,10 @@ public enum PrimitiveDefaultValueMode
7878
private final Collection<PropertyPath> includedProperties = new HashSet<PropertyPath>(10);
7979
private final Collection<PropertyPath> excludedProperties = new HashSet<PropertyPath>(10);
8080
private final Collection<PropertyPath> equalsOnlyProperties = new LinkedHashSet<PropertyPath>(10);
81-
private final Collection<MethodEqualPropertyPathAndMethod> methodEqualProperties = new LinkedHashSet<MethodEqualPropertyPathAndMethod>(10);
81+
private final Collection<PropertyPathAndMethod> methodEqualProperties = new LinkedHashSet<PropertyPathAndMethod>(10);
8282
private final Collection<Class<?>> compareToOnlyTypes = new LinkedHashSet<Class<?>>(10);
8383
private final Collection<Class<?>> equalsOnlyTypes = new LinkedHashSet<Class<?>>(10);
84-
private final Collection<MethodEqualClassAndMethod> methodEqualTypes = new LinkedHashSet<MethodEqualClassAndMethod>(10);
84+
private final Collection<ClassAndMethod> methodEqualTypes = new LinkedHashSet<ClassAndMethod>(10);
8585
private boolean returnUnchangedNodes = false;
8686
private boolean returnIgnoredNodes = false;
8787
private boolean returnCircularNodes = true;
@@ -147,11 +147,11 @@ public Configuration withEqualsOnlyProperty(final PropertyPath propertyPath)
147147
}
148148

149149
public Configuration withMethodEqualsProperty(final PropertyPath propertyPath, final String methodName) {
150-
this.methodEqualProperties.add(new MethodEqualPropertyPathAndMethod(propertyPath, methodName));
150+
this.methodEqualProperties.add(new PropertyPathAndMethod(propertyPath, methodName));
151151
return this;
152152
}
153153

154-
public Configuration withMethodEqualsProperty(MethodEqualPropertyPathAndMethod propertyPathEqualsMethod) {
154+
public Configuration withMethodEqualsProperty(PropertyPathAndMethod propertyPathEqualsMethod) {
155155
this.methodEqualProperties.add(propertyPathEqualsMethod);
156156
return this;
157157
}
@@ -337,7 +337,7 @@ public String getWithMethodEqualsMethod(Node node){
337337
return annotation.method();
338338
}
339339

340-
MethodEqualClassAndMethod applicable = findMethodEqualPropertyForClass(propertyType);
340+
ClassAndMethod applicable = findMethodEqualPropertyForClass(propertyType);
341341
if (applicable != null)
342342
{
343343
return applicable.getMethod();
@@ -347,16 +347,16 @@ public String getWithMethodEqualsMethod(Node node){
347347
{
348348
return node.getWithMethodEqualsMethod();
349349
}
350-
MethodEqualPropertyPathAndMethod applicable = findMethodEqualPropertyForPath(node.getPropertyPath());
350+
PropertyPathAndMethod applicable = findMethodEqualPropertyForPath(node.getPropertyPath());
351351
if (applicable != null)
352352
{
353353
return applicable.getMethod();
354354
}
355355
return null;
356356
}
357357

358-
private MethodEqualClassAndMethod findMethodEqualPropertyForClass(Class<?> clazz){
359-
for(MethodEqualClassAndMethod propertyPathEqualsMethod: methodEqualTypes){
358+
private ClassAndMethod findMethodEqualPropertyForClass(Class<?> clazz){
359+
for(ClassAndMethod propertyPathEqualsMethod: methodEqualTypes){
360360
if(clazz.equals(propertyPathEqualsMethod.getClazz())){
361361
return propertyPathEqualsMethod;
362362
}
@@ -365,8 +365,8 @@ private MethodEqualClassAndMethod findMethodEqualPropertyForClass(Class<?> clazz
365365

366366
}
367367

368-
private MethodEqualPropertyPathAndMethod findMethodEqualPropertyForPath(PropertyPath propertyPath){
369-
for(MethodEqualPropertyPathAndMethod propertyPathEqualsMethod: methodEqualProperties){
368+
private PropertyPathAndMethod findMethodEqualPropertyForPath(PropertyPath propertyPath){
369+
for(PropertyPathAndMethod propertyPathEqualsMethod: methodEqualProperties){
370370
if(propertyPath.equals(propertyPathEqualsMethod.getPropertyPath())){
371371
return propertyPathEqualsMethod;
372372
}

‎src/main/java/de/danielbechler/diff/example/MethodEqualExample.java‎

Lines changed: 34 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -5,8 +5,8 @@
55

66
import de.danielbechler.diff.Configuration;
77
import de.danielbechler.diff.ObjectDifferFactory;
8+
import de.danielbechler.diff.annotation.ObjectDiffMethodEqualsType;
89
import de.danielbechler.diff.annotation.ObjectDiffProperty;
9-
import de.danielbechler.diff.example.IgnoreExample.User;
1010
import de.danielbechler.diff.node.Node;
1111
import de.danielbechler.diff.path.PropertyPath;
1212
import de.danielbechler.diff.visitor.PrintingVisitor;
@@ -18,17 +18,15 @@ private MethodEqualExample()
1818

1919
public static void main(final String[] args)
2020
{
21-
List<Object> baseItems = new ArrayList<Object>();
22-
baseItems.add("baseitem");
23-
final EncompassingClass base = new EncompassingClass(baseItems);
24-
List<Object> workingItems = new ArrayList<Object>();
25-
workingItems.add("workingitem");
26-
final EncompassingClass working = new EncompassingClass(workingItems);
21+
PropertyClass prop = new PropertyClass("1", "2");
22+
final EncompassingClass base = new EncompassingClass(prop);
23+
PropertyClass prop2 = new PropertyClass("1", "3");
24+
final EncompassingClass working = new EncompassingClass(prop2);
2725

2826
final Configuration configuration = new Configuration();
2927

30-
// (Option 1) Causes the ObjectDiffer to use the method "size" on the 'items' property of the root object
31-
configuration.withMethodEqualsProperty(PropertyPath.buildWith("items"), "size");
28+
// (Option 1) Causes the ObjectDiffer to compare using the method "getProp1" on the 'prop' property of the root object
29+
configuration.withMethodEqualsProperty(PropertyPath.buildWith("prop"), "getProp1");
3230

3331
final Node node = ObjectDifferFactory.getInstance(configuration).compare(working, base);
3432

@@ -37,24 +35,42 @@ public static void main(final String[] args)
3735
// Output with ignore:
3836
// Property at path '/' has not changed
3937
// Output without ignore:
40-
// Property at path '/items[workingitem]' has been added => [ workingitem ]
41-
// Property at path '/items[baseitem]' with value [ baseitem ] has been removed
38+
// Property at path '/prop/prop2' has changed from [ 2 ] to [ 3 ]
4239
}
4340

4441
public static class EncompassingClass
4542
{
46-
private final List<Object> items;
43+
private final PropertyClass prop;
4744

48-
public EncompassingClass(final List<Object> items)
45+
public EncompassingClass(final PropertyClass prop)
4946
{
50-
this.items = items;
47+
this.prop = prop;
5148
}
5249

53-
/* (Option 2) This annotation causes the ObjectDiffer to always ignore this property */
54-
@ObjectDiffProperty(methodEqual = "size")
55-
public List<Object> getItems()
50+
/* (Option 2) This annotation causes the ObjectDiffer to use getProp1 method to compare */
51+
//@ObjectDiffProperty(methodEqual = "getProp1")
52+
public PropertyClass getProp() {
53+
return prop;
54+
}
55+
}
56+
57+
/* (Option 3) This annotation causes the ObjectDiffer to use getProp1 method to compare */
58+
//@ObjectDiffMethodEqualsType(method="getProp1")
59+
public static class PropertyClass
60+
{
61+
private String prop1;
62+
private String prop2;
63+
64+
public PropertyClass(String prop1, String prop2)
5665
{
57-
return items;
66+
this.prop1 = prop1;
67+
this.prop2 = prop2;
68+
}
69+
public String getProp1() {
70+
return prop1;
71+
}
72+
public String getProp2() {
73+
return prop2;
5874
}
5975
}
6076

‎src/main/java/de/danielbechler/diff/path/MethodEqualClassAndMethod.java‎ renamed to ‎src/main/java/de/danielbechler/diff/path/ClassAndMethod.java‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,9 @@
11
package de.danielbechler.diff.path;
22

3-
public class MethodEqualClassAndMethod {
3+
public class ClassAndMethod {
44
private Class<?> clazz;
55
private String method;
6-
public MethodEqualClassAndMethod(Class<?> clazz, String method){
6+
public ClassAndMethod(Class<?> clazz, String method){
77
this.clazz = clazz;
88
this.method = method;
99
}

‎src/main/java/de/danielbechler/diff/path/MethodEqualPropertyPathAndMethod.java‎ renamed to ‎src/main/java/de/danielbechler/diff/path/PropertyPathAndMethod.java‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,11 @@
11
package de.danielbechler.diff.path;
22

3-
public class MethodEqualPropertyPathAndMethod {
3+
public class PropertyPathAndMethod {
44
private PropertyPath propertyPath;
55
private String method;
66

7-
public MethodEqualPropertyPathAndMethod(){}
8-
public MethodEqualPropertyPathAndMethod(PropertyPath propertyPath, String method){
7+
public PropertyPathAndMethod(){}
8+
public PropertyPathAndMethod(PropertyPath propertyPath, String method){
99
this.propertyPath = propertyPath;
1010
this.method = method;
1111
}

‎src/test/java/de/danielbechler/diff/BeanDifferShould.java‎

Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -24,6 +24,8 @@
2424
import org.mockito.Mock;
2525
import org.testng.annotations.*;
2626

27+
import static de.danielbechler.diff.node.Node.State.CHANGED;
28+
import static de.danielbechler.diff.node.Node.State.UNTOUCHED;
2729
import static de.danielbechler.diff.node.NodeAssertions.assertThat;
2830
import static java.util.Arrays.*;
2931
import static org.hamcrest.MatcherAssert.assertThat;
@@ -120,6 +122,34 @@ public void compare_bean_via_equals()
120122

121123
assertThat(node).self().isUntouched();
122124
}
125+
126+
@Test
127+
public void detect_no_change_when_comparing_using_with_method_equals_and_result_is_same()
128+
{
129+
final ObjectWithNestedObject working = new ObjectWithNestedObject("foo");
130+
working.setObject(new ObjectWithNestedObject("childid"));
131+
final ObjectWithNestedObject base = new ObjectWithNestedObject("foo");
132+
base.setObject(new ObjectWithNestedObject("differentchildid"));
133+
configuration.withMethodEqualsProperty(PropertyPath.buildRootPath(), "getId");
134+
135+
final Node node = differ.compare(Node.ROOT, Instances.of(working, base));
136+
137+
assertThat(node).self().isUntouched();
138+
}
139+
140+
@Test
141+
public void detect_change_when_comparing_using_with_method_equals_and_result_is_different()
142+
{
143+
final ObjectWithNestedObject working = new ObjectWithNestedObject("foo");
144+
working.setObject(new ObjectWithNestedObject("childid"));
145+
final ObjectWithNestedObject base = new ObjectWithNestedObject("bar");
146+
base.setObject(new ObjectWithNestedObject("differentchildid"));
147+
configuration.withMethodEqualsProperty(PropertyPath.buildRootPath(), "getId");
148+
149+
final Node node = differ.compare(Node.ROOT, Instances.of(working, base));
150+
151+
assertThat(node).self().hasChanges();
152+
}
123153

124154
@Test
125155
public void compare_bean_via_introspection_and_delegate_comparison_of_properties()

‎src/test/java/de/danielbechler/diff/CollectionDifferShould.java‎

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -24,6 +24,8 @@
2424

2525
import java.util.*;
2626

27+
import static de.danielbechler.diff.node.Node.State.CHANGED;
28+
import static de.danielbechler.diff.node.Node.State.UNTOUCHED;
2729
import static java.util.Arrays.*;
2830
import static java.util.Collections.*;
2931
import static org.mockito.Mockito.*;
@@ -118,6 +120,26 @@ public void compare_only_via_equals_if_equals_only_is_enabled()
118120
compare();
119121
verify(collectionNode).setState(Node.State.UNTOUCHED);
120122
}
123+
124+
@Test
125+
public void detect_no_change_when_comparing_using_with_method_equals_and_result_is_same()
126+
{
127+
when(nodeInspector.isWithMethodEquals(collectionNode)).thenReturn(true);
128+
when(nodeInspector.getWithMethodEqualsMethod(collectionNode)).thenReturn("somemethod");
129+
when(instances.areMethodResultEqual("somemethod")).thenReturn(true);
130+
compare();
131+
verify(collectionNode).setState(Node.State.UNTOUCHED);
132+
}
133+
134+
@Test
135+
public void detect_change_when_comparing_using_with_method_equals_and_result_is_different()
136+
{
137+
when(nodeInspector.isWithMethodEquals(collectionNode)).thenReturn(true);
138+
when(nodeInspector.getWithMethodEqualsMethod(collectionNode)).thenReturn("somemethod");
139+
when(instances.areMethodResultEqual("somemethod")).thenReturn(false);
140+
compare();
141+
verify(collectionNode).setState(CHANGED);
142+
}
121143

122144
@Test
123145
public void detect_changes_if_equals_only_is_enabled()

‎src/test/java/de/danielbechler/diff/InstancesTest.java‎

Lines changed: 47 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -17,6 +17,8 @@
1717
package de.danielbechler.diff;
1818

1919
import de.danielbechler.diff.accessor.*;
20+
import de.danielbechler.diff.mock.ObjectWithString;
21+
2022
import org.testng.annotations.*;
2123

2224
import java.lang.reflect.*;
@@ -120,6 +122,51 @@ public void testIsPrimitiveTypeReturnsFalseForComplexType()
120122
assertThat(new Instances(RootAccessor.getInstance(), "1", "2", null).isPrimitiveType()).isFalse();
121123
}
122124

125+
@Test
126+
public void testMethodResultNotEqual() throws Exception
127+
{
128+
final Method readMethod = getClass().getDeclaredMethod("getTestValue");
129+
final PropertyAccessor accessor = new PropertyAccessor("testValue", readMethod, null);
130+
131+
ObjectWithString working = new ObjectWithString("string1");
132+
ObjectWithString base = new ObjectWithString("string2");
133+
134+
final Instances instances = new Instances(accessor, working, base, null);
135+
assertThat(instances.areMethodResultEqual("getValue")).isFalse();
136+
}
137+
138+
@Test
139+
public void testMethodResultEqual() throws Exception
140+
{
141+
final Method readMethod = getClass().getDeclaredMethod("getTestValue");
142+
final PropertyAccessor accessor = new PropertyAccessor("testValue", readMethod, null);
143+
144+
ObjectWithString working = new ObjectWithString("string");
145+
ObjectWithString base = new ObjectWithString("string");
146+
147+
final Instances instances = new Instances(accessor, working, base, null);
148+
assertThat(instances.areMethodResultEqual("getValue")).isTrue();
149+
}
150+
151+
@Test
152+
public void testMethodResultEqualInvalidMethod() throws Exception
153+
{
154+
final Method readMethod = getClass().getDeclaredMethod("getTestValue");
155+
final PropertyAccessor accessor = new PropertyAccessor("testValue", readMethod, null);
156+
157+
ObjectWithString working = new ObjectWithString("string");
158+
ObjectWithString base = new ObjectWithString("string");
159+
160+
final Instances instances = new Instances(accessor, working, base, null);
161+
try {
162+
instances.areMethodResultEqual("invalid");
163+
fail("no exception thrown");
164+
}
165+
catch(RuntimeException e){
166+
assertThat(e.getCause() instanceof NoSuchMethodException).isTrue();
167+
}
168+
}
169+
123170
@SuppressWarnings({"MethodMayBeStatic", "UnusedDeclaration"})
124171
public long getTestValue()
125172
{

‎src/test/java/de/danielbechler/diff/MapDifferShould.java‎

Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -90,6 +90,30 @@ public void detect_no_change_when_comparing_using_equals()
9090
verify(node).setState(UNTOUCHED);
9191
}
9292

93+
@Test
94+
public void detect_no_change_when_comparing_using_with_method_equals_and_result_is_same()
95+
{
96+
when(nodeInspector.isWithMethodEquals(internalNode)).thenReturn(true);
97+
when(nodeInspector.getWithMethodEqualsMethod(internalNode)).thenReturn("somemethod");
98+
when(instances.areMethodResultEqual("somemethod")).thenReturn(true);
99+
100+
node = compare(working, base);
101+
102+
verify(node).setState(UNTOUCHED);
103+
}
104+
105+
@Test
106+
public void detect_change_when_comparing_using_with_method_equals_and_result_is_different()
107+
{
108+
when(nodeInspector.isWithMethodEquals(internalNode)).thenReturn(true);
109+
when(nodeInspector.getWithMethodEqualsMethod(internalNode)).thenReturn("somemethod");
110+
when(instances.areMethodResultEqual("somemethod")).thenReturn(false);
111+
112+
node = compare(working, base);
113+
114+
verify(node).setState(CHANGED);
115+
}
116+
93117
@Test
94118
public void detect_addition()
95119
{

0 commit comments

Comments
 (0)