You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by gg...@apache.org on 2023/12/11 17:46:29 UTC
(commons-lang) branch master updated: Internal refactoring
This is an automated email from the ASF dual-hosted git repository.
ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-lang.git
The following commit(s) were added to refs/heads/master by this push:
new faa1a1eea Internal refactoring
faa1a1eea is described below
commit faa1a1eea544dbdf5c2fa88c622e6e3eedd09837
Author: Gary Gregory <ga...@gmail.com>
AuthorDate: Mon Dec 11 12:46:19 2023 -0500
Internal refactoring
Use lambdas instead of anonymous inner classes
---
.../org/apache/commons/lang3/builder/Diff.java | 9 +-
.../apache/commons/lang3/builder/DiffBuilder.java | 455 +++------------------
.../commons/lang3/builder/DiffBuilderTest.java | 149 +++----
3 files changed, 119 insertions(+), 494 deletions(-)
diff --git a/src/main/java/org/apache/commons/lang3/builder/Diff.java b/src/main/java/org/apache/commons/lang3/builder/Diff.java
index b8a1af99f..da0335aad 100644
--- a/src/main/java/org/apache/commons/lang3/builder/Diff.java
+++ b/src/main/java/org/apache/commons/lang3/builder/Diff.java
@@ -54,9 +54,12 @@ public abstract class Diff<T> extends Pair<T, T> {
* the field name
*/
protected Diff(final String fieldName) {
- this.type = ObjectUtils.defaultIfNull(
- TypeUtils.getTypeArguments(getClass(), Diff.class).get(
- Diff.class.getTypeParameters()[0]), Object.class);
+ this.type = ObjectUtils.defaultIfNull(TypeUtils.getTypeArguments(getClass(), Diff.class).get(Diff.class.getTypeParameters()[0]), Object.class);
+ this.fieldName = fieldName;
+ }
+
+ Diff(final String fieldName, final Type type) {
+ this.type = type;
this.fieldName = fieldName;
}
diff --git a/src/main/java/org/apache/commons/lang3/builder/DiffBuilder.java b/src/main/java/org/apache/commons/lang3/builder/DiffBuilder.java
index e2415c3eb..38083f381 100644
--- a/src/main/java/org/apache/commons/lang3/builder/DiffBuilder.java
+++ b/src/main/java/org/apache/commons/lang3/builder/DiffBuilder.java
@@ -20,6 +20,7 @@ import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
+import java.util.function.Supplier;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.ObjectUtils;
@@ -70,10 +71,33 @@ import org.apache.commons.lang3.ObjectUtils;
*/
public class DiffBuilder<T> implements Builder<DiffResult<T>> {
+ private static final class SDiff<T> extends Diff<T> {
+
+ private static final long serialVersionUID = 1L;
+ private final transient Supplier<T> leftS;
+ private final transient Supplier<T> rightS;
+
+ private SDiff(final String fieldName, final Supplier<T> leftS, final Supplier<T> rightS, final Class<T> type) {
+ super(fieldName, type);
+ this.leftS = leftS;
+ this.rightS = rightS;
+ }
+
+ @Override
+ public T getLeft() {
+ return leftS.get();
+ }
+
+ @Override
+ public T getRight() {
+ return rightS.get();
+ }
+
+ }
static final String TO_STRING_FORMAT = "%s differs from %s";
private final List<Diff<?>> diffs;
- private final boolean objectsEquals;
+ private final boolean equals;
private final T left;
private final T right;
private final ToStringStyle style;
@@ -140,7 +164,12 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
this.toStringFormat = DiffBuilder.TO_STRING_FORMAT;
this.style = style != null ? style : ToStringStyle.DEFAULT_STYLE;
// Don't compare any fields if objects equal
- this.objectsEquals = testObjectsEquals && Objects.equals(lhs, rhs);
+ this.equals = testObjectsEquals && Objects.equals(lhs, rhs);
+ }
+
+ private <F> DiffBuilder<T> add(final String fieldName, final Supplier<F> left, final Supplier<F> right, final Class<F> type) {
+ diffs.add(new SDiff<>(Objects.requireNonNull(fieldName, "fieldName"), left, right, type));
+ return this;
}
/**
@@ -157,27 +186,7 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
* if field name is {@code null}
*/
public DiffBuilder<T> append(final String fieldName, final boolean lhs, final boolean rhs) {
- validateFieldNameNotNull(fieldName);
-
- if (objectsEquals) {
- return this;
- }
- if (lhs != rhs) {
- diffs.add(new Diff<Boolean>(fieldName) {
- private static final long serialVersionUID = 1L;
-
- @Override
- public Boolean getLeft() {
- return Boolean.valueOf(lhs);
- }
-
- @Override
- public Boolean getRight() {
- return Boolean.valueOf(rhs);
- }
- });
- }
- return this;
+ return equals || lhs == rhs ? this : add(fieldName, () -> Boolean.valueOf(lhs), () -> Boolean.valueOf(rhs), Boolean.class);
}
/**
@@ -194,26 +203,7 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
* if field name is {@code null}
*/
public DiffBuilder<T> append(final String fieldName, final boolean[] lhs, final boolean[] rhs) {
- validateFieldNameNotNull(fieldName);
- if (objectsEquals) {
- return this;
- }
- if (!Arrays.equals(lhs, rhs)) {
- diffs.add(new Diff<Boolean[]>(fieldName) {
- private static final long serialVersionUID = 1L;
-
- @Override
- public Boolean[] getLeft() {
- return ArrayUtils.toObject(lhs);
- }
-
- @Override
- public Boolean[] getRight() {
- return ArrayUtils.toObject(rhs);
- }
- });
- }
- return this;
+ return equals || Arrays.equals(lhs, rhs) ? this : add(fieldName, () -> ArrayUtils.toObject(lhs), () -> ArrayUtils.toObject(rhs), Boolean[].class);
}
/**
@@ -230,26 +220,7 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
* if field name is {@code null}
*/
public DiffBuilder<T> append(final String fieldName, final byte lhs, final byte rhs) {
- validateFieldNameNotNull(fieldName);
- if (objectsEquals) {
- return this;
- }
- if (lhs != rhs) {
- diffs.add(new Diff<Byte>(fieldName) {
- private static final long serialVersionUID = 1L;
-
- @Override
- public Byte getLeft() {
- return Byte.valueOf(lhs);
- }
-
- @Override
- public Byte getRight() {
- return Byte.valueOf(rhs);
- }
- });
- }
- return this;
+ return equals || lhs == rhs ? this : add(fieldName, () -> Byte.valueOf(lhs), () -> Byte.valueOf(rhs), Byte.class);
}
/**
@@ -266,27 +237,7 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
* if field name is {@code null}
*/
public DiffBuilder<T> append(final String fieldName, final byte[] lhs, final byte[] rhs) {
- validateFieldNameNotNull(fieldName);
-
- if (objectsEquals) {
- return this;
- }
- if (!Arrays.equals(lhs, rhs)) {
- diffs.add(new Diff<Byte[]>(fieldName) {
- private static final long serialVersionUID = 1L;
-
- @Override
- public Byte[] getLeft() {
- return ArrayUtils.toObject(lhs);
- }
-
- @Override
- public Byte[] getRight() {
- return ArrayUtils.toObject(rhs);
- }
- });
- }
- return this;
+ return equals || Arrays.equals(lhs, rhs) ? this : add(fieldName, () -> ArrayUtils.toObject(lhs), () -> ArrayUtils.toObject(rhs), Byte[].class);
}
/**
@@ -303,27 +254,7 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
* if field name is {@code null}
*/
public DiffBuilder<T> append(final String fieldName, final char lhs, final char rhs) {
- validateFieldNameNotNull(fieldName);
-
- if (objectsEquals) {
- return this;
- }
- if (lhs != rhs) {
- diffs.add(new Diff<Character>(fieldName) {
- private static final long serialVersionUID = 1L;
-
- @Override
- public Character getLeft() {
- return Character.valueOf(lhs);
- }
-
- @Override
- public Character getRight() {
- return Character.valueOf(rhs);
- }
- });
- }
- return this;
+ return equals || lhs == rhs ? this : add(fieldName, () -> Character.valueOf(lhs), () -> Character.valueOf(rhs), Character.class);
}
/**
@@ -340,34 +271,14 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
* if field name is {@code null}
*/
public DiffBuilder<T> append(final String fieldName, final char[] lhs, final char[] rhs) {
- validateFieldNameNotNull(fieldName);
-
- if (objectsEquals) {
- return this;
- }
- if (!Arrays.equals(lhs, rhs)) {
- diffs.add(new Diff<Character[]>(fieldName) {
- private static final long serialVersionUID = 1L;
-
- @Override
- public Character[] getLeft() {
- return ArrayUtils.toObject(lhs);
- }
-
- @Override
- public Character[] getRight() {
- return ArrayUtils.toObject(rhs);
- }
- });
- }
- return this;
+ return equals || Arrays.equals(lhs, rhs) ? this : add(fieldName, () -> ArrayUtils.toObject(lhs), () -> ArrayUtils.toObject(rhs), Character[].class);
}
/**
* Append diffs from another {@link DiffResult}.
*
* <p>
- * This method is useful if you want to compare properties which are
+ * Useful this method to compare properties which are
* themselves Diffable and would like to know which specific part of
* it is different.
* </p>
@@ -397,9 +308,8 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
* @since 3.5
*/
public DiffBuilder<T> append(final String fieldName, final DiffResult<T> diffResult) {
- validateFieldNameNotNull(fieldName);
Objects.requireNonNull(diffResult, "diffResult");
- if (objectsEquals) {
+ if (equals) {
return this;
}
diffResult.getDiffs().forEach(diff -> append(fieldName + "." + diff.getFieldName(), diff.getLeft(), diff.getRight()));
@@ -420,27 +330,8 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
* if field name is {@code null}
*/
public DiffBuilder<T> append(final String fieldName, final double lhs, final double rhs) {
- validateFieldNameNotNull(fieldName);
-
- if (objectsEquals) {
- return this;
- }
- if (Double.doubleToLongBits(lhs) != Double.doubleToLongBits(rhs)) {
- diffs.add(new Diff<Double>(fieldName) {
- private static final long serialVersionUID = 1L;
-
- @Override
- public Double getLeft() {
- return Double.valueOf(lhs);
- }
-
- @Override
- public Double getRight() {
- return Double.valueOf(rhs);
- }
- });
- }
- return this;
+ return equals || Double.doubleToLongBits(lhs) == Double.doubleToLongBits(rhs) ? this
+ : add(fieldName, () -> Double.valueOf(lhs), () -> Double.valueOf(rhs), Double.class);
}
/**
@@ -457,27 +348,7 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
* if field name is {@code null}
*/
public DiffBuilder<T> append(final String fieldName, final double[] lhs, final double[] rhs) {
- validateFieldNameNotNull(fieldName);
-
- if (objectsEquals) {
- return this;
- }
- if (!Arrays.equals(lhs, rhs)) {
- diffs.add(new Diff<Double[]>(fieldName) {
- private static final long serialVersionUID = 1L;
-
- @Override
- public Double[] getLeft() {
- return ArrayUtils.toObject(lhs);
- }
-
- @Override
- public Double[] getRight() {
- return ArrayUtils.toObject(rhs);
- }
- });
- }
- return this;
+ return equals || Arrays.equals(lhs, rhs) ? this : add(fieldName, () -> ArrayUtils.toObject(lhs), () -> ArrayUtils.toObject(rhs), Double[].class);
}
/**
@@ -493,29 +364,9 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
* @throws NullPointerException
* if field name is {@code null}
*/
- public DiffBuilder<T> append(final String fieldName, final float lhs,
- final float rhs) {
- validateFieldNameNotNull(fieldName);
-
- if (objectsEquals) {
- return this;
- }
- if (Float.floatToIntBits(lhs) != Float.floatToIntBits(rhs)) {
- diffs.add(new Diff<Float>(fieldName) {
- private static final long serialVersionUID = 1L;
-
- @Override
- public Float getLeft() {
- return Float.valueOf(lhs);
- }
-
- @Override
- public Float getRight() {
- return Float.valueOf(rhs);
- }
- });
- }
- return this;
+ public DiffBuilder<T> append(final String fieldName, final float lhs, final float rhs) {
+ return equals || Float.floatToIntBits(lhs) == Float.floatToIntBits(rhs) ? this
+ : add(fieldName, () -> Float.valueOf(lhs), () -> Float.valueOf(rhs), Float.class);
}
/**
@@ -532,27 +383,7 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
* if field name is {@code null}
*/
public DiffBuilder<T> append(final String fieldName, final float[] lhs, final float[] rhs) {
- validateFieldNameNotNull(fieldName);
-
- if (objectsEquals) {
- return this;
- }
- if (!Arrays.equals(lhs, rhs)) {
- diffs.add(new Diff<Float[]>(fieldName) {
- private static final long serialVersionUID = 1L;
-
- @Override
- public Float[] getLeft() {
- return ArrayUtils.toObject(lhs);
- }
-
- @Override
- public Float[] getRight() {
- return ArrayUtils.toObject(rhs);
- }
- });
- }
- return this;
+ return equals || Arrays.equals(lhs, rhs) ? this : add(fieldName, () -> ArrayUtils.toObject(lhs), () -> ArrayUtils.toObject(rhs), Float[].class);
}
/**
@@ -569,27 +400,7 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
* if field name is {@code null}
*/
public DiffBuilder<T> append(final String fieldName, final int lhs, final int rhs) {
- validateFieldNameNotNull(fieldName);
-
- if (objectsEquals) {
- return this;
- }
- if (lhs != rhs) {
- diffs.add(new Diff<Integer>(fieldName) {
- private static final long serialVersionUID = 1L;
-
- @Override
- public Integer getLeft() {
- return Integer.valueOf(lhs);
- }
-
- @Override
- public Integer getRight() {
- return Integer.valueOf(rhs);
- }
- });
- }
- return this;
+ return equals || lhs == rhs ? this : add(fieldName, () -> Integer.valueOf(lhs), () -> Integer.valueOf(rhs), Integer.class);
}
/**
@@ -606,27 +417,7 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
* if field name is {@code null}
*/
public DiffBuilder<T> append(final String fieldName, final int[] lhs, final int[] rhs) {
- validateFieldNameNotNull(fieldName);
-
- if (objectsEquals) {
- return this;
- }
- if (!Arrays.equals(lhs, rhs)) {
- diffs.add(new Diff<Integer[]>(fieldName) {
- private static final long serialVersionUID = 1L;
-
- @Override
- public Integer[] getLeft() {
- return ArrayUtils.toObject(lhs);
- }
-
- @Override
- public Integer[] getRight() {
- return ArrayUtils.toObject(rhs);
- }
- });
- }
- return this;
+ return equals || Arrays.equals(lhs, rhs) ? this : add(fieldName, () -> ArrayUtils.toObject(lhs), () -> ArrayUtils.toObject(rhs), Integer[].class);
}
/**
@@ -643,27 +434,7 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
* if field name is {@code null}
*/
public DiffBuilder<T> append(final String fieldName, final long lhs, final long rhs) {
- validateFieldNameNotNull(fieldName);
-
- if (objectsEquals) {
- return this;
- }
- if (lhs != rhs) {
- diffs.add(new Diff<Long>(fieldName) {
- private static final long serialVersionUID = 1L;
-
- @Override
- public Long getLeft() {
- return Long.valueOf(lhs);
- }
-
- @Override
- public Long getRight() {
- return Long.valueOf(rhs);
- }
- });
- }
- return this;
+ return equals || lhs == rhs ? this : add(fieldName, () -> Long.valueOf(lhs), () -> Long.valueOf(rhs), Long.class);
}
/**
@@ -680,27 +451,7 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
* if field name is {@code null}
*/
public DiffBuilder<T> append(final String fieldName, final long[] lhs, final long[] rhs) {
- validateFieldNameNotNull(fieldName);
-
- if (objectsEquals) {
- return this;
- }
- if (!Arrays.equals(lhs, rhs)) {
- diffs.add(new Diff<Long[]>(fieldName) {
- private static final long serialVersionUID = 1L;
-
- @Override
- public Long[] getLeft() {
- return ArrayUtils.toObject(lhs);
- }
-
- @Override
- public Long[] getRight() {
- return ArrayUtils.toObject(rhs);
- }
- });
- }
- return this;
+ return equals || Arrays.equals(lhs, rhs) ? this : add(fieldName, () -> ArrayUtils.toObject(lhs), () -> ArrayUtils.toObject(rhs), Long[].class);
}
/**
@@ -717,22 +468,11 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
* if field name is {@code null}
*/
public DiffBuilder<T> append(final String fieldName, final Object lhs, final Object rhs) {
- validateFieldNameNotNull(fieldName);
- if (objectsEquals) {
- return this;
- }
- if (lhs == rhs) {
+ if (equals || lhs == rhs) {
return this;
}
-
- final Object objectToTest;
- if (lhs != null) {
- objectToTest = lhs;
- } else {
- // rhs cannot be null, as lhs != rhs
- objectToTest = rhs;
- }
-
+ // rhs cannot be null, as lhs != rhs
+ final Object objectToTest = lhs != null ? lhs : rhs;
if (ObjectUtils.isArray(objectToTest)) {
if (objectToTest instanceof boolean[]) {
return append(fieldName, (boolean[]) lhs, (boolean[]) rhs);
@@ -758,29 +498,13 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
if (objectToTest instanceof short[]) {
return append(fieldName, (short[]) lhs, (short[]) rhs);
}
-
return append(fieldName, (Object[]) lhs, (Object[]) rhs);
}
-
// Not array type
if (Objects.equals(lhs, rhs)) {
return this;
}
-
- diffs.add(new Diff<Object>(fieldName) {
- private static final long serialVersionUID = 1L;
-
- @Override
- public Object getLeft() {
- return lhs;
- }
-
- @Override
- public Object getRight() {
- return rhs;
- }
- });
-
+ add(fieldName, () -> lhs, () -> rhs, Object.class);
return this;
}
@@ -798,28 +522,7 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
* if field name is {@code null}
*/
public DiffBuilder<T> append(final String fieldName, final Object[] lhs, final Object[] rhs) {
- validateFieldNameNotNull(fieldName);
- if (objectsEquals) {
- return this;
- }
-
- if (!Arrays.equals(lhs, rhs)) {
- diffs.add(new Diff<Object[]>(fieldName) {
- private static final long serialVersionUID = 1L;
-
- @Override
- public Object[] getLeft() {
- return lhs;
- }
-
- @Override
- public Object[] getRight() {
- return rhs;
- }
- });
- }
-
- return this;
+ return equals || Arrays.equals(lhs, rhs) ? this : add(fieldName, () -> lhs, () -> rhs, Object[].class);
}
/**
@@ -836,27 +539,7 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
* if field name is {@code null}
*/
public DiffBuilder<T> append(final String fieldName, final short lhs, final short rhs) {
- validateFieldNameNotNull(fieldName);
-
- if (objectsEquals) {
- return this;
- }
- if (lhs != rhs) {
- diffs.add(new Diff<Short>(fieldName) {
- private static final long serialVersionUID = 1L;
-
- @Override
- public Short getLeft() {
- return Short.valueOf(lhs);
- }
-
- @Override
- public Short getRight() {
- return Short.valueOf(rhs);
- }
- });
- }
- return this;
+ return equals || lhs == rhs ? this : add(fieldName, () -> Short.valueOf(lhs), () -> Short.valueOf(rhs), Short.class);
}
/**
@@ -873,27 +556,7 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
* if field name is {@code null}
*/
public DiffBuilder<T> append(final String fieldName, final short[] lhs, final short[] rhs) {
- validateFieldNameNotNull(fieldName);
-
- if (objectsEquals) {
- return this;
- }
- if (!Arrays.equals(lhs, rhs)) {
- diffs.add(new Diff<Short[]>(fieldName) {
- private static final long serialVersionUID = 1L;
-
- @Override
- public Short[] getLeft() {
- return ArrayUtils.toObject(lhs);
- }
-
- @Override
- public Short[] getRight() {
- return ArrayUtils.toObject(rhs);
- }
- });
- }
- return this;
+ return equals || Arrays.equals(lhs, rhs) ? this : add(fieldName, () -> ArrayUtils.toObject(lhs), () -> ArrayUtils.toObject(rhs), Short[].class);
}
/**
@@ -908,8 +571,4 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
return new DiffResult<>(left, right, diffs, style, toStringFormat);
}
- private void validateFieldNameNotNull(final String fieldName) {
- Objects.requireNonNull(fieldName, "fieldName");
- }
-
}
diff --git a/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java b/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java
index d1fb69ad1..c43df6513 100644
--- a/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java
+++ b/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java
@@ -38,46 +38,36 @@ public class DiffBuilderTest extends AbstractLangTest {
private static final class TypeTestClass implements Diffable<TypeTestClass> {
private ToStringStyle style = SHORT_STYLE;
private boolean booleanField = true;
- private boolean[] booleanArrayField = {true};
+ private boolean[] booleanArrayField = { true };
private byte byteField = (byte) 0xFF;
- private byte[] byteArrayField = {(byte) 0xFF};
+ private byte[] byteArrayField = { (byte) 0xFF };
private char charField = 'a';
- private char[] charArrayField = {'a'};
+ private char[] charArrayField = { 'a' };
private double doubleField = 1.0;
- private double[] doubleArrayField = {1.0};
+ private double[] doubleArrayField = { 1.0 };
private float floatField = 1.0f;
- private float[] floatArrayField = {1.0f};
+ private float[] floatArrayField = { 1.0f };
private int intField = 1;
- private int[] intArrayField = {1};
+ private int[] intArrayField = { 1 };
private long longField = 1L;
- private long[] longArrayField = {1L};
+ private long[] longArrayField = { 1L };
private short shortField = 1;
- private short[] shortArrayField = {1};
+ private short[] shortArrayField = { 1 };
private Object objectField;
- private Object[] objectArrayField = {null};
+ private Object[] objectArrayField = { null };
@Override
public DiffResult<TypeTestClass> 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();
+ 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();
}
@Override
@@ -101,7 +91,7 @@ public class DiffBuilderTest extends AbstractLangTest {
final DiffResult<TypeTestClass> list = class1.diff(class2);
assertEquals(1, list.getNumberOfDiffs());
final Diff<?> diff = list.getDiffs().get(0);
- assertEquals(Boolean.class, diff.getType());
+ assertEquals(Boolean.class, diff.getType(), () -> diff.getType().getClass().toString());
assertEquals(Boolean.TRUE, diff.getLeft());
assertEquals(Boolean.FALSE, diff.getRight());
}
@@ -110,14 +100,12 @@ public class DiffBuilderTest extends AbstractLangTest {
public void testBooleanArray() {
final TypeTestClass class1 = new TypeTestClass();
final TypeTestClass class2 = new TypeTestClass();
- class2.booleanArrayField = new boolean[] {false, false};
+ class2.booleanArrayField = new boolean[] { false, false };
final DiffResult<TypeTestClass> list = class1.diff(class2);
assertEquals(1, list.getNumberOfDiffs());
final Diff<?> diff = list.getDiffs().get(0);
- assertArrayEquals(ArrayUtils.toObject(class1.booleanArrayField),
- (Object[]) diff.getLeft());
- assertArrayEquals(ArrayUtils.toObject(class2.booleanArrayField),
- (Object[]) diff.getRight());
+ assertArrayEquals(ArrayUtils.toObject(class1.booleanArrayField), (Object[]) diff.getLeft());
+ assertArrayEquals(ArrayUtils.toObject(class2.booleanArrayField), (Object[]) diff.getRight());
}
@Test
@@ -128,6 +116,7 @@ public class DiffBuilderTest extends AbstractLangTest {
final DiffResult<TypeTestClass> list = class1.diff(class2);
assertEquals(1, list.getNumberOfDiffs());
final Diff<?> diff = list.getDiffs().get(0);
+ assertEquals(Byte.class, diff.getType(), () -> diff.getType().getClass().toString());
assertEquals(Byte.valueOf(class1.byteField), diff.getLeft());
assertEquals(Byte.valueOf(class2.byteField), diff.getRight());
}
@@ -136,29 +125,21 @@ public class DiffBuilderTest extends AbstractLangTest {
public void testByteArray() {
final TypeTestClass class1 = new TypeTestClass();
final TypeTestClass class2 = new TypeTestClass();
- class2.byteArrayField= new byte[] {0x01, 0x02};
+ class2.byteArrayField = new byte[] { 0x01, 0x02 };
final DiffResult<TypeTestClass> list = class1.diff(class2);
assertEquals(1, list.getNumberOfDiffs());
final Diff<?> diff = list.getDiffs().get(0);
- assertArrayEquals(ArrayUtils.toObject(class1.byteArrayField),
- (Object[]) diff.getLeft());
- assertArrayEquals(ArrayUtils.toObject(class2.byteArrayField),
- (Object[]) diff.getRight());
+ assertArrayEquals(ArrayUtils.toObject(class1.byteArrayField), (Object[]) diff.getLeft());
+ assertArrayEquals(ArrayUtils.toObject(class2.byteArrayField), (Object[]) diff.getRight());
}
@Test
public void testByteArrayEqualAsObject() {
- final DiffResult<String> 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();
+ final DiffResult<String> 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());
}
@@ -179,14 +160,12 @@ public class DiffBuilderTest extends AbstractLangTest {
public void testCharArray() {
final TypeTestClass class1 = new TypeTestClass();
final TypeTestClass class2 = new TypeTestClass();
- class2.charArrayField = new char[] {'f', 'o', 'o'};
+ class2.charArrayField = new char[] { 'f', 'o', 'o' };
final DiffResult<TypeTestClass> list = class1.diff(class2);
assertEquals(1, list.getNumberOfDiffs());
final Diff<?> diff = list.getDiffs().get(0);
- assertArrayEquals(ArrayUtils.toObject(class1.charArrayField),
- (Object[]) diff.getLeft());
- assertArrayEquals(ArrayUtils.toObject(class2.charArrayField),
- (Object[]) diff.getRight());
+ assertArrayEquals(ArrayUtils.toObject(class1.charArrayField), (Object[]) diff.getLeft());
+ assertArrayEquals(ArrayUtils.toObject(class2.charArrayField), (Object[]) diff.getRight());
}
@Test
@@ -195,9 +174,7 @@ public class DiffBuilderTest extends AbstractLangTest {
final TypeTestClass class2 = new TypeTestClass();
class2.intField = 2;
- final DiffResult<TypeTestClass> list = new DiffBuilder<>(class1, class2, SHORT_STYLE)
- .append("prop1", class1.diff(class2))
- .build();
+ final DiffResult<TypeTestClass> 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());
}
@@ -218,14 +195,12 @@ public class DiffBuilderTest extends AbstractLangTest {
public void testDoubleArray() {
final TypeTestClass class1 = new TypeTestClass();
final TypeTestClass class2 = new TypeTestClass();
- class2.doubleArrayField = new double[] {3.0, 2.9, 2.8};
+ class2.doubleArrayField = new double[] { 3.0, 2.9, 2.8 };
final DiffResult<TypeTestClass> list = class1.diff(class2);
assertEquals(1, list.getNumberOfDiffs());
final Diff<?> diff = list.getDiffs().get(0);
- assertArrayEquals(ArrayUtils.toObject(class1.doubleArrayField),
- (Object[]) diff.getLeft());
- assertArrayEquals(ArrayUtils.toObject(class2.doubleArrayField),
- (Object[]) diff.getRight());
+ assertArrayEquals(ArrayUtils.toObject(class1.doubleArrayField), (Object[]) diff.getLeft());
+ assertArrayEquals(ArrayUtils.toObject(class2.doubleArrayField), (Object[]) diff.getRight());
}
@Test
@@ -244,14 +219,12 @@ public class DiffBuilderTest extends AbstractLangTest {
public void testFloatArray() {
final TypeTestClass class1 = new TypeTestClass();
final TypeTestClass class2 = new TypeTestClass();
- class2.floatArrayField = new float[] {3.0F, 2.9F, 2.8F};
+ class2.floatArrayField = new float[] { 3.0F, 2.9F, 2.8F };
final DiffResult<TypeTestClass> list = class1.diff(class2);
assertEquals(1, list.getNumberOfDiffs());
final Diff<?> diff = list.getDiffs().get(0);
- assertArrayEquals(ArrayUtils.toObject(class1.floatArrayField),
- (Object[]) diff.getLeft());
- assertArrayEquals(ArrayUtils.toObject(class2.floatArrayField),
- (Object[]) diff.getRight());
+ assertArrayEquals(ArrayUtils.toObject(class1.floatArrayField), (Object[]) diff.getLeft());
+ assertArrayEquals(ArrayUtils.toObject(class2.floatArrayField), (Object[]) diff.getRight());
}
@Test
@@ -270,14 +243,12 @@ public class DiffBuilderTest extends AbstractLangTest {
public void testIntArray() {
final TypeTestClass class1 = new TypeTestClass();
final TypeTestClass class2 = new TypeTestClass();
- class2.intArrayField = new int[] {3, 2, 1};
+ class2.intArrayField = new int[] { 3, 2, 1 };
final DiffResult<TypeTestClass> list = class1.diff(class2);
assertEquals(1, list.getNumberOfDiffs());
final Diff<?> diff = list.getDiffs().get(0);
- assertArrayEquals(ArrayUtils.toObject(class1.intArrayField),
- (Object[]) diff.getLeft());
- assertArrayEquals(ArrayUtils.toObject(class2.intArrayField),
- (Object[]) diff.getRight());
+ assertArrayEquals(ArrayUtils.toObject(class1.intArrayField), (Object[]) diff.getLeft());
+ assertArrayEquals(ArrayUtils.toObject(class2.intArrayField), (Object[]) diff.getRight());
}
@Test
@@ -296,14 +267,12 @@ public class DiffBuilderTest extends AbstractLangTest {
public void testLongArray() {
final TypeTestClass class1 = new TypeTestClass();
final TypeTestClass class2 = new TypeTestClass();
- class2.longArrayField = new long[] {3L, 2L, 1L};
+ class2.longArrayField = new long[] { 3L, 2L, 1L };
final DiffResult<TypeTestClass> list = class1.diff(class2);
assertEquals(1, list.getNumberOfDiffs());
final Diff<?> diff = list.getDiffs().get(0);
- assertArrayEquals(ArrayUtils.toObject(class1.longArrayField),
- (Object[]) diff.getLeft());
- assertArrayEquals(ArrayUtils.toObject(class2.longArrayField),
- (Object[]) diff.getRight());
+ assertArrayEquals(ArrayUtils.toObject(class1.longArrayField), (Object[]) diff.getLeft());
+ assertArrayEquals(ArrayUtils.toObject(class2.longArrayField), (Object[]) diff.getRight());
}
@Test
@@ -342,7 +311,7 @@ public class DiffBuilderTest extends AbstractLangTest {
public void testObjectArray() {
final TypeTestClass class1 = new TypeTestClass();
final TypeTestClass class2 = new TypeTestClass();
- class2.objectArrayField = new Object[] {"string", 1, 2};
+ class2.objectArrayField = new Object[] { "string", 1, 2 };
final DiffResult<TypeTestClass> list = class1.diff(class2);
assertEquals(1, list.getNumberOfDiffs());
final Diff<?> diff = list.getDiffs().get(0);
@@ -354,8 +323,8 @@ public class DiffBuilderTest extends AbstractLangTest {
public void testObjectArrayEqual() {
final TypeTestClass class1 = new TypeTestClass();
final TypeTestClass class2 = new TypeTestClass();
- class1.objectArrayField = new Object[] {"string", 1, 2};
- class2.objectArrayField = new Object[] {"string", 1, 2};
+ class1.objectArrayField = new Object[] { "string", 1, 2 };
+ class2.objectArrayField = new Object[] { "string", 1, 2 };
final DiffResult<TypeTestClass> list = class1.diff(class2);
assertEquals(0, list.getNumberOfDiffs());
}
@@ -412,9 +381,7 @@ public class DiffBuilderTest extends AbstractLangTest {
@Test
public void testSameObjectIgnoresAppends() {
final TypeTestClass testClass = new TypeTestClass();
- final DiffResult<TypeTestClass> list = new DiffBuilder<>(testClass, testClass, SHORT_STYLE)
- .append("ignored", false, true)
- .build();
+ final DiffResult<TypeTestClass> list = new DiffBuilder<>(testClass, testClass, SHORT_STYLE).append("ignored", false, true).build();
assertEquals(0, list.getNumberOfDiffs());
}
@@ -434,23 +401,19 @@ public class DiffBuilderTest extends AbstractLangTest {
public void testShortArray() {
final TypeTestClass class1 = new TypeTestClass();
final TypeTestClass class2 = new TypeTestClass();
- class2.shortArrayField = new short[] {3, 2, 1};
+ class2.shortArrayField = new short[] { 3, 2, 1 };
final DiffResult<TypeTestClass> list = class1.diff(class2);
assertEquals(1, list.getNumberOfDiffs());
final Diff<?> diff = list.getDiffs().get(0);
- assertArrayEquals(ArrayUtils.toObject(class1.shortArrayField),
- (Object[]) diff.getLeft());
- assertArrayEquals(ArrayUtils.toObject(class2.shortArrayField),
- (Object[]) diff.getRight());
+ assertArrayEquals(ArrayUtils.toObject(class1.shortArrayField), (Object[]) diff.getLeft());
+ assertArrayEquals(ArrayUtils.toObject(class2.shortArrayField), (Object[]) diff.getRight());
}
@Test
public void testSimilarObjectIgnoresAppends() {
final TypeTestClass testClass1 = new TypeTestClass();
final TypeTestClass testClass2 = new TypeTestClass();
- final DiffResult<TypeTestClass> list = new DiffBuilder<>(testClass1, testClass2, SHORT_STYLE)
- .append("ignored", false, true)
- .build();
+ final DiffResult<TypeTestClass> list = new DiffBuilder<>(testClass1, testClass2, SHORT_STYLE).append("ignored", false, true).build();
assertEquals(0, list.getNumberOfDiffs());
}