You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@commons.apache.org by Matt Benson <gu...@gmail.com> on 2014/01/24 23:51:01 UTC
Re: svn commit: r1561215 - in /commons/proper/lang/trunk/src:
changes/ main/java/org/apache/commons/lang3/builder/ test/java/org/apache/commons/lang3/builder/
Hi, Duncan, and congrats on your first commit! However, based on the
comments of those of us who were participating in JIRA, I had expected that
DiffList would be renamed to DiffResult, to avoid any confusion based on
its being *named* "*List" without actually *implementing* the
java.util.List interface.
br,
Matt
On Fri, Jan 24, 2014 at 4:37 PM, <dj...@apache.org> wrote:
> Author: djones
> Date: Fri Jan 24 22:37:50 2014
> New Revision: 1561215
>
> URL: http://svn.apache.org/r1561215
> Log:
> LANG-637: There should be a DifferenceBuilder with a
> ReflectionDifferenceBuilder implementation
>
> Added:
>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diff.java
> (with props)
>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffBuilder.java
> (with props)
>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffList.java
> (with props)
>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diffable.java
> (with props)
>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java
> (with props)
>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffListTest.java
> (with props)
>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffTest.java
> (with props)
> Modified:
> commons/proper/lang/trunk/src/changes/changes.xml
>
> Modified: commons/proper/lang/trunk/src/changes/changes.xml
> URL:
> http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/changes/changes.xml?rev=1561215&r1=1561214&r2=1561215&view=diff
>
> ==============================================================================
> --- commons/proper/lang/trunk/src/changes/changes.xml [utf-8] (original)
> +++ commons/proper/lang/trunk/src/changes/changes.xml [utf-8] Fri Jan 24
> 22:37:50 2014
> @@ -22,6 +22,7 @@
> <body>
>
> <release version="3.3" date="TBA" description="Bugfix and Feature
> release">
> + <action issue="LANG-637" type="add" dev="djones">There should be a
> DifferenceBuilder with a ReflectionDifferenceBuilder implementation</action>
> <action issue="LANG-954" type="fix" due-to="Michael Keppler"
> dev="sebb">uncaught PatternSyntaxException in FastDateFormat on
> Android</action>
> <action issue="LANG-956" type="update" dev="britter">Improve JavaDoc
> of WordUtils.wrap methods</action>
> <action issue="LANG-944" type="add" dev="britter" due-to="Rekha
> Joshi">Add the Jaro-Winkler string distance algorithm to
> StringUtils</action>
>
> Added:
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diff.java
> URL:
> http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diff.java?rev=1561215&view=auto
>
> ==============================================================================
> ---
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diff.java
> (added)
> +++
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diff.java
> Fri Jan 24 22:37:50 2014
> @@ -0,0 +1,119 @@
> +/**
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +package org.apache.commons.lang3.builder;
> +
> +import java.lang.reflect.Type;
> +
> +import org.apache.commons.lang3.ObjectUtils;
> +import org.apache.commons.lang3.reflect.TypeUtils;
> +import org.apache.commons.lang3.tuple.Pair;
> +
> +/**
> + * <p>
> + * A {@code Diff} contains the differences between two {@link Diffable}
> class
> + * fields.
> + * </p>
> + *
> + * <p>
> + * Typically, {@code Diff}s are retrieved by using a {@link DiffBuilder}
> to
> + * produce a {@link DiffList}, containing the differences between two
> objects.
> + * </p>
> + *
> + *
> + * @param <T>
> + * The type of object contained within this {@code Diff}.
> Differences
> + * between primitive objects are stored as their Object wrapper
> + * equivalent.
> + * @since 3.3
> + * @version $Id$
> + */
> +public abstract class Diff<T> extends Pair<T, T> {
> +
> + private static final long serialVersionUID = 1L;
> +
> + private final Type type;
> + private final String fieldName;
> +
> + /**
> + * <p>
> + * Constructs a new {@code Diff} for the given field name.
> + * </p>
> + *
> + * @param fieldName
> + * the name of the field
> + */
> + protected Diff(String fieldName) {
> + this.type = ObjectUtils.defaultIfNull(
> + TypeUtils.getTypeArguments(getClass(), Diff.class).get(
> + Diff.class.getTypeParameters()[0]), Object.class);
> + this.fieldName = fieldName;
> + }
> +
> + /**
> + * <p>
> + * Returns the type of the field.
> + * </p>
> + *
> + * @return the field type
> + */
> + public final Type getType() {
> + return type;
> + }
> +
> + /**
> + * <p>
> + * Returns the name of the field.
> + * </p>
> + *
> + * @return the field name
> + */
> + public final String getFieldName() {
> + return fieldName;
> + }
> +
> + /**
> + * <p>
> + * Returns a {@code String} representation of the {@code Diff}, with
> the
> + * following format:
> + *
> + * <pre>
> + * [fieldname: left-value, right-value]
> + * </pre>
> + *
> + * </p>
> + *
> + * @return the string representation
> + */
> + @Override
> + public final String toString() {
> + return String.format("[%s: %s, %s]", fieldName, getLeft(),
> getRight());
> + }
> +
> + /**
> + * <p>
> + * Throws {@code UnsupportedOperationException}.
> + * </p>
> + *
> + * @param value
> + * ignored
> + * @return nothing
> + */
> + @Override
> + public final T setValue(T value) {
> + throw new UnsupportedOperationException("Cannot alter Diff
> object.");
> + }
> +}
>
> Propchange:
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diff.java
>
> ------------------------------------------------------------------------------
> svn:eol-style = native
>
> Propchange:
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diff.java
>
> ------------------------------------------------------------------------------
> svn:keywords = Id Revision
>
> Propchange:
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diff.java
>
> ------------------------------------------------------------------------------
> svn:mime-type = text/plain
>
> Added:
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffBuilder.java
> URL:
> http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffBuilder.java?rev=1561215&view=auto
>
> ==============================================================================
> ---
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffBuilder.java
> (added)
> +++
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffBuilder.java
> Fri Jan 24 22:37:50 2014
> @@ -0,0 +1,914 @@
> +/**
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +package org.apache.commons.lang3.builder;
> +
> +import java.util.ArrayList;
> +import java.util.Arrays;
> +import java.util.List;
> +
> +import org.apache.commons.lang3.ArrayUtils;
> +
> +/**
> + * <p>
> + * Assists in implementing {@link Diffable#diff(Object)} methods.
> + * </p>
> + *
> + * <p>
> + * To use this class, write code as follows:
> + * </p>
> + *
> + * <pre>
> + * public class Person implements Diffable<Person> {
> + * String name;
> + * int age;
> + * boolean smoker;
> + *
> + * ...
> + *
> + * public DiffList diff(Person obj) {
> + * // No need for null check, as NullPointerException correct if obj
> is null
> + * return new DiffBuilder(this, obj, ToStringStyle.SHORT_PREFIX_STYLE)
> + * .append("name", this.name, obj.name)
> + * .append("age", this.age, obj.age)
> + * .append("smoker", this.smoker, obj.smoker)
> + * .build();
> + * }
> + * }
> + * </pre>
> + *
> + * <p>
> + * The {@code ToStringStyle} passed to the constructor is embedded in the
> + * returned {@code DiffList} and influences the style of the
> + * {@code DiffList.toString()} method. This style choice can be
> overridden by
> + * calling {@link DiffList#toString(ToStringStyle)}.
> + * </p>
> + *
> + * @since 3.3
> + * @version $Id$
> + * @see Diffable
> + * @see Diff
> + * @see DiffList
> + * @see ToStringStyle
> + */
> +public class DiffBuilder implements Builder<DiffList> {
> +
> + private final List<Diff<?>> diffs;
> + private final boolean objectsTriviallyEqual;
> + private final Object lhs;
> + private final Object rhs;
> + private final ToStringStyle style;
> +
> + /**
> + * <p>
> + * Constructs a builder for the specified objects with the specified
> style.
> + * </p>
> + *
> + * <p>
> + * If {@code lhs == rhs} or {@code lhs.equals(rhs)} then the builder
> will
> + * not evaluate any calls to {@code append(...)} and will return an
> empty
> + * {@link DiffList} when {@link #build()} is executed.
> + * </p>
> + *
> + * @param lhs
> + * {@code this} object
> + * @param rhs
> + * the object to diff against
> + * @param style
> + * the style will use when outputting the objects, {@code
> null}
> + * uses the default
> + * @throws IllegalArgumentException
> + * if {@code lhs} or {@code rhs} is {@code null}
> + */
> + public DiffBuilder(final Object lhs, final Object rhs,
> + final ToStringStyle style) {
> + if (lhs == null) {
> + throw new IllegalArgumentException("lhs cannot be null");
> + }
> + if (rhs == null) {
> + throw new IllegalArgumentException("rhs cannot be null");
> + }
> +
> + this.diffs = new ArrayList<Diff<?>>();
> + this.lhs = lhs;
> + this.rhs = rhs;
> + this.style = style;
> +
> + // Don't compare any fields if objects equal
> + this.objectsTriviallyEqual = (lhs == rhs || lhs.equals(rhs));
> + }
> +
> + /**
> + * <p>
> + * Test if two {@code boolean}s are equal.
> + * </p>
> + *
> + * @param fieldName
> + * the field name
> + * @param lhs
> + * the left hand {@code boolean}
> + * @param rhs
> + * the right hand {@code boolean}
> + * @return this
> + * @throws IllegalArgumentException
> + * if field name is {@code null}
> + */
> + public DiffBuilder append(final String fieldName, final boolean lhs,
> + final boolean rhs) {
> + if (fieldName == null) {
> + throw new IllegalArgumentException("Field name cannot be
> null");
> + }
> +
> + if (objectsTriviallyEqual) {
> + 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;
> + }
> +
> + /**
> + * <p>
> + * Test if two {@code boolean[]}s are equal.
> + * </p>
> + *
> + * @param fieldName
> + * the field name
> + * @param lhs
> + * the left hand {@code boolean[]}
> + * @param rhs
> + * the right hand {@code boolean[]}
> + * @return this
> + * @throws IllegalArgumentException
> + * if field name is {@code null}
> + */
> + public DiffBuilder append(final String fieldName, final boolean[] lhs,
> + final boolean[] rhs) {
> + if (fieldName == null) {
> + throw new IllegalArgumentException("Field name cannot be
> null");
> + }
> + if (objectsTriviallyEqual) {
> + 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;
> + }
> +
> + /**
> + * <p>
> + * Test if two {@code byte}s are equal.
> + * </p>
> + *
> + * @param fieldName
> + * the field name
> + * @param lhs
> + * the left hand {@code byte}
> + * @param rhs
> + * the right hand {@code byte}
> + * @return this
> + * @throws IllegalArgumentException
> + * if field name is {@code null}
> + */
> + public DiffBuilder append(final String fieldName, final byte lhs,
> + final byte rhs) {
> + if (fieldName == null) {
> + throw new IllegalArgumentException("Field name cannot be
> null");
> + }
> + if (objectsTriviallyEqual) {
> + 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;
> + }
> +
> + /**
> + * <p>
> + * Test if two {@code byte[]}s are equal.
> + * </p>
> + *
> + * @param fieldName
> + * the field name
> + * @param lhs
> + * the left hand {@code byte[]}
> + * @param rhs
> + * the right hand {@code byte[]}
> + * @return this
> + * @throws IllegalArgumentException
> + * if field name is {@code null}
> + */
> + public DiffBuilder append(final String fieldName, final byte[] lhs,
> + final byte[] rhs) {
> + if (fieldName == null) {
> + throw new IllegalArgumentException("Field name cannot be
> null");
> + }
> +
> + if (objectsTriviallyEqual) {
> + 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;
> + }
> +
> + /**
> + * <p>
> + * Test if two {@code char}s are equal.
> + * </p>
> + *
> + * @param fieldName
> + * the field name
> + * @param lhs
> + * the left hand {@code char}
> + * @param rhs
> + * the right hand {@code char}
> + * @return this
> + * @throws IllegalArgumentException
> + * if field name is {@code null}
> + */
> + public DiffBuilder append(final String fieldName, final char lhs,
> + final char rhs) {
> + if (fieldName == null) {
> + throw new IllegalArgumentException("Field name cannot be
> null");
> + }
> +
> + if (objectsTriviallyEqual) {
> + 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;
> + }
> +
> + /**
> + * <p>
> + * Test if two {@code char[]}s are equal.
> + * </p>
> + *
> + * @param fieldName
> + * the field name
> + * @param lhs
> + * the left hand {@code char[]}
> + * @param rhs
> + * the right hand {@code char[]}
> + * @return this
> + * @throws IllegalArgumentException
> + * if field name is {@code null}
> + */
> + public DiffBuilder append(final String fieldName, final char[] lhs,
> + final char[] rhs) {
> + if (fieldName == null) {
> + throw new IllegalArgumentException("Field name cannot be
> null");
> + }
> +
> + if (objectsTriviallyEqual) {
> + 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;
> + }
> +
> + /**
> + * <p>
> + * Test if two {@code double}s are equal.
> + * </p>
> + *
> + * @param fieldName
> + * the field name
> + * @param lhs
> + * the left hand {@code double}
> + * @param rhs
> + * the right hand {@code double}
> + * @return this
> + * @throws IllegalArgumentException
> + * if field name is {@code null}
> + */
> + public DiffBuilder append(final String fieldName, final double lhs,
> + final double rhs) {
> + if (fieldName == null) {
> + throw new IllegalArgumentException("Field name cannot be
> null");
> + }
> +
> + if (objectsTriviallyEqual) {
> + 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;
> + }
> +
> + /**
> + * <p>
> + * Test if two {@code double[]}s are equal.
> + * </p>
> + *
> + * @param fieldName
> + * the field name
> + * @param lhs
> + * the left hand {@code double[]}
> + * @param rhs
> + * the right hand {@code double[]}
> + * @return this
> + * @throws IllegalArgumentException
> + * if field name is {@code null}
> + */
> + public DiffBuilder append(final String fieldName, final double[] lhs,
> + final double[] rhs) {
> + if (fieldName == null) {
> + throw new IllegalArgumentException("Field name cannot be
> null");
> + }
> +
> + if (objectsTriviallyEqual) {
> + 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;
> + }
> +
> + /**
> + * <p>
> + * Test if two {@code float}s are equal.
> + * </p>
> + *
> + * @param fieldName
> + * the field name
> + * @param lhs
> + * the left hand {@code float}
> + * @param rhs
> + * the right hand {@code float}
> + * @return this
> + * @throws IllegalArgumentException
> + * if field name is {@code null}
> + */
> + public DiffBuilder append(final String fieldName, final float lhs,
> + final float rhs) {
> + if (fieldName == null) {
> + throw new IllegalArgumentException("Field name cannot be
> null");
> + }
> +
> + if (objectsTriviallyEqual) {
> + 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;
> + }
> +
> + /**
> + * <p>
> + * Test if two {@code float[]}s are equal.
> + * </p>
> + *
> + * @param fieldName
> + * the field name
> + * @param lhs
> + * the left hand {@code float[]}
> + * @param rhs
> + * the right hand {@code float[]}
> + * @return this
> + * @throws IllegalArgumentException
> + * if field name is {@code null}
> + */
> + public DiffBuilder append(final String fieldName, final float[] lhs,
> + final float[] rhs) {
> + if (fieldName == null) {
> + throw new IllegalArgumentException("Field name cannot be
> null");
> + }
> +
> + if (objectsTriviallyEqual) {
> + 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;
> + }
> +
> + /**
> + * <p>
> + * Test if two {@code int}s are equal.
> + * </p>
> + *
> + * @param fieldName
> + * the field name
> + * @param lhs
> + * the left hand {@code int}
> + * @param rhs
> + * the right hand {@code int}
> + * @return this
> + * @throws IllegalArgumentException
> + * if field name is {@code null}
> + */
> + public DiffBuilder append(final String fieldName, final int lhs,
> + final int rhs) {
> + if (fieldName == null) {
> + throw new IllegalArgumentException("Field name cannot be
> null");
> + }
> +
> + if (objectsTriviallyEqual) {
> + 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;
> + }
> +
> + /**
> + * <p>
> + * Test if two {@code int[]}s are equal.
> + * </p>
> + *
> + * @param fieldName
> + * the field name
> + * @param lhs
> + * the left hand {@code int[]}
> + * @param rhs
> + * the right hand {@code int[]}
> + * @return this
> + * @throws IllegalArgumentException
> + * if field name is {@code null}
> + */
> + public DiffBuilder append(final String fieldName, final int[] lhs,
> + final int[] rhs) {
> + if (fieldName == null) {
> + throw new IllegalArgumentException("Field name cannot be
> null");
> + }
> +
> + if (objectsTriviallyEqual) {
> + 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;
> + }
> +
> + /**
> + * <p>
> + * Test if two {@code long}s are equal.
> + * </p>
> + *
> + * @param fieldName
> + * the field name
> + * @param lhs
> + * the left hand {@code long}
> + * @param rhs
> + * the right hand {@code long}
> + * @return this
> + * @throws IllegalArgumentException
> + * if field name is {@code null}
> + */
> + public DiffBuilder append(final String fieldName, final long lhs,
> + final long rhs) {
> + if (fieldName == null) {
> + throw new IllegalArgumentException("Field name cannot be
> null");
> + }
> +
> + if (objectsTriviallyEqual) {
> + 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;
> + }
> +
> + /**
> + * <p>
> + * Test if two {@code long[]}s are equal.
> + * </p>
> + *
> + * @param fieldName
> + * the field name
> + * @param lhs
> + * the left hand {@code long[]}
> + * @param rhs
> + * the right hand {@code long[]}
> + * @return this
> + * @throws IllegalArgumentException
> + * if field name is {@code null}
> + */
> + public DiffBuilder append(final String fieldName, final long[] lhs,
> + final long[] rhs) {
> + if (fieldName == null) {
> + throw new IllegalArgumentException("Field name cannot be
> null");
> + }
> +
> + if (objectsTriviallyEqual) {
> + 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;
> + }
> +
> + /**
> + * <p>
> + * Test if two {@code short}s are equal.
> + * </p>
> + *
> + * @param fieldName
> + * the field name
> + * @param lhs
> + * the left hand {@code short}
> + * @param rhs
> + * the right hand {@code short}
> + * @return this
> + * @throws IllegalArgumentException
> + * if field name is {@code null}
> + */
> + public DiffBuilder append(final String fieldName, final short lhs,
> + final short rhs) {
> + if (fieldName == null) {
> + throw new IllegalArgumentException("Field name cannot be
> null");
> + }
> +
> + if (objectsTriviallyEqual) {
> + 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;
> + }
> +
> + /**
> + * <p>
> + * Test if two {@code short[]}s are equal.
> + * </p>
> + *
> + * @param fieldName
> + * the field name
> + * @param lhs
> + * the left hand {@code short[]}
> + * @param rhs
> + * the right hand {@code short[]}
> + * @return this
> + * @throws IllegalArgumentException
> + * if field name is {@code null}
> + */
> + public DiffBuilder append(final String fieldName, final short[] lhs,
> + final short[] rhs) {
> + if (fieldName == null) {
> + throw new IllegalArgumentException("Field name cannot be
> null");
> + }
> +
> + if (objectsTriviallyEqual) {
> + 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;
> + }
> +
> + /**
> + * <p>
> + * Test if two {@code Objects}s are equal.
> + * </p>
> + *
> + * @param fieldName
> + * the field name
> + * @param lhs
> + * the left hand {@code Object}
> + * @param rhs
> + * the right hand {@code Object}
> + * @return this
> + */
> + public DiffBuilder append(final String fieldName, final Object lhs,
> + final Object rhs) {
> +
> + if (objectsTriviallyEqual) {
> + return this;
> + }
> + if (lhs == rhs) {
> + return this;
> + }
> +
> + Object objectToTest;
> + if (lhs != null) {
> + objectToTest = lhs;
> + } else {
> + // rhs cannot be null, as lhs != rhs
> + objectToTest = rhs;
> + }
> +
> + if (objectToTest.getClass().isArray()) {
> + if (objectToTest instanceof boolean[]) {
> + return append(fieldName, (boolean[]) lhs, (boolean[])
> rhs);
> + }
> + if (objectToTest instanceof byte[]) {
> + return append(fieldName, (byte[]) lhs, (byte[]) rhs);
> + }
> + if (objectToTest instanceof char[]) {
> + return append(fieldName, (char[]) lhs, (char[]) rhs);
> + }
> + if (objectToTest instanceof double[]) {
> + return append(fieldName, (double[]) lhs, (double[]) rhs);
> + }
> + if (objectToTest instanceof float[]) {
> + return append(fieldName, (float[]) lhs, (float[]) rhs);
> + }
> + if (objectToTest instanceof int[]) {
> + return append(fieldName, (int[]) lhs, (int[]) rhs);
> + }
> + if (objectToTest instanceof long[]) {
> + return append(fieldName, (long[]) lhs, (long[]) rhs);
> + }
> + if (objectToTest instanceof short[]) {
> + return append(fieldName, (short[]) lhs, (short[]) rhs);
> + }
> +
> + return append(fieldName, (Object[]) lhs, (Object[]) rhs);
> + }
> +
> + // Not array type
> + 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;
> + }
> +
> + /**
> + * <p>
> + * Test if two {@code Object[]}s are equal.
> + * </p>
> + *
> + * @param fieldName
> + * the field name
> + * @param lhs
> + * the left hand {@code Object[]}
> + * @param rhs
> + * the right hand {@code Object[]}
> + * @return this
> + */
> + public DiffBuilder append(final String fieldName, final Object[] lhs,
> + final Object[] rhs) {
> + if (objectsTriviallyEqual) {
> + 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;
> + }
> +
> + /**
> + * <p>
> + * Builds a {@link DiffList} based on the differences appended to this
> + * builder.
> + * </p>
> + *
> + * @return a {@code DiffList} containing the differences between the
> two
> + * objects.
> + */
> + @Override
> + public DiffList build() {
> + return new DiffList(lhs, rhs, diffs, style);
> + }
> +
> +}
>
> Propchange:
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffBuilder.java
>
> ------------------------------------------------------------------------------
> svn:eol-style = native
>
> Propchange:
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffBuilder.java
>
> ------------------------------------------------------------------------------
> svn:keywords = Id Revision
>
> Propchange:
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffBuilder.java
>
> ------------------------------------------------------------------------------
> svn:mime-type = text/plain
>
> Added:
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffList.java
> URL:
> http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffList.java?rev=1561215&view=auto
>
> ==============================================================================
> ---
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffList.java
> (added)
> +++
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffList.java
> Fri Jan 24 22:37:50 2014
> @@ -0,0 +1,208 @@
> +/**
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +package org.apache.commons.lang3.builder;
> +
> +import java.util.Collections;
> +import java.util.Iterator;
> +import java.util.List;
> +
> +/**
> + * <p>
> + * A {@code DiffList} contains a list of the differences between two
> + * {@link Diffable} objects. Typically these differences are displayed
> using
> + * {@link #toString()} method, which returns a string describing the
> fields that
> + * differ between the objects.
> + * </p>
> + * <p>
> + * Use a {@link DiffBuilder} to build a {@code DiffList} comparing two
> objects.
> + * </p>
> + *
> + * @since 3.3
> + * @version $Id$
> + */
> +public class DiffList implements Iterable<Diff<?>> {
> +
> + /**
> + * <p>
> + * The {@code String} returned when the objects have no differences:
> + * {@value}
> + * </p>
> + */
> + public static final String OBJECTS_SAME_STRING = "";
> +
> + private static final String DIFFERS_STRING = "differs from";
> +
> + private final List<Diff<?>> diffs;
> + private final Object lhs;
> + private final Object rhs;
> + private final ToStringStyle style;
> +
> + /**
> + * <p>
> + * Creates a {@link DiffList} containing the differences between two
> + * objects.
> + * </p>
> + *
> + * @param lhs
> + * the left hand object
> + * @param rhs
> + * the right hand object
> + * @param diffs
> + * the list of differences, may be empty
> + * @param style
> + * the style to use for the {@link #toString()} method.
> May be
> + * {@code null}, in which case
> + * {@link ToStringStyle#DEFAULT_STYLE} is used
> + * @throws IllegalArgumentException
> + * if {@code lhs}, {@code rhs} or {@code diffs} is {@code
> null}
> + */
> + DiffList(final Object lhs, final Object rhs, final List<Diff<?>>
> diffs,
> + final ToStringStyle style) {
> + if (lhs == null) {
> + throw new IllegalArgumentException(
> + "Left hand object cannot be null");
> + }
> + if (rhs == null) {
> + throw new IllegalArgumentException(
> + "Right hand object cannot be null");
> + }
> + if (diffs == null) {
> + throw new IllegalArgumentException(
> + "List of differences cannot be null");
> + }
> +
> + this.diffs = diffs;
> + this.lhs = lhs;
> + this.rhs = rhs;
> +
> + if (style == null) {
> + this.style = ToStringStyle.DEFAULT_STYLE;
> + } else {
> + this.style = style;
> + }
> + }
> +
> + /**
> + * <p>
> + * Returns an unmodifiable list of {@code Diff}s. The list may be
> empty if
> + * there were no differences between the objects.
> + * </p>
> + *
> + * @return an unmodifiable list of {@code Diff}s
> + */
> + public List<Diff<?>> getDiffs() {
> + return Collections.unmodifiableList(diffs);
> + }
> +
> + /**
> + * <p>
> + * Returns the number of differences between the two objects.
> + * </p>
> + *
> + * @return the number of differences
> + */
> + public int getNumberOfDiffs() {
> + return diffs.size();
> + }
> +
> + /**
> + * <p>
> + * Returns the style used by the {@link #toString()} method.
> + * </p>
> + *
> + * @return the style
> + */
> + public ToStringStyle getToStringStyle() {
> + return style;
> + }
> +
> + /**
> + * <p>
> + * Builds a {@code String} description of the differences contained
> within
> + * this {@code DiffList}. A {@link ToStringBuilder} is used for each
> object
> + * and the style of the output is governed by the {@code
> ToStringStyle}
> + * passed to the constructor.
> + * </p>
> + *
> + * <p>
> + * If there are no differences stored in this list, the method will
> return
> + * {@link #OBJECTS_SAME_STRING}. Otherwise, using the example given in
> + * {@link Diffable} and {@link ToStringStyle#SHORT_PREFIX_STYLE}, an
> output
> + * might be:
> + * </p>
> + *
> + * <pre>
> + * Person[name=John Doe,age=32] differs from Person[name=Joe
> Bloggs,age=26]
> + * </pre>
> + *
> + * <p>
> + * This indicates that the objects differ in name and age, but not in
> + * smoking status.
> + * </p>
> + *
> + * <p>
> + * To use a different {@code ToStringStyle} for an instance of this
> class,
> + * use {@link #toString(ToStringStyle)}.
> + * </p>
> + *
> + * @return a {@code String} description of the differences.
> + */
> + @Override
> + public String toString() {
> + return toString(style);
> + }
> +
> + /**
> + * <p>
> + * Builds a {@code String} description of the differences contained
> within
> + * this {@code DiffList}, using the supplied {@code ToStringStyle}.
> + * </p>
> + *
> + * @param style
> + * the {@code ToStringStyle} to use when outputting the
> objects
> + *
> + * @return a {@code String} description of the differences.
> + */
> + public String toString(ToStringStyle style) {
> + if (diffs.size() == 0) {
> + return OBJECTS_SAME_STRING;
> + }
> +
> + ToStringBuilder lhsBuilder = new ToStringBuilder(lhs, style);
> + ToStringBuilder rhsBuilder = new ToStringBuilder(rhs, style);
> +
> + for (Diff<?> diff : diffs) {
> + lhsBuilder.append(diff.getFieldName(), diff.getLeft());
> + rhsBuilder.append(diff.getFieldName(), diff.getRight());
> + }
> +
> + return String.format("%s %s %s", lhsBuilder.build(),
> DIFFERS_STRING,
> + rhsBuilder.build());
> + }
> +
> + /**
> + * <p>
> + * Returns an iterator over the {@code Diff} objects contained in
> this list.
> + * </p>
> + *
> + * @return the iterator
> + */
> + @Override
> + public Iterator<Diff<?>> iterator() {
> + return diffs.iterator();
> + }
> +}
>
> Propchange:
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffList.java
>
> ------------------------------------------------------------------------------
> svn:eol-style = native
>
> Propchange:
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffList.java
>
> ------------------------------------------------------------------------------
> svn:keywords = Id Revision
>
> Propchange:
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffList.java
>
> ------------------------------------------------------------------------------
> svn:mime-type = text/plain
>
> Added:
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diffable.java
> URL:
> http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diffable.java?rev=1561215&view=auto
>
> ==============================================================================
> ---
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diffable.java
> (added)
> +++
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diffable.java
> Fri Jan 24 22:37:50 2014
> @@ -0,0 +1,54 @@
> +/**
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +package org.apache.commons.lang3.builder;
> +
> +/**
> + * <p>{@code Diffable} classes can be compared with other objects
> + * for differences. The {@link DiffList} object retrieved can be queried
> + * for a list of differences or printed using the {@link
> DiffList#toString()}.</p>
> + *
> + * <p>The calculation of the differences is <i>consistent with equals</i>
> if
> + * and only if {@code d1.equals(d2)} implies {@code d1.diff(d2) == ""}.
> + * It is strongly recommended that implementations are consistent with
> equals
> + * to avoid confusion. Note that {@code null} is not an instance of any
> class
> + * and {@code d1.diff(null)} should throw a {@code
> NullPointerException}.</p>
> + *
> + * <p>
> + * {@code Diffable} classes lend themselves well to unit testing, in
> which a
> + * easily readable description of the differences between an anticipated
> result and
> + * an actual result can be retrieved. For example:
> + * </p>
> + * <pre>
> + * Assert.assertEquals(expected.diff(result), expected, result);
> + * </pre>
> + *
> + * @param <T> the type of objects that this object may be differentiated
> against
> + * @since 3.3
> + * @version $Id$
> + */
> +public interface Diffable<T> {
> +
> + /**
> + * <p>Retrieves a list of the differences between
> + * this object and the supplied object.</p>
> + *
> + * @param obj the object to diff against, can be {@code null}
> + * @return a list of differences
> + * @throws NullPointerException if the specified object is {@code
> null}
> + */
> + DiffList diff(T obj);
> +}
>
> Propchange:
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diffable.java
>
> ------------------------------------------------------------------------------
> svn:eol-style = native
>
> Propchange:
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diffable.java
>
> ------------------------------------------------------------------------------
> svn:keywords = Id Revision
>
> Propchange:
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diffable.java
>
> ------------------------------------------------------------------------------
> svn:mime-type = text/plain
>
> Added:
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java
> URL:
> http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java?rev=1561215&view=auto
>
> ==============================================================================
> ---
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java
> (added)
> +++
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java
> Fri Jan 24 22:37:50 2014
> @@ -0,0 +1,415 @@
> +/**
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +package org.apache.commons.lang3.builder;
> +
> +import static org.junit.Assert.assertArrayEquals;
> +import static org.junit.Assert.assertEquals;
> +
> +import org.apache.commons.lang3.ArrayUtils;
> +import org.junit.Test;
> +
> +
> +/**
> + * Unit tests {@link DiffBuilder}.
> + *
> + * @version $Id$
> + */
> +public class DiffBuilderTest {
> +
> + private static final ToStringStyle SHORT_STYLE =
> ToStringStyle.SHORT_PREFIX_STYLE;
> +
> + private static class TypeTestClass implements Diffable<TypeTestClass>
> {
> + private ToStringStyle style = SHORT_STYLE;
> + private boolean booleanField = true;
> + private boolean[] booleanArrayField = {true};
> + private byte byteField = (byte) 0xFF;
> + private byte[] byteArrayField = {(byte) 0xFF};
> + private char charField = 'a';
> + private char[] charArrayField = {'a'};
> + private double doubleField = 1.0;
> + private double[] doubleArrayField = {1.0};
> + private float floatField = 1.0f;
> + private float[] floatArrayField = {1.0f};
> + private int intField = 1;
> + private int[] intArrayField = {1};
> + private long longField = 1L;
> + private long[] longArrayField = {1L};
> + private short shortField = 1;
> + private short[] shortArrayField = {1};
> + private Object objectField = null;
> + private Object[] objectArrayField = {null};
> +
> + @Override
> + public DiffList diff(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();
> + }
> +
> + @Override
> + public int hashCode() {
> + return HashCodeBuilder.reflectionHashCode(this, false);
> + }
> +
> + @Override
> + public boolean equals(Object obj) {
> + return EqualsBuilder.reflectionEquals(this, obj, false);
> + }
> + }
> +
> +
> + @Test
> + public void testBoolean() {
> + TypeTestClass class1 = new TypeTestClass();
> + TypeTestClass class2 = new TypeTestClass();
> + class2.booleanField = false;
> + DiffList list = class1.diff(class2);
> + assertEquals(1, list.getNumberOfDiffs());
> + Diff<?> diff = list.getDiffs().get(0);
> + assertEquals(Boolean.class, diff.getType());
> + assertEquals(Boolean.TRUE, diff.getLeft());
> + assertEquals(Boolean.FALSE, diff.getRight());
> + }
> +
> + @Test
> + public void testBooleanArray() throws Exception {
> + TypeTestClass class1 = new TypeTestClass();
> + TypeTestClass class2 = new TypeTestClass();
> + class2.booleanArrayField = new boolean[] {false, false};
> + DiffList list = class1.diff(class2);
> + assertEquals(1, list.getNumberOfDiffs());
> + Diff<?> diff = list.getDiffs().get(0);
> + assertArrayEquals(ArrayUtils.toObject(class1.booleanArrayField),
> + (Object[]) diff.getLeft());
> + assertArrayEquals(ArrayUtils.toObject(class2.booleanArrayField),
> + (Object[]) diff.getRight());
> + }
> +
> +
> + @Test
> + public void testByte() {
> + TypeTestClass class1 = new TypeTestClass();
> + TypeTestClass class2 = new TypeTestClass();
> + class2.byteField = 0x01;
> + DiffList list = class1.diff(class2);
> + assertEquals(1, list.getNumberOfDiffs());
> + Diff<?> diff = list.getDiffs().get(0);
> + assertEquals(Byte.valueOf(class1.byteField), diff.getLeft());
> + assertEquals(Byte.valueOf(class2.byteField), diff.getRight());
> + }
> +
> + @Test
> + public void testByteArray() throws Exception {
> + TypeTestClass class1 = new TypeTestClass();
> + TypeTestClass class2 = new TypeTestClass();
> + class2.byteArrayField= new byte[] {0x01, 0x02};
> + DiffList list = class1.diff(class2);
> + assertEquals(1, list.getNumberOfDiffs());
> + Diff<?> diff = list.getDiffs().get(0);
> + assertArrayEquals(ArrayUtils.toObject(class1.byteArrayField),
> + (Object[]) diff.getLeft());
> + assertArrayEquals(ArrayUtils.toObject(class2.byteArrayField),
> + (Object[]) diff.getRight());
> + }
> +
> + @Test
> + public void testChar() {
> + TypeTestClass class1 = new TypeTestClass();
> + TypeTestClass class2 = new TypeTestClass();
> + class2.charField = 'z';
> + DiffList list = class1.diff(class2);
> + assertEquals(1, list.getNumberOfDiffs());
> + Diff<?> diff = list.getDiffs().get(0);
> + assertEquals(Character.valueOf(class1.charField), diff.getLeft());
> + assertEquals(Character.valueOf(class2.charField),
> diff.getRight());
> + }
> +
> +
> + @Test
> + public void testCharArray() throws Exception {
> + TypeTestClass class1 = new TypeTestClass();
> + TypeTestClass class2 = new TypeTestClass();
> + class2.charArrayField = new char[] {'f', 'o', 'o'};
> + DiffList list = class1.diff(class2);
> + assertEquals(1, list.getNumberOfDiffs());
> + Diff<?> diff = list.getDiffs().get(0);
> + assertArrayEquals(ArrayUtils.toObject(class1.charArrayField),
> + (Object[]) diff.getLeft());
> + assertArrayEquals(ArrayUtils.toObject(class2.charArrayField),
> + (Object[]) diff.getRight());
> + }
> +
> +
> + @Test
> + public void testDouble() {
> + TypeTestClass class1 = new TypeTestClass();
> + TypeTestClass class2 = new TypeTestClass();
> + class2.doubleField = 99.99;
> + DiffList list = class1.diff(class2);
> + assertEquals(1, list.getNumberOfDiffs());
> + Diff<?> diff = list.getDiffs().get(0);
> + assertEquals(Double.valueOf(class1.doubleField), diff.getLeft());
> + assertEquals(Double.valueOf(class2.doubleField), diff.getRight());
> + }
> +
> +
> + @Test
> + public void testDoubleArray() throws Exception {
> + TypeTestClass class1 = new TypeTestClass();
> + TypeTestClass class2 = new TypeTestClass();
> + class2.doubleArrayField = new double[] {3.0, 2.9, 2.8};
> + DiffList list = class1.diff(class2);
> + assertEquals(1, list.getNumberOfDiffs());
> + Diff<?> diff = list.getDiffs().get(0);
> + assertArrayEquals(ArrayUtils.toObject(class1.doubleArrayField),
> + (Object[]) diff.getLeft());
> + assertArrayEquals(ArrayUtils.toObject(class2.doubleArrayField),
> + (Object[]) diff.getRight());
> + }
> +
> + @Test
> + public void testFloat() {
> + TypeTestClass class1 = new TypeTestClass();
> + TypeTestClass class2 = new TypeTestClass();
> + class2.floatField = 99.99F;
> + DiffList list = class1.diff(class2);
> + assertEquals(1, list.getNumberOfDiffs());
> + Diff<?> diff = list.getDiffs().get(0);
> + assertEquals(Float.valueOf(class1.floatField), diff.getLeft());
> + assertEquals(Float.valueOf(class2.floatField), diff.getRight());
> + }
> +
> +
> + @Test
> + public void testFloatArray() throws Exception {
> + TypeTestClass class1 = new TypeTestClass();
> + TypeTestClass class2 = new TypeTestClass();
> + class2.floatArrayField = new float[] {3.0F, 2.9F, 2.8F};
> + DiffList list = class1.diff(class2);
> + assertEquals(1, list.getNumberOfDiffs());
> + Diff<?> diff = list.getDiffs().get(0);
> + assertArrayEquals(ArrayUtils.toObject(class1.floatArrayField),
> + (Object[]) diff.getLeft());
> + assertArrayEquals(ArrayUtils.toObject(class2.floatArrayField),
> + (Object[]) diff.getRight());
> + }
> +
> +
> + @Test
> + public void testInt() {
> + TypeTestClass class1 = new TypeTestClass();
> + TypeTestClass class2 = new TypeTestClass();
> + class2.intField = 42;
> + DiffList list = class1.diff(class2);
> + assertEquals(1, list.getNumberOfDiffs());
> + Diff<?> diff = list.getDiffs().get(0);
> + assertEquals(Integer.valueOf(class1.intField), diff.getLeft());
> + assertEquals(Integer.valueOf(class2.intField), diff.getRight());
> + }
> +
> +
> + @Test
> + public void testIntArray() throws Exception {
> + TypeTestClass class1 = new TypeTestClass();
> + TypeTestClass class2 = new TypeTestClass();
> + class2.intArrayField = new int[] {3, 2, 1};
> + DiffList list = class1.diff(class2);
> + assertEquals(1, list.getNumberOfDiffs());
> + Diff<?> diff = list.getDiffs().get(0);
> + assertArrayEquals(ArrayUtils.toObject(class1.intArrayField),
> + (Object[]) diff.getLeft());
> + assertArrayEquals(ArrayUtils.toObject(class2.intArrayField),
> + (Object[]) diff.getRight());
> + }
> +
> + @Test
> + public void testLong() {
> + TypeTestClass class1 = new TypeTestClass();
> + TypeTestClass class2 = new TypeTestClass();
> + class2.longField = 42L;
> + DiffList list = class1.diff(class2);
> + assertEquals(1, list.getNumberOfDiffs());
> + Diff<?> diff = list.getDiffs().get(0);
> + assertEquals(Long.valueOf(class1.longField), diff.getLeft());
> + assertEquals(Long.valueOf(class2.longField), diff.getRight());
> + }
> +
> +
> + @Test
> + public void testLongArray() throws Exception {
> + TypeTestClass class1 = new TypeTestClass();
> + TypeTestClass class2 = new TypeTestClass();
> + class2.longArrayField = new long[] {3L, 2L, 1L};
> + DiffList list = class1.diff(class2);
> + assertEquals(1, list.getNumberOfDiffs());
> + Diff<?> diff = list.getDiffs().get(0);
> + assertArrayEquals(ArrayUtils.toObject(class1.longArrayField),
> + (Object[]) diff.getLeft());
> + assertArrayEquals(ArrayUtils.toObject(class2.longArrayField),
> + (Object[]) diff.getRight());
> + }
> +
> + @Test
> + public void testShort() {
> + TypeTestClass class1 = new TypeTestClass();
> + TypeTestClass class2 = new TypeTestClass();
> + class2.shortField = 42;
> + DiffList list = class1.diff(class2);
> + assertEquals(1, list.getNumberOfDiffs());
> + Diff<?> diff = list.getDiffs().get(0);
> + assertEquals(Short.valueOf(class1.shortField), diff.getLeft());
> + assertEquals(Short.valueOf(class2.shortField), diff.getRight());
> + }
> +
> +
> + @Test
> + public void testShortArray() throws Exception {
> + TypeTestClass class1 = new TypeTestClass();
> + TypeTestClass class2 = new TypeTestClass();
> + class2.shortArrayField = new short[] {3, 2, 1};
> + DiffList list = class1.diff(class2);
> + assertEquals(1, list.getNumberOfDiffs());
> + Diff<?> diff = list.getDiffs().get(0);
> + assertArrayEquals(ArrayUtils.toObject(class1.shortArrayField),
> + (Object[]) diff.getLeft());
> + assertArrayEquals(ArrayUtils.toObject(class2.shortArrayField),
> + (Object[]) diff.getRight());
> + }
> +
> + @Test
> + public void testObject() throws Exception {
> + TypeTestClass class1 = new TypeTestClass();
> + TypeTestClass class2 = new TypeTestClass();
> + class2.objectField = "Some string";
> + DiffList list = class1.diff(class2);
> + assertEquals(1, list.getNumberOfDiffs());
> + Diff<?> diff = list.getDiffs().get(0);
> + assertEquals(class1.objectField, diff.getLeft());
> + assertEquals(class2.objectField, diff.getRight());
> + }
> +
> + @Test
> + public void testObjectsEqual() throws Exception {
> + TypeTestClass class1 = new TypeTestClass();
> + TypeTestClass class2 = new TypeTestClass();
> + class1.objectField = "Some string";
> + class2.objectField = "Some string";
> + DiffList list = class1.diff(class2);
> + assertEquals(0, list.getNumberOfDiffs());
> + }
> +
> +
> + @Test
> + public void testObjectArray() throws Exception {
> + TypeTestClass class1 = new TypeTestClass();
> + TypeTestClass class2 = new TypeTestClass();
> + class2.objectArrayField = new Object[] {"string", 1, 2};
> + DiffList list = class1.diff(class2);
> + assertEquals(1, list.getNumberOfDiffs());
> + Diff<?> diff = list.getDiffs().get(0);
> + assertArrayEquals(class1.objectArrayField, (Object[])
> diff.getLeft());
> + assertArrayEquals(class2.objectArrayField, (Object[])
> diff.getRight());
> + }
> +
> + @Test
> + public void testObjectArrayEqual() throws Exception {
> + TypeTestClass class1 = new TypeTestClass();
> + TypeTestClass class2 = new TypeTestClass();
> + class1.objectArrayField = new Object[] {"string", 1, 2};
> + class2.objectArrayField = new Object[] {"string", 1, 2};
> + DiffList list = class1.diff(class2);
> + assertEquals(0, list.getNumberOfDiffs());
> + }
> +
> +
> + @Test
> + public void testByteArrayEqualAsObject() throws Exception {
> + DiffList list = new DiffBuilder("String1", "String2", SHORT_STYLE)
> + .append("foo", (Object) new boolean[] {false}, (Object) new
> boolean[] {false})
> + .append("foo", (Object) new byte[] {0x01}, (Object) new
> byte[] {0x01})
> + .append("foo", (Object) new char[] {'a'}, (Object) new char[]
> {'a'})
> + .append("foo", (Object) new double[] {1.0}, (Object) new
> double[] {1.0})
> + .append("foo", (Object) new float[] {1.0F}, (Object) new
> float[] {1.0F})
> + .append("foo", (Object) new int[] {1}, (Object) new int[] {1})
> + .append("foo", (Object) new long[] {1L}, (Object) new long[]
> {1L})
> + .append("foo", (Object) new short[] {1}, (Object) new short[]
> {1})
> + .append("foo", (Object) new Object[] {1, "two"}, (Object) new
> Object[] {1, "two"})
> + .build();
> +
> + assertEquals(0, list.getNumberOfDiffs());
> + }
> +
> +
> + @Test(expected=IllegalArgumentException.class)
> + public void testNullLhs() {
> + new DiffBuilder(null, this, ToStringStyle.DEFAULT_STYLE);
> + }
> +
> +
> + @Test(expected=IllegalArgumentException.class)
> + public void testNullRhs() {
> + new DiffBuilder(this, null, ToStringStyle.DEFAULT_STYLE);
> + }
> +
> + @Test
> + public void testSameObjectIgnoresAppends() {
> + TypeTestClass testClass = new TypeTestClass();
> + DiffList list = new DiffBuilder(testClass, testClass, SHORT_STYLE)
> + .append("ignored", false, true)
> + .build();
> + assertEquals(0, list.getNumberOfDiffs());
> + }
> +
> + @Test
> + public void testSimilarObjectIgnoresAppends() {
> + TypeTestClass testClass1 = new TypeTestClass();
> + TypeTestClass testClass2 = new TypeTestClass();
> + DiffList list = new DiffBuilder(testClass1, testClass2,
> SHORT_STYLE)
> + .append("ignored", false, true)
> + .build();
> + assertEquals(0, list.getNumberOfDiffs());
> + }
> +
> +
> + @Test
> + public void testStylePassedToDiffList() {
> + TypeTestClass class1 = new TypeTestClass();
> + DiffList list = class1.diff(class1);
> + assertEquals(SHORT_STYLE, list.getToStringStyle());
> +
> + class1.style = ToStringStyle.MULTI_LINE_STYLE;
> + list = class1.diff(class1);
> + assertEquals(ToStringStyle.MULTI_LINE_STYLE,
> list.getToStringStyle());
> + }
> +}
>
> Propchange:
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java
>
> ------------------------------------------------------------------------------
> svn:eol-style = native
>
> Propchange:
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java
>
> ------------------------------------------------------------------------------
> svn:keywords = Id Revision
>
> Propchange:
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java
>
> ------------------------------------------------------------------------------
> svn:mime-type = text/plain
>
> Added:
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffListTest.java
> URL:
> http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffListTest.java?rev=1561215&view=auto
>
> ==============================================================================
> ---
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffListTest.java
> (added)
> +++
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffListTest.java
> Fri Jan 24 22:37:50 2014
> @@ -0,0 +1,149 @@
> +/**
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +package org.apache.commons.lang3.builder;
> +
> +import static org.junit.Assert.assertEquals;
> +import static org.junit.Assert.assertTrue;
> +
> +import java.util.Iterator;
> +import java.util.List;
> +
> +import org.junit.Test;
> +
> +/**
> + * Unit tests {@link DiffList}.
> + *
> + * @version $Id$
> + */
> +public class DiffListTest {
> +
> + private static final SimpleClass SIMPLE_FALSE = new
> SimpleClass(false);
> + private static final SimpleClass SIMPLE_TRUE = new SimpleClass(true);
> + private static final ToStringStyle SHORT_STYLE =
> ToStringStyle.SHORT_PREFIX_STYLE;
> +
> + private static class SimpleClass implements Diffable<SimpleClass> {
> + private boolean booleanField;
> +
> + public SimpleClass(boolean booleanField) {
> + this.booleanField = booleanField;
> + }
> +
> + public static String getFieldName() {
> + return "booleanField";
> + }
> +
> + @Override
> + public DiffList diff(SimpleClass obj) {
> + return new DiffBuilder(this, obj,
> ToStringStyle.SHORT_PREFIX_STYLE)
> + .append(getFieldName(), booleanField,
> obj.booleanField)
> + .build();
> + }
> + }
> +
> + private static class EmptyClass {
> + }
> +
> + @Test(expected = UnsupportedOperationException.class)
> + public void testListIsNonModifiable() {
> + SimpleClass lhs = new SimpleClass(true);
> + SimpleClass rhs = new SimpleClass(false);
> +
> + List<Diff<?>> diffs = lhs.diff(rhs).getDiffs();
> +
> + DiffList list = new DiffList(lhs, rhs, diffs, SHORT_STYLE);
> + assertEquals(diffs, list.getDiffs());
> + assertEquals(1, list.getNumberOfDiffs());
> + list.getDiffs().remove(0);
> + }
> +
> + @Test
> + public void testIterator() {
> + SimpleClass lhs = new SimpleClass(true);
> + SimpleClass rhs = new SimpleClass(false);
> +
> + List<Diff<?>> diffs = lhs.diff(rhs).getDiffs();
> + Iterator<Diff<?>> expectedIterator = diffs.iterator();
> +
> + DiffList list = new DiffList(lhs, rhs, diffs, SHORT_STYLE);
> + Iterator<Diff<?>> iterator = list.iterator();
> +
> + while (iterator.hasNext()) {
> + assertTrue(expectedIterator.hasNext());
> + assertEquals(expectedIterator.next(), iterator.next());
> + }
> + }
> +
> + @Test
> + public void testToStringOutput() {
> + DiffList list = new DiffBuilder(new EmptyClass(), new
> EmptyClass(),
> + ToStringStyle.SHORT_PREFIX_STYLE).append("test", false,
> true)
> + .build();
> + assertEquals(
> + "DiffListTest.EmptyClass[test=false] differs from
> DiffListTest.EmptyClass[test=true]",
> + list.toString());
> + }
> +
> + @Test
> + public void testToStringSpecifyStyleOutput() {
> + DiffList list = SIMPLE_FALSE.diff(SIMPLE_TRUE);
> + assertTrue(list.getToStringStyle().equals(SHORT_STYLE));
> +
> + String lhsString = new ToStringBuilder(SIMPLE_FALSE,
> + ToStringStyle.MULTI_LINE_STYLE).append(
> + SimpleClass.getFieldName(),
> SIMPLE_FALSE.booleanField).build();
> +
> + String rhsString = new ToStringBuilder(SIMPLE_TRUE,
> + ToStringStyle.MULTI_LINE_STYLE).append(
> + SimpleClass.getFieldName(),
> SIMPLE_TRUE.booleanField).build();
> +
> + String expectedOutput = String.format("%s differs from %s",
> lhsString,
> + rhsString);
> + assertEquals(expectedOutput,
> + list.toString(ToStringStyle.MULTI_LINE_STYLE));
> + }
> +
> + @Test(expected = IllegalArgumentException.class)
> + public void testNullLhs() {
> + new DiffList(null, SIMPLE_FALSE, SIMPLE_TRUE.diff(SIMPLE_FALSE)
> + .getDiffs(), SHORT_STYLE);
> + }
> +
> + @Test(expected = IllegalArgumentException.class)
> + public void testNullRhs() {
> + new DiffList(SIMPLE_TRUE, null, SIMPLE_TRUE.diff(SIMPLE_FALSE)
> + .getDiffs(), SHORT_STYLE);
> + }
> +
> + @Test(expected = IllegalArgumentException.class)
> + public void testNullList() {
> + new DiffList(SIMPLE_TRUE, SIMPLE_FALSE, null, SHORT_STYLE);
> + }
> +
> + @Test
> + public void testNullStyle() {
> + DiffList diffList = new DiffList(SIMPLE_TRUE, SIMPLE_FALSE,
> SIMPLE_TRUE
> + .diff(SIMPLE_FALSE).getDiffs(), null);
> + assertEquals(ToStringStyle.DEFAULT_STYLE,
> diffList.getToStringStyle());
> + }
> +
> + @Test
> + public void testNoDifferencesString() {
> + DiffList diffList = new DiffBuilder(SIMPLE_TRUE, SIMPLE_TRUE,
> + SHORT_STYLE).build();
> + assertEquals(DiffList.OBJECTS_SAME_STRING, diffList.toString());
> + }
> +}
>
> Propchange:
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffListTest.java
>
> ------------------------------------------------------------------------------
> svn:eol-style = native
>
> Propchange:
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffListTest.java
>
> ------------------------------------------------------------------------------
> svn:keywords = Id Revision
>
> Propchange:
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffListTest.java
>
> ------------------------------------------------------------------------------
> svn:mime-type = text/plain
>
> Added:
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffTest.java
> URL:
> http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffTest.java?rev=1561215&view=auto
>
> ==============================================================================
> ---
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffTest.java
> (added)
> +++
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffTest.java
> Fri Jan 24 22:37:50 2014
> @@ -0,0 +1,72 @@
> +/**
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +package org.apache.commons.lang3.builder;
> +
> +import static org.junit.Assert.assertEquals;
> +
> +import org.junit.Test;
> +
> +
> +/**
> + * Unit tests {@link Diff}.
> + *
> + * @version $Id$
> + */
> +public class DiffTest {
> +
> + private static final String FIELD_NAME = "field";
> + private static final Diff<Boolean> booleanDiff = new
> BooleanDiff(FIELD_NAME);
> +
> + private static class BooleanDiff extends Diff<Boolean> {
> + private static final long serialVersionUID = 1L;
> +
> + protected BooleanDiff(String fieldName) {
> + super(fieldName);
> + }
> +
> + @Override
> + public Boolean getLeft() {
> + return Boolean.TRUE;
> + }
> +
> + @Override
> + public Boolean getRight() {
> + return Boolean.FALSE;
> + }
> + }
> +
> + @Test(expected = UnsupportedOperationException.class)
> + public void testCannotModify() {
> + booleanDiff.setValue(Boolean.FALSE);
> + }
> +
> + @Test
> + public void testGetFieldName() {
> + assertEquals(FIELD_NAME, booleanDiff.getFieldName());
> + }
> +
> + @Test
> + public void testGetType() {
> + assertEquals(Boolean.class, booleanDiff.getType());
> + }
> +
> + @Test
> + public void testToString() {
> + assertEquals(String.format("[%s: %s, %s]", FIELD_NAME,
> booleanDiff.getLeft(),
> + booleanDiff.getRight()), booleanDiff.toString());
> + }
> +}
>
> Propchange:
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffTest.java
>
> ------------------------------------------------------------------------------
> svn:eol-style = native
>
> Propchange:
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffTest.java
>
> ------------------------------------------------------------------------------
> svn:keywords = Id Revision
>
> Propchange:
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffTest.java
>
> ------------------------------------------------------------------------------
> svn:mime-type = text/plain
>
>
>
Re: svn commit: r1561215 - in /commons/proper/lang/trunk/src:
changes/ main/java/org/apache/commons/lang3/builder/ test/java/org/apache/commons/lang3/builder/
Posted by Matt Benson <gu...@gmail.com>.
And I thought I was gentle. :D
On Fri, Jan 24, 2014 at 5:05 PM, Duncan Jones <du...@wortharead.com> wrote:
> Hi Matt,
>
> On 24 January 2014 22:51, Matt Benson <gu...@gmail.com> wrote:
> > Hi, Duncan, and congrats on your first commit! However, based on the
> > comments of those of us who were participating in JIRA, I had expected
> that
> > DiffList would be renamed to DiffResult, to avoid any confusion based on
> > its being *named* "*List" without actually *implementing* the
> > java.util.List interface.
> >
> > br,
> > Matt
>
> Ah, the email I was dreading after my first commit! You are quite
> correct, of course, I'll amend that now.
>
> Duncan
>
> >
> >
> > On Fri, Jan 24, 2014 at 4:37 PM, <dj...@apache.org> wrote:
> >
> >> Author: djones
> >> Date: Fri Jan 24 22:37:50 2014
> >> New Revision: 1561215
> >>
> >> URL: http://svn.apache.org/r1561215
> >> Log:
> >> LANG-637: There should be a DifferenceBuilder with a
> >> ReflectionDifferenceBuilder implementation
> >>
> >> Added:
> >>
> >>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diff.java
> >> (with props)
> >>
> >>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffBuilder.java
> >> (with props)
> >>
> >>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffList.java
> >> (with props)
> >>
> >>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diffable.java
> >> (with props)
> >>
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java
> >> (with props)
> >>
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffListTest.java
> >> (with props)
> >>
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffTest.java
> >> (with props)
> >> Modified:
> >> commons/proper/lang/trunk/src/changes/changes.xml
> >>
> >> Modified: commons/proper/lang/trunk/src/changes/changes.xml
> >> URL:
> >>
> http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/changes/changes.xml?rev=1561215&r1=1561214&r2=1561215&view=diff
> >>
> >>
> ==============================================================================
> >> --- commons/proper/lang/trunk/src/changes/changes.xml [utf-8] (original)
> >> +++ commons/proper/lang/trunk/src/changes/changes.xml [utf-8] Fri Jan 24
> >> 22:37:50 2014
> >> @@ -22,6 +22,7 @@
> >> <body>
> >>
> >> <release version="3.3" date="TBA" description="Bugfix and Feature
> >> release">
> >> + <action issue="LANG-637" type="add" dev="djones">There should be a
> >> DifferenceBuilder with a ReflectionDifferenceBuilder
> implementation</action>
> >> <action issue="LANG-954" type="fix" due-to="Michael Keppler"
> >> dev="sebb">uncaught PatternSyntaxException in FastDateFormat on
> >> Android</action>
> >> <action issue="LANG-956" type="update" dev="britter">Improve
> JavaDoc
> >> of WordUtils.wrap methods</action>
> >> <action issue="LANG-944" type="add" dev="britter" due-to="Rekha
> >> Joshi">Add the Jaro-Winkler string distance algorithm to
> >> StringUtils</action>
> >>
> >> Added:
> >>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diff.java
> >> URL:
> >>
> http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diff.java?rev=1561215&view=auto
> >>
> >>
> ==============================================================================
> >> ---
> >>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diff.java
> >> (added)
> >> +++
> >>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diff.java
> >> Fri Jan 24 22:37:50 2014
> >> @@ -0,0 +1,119 @@
> >> +/**
> >> + * Licensed to the Apache Software Foundation (ASF) under one or more
> >> + * contributor license agreements. See the NOTICE file distributed
> with
> >> + * this work for additional information regarding copyright ownership.
> >> + * The ASF licenses this file to You under the Apache License, Version
> 2.0
> >> + * (the "License"); you may not use this file except in compliance with
> >> + * the License. You may obtain a copy of the License at
> >> + *
> >> + * http://www.apache.org/licenses/LICENSE-2.0
> >> + *
> >> + * Unless required by applicable law or agreed to in writing, software
> >> + * distributed under the License is distributed on an "AS IS" BASIS,
> >> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> >> implied.
> >> + * See the License for the specific language governing permissions and
> >> + * limitations under the License.
> >> + */
> >> +package org.apache.commons.lang3.builder;
> >> +
> >> +import java.lang.reflect.Type;
> >> +
> >> +import org.apache.commons.lang3.ObjectUtils;
> >> +import org.apache.commons.lang3.reflect.TypeUtils;
> >> +import org.apache.commons.lang3.tuple.Pair;
> >> +
> >> +/**
> >> + * <p>
> >> + * A {@code Diff} contains the differences between two {@link Diffable}
> >> class
> >> + * fields.
> >> + * </p>
> >> + *
> >> + * <p>
> >> + * Typically, {@code Diff}s are retrieved by using a {@link
> DiffBuilder}
> >> to
> >> + * produce a {@link DiffList}, containing the differences between two
> >> objects.
> >> + * </p>
> >> + *
> >> + *
> >> + * @param <T>
> >> + * The type of object contained within this {@code Diff}.
> >> Differences
> >> + * between primitive objects are stored as their Object
> wrapper
> >> + * equivalent.
> >> + * @since 3.3
> >> + * @version $Id$
> >> + */
> >> +public abstract class Diff<T> extends Pair<T, T> {
> >> +
> >> + private static final long serialVersionUID = 1L;
> >> +
> >> + private final Type type;
> >> + private final String fieldName;
> >> +
> >> + /**
> >> + * <p>
> >> + * Constructs a new {@code Diff} for the given field name.
> >> + * </p>
> >> + *
> >> + * @param fieldName
> >> + * the name of the field
> >> + */
> >> + protected Diff(String fieldName) {
> >> + this.type = ObjectUtils.defaultIfNull(
> >> + TypeUtils.getTypeArguments(getClass(), Diff.class).get(
> >> + Diff.class.getTypeParameters()[0]),
> Object.class);
> >> + this.fieldName = fieldName;
> >> + }
> >> +
> >> + /**
> >> + * <p>
> >> + * Returns the type of the field.
> >> + * </p>
> >> + *
> >> + * @return the field type
> >> + */
> >> + public final Type getType() {
> >> + return type;
> >> + }
> >> +
> >> + /**
> >> + * <p>
> >> + * Returns the name of the field.
> >> + * </p>
> >> + *
> >> + * @return the field name
> >> + */
> >> + public final String getFieldName() {
> >> + return fieldName;
> >> + }
> >> +
> >> + /**
> >> + * <p>
> >> + * Returns a {@code String} representation of the {@code Diff},
> with
> >> the
> >> + * following format:
> >> + *
> >> + * <pre>
> >> + * [fieldname: left-value, right-value]
> >> + * </pre>
> >> + *
> >> + * </p>
> >> + *
> >> + * @return the string representation
> >> + */
> >> + @Override
> >> + public final String toString() {
> >> + return String.format("[%s: %s, %s]", fieldName, getLeft(),
> >> getRight());
> >> + }
> >> +
> >> + /**
> >> + * <p>
> >> + * Throws {@code UnsupportedOperationException}.
> >> + * </p>
> >> + *
> >> + * @param value
> >> + * ignored
> >> + * @return nothing
> >> + */
> >> + @Override
> >> + public final T setValue(T value) {
> >> + throw new UnsupportedOperationException("Cannot alter Diff
> >> object.");
> >> + }
> >> +}
> >>
> >> Propchange:
> >>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diff.java
> >>
> >>
> ------------------------------------------------------------------------------
> >> svn:eol-style = native
> >>
> >> Propchange:
> >>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diff.java
> >>
> >>
> ------------------------------------------------------------------------------
> >> svn:keywords = Id Revision
> >>
> >> Propchange:
> >>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diff.java
> >>
> >>
> ------------------------------------------------------------------------------
> >> svn:mime-type = text/plain
> >>
> >> Added:
> >>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffBuilder.java
> >> URL:
> >>
> http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffBuilder.java?rev=1561215&view=auto
> >>
> >>
> ==============================================================================
> >> ---
> >>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffBuilder.java
> >> (added)
> >> +++
> >>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffBuilder.java
> >> Fri Jan 24 22:37:50 2014
> >> @@ -0,0 +1,914 @@
> >> +/**
> >> + * Licensed to the Apache Software Foundation (ASF) under one or more
> >> + * contributor license agreements. See the NOTICE file distributed
> with
> >> + * this work for additional information regarding copyright ownership.
> >> + * The ASF licenses this file to You under the Apache License, Version
> 2.0
> >> + * (the "License"); you may not use this file except in compliance with
> >> + * the License. You may obtain a copy of the License at
> >> + *
> >> + * http://www.apache.org/licenses/LICENSE-2.0
> >> + *
> >> + * Unless required by applicable law or agreed to in writing, software
> >> + * distributed under the License is distributed on an "AS IS" BASIS,
> >> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> >> implied.
> >> + * See the License for the specific language governing permissions and
> >> + * limitations under the License.
> >> + */
> >> +package org.apache.commons.lang3.builder;
> >> +
> >> +import java.util.ArrayList;
> >> +import java.util.Arrays;
> >> +import java.util.List;
> >> +
> >> +import org.apache.commons.lang3.ArrayUtils;
> >> +
> >> +/**
> >> + * <p>
> >> + * Assists in implementing {@link Diffable#diff(Object)} methods.
> >> + * </p>
> >> + *
> >> + * <p>
> >> + * To use this class, write code as follows:
> >> + * </p>
> >> + *
> >> + * <pre>
> >> + * public class Person implements Diffable<Person> {
> >> + * String name;
> >> + * int age;
> >> + * boolean smoker;
> >> + *
> >> + * ...
> >> + *
> >> + * public DiffList diff(Person obj) {
> >> + * // No need for null check, as NullPointerException correct if
> obj
> >> is null
> >> + * return new DiffBuilder(this, obj,
> ToStringStyle.SHORT_PREFIX_STYLE)
> >> + * .append("name", this.name, obj.name)
> >> + * .append("age", this.age, obj.age)
> >> + * .append("smoker", this.smoker, obj.smoker)
> >> + * .build();
> >> + * }
> >> + * }
> >> + * </pre>
> >> + *
> >> + * <p>
> >> + * The {@code ToStringStyle} passed to the constructor is embedded in
> the
> >> + * returned {@code DiffList} and influences the style of the
> >> + * {@code DiffList.toString()} method. This style choice can be
> >> overridden by
> >> + * calling {@link DiffList#toString(ToStringStyle)}.
> >> + * </p>
> >> + *
> >> + * @since 3.3
> >> + * @version $Id$
> >> + * @see Diffable
> >> + * @see Diff
> >> + * @see DiffList
> >> + * @see ToStringStyle
> >> + */
> >> +public class DiffBuilder implements Builder<DiffList> {
> >> +
> >> + private final List<Diff<?>> diffs;
> >> + private final boolean objectsTriviallyEqual;
> >> + private final Object lhs;
> >> + private final Object rhs;
> >> + private final ToStringStyle style;
> >> +
> >> + /**
> >> + * <p>
> >> + * Constructs a builder for the specified objects with the
> specified
> >> style.
> >> + * </p>
> >> + *
> >> + * <p>
> >> + * If {@code lhs == rhs} or {@code lhs.equals(rhs)} then the
> builder
> >> will
> >> + * not evaluate any calls to {@code append(...)} and will return an
> >> empty
> >> + * {@link DiffList} when {@link #build()} is executed.
> >> + * </p>
> >> + *
> >> + * @param lhs
> >> + * {@code this} object
> >> + * @param rhs
> >> + * the object to diff against
> >> + * @param style
> >> + * the style will use when outputting the objects,
> {@code
> >> null}
> >> + * uses the default
> >> + * @throws IllegalArgumentException
> >> + * if {@code lhs} or {@code rhs} is {@code null}
> >> + */
> >> + public DiffBuilder(final Object lhs, final Object rhs,
> >> + final ToStringStyle style) {
> >> + if (lhs == null) {
> >> + throw new IllegalArgumentException("lhs cannot be null");
> >> + }
> >> + if (rhs == null) {
> >> + throw new IllegalArgumentException("rhs cannot be null");
> >> + }
> >> +
> >> + this.diffs = new ArrayList<Diff<?>>();
> >> + this.lhs = lhs;
> >> + this.rhs = rhs;
> >> + this.style = style;
> >> +
> >> + // Don't compare any fields if objects equal
> >> + this.objectsTriviallyEqual = (lhs == rhs || lhs.equals(rhs));
> >> + }
> >> +
> >> + /**
> >> + * <p>
> >> + * Test if two {@code boolean}s are equal.
> >> + * </p>
> >> + *
> >> + * @param fieldName
> >> + * the field name
> >> + * @param lhs
> >> + * the left hand {@code boolean}
> >> + * @param rhs
> >> + * the right hand {@code boolean}
> >> + * @return this
> >> + * @throws IllegalArgumentException
> >> + * if field name is {@code null}
> >> + */
> >> + public DiffBuilder append(final String fieldName, final boolean
> lhs,
> >> + final boolean rhs) {
> >> + if (fieldName == null) {
> >> + throw new IllegalArgumentException("Field name cannot be
> >> null");
> >> + }
> >> +
> >> + if (objectsTriviallyEqual) {
> >> + 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;
> >> + }
> >> +
> >> + /**
> >> + * <p>
> >> + * Test if two {@code boolean[]}s are equal.
> >> + * </p>
> >> + *
> >> + * @param fieldName
> >> + * the field name
> >> + * @param lhs
> >> + * the left hand {@code boolean[]}
> >> + * @param rhs
> >> + * the right hand {@code boolean[]}
> >> + * @return this
> >> + * @throws IllegalArgumentException
> >> + * if field name is {@code null}
> >> + */
> >> + public DiffBuilder append(final String fieldName, final boolean[]
> lhs,
> >> + final boolean[] rhs) {
> >> + if (fieldName == null) {
> >> + throw new IllegalArgumentException("Field name cannot be
> >> null");
> >> + }
> >> + if (objectsTriviallyEqual) {
> >> + 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;
> >> + }
> >> +
> >> + /**
> >> + * <p>
> >> + * Test if two {@code byte}s are equal.
> >> + * </p>
> >> + *
> >> + * @param fieldName
> >> + * the field name
> >> + * @param lhs
> >> + * the left hand {@code byte}
> >> + * @param rhs
> >> + * the right hand {@code byte}
> >> + * @return this
> >> + * @throws IllegalArgumentException
> >> + * if field name is {@code null}
> >> + */
> >> + public DiffBuilder append(final String fieldName, final byte lhs,
> >> + final byte rhs) {
> >> + if (fieldName == null) {
> >> + throw new IllegalArgumentException("Field name cannot be
> >> null");
> >> + }
> >> + if (objectsTriviallyEqual) {
> >> + 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;
> >> + }
> >> +
> >> + /**
> >> + * <p>
> >> + * Test if two {@code byte[]}s are equal.
> >> + * </p>
> >> + *
> >> + * @param fieldName
> >> + * the field name
> >> + * @param lhs
> >> + * the left hand {@code byte[]}
> >> + * @param rhs
> >> + * the right hand {@code byte[]}
> >> + * @return this
> >> + * @throws IllegalArgumentException
> >> + * if field name is {@code null}
> >> + */
> >> + public DiffBuilder append(final String fieldName, final byte[] lhs,
> >> + final byte[] rhs) {
> >> + if (fieldName == null) {
> >> + throw new IllegalArgumentException("Field name cannot be
> >> null");
> >> + }
> >> +
> >> + if (objectsTriviallyEqual) {
> >> + 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;
> >> + }
> >> +
> >> + /**
> >> + * <p>
> >> + * Test if two {@code char}s are equal.
> >> + * </p>
> >> + *
> >> + * @param fieldName
> >> + * the field name
> >> + * @param lhs
> >> + * the left hand {@code char}
> >> + * @param rhs
> >> + * the right hand {@code char}
> >> + * @return this
> >> + * @throws IllegalArgumentException
> >> + * if field name is {@code null}
> >> + */
> >> + public DiffBuilder append(final String fieldName, final char lhs,
> >> + final char rhs) {
> >> + if (fieldName == null) {
> >> + throw new IllegalArgumentException("Field name cannot be
> >> null");
> >> + }
> >> +
> >> + if (objectsTriviallyEqual) {
> >> + 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;
> >> + }
> >> +
> >> + /**
> >> + * <p>
> >> + * Test if two {@code char[]}s are equal.
> >> + * </p>
> >> + *
> >> + * @param fieldName
> >> + * the field name
> >> + * @param lhs
> >> + * the left hand {@code char[]}
> >> + * @param rhs
> >> + * the right hand {@code char[]}
> >> + * @return this
> >> + * @throws IllegalArgumentException
> >> + * if field name is {@code null}
> >> + */
> >> + public DiffBuilder append(final String fieldName, final char[] lhs,
> >> + final char[] rhs) {
> >> + if (fieldName == null) {
> >> + throw new IllegalArgumentException("Field name cannot be
> >> null");
> >> + }
> >> +
> >> + if (objectsTriviallyEqual) {
> >> + 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;
> >> + }
> >> +
> >> + /**
> >> + * <p>
> >> + * Test if two {@code double}s are equal.
> >> + * </p>
> >> + *
> >> + * @param fieldName
> >> + * the field name
> >> + * @param lhs
> >> + * the left hand {@code double}
> >> + * @param rhs
> >> + * the right hand {@code double}
> >> + * @return this
> >> + * @throws IllegalArgumentException
> >> + * if field name is {@code null}
> >> + */
> >> + public DiffBuilder append(final String fieldName, final double lhs,
> >> + final double rhs) {
> >> + if (fieldName == null) {
> >> + throw new IllegalArgumentException("Field name cannot be
> >> null");
> >> + }
> >> +
> >> + if (objectsTriviallyEqual) {
> >> + 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;
> >> + }
> >> +
> >> + /**
> >> + * <p>
> >> + * Test if two {@code double[]}s are equal.
> >> + * </p>
> >> + *
> >> + * @param fieldName
> >> + * the field name
> >> + * @param lhs
> >> + * the left hand {@code double[]}
> >> + * @param rhs
> >> + * the right hand {@code double[]}
> >> + * @return this
> >> + * @throws IllegalArgumentException
> >> + * if field name is {@code null}
> >> + */
> >> + public DiffBuilder append(final String fieldName, final double[]
> lhs,
> >> + final double[] rhs) {
> >> + if (fieldName == null) {
> >> + throw new IllegalArgumentException("Field name cannot be
> >> null");
> >> + }
> >> +
> >> + if (objectsTriviallyEqual) {
> >> + 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;
> >> + }
> >> +
> >> + /**
> >> + * <p>
> >> + * Test if two {@code float}s are equal.
> >> + * </p>
> >> + *
> >> + * @param fieldName
> >> + * the field name
> >> + * @param lhs
> >> + * the left hand {@code float}
> >> + * @param rhs
> >> + * the right hand {@code float}
> >> + * @return this
> >> + * @throws IllegalArgumentException
> >> + * if field name is {@code null}
> >> + */
> >> + public DiffBuilder append(final String fieldName, final float lhs,
> >> + final float rhs) {
> >> + if (fieldName == null) {
> >> + throw new IllegalArgumentException("Field name cannot be
> >> null");
> >> + }
> >> +
> >> + if (objectsTriviallyEqual) {
> >> + 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;
> >> + }
> >> +
> >> + /**
> >> + * <p>
> >> + * Test if two {@code float[]}s are equal.
> >> + * </p>
> >> + *
> >> + * @param fieldName
> >> + * the field name
> >> + * @param lhs
> >> + * the left hand {@code float[]}
> >> + * @param rhs
> >> + * the right hand {@code float[]}
> >> + * @return this
> >> + * @throws IllegalArgumentException
> >> + * if field name is {@code null}
> >> + */
> >> + public DiffBuilder append(final String fieldName, final float[]
> lhs,
> >> + final float[] rhs) {
> >> + if (fieldName == null) {
> >> + throw new IllegalArgumentException("Field name cannot be
> >> null");
> >> + }
> >> +
> >> + if (objectsTriviallyEqual) {
> >> + 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;
> >> + }
> >> +
> >> + /**
> >> + * <p>
> >> + * Test if two {@code int}s are equal.
> >> + * </p>
> >> + *
> >> + * @param fieldName
> >> + * the field name
> >> + * @param lhs
> >> + * the left hand {@code int}
> >> + * @param rhs
> >> + * the right hand {@code int}
> >> + * @return this
> >> + * @throws IllegalArgumentException
> >> + * if field name is {@code null}
> >> + */
> >> + public DiffBuilder append(final String fieldName, final int lhs,
> >> + final int rhs) {
> >> + if (fieldName == null) {
> >> + throw new IllegalArgumentException("Field name cannot be
> >> null");
> >> + }
> >> +
> >> + if (objectsTriviallyEqual) {
> >> + 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;
> >> + }
> >> +
> >> + /**
> >> + * <p>
> >> + * Test if two {@code int[]}s are equal.
> >> + * </p>
> >> + *
> >> + * @param fieldName
> >> + * the field name
> >> + * @param lhs
> >> + * the left hand {@code int[]}
> >> + * @param rhs
> >> + * the right hand {@code int[]}
> >> + * @return this
> >> + * @throws IllegalArgumentException
> >> + * if field name is {@code null}
> >> + */
> >> + public DiffBuilder append(final String fieldName, final int[] lhs,
> >> + final int[] rhs) {
> >> + if (fieldName == null) {
> >> + throw new IllegalArgumentException("Field name cannot be
> >> null");
> >> + }
> >> +
> >> + if (objectsTriviallyEqual) {
> >> + 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;
> >> + }
> >> +
> >> + /**
> >> + * <p>
> >> + * Test if two {@code long}s are equal.
> >> + * </p>
> >> + *
> >> + * @param fieldName
> >> + * the field name
> >> + * @param lhs
> >> + * the left hand {@code long}
> >> + * @param rhs
> >> + * the right hand {@code long}
> >> + * @return this
> >> + * @throws IllegalArgumentException
> >> + * if field name is {@code null}
> >> + */
> >> + public DiffBuilder append(final String fieldName, final long lhs,
> >> + final long rhs) {
> >> + if (fieldName == null) {
> >> + throw new IllegalArgumentException("Field name cannot be
> >> null");
> >> + }
> >> +
> >> + if (objectsTriviallyEqual) {
> >> + 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;
> >> + }
> >> +
> >> + /**
> >> + * <p>
> >> + * Test if two {@code long[]}s are equal.
> >> + * </p>
> >> + *
> >> + * @param fieldName
> >> + * the field name
> >> + * @param lhs
> >> + * the left hand {@code long[]}
> >> + * @param rhs
> >> + * the right hand {@code long[]}
> >> + * @return this
> >> + * @throws IllegalArgumentException
> >> + * if field name is {@code null}
> >> + */
> >> + public DiffBuilder append(final String fieldName, final long[] lhs,
> >> + final long[] rhs) {
> >> + if (fieldName == null) {
> >> + throw new IllegalArgumentException("Field name cannot be
> >> null");
> >> + }
> >> +
> >> + if (objectsTriviallyEqual) {
> >> + 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;
> >> + }
> >> +
> >> + /**
> >> + * <p>
> >> + * Test if two {@code short}s are equal.
> >> + * </p>
> >> + *
> >> + * @param fieldName
> >> + * the field name
> >> + * @param lhs
> >> + * the left hand {@code short}
> >> + * @param rhs
> >> + * the right hand {@code short}
> >> + * @return this
> >> + * @throws IllegalArgumentException
> >> + * if field name is {@code null}
> >> + */
> >> + public DiffBuilder append(final String fieldName, final short lhs,
> >> + final short rhs) {
> >> + if (fieldName == null) {
> >> + throw new IllegalArgumentException("Field name cannot be
> >> null");
> >> + }
> >> +
> >> + if (objectsTriviallyEqual) {
> >> + 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;
> >> + }
> >> +
> >> + /**
> >> + * <p>
> >> + * Test if two {@code short[]}s are equal.
> >> + * </p>
> >> + *
> >> + * @param fieldName
> >> + * the field name
> >> + * @param lhs
> >> + * the left hand {@code short[]}
> >> + * @param rhs
> >> + * the right hand {@code short[]}
> >> + * @return this
> >> + * @throws IllegalArgumentException
> >> + * if field name is {@code null}
> >> + */
> >> + public DiffBuilder append(final String fieldName, final short[]
> lhs,
> >> + final short[] rhs) {
> >> + if (fieldName == null) {
> >> + throw new IllegalArgumentException("Field name cannot be
> >> null");
> >> + }
> >> +
> >> + if (objectsTriviallyEqual) {
> >> + 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;
> >> + }
> >> +
> >> + /**
> >> + * <p>
> >> + * Test if two {@code Objects}s are equal.
> >> + * </p>
> >> + *
> >> + * @param fieldName
> >> + * the field name
> >> + * @param lhs
> >> + * the left hand {@code Object}
> >> + * @param rhs
> >> + * the right hand {@code Object}
> >> + * @return this
> >> + */
> >> + public DiffBuilder append(final String fieldName, final Object lhs,
> >> + final Object rhs) {
> >> +
> >> + if (objectsTriviallyEqual) {
> >> + return this;
> >> + }
> >> + if (lhs == rhs) {
> >> + return this;
> >> + }
> >> +
> >> + Object objectToTest;
> >> + if (lhs != null) {
> >> + objectToTest = lhs;
> >> + } else {
> >> + // rhs cannot be null, as lhs != rhs
> >> + objectToTest = rhs;
> >> + }
> >> +
> >> + if (objectToTest.getClass().isArray()) {
> >> + if (objectToTest instanceof boolean[]) {
> >> + return append(fieldName, (boolean[]) lhs, (boolean[])
> >> rhs);
> >> + }
> >> + if (objectToTest instanceof byte[]) {
> >> + return append(fieldName, (byte[]) lhs, (byte[]) rhs);
> >> + }
> >> + if (objectToTest instanceof char[]) {
> >> + return append(fieldName, (char[]) lhs, (char[]) rhs);
> >> + }
> >> + if (objectToTest instanceof double[]) {
> >> + return append(fieldName, (double[]) lhs, (double[])
> rhs);
> >> + }
> >> + if (objectToTest instanceof float[]) {
> >> + return append(fieldName, (float[]) lhs, (float[]) rhs);
> >> + }
> >> + if (objectToTest instanceof int[]) {
> >> + return append(fieldName, (int[]) lhs, (int[]) rhs);
> >> + }
> >> + if (objectToTest instanceof long[]) {
> >> + return append(fieldName, (long[]) lhs, (long[]) rhs);
> >> + }
> >> + if (objectToTest instanceof short[]) {
> >> + return append(fieldName, (short[]) lhs, (short[]) rhs);
> >> + }
> >> +
> >> + return append(fieldName, (Object[]) lhs, (Object[]) rhs);
> >> + }
> >> +
> >> + // Not array type
> >> + 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;
> >> + }
> >> +
> >> + /**
> >> + * <p>
> >> + * Test if two {@code Object[]}s are equal.
> >> + * </p>
> >> + *
> >> + * @param fieldName
> >> + * the field name
> >> + * @param lhs
> >> + * the left hand {@code Object[]}
> >> + * @param rhs
> >> + * the right hand {@code Object[]}
> >> + * @return this
> >> + */
> >> + public DiffBuilder append(final String fieldName, final Object[]
> lhs,
> >> + final Object[] rhs) {
> >> + if (objectsTriviallyEqual) {
> >> + 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;
> >> + }
> >> +
> >> + /**
> >> + * <p>
> >> + * Builds a {@link DiffList} based on the differences appended to
> this
> >> + * builder.
> >> + * </p>
> >> + *
> >> + * @return a {@code DiffList} containing the differences between
> the
> >> two
> >> + * objects.
> >> + */
> >> + @Override
> >> + public DiffList build() {
> >> + return new DiffList(lhs, rhs, diffs, style);
> >> + }
> >> +
> >> +}
> >>
> >> Propchange:
> >>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffBuilder.java
> >>
> >>
> ------------------------------------------------------------------------------
> >> svn:eol-style = native
> >>
> >> Propchange:
> >>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffBuilder.java
> >>
> >>
> ------------------------------------------------------------------------------
> >> svn:keywords = Id Revision
> >>
> >> Propchange:
> >>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffBuilder.java
> >>
> >>
> ------------------------------------------------------------------------------
> >> svn:mime-type = text/plain
> >>
> >> Added:
> >>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffList.java
> >> URL:
> >>
> http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffList.java?rev=1561215&view=auto
> >>
> >>
> ==============================================================================
> >> ---
> >>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffList.java
> >> (added)
> >> +++
> >>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffList.java
> >> Fri Jan 24 22:37:50 2014
> >> @@ -0,0 +1,208 @@
> >> +/**
> >> + * Licensed to the Apache Software Foundation (ASF) under one or more
> >> + * contributor license agreements. See the NOTICE file distributed
> with
> >> + * this work for additional information regarding copyright ownership.
> >> + * The ASF licenses this file to You under the Apache License, Version
> 2.0
> >> + * (the "License"); you may not use this file except in compliance with
> >> + * the License. You may obtain a copy of the License at
> >> + *
> >> + * http://www.apache.org/licenses/LICENSE-2.0
> >> + *
> >> + * Unless required by applicable law or agreed to in writing, software
> >> + * distributed under the License is distributed on an "AS IS" BASIS,
> >> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> >> implied.
> >> + * See the License for the specific language governing permissions and
> >> + * limitations under the License.
> >> + */
> >> +package org.apache.commons.lang3.builder;
> >> +
> >> +import java.util.Collections;
> >> +import java.util.Iterator;
> >> +import java.util.List;
> >> +
> >> +/**
> >> + * <p>
> >> + * A {@code DiffList} contains a list of the differences between two
> >> + * {@link Diffable} objects. Typically these differences are displayed
> >> using
> >> + * {@link #toString()} method, which returns a string describing the
> >> fields that
> >> + * differ between the objects.
> >> + * </p>
> >> + * <p>
> >> + * Use a {@link DiffBuilder} to build a {@code DiffList} comparing two
> >> objects.
> >> + * </p>
> >> + *
> >> + * @since 3.3
> >> + * @version $Id$
> >> + */
> >> +public class DiffList implements Iterable<Diff<?>> {
> >> +
> >> + /**
> >> + * <p>
> >> + * The {@code String} returned when the objects have no
> differences:
> >> + * {@value}
> >> + * </p>
> >> + */
> >> + public static final String OBJECTS_SAME_STRING = "";
> >> +
> >> + private static final String DIFFERS_STRING = "differs from";
> >> +
> >> + private final List<Diff<?>> diffs;
> >> + private final Object lhs;
> >> + private final Object rhs;
> >> + private final ToStringStyle style;
> >> +
> >> + /**
> >> + * <p>
> >> + * Creates a {@link DiffList} containing the differences between
> two
> >> + * objects.
> >> + * </p>
> >> + *
> >> + * @param lhs
> >> + * the left hand object
> >> + * @param rhs
> >> + * the right hand object
> >> + * @param diffs
> >> + * the list of differences, may be empty
> >> + * @param style
> >> + * the style to use for the {@link #toString()} method.
> >> May be
> >> + * {@code null}, in which case
> >> + * {@link ToStringStyle#DEFAULT_STYLE} is used
> >> + * @throws IllegalArgumentException
> >> + * if {@code lhs}, {@code rhs} or {@code diffs} is
> {@code
> >> null}
> >> + */
> >> + DiffList(final Object lhs, final Object rhs, final List<Diff<?>>
> >> diffs,
> >> + final ToStringStyle style) {
> >> + if (lhs == null) {
> >> + throw new IllegalArgumentException(
> >> + "Left hand object cannot be null");
> >> + }
> >> + if (rhs == null) {
> >> + throw new IllegalArgumentException(
> >> + "Right hand object cannot be null");
> >> + }
> >> + if (diffs == null) {
> >> + throw new IllegalArgumentException(
> >> + "List of differences cannot be null");
> >> + }
> >> +
> >> + this.diffs = diffs;
> >> + this.lhs = lhs;
> >> + this.rhs = rhs;
> >> +
> >> + if (style == null) {
> >> + this.style = ToStringStyle.DEFAULT_STYLE;
> >> + } else {
> >> + this.style = style;
> >> + }
> >> + }
> >> +
> >> + /**
> >> + * <p>
> >> + * Returns an unmodifiable list of {@code Diff}s. The list may be
> >> empty if
> >> + * there were no differences between the objects.
> >> + * </p>
> >> + *
> >> + * @return an unmodifiable list of {@code Diff}s
> >> + */
> >> + public List<Diff<?>> getDiffs() {
> >> + return Collections.unmodifiableList(diffs);
> >> + }
> >> +
> >> + /**
> >> + * <p>
> >> + * Returns the number of differences between the two objects.
> >> + * </p>
> >> + *
> >> + * @return the number of differences
> >> + */
> >> + public int getNumberOfDiffs() {
> >> + return diffs.size();
> >> + }
> >> +
> >> + /**
> >> + * <p>
> >> + * Returns the style used by the {@link #toString()} method.
> >> + * </p>
> >> + *
> >> + * @return the style
> >> + */
> >> + public ToStringStyle getToStringStyle() {
> >> + return style;
> >> + }
> >> +
> >> + /**
> >> + * <p>
> >> + * Builds a {@code String} description of the differences contained
> >> within
> >> + * this {@code DiffList}. A {@link ToStringBuilder} is used for
> each
> >> object
> >> + * and the style of the output is governed by the {@code
> >> ToStringStyle}
> >> + * passed to the constructor.
> >> + * </p>
> >> + *
> >> + * <p>
> >> + * If there are no differences stored in this list, the method will
> >> return
> >> + * {@link #OBJECTS_SAME_STRING}. Otherwise, using the example
> given in
> >> + * {@link Diffable} and {@link ToStringStyle#SHORT_PREFIX_STYLE},
> an
> >> output
> >> + * might be:
> >> + * </p>
> >> + *
> >> + * <pre>
> >> + * Person[name=John Doe,age=32] differs from Person[name=Joe
> >> Bloggs,age=26]
> >> + * </pre>
> >> + *
> >> + * <p>
> >> + * This indicates that the objects differ in name and age, but not
> in
> >> + * smoking status.
> >> + * </p>
> >> + *
> >> + * <p>
> >> + * To use a different {@code ToStringStyle} for an instance of this
> >> class,
> >> + * use {@link #toString(ToStringStyle)}.
> >> + * </p>
> >> + *
> >> + * @return a {@code String} description of the differences.
> >> + */
> >> + @Override
> >> + public String toString() {
> >> + return toString(style);
> >> + }
> >> +
> >> + /**
> >> + * <p>
> >> + * Builds a {@code String} description of the differences contained
> >> within
> >> + * this {@code DiffList}, using the supplied {@code ToStringStyle}.
> >> + * </p>
> >> + *
> >> + * @param style
> >> + * the {@code ToStringStyle} to use when outputting the
> >> objects
> >> + *
> >> + * @return a {@code String} description of the differences.
> >> + */
> >> + public String toString(ToStringStyle style) {
> >> + if (diffs.size() == 0) {
> >> + return OBJECTS_SAME_STRING;
> >> + }
> >> +
> >> + ToStringBuilder lhsBuilder = new ToStringBuilder(lhs, style);
> >> + ToStringBuilder rhsBuilder = new ToStringBuilder(rhs, style);
> >> +
> >> + for (Diff<?> diff : diffs) {
> >> + lhsBuilder.append(diff.getFieldName(), diff.getLeft());
> >> + rhsBuilder.append(diff.getFieldName(), diff.getRight());
> >> + }
> >> +
> >> + return String.format("%s %s %s", lhsBuilder.build(),
> >> DIFFERS_STRING,
> >> + rhsBuilder.build());
> >> + }
> >> +
> >> + /**
> >> + * <p>
> >> + * Returns an iterator over the {@code Diff} objects contained in
> >> this list.
> >> + * </p>
> >> + *
> >> + * @return the iterator
> >> + */
> >> + @Override
> >> + public Iterator<Diff<?>> iterator() {
> >> + return diffs.iterator();
> >> + }
> >> +}
> >>
> >> Propchange:
> >>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffList.java
> >>
> >>
> ------------------------------------------------------------------------------
> >> svn:eol-style = native
> >>
> >> Propchange:
> >>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffList.java
> >>
> >>
> ------------------------------------------------------------------------------
> >> svn:keywords = Id Revision
> >>
> >> Propchange:
> >>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffList.java
> >>
> >>
> ------------------------------------------------------------------------------
> >> svn:mime-type = text/plain
> >>
> >> Added:
> >>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diffable.java
> >> URL:
> >>
> http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diffable.java?rev=1561215&view=auto
> >>
> >>
> ==============================================================================
> >> ---
> >>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diffable.java
> >> (added)
> >> +++
> >>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diffable.java
> >> Fri Jan 24 22:37:50 2014
> >> @@ -0,0 +1,54 @@
> >> +/**
> >> + * Licensed to the Apache Software Foundation (ASF) under one or more
> >> + * contributor license agreements. See the NOTICE file distributed
> with
> >> + * this work for additional information regarding copyright ownership.
> >> + * The ASF licenses this file to You under the Apache License, Version
> 2.0
> >> + * (the "License"); you may not use this file except in compliance with
> >> + * the License. You may obtain a copy of the License at
> >> + *
> >> + * http://www.apache.org/licenses/LICENSE-2.0
> >> + *
> >> + * Unless required by applicable law or agreed to in writing, software
> >> + * distributed under the License is distributed on an "AS IS" BASIS,
> >> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> >> implied.
> >> + * See the License for the specific language governing permissions and
> >> + * limitations under the License.
> >> + */
> >> +package org.apache.commons.lang3.builder;
> >> +
> >> +/**
> >> + * <p>{@code Diffable} classes can be compared with other objects
> >> + * for differences. The {@link DiffList} object retrieved can be
> queried
> >> + * for a list of differences or printed using the {@link
> >> DiffList#toString()}.</p>
> >> + *
> >> + * <p>The calculation of the differences is <i>consistent with
> equals</i>
> >> if
> >> + * and only if {@code d1.equals(d2)} implies {@code d1.diff(d2) == ""}.
> >> + * It is strongly recommended that implementations are consistent with
> >> equals
> >> + * to avoid confusion. Note that {@code null} is not an instance of any
> >> class
> >> + * and {@code d1.diff(null)} should throw a {@code
> >> NullPointerException}.</p>
> >> + *
> >> + * <p>
> >> + * {@code Diffable} classes lend themselves well to unit testing, in
> >> which a
> >> + * easily readable description of the differences between an
> anticipated
> >> result and
> >> + * an actual result can be retrieved. For example:
> >> + * </p>
> >> + * <pre>
> >> + * Assert.assertEquals(expected.diff(result), expected, result);
> >> + * </pre>
> >> + *
> >> + * @param <T> the type of objects that this object may be
> differentiated
> >> against
> >> + * @since 3.3
> >> + * @version $Id$
> >> + */
> >> +public interface Diffable<T> {
> >> +
> >> + /**
> >> + * <p>Retrieves a list of the differences between
> >> + * this object and the supplied object.</p>
> >> + *
> >> + * @param obj the object to diff against, can be {@code null}
> >> + * @return a list of differences
> >> + * @throws NullPointerException if the specified object is {@code
> >> null}
> >> + */
> >> + DiffList diff(T obj);
> >> +}
> >>
> >> Propchange:
> >>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diffable.java
> >>
> >>
> ------------------------------------------------------------------------------
> >> svn:eol-style = native
> >>
> >> Propchange:
> >>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diffable.java
> >>
> >>
> ------------------------------------------------------------------------------
> >> svn:keywords = Id Revision
> >>
> >> Propchange:
> >>
> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diffable.java
> >>
> >>
> ------------------------------------------------------------------------------
> >> svn:mime-type = text/plain
> >>
> >> Added:
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java
> >> URL:
> >>
> http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java?rev=1561215&view=auto
> >>
> >>
> ==============================================================================
> >> ---
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java
> >> (added)
> >> +++
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java
> >> Fri Jan 24 22:37:50 2014
> >> @@ -0,0 +1,415 @@
> >> +/**
> >> + * Licensed to the Apache Software Foundation (ASF) under one or more
> >> + * contributor license agreements. See the NOTICE file distributed
> with
> >> + * this work for additional information regarding copyright ownership.
> >> + * The ASF licenses this file to You under the Apache License, Version
> 2.0
> >> + * (the "License"); you may not use this file except in compliance with
> >> + * the License. You may obtain a copy of the License at
> >> + *
> >> + * http://www.apache.org/licenses/LICENSE-2.0
> >> + *
> >> + * Unless required by applicable law or agreed to in writing, software
> >> + * distributed under the License is distributed on an "AS IS" BASIS,
> >> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> >> implied.
> >> + * See the License for the specific language governing permissions and
> >> + * limitations under the License.
> >> + */
> >> +package org.apache.commons.lang3.builder;
> >> +
> >> +import static org.junit.Assert.assertArrayEquals;
> >> +import static org.junit.Assert.assertEquals;
> >> +
> >> +import org.apache.commons.lang3.ArrayUtils;
> >> +import org.junit.Test;
> >> +
> >> +
> >> +/**
> >> + * Unit tests {@link DiffBuilder}.
> >> + *
> >> + * @version $Id$
> >> + */
> >> +public class DiffBuilderTest {
> >> +
> >> + private static final ToStringStyle SHORT_STYLE =
> >> ToStringStyle.SHORT_PREFIX_STYLE;
> >> +
> >> + private static class TypeTestClass implements
> Diffable<TypeTestClass>
> >> {
> >> + private ToStringStyle style = SHORT_STYLE;
> >> + private boolean booleanField = true;
> >> + private boolean[] booleanArrayField = {true};
> >> + private byte byteField = (byte) 0xFF;
> >> + private byte[] byteArrayField = {(byte) 0xFF};
> >> + private char charField = 'a';
> >> + private char[] charArrayField = {'a'};
> >> + private double doubleField = 1.0;
> >> + private double[] doubleArrayField = {1.0};
> >> + private float floatField = 1.0f;
> >> + private float[] floatArrayField = {1.0f};
> >> + private int intField = 1;
> >> + private int[] intArrayField = {1};
> >> + private long longField = 1L;
> >> + private long[] longArrayField = {1L};
> >> + private short shortField = 1;
> >> + private short[] shortArrayField = {1};
> >> + private Object objectField = null;
> >> + private Object[] objectArrayField = {null};
> >> +
> >> + @Override
> >> + public DiffList diff(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();
> >> + }
> >> +
> >> + @Override
> >> + public int hashCode() {
> >> + return HashCodeBuilder.reflectionHashCode(this, false);
> >> + }
> >> +
> >> + @Override
> >> + public boolean equals(Object obj) {
> >> + return EqualsBuilder.reflectionEquals(this, obj, false);
> >> + }
> >> + }
> >> +
> >> +
> >> + @Test
> >> + public void testBoolean() {
> >> + TypeTestClass class1 = new TypeTestClass();
> >> + TypeTestClass class2 = new TypeTestClass();
> >> + class2.booleanField = false;
> >> + DiffList list = class1.diff(class2);
> >> + assertEquals(1, list.getNumberOfDiffs());
> >> + Diff<?> diff = list.getDiffs().get(0);
> >> + assertEquals(Boolean.class, diff.getType());
> >> + assertEquals(Boolean.TRUE, diff.getLeft());
> >> + assertEquals(Boolean.FALSE, diff.getRight());
> >> + }
> >> +
> >> + @Test
> >> + public void testBooleanArray() throws Exception {
> >> + TypeTestClass class1 = new TypeTestClass();
> >> + TypeTestClass class2 = new TypeTestClass();
> >> + class2.booleanArrayField = new boolean[] {false, false};
> >> + DiffList list = class1.diff(class2);
> >> + assertEquals(1, list.getNumberOfDiffs());
> >> + Diff<?> diff = list.getDiffs().get(0);
> >> +
> assertArrayEquals(ArrayUtils.toObject(class1.booleanArrayField),
> >> + (Object[]) diff.getLeft());
> >> +
> assertArrayEquals(ArrayUtils.toObject(class2.booleanArrayField),
> >> + (Object[]) diff.getRight());
> >> + }
> >> +
> >> +
> >> + @Test
> >> + public void testByte() {
> >> + TypeTestClass class1 = new TypeTestClass();
> >> + TypeTestClass class2 = new TypeTestClass();
> >> + class2.byteField = 0x01;
> >> + DiffList list = class1.diff(class2);
> >> + assertEquals(1, list.getNumberOfDiffs());
> >> + Diff<?> diff = list.getDiffs().get(0);
> >> + assertEquals(Byte.valueOf(class1.byteField), diff.getLeft());
> >> + assertEquals(Byte.valueOf(class2.byteField), diff.getRight());
> >> + }
> >> +
> >> + @Test
> >> + public void testByteArray() throws Exception {
> >> + TypeTestClass class1 = new TypeTestClass();
> >> + TypeTestClass class2 = new TypeTestClass();
> >> + class2.byteArrayField= new byte[] {0x01, 0x02};
> >> + DiffList list = class1.diff(class2);
> >> + assertEquals(1, list.getNumberOfDiffs());
> >> + Diff<?> diff = list.getDiffs().get(0);
> >> + assertArrayEquals(ArrayUtils.toObject(class1.byteArrayField),
> >> + (Object[]) diff.getLeft());
> >> + assertArrayEquals(ArrayUtils.toObject(class2.byteArrayField),
> >> + (Object[]) diff.getRight());
> >> + }
> >> +
> >> + @Test
> >> + public void testChar() {
> >> + TypeTestClass class1 = new TypeTestClass();
> >> + TypeTestClass class2 = new TypeTestClass();
> >> + class2.charField = 'z';
> >> + DiffList list = class1.diff(class2);
> >> + assertEquals(1, list.getNumberOfDiffs());
> >> + Diff<?> diff = list.getDiffs().get(0);
> >> + assertEquals(Character.valueOf(class1.charField),
> diff.getLeft());
> >> + assertEquals(Character.valueOf(class2.charField),
> >> diff.getRight());
> >> + }
> >> +
> >> +
> >> + @Test
> >> + public void testCharArray() throws Exception {
> >> + TypeTestClass class1 = new TypeTestClass();
> >> + TypeTestClass class2 = new TypeTestClass();
> >> + class2.charArrayField = new char[] {'f', 'o', 'o'};
> >> + DiffList list = class1.diff(class2);
> >> + assertEquals(1, list.getNumberOfDiffs());
> >> + Diff<?> diff = list.getDiffs().get(0);
> >> + assertArrayEquals(ArrayUtils.toObject(class1.charArrayField),
> >> + (Object[]) diff.getLeft());
> >> + assertArrayEquals(ArrayUtils.toObject(class2.charArrayField),
> >> + (Object[]) diff.getRight());
> >> + }
> >> +
> >> +
> >> + @Test
> >> + public void testDouble() {
> >> + TypeTestClass class1 = new TypeTestClass();
> >> + TypeTestClass class2 = new TypeTestClass();
> >> + class2.doubleField = 99.99;
> >> + DiffList list = class1.diff(class2);
> >> + assertEquals(1, list.getNumberOfDiffs());
> >> + Diff<?> diff = list.getDiffs().get(0);
> >> + assertEquals(Double.valueOf(class1.doubleField),
> diff.getLeft());
> >> + assertEquals(Double.valueOf(class2.doubleField),
> diff.getRight());
> >> + }
> >> +
> >> +
> >> + @Test
> >> + public void testDoubleArray() throws Exception {
> >> + TypeTestClass class1 = new TypeTestClass();
> >> + TypeTestClass class2 = new TypeTestClass();
> >> + class2.doubleArrayField = new double[] {3.0, 2.9, 2.8};
> >> + DiffList list = class1.diff(class2);
> >> + assertEquals(1, list.getNumberOfDiffs());
> >> + Diff<?> diff = list.getDiffs().get(0);
> >> + assertArrayEquals(ArrayUtils.toObject(class1.doubleArrayField),
> >> + (Object[]) diff.getLeft());
> >> + assertArrayEquals(ArrayUtils.toObject(class2.doubleArrayField),
> >> + (Object[]) diff.getRight());
> >> + }
> >> +
> >> + @Test
> >> + public void testFloat() {
> >> + TypeTestClass class1 = new TypeTestClass();
> >> + TypeTestClass class2 = new TypeTestClass();
> >> + class2.floatField = 99.99F;
> >> + DiffList list = class1.diff(class2);
> >> + assertEquals(1, list.getNumberOfDiffs());
> >> + Diff<?> diff = list.getDiffs().get(0);
> >> + assertEquals(Float.valueOf(class1.floatField), diff.getLeft());
> >> + assertEquals(Float.valueOf(class2.floatField),
> diff.getRight());
> >> + }
> >> +
> >> +
> >> + @Test
> >> + public void testFloatArray() throws Exception {
> >> + TypeTestClass class1 = new TypeTestClass();
> >> + TypeTestClass class2 = new TypeTestClass();
> >> + class2.floatArrayField = new float[] {3.0F, 2.9F, 2.8F};
> >> + DiffList list = class1.diff(class2);
> >> + assertEquals(1, list.getNumberOfDiffs());
> >> + Diff<?> diff = list.getDiffs().get(0);
> >> + assertArrayEquals(ArrayUtils.toObject(class1.floatArrayField),
> >> + (Object[]) diff.getLeft());
> >> + assertArrayEquals(ArrayUtils.toObject(class2.floatArrayField),
> >> + (Object[]) diff.getRight());
> >> + }
> >> +
> >> +
> >> + @Test
> >> + public void testInt() {
> >> + TypeTestClass class1 = new TypeTestClass();
> >> + TypeTestClass class2 = new TypeTestClass();
> >> + class2.intField = 42;
> >> + DiffList list = class1.diff(class2);
> >> + assertEquals(1, list.getNumberOfDiffs());
> >> + Diff<?> diff = list.getDiffs().get(0);
> >> + assertEquals(Integer.valueOf(class1.intField), diff.getLeft());
> >> + assertEquals(Integer.valueOf(class2.intField),
> diff.getRight());
> >> + }
> >> +
> >> +
> >> + @Test
> >> + public void testIntArray() throws Exception {
> >> + TypeTestClass class1 = new TypeTestClass();
> >> + TypeTestClass class2 = new TypeTestClass();
> >> + class2.intArrayField = new int[] {3, 2, 1};
> >> + DiffList list = class1.diff(class2);
> >> + assertEquals(1, list.getNumberOfDiffs());
> >> + Diff<?> diff = list.getDiffs().get(0);
> >> + assertArrayEquals(ArrayUtils.toObject(class1.intArrayField),
> >> + (Object[]) diff.getLeft());
> >> + assertArrayEquals(ArrayUtils.toObject(class2.intArrayField),
> >> + (Object[]) diff.getRight());
> >> + }
> >> +
> >> + @Test
> >> + public void testLong() {
> >> + TypeTestClass class1 = new TypeTestClass();
> >> + TypeTestClass class2 = new TypeTestClass();
> >> + class2.longField = 42L;
> >> + DiffList list = class1.diff(class2);
> >> + assertEquals(1, list.getNumberOfDiffs());
> >> + Diff<?> diff = list.getDiffs().get(0);
> >> + assertEquals(Long.valueOf(class1.longField), diff.getLeft());
> >> + assertEquals(Long.valueOf(class2.longField), diff.getRight());
> >> + }
> >> +
> >> +
> >> + @Test
> >> + public void testLongArray() throws Exception {
> >> + TypeTestClass class1 = new TypeTestClass();
> >> + TypeTestClass class2 = new TypeTestClass();
> >> + class2.longArrayField = new long[] {3L, 2L, 1L};
> >> + DiffList list = class1.diff(class2);
> >> + assertEquals(1, list.getNumberOfDiffs());
> >> + Diff<?> diff = list.getDiffs().get(0);
> >> + assertArrayEquals(ArrayUtils.toObject(class1.longArrayField),
> >> + (Object[]) diff.getLeft());
> >> + assertArrayEquals(ArrayUtils.toObject(class2.longArrayField),
> >> + (Object[]) diff.getRight());
> >> + }
> >> +
> >> + @Test
> >> + public void testShort() {
> >> + TypeTestClass class1 = new TypeTestClass();
> >> + TypeTestClass class2 = new TypeTestClass();
> >> + class2.shortField = 42;
> >> + DiffList list = class1.diff(class2);
> >> + assertEquals(1, list.getNumberOfDiffs());
> >> + Diff<?> diff = list.getDiffs().get(0);
> >> + assertEquals(Short.valueOf(class1.shortField), diff.getLeft());
> >> + assertEquals(Short.valueOf(class2.shortField),
> diff.getRight());
> >> + }
> >> +
> >> +
> >> + @Test
> >> + public void testShortArray() throws Exception {
> >> + TypeTestClass class1 = new TypeTestClass();
> >> + TypeTestClass class2 = new TypeTestClass();
> >> + class2.shortArrayField = new short[] {3, 2, 1};
> >> + DiffList list = class1.diff(class2);
> >> + assertEquals(1, list.getNumberOfDiffs());
> >> + Diff<?> diff = list.getDiffs().get(0);
> >> + assertArrayEquals(ArrayUtils.toObject(class1.shortArrayField),
> >> + (Object[]) diff.getLeft());
> >> + assertArrayEquals(ArrayUtils.toObject(class2.shortArrayField),
> >> + (Object[]) diff.getRight());
> >> + }
> >> +
> >> + @Test
> >> + public void testObject() throws Exception {
> >> + TypeTestClass class1 = new TypeTestClass();
> >> + TypeTestClass class2 = new TypeTestClass();
> >> + class2.objectField = "Some string";
> >> + DiffList list = class1.diff(class2);
> >> + assertEquals(1, list.getNumberOfDiffs());
> >> + Diff<?> diff = list.getDiffs().get(0);
> >> + assertEquals(class1.objectField, diff.getLeft());
> >> + assertEquals(class2.objectField, diff.getRight());
> >> + }
> >> +
> >> + @Test
> >> + public void testObjectsEqual() throws Exception {
> >> + TypeTestClass class1 = new TypeTestClass();
> >> + TypeTestClass class2 = new TypeTestClass();
> >> + class1.objectField = "Some string";
> >> + class2.objectField = "Some string";
> >> + DiffList list = class1.diff(class2);
> >> + assertEquals(0, list.getNumberOfDiffs());
> >> + }
> >> +
> >> +
> >> + @Test
> >> + public void testObjectArray() throws Exception {
> >> + TypeTestClass class1 = new TypeTestClass();
> >> + TypeTestClass class2 = new TypeTestClass();
> >> + class2.objectArrayField = new Object[] {"string", 1, 2};
> >> + DiffList list = class1.diff(class2);
> >> + assertEquals(1, list.getNumberOfDiffs());
> >> + Diff<?> diff = list.getDiffs().get(0);
> >> + assertArrayEquals(class1.objectArrayField, (Object[])
> >> diff.getLeft());
> >> + assertArrayEquals(class2.objectArrayField, (Object[])
> >> diff.getRight());
> >> + }
> >> +
> >> + @Test
> >> + public void testObjectArrayEqual() throws Exception {
> >> + TypeTestClass class1 = new TypeTestClass();
> >> + TypeTestClass class2 = new TypeTestClass();
> >> + class1.objectArrayField = new Object[] {"string", 1, 2};
> >> + class2.objectArrayField = new Object[] {"string", 1, 2};
> >> + DiffList list = class1.diff(class2);
> >> + assertEquals(0, list.getNumberOfDiffs());
> >> + }
> >> +
> >> +
> >> + @Test
> >> + public void testByteArrayEqualAsObject() throws Exception {
> >> + DiffList list = new DiffBuilder("String1", "String2",
> SHORT_STYLE)
> >> + .append("foo", (Object) new boolean[] {false}, (Object) new
> >> boolean[] {false})
> >> + .append("foo", (Object) new byte[] {0x01}, (Object) new
> >> byte[] {0x01})
> >> + .append("foo", (Object) new char[] {'a'}, (Object) new
> char[]
> >> {'a'})
> >> + .append("foo", (Object) new double[] {1.0}, (Object) new
> >> double[] {1.0})
> >> + .append("foo", (Object) new float[] {1.0F}, (Object) new
> >> float[] {1.0F})
> >> + .append("foo", (Object) new int[] {1}, (Object) new int[]
> {1})
> >> + .append("foo", (Object) new long[] {1L}, (Object) new
> long[]
> >> {1L})
> >> + .append("foo", (Object) new short[] {1}, (Object) new
> short[]
> >> {1})
> >> + .append("foo", (Object) new Object[] {1, "two"}, (Object)
> new
> >> Object[] {1, "two"})
> >> + .build();
> >> +
> >> + assertEquals(0, list.getNumberOfDiffs());
> >> + }
> >> +
> >> +
> >> + @Test(expected=IllegalArgumentException.class)
> >> + public void testNullLhs() {
> >> + new DiffBuilder(null, this, ToStringStyle.DEFAULT_STYLE);
> >> + }
> >> +
> >> +
> >> + @Test(expected=IllegalArgumentException.class)
> >> + public void testNullRhs() {
> >> + new DiffBuilder(this, null, ToStringStyle.DEFAULT_STYLE);
> >> + }
> >> +
> >> + @Test
> >> + public void testSameObjectIgnoresAppends() {
> >> + TypeTestClass testClass = new TypeTestClass();
> >> + DiffList list = new DiffBuilder(testClass, testClass,
> SHORT_STYLE)
> >> + .append("ignored", false, true)
> >> + .build();
> >> + assertEquals(0, list.getNumberOfDiffs());
> >> + }
> >> +
> >> + @Test
> >> + public void testSimilarObjectIgnoresAppends() {
> >> + TypeTestClass testClass1 = new TypeTestClass();
> >> + TypeTestClass testClass2 = new TypeTestClass();
> >> + DiffList list = new DiffBuilder(testClass1, testClass2,
> >> SHORT_STYLE)
> >> + .append("ignored", false, true)
> >> + .build();
> >> + assertEquals(0, list.getNumberOfDiffs());
> >> + }
> >> +
> >> +
> >> + @Test
> >> + public void testStylePassedToDiffList() {
> >> + TypeTestClass class1 = new TypeTestClass();
> >> + DiffList list = class1.diff(class1);
> >> + assertEquals(SHORT_STYLE, list.getToStringStyle());
> >> +
> >> + class1.style = ToStringStyle.MULTI_LINE_STYLE;
> >> + list = class1.diff(class1);
> >> + assertEquals(ToStringStyle.MULTI_LINE_STYLE,
> >> list.getToStringStyle());
> >> + }
> >> +}
> >>
> >> Propchange:
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java
> >>
> >>
> ------------------------------------------------------------------------------
> >> svn:eol-style = native
> >>
> >> Propchange:
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java
> >>
> >>
> ------------------------------------------------------------------------------
> >> svn:keywords = Id Revision
> >>
> >> Propchange:
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java
> >>
> >>
> ------------------------------------------------------------------------------
> >> svn:mime-type = text/plain
> >>
> >> Added:
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffListTest.java
> >> URL:
> >>
> http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffListTest.java?rev=1561215&view=auto
> >>
> >>
> ==============================================================================
> >> ---
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffListTest.java
> >> (added)
> >> +++
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffListTest.java
> >> Fri Jan 24 22:37:50 2014
> >> @@ -0,0 +1,149 @@
> >> +/**
> >> + * Licensed to the Apache Software Foundation (ASF) under one or more
> >> + * contributor license agreements. See the NOTICE file distributed
> with
> >> + * this work for additional information regarding copyright ownership.
> >> + * The ASF licenses this file to You under the Apache License, Version
> 2.0
> >> + * (the "License"); you may not use this file except in compliance with
> >> + * the License. You may obtain a copy of the License at
> >> + *
> >> + * http://www.apache.org/licenses/LICENSE-2.0
> >> + *
> >> + * Unless required by applicable law or agreed to in writing, software
> >> + * distributed under the License is distributed on an "AS IS" BASIS,
> >> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> >> implied.
> >> + * See the License for the specific language governing permissions and
> >> + * limitations under the License.
> >> + */
> >> +package org.apache.commons.lang3.builder;
> >> +
> >> +import static org.junit.Assert.assertEquals;
> >> +import static org.junit.Assert.assertTrue;
> >> +
> >> +import java.util.Iterator;
> >> +import java.util.List;
> >> +
> >> +import org.junit.Test;
> >> +
> >> +/**
> >> + * Unit tests {@link DiffList}.
> >> + *
> >> + * @version $Id$
> >> + */
> >> +public class DiffListTest {
> >> +
> >> + private static final SimpleClass SIMPLE_FALSE = new
> >> SimpleClass(false);
> >> + private static final SimpleClass SIMPLE_TRUE = new
> SimpleClass(true);
> >> + private static final ToStringStyle SHORT_STYLE =
> >> ToStringStyle.SHORT_PREFIX_STYLE;
> >> +
> >> + private static class SimpleClass implements Diffable<SimpleClass> {
> >> + private boolean booleanField;
> >> +
> >> + public SimpleClass(boolean booleanField) {
> >> + this.booleanField = booleanField;
> >> + }
> >> +
> >> + public static String getFieldName() {
> >> + return "booleanField";
> >> + }
> >> +
> >> + @Override
> >> + public DiffList diff(SimpleClass obj) {
> >> + return new DiffBuilder(this, obj,
> >> ToStringStyle.SHORT_PREFIX_STYLE)
> >> + .append(getFieldName(), booleanField,
> >> obj.booleanField)
> >> + .build();
> >> + }
> >> + }
> >> +
> >> + private static class EmptyClass {
> >> + }
> >> +
> >> + @Test(expected = UnsupportedOperationException.class)
> >> + public void testListIsNonModifiable() {
> >> + SimpleClass lhs = new SimpleClass(true);
> >> + SimpleClass rhs = new SimpleClass(false);
> >> +
> >> + List<Diff<?>> diffs = lhs.diff(rhs).getDiffs();
> >> +
> >> + DiffList list = new DiffList(lhs, rhs, diffs, SHORT_STYLE);
> >> + assertEquals(diffs, list.getDiffs());
> >> + assertEquals(1, list.getNumberOfDiffs());
> >> + list.getDiffs().remove(0);
> >> + }
> >> +
> >> + @Test
> >> + public void testIterator() {
> >> + SimpleClass lhs = new SimpleClass(true);
> >> + SimpleClass rhs = new SimpleClass(false);
> >> +
> >> + List<Diff<?>> diffs = lhs.diff(rhs).getDiffs();
> >> + Iterator<Diff<?>> expectedIterator = diffs.iterator();
> >> +
> >> + DiffList list = new DiffList(lhs, rhs, diffs, SHORT_STYLE);
> >> + Iterator<Diff<?>> iterator = list.iterator();
> >> +
> >> + while (iterator.hasNext()) {
> >> + assertTrue(expectedIterator.hasNext());
> >> + assertEquals(expectedIterator.next(), iterator.next());
> >> + }
> >> + }
> >> +
> >> + @Test
> >> + public void testToStringOutput() {
> >> + DiffList list = new DiffBuilder(new EmptyClass(), new
> >> EmptyClass(),
> >> + ToStringStyle.SHORT_PREFIX_STYLE).append("test", false,
> >> true)
> >> + .build();
> >> + assertEquals(
> >> + "DiffListTest.EmptyClass[test=false] differs from
> >> DiffListTest.EmptyClass[test=true]",
> >> + list.toString());
> >> + }
> >> +
> >> + @Test
> >> + public void testToStringSpecifyStyleOutput() {
> >> + DiffList list = SIMPLE_FALSE.diff(SIMPLE_TRUE);
> >> + assertTrue(list.getToStringStyle().equals(SHORT_STYLE));
> >> +
> >> + String lhsString = new ToStringBuilder(SIMPLE_FALSE,
> >> + ToStringStyle.MULTI_LINE_STYLE).append(
> >> + SimpleClass.getFieldName(),
> >> SIMPLE_FALSE.booleanField).build();
> >> +
> >> + String rhsString = new ToStringBuilder(SIMPLE_TRUE,
> >> + ToStringStyle.MULTI_LINE_STYLE).append(
> >> + SimpleClass.getFieldName(),
> >> SIMPLE_TRUE.booleanField).build();
> >> +
> >> + String expectedOutput = String.format("%s differs from %s",
> >> lhsString,
> >> + rhsString);
> >> + assertEquals(expectedOutput,
> >> + list.toString(ToStringStyle.MULTI_LINE_STYLE));
> >> + }
> >> +
> >> + @Test(expected = IllegalArgumentException.class)
> >> + public void testNullLhs() {
> >> + new DiffList(null, SIMPLE_FALSE, SIMPLE_TRUE.diff(SIMPLE_FALSE)
> >> + .getDiffs(), SHORT_STYLE);
> >> + }
> >> +
> >> + @Test(expected = IllegalArgumentException.class)
> >> + public void testNullRhs() {
> >> + new DiffList(SIMPLE_TRUE, null, SIMPLE_TRUE.diff(SIMPLE_FALSE)
> >> + .getDiffs(), SHORT_STYLE);
> >> + }
> >> +
> >> + @Test(expected = IllegalArgumentException.class)
> >> + public void testNullList() {
> >> + new DiffList(SIMPLE_TRUE, SIMPLE_FALSE, null, SHORT_STYLE);
> >> + }
> >> +
> >> + @Test
> >> + public void testNullStyle() {
> >> + DiffList diffList = new DiffList(SIMPLE_TRUE, SIMPLE_FALSE,
> >> SIMPLE_TRUE
> >> + .diff(SIMPLE_FALSE).getDiffs(), null);
> >> + assertEquals(ToStringStyle.DEFAULT_STYLE,
> >> diffList.getToStringStyle());
> >> + }
> >> +
> >> + @Test
> >> + public void testNoDifferencesString() {
> >> + DiffList diffList = new DiffBuilder(SIMPLE_TRUE, SIMPLE_TRUE,
> >> + SHORT_STYLE).build();
> >> + assertEquals(DiffList.OBJECTS_SAME_STRING,
> diffList.toString());
> >> + }
> >> +}
> >>
> >> Propchange:
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffListTest.java
> >>
> >>
> ------------------------------------------------------------------------------
> >> svn:eol-style = native
> >>
> >> Propchange:
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffListTest.java
> >>
> >>
> ------------------------------------------------------------------------------
> >> svn:keywords = Id Revision
> >>
> >> Propchange:
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffListTest.java
> >>
> >>
> ------------------------------------------------------------------------------
> >> svn:mime-type = text/plain
> >>
> >> Added:
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffTest.java
> >> URL:
> >>
> http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffTest.java?rev=1561215&view=auto
> >>
> >>
> ==============================================================================
> >> ---
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffTest.java
> >> (added)
> >> +++
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffTest.java
> >> Fri Jan 24 22:37:50 2014
> >> @@ -0,0 +1,72 @@
> >> +/**
> >> + * Licensed to the Apache Software Foundation (ASF) under one or more
> >> + * contributor license agreements. See the NOTICE file distributed
> with
> >> + * this work for additional information regarding copyright ownership.
> >> + * The ASF licenses this file to You under the Apache License, Version
> 2.0
> >> + * (the "License"); you may not use this file except in compliance with
> >> + * the License. You may obtain a copy of the License at
> >> + *
> >> + * http://www.apache.org/licenses/LICENSE-2.0
> >> + *
> >> + * Unless required by applicable law or agreed to in writing, software
> >> + * distributed under the License is distributed on an "AS IS" BASIS,
> >> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> >> implied.
> >> + * See the License for the specific language governing permissions and
> >> + * limitations under the License.
> >> + */
> >> +package org.apache.commons.lang3.builder;
> >> +
> >> +import static org.junit.Assert.assertEquals;
> >> +
> >> +import org.junit.Test;
> >> +
> >> +
> >> +/**
> >> + * Unit tests {@link Diff}.
> >> + *
> >> + * @version $Id$
> >> + */
> >> +public class DiffTest {
> >> +
> >> + private static final String FIELD_NAME = "field";
> >> + private static final Diff<Boolean> booleanDiff = new
> >> BooleanDiff(FIELD_NAME);
> >> +
> >> + private static class BooleanDiff extends Diff<Boolean> {
> >> + private static final long serialVersionUID = 1L;
> >> +
> >> + protected BooleanDiff(String fieldName) {
> >> + super(fieldName);
> >> + }
> >> +
> >> + @Override
> >> + public Boolean getLeft() {
> >> + return Boolean.TRUE;
> >> + }
> >> +
> >> + @Override
> >> + public Boolean getRight() {
> >> + return Boolean.FALSE;
> >> + }
> >> + }
> >> +
> >> + @Test(expected = UnsupportedOperationException.class)
> >> + public void testCannotModify() {
> >> + booleanDiff.setValue(Boolean.FALSE);
> >> + }
> >> +
> >> + @Test
> >> + public void testGetFieldName() {
> >> + assertEquals(FIELD_NAME, booleanDiff.getFieldName());
> >> + }
> >> +
> >> + @Test
> >> + public void testGetType() {
> >> + assertEquals(Boolean.class, booleanDiff.getType());
> >> + }
> >> +
> >> + @Test
> >> + public void testToString() {
> >> + assertEquals(String.format("[%s: %s, %s]", FIELD_NAME,
> >> booleanDiff.getLeft(),
> >> + booleanDiff.getRight()), booleanDiff.toString());
> >> + }
> >> +}
> >>
> >> Propchange:
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffTest.java
> >>
> >>
> ------------------------------------------------------------------------------
> >> svn:eol-style = native
> >>
> >> Propchange:
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffTest.java
> >>
> >>
> ------------------------------------------------------------------------------
> >> svn:keywords = Id Revision
> >>
> >> Propchange:
> >>
> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffTest.java
> >>
> >>
> ------------------------------------------------------------------------------
> >> svn:mime-type = text/plain
> >>
> >>
> >>
>
Re: svn commit: r1561215 - in /commons/proper/lang/trunk/src:
changes/ main/java/org/apache/commons/lang3/builder/ test/java/org/apache/commons/lang3/builder/
Posted by Duncan Jones <du...@wortharead.com>.
Hi Matt,
On 24 January 2014 22:51, Matt Benson <gu...@gmail.com> wrote:
> Hi, Duncan, and congrats on your first commit! However, based on the
> comments of those of us who were participating in JIRA, I had expected that
> DiffList would be renamed to DiffResult, to avoid any confusion based on
> its being *named* "*List" without actually *implementing* the
> java.util.List interface.
>
> br,
> Matt
Ah, the email I was dreading after my first commit! You are quite
correct, of course, I'll amend that now.
Duncan
>
>
> On Fri, Jan 24, 2014 at 4:37 PM, <dj...@apache.org> wrote:
>
>> Author: djones
>> Date: Fri Jan 24 22:37:50 2014
>> New Revision: 1561215
>>
>> URL: http://svn.apache.org/r1561215
>> Log:
>> LANG-637: There should be a DifferenceBuilder with a
>> ReflectionDifferenceBuilder implementation
>>
>> Added:
>>
>> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diff.java
>> (with props)
>>
>> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffBuilder.java
>> (with props)
>>
>> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffList.java
>> (with props)
>>
>> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diffable.java
>> (with props)
>>
>> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java
>> (with props)
>>
>> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffListTest.java
>> (with props)
>>
>> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffTest.java
>> (with props)
>> Modified:
>> commons/proper/lang/trunk/src/changes/changes.xml
>>
>> Modified: commons/proper/lang/trunk/src/changes/changes.xml
>> URL:
>> http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/changes/changes.xml?rev=1561215&r1=1561214&r2=1561215&view=diff
>>
>> ==============================================================================
>> --- commons/proper/lang/trunk/src/changes/changes.xml [utf-8] (original)
>> +++ commons/proper/lang/trunk/src/changes/changes.xml [utf-8] Fri Jan 24
>> 22:37:50 2014
>> @@ -22,6 +22,7 @@
>> <body>
>>
>> <release version="3.3" date="TBA" description="Bugfix and Feature
>> release">
>> + <action issue="LANG-637" type="add" dev="djones">There should be a
>> DifferenceBuilder with a ReflectionDifferenceBuilder implementation</action>
>> <action issue="LANG-954" type="fix" due-to="Michael Keppler"
>> dev="sebb">uncaught PatternSyntaxException in FastDateFormat on
>> Android</action>
>> <action issue="LANG-956" type="update" dev="britter">Improve JavaDoc
>> of WordUtils.wrap methods</action>
>> <action issue="LANG-944" type="add" dev="britter" due-to="Rekha
>> Joshi">Add the Jaro-Winkler string distance algorithm to
>> StringUtils</action>
>>
>> Added:
>> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diff.java
>> URL:
>> http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diff.java?rev=1561215&view=auto
>>
>> ==============================================================================
>> ---
>> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diff.java
>> (added)
>> +++
>> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diff.java
>> Fri Jan 24 22:37:50 2014
>> @@ -0,0 +1,119 @@
>> +/**
>> + * Licensed to the Apache Software Foundation (ASF) under one or more
>> + * contributor license agreements. See the NOTICE file distributed with
>> + * this work for additional information regarding copyright ownership.
>> + * The ASF licenses this file to You under the Apache License, Version 2.0
>> + * (the "License"); you may not use this file except in compliance with
>> + * the License. You may obtain a copy of the License at
>> + *
>> + * http://www.apache.org/licenses/LICENSE-2.0
>> + *
>> + * Unless required by applicable law or agreed to in writing, software
>> + * distributed under the License is distributed on an "AS IS" BASIS,
>> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
>> implied.
>> + * See the License for the specific language governing permissions and
>> + * limitations under the License.
>> + */
>> +package org.apache.commons.lang3.builder;
>> +
>> +import java.lang.reflect.Type;
>> +
>> +import org.apache.commons.lang3.ObjectUtils;
>> +import org.apache.commons.lang3.reflect.TypeUtils;
>> +import org.apache.commons.lang3.tuple.Pair;
>> +
>> +/**
>> + * <p>
>> + * A {@code Diff} contains the differences between two {@link Diffable}
>> class
>> + * fields.
>> + * </p>
>> + *
>> + * <p>
>> + * Typically, {@code Diff}s are retrieved by using a {@link DiffBuilder}
>> to
>> + * produce a {@link DiffList}, containing the differences between two
>> objects.
>> + * </p>
>> + *
>> + *
>> + * @param <T>
>> + * The type of object contained within this {@code Diff}.
>> Differences
>> + * between primitive objects are stored as their Object wrapper
>> + * equivalent.
>> + * @since 3.3
>> + * @version $Id$
>> + */
>> +public abstract class Diff<T> extends Pair<T, T> {
>> +
>> + private static final long serialVersionUID = 1L;
>> +
>> + private final Type type;
>> + private final String fieldName;
>> +
>> + /**
>> + * <p>
>> + * Constructs a new {@code Diff} for the given field name.
>> + * </p>
>> + *
>> + * @param fieldName
>> + * the name of the field
>> + */
>> + protected Diff(String fieldName) {
>> + this.type = ObjectUtils.defaultIfNull(
>> + TypeUtils.getTypeArguments(getClass(), Diff.class).get(
>> + Diff.class.getTypeParameters()[0]), Object.class);
>> + this.fieldName = fieldName;
>> + }
>> +
>> + /**
>> + * <p>
>> + * Returns the type of the field.
>> + * </p>
>> + *
>> + * @return the field type
>> + */
>> + public final Type getType() {
>> + return type;
>> + }
>> +
>> + /**
>> + * <p>
>> + * Returns the name of the field.
>> + * </p>
>> + *
>> + * @return the field name
>> + */
>> + public final String getFieldName() {
>> + return fieldName;
>> + }
>> +
>> + /**
>> + * <p>
>> + * Returns a {@code String} representation of the {@code Diff}, with
>> the
>> + * following format:
>> + *
>> + * <pre>
>> + * [fieldname: left-value, right-value]
>> + * </pre>
>> + *
>> + * </p>
>> + *
>> + * @return the string representation
>> + */
>> + @Override
>> + public final String toString() {
>> + return String.format("[%s: %s, %s]", fieldName, getLeft(),
>> getRight());
>> + }
>> +
>> + /**
>> + * <p>
>> + * Throws {@code UnsupportedOperationException}.
>> + * </p>
>> + *
>> + * @param value
>> + * ignored
>> + * @return nothing
>> + */
>> + @Override
>> + public final T setValue(T value) {
>> + throw new UnsupportedOperationException("Cannot alter Diff
>> object.");
>> + }
>> +}
>>
>> Propchange:
>> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diff.java
>>
>> ------------------------------------------------------------------------------
>> svn:eol-style = native
>>
>> Propchange:
>> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diff.java
>>
>> ------------------------------------------------------------------------------
>> svn:keywords = Id Revision
>>
>> Propchange:
>> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diff.java
>>
>> ------------------------------------------------------------------------------
>> svn:mime-type = text/plain
>>
>> Added:
>> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffBuilder.java
>> URL:
>> http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffBuilder.java?rev=1561215&view=auto
>>
>> ==============================================================================
>> ---
>> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffBuilder.java
>> (added)
>> +++
>> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffBuilder.java
>> Fri Jan 24 22:37:50 2014
>> @@ -0,0 +1,914 @@
>> +/**
>> + * Licensed to the Apache Software Foundation (ASF) under one or more
>> + * contributor license agreements. See the NOTICE file distributed with
>> + * this work for additional information regarding copyright ownership.
>> + * The ASF licenses this file to You under the Apache License, Version 2.0
>> + * (the "License"); you may not use this file except in compliance with
>> + * the License. You may obtain a copy of the License at
>> + *
>> + * http://www.apache.org/licenses/LICENSE-2.0
>> + *
>> + * Unless required by applicable law or agreed to in writing, software
>> + * distributed under the License is distributed on an "AS IS" BASIS,
>> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
>> implied.
>> + * See the License for the specific language governing permissions and
>> + * limitations under the License.
>> + */
>> +package org.apache.commons.lang3.builder;
>> +
>> +import java.util.ArrayList;
>> +import java.util.Arrays;
>> +import java.util.List;
>> +
>> +import org.apache.commons.lang3.ArrayUtils;
>> +
>> +/**
>> + * <p>
>> + * Assists in implementing {@link Diffable#diff(Object)} methods.
>> + * </p>
>> + *
>> + * <p>
>> + * To use this class, write code as follows:
>> + * </p>
>> + *
>> + * <pre>
>> + * public class Person implements Diffable<Person> {
>> + * String name;
>> + * int age;
>> + * boolean smoker;
>> + *
>> + * ...
>> + *
>> + * public DiffList diff(Person obj) {
>> + * // No need for null check, as NullPointerException correct if obj
>> is null
>> + * return new DiffBuilder(this, obj, ToStringStyle.SHORT_PREFIX_STYLE)
>> + * .append("name", this.name, obj.name)
>> + * .append("age", this.age, obj.age)
>> + * .append("smoker", this.smoker, obj.smoker)
>> + * .build();
>> + * }
>> + * }
>> + * </pre>
>> + *
>> + * <p>
>> + * The {@code ToStringStyle} passed to the constructor is embedded in the
>> + * returned {@code DiffList} and influences the style of the
>> + * {@code DiffList.toString()} method. This style choice can be
>> overridden by
>> + * calling {@link DiffList#toString(ToStringStyle)}.
>> + * </p>
>> + *
>> + * @since 3.3
>> + * @version $Id$
>> + * @see Diffable
>> + * @see Diff
>> + * @see DiffList
>> + * @see ToStringStyle
>> + */
>> +public class DiffBuilder implements Builder<DiffList> {
>> +
>> + private final List<Diff<?>> diffs;
>> + private final boolean objectsTriviallyEqual;
>> + private final Object lhs;
>> + private final Object rhs;
>> + private final ToStringStyle style;
>> +
>> + /**
>> + * <p>
>> + * Constructs a builder for the specified objects with the specified
>> style.
>> + * </p>
>> + *
>> + * <p>
>> + * If {@code lhs == rhs} or {@code lhs.equals(rhs)} then the builder
>> will
>> + * not evaluate any calls to {@code append(...)} and will return an
>> empty
>> + * {@link DiffList} when {@link #build()} is executed.
>> + * </p>
>> + *
>> + * @param lhs
>> + * {@code this} object
>> + * @param rhs
>> + * the object to diff against
>> + * @param style
>> + * the style will use when outputting the objects, {@code
>> null}
>> + * uses the default
>> + * @throws IllegalArgumentException
>> + * if {@code lhs} or {@code rhs} is {@code null}
>> + */
>> + public DiffBuilder(final Object lhs, final Object rhs,
>> + final ToStringStyle style) {
>> + if (lhs == null) {
>> + throw new IllegalArgumentException("lhs cannot be null");
>> + }
>> + if (rhs == null) {
>> + throw new IllegalArgumentException("rhs cannot be null");
>> + }
>> +
>> + this.diffs = new ArrayList<Diff<?>>();
>> + this.lhs = lhs;
>> + this.rhs = rhs;
>> + this.style = style;
>> +
>> + // Don't compare any fields if objects equal
>> + this.objectsTriviallyEqual = (lhs == rhs || lhs.equals(rhs));
>> + }
>> +
>> + /**
>> + * <p>
>> + * Test if two {@code boolean}s are equal.
>> + * </p>
>> + *
>> + * @param fieldName
>> + * the field name
>> + * @param lhs
>> + * the left hand {@code boolean}
>> + * @param rhs
>> + * the right hand {@code boolean}
>> + * @return this
>> + * @throws IllegalArgumentException
>> + * if field name is {@code null}
>> + */
>> + public DiffBuilder append(final String fieldName, final boolean lhs,
>> + final boolean rhs) {
>> + if (fieldName == null) {
>> + throw new IllegalArgumentException("Field name cannot be
>> null");
>> + }
>> +
>> + if (objectsTriviallyEqual) {
>> + 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;
>> + }
>> +
>> + /**
>> + * <p>
>> + * Test if two {@code boolean[]}s are equal.
>> + * </p>
>> + *
>> + * @param fieldName
>> + * the field name
>> + * @param lhs
>> + * the left hand {@code boolean[]}
>> + * @param rhs
>> + * the right hand {@code boolean[]}
>> + * @return this
>> + * @throws IllegalArgumentException
>> + * if field name is {@code null}
>> + */
>> + public DiffBuilder append(final String fieldName, final boolean[] lhs,
>> + final boolean[] rhs) {
>> + if (fieldName == null) {
>> + throw new IllegalArgumentException("Field name cannot be
>> null");
>> + }
>> + if (objectsTriviallyEqual) {
>> + 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;
>> + }
>> +
>> + /**
>> + * <p>
>> + * Test if two {@code byte}s are equal.
>> + * </p>
>> + *
>> + * @param fieldName
>> + * the field name
>> + * @param lhs
>> + * the left hand {@code byte}
>> + * @param rhs
>> + * the right hand {@code byte}
>> + * @return this
>> + * @throws IllegalArgumentException
>> + * if field name is {@code null}
>> + */
>> + public DiffBuilder append(final String fieldName, final byte lhs,
>> + final byte rhs) {
>> + if (fieldName == null) {
>> + throw new IllegalArgumentException("Field name cannot be
>> null");
>> + }
>> + if (objectsTriviallyEqual) {
>> + 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;
>> + }
>> +
>> + /**
>> + * <p>
>> + * Test if two {@code byte[]}s are equal.
>> + * </p>
>> + *
>> + * @param fieldName
>> + * the field name
>> + * @param lhs
>> + * the left hand {@code byte[]}
>> + * @param rhs
>> + * the right hand {@code byte[]}
>> + * @return this
>> + * @throws IllegalArgumentException
>> + * if field name is {@code null}
>> + */
>> + public DiffBuilder append(final String fieldName, final byte[] lhs,
>> + final byte[] rhs) {
>> + if (fieldName == null) {
>> + throw new IllegalArgumentException("Field name cannot be
>> null");
>> + }
>> +
>> + if (objectsTriviallyEqual) {
>> + 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;
>> + }
>> +
>> + /**
>> + * <p>
>> + * Test if two {@code char}s are equal.
>> + * </p>
>> + *
>> + * @param fieldName
>> + * the field name
>> + * @param lhs
>> + * the left hand {@code char}
>> + * @param rhs
>> + * the right hand {@code char}
>> + * @return this
>> + * @throws IllegalArgumentException
>> + * if field name is {@code null}
>> + */
>> + public DiffBuilder append(final String fieldName, final char lhs,
>> + final char rhs) {
>> + if (fieldName == null) {
>> + throw new IllegalArgumentException("Field name cannot be
>> null");
>> + }
>> +
>> + if (objectsTriviallyEqual) {
>> + 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;
>> + }
>> +
>> + /**
>> + * <p>
>> + * Test if two {@code char[]}s are equal.
>> + * </p>
>> + *
>> + * @param fieldName
>> + * the field name
>> + * @param lhs
>> + * the left hand {@code char[]}
>> + * @param rhs
>> + * the right hand {@code char[]}
>> + * @return this
>> + * @throws IllegalArgumentException
>> + * if field name is {@code null}
>> + */
>> + public DiffBuilder append(final String fieldName, final char[] lhs,
>> + final char[] rhs) {
>> + if (fieldName == null) {
>> + throw new IllegalArgumentException("Field name cannot be
>> null");
>> + }
>> +
>> + if (objectsTriviallyEqual) {
>> + 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;
>> + }
>> +
>> + /**
>> + * <p>
>> + * Test if two {@code double}s are equal.
>> + * </p>
>> + *
>> + * @param fieldName
>> + * the field name
>> + * @param lhs
>> + * the left hand {@code double}
>> + * @param rhs
>> + * the right hand {@code double}
>> + * @return this
>> + * @throws IllegalArgumentException
>> + * if field name is {@code null}
>> + */
>> + public DiffBuilder append(final String fieldName, final double lhs,
>> + final double rhs) {
>> + if (fieldName == null) {
>> + throw new IllegalArgumentException("Field name cannot be
>> null");
>> + }
>> +
>> + if (objectsTriviallyEqual) {
>> + 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;
>> + }
>> +
>> + /**
>> + * <p>
>> + * Test if two {@code double[]}s are equal.
>> + * </p>
>> + *
>> + * @param fieldName
>> + * the field name
>> + * @param lhs
>> + * the left hand {@code double[]}
>> + * @param rhs
>> + * the right hand {@code double[]}
>> + * @return this
>> + * @throws IllegalArgumentException
>> + * if field name is {@code null}
>> + */
>> + public DiffBuilder append(final String fieldName, final double[] lhs,
>> + final double[] rhs) {
>> + if (fieldName == null) {
>> + throw new IllegalArgumentException("Field name cannot be
>> null");
>> + }
>> +
>> + if (objectsTriviallyEqual) {
>> + 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;
>> + }
>> +
>> + /**
>> + * <p>
>> + * Test if two {@code float}s are equal.
>> + * </p>
>> + *
>> + * @param fieldName
>> + * the field name
>> + * @param lhs
>> + * the left hand {@code float}
>> + * @param rhs
>> + * the right hand {@code float}
>> + * @return this
>> + * @throws IllegalArgumentException
>> + * if field name is {@code null}
>> + */
>> + public DiffBuilder append(final String fieldName, final float lhs,
>> + final float rhs) {
>> + if (fieldName == null) {
>> + throw new IllegalArgumentException("Field name cannot be
>> null");
>> + }
>> +
>> + if (objectsTriviallyEqual) {
>> + 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;
>> + }
>> +
>> + /**
>> + * <p>
>> + * Test if two {@code float[]}s are equal.
>> + * </p>
>> + *
>> + * @param fieldName
>> + * the field name
>> + * @param lhs
>> + * the left hand {@code float[]}
>> + * @param rhs
>> + * the right hand {@code float[]}
>> + * @return this
>> + * @throws IllegalArgumentException
>> + * if field name is {@code null}
>> + */
>> + public DiffBuilder append(final String fieldName, final float[] lhs,
>> + final float[] rhs) {
>> + if (fieldName == null) {
>> + throw new IllegalArgumentException("Field name cannot be
>> null");
>> + }
>> +
>> + if (objectsTriviallyEqual) {
>> + 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;
>> + }
>> +
>> + /**
>> + * <p>
>> + * Test if two {@code int}s are equal.
>> + * </p>
>> + *
>> + * @param fieldName
>> + * the field name
>> + * @param lhs
>> + * the left hand {@code int}
>> + * @param rhs
>> + * the right hand {@code int}
>> + * @return this
>> + * @throws IllegalArgumentException
>> + * if field name is {@code null}
>> + */
>> + public DiffBuilder append(final String fieldName, final int lhs,
>> + final int rhs) {
>> + if (fieldName == null) {
>> + throw new IllegalArgumentException("Field name cannot be
>> null");
>> + }
>> +
>> + if (objectsTriviallyEqual) {
>> + 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;
>> + }
>> +
>> + /**
>> + * <p>
>> + * Test if two {@code int[]}s are equal.
>> + * </p>
>> + *
>> + * @param fieldName
>> + * the field name
>> + * @param lhs
>> + * the left hand {@code int[]}
>> + * @param rhs
>> + * the right hand {@code int[]}
>> + * @return this
>> + * @throws IllegalArgumentException
>> + * if field name is {@code null}
>> + */
>> + public DiffBuilder append(final String fieldName, final int[] lhs,
>> + final int[] rhs) {
>> + if (fieldName == null) {
>> + throw new IllegalArgumentException("Field name cannot be
>> null");
>> + }
>> +
>> + if (objectsTriviallyEqual) {
>> + 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;
>> + }
>> +
>> + /**
>> + * <p>
>> + * Test if two {@code long}s are equal.
>> + * </p>
>> + *
>> + * @param fieldName
>> + * the field name
>> + * @param lhs
>> + * the left hand {@code long}
>> + * @param rhs
>> + * the right hand {@code long}
>> + * @return this
>> + * @throws IllegalArgumentException
>> + * if field name is {@code null}
>> + */
>> + public DiffBuilder append(final String fieldName, final long lhs,
>> + final long rhs) {
>> + if (fieldName == null) {
>> + throw new IllegalArgumentException("Field name cannot be
>> null");
>> + }
>> +
>> + if (objectsTriviallyEqual) {
>> + 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;
>> + }
>> +
>> + /**
>> + * <p>
>> + * Test if two {@code long[]}s are equal.
>> + * </p>
>> + *
>> + * @param fieldName
>> + * the field name
>> + * @param lhs
>> + * the left hand {@code long[]}
>> + * @param rhs
>> + * the right hand {@code long[]}
>> + * @return this
>> + * @throws IllegalArgumentException
>> + * if field name is {@code null}
>> + */
>> + public DiffBuilder append(final String fieldName, final long[] lhs,
>> + final long[] rhs) {
>> + if (fieldName == null) {
>> + throw new IllegalArgumentException("Field name cannot be
>> null");
>> + }
>> +
>> + if (objectsTriviallyEqual) {
>> + 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;
>> + }
>> +
>> + /**
>> + * <p>
>> + * Test if two {@code short}s are equal.
>> + * </p>
>> + *
>> + * @param fieldName
>> + * the field name
>> + * @param lhs
>> + * the left hand {@code short}
>> + * @param rhs
>> + * the right hand {@code short}
>> + * @return this
>> + * @throws IllegalArgumentException
>> + * if field name is {@code null}
>> + */
>> + public DiffBuilder append(final String fieldName, final short lhs,
>> + final short rhs) {
>> + if (fieldName == null) {
>> + throw new IllegalArgumentException("Field name cannot be
>> null");
>> + }
>> +
>> + if (objectsTriviallyEqual) {
>> + 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;
>> + }
>> +
>> + /**
>> + * <p>
>> + * Test if two {@code short[]}s are equal.
>> + * </p>
>> + *
>> + * @param fieldName
>> + * the field name
>> + * @param lhs
>> + * the left hand {@code short[]}
>> + * @param rhs
>> + * the right hand {@code short[]}
>> + * @return this
>> + * @throws IllegalArgumentException
>> + * if field name is {@code null}
>> + */
>> + public DiffBuilder append(final String fieldName, final short[] lhs,
>> + final short[] rhs) {
>> + if (fieldName == null) {
>> + throw new IllegalArgumentException("Field name cannot be
>> null");
>> + }
>> +
>> + if (objectsTriviallyEqual) {
>> + 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;
>> + }
>> +
>> + /**
>> + * <p>
>> + * Test if two {@code Objects}s are equal.
>> + * </p>
>> + *
>> + * @param fieldName
>> + * the field name
>> + * @param lhs
>> + * the left hand {@code Object}
>> + * @param rhs
>> + * the right hand {@code Object}
>> + * @return this
>> + */
>> + public DiffBuilder append(final String fieldName, final Object lhs,
>> + final Object rhs) {
>> +
>> + if (objectsTriviallyEqual) {
>> + return this;
>> + }
>> + if (lhs == rhs) {
>> + return this;
>> + }
>> +
>> + Object objectToTest;
>> + if (lhs != null) {
>> + objectToTest = lhs;
>> + } else {
>> + // rhs cannot be null, as lhs != rhs
>> + objectToTest = rhs;
>> + }
>> +
>> + if (objectToTest.getClass().isArray()) {
>> + if (objectToTest instanceof boolean[]) {
>> + return append(fieldName, (boolean[]) lhs, (boolean[])
>> rhs);
>> + }
>> + if (objectToTest instanceof byte[]) {
>> + return append(fieldName, (byte[]) lhs, (byte[]) rhs);
>> + }
>> + if (objectToTest instanceof char[]) {
>> + return append(fieldName, (char[]) lhs, (char[]) rhs);
>> + }
>> + if (objectToTest instanceof double[]) {
>> + return append(fieldName, (double[]) lhs, (double[]) rhs);
>> + }
>> + if (objectToTest instanceof float[]) {
>> + return append(fieldName, (float[]) lhs, (float[]) rhs);
>> + }
>> + if (objectToTest instanceof int[]) {
>> + return append(fieldName, (int[]) lhs, (int[]) rhs);
>> + }
>> + if (objectToTest instanceof long[]) {
>> + return append(fieldName, (long[]) lhs, (long[]) rhs);
>> + }
>> + if (objectToTest instanceof short[]) {
>> + return append(fieldName, (short[]) lhs, (short[]) rhs);
>> + }
>> +
>> + return append(fieldName, (Object[]) lhs, (Object[]) rhs);
>> + }
>> +
>> + // Not array type
>> + 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;
>> + }
>> +
>> + /**
>> + * <p>
>> + * Test if two {@code Object[]}s are equal.
>> + * </p>
>> + *
>> + * @param fieldName
>> + * the field name
>> + * @param lhs
>> + * the left hand {@code Object[]}
>> + * @param rhs
>> + * the right hand {@code Object[]}
>> + * @return this
>> + */
>> + public DiffBuilder append(final String fieldName, final Object[] lhs,
>> + final Object[] rhs) {
>> + if (objectsTriviallyEqual) {
>> + 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;
>> + }
>> +
>> + /**
>> + * <p>
>> + * Builds a {@link DiffList} based on the differences appended to this
>> + * builder.
>> + * </p>
>> + *
>> + * @return a {@code DiffList} containing the differences between the
>> two
>> + * objects.
>> + */
>> + @Override
>> + public DiffList build() {
>> + return new DiffList(lhs, rhs, diffs, style);
>> + }
>> +
>> +}
>>
>> Propchange:
>> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffBuilder.java
>>
>> ------------------------------------------------------------------------------
>> svn:eol-style = native
>>
>> Propchange:
>> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffBuilder.java
>>
>> ------------------------------------------------------------------------------
>> svn:keywords = Id Revision
>>
>> Propchange:
>> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffBuilder.java
>>
>> ------------------------------------------------------------------------------
>> svn:mime-type = text/plain
>>
>> Added:
>> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffList.java
>> URL:
>> http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffList.java?rev=1561215&view=auto
>>
>> ==============================================================================
>> ---
>> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffList.java
>> (added)
>> +++
>> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffList.java
>> Fri Jan 24 22:37:50 2014
>> @@ -0,0 +1,208 @@
>> +/**
>> + * Licensed to the Apache Software Foundation (ASF) under one or more
>> + * contributor license agreements. See the NOTICE file distributed with
>> + * this work for additional information regarding copyright ownership.
>> + * The ASF licenses this file to You under the Apache License, Version 2.0
>> + * (the "License"); you may not use this file except in compliance with
>> + * the License. You may obtain a copy of the License at
>> + *
>> + * http://www.apache.org/licenses/LICENSE-2.0
>> + *
>> + * Unless required by applicable law or agreed to in writing, software
>> + * distributed under the License is distributed on an "AS IS" BASIS,
>> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
>> implied.
>> + * See the License for the specific language governing permissions and
>> + * limitations under the License.
>> + */
>> +package org.apache.commons.lang3.builder;
>> +
>> +import java.util.Collections;
>> +import java.util.Iterator;
>> +import java.util.List;
>> +
>> +/**
>> + * <p>
>> + * A {@code DiffList} contains a list of the differences between two
>> + * {@link Diffable} objects. Typically these differences are displayed
>> using
>> + * {@link #toString()} method, which returns a string describing the
>> fields that
>> + * differ between the objects.
>> + * </p>
>> + * <p>
>> + * Use a {@link DiffBuilder} to build a {@code DiffList} comparing two
>> objects.
>> + * </p>
>> + *
>> + * @since 3.3
>> + * @version $Id$
>> + */
>> +public class DiffList implements Iterable<Diff<?>> {
>> +
>> + /**
>> + * <p>
>> + * The {@code String} returned when the objects have no differences:
>> + * {@value}
>> + * </p>
>> + */
>> + public static final String OBJECTS_SAME_STRING = "";
>> +
>> + private static final String DIFFERS_STRING = "differs from";
>> +
>> + private final List<Diff<?>> diffs;
>> + private final Object lhs;
>> + private final Object rhs;
>> + private final ToStringStyle style;
>> +
>> + /**
>> + * <p>
>> + * Creates a {@link DiffList} containing the differences between two
>> + * objects.
>> + * </p>
>> + *
>> + * @param lhs
>> + * the left hand object
>> + * @param rhs
>> + * the right hand object
>> + * @param diffs
>> + * the list of differences, may be empty
>> + * @param style
>> + * the style to use for the {@link #toString()} method.
>> May be
>> + * {@code null}, in which case
>> + * {@link ToStringStyle#DEFAULT_STYLE} is used
>> + * @throws IllegalArgumentException
>> + * if {@code lhs}, {@code rhs} or {@code diffs} is {@code
>> null}
>> + */
>> + DiffList(final Object lhs, final Object rhs, final List<Diff<?>>
>> diffs,
>> + final ToStringStyle style) {
>> + if (lhs == null) {
>> + throw new IllegalArgumentException(
>> + "Left hand object cannot be null");
>> + }
>> + if (rhs == null) {
>> + throw new IllegalArgumentException(
>> + "Right hand object cannot be null");
>> + }
>> + if (diffs == null) {
>> + throw new IllegalArgumentException(
>> + "List of differences cannot be null");
>> + }
>> +
>> + this.diffs = diffs;
>> + this.lhs = lhs;
>> + this.rhs = rhs;
>> +
>> + if (style == null) {
>> + this.style = ToStringStyle.DEFAULT_STYLE;
>> + } else {
>> + this.style = style;
>> + }
>> + }
>> +
>> + /**
>> + * <p>
>> + * Returns an unmodifiable list of {@code Diff}s. The list may be
>> empty if
>> + * there were no differences between the objects.
>> + * </p>
>> + *
>> + * @return an unmodifiable list of {@code Diff}s
>> + */
>> + public List<Diff<?>> getDiffs() {
>> + return Collections.unmodifiableList(diffs);
>> + }
>> +
>> + /**
>> + * <p>
>> + * Returns the number of differences between the two objects.
>> + * </p>
>> + *
>> + * @return the number of differences
>> + */
>> + public int getNumberOfDiffs() {
>> + return diffs.size();
>> + }
>> +
>> + /**
>> + * <p>
>> + * Returns the style used by the {@link #toString()} method.
>> + * </p>
>> + *
>> + * @return the style
>> + */
>> + public ToStringStyle getToStringStyle() {
>> + return style;
>> + }
>> +
>> + /**
>> + * <p>
>> + * Builds a {@code String} description of the differences contained
>> within
>> + * this {@code DiffList}. A {@link ToStringBuilder} is used for each
>> object
>> + * and the style of the output is governed by the {@code
>> ToStringStyle}
>> + * passed to the constructor.
>> + * </p>
>> + *
>> + * <p>
>> + * If there are no differences stored in this list, the method will
>> return
>> + * {@link #OBJECTS_SAME_STRING}. Otherwise, using the example given in
>> + * {@link Diffable} and {@link ToStringStyle#SHORT_PREFIX_STYLE}, an
>> output
>> + * might be:
>> + * </p>
>> + *
>> + * <pre>
>> + * Person[name=John Doe,age=32] differs from Person[name=Joe
>> Bloggs,age=26]
>> + * </pre>
>> + *
>> + * <p>
>> + * This indicates that the objects differ in name and age, but not in
>> + * smoking status.
>> + * </p>
>> + *
>> + * <p>
>> + * To use a different {@code ToStringStyle} for an instance of this
>> class,
>> + * use {@link #toString(ToStringStyle)}.
>> + * </p>
>> + *
>> + * @return a {@code String} description of the differences.
>> + */
>> + @Override
>> + public String toString() {
>> + return toString(style);
>> + }
>> +
>> + /**
>> + * <p>
>> + * Builds a {@code String} description of the differences contained
>> within
>> + * this {@code DiffList}, using the supplied {@code ToStringStyle}.
>> + * </p>
>> + *
>> + * @param style
>> + * the {@code ToStringStyle} to use when outputting the
>> objects
>> + *
>> + * @return a {@code String} description of the differences.
>> + */
>> + public String toString(ToStringStyle style) {
>> + if (diffs.size() == 0) {
>> + return OBJECTS_SAME_STRING;
>> + }
>> +
>> + ToStringBuilder lhsBuilder = new ToStringBuilder(lhs, style);
>> + ToStringBuilder rhsBuilder = new ToStringBuilder(rhs, style);
>> +
>> + for (Diff<?> diff : diffs) {
>> + lhsBuilder.append(diff.getFieldName(), diff.getLeft());
>> + rhsBuilder.append(diff.getFieldName(), diff.getRight());
>> + }
>> +
>> + return String.format("%s %s %s", lhsBuilder.build(),
>> DIFFERS_STRING,
>> + rhsBuilder.build());
>> + }
>> +
>> + /**
>> + * <p>
>> + * Returns an iterator over the {@code Diff} objects contained in
>> this list.
>> + * </p>
>> + *
>> + * @return the iterator
>> + */
>> + @Override
>> + public Iterator<Diff<?>> iterator() {
>> + return diffs.iterator();
>> + }
>> +}
>>
>> Propchange:
>> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffList.java
>>
>> ------------------------------------------------------------------------------
>> svn:eol-style = native
>>
>> Propchange:
>> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffList.java
>>
>> ------------------------------------------------------------------------------
>> svn:keywords = Id Revision
>>
>> Propchange:
>> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/DiffList.java
>>
>> ------------------------------------------------------------------------------
>> svn:mime-type = text/plain
>>
>> Added:
>> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diffable.java
>> URL:
>> http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diffable.java?rev=1561215&view=auto
>>
>> ==============================================================================
>> ---
>> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diffable.java
>> (added)
>> +++
>> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diffable.java
>> Fri Jan 24 22:37:50 2014
>> @@ -0,0 +1,54 @@
>> +/**
>> + * Licensed to the Apache Software Foundation (ASF) under one or more
>> + * contributor license agreements. See the NOTICE file distributed with
>> + * this work for additional information regarding copyright ownership.
>> + * The ASF licenses this file to You under the Apache License, Version 2.0
>> + * (the "License"); you may not use this file except in compliance with
>> + * the License. You may obtain a copy of the License at
>> + *
>> + * http://www.apache.org/licenses/LICENSE-2.0
>> + *
>> + * Unless required by applicable law or agreed to in writing, software
>> + * distributed under the License is distributed on an "AS IS" BASIS,
>> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
>> implied.
>> + * See the License for the specific language governing permissions and
>> + * limitations under the License.
>> + */
>> +package org.apache.commons.lang3.builder;
>> +
>> +/**
>> + * <p>{@code Diffable} classes can be compared with other objects
>> + * for differences. The {@link DiffList} object retrieved can be queried
>> + * for a list of differences or printed using the {@link
>> DiffList#toString()}.</p>
>> + *
>> + * <p>The calculation of the differences is <i>consistent with equals</i>
>> if
>> + * and only if {@code d1.equals(d2)} implies {@code d1.diff(d2) == ""}.
>> + * It is strongly recommended that implementations are consistent with
>> equals
>> + * to avoid confusion. Note that {@code null} is not an instance of any
>> class
>> + * and {@code d1.diff(null)} should throw a {@code
>> NullPointerException}.</p>
>> + *
>> + * <p>
>> + * {@code Diffable} classes lend themselves well to unit testing, in
>> which a
>> + * easily readable description of the differences between an anticipated
>> result and
>> + * an actual result can be retrieved. For example:
>> + * </p>
>> + * <pre>
>> + * Assert.assertEquals(expected.diff(result), expected, result);
>> + * </pre>
>> + *
>> + * @param <T> the type of objects that this object may be differentiated
>> against
>> + * @since 3.3
>> + * @version $Id$
>> + */
>> +public interface Diffable<T> {
>> +
>> + /**
>> + * <p>Retrieves a list of the differences between
>> + * this object and the supplied object.</p>
>> + *
>> + * @param obj the object to diff against, can be {@code null}
>> + * @return a list of differences
>> + * @throws NullPointerException if the specified object is {@code
>> null}
>> + */
>> + DiffList diff(T obj);
>> +}
>>
>> Propchange:
>> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diffable.java
>>
>> ------------------------------------------------------------------------------
>> svn:eol-style = native
>>
>> Propchange:
>> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diffable.java
>>
>> ------------------------------------------------------------------------------
>> svn:keywords = Id Revision
>>
>> Propchange:
>> commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/builder/Diffable.java
>>
>> ------------------------------------------------------------------------------
>> svn:mime-type = text/plain
>>
>> Added:
>> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java
>> URL:
>> http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java?rev=1561215&view=auto
>>
>> ==============================================================================
>> ---
>> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java
>> (added)
>> +++
>> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java
>> Fri Jan 24 22:37:50 2014
>> @@ -0,0 +1,415 @@
>> +/**
>> + * Licensed to the Apache Software Foundation (ASF) under one or more
>> + * contributor license agreements. See the NOTICE file distributed with
>> + * this work for additional information regarding copyright ownership.
>> + * The ASF licenses this file to You under the Apache License, Version 2.0
>> + * (the "License"); you may not use this file except in compliance with
>> + * the License. You may obtain a copy of the License at
>> + *
>> + * http://www.apache.org/licenses/LICENSE-2.0
>> + *
>> + * Unless required by applicable law or agreed to in writing, software
>> + * distributed under the License is distributed on an "AS IS" BASIS,
>> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
>> implied.
>> + * See the License for the specific language governing permissions and
>> + * limitations under the License.
>> + */
>> +package org.apache.commons.lang3.builder;
>> +
>> +import static org.junit.Assert.assertArrayEquals;
>> +import static org.junit.Assert.assertEquals;
>> +
>> +import org.apache.commons.lang3.ArrayUtils;
>> +import org.junit.Test;
>> +
>> +
>> +/**
>> + * Unit tests {@link DiffBuilder}.
>> + *
>> + * @version $Id$
>> + */
>> +public class DiffBuilderTest {
>> +
>> + private static final ToStringStyle SHORT_STYLE =
>> ToStringStyle.SHORT_PREFIX_STYLE;
>> +
>> + private static class TypeTestClass implements Diffable<TypeTestClass>
>> {
>> + private ToStringStyle style = SHORT_STYLE;
>> + private boolean booleanField = true;
>> + private boolean[] booleanArrayField = {true};
>> + private byte byteField = (byte) 0xFF;
>> + private byte[] byteArrayField = {(byte) 0xFF};
>> + private char charField = 'a';
>> + private char[] charArrayField = {'a'};
>> + private double doubleField = 1.0;
>> + private double[] doubleArrayField = {1.0};
>> + private float floatField = 1.0f;
>> + private float[] floatArrayField = {1.0f};
>> + private int intField = 1;
>> + private int[] intArrayField = {1};
>> + private long longField = 1L;
>> + private long[] longArrayField = {1L};
>> + private short shortField = 1;
>> + private short[] shortArrayField = {1};
>> + private Object objectField = null;
>> + private Object[] objectArrayField = {null};
>> +
>> + @Override
>> + public DiffList diff(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();
>> + }
>> +
>> + @Override
>> + public int hashCode() {
>> + return HashCodeBuilder.reflectionHashCode(this, false);
>> + }
>> +
>> + @Override
>> + public boolean equals(Object obj) {
>> + return EqualsBuilder.reflectionEquals(this, obj, false);
>> + }
>> + }
>> +
>> +
>> + @Test
>> + public void testBoolean() {
>> + TypeTestClass class1 = new TypeTestClass();
>> + TypeTestClass class2 = new TypeTestClass();
>> + class2.booleanField = false;
>> + DiffList list = class1.diff(class2);
>> + assertEquals(1, list.getNumberOfDiffs());
>> + Diff<?> diff = list.getDiffs().get(0);
>> + assertEquals(Boolean.class, diff.getType());
>> + assertEquals(Boolean.TRUE, diff.getLeft());
>> + assertEquals(Boolean.FALSE, diff.getRight());
>> + }
>> +
>> + @Test
>> + public void testBooleanArray() throws Exception {
>> + TypeTestClass class1 = new TypeTestClass();
>> + TypeTestClass class2 = new TypeTestClass();
>> + class2.booleanArrayField = new boolean[] {false, false};
>> + DiffList list = class1.diff(class2);
>> + assertEquals(1, list.getNumberOfDiffs());
>> + Diff<?> diff = list.getDiffs().get(0);
>> + assertArrayEquals(ArrayUtils.toObject(class1.booleanArrayField),
>> + (Object[]) diff.getLeft());
>> + assertArrayEquals(ArrayUtils.toObject(class2.booleanArrayField),
>> + (Object[]) diff.getRight());
>> + }
>> +
>> +
>> + @Test
>> + public void testByte() {
>> + TypeTestClass class1 = new TypeTestClass();
>> + TypeTestClass class2 = new TypeTestClass();
>> + class2.byteField = 0x01;
>> + DiffList list = class1.diff(class2);
>> + assertEquals(1, list.getNumberOfDiffs());
>> + Diff<?> diff = list.getDiffs().get(0);
>> + assertEquals(Byte.valueOf(class1.byteField), diff.getLeft());
>> + assertEquals(Byte.valueOf(class2.byteField), diff.getRight());
>> + }
>> +
>> + @Test
>> + public void testByteArray() throws Exception {
>> + TypeTestClass class1 = new TypeTestClass();
>> + TypeTestClass class2 = new TypeTestClass();
>> + class2.byteArrayField= new byte[] {0x01, 0x02};
>> + DiffList list = class1.diff(class2);
>> + assertEquals(1, list.getNumberOfDiffs());
>> + Diff<?> diff = list.getDiffs().get(0);
>> + assertArrayEquals(ArrayUtils.toObject(class1.byteArrayField),
>> + (Object[]) diff.getLeft());
>> + assertArrayEquals(ArrayUtils.toObject(class2.byteArrayField),
>> + (Object[]) diff.getRight());
>> + }
>> +
>> + @Test
>> + public void testChar() {
>> + TypeTestClass class1 = new TypeTestClass();
>> + TypeTestClass class2 = new TypeTestClass();
>> + class2.charField = 'z';
>> + DiffList list = class1.diff(class2);
>> + assertEquals(1, list.getNumberOfDiffs());
>> + Diff<?> diff = list.getDiffs().get(0);
>> + assertEquals(Character.valueOf(class1.charField), diff.getLeft());
>> + assertEquals(Character.valueOf(class2.charField),
>> diff.getRight());
>> + }
>> +
>> +
>> + @Test
>> + public void testCharArray() throws Exception {
>> + TypeTestClass class1 = new TypeTestClass();
>> + TypeTestClass class2 = new TypeTestClass();
>> + class2.charArrayField = new char[] {'f', 'o', 'o'};
>> + DiffList list = class1.diff(class2);
>> + assertEquals(1, list.getNumberOfDiffs());
>> + Diff<?> diff = list.getDiffs().get(0);
>> + assertArrayEquals(ArrayUtils.toObject(class1.charArrayField),
>> + (Object[]) diff.getLeft());
>> + assertArrayEquals(ArrayUtils.toObject(class2.charArrayField),
>> + (Object[]) diff.getRight());
>> + }
>> +
>> +
>> + @Test
>> + public void testDouble() {
>> + TypeTestClass class1 = new TypeTestClass();
>> + TypeTestClass class2 = new TypeTestClass();
>> + class2.doubleField = 99.99;
>> + DiffList list = class1.diff(class2);
>> + assertEquals(1, list.getNumberOfDiffs());
>> + Diff<?> diff = list.getDiffs().get(0);
>> + assertEquals(Double.valueOf(class1.doubleField), diff.getLeft());
>> + assertEquals(Double.valueOf(class2.doubleField), diff.getRight());
>> + }
>> +
>> +
>> + @Test
>> + public void testDoubleArray() throws Exception {
>> + TypeTestClass class1 = new TypeTestClass();
>> + TypeTestClass class2 = new TypeTestClass();
>> + class2.doubleArrayField = new double[] {3.0, 2.9, 2.8};
>> + DiffList list = class1.diff(class2);
>> + assertEquals(1, list.getNumberOfDiffs());
>> + Diff<?> diff = list.getDiffs().get(0);
>> + assertArrayEquals(ArrayUtils.toObject(class1.doubleArrayField),
>> + (Object[]) diff.getLeft());
>> + assertArrayEquals(ArrayUtils.toObject(class2.doubleArrayField),
>> + (Object[]) diff.getRight());
>> + }
>> +
>> + @Test
>> + public void testFloat() {
>> + TypeTestClass class1 = new TypeTestClass();
>> + TypeTestClass class2 = new TypeTestClass();
>> + class2.floatField = 99.99F;
>> + DiffList list = class1.diff(class2);
>> + assertEquals(1, list.getNumberOfDiffs());
>> + Diff<?> diff = list.getDiffs().get(0);
>> + assertEquals(Float.valueOf(class1.floatField), diff.getLeft());
>> + assertEquals(Float.valueOf(class2.floatField), diff.getRight());
>> + }
>> +
>> +
>> + @Test
>> + public void testFloatArray() throws Exception {
>> + TypeTestClass class1 = new TypeTestClass();
>> + TypeTestClass class2 = new TypeTestClass();
>> + class2.floatArrayField = new float[] {3.0F, 2.9F, 2.8F};
>> + DiffList list = class1.diff(class2);
>> + assertEquals(1, list.getNumberOfDiffs());
>> + Diff<?> diff = list.getDiffs().get(0);
>> + assertArrayEquals(ArrayUtils.toObject(class1.floatArrayField),
>> + (Object[]) diff.getLeft());
>> + assertArrayEquals(ArrayUtils.toObject(class2.floatArrayField),
>> + (Object[]) diff.getRight());
>> + }
>> +
>> +
>> + @Test
>> + public void testInt() {
>> + TypeTestClass class1 = new TypeTestClass();
>> + TypeTestClass class2 = new TypeTestClass();
>> + class2.intField = 42;
>> + DiffList list = class1.diff(class2);
>> + assertEquals(1, list.getNumberOfDiffs());
>> + Diff<?> diff = list.getDiffs().get(0);
>> + assertEquals(Integer.valueOf(class1.intField), diff.getLeft());
>> + assertEquals(Integer.valueOf(class2.intField), diff.getRight());
>> + }
>> +
>> +
>> + @Test
>> + public void testIntArray() throws Exception {
>> + TypeTestClass class1 = new TypeTestClass();
>> + TypeTestClass class2 = new TypeTestClass();
>> + class2.intArrayField = new int[] {3, 2, 1};
>> + DiffList list = class1.diff(class2);
>> + assertEquals(1, list.getNumberOfDiffs());
>> + Diff<?> diff = list.getDiffs().get(0);
>> + assertArrayEquals(ArrayUtils.toObject(class1.intArrayField),
>> + (Object[]) diff.getLeft());
>> + assertArrayEquals(ArrayUtils.toObject(class2.intArrayField),
>> + (Object[]) diff.getRight());
>> + }
>> +
>> + @Test
>> + public void testLong() {
>> + TypeTestClass class1 = new TypeTestClass();
>> + TypeTestClass class2 = new TypeTestClass();
>> + class2.longField = 42L;
>> + DiffList list = class1.diff(class2);
>> + assertEquals(1, list.getNumberOfDiffs());
>> + Diff<?> diff = list.getDiffs().get(0);
>> + assertEquals(Long.valueOf(class1.longField), diff.getLeft());
>> + assertEquals(Long.valueOf(class2.longField), diff.getRight());
>> + }
>> +
>> +
>> + @Test
>> + public void testLongArray() throws Exception {
>> + TypeTestClass class1 = new TypeTestClass();
>> + TypeTestClass class2 = new TypeTestClass();
>> + class2.longArrayField = new long[] {3L, 2L, 1L};
>> + DiffList list = class1.diff(class2);
>> + assertEquals(1, list.getNumberOfDiffs());
>> + Diff<?> diff = list.getDiffs().get(0);
>> + assertArrayEquals(ArrayUtils.toObject(class1.longArrayField),
>> + (Object[]) diff.getLeft());
>> + assertArrayEquals(ArrayUtils.toObject(class2.longArrayField),
>> + (Object[]) diff.getRight());
>> + }
>> +
>> + @Test
>> + public void testShort() {
>> + TypeTestClass class1 = new TypeTestClass();
>> + TypeTestClass class2 = new TypeTestClass();
>> + class2.shortField = 42;
>> + DiffList list = class1.diff(class2);
>> + assertEquals(1, list.getNumberOfDiffs());
>> + Diff<?> diff = list.getDiffs().get(0);
>> + assertEquals(Short.valueOf(class1.shortField), diff.getLeft());
>> + assertEquals(Short.valueOf(class2.shortField), diff.getRight());
>> + }
>> +
>> +
>> + @Test
>> + public void testShortArray() throws Exception {
>> + TypeTestClass class1 = new TypeTestClass();
>> + TypeTestClass class2 = new TypeTestClass();
>> + class2.shortArrayField = new short[] {3, 2, 1};
>> + DiffList list = class1.diff(class2);
>> + assertEquals(1, list.getNumberOfDiffs());
>> + Diff<?> diff = list.getDiffs().get(0);
>> + assertArrayEquals(ArrayUtils.toObject(class1.shortArrayField),
>> + (Object[]) diff.getLeft());
>> + assertArrayEquals(ArrayUtils.toObject(class2.shortArrayField),
>> + (Object[]) diff.getRight());
>> + }
>> +
>> + @Test
>> + public void testObject() throws Exception {
>> + TypeTestClass class1 = new TypeTestClass();
>> + TypeTestClass class2 = new TypeTestClass();
>> + class2.objectField = "Some string";
>> + DiffList list = class1.diff(class2);
>> + assertEquals(1, list.getNumberOfDiffs());
>> + Diff<?> diff = list.getDiffs().get(0);
>> + assertEquals(class1.objectField, diff.getLeft());
>> + assertEquals(class2.objectField, diff.getRight());
>> + }
>> +
>> + @Test
>> + public void testObjectsEqual() throws Exception {
>> + TypeTestClass class1 = new TypeTestClass();
>> + TypeTestClass class2 = new TypeTestClass();
>> + class1.objectField = "Some string";
>> + class2.objectField = "Some string";
>> + DiffList list = class1.diff(class2);
>> + assertEquals(0, list.getNumberOfDiffs());
>> + }
>> +
>> +
>> + @Test
>> + public void testObjectArray() throws Exception {
>> + TypeTestClass class1 = new TypeTestClass();
>> + TypeTestClass class2 = new TypeTestClass();
>> + class2.objectArrayField = new Object[] {"string", 1, 2};
>> + DiffList list = class1.diff(class2);
>> + assertEquals(1, list.getNumberOfDiffs());
>> + Diff<?> diff = list.getDiffs().get(0);
>> + assertArrayEquals(class1.objectArrayField, (Object[])
>> diff.getLeft());
>> + assertArrayEquals(class2.objectArrayField, (Object[])
>> diff.getRight());
>> + }
>> +
>> + @Test
>> + public void testObjectArrayEqual() throws Exception {
>> + TypeTestClass class1 = new TypeTestClass();
>> + TypeTestClass class2 = new TypeTestClass();
>> + class1.objectArrayField = new Object[] {"string", 1, 2};
>> + class2.objectArrayField = new Object[] {"string", 1, 2};
>> + DiffList list = class1.diff(class2);
>> + assertEquals(0, list.getNumberOfDiffs());
>> + }
>> +
>> +
>> + @Test
>> + public void testByteArrayEqualAsObject() throws Exception {
>> + DiffList list = new DiffBuilder("String1", "String2", SHORT_STYLE)
>> + .append("foo", (Object) new boolean[] {false}, (Object) new
>> boolean[] {false})
>> + .append("foo", (Object) new byte[] {0x01}, (Object) new
>> byte[] {0x01})
>> + .append("foo", (Object) new char[] {'a'}, (Object) new char[]
>> {'a'})
>> + .append("foo", (Object) new double[] {1.0}, (Object) new
>> double[] {1.0})
>> + .append("foo", (Object) new float[] {1.0F}, (Object) new
>> float[] {1.0F})
>> + .append("foo", (Object) new int[] {1}, (Object) new int[] {1})
>> + .append("foo", (Object) new long[] {1L}, (Object) new long[]
>> {1L})
>> + .append("foo", (Object) new short[] {1}, (Object) new short[]
>> {1})
>> + .append("foo", (Object) new Object[] {1, "two"}, (Object) new
>> Object[] {1, "two"})
>> + .build();
>> +
>> + assertEquals(0, list.getNumberOfDiffs());
>> + }
>> +
>> +
>> + @Test(expected=IllegalArgumentException.class)
>> + public void testNullLhs() {
>> + new DiffBuilder(null, this, ToStringStyle.DEFAULT_STYLE);
>> + }
>> +
>> +
>> + @Test(expected=IllegalArgumentException.class)
>> + public void testNullRhs() {
>> + new DiffBuilder(this, null, ToStringStyle.DEFAULT_STYLE);
>> + }
>> +
>> + @Test
>> + public void testSameObjectIgnoresAppends() {
>> + TypeTestClass testClass = new TypeTestClass();
>> + DiffList list = new DiffBuilder(testClass, testClass, SHORT_STYLE)
>> + .append("ignored", false, true)
>> + .build();
>> + assertEquals(0, list.getNumberOfDiffs());
>> + }
>> +
>> + @Test
>> + public void testSimilarObjectIgnoresAppends() {
>> + TypeTestClass testClass1 = new TypeTestClass();
>> + TypeTestClass testClass2 = new TypeTestClass();
>> + DiffList list = new DiffBuilder(testClass1, testClass2,
>> SHORT_STYLE)
>> + .append("ignored", false, true)
>> + .build();
>> + assertEquals(0, list.getNumberOfDiffs());
>> + }
>> +
>> +
>> + @Test
>> + public void testStylePassedToDiffList() {
>> + TypeTestClass class1 = new TypeTestClass();
>> + DiffList list = class1.diff(class1);
>> + assertEquals(SHORT_STYLE, list.getToStringStyle());
>> +
>> + class1.style = ToStringStyle.MULTI_LINE_STYLE;
>> + list = class1.diff(class1);
>> + assertEquals(ToStringStyle.MULTI_LINE_STYLE,
>> list.getToStringStyle());
>> + }
>> +}
>>
>> Propchange:
>> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java
>>
>> ------------------------------------------------------------------------------
>> svn:eol-style = native
>>
>> Propchange:
>> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java
>>
>> ------------------------------------------------------------------------------
>> svn:keywords = Id Revision
>>
>> Propchange:
>> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java
>>
>> ------------------------------------------------------------------------------
>> svn:mime-type = text/plain
>>
>> Added:
>> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffListTest.java
>> URL:
>> http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffListTest.java?rev=1561215&view=auto
>>
>> ==============================================================================
>> ---
>> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffListTest.java
>> (added)
>> +++
>> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffListTest.java
>> Fri Jan 24 22:37:50 2014
>> @@ -0,0 +1,149 @@
>> +/**
>> + * Licensed to the Apache Software Foundation (ASF) under one or more
>> + * contributor license agreements. See the NOTICE file distributed with
>> + * this work for additional information regarding copyright ownership.
>> + * The ASF licenses this file to You under the Apache License, Version 2.0
>> + * (the "License"); you may not use this file except in compliance with
>> + * the License. You may obtain a copy of the License at
>> + *
>> + * http://www.apache.org/licenses/LICENSE-2.0
>> + *
>> + * Unless required by applicable law or agreed to in writing, software
>> + * distributed under the License is distributed on an "AS IS" BASIS,
>> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
>> implied.
>> + * See the License for the specific language governing permissions and
>> + * limitations under the License.
>> + */
>> +package org.apache.commons.lang3.builder;
>> +
>> +import static org.junit.Assert.assertEquals;
>> +import static org.junit.Assert.assertTrue;
>> +
>> +import java.util.Iterator;
>> +import java.util.List;
>> +
>> +import org.junit.Test;
>> +
>> +/**
>> + * Unit tests {@link DiffList}.
>> + *
>> + * @version $Id$
>> + */
>> +public class DiffListTest {
>> +
>> + private static final SimpleClass SIMPLE_FALSE = new
>> SimpleClass(false);
>> + private static final SimpleClass SIMPLE_TRUE = new SimpleClass(true);
>> + private static final ToStringStyle SHORT_STYLE =
>> ToStringStyle.SHORT_PREFIX_STYLE;
>> +
>> + private static class SimpleClass implements Diffable<SimpleClass> {
>> + private boolean booleanField;
>> +
>> + public SimpleClass(boolean booleanField) {
>> + this.booleanField = booleanField;
>> + }
>> +
>> + public static String getFieldName() {
>> + return "booleanField";
>> + }
>> +
>> + @Override
>> + public DiffList diff(SimpleClass obj) {
>> + return new DiffBuilder(this, obj,
>> ToStringStyle.SHORT_PREFIX_STYLE)
>> + .append(getFieldName(), booleanField,
>> obj.booleanField)
>> + .build();
>> + }
>> + }
>> +
>> + private static class EmptyClass {
>> + }
>> +
>> + @Test(expected = UnsupportedOperationException.class)
>> + public void testListIsNonModifiable() {
>> + SimpleClass lhs = new SimpleClass(true);
>> + SimpleClass rhs = new SimpleClass(false);
>> +
>> + List<Diff<?>> diffs = lhs.diff(rhs).getDiffs();
>> +
>> + DiffList list = new DiffList(lhs, rhs, diffs, SHORT_STYLE);
>> + assertEquals(diffs, list.getDiffs());
>> + assertEquals(1, list.getNumberOfDiffs());
>> + list.getDiffs().remove(0);
>> + }
>> +
>> + @Test
>> + public void testIterator() {
>> + SimpleClass lhs = new SimpleClass(true);
>> + SimpleClass rhs = new SimpleClass(false);
>> +
>> + List<Diff<?>> diffs = lhs.diff(rhs).getDiffs();
>> + Iterator<Diff<?>> expectedIterator = diffs.iterator();
>> +
>> + DiffList list = new DiffList(lhs, rhs, diffs, SHORT_STYLE);
>> + Iterator<Diff<?>> iterator = list.iterator();
>> +
>> + while (iterator.hasNext()) {
>> + assertTrue(expectedIterator.hasNext());
>> + assertEquals(expectedIterator.next(), iterator.next());
>> + }
>> + }
>> +
>> + @Test
>> + public void testToStringOutput() {
>> + DiffList list = new DiffBuilder(new EmptyClass(), new
>> EmptyClass(),
>> + ToStringStyle.SHORT_PREFIX_STYLE).append("test", false,
>> true)
>> + .build();
>> + assertEquals(
>> + "DiffListTest.EmptyClass[test=false] differs from
>> DiffListTest.EmptyClass[test=true]",
>> + list.toString());
>> + }
>> +
>> + @Test
>> + public void testToStringSpecifyStyleOutput() {
>> + DiffList list = SIMPLE_FALSE.diff(SIMPLE_TRUE);
>> + assertTrue(list.getToStringStyle().equals(SHORT_STYLE));
>> +
>> + String lhsString = new ToStringBuilder(SIMPLE_FALSE,
>> + ToStringStyle.MULTI_LINE_STYLE).append(
>> + SimpleClass.getFieldName(),
>> SIMPLE_FALSE.booleanField).build();
>> +
>> + String rhsString = new ToStringBuilder(SIMPLE_TRUE,
>> + ToStringStyle.MULTI_LINE_STYLE).append(
>> + SimpleClass.getFieldName(),
>> SIMPLE_TRUE.booleanField).build();
>> +
>> + String expectedOutput = String.format("%s differs from %s",
>> lhsString,
>> + rhsString);
>> + assertEquals(expectedOutput,
>> + list.toString(ToStringStyle.MULTI_LINE_STYLE));
>> + }
>> +
>> + @Test(expected = IllegalArgumentException.class)
>> + public void testNullLhs() {
>> + new DiffList(null, SIMPLE_FALSE, SIMPLE_TRUE.diff(SIMPLE_FALSE)
>> + .getDiffs(), SHORT_STYLE);
>> + }
>> +
>> + @Test(expected = IllegalArgumentException.class)
>> + public void testNullRhs() {
>> + new DiffList(SIMPLE_TRUE, null, SIMPLE_TRUE.diff(SIMPLE_FALSE)
>> + .getDiffs(), SHORT_STYLE);
>> + }
>> +
>> + @Test(expected = IllegalArgumentException.class)
>> + public void testNullList() {
>> + new DiffList(SIMPLE_TRUE, SIMPLE_FALSE, null, SHORT_STYLE);
>> + }
>> +
>> + @Test
>> + public void testNullStyle() {
>> + DiffList diffList = new DiffList(SIMPLE_TRUE, SIMPLE_FALSE,
>> SIMPLE_TRUE
>> + .diff(SIMPLE_FALSE).getDiffs(), null);
>> + assertEquals(ToStringStyle.DEFAULT_STYLE,
>> diffList.getToStringStyle());
>> + }
>> +
>> + @Test
>> + public void testNoDifferencesString() {
>> + DiffList diffList = new DiffBuilder(SIMPLE_TRUE, SIMPLE_TRUE,
>> + SHORT_STYLE).build();
>> + assertEquals(DiffList.OBJECTS_SAME_STRING, diffList.toString());
>> + }
>> +}
>>
>> Propchange:
>> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffListTest.java
>>
>> ------------------------------------------------------------------------------
>> svn:eol-style = native
>>
>> Propchange:
>> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffListTest.java
>>
>> ------------------------------------------------------------------------------
>> svn:keywords = Id Revision
>>
>> Propchange:
>> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffListTest.java
>>
>> ------------------------------------------------------------------------------
>> svn:mime-type = text/plain
>>
>> Added:
>> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffTest.java
>> URL:
>> http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffTest.java?rev=1561215&view=auto
>>
>> ==============================================================================
>> ---
>> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffTest.java
>> (added)
>> +++
>> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffTest.java
>> Fri Jan 24 22:37:50 2014
>> @@ -0,0 +1,72 @@
>> +/**
>> + * Licensed to the Apache Software Foundation (ASF) under one or more
>> + * contributor license agreements. See the NOTICE file distributed with
>> + * this work for additional information regarding copyright ownership.
>> + * The ASF licenses this file to You under the Apache License, Version 2.0
>> + * (the "License"); you may not use this file except in compliance with
>> + * the License. You may obtain a copy of the License at
>> + *
>> + * http://www.apache.org/licenses/LICENSE-2.0
>> + *
>> + * Unless required by applicable law or agreed to in writing, software
>> + * distributed under the License is distributed on an "AS IS" BASIS,
>> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
>> implied.
>> + * See the License for the specific language governing permissions and
>> + * limitations under the License.
>> + */
>> +package org.apache.commons.lang3.builder;
>> +
>> +import static org.junit.Assert.assertEquals;
>> +
>> +import org.junit.Test;
>> +
>> +
>> +/**
>> + * Unit tests {@link Diff}.
>> + *
>> + * @version $Id$
>> + */
>> +public class DiffTest {
>> +
>> + private static final String FIELD_NAME = "field";
>> + private static final Diff<Boolean> booleanDiff = new
>> BooleanDiff(FIELD_NAME);
>> +
>> + private static class BooleanDiff extends Diff<Boolean> {
>> + private static final long serialVersionUID = 1L;
>> +
>> + protected BooleanDiff(String fieldName) {
>> + super(fieldName);
>> + }
>> +
>> + @Override
>> + public Boolean getLeft() {
>> + return Boolean.TRUE;
>> + }
>> +
>> + @Override
>> + public Boolean getRight() {
>> + return Boolean.FALSE;
>> + }
>> + }
>> +
>> + @Test(expected = UnsupportedOperationException.class)
>> + public void testCannotModify() {
>> + booleanDiff.setValue(Boolean.FALSE);
>> + }
>> +
>> + @Test
>> + public void testGetFieldName() {
>> + assertEquals(FIELD_NAME, booleanDiff.getFieldName());
>> + }
>> +
>> + @Test
>> + public void testGetType() {
>> + assertEquals(Boolean.class, booleanDiff.getType());
>> + }
>> +
>> + @Test
>> + public void testToString() {
>> + assertEquals(String.format("[%s: %s, %s]", FIELD_NAME,
>> booleanDiff.getLeft(),
>> + booleanDiff.getRight()), booleanDiff.toString());
>> + }
>> +}
>>
>> Propchange:
>> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffTest.java
>>
>> ------------------------------------------------------------------------------
>> svn:eol-style = native
>>
>> Propchange:
>> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffTest.java
>>
>> ------------------------------------------------------------------------------
>> svn:keywords = Id Revision
>>
>> Propchange:
>> commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/builder/DiffTest.java
>>
>> ------------------------------------------------------------------------------
>> svn:mime-type = text/plain
>>
>>
>>
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@commons.apache.org
For additional commands, e-mail: dev-help@commons.apache.org