From b47c241280b52f7551d1854699abbae72a68e733 Mon Sep 17 00:00:00 2001 From: Stephen Colebourne Date: Thu, 12 Sep 2002 22:00:35 +0000 Subject: [PATCH] Added code from Steve Downey, with some formatting changes and extra tests git-svn-id: https://svn.apache.org/repos/asf/jakarta/commons/proper/lang/trunk@137018 13f79535-47bb-0310-9956-ffa450edef68 --- .../lang/builder/EqualsBuilderTest.java | 680 ++++++++++++++++++ 1 file changed, 680 insertions(+) create mode 100644 src/test/org/apache/commons/lang/builder/EqualsBuilderTest.java diff --git a/src/test/org/apache/commons/lang/builder/EqualsBuilderTest.java b/src/test/org/apache/commons/lang/builder/EqualsBuilderTest.java new file mode 100644 index 000000000..c332248a6 --- /dev/null +++ b/src/test/org/apache/commons/lang/builder/EqualsBuilderTest.java @@ -0,0 +1,680 @@ +/* ==================================================================== + * The Apache Software License, Version 1.1 + * + * Copyright (c) 2002 The Apache Software Foundation. All rights + * reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * 3. The end-user documentation included with the redistribution, if + * any, must include the following acknowlegement: + * "This product includes software developed by the + * Apache Software Foundation (http://www.apache.org/)." + * Alternately, this acknowlegement may appear in the software itself, + * if and wherever such third-party acknowlegements normally appear. + * + * 4. The names "The Jakarta Project", "Commons", and "Apache Software + * Foundation" must not be used to endorse or promote products derived + * from this software without prior written permission. For written + * permission, please contact apache@apache.org. + * + * 5. Products derived from this software may not be called "Apache" + * nor may "Apache" appear in their names without prior written + * permission of the Apache Software Foundation. + * + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR + * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * ==================================================================== + * + * This software consists of voluntary contributions made by many + * individuals on behalf of the Apache Software Foundation. For more + * information on the Apache Software Foundation, please see + * . + */ +package org.apache.commons.lang.builder; + +import junit.framework.Test; +import junit.framework.TestCase; +import junit.framework.TestSuite; +import junit.textui.TestRunner; +/** + * Unit tests {@link org.apache.commons.lang.EqualsBuilder}. + * + * @author Steve Downey + * @author Stephen Colebourne + * @version $Id: EqualsBuilderTest.java,v 1.1 2002/09/12 22:00:35 scolebourne Exp $ + */ +public class EqualsBuilderTest extends TestCase { + + public EqualsBuilderTest(String name) { + super(name); + } + + public static void main(String[] args) { + TestRunner.run(suite()); + } + + public static Test suite() { + TestSuite suite = new TestSuite(EqualsBuilderTest.class); + suite.setName("HashCodeBuilder Tests"); + return suite; + } + + protected void setUp() throws Exception { + super.setUp(); + } + + protected void tearDown() throws Exception { + super.tearDown(); + } + + //----------------------------------------------------------------------- + + static class TestObject { + private int a; + public TestObject(int a) { + this.a = a; + } + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof TestObject)) { + return false; + } + TestObject rhs = (TestObject) o; + return (a == rhs.a); + } + + public void setA(int a) { + this.a = a; + } + + public int getA() { + return a; + } + } + + public void testReflectionEquals() { + TestObject o1 = new TestObject(4); + TestObject o2 = new TestObject(5); + assertTrue(EqualsBuilder.reflectionEquals(o1, o1)); + assertTrue(!EqualsBuilder.reflectionEquals(o1, o2)); + o2.setA(4); + assertTrue(EqualsBuilder.reflectionEquals(o1, o2)); + + assertTrue(!EqualsBuilder.reflectionEquals(o1, this)); + + assertTrue(!EqualsBuilder.reflectionEquals(o1, null)); + assertTrue(!EqualsBuilder.reflectionEquals(null, o2)); + assertTrue(EqualsBuilder.reflectionEquals((Object) null, (Object) null)); + } + + public void testObject() { + TestObject o1 = new TestObject(4); + TestObject o2 = new TestObject(5); + assertTrue(new EqualsBuilder().append(o1, o1).isEquals()); + assertTrue(!new EqualsBuilder().append(o1, o2).isEquals()); + o2.setA(4); + assertTrue(new EqualsBuilder().append(o1, o2).isEquals()); + + assertTrue(!new EqualsBuilder().append(o1, this).isEquals()); + + assertTrue(!new EqualsBuilder().append(o1, null).isEquals()); + assertTrue(!new EqualsBuilder().append(null, o2).isEquals()); + assertTrue(new EqualsBuilder().append((Object) null, (Object) null).isEquals()); + } + + public void testLong() { + long o1 = 1L; + long o2 = 2L; + assertTrue(new EqualsBuilder().append(o1, o1).isEquals()); + assertTrue(!new EqualsBuilder().append(o1, o2).isEquals()); + } + + public void testInt() { + int o1 = 1; + int o2 = 2; + assertTrue(new EqualsBuilder().append(o1, o1).isEquals()); + assertTrue(!new EqualsBuilder().append(o1, o2).isEquals()); + } + + public void testShort() { + short o1 = 1; + short o2 = 2; + assertTrue(new EqualsBuilder().append(o1, o1).isEquals()); + assertTrue(!new EqualsBuilder().append(o1, o2).isEquals()); + } + + public void testChar() { + char o1 = 1; + char o2 = 2; + assertTrue(new EqualsBuilder().append(o1, o1).isEquals()); + assertTrue(!new EqualsBuilder().append(o1, o2).isEquals()); + } + + public void testByte() { + byte o1 = 1; + byte o2 = 2; + assertTrue(new EqualsBuilder().append(o1, o1).isEquals()); + assertTrue(!new EqualsBuilder().append(o1, o2).isEquals()); + } + + public void testDouble() { + double o1 = 1; + double o2 = 2; + assertTrue(new EqualsBuilder().append(o1, o1).isEquals()); + assertTrue(!new EqualsBuilder().append(o1, o2).isEquals()); + assertTrue(!new EqualsBuilder().append(o1, Double.NaN).isEquals()); + assertTrue(new EqualsBuilder().append(Double.NaN, Double.NaN).isEquals()); + assertTrue(new EqualsBuilder().append(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY).isEquals()); + } + + public void testFloat() { + float o1 = 1; + float o2 = 2; + assertTrue(new EqualsBuilder().append(o1, o1).isEquals()); + assertTrue(!new EqualsBuilder().append(o1, o2).isEquals()); + assertTrue(!new EqualsBuilder().append(o1, Float.NaN).isEquals()); + assertTrue(new EqualsBuilder().append(Float.NaN, Float.NaN).isEquals()); + assertTrue(new EqualsBuilder().append(Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY).isEquals()); + } + + public void testBoolean() { + boolean o1 = true; + boolean o2 = false; + assertTrue(new EqualsBuilder().append(o1, o1).isEquals()); + assertTrue(!new EqualsBuilder().append(o1, o2).isEquals()); + } + + public void testObjectArray() { + TestObject[] obj1 = new TestObject[2]; + obj1[0] = new TestObject(4); + obj1[1] = new TestObject(5); + TestObject[] obj2 = new TestObject[2]; + obj2[0] = new TestObject(4); + obj2[1] = new TestObject(5); + assertTrue(new EqualsBuilder().append(obj1, obj1).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals()); + obj1[1].setA(6); + assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals()); + + obj2 = null; + assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals()); + obj1 = null; + assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals()); + } + + public void testLongArray() { + long[] obj1 = new long[2]; + obj1[0] = 5L; + obj1[1] = 6L; + long[] obj2 = new long[2]; + obj2[0] = 5L; + obj2[1] = 6L; + assertTrue(new EqualsBuilder().append(obj1, obj1).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals()); + obj1[1] = 7; + assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals()); + + obj2 = null; + assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals()); + obj1 = null; + assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals()); + } + + public void testIntArray() { + int[] obj1 = new int[2]; + obj1[0] = 5; + obj1[1] = 6; + int[] obj2 = new int[2]; + obj2[0] = 5; + obj2[1] = 6; + assertTrue(new EqualsBuilder().append(obj1, obj1).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals()); + obj1[1] = 7; + assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals()); + + obj2 = null; + assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals()); + obj1 = null; + assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals()); + } + + public void testShortArray() { + short[] obj1 = new short[2]; + obj1[0] = 5; + obj1[1] = 6; + short[] obj2 = new short[2]; + obj2[0] = 5; + obj2[1] = 6; + assertTrue(new EqualsBuilder().append(obj1, obj1).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals()); + obj1[1] = 7; + assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals()); + + obj2 = null; + assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals()); + obj1 = null; + assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals()); + } + + public void testCharArray() { + char[] obj1 = new char[2]; + obj1[0] = 5; + obj1[1] = 6; + char[] obj2 = new char[2]; + obj2[0] = 5; + obj2[1] = 6; + assertTrue(new EqualsBuilder().append(obj1, obj1).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals()); + obj1[1] = 7; + assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals()); + + obj2 = null; + assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals()); + obj1 = null; + assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals()); + } + + public void testByteArray() { + byte[] obj1 = new byte[2]; + obj1[0] = 5; + obj1[1] = 6; + byte[] obj2 = new byte[2]; + obj2[0] = 5; + obj2[1] = 6; + assertTrue(new EqualsBuilder().append(obj1, obj1).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals()); + obj1[1] = 7; + assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals()); + + obj2 = null; + assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals()); + obj1 = null; + assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals()); + } + + public void testDoubleArray() { + double[] obj1 = new double[2]; + obj1[0] = 5; + obj1[1] = 6; + double[] obj2 = new double[2]; + obj2[0] = 5; + obj2[1] = 6; + assertTrue(new EqualsBuilder().append(obj1, obj1).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals()); + obj1[1] = 7; + assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals()); + + obj2 = null; + assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals()); + obj1 = null; + assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals()); + } + + public void testFloatArray() { + float[] obj1 = new float[2]; + obj1[0] = 5; + obj1[1] = 6; + float[] obj2 = new float[2]; + obj2[0] = 5; + obj2[1] = 6; + assertTrue(new EqualsBuilder().append(obj1, obj1).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals()); + obj1[1] = 7; + assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals()); + + obj2 = null; + assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals()); + obj1 = null; + assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals()); + } + + public void testBooleanArray() { + boolean[] obj1 = new boolean[2]; + obj1[0] = true; + obj1[1] = false; + boolean[] obj2 = new boolean[2]; + obj2[0] = true; + obj2[1] = false; + assertTrue(new EqualsBuilder().append(obj1, obj1).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals()); + obj1[1] = true; + assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals()); + + obj2 = null; + assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals()); + obj1 = null; + assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals()); + } + + public void testMultiLongArray() { + long[][] array1 = new long[2][2]; + long[][] array2 = new long[2][2]; + for (int i = 0; i < array1.length; ++i) { + for (int j = 0; j < array1[0].length; j++) { + array1[i][j] = (i + 1) * (j + 1); + array2[i][j] = (i + 1) * (j + 1); + } + } + assertTrue(new EqualsBuilder().append(array1, array1).isEquals()); + assertTrue(new EqualsBuilder().append(array1, array2).isEquals()); + array1[1][1] = 0; + assertTrue(!new EqualsBuilder().append(array1, array2).isEquals()); + } + + public void testMultiIntArray() { + int[][] array1 = new int[2][2]; + int[][] array2 = new int[2][2]; + for (int i = 0; i < array1.length; ++i) { + for (int j = 0; j < array1[0].length; j++) { + array1[i][j] = (i + 1) * (j + 1); + array2[i][j] = (i + 1) * (j + 1); + } + } + assertTrue(new EqualsBuilder().append(array1, array1).isEquals()); + assertTrue(new EqualsBuilder().append(array1, array2).isEquals()); + array1[1][1] = 0; + assertTrue(!new EqualsBuilder().append(array1, array2).isEquals()); + } + + public void testMultiShortArray() { + short[][] array1 = new short[2][2]; + short[][] array2 = new short[2][2]; + for (short i = 0; i < array1.length; ++i) { + for (short j = 0; j < array1[0].length; j++) { + array1[i][j] = i; + array2[i][j] = i; + } + } + assertTrue(new EqualsBuilder().append(array1, array1).isEquals()); + assertTrue(new EqualsBuilder().append(array1, array2).isEquals()); + array1[1][1] = 0; + assertTrue(!new EqualsBuilder().append(array1, array2).isEquals()); + } + + public void testMultiCharArray() { + char[][] array1 = new char[2][2]; + char[][] array2 = new char[2][2]; + for (char i = 0; i < array1.length; ++i) { + for (char j = 0; j < array1[0].length; j++) { + array1[i][j] = i; + array2[i][j] = i; + } + } + assertTrue(new EqualsBuilder().append(array1, array1).isEquals()); + assertTrue(new EqualsBuilder().append(array1, array2).isEquals()); + array1[1][1] = 0; + assertTrue(!new EqualsBuilder().append(array1, array2).isEquals()); + } + + public void testMultiByteArray() { + byte[][] array1 = new byte[2][2]; + byte[][] array2 = new byte[2][2]; + for (byte i = 0; i < array1.length; ++i) { + for (byte j = 0; j < array1[0].length; j++) { + array1[i][j] = i; + array2[i][j] = i; + } + } + assertTrue(new EqualsBuilder().append(array1, array1).isEquals()); + assertTrue(new EqualsBuilder().append(array1, array2).isEquals()); + array1[1][1] = 0; + assertTrue(!new EqualsBuilder().append(array1, array2).isEquals()); + } + public void testMultiFloatArray() { + float[][] array1 = new float[2][2]; + float[][] array2 = new float[2][2]; + for (int i = 0; i < array1.length; ++i) { + for (int j = 0; j < array1[0].length; j++) { + array1[i][j] = (i + 1) * (j + 1); + array2[i][j] = (i + 1) * (j + 1); + } + } + assertTrue(new EqualsBuilder().append(array1, array1).isEquals()); + assertTrue(new EqualsBuilder().append(array1, array2).isEquals()); + array1[1][1] = 0; + assertTrue(!new EqualsBuilder().append(array1, array2).isEquals()); + } + + public void testMultiDoubleArray() { + double[][] array1 = new double[2][2]; + double[][] array2 = new double[2][2]; + for (int i = 0; i < array1.length; ++i) { + for (int j = 0; j < array1[0].length; j++) { + array1[i][j] = (i + 1) * (j + 1); + array2[i][j] = (i + 1) * (j + 1); + } + } + assertTrue(new EqualsBuilder().append(array1, array1).isEquals()); + assertTrue(new EqualsBuilder().append(array1, array2).isEquals()); + array1[1][1] = 0; + assertTrue(!new EqualsBuilder().append(array1, array2).isEquals()); + } + + public void testMultiBooleanArray() { + boolean[][] array1 = new boolean[2][2]; + boolean[][] array2 = new boolean[2][2]; + for (int i = 0; i < array1.length; ++i) { + for (int j = 0; j < array1[0].length; j++) { + array1[i][j] = (i == 1) || (j == 1); + array2[i][j] = (i == 1) || (j == 1); + } + } + assertTrue(new EqualsBuilder().append(array1, array1).isEquals()); + assertTrue(new EqualsBuilder().append(array1, array2).isEquals()); + array1[1][1] = false; + assertTrue(!new EqualsBuilder().append(array1, array2).isEquals()); + } + + public void testRaggedArray() { + long array1[][] = new long[2][]; + long array2[][] = new long[2][]; + for (int i = 0; i < array1.length; ++i) { + array1[i] = new long[2]; + array2[i] = new long[2]; + for (int j = 0; j < array1[i].length; ++j) { + array1[i][j] = (i + 1) * (j + 1); + array2[i][j] = (i + 1) * (j + 1); + } + } + assertTrue(new EqualsBuilder().append(array1, array1).isEquals()); + assertTrue(new EqualsBuilder().append(array1, array2).isEquals()); + array1[1][1] = 0; + assertTrue(!new EqualsBuilder().append(array1, array2).isEquals()); + } + + public void testMixedArray() { + Object array1[] = new Object[2]; + Object array2[] = new Object[2]; + for (int i = 0; i < array1.length; ++i) { + array1[i] = new long[2]; + array2[i] = new long[2]; + for (int j = 0; j < 2; ++j) { + TestObject obj1 = new TestObject((i + 1) * (j + 1)); + TestObject obj2 = new TestObject((i + 1) * (j + 1)); + ((long[]) array1[i])[j] = (i + 1) * (j + 1); + ((long[]) array2[i])[j] = (i + 1) * (j + 1); + } + } + assertTrue(new EqualsBuilder().append(array1, array1).isEquals()); + assertTrue(new EqualsBuilder().append(array1, array2).isEquals()); + ((long[]) array1[1])[1] = 0; + assertTrue(!new EqualsBuilder().append(array1, array2).isEquals()); + } + + public void testObjectArrayHiddenByObject() { + TestObject[] array1 = new TestObject[2]; + array1[0] = new TestObject(4); + array1[1] = new TestObject(5); + TestObject[] array2 = new TestObject[2]; + array2[0] = new TestObject(4); + array2[1] = new TestObject(5); + Object obj1 = array1; + Object obj2 = array2; + assertTrue(new EqualsBuilder().append(obj1, obj1).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, array1).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, array2).isEquals()); + array1[1].setA(6); + assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals()); + } + + public void testLongArrayHiddenByObject() { + long[] array1 = new long[2]; + array1[0] = 5L; + array1[1] = 6L; + long[] array2 = new long[2]; + array2[0] = 5L; + array2[1] = 6L; + Object obj1 = array1; + Object obj2 = array2; + assertTrue(new EqualsBuilder().append(obj1, obj1).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, array1).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, array2).isEquals()); + array1[1] = 7; + assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals()); + } + + public void testIntArrayHiddenByObject() { + int[] array1 = new int[2]; + array1[0] = 5; + array1[1] = 6; + int[] array2 = new int[2]; + array2[0] = 5; + array2[1] = 6; + Object obj1 = array1; + Object obj2 = array2; + assertTrue(new EqualsBuilder().append(obj1, obj1).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, array1).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, array2).isEquals()); + array1[1] = 7; + assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals()); + } + + public void testShortArrayHiddenByObject() { + short[] array1 = new short[2]; + array1[0] = 5; + array1[1] = 6; + short[] array2 = new short[2]; + array2[0] = 5; + array2[1] = 6; + Object obj1 = array1; + Object obj2 = array2; + assertTrue(new EqualsBuilder().append(obj1, obj1).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, array1).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, array2).isEquals()); + array1[1] = 7; + assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals()); + } + + public void testCharArrayHiddenByObject() { + char[] array1 = new char[2]; + array1[0] = 5; + array1[1] = 6; + char[] array2 = new char[2]; + array2[0] = 5; + array2[1] = 6; + Object obj1 = array1; + Object obj2 = array2; + assertTrue(new EqualsBuilder().append(obj1, obj1).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, array1).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, array2).isEquals()); + array1[1] = 7; + assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals()); + } + + public void testByteArrayHiddenByObject() { + byte[] array1 = new byte[2]; + array1[0] = 5; + array1[1] = 6; + byte[] array2 = new byte[2]; + array2[0] = 5; + array2[1] = 6; + Object obj1 = array1; + Object obj2 = array2; + assertTrue(new EqualsBuilder().append(obj1, obj1).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, array1).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, array2).isEquals()); + array1[1] = 7; + assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals()); + } + + public void testDoubleArrayHiddenByObject() { + double[] array1 = new double[2]; + array1[0] = 5; + array1[1] = 6; + double[] array2 = new double[2]; + array2[0] = 5; + array2[1] = 6; + Object obj1 = array1; + Object obj2 = array2; + assertTrue(new EqualsBuilder().append(obj1, obj1).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, array1).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, array2).isEquals()); + array1[1] = 7; + assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals()); + } + + public void testFloatArrayHiddenByObject() { + float[] array1 = new float[2]; + array1[0] = 5; + array1[1] = 6; + float[] array2 = new float[2]; + array2[0] = 5; + array2[1] = 6; + Object obj1 = array1; + Object obj2 = array2; + assertTrue(new EqualsBuilder().append(obj1, obj1).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, array1).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, array2).isEquals()); + array1[1] = 7; + assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals()); + } + + public void testBooleanArrayHiddenByObject() { + boolean[] array1 = new boolean[2]; + array1[0] = true; + array1[1] = false; + boolean[] array2 = new boolean[2]; + array2[0] = true; + array2[1] = false; + Object obj1 = array1; + Object obj2 = array2; + assertTrue(new EqualsBuilder().append(obj1, obj1).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, array1).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals()); + assertTrue(new EqualsBuilder().append(obj1, array2).isEquals()); + array1[1] = true; + assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals()); + } + +}