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