View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      https://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.apache.commons.lang3.builder;
18  
19  import static org.apache.commons.lang3.LangAssertions.assertNullPointerException;
20  import static org.junit.jupiter.api.Assertions.assertArrayEquals;
21  import static org.junit.jupiter.api.Assertions.assertEquals;
22  import static org.junit.jupiter.api.Assertions.assertNotEquals;
23  import static org.junit.jupiter.api.Assertions.assertNotSame;
24  import static org.junit.jupiter.api.Assertions.assertSame;
25  import static org.junit.jupiter.api.Assertions.assertTrue;
26  
27  import java.util.List;
28  
29  import org.apache.commons.lang3.AbstractLangTest;
30  import org.apache.commons.lang3.ArrayUtils;
31  import org.junit.jupiter.api.Test;
32  
33  /**
34   * Tests {@link DiffBuilder}.
35   */
36  class DiffBuilderTest extends AbstractLangTest {
37  
38      /**
39       * Test fixture.
40       */
41      private static class NestedTypeTestClass implements Diffable<NestedTypeTestClass> {
42  
43          private final ToStringStyle style = SHORT_STYLE;
44          private boolean booleanField = true;
45  
46          @Override
47          public DiffResult<NestedTypeTestClass> diff(final NestedTypeTestClass obj) {
48              // @formatter:off
49              return new DiffBuilder<>(this, obj, style)
50                      .append("boolean", booleanField, obj.booleanField)
51                      .build();
52              // @formatter:on
53          }
54  
55          @Override
56          public boolean equals(final Object obj) {
57              return EqualsBuilder.reflectionEquals(this, obj, false);
58          }
59  
60          @Override
61          public int hashCode() {
62              return HashCodeBuilder.reflectionHashCode(this, false);
63          }
64      }
65  
66      /**
67       * Test fixture.
68       */
69      private static final class TypeTestClass implements Diffable<TypeTestClass> {
70  
71          private ToStringStyle style = SHORT_STYLE;
72          private boolean booleanField = true;
73          private boolean[] booleanArrayField = { true };
74          private byte byteField = (byte) 0xFF;
75          private byte[] byteArrayField = { (byte) 0xFF };
76          private char charField = 'a';
77          private char[] charArrayField = { 'a' };
78          private double doubleField = 1.0;
79          private double[] doubleArrayField = { 1.0 };
80          private float floatField = 1.0f;
81          private float[] floatArrayField = { 1.0f };
82          private int intField = 1;
83          private int[] intArrayField = { 1 };
84          private long longField = 1L;
85          private long[] longArrayField = { 1L };
86          private short shortField = 1;
87          private short[] shortArrayField = { 1 };
88          private Object objectField;
89          private Object[] objectArrayField = { null };
90          private final NestedTypeTestClass nestedDiffableField = new NestedTypeTestClass();
91  
92          @Override
93          public DiffResult<TypeTestClass> diff(final TypeTestClass obj) {
94              // @formatter:off
95              return new DiffBuilder<>(this, obj, style)
96                      .append("boolean", booleanField, obj.booleanField)
97                      .append("booleanArray", booleanArrayField, obj.booleanArrayField)
98                      .append("byte", byteField, obj.byteField)
99                      .append("byteArray", byteArrayField, obj.byteArrayField)
100                     .append("char", charField, obj.charField)
101                     .append("charArray", charArrayField, obj.charArrayField)
102                     .append("double", doubleField, obj.doubleField)
103                     .append("doubleArray", doubleArrayField, obj.doubleArrayField)
104                     .append("float", floatField, obj.floatField)
105                     .append("floatArray", floatArrayField, obj.floatArrayField)
106                     .append("int", intField, obj.intField)
107                     .append("intArray", intArrayField, obj.intArrayField)
108                     .append("long", longField, obj.longField)
109                     .append("longArray", longArrayField, obj.longArrayField)
110                     .append("short", shortField, obj.shortField)
111                     .append("shortArray", shortArrayField, obj.shortArrayField)
112                     .append("objectField", objectField, obj.objectField)
113                     .append("objectArrayField", objectArrayField, obj.objectArrayField)
114                     .append("nestedDiffableField", nestedDiffableField.diff(obj.nestedDiffableField))
115                     .build();
116             // @formatter:on
117         }
118 
119         @Override
120         public boolean equals(final Object obj) {
121             return EqualsBuilder.reflectionEquals(this, obj, false);
122         }
123 
124         @Override
125         public int hashCode() {
126             return HashCodeBuilder.reflectionHashCode(this, false);
127         }
128     }
129 
130     private static final ToStringStyle SHORT_STYLE = ToStringStyle.SHORT_PREFIX_STYLE;
131 
132     @Test
133     void testBoolean() {
134         final TypeTestClass class1 = new TypeTestClass();
135         final TypeTestClass class2 = new TypeTestClass();
136         class2.booleanField = false;
137         final DiffResult<TypeTestClass> list = class1.diff(class2);
138         assertEquals(1, list.getNumberOfDiffs());
139         final Diff<?> diff = list.getDiffs().get(0);
140         assertEquals(Boolean.class, diff.getType(), () -> diff.getType().getClass().toString());
141         assertEquals(Boolean.TRUE, diff.getLeft());
142         assertEquals(Boolean.FALSE, diff.getRight());
143     }
144 
145     @Test
146     void testBooleanArray() {
147         final TypeTestClass class1 = new TypeTestClass();
148         final TypeTestClass class2 = new TypeTestClass();
149         class2.booleanArrayField = new boolean[] { false, false };
150         final DiffResult<TypeTestClass> list = class1.diff(class2);
151         assertEquals(1, list.getNumberOfDiffs());
152         final Diff<?> diff = list.getDiffs().get(0);
153         assertArrayEquals(ArrayUtils.toObject(class1.booleanArrayField), (Object[]) diff.getLeft());
154         assertArrayEquals(ArrayUtils.toObject(class2.booleanArrayField), (Object[]) diff.getRight());
155     }
156 
157     @Test
158     void testByte() {
159         final TypeTestClass class1 = new TypeTestClass();
160         final TypeTestClass class2 = new TypeTestClass();
161         class2.byteField = 0x01;
162         final DiffResult<TypeTestClass> list = class1.diff(class2);
163         assertEquals(1, list.getNumberOfDiffs());
164         final Diff<?> diff = list.getDiffs().get(0);
165         assertEquals(Byte.class, diff.getType(), () -> diff.getType().getClass().toString());
166         assertEquals(Byte.valueOf(class1.byteField), diff.getLeft());
167         assertEquals(Byte.valueOf(class2.byteField), diff.getRight());
168     }
169 
170     @Test
171     void testByteArray() {
172         final TypeTestClass class1 = new TypeTestClass();
173         final TypeTestClass class2 = new TypeTestClass();
174         class2.byteArrayField = new byte[] { 0x01, 0x02 };
175         final DiffResult<TypeTestClass> list = class1.diff(class2);
176         assertEquals(1, list.getNumberOfDiffs());
177         final Diff<?> diff = list.getDiffs().get(0);
178         assertArrayEquals(ArrayUtils.toObject(class1.byteArrayField), (Object[]) diff.getLeft());
179         assertArrayEquals(ArrayUtils.toObject(class2.byteArrayField), (Object[]) diff.getRight());
180     }
181 
182     @Test
183     void testByteArrayEqualAsObject1() {
184         // @formatter:off
185         final DiffResult<String> list = DiffBuilder.<String>builder().setLeft("String1").setRight("String2").setStyle(SHORT_STYLE).build()
186                 .append("foo", new boolean[] { false }, new boolean[] { false })
187                 .append("foo", new byte[] { 0x01 }, new byte[] { 0x01 })
188                 .append("foo", new char[] { 'a' }, new char[] { 'a' })
189                 .append("foo", new double[] { 1.0 }, new double[] { 1.0 })
190                 .append("foo", new float[] { 1.0F }, new float[] { 1.0F })
191                 .append("foo", new int[] { 1 }, new int[] { 1 })
192                 .append("foo", new long[] { 1L }, new long[] { 1L })
193                 .append("foo", new short[] { 1 }, new short[] { 1 })
194                 .append("foo", new Object[] { 1, "two" }, new Object[] { 1, "two" })
195                 .build();
196         // @formatter:on
197         assertEquals(0, list.getNumberOfDiffs());
198     }
199 
200     @Test
201     void testByteArrayEqualAsObjectDeprecated() {
202         // @formatter:off
203         final DiffResult<String> list = new DiffBuilder<>("String1", "String2", SHORT_STYLE)
204                 .append("foo", new boolean[] { false }, new boolean[] { false })
205                 .append("foo", new byte[] { 0x01 }, new byte[] { 0x01 })
206                 .append("foo", new char[] { 'a' }, new char[] { 'a' })
207                 .append("foo", new double[] { 1.0 }, new double[] { 1.0 })
208                 .append("foo", new float[] { 1.0F }, new float[] { 1.0F })
209                 .append("foo", new int[] { 1 }, new int[] { 1 })
210                 .append("foo", new long[] { 1L }, new long[] { 1L })
211                 .append("foo", new short[] { 1 }, new short[] { 1 })
212                 .append("foo", new Object[] { 1, "two" }, new Object[] { 1, "two" })
213                 .build();
214         // @formatter:on
215         assertEquals(0, list.getNumberOfDiffs());
216     }
217 
218     @Test
219     void testChar() {
220         final TypeTestClass class1 = new TypeTestClass();
221         final TypeTestClass class2 = new TypeTestClass();
222         class2.charField = 'z';
223         final DiffResult<TypeTestClass> list = class1.diff(class2);
224         assertEquals(1, list.getNumberOfDiffs());
225         final Diff<?> diff = list.getDiffs().get(0);
226         assertEquals(Character.valueOf(class1.charField), diff.getLeft());
227         assertEquals(Character.valueOf(class2.charField), diff.getRight());
228     }
229 
230     @Test
231     void testCharArray() {
232         final TypeTestClass class1 = new TypeTestClass();
233         final TypeTestClass class2 = new TypeTestClass();
234         class2.charArrayField = new char[] { 'f', 'o', 'o' };
235         final DiffResult<TypeTestClass> list = class1.diff(class2);
236         assertEquals(1, list.getNumberOfDiffs());
237         final Diff<?> diff = list.getDiffs().get(0);
238         assertArrayEquals(ArrayUtils.toObject(class1.charArrayField), (Object[]) diff.getLeft());
239         assertArrayEquals(ArrayUtils.toObject(class2.charArrayField), (Object[]) diff.getRight());
240     }
241 
242     @Test
243     void testDiffResult() {
244         final TypeTestClass class1 = new TypeTestClass();
245         final TypeTestClass class2 = new TypeTestClass();
246         class2.intField = 2;
247 
248         final DiffResult<TypeTestClass> list = new DiffBuilder<>(class1, class2, SHORT_STYLE).append("prop1", class1.diff(class2)).build();
249         assertEquals(1, list.getNumberOfDiffs());
250         assertEquals("prop1.int", list.getDiffs().get(0).getFieldName());
251     }
252 
253     @Test
254     void testDiffResultEquals() {
255         final TypeTestClass class1 = new TypeTestClass();
256         class1.intField = 2;
257 
258         final DiffResult<TypeTestClass> list = new DiffBuilder<>(class1, class1, SHORT_STYLE).append("prop1", class1.diff(class1)).build();
259         assertEquals(0, list.getNumberOfDiffs());
260         assertTrue(list.getDiffs().isEmpty());
261     }
262 
263     @Test
264     void testDouble() {
265         final TypeTestClass class1 = new TypeTestClass();
266         final TypeTestClass class2 = new TypeTestClass();
267         class2.doubleField = 99.99;
268         final DiffResult<TypeTestClass> list = class1.diff(class2);
269         assertEquals(1, list.getNumberOfDiffs());
270         final Diff<?> diff = list.getDiffs().get(0);
271         assertEquals(Double.valueOf(class1.doubleField), diff.getLeft());
272         assertEquals(Double.valueOf(class2.doubleField), diff.getRight());
273     }
274 
275     @Test
276     void testDoubleArray() {
277         final TypeTestClass class1 = new TypeTestClass();
278         final TypeTestClass class2 = new TypeTestClass();
279         class2.doubleArrayField = new double[] { 3.0, 2.9, 2.8 };
280         final DiffResult<TypeTestClass> list = class1.diff(class2);
281         assertEquals(1, list.getNumberOfDiffs());
282         final Diff<?> diff = list.getDiffs().get(0);
283         assertArrayEquals(ArrayUtils.toObject(class1.doubleArrayField), (Object[]) diff.getLeft());
284         assertArrayEquals(ArrayUtils.toObject(class2.doubleArrayField), (Object[]) diff.getRight());
285     }
286 
287     @Test
288     void testFloat() {
289         final TypeTestClass class1 = new TypeTestClass();
290         final TypeTestClass class2 = new TypeTestClass();
291         class2.floatField = 99.99F;
292         final DiffResult<TypeTestClass> list = class1.diff(class2);
293         assertEquals(1, list.getNumberOfDiffs());
294         final Diff<?> diff = list.getDiffs().get(0);
295         assertEquals(Float.valueOf(class1.floatField), diff.getLeft());
296         assertEquals(Float.valueOf(class2.floatField), diff.getRight());
297     }
298 
299     @Test
300     void testFloatArray() {
301         final TypeTestClass class1 = new TypeTestClass();
302         final TypeTestClass class2 = new TypeTestClass();
303         class2.floatArrayField = new float[] { 3.0F, 2.9F, 2.8F };
304         final DiffResult<TypeTestClass> list = class1.diff(class2);
305         assertEquals(1, list.getNumberOfDiffs());
306         final Diff<?> diff = list.getDiffs().get(0);
307         assertArrayEquals(ArrayUtils.toObject(class1.floatArrayField), (Object[]) diff.getLeft());
308         assertArrayEquals(ArrayUtils.toObject(class2.floatArrayField), (Object[]) diff.getRight());
309     }
310 
311     @Test
312     void testInt() {
313         final TypeTestClass class1 = new TypeTestClass();
314         final TypeTestClass class2 = new TypeTestClass();
315         class2.intField = 42;
316         final DiffResult<TypeTestClass> list = class1.diff(class2);
317         assertEquals(1, list.getNumberOfDiffs());
318         final Diff<?> diff = list.getDiffs().get(0);
319         assertEquals(Integer.valueOf(class1.intField), diff.getLeft());
320         assertEquals(Integer.valueOf(class2.intField), diff.getRight());
321     }
322 
323     @Test
324     void testIntArray() {
325         final TypeTestClass class1 = new TypeTestClass();
326         final TypeTestClass class2 = new TypeTestClass();
327         class2.intArrayField = new int[] { 3, 2, 1 };
328         final DiffResult<TypeTestClass> list = class1.diff(class2);
329         assertEquals(1, list.getNumberOfDiffs());
330         final Diff<?> diff = list.getDiffs().get(0);
331         assertArrayEquals(ArrayUtils.toObject(class1.intArrayField), (Object[]) diff.getLeft());
332         assertArrayEquals(ArrayUtils.toObject(class2.intArrayField), (Object[]) diff.getRight());
333     }
334 
335     @Test
336     void testLong() {
337         final TypeTestClass class1 = new TypeTestClass();
338         final TypeTestClass class2 = new TypeTestClass();
339         class2.longField = 42L;
340         final DiffResult<TypeTestClass> list = class1.diff(class2);
341         assertEquals(1, list.getNumberOfDiffs());
342         final Diff<?> diff = list.getDiffs().get(0);
343         assertEquals(Long.valueOf(class1.longField), diff.getLeft());
344         assertEquals(Long.valueOf(class2.longField), diff.getRight());
345     }
346 
347     @Test
348     void testLongArray() {
349         final TypeTestClass class1 = new TypeTestClass();
350         final TypeTestClass class2 = new TypeTestClass();
351         class2.longArrayField = new long[] { 3L, 2L, 1L };
352         final DiffResult<TypeTestClass> list = class1.diff(class2);
353         assertEquals(1, list.getNumberOfDiffs());
354         final Diff<?> diff = list.getDiffs().get(0);
355         assertArrayEquals(ArrayUtils.toObject(class1.longArrayField), (Object[]) diff.getLeft());
356         assertArrayEquals(ArrayUtils.toObject(class2.longArrayField), (Object[]) diff.getRight());
357     }
358 
359     @Test
360     void testNestedDiffableNo() {
361         final TypeTestClass class1 = new TypeTestClass();
362         final TypeTestClass class2 = new TypeTestClass();
363         final DiffResult<TypeTestClass> list = class1.diff(class2);
364         assertEquals(0, list.getNumberOfDiffs());
365         final List<Diff<?>> diff = list.getDiffs();
366         assertTrue(diff.isEmpty());
367     }
368 
369     @Test
370     void testNestedDiffableYesNestedNot() {
371         final TypeTestClass class1 = new TypeTestClass();
372         final TypeTestClass class2 = new TypeTestClass();
373         class2.intField = 9;
374         final DiffResult<TypeTestClass> list = class1.diff(class2);
375         assertEquals(1, list.getNumberOfDiffs());
376         final Diff<?> diff = list.getDiffs().get(0);
377         assertEquals(Integer.class, diff.getType());
378         assertEquals(1, diff.getLeft());
379         assertEquals(9, diff.getRight());
380     }
381 
382     @Test
383     void testNestedDiffableYesNestedOnly() {
384         final TypeTestClass class1 = new TypeTestClass();
385         final TypeTestClass class2 = new TypeTestClass();
386         class2.nestedDiffableField.booleanField = false;
387         final DiffResult<TypeTestClass> list = class1.diff(class2);
388         assertEquals(1, list.getNumberOfDiffs());
389         final Diff<?> diff = list.getDiffs().get(0);
390         assertEquals(Object.class, diff.getType());
391         assertEquals(Boolean.TRUE, diff.getLeft());
392         assertEquals(Boolean.FALSE, diff.getRight());
393     }
394 
395     @Test
396     void testNestedDiffableYesNestedYes() {
397         final TypeTestClass class1 = new TypeTestClass();
398         final TypeTestClass class2 = new TypeTestClass();
399         class2.intField = 9;
400         class2.nestedDiffableField.booleanField = false;
401         final DiffResult<TypeTestClass> list = class1.diff(class2);
402         assertEquals(2, list.getNumberOfDiffs());
403         final Diff<?> diff0 = list.getDiffs().get(0);
404         assertEquals(Integer.class, diff0.getType());
405         assertEquals(1, diff0.getLeft());
406         assertEquals(9, diff0.getRight());
407         final Diff<?> diff1 = list.getDiffs().get(1);
408         assertEquals(Object.class, diff1.getType());
409         assertEquals(Boolean.TRUE, diff1.getLeft());
410         assertEquals(Boolean.FALSE, diff1.getRight());
411     }
412 
413     @Test
414     void testNullLhs() {
415         assertNullPointerException(() -> new DiffBuilder<>(null, this, ToStringStyle.DEFAULT_STYLE));
416     }
417 
418     @Test
419     void testNullLhs_4args() {
420         assertNullPointerException(() -> new DiffBuilder<>(null, this, ToStringStyle.DEFAULT_STYLE, true));
421     }
422 
423     @Test
424     void testNullRhs() {
425         assertNullPointerException(() -> new DiffBuilder<>(this, null, ToStringStyle.DEFAULT_STYLE));
426     }
427 
428     @Test
429     void testNullRhs_4args() {
430         assertNullPointerException(() -> new DiffBuilder<>(this, null, ToStringStyle.DEFAULT_STYLE, true));
431     }
432 
433     @Test
434     void testObject() {
435         final TypeTestClass class1 = new TypeTestClass();
436         final TypeTestClass class2 = new TypeTestClass();
437         class2.objectField = "Some string";
438         final DiffResult<TypeTestClass> list = class1.diff(class2);
439         assertEquals(1, list.getNumberOfDiffs());
440         final Diff<?> diff = list.getDiffs().get(0);
441         assertEquals(class1.objectField, diff.getLeft());
442         assertEquals(class2.objectField, diff.getRight());
443     }
444 
445     @Test
446     void testObjectArray() {
447         final TypeTestClass class1 = new TypeTestClass();
448         final TypeTestClass class2 = new TypeTestClass();
449         class2.objectArrayField = new Object[] { "string", 1, 2 };
450         final DiffResult<TypeTestClass> list = class1.diff(class2);
451         assertEquals(1, list.getNumberOfDiffs());
452         final Diff<?> diff = list.getDiffs().get(0);
453         assertArrayEquals(class1.objectArrayField, (Object[]) diff.getLeft());
454         assertArrayEquals(class2.objectArrayField, (Object[]) diff.getRight());
455     }
456 
457     @Test
458     void testObjectArrayEqual() {
459         final TypeTestClass class1 = new TypeTestClass();
460         final TypeTestClass class2 = new TypeTestClass();
461         class1.objectArrayField = new Object[] { "string", 1, 2 };
462         class2.objectArrayField = new Object[] { "string", 1, 2 };
463         final DiffResult<TypeTestClass> list = class1.diff(class2);
464         assertEquals(0, list.getNumberOfDiffs());
465     }
466 
467     /**
468      * Test that "left" and "right" are the same instance but are equal.
469      */
470     @Test
471     void testObjectsNotSameButEqual() {
472         final TypeTestClass left = new TypeTestClass();
473         left.objectField = Integer.valueOf(1000);
474         final TypeTestClass right = new TypeTestClass();
475         right.objectField = Integer.valueOf(1000);
476         assertNotSame(left.objectField, right.objectField);
477         assertEquals(left.objectField, right.objectField);
478 
479         final DiffResult<TypeTestClass> list = left.diff(right);
480         assertEquals(0, list.getNumberOfDiffs());
481     }
482 
483     /**
484      * Test that "left" and "right" are not the same instance and are not equal.
485      */
486     @Test
487     void testObjectsNotSameNorEqual() {
488         final TypeTestClass left = new TypeTestClass();
489         left.objectField = 4;
490         final TypeTestClass right = new TypeTestClass();
491         right.objectField = 100;
492         assertNotSame(left.objectField, right.objectField);
493         assertNotEquals(left.objectField, right.objectField);
494 
495         final DiffResult<TypeTestClass> list = left.diff(right);
496         assertEquals(1, list.getNumberOfDiffs());
497     }
498 
499     /**
500      * Test that "left" and "right" are the same instance and are equal.
501      */
502     @Test
503     void testObjectsSameAndEqual() {
504         final Integer sameObject = 1;
505         final TypeTestClass left = new TypeTestClass();
506         left.objectField = sameObject;
507         final TypeTestClass right = new TypeTestClass();
508         right.objectField = sameObject;
509         assertSame(left.objectField, right.objectField);
510         assertEquals(left.objectField, right.objectField);
511 
512         final DiffResult<TypeTestClass> list = left.diff(right);
513         assertEquals(0, list.getNumberOfDiffs());
514     }
515 
516     @Test
517     void testSameObjectIgnoresAppends() {
518         final TypeTestClass testClass = new TypeTestClass();
519         final DiffResult<TypeTestClass> list = new DiffBuilder<>(testClass, testClass, SHORT_STYLE).append("ignored", false, true).build();
520         assertEquals(0, list.getNumberOfDiffs());
521     }
522 
523     @Test
524     void testShort() {
525         final TypeTestClass class1 = new TypeTestClass();
526         final TypeTestClass class2 = new TypeTestClass();
527         class2.shortField = 42;
528         final DiffResult<TypeTestClass> list = class1.diff(class2);
529         assertEquals(1, list.getNumberOfDiffs());
530         final Diff<?> diff = list.getDiffs().get(0);
531         assertEquals(Short.valueOf(class1.shortField), diff.getLeft());
532         assertEquals(Short.valueOf(class2.shortField), diff.getRight());
533     }
534 
535     @Test
536     void testShortArray() {
537         final TypeTestClass class1 = new TypeTestClass();
538         final TypeTestClass class2 = new TypeTestClass();
539         class2.shortArrayField = new short[] { 3, 2, 1 };
540         final DiffResult<TypeTestClass> list = class1.diff(class2);
541         assertEquals(1, list.getNumberOfDiffs());
542         final Diff<?> diff = list.getDiffs().get(0);
543         assertArrayEquals(ArrayUtils.toObject(class1.shortArrayField), (Object[]) diff.getLeft());
544         assertArrayEquals(ArrayUtils.toObject(class2.shortArrayField), (Object[]) diff.getRight());
545     }
546 
547     @Test
548     void testSimilarObjectIgnoresAppends() {
549         final TypeTestClass testClass1 = new TypeTestClass();
550         final TypeTestClass testClass2 = new TypeTestClass();
551         final DiffResult<TypeTestClass> list = new DiffBuilder<>(testClass1, testClass2, SHORT_STYLE).append("ignored", false, true).build();
552         assertEquals(0, list.getNumberOfDiffs());
553     }
554 
555     @Test
556     void testStylePassedToDiffResult() {
557         final TypeTestClass class1 = new TypeTestClass();
558         DiffResult<TypeTestClass> list = class1.diff(class1);
559         assertEquals(SHORT_STYLE, list.getToStringStyle());
560 
561         class1.style = ToStringStyle.MULTI_LINE_STYLE;
562         list = class1.diff(class1);
563         assertEquals(ToStringStyle.MULTI_LINE_STYLE, list.getToStringStyle());
564     }
565 
566     @Test
567     void testTriviallyEqualTestDisabled() {
568         // Constructor's arguments are not trivially equal, but not testing for that.
569         final DiffBuilder<Integer> explicitTestAndNotEqual1 = new DiffBuilder<>(1, 2, null, false);
570         explicitTestAndNotEqual1.append("letter", "X", "Y");
571         assertEquals(1, explicitTestAndNotEqual1.build().getNumberOfDiffs());
572 
573         // Constructor's arguments are trivially equal, but not testing for that.
574         final DiffBuilder<Integer> explicitTestAndNotEqual2 = new DiffBuilder<>(1, 1, null, false);
575         // This append(f, l, r) will not abort early.
576         explicitTestAndNotEqual2.append("letter", "X", "Y");
577         assertEquals(1, explicitTestAndNotEqual2.build().getNumberOfDiffs());
578     }
579 
580     @Test
581     void testTriviallyEqualTestEnabled() {
582         // The option to test if trivially equal is enabled by default.
583         final DiffBuilder<Integer> implicitTestAndEqual = new DiffBuilder<>(1, 1, null);
584         // This append(f, l, r) will abort without creating a Diff for letter.
585         implicitTestAndEqual.append("letter", "X", "Y");
586         assertEquals(0, implicitTestAndEqual.build().getNumberOfDiffs());
587 
588         final DiffBuilder<Integer> implicitTestAndNotEqual = new DiffBuilder<>(1, 2, null);
589         // This append(f, l, r) will not abort early
590         // because the constructor's arguments were not trivially equal.
591         implicitTestAndNotEqual.append("letter", "X", "Y");
592         assertEquals(1, implicitTestAndNotEqual.build().getNumberOfDiffs());
593 
594         // This is explicitly enabling the trivially equal test.
595         final DiffBuilder<Integer> explicitTestAndEqual = new DiffBuilder<>(1, 1, null, true);
596         explicitTestAndEqual.append("letter", "X", "Y");
597         assertEquals(0, explicitTestAndEqual.build().getNumberOfDiffs());
598     }
599 
600 }