@Override public DiffResult diff(final SimpleClass obj) { return new DiffBuilder(this, obj, ToStringStyle.SHORT_PREFIX_STYLE) .append(getFieldName(), booleanField, obj.booleanField) .build(); } }
@Test public void testTriviallyEqualTestDisabled() { final Matcher<Integer> equalToOne = equalTo(1); // Constructor's arguments are not trivially equal, but not testing for that. final DiffBuilder explicitTestAndNotEqual1 = new DiffBuilder(1, 2, null, false); explicitTestAndNotEqual1.append("letter", "X", "Y"); assertThat(explicitTestAndNotEqual1.build().getNumberOfDiffs(), equalToOne); // Constructor's arguments are trivially equal, but not testing for that. final DiffBuilder explicitTestAndNotEqual2 = new DiffBuilder(1, 1, null, false); // This append(f, l, r) will not abort early. explicitTestAndNotEqual2.append("letter", "X", "Y"); assertThat(explicitTestAndNotEqual2.build().getNumberOfDiffs(), equalToOne); }
@Test public void testNoDifferencesString() { final DiffResult diffResult = new DiffBuilder(SIMPLE_TRUE, SIMPLE_TRUE, SHORT_STYLE).build(); assertEquals(DiffResult.OBJECTS_SAME_STRING, diffResult.toString()); } }
@Test public void testTriviallyEqualTestEnabled() { final Matcher<Integer> equalToZero = equalTo(0); final Matcher<Integer> equalToOne = equalTo(1); // The option to test if trivially equal is enabled by default. final DiffBuilder implicitTestAndEqual = new DiffBuilder(1, 1, null); // This append(f, l, r) will abort without creating a Diff for letter. implicitTestAndEqual.append("letter", "X", "Y"); assertThat(implicitTestAndEqual.build().getNumberOfDiffs(), equalToZero); final DiffBuilder implicitTestAndNotEqual = new DiffBuilder(1, 2, null); // This append(f, l, r) will not abort early // because the constructor's arguments were not trivially equal. implicitTestAndNotEqual.append("letter", "X", "Y"); assertThat(implicitTestAndNotEqual.build().getNumberOfDiffs(), equalToOne); // This is explicitly enabling the trivially equal test. final DiffBuilder explicitTestAndEqual = new DiffBuilder(1, 1, null, true); explicitTestAndEqual.append("letter", "X", "Y"); assertThat(explicitTestAndEqual.build().getNumberOfDiffs(), equalToZero); }
@Test public void testSameObjectIgnoresAppends() { final TypeTestClass testClass = new TypeTestClass(); final DiffResult list = new DiffBuilder(testClass, testClass, SHORT_STYLE) .append("ignored", false, true) .build(); assertEquals(0, list.getNumberOfDiffs()); }
@Test public void testSimilarObjectIgnoresAppends() { final TypeTestClass testClass1 = new TypeTestClass(); final TypeTestClass testClass2 = new TypeTestClass(); final DiffResult list = new DiffBuilder(testClass1, testClass2, SHORT_STYLE) .append("ignored", false, true) .build(); assertEquals(0, list.getNumberOfDiffs()); }
@Test public void testDiffResult() { final TypeTestClass class1 = new TypeTestClass(); final TypeTestClass class2 = new TypeTestClass(); class2.intField = 2; final DiffResult list = new DiffBuilder(class1, class2, SHORT_STYLE) .append("prop1", class1.diff(class2)) .build(); assertEquals(1, list.getNumberOfDiffs()); assertEquals("prop1.int", list.getDiffs().get(0).getFieldName()); }
@Test public void testToStringOutput() { final DiffResult list = new DiffBuilder(new EmptyClass(), new EmptyClass(), ToStringStyle.SHORT_PREFIX_STYLE).append("test", false, true) .build(); assertEquals( "DiffResultTest.EmptyClass[test=false] differs from DiffResultTest.EmptyClass[test=true]", list.toString()); }
@Test public void testByteArrayEqualAsObject() throws Exception { final DiffResult list = new DiffBuilder("String1", "String2", SHORT_STYLE) .append("foo", new boolean[] {false}, new boolean[] {false}) .append("foo", new byte[] {0x01}, new byte[] {0x01}) .append("foo", new char[] {'a'}, new char[] {'a'}) .append("foo", new double[] {1.0}, new double[] {1.0}) .append("foo", new float[] {1.0F}, new float[] {1.0F}) .append("foo", new int[] {1}, new int[] {1}) .append("foo", new long[] {1L}, new long[] {1L}) .append("foo", new short[] {1}, new short[] {1}) .append("foo", new Object[] {1, "two"}, new Object[] {1, "two"}) .build(); assertEquals(0, list.getNumberOfDiffs()); }
@Override public DiffResult diff(final TypeTestClass obj) { return new DiffBuilder(this, obj, style) .append("boolean", booleanField, obj.booleanField) .append("booleanArray", booleanArrayField, obj.booleanArrayField) .append("byte", byteField, obj.byteField) .append("byteArray", byteArrayField, obj.byteArrayField) .append("char", charField, obj.charField) .append("charArray", charArrayField, obj.charArrayField) .append("double", doubleField, obj.doubleField) .append("doubleArray", doubleArrayField, obj.doubleArrayField) .append("float", floatField, obj.floatField) .append("floatArray", floatArrayField, obj.floatArrayField) .append("int", intField, obj.intField) .append("intArray", intArrayField, obj.intArrayField) .append("long", longField, obj.longField) .append("longArray", longArrayField, obj.longArrayField) .append("short", shortField, obj.shortField) .append("shortArray", shortArrayField, obj.shortArrayField) .append("objectField", objectField, obj.objectField) .append("objectArrayField", objectArrayField, obj.objectArrayField) .build(); }
/** * Static internal method for {@link DiffProcessor}, do not use outside context */ public static <T> DiffResult diffMap( DiffFunctions diffFunctions, Class<T> c, Map<String, ? extends T> lhs, Map<String, ? extends T> rhs) { final Map<String, ? extends T> localRhs = rhs != null ? rhs : Collections.emptyMap(); final Map<String, ? extends T> localLhs = lhs != null ? lhs : Collections.emptyMap(); DiffBuilder db = new DiffBuilder(localLhs, localRhs, ToStringStyle.DEFAULT_STYLE, false); localLhs.forEach((key, lhsValue) -> diffByType(diffFunctions, c, localRhs, db, key, lhsValue)); localRhs.keySet().stream() .filter(k -> !localLhs.containsKey(k)) .forEach(key -> diffByType(diffFunctions, c, localRhs, db, key, null)); return db.build(); }
/** * Static internal method for {@link DiffProcessor}, do not use outside context */ public static <T> DiffResult diffInternalClass( DiffFunctions diffFunctions, Class<T> c, T lhs, T rhs) { if (lhs == null || rhs == null) { return new DiffBuilder(emptyOrNotEmpty(lhs), emptyOrNotEmpty(rhs), ToStringStyle.DEFAULT_STYLE, false) .append(lhs == null ? NEW_MARKER : DELETED_MARKER, lhs, rhs) .build(); } return diffFunctions.diffFor(c, lhs, rhs); }