/*
* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* @test
* @bug 8033148 8141409
* @summary tests for array equals and compare
* @run testng ArraysEqCmpTest
*/
import org.testng.Assert;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.function.BiFunction;
import java.util.function.LongFunction;
import java.util.stream.IntStream;
public class ArraysEqCmpTest {
// Maximum width in bits
static final int MAX_WIDTH = 512;
static final Map<Class, Integer> typeToWidth;
static {
typeToWidth = new HashMap<>();
typeToWidth.put(boolean.class, Byte.SIZE);
typeToWidth.put(byte.class, Byte.SIZE);
typeToWidth.put(short.class, Short.SIZE);
typeToWidth.put(char.class, Character.SIZE);
typeToWidth.put(int.class, Integer.SIZE);
typeToWidth.put(long.class, Long.SIZE);
typeToWidth.put(float.class, Float.SIZE);
typeToWidth.put(double.class, Double.SIZE);
typeToWidth.put(Object.class, Integer.SIZE); // @@@ 32 or 64?
}
static int arraySizeFor(Class<?> type) {
type = type.isPrimitive() ? type : Object.class;
return 4 * MAX_WIDTH / typeToWidth.get(type);
}
static abstract class ArrayType<T> {
final Class<?> arrayType;
final Class<?> componentType;
final boolean unsigned;
final MethodHandle cpy;
final MethodHandle eq;
final MethodHandle eqr;
final MethodHandle cmp;
final MethodHandle cmpr;
final MethodHandle mm;
final MethodHandle mmr;
final MethodHandle getter;
final MethodHandle toString;
public ArrayType(Class<T> arrayType) {
this(arrayType, false);
}
public ArrayType(Class<T> arrayType, boolean unsigned) {
this.arrayType = arrayType;
this.componentType = arrayType.getComponentType();
this.unsigned = unsigned;
try {
MethodHandles.Lookup l = MethodHandles.lookup();
getter = MethodHandles.arrayElementGetter(arrayType);
if (componentType.isPrimitive()) {
cpy = l.findStatic(Arrays.class, "copyOfRange",
MethodType.methodType(arrayType, arrayType, int.class, int.class));
MethodType eqt = MethodType.methodType(
boolean.class, arrayType, arrayType);
MethodType eqrt = MethodType.methodType(
boolean.class, arrayType, int.class, int.class, arrayType, int.class, int.class);
eq = l.findStatic(Arrays.class, "equals", eqt);
eqr = l.findStatic(Arrays.class, "equals", eqrt);
String compareName = unsigned ? "compareUnsigned" : "compare";
cmp = l.findStatic(Arrays.class, compareName,
eqt.changeReturnType(int.class));
cmpr = l.findStatic(Arrays.class, compareName,
eqrt.changeReturnType(int.class));
mm = l.findStatic(Arrays.class, "mismatch",
eqt.changeReturnType(int.class));
mmr = l.findStatic(Arrays.class, "mismatch",
eqrt.changeReturnType(int.class));
toString = l.findStatic(Arrays.class, "toString",
MethodType.methodType(String.class, arrayType));
}
else {
cpy = l.findStatic(Arrays.class, "copyOfRange",
MethodType.methodType(Object[].class, Object[].class, int.class, int.class));
MethodType eqt = MethodType.methodType(
boolean.class, Object[].class, Object[].class);
MethodType eqrt = MethodType.methodType(
boolean.class, Object[].class, int.class, int.class, Object[].class, int.class, int.class);
eq = l.findStatic(Arrays.class, "equals", eqt);
eqr = l.findStatic(Arrays.class, "equals", eqrt);
MethodType cmpt = MethodType.methodType(
int.class, Comparable[].class, Comparable[].class);
MethodType cmprt = MethodType.methodType(
int.class, Comparable[].class, int.class, int.class, Comparable[].class, int.class, int.class);
cmp = l.findStatic(Arrays.class, "compare", cmpt);
cmpr = l.findStatic(Arrays.class, "compare", cmprt);
mm = l.findStatic(Arrays.class, "mismatch",
eqt.changeReturnType(int.class));
mmr = l.findStatic(Arrays.class, "mismatch",
eqrt.changeReturnType(int.class));
toString = l.findStatic(Arrays.class, "toString",
MethodType.methodType(String.class, Object[].class));
}
}
catch (Exception e) {
throw new Error(e);
}
}
@Override
public String toString() {
String s = arrayType.getCanonicalName();
return unsigned ? "unsigned " + s : s;
}
Object construct(int length) {
return Array.newInstance(componentType, length);
}
Object copyOf(Object a) {
return copyOf(a, 0, Array.getLength(a));
}
Object copyOf(Object a, int from, int to) {
try {
return (Object) cpy.invoke(a, from, to);
}
catch (RuntimeException | Error e) {
throw e;
}
catch (Throwable t) {
throw new Error(t);
}
}
Object get(Object a, int i) {
try {
return (Object) getter.invoke(a, i);
}
catch (RuntimeException | Error e) {
throw e;
}
catch (Throwable t) {
throw new Error(t);
}
}
abstract void set(Object a, int i, Object v);
boolean equals(Object a, Object b) {
try {
return (boolean) eq.invoke(a, b);
}
catch (RuntimeException | Error e) {
throw e;
}
catch (Throwable t) {
throw new Error(t);
}
}
boolean equals(Object a, int aFromIndex, int aToIndex,
Object b, int bFromIndex, int bToIndex) {
try {
return (boolean) eqr.invoke(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex);
}
catch (RuntimeException | Error e) {
throw e;
}
catch (Throwable t) {
throw new Error(t);
}
}
int compare(Object a, Object b) {
try {
return (int) cmp.invoke(a, b);
}
catch (RuntimeException | Error e) {
throw e;
}
catch (Throwable t) {
throw new Error(t);
}
}
int compare(Object a, int aFromIndex, int aToIndex,
Object b, int bFromIndex, int bToIndex) {
try {
return (int) cmpr.invoke(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex);
}
catch (RuntimeException | Error e) {
throw e;
}
catch (Throwable t) {
throw new Error(t);
}
}
int mismatch(Object a, Object b) {
try {
return (int) mm.invoke(a, b);
}
catch (RuntimeException | Error e) {
throw e;
}
catch (Throwable t) {
throw new Error(t);
}
}
int mismatch(Object a, int aFromIndex, int aToIndex,
Object b, int bFromIndex, int bToIndex) {
try {
return (int) mmr.invoke(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex);
}
catch (RuntimeException | Error e) {
throw e;
}
catch (Throwable t) {
throw new Error(t);
}
}
String toString(Object a) {
try {
return (String) toString.invoke(a);
}
catch (RuntimeException | Error e) {
throw e;
}
catch (Throwable t) {
throw new Error(t);
}
}
static class BoxedIntegers extends ArrayType<Integer[]> {
public BoxedIntegers() {
super(Integer[].class);
}
@Override
void set(Object a, int i, Object v) {
// Ensure unique reference
((Integer[]) a)[i] = v != null ? new Integer((Integer) v) : null;
}
}
static class BoxedIntegersWithReverseComparator extends BoxedIntegers {
final Comparator<Integer> c = (a, b) -> {
// Nulls sort after non-nulls
if (a == null || b == null)
return a == null ? b == null ? 0 : 1 : -1;
return Integer.compare(b, a);
};
final MethodHandle eqc;
final MethodHandle eqcr;
final MethodHandle cmpc;
final MethodHandle cmpcr;
final MethodHandle mismatchc;
final MethodHandle mismatchcr;
public BoxedIntegersWithReverseComparator() {
try {
MethodHandles.Lookup l = MethodHandles.lookup();
MethodType cmpt = MethodType.methodType(
int.class, Object[].class, Object[].class, Comparator.class);
MethodType cmprt = MethodType.methodType(
int.class, Object[].class, int.class, int.class,
Object[].class, int.class, int.class, Comparator.class);
eqc = l.findStatic(Arrays.class, "equals", cmpt.changeReturnType(boolean.class));
eqcr = l.findStatic(Arrays.class, "equals", cmprt.changeReturnType(boolean.class));
cmpc = l.findStatic(Arrays.class, "compare", cmpt);
cmpcr = l.findStatic(Arrays.class, "compare", cmprt);
mismatchc = l.findStatic(Arrays.class, "mismatch", cmpt);
mismatchcr = l.findStatic(Arrays.class, "mismatch", cmprt);
}
catch (Exception e) {
throw new Error(e);
}
}
@Override
boolean equals(Object a, Object b) {
try {
return (boolean) eqc.invoke(a, b, c);
}
catch (RuntimeException | Error e) {
throw e;
}
catch (Throwable t) {
throw new Error(t);
}
}
@Override
boolean equals(Object a, int aFromIndex, int aToIndex,
Object b, int bFromIndex, int bToIndex) {
try {
return (boolean) eqcr.invoke(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex, c);
}
catch (RuntimeException | Error e) {
throw e;
}
catch (Throwable t) {
throw new Error(t);
}
}
@Override
int compare(Object a, Object b) {
try {
return (int) cmpc.invoke(a, b, c);
}
catch (RuntimeException | Error e) {
throw e;
}
catch (Throwable t) {
throw new Error(t);
}
}
@Override
int compare(Object a, int aFromIndex, int aToIndex,
Object b, int bFromIndex, int bToIndex) {
try {
return (int) cmpcr.invoke(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex, c);
}
catch (RuntimeException | Error e) {
throw e;
}
catch (Throwable t) {
throw new Error(t);
}
}
@Override
int mismatch(Object a, Object b) {
try {
return (int) mismatchc.invoke(a, b, c);
}
catch (RuntimeException | Error e) {
throw e;
}
catch (Throwable t) {
throw new Error(t);
}
}
@Override
int mismatch(Object a, int aFromIndex, int aToIndex,
Object b, int bFromIndex, int bToIndex) {
try {
return (int) mismatchcr.invoke(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex, c);
}
catch (RuntimeException | Error e) {
throw e;
}
catch (Throwable t) {
throw new Error(t);
}
}
@Override
public String toString() {
return arrayType.getCanonicalName() + " with Comparator";
}
}
static class Booleans extends ArrayType<boolean[]> {
public Booleans() {
super(boolean[].class);
}
@Override
void set(Object a, int i, Object v) {
boolean pv;
if (v instanceof Boolean) {
pv = (Boolean) v;
}
else if (v instanceof Integer) {
pv = ((Integer) v) >= 0;
}
else throw new IllegalStateException();
((boolean[]) a)[i] = pv;
}
}
static class Bytes extends ArrayType<byte[]> {
public Bytes(boolean unsigned) {
super(byte[].class, unsigned);
}
@Override
void set(Object a, int i, Object v) {
byte pv;
if (v instanceof Byte) {
pv = (Byte) v;
}
else if (v instanceof Integer) {
pv = ((Integer) v).byteValue();
}
else throw new IllegalStateException();
((byte[]) a)[i] = pv;
}
}
static class Characters extends ArrayType<char[]> {
public Characters() {
super(char[].class);
}
@Override
void set(Object a, int i, Object v) {
char pv;
if (v instanceof Character) {
pv = (Character) v;
}
else if (v instanceof Integer) {
pv = (char) ((Integer) v).intValue();
}
else throw new IllegalStateException();
((char[]) a)[i] = pv;
}
}
static class Shorts extends ArrayType<short[]> {
public Shorts(boolean unsigned) {
super(short[].class, unsigned);
}
@Override
void set(Object a, int i, Object v) {
short pv;
if (v instanceof Short) {
pv = (Short) v;
}
else if (v instanceof Integer) {
pv = ((Integer) v).shortValue();
}
else throw new IllegalStateException();
((short[]) a)[i] = pv;
}
}
static class Integers extends ArrayType<int[]> {
public Integers(boolean unsigned) {
super(int[].class, unsigned);
}
@Override
void set(Object a, int i, Object v) {
int pv;
if (v instanceof Integer) {
pv = ((Integer) v).shortValue();
}
else throw new IllegalStateException();
((int[]) a)[i] = pv;
}
}
static class Longs extends ArrayType<long[]> {
public Longs(boolean unsigned) {
super(long[].class, unsigned);
}
@Override
void set(Object a, int i, Object v) {
long pv;
if (v instanceof Long) {
pv = (Long) v;
}
else if (v instanceof Integer) {
pv = ((Integer) v).longValue();
}
else throw new IllegalStateException();
((long[]) a)[i] = pv;
}
}
static class Floats extends ArrayType<float[]> {
public Floats() {
super(float[].class);
}
@Override
void set(Object a, int i, Object v) {
float pv;
if (v instanceof Float) {
pv = (Float) v;
}
else if (v instanceof Integer) {
pv = ((Integer) v).floatValue();
}
else throw new IllegalStateException();
((float[]) a)[i] = pv;
}
}
static class Doubles extends ArrayType<double[]> {
public Doubles() {
super(double[].class);
}
@Override
void set(Object a, int i, Object v) {
double pv;
if (v instanceof Double) {
pv = (Double) v;
}
else if (v instanceof Integer) {
pv = ((Integer) v).doubleValue();
}
else throw new IllegalStateException();
((double[]) a)[i] = pv;
}
}
}
static Object[][] arrayTypes;
@DataProvider
public static Object[][] arrayTypesProvider() {
if (arrayTypes == null) {
arrayTypes = new Object[][]{
new Object[]{new ArrayType.BoxedIntegers()},
new Object[]{new ArrayType.BoxedIntegersWithReverseComparator()},
new Object[]{new ArrayType.Booleans()},
new Object[]{new ArrayType.Bytes(false)},
new Object[]{new ArrayType.Bytes(true)},
new Object[]{new ArrayType.Characters()},
new Object[]{new ArrayType.Shorts(false)},
new Object[]{new ArrayType.Shorts(true)},
new Object[]{new ArrayType.Integers(false)},
new Object[]{new ArrayType.Integers(true)},
new Object[]{new ArrayType.Longs(false)},
new Object[]{new ArrayType.Longs(true)},
new Object[]{new ArrayType.Floats()},
new Object[]{new ArrayType.Doubles()},
};
}
return arrayTypes;
}
static Object[][] floatArrayTypes;
@DataProvider
public static Object[][] floatArrayTypesProvider() {
if (floatArrayTypes == null) {
LongFunction<Object> bTof = rb -> Float.intBitsToFloat((int) rb);
LongFunction<Object> bToD = Double::longBitsToDouble;
floatArrayTypes = new Object[][]{
new Object[]{new ArrayType.Floats(), 0x7fc00000L, 0x7f800001L, bTof},
new Object[]{new ArrayType.Doubles(), 0x7ff8000000000000L, 0x7ff0000000000001L, bToD},
};
}
return floatArrayTypes;
}
static Object[][] objectArrayTypes;
@DataProvider
public static Object[][] objectArrayTypesProvider() {
if (objectArrayTypes == null) {
LongFunction<Object> bTof = rb -> Float.intBitsToFloat((int) rb);
LongFunction<Object> bToD = Double::longBitsToDouble;
objectArrayTypes = new Object[][]{
new Object[]{new ArrayType.BoxedIntegers()},
new Object[]{new ArrayType.BoxedIntegersWithReverseComparator()},
};
}
return objectArrayTypes;
}
static Object[][] signedUnsignedArrayTypes;
@DataProvider
public static Object[][] signedUnsignedArrayTypes() {
if (signedUnsignedArrayTypes == null) {
signedUnsignedArrayTypes = new Object[][]{
new Object[]{new ArrayType.Bytes(false), new ArrayType.Bytes(true)},
new Object[]{new ArrayType.Shorts(false), new ArrayType.Shorts(true)},
new Object[]{new ArrayType.Integers(false), new ArrayType.Integers(true)},
new Object[]{new ArrayType.Longs(false), new ArrayType.Longs(true)},
};
}
return signedUnsignedArrayTypes;
}
// Equality and comparison tests
@Test(dataProvider = "arrayTypesProvider")
public void testArray(ArrayType<?> arrayType) {
BiFunction<ArrayType<?>, Integer, Object> constructor = (at, s) -> {
Object a = at.construct(s);
for (int x = 0; x < s; x++) {
at.set(a, x, x % 8);
}
return a;
};
BiFunction<ArrayType<?>, Object, Object> cloner = (at, a) ->
constructor.apply(at, Array.getLength(a));
testArrayType(arrayType, constructor, cloner);
}
@Test(dataProvider = "floatArrayTypesProvider")
public void testPrimitiveFloatArray(
ArrayType<?> arrayType,
long canonicalNanRawBits, long nonCanonicalNanRawBits,
LongFunction<Object> bitsToFloat) {
Object canonicalNan = bitsToFloat.apply(canonicalNanRawBits);
// If conversion is a signalling NaN it may be subject to conversion to a
// quiet NaN on some processors, even if a copy is performed
// The tests assume that if conversion occurs it does not convert to the
// canonical NaN
Object nonCanonicalNan = bitsToFloat.apply(nonCanonicalNanRawBits);
BiFunction<ArrayType<?>, Integer, Object> canonicalNaNs = (at, s) -> {
Object a = at.construct(s);
for (int x = 0; x < s; x++) {
at.set(a, x, canonicalNan);
}
return a;
};
BiFunction<ArrayType<?>, Object, Object> nonCanonicalNaNs = (at, a) -> {
int s = Array.getLength(a);
Object ac = at.construct(s);
for (int x = 0; x < s; x++) {
at.set(ac, x, nonCanonicalNan);
}
return ac;
};
BiFunction<ArrayType<?>, Object, Object> halfNonCanonicalNaNs = (at, a) -> {
int s = Array.getLength(a);
Object ac = at.construct(s);
for (int x = 0; x < s / 2; x++) {
at.set(ac, x, nonCanonicalNan);
}
for (int x = s / 2; x < s; x++) {
at.set(ac, x, 1);
}
return ac;
};
testArrayType(arrayType, canonicalNaNs, nonCanonicalNaNs);
testArrayType(arrayType, canonicalNaNs, halfNonCanonicalNaNs);
}
@Test(dataProvider = "objectArrayTypesProvider")
public void testNullElementsInObjectArray(ArrayType<?> arrayType) {
BiFunction<ArrayType<?>, Object, Object> cloner = ArrayType::copyOf;
// All nulls
testArrayType(arrayType,
(at, s) -> {
Object a = at.construct(s);
for (int x = 0; x < s; x++) {
at.set(a, x, null);
}
return a;
},
cloner);
// Some nulls
testArrayType(arrayType,
(at, s) -> {
Object a = at.construct(s);
for (int x = 0; x < s; x++) {
int v = x % 8;
at.set(a, x, v == 0 ? null : v);
}
return a;
},
cloner);
Integer[] a = new Integer[]{null, 0};
Integer[] b = new Integer[]{0, 0};
Assert.assertTrue(Arrays.compare(a, b) < 0);
Assert.assertTrue(Arrays.compare(b, a) > 0);
}
@Test(dataProvider = "objectArrayTypesProvider")
public void testSameRefElementsInObjectArray(ArrayType<?> arrayType) {
BiFunction<ArrayType<?>, Object, Object> cloner = ArrayType::copyOf;
// One ref
Integer one = 1;
testArrayType(arrayType,
(at, s) -> {
Integer[] a = (Integer[]) at.construct(s);
for (int x = 0; x < s; x++) {
a[x] = one;
}
return a;
},
cloner);
// All ref
testArrayType(arrayType,
(at, s) -> {
Integer[] a = (Integer[]) at.construct(s);
for (int x = 0; x < s; x++) {
a[x] = Integer.valueOf(s);
}
return a;
},
cloner);
// Some same ref
testArrayType(arrayType,
(at, s) -> {
Integer[] a = (Integer[]) at.construct(s);
for (int x = 0; x < s; x++) {
int v = x % 8;
a[x] = v == 1 ? one : new Integer(v);
}
return a;
},
cloner);
}
@Test(dataProvider = "signedUnsignedArrayTypes")
public void testSignedUnsignedArray(ArrayType<?> sat, ArrayType<?> uat) {
BiFunction<ArrayType<?>, Integer, Object> constructor = (at, s) -> {
Object a = at.construct(s);
for (int x = 0; x < s; x++) {
at.set(a, x, 1);
}
return a;
};
int n = arraySizeFor(sat.componentType);
for (int s : ranges(0, n)) {
Object a = constructor.apply(sat, s);
for (int aFrom : ranges(0, s)) {
for (int aTo : ranges(aFrom, s)) {
int aLength = aTo - aFrom;
if (aLength > 0) {
for (int i = aFrom; i < aTo; i++) {
Object ac = sat.copyOf(a);
// Create common prefix with a length of i - aFrom
sat.set(ac, i, -1);
int sc = sat.compare(ac, aFrom, aTo, a, aFrom, aTo);
int uc = uat.compare(ac, aFrom, aTo, a, aFrom, aTo);
Assert.assertTrue(sc < 0);
Assert.assertTrue(uc > 0);
}
}
}
}
}
}
void testArrayType(ArrayType<?> at,
BiFunction<ArrayType<?>, Integer, Object> constructor,
BiFunction<ArrayType<?>, Object, Object> cloner) {
int n = arraySizeFor(at.componentType);
for (int s : ranges(0, n)) {
Object a = constructor.apply(at, s);
Object b = cloner.apply(at, a);
for (int aFrom : ranges(0, s)) {
for (int aTo : ranges(aFrom, s)) {
int aLength = aTo - aFrom;
for (int bFrom : ranges(0, s)) {
for (int bTo : ranges(bFrom, s)) {
int bLength = bTo - bFrom;
Object anr = at.copyOf(a, aFrom, aTo);
Object bnr = at.copyOf(b, bFrom, bTo);
boolean eq = isEqual(at, a, aFrom, aTo, b, bFrom, bTo);
Assert.assertEquals(at.equals(a, aFrom, aTo, b, bFrom, bTo), eq);
Assert.assertEquals(at.equals(b, bFrom, bTo, a, aFrom, aTo), eq);
Assert.assertEquals(at.equals(anr, bnr), eq);
Assert.assertEquals(at.equals(bnr, anr), eq);
if (eq) {
Assert.assertEquals(at.compare(a, aFrom, aTo, b, bFrom, bTo), 0);
Assert.assertEquals(at.compare(b, bFrom, bTo, a, aFrom, aTo), 0);
Assert.assertEquals(at.compare(anr, bnr), 0);
Assert.assertEquals(at.compare(bnr, anr), 0);
Assert.assertEquals(at.mismatch(a, aFrom, aTo, b, bFrom, bTo), -1);
Assert.assertEquals(at.mismatch(b, bFrom, bTo, a, aFrom, aTo), -1);
Assert.assertEquals(at.mismatch(anr, bnr), -1);
Assert.assertEquals(at.mismatch(bnr, anr), -1);
}
else {
int aCb = at.compare(a, aFrom, aTo, b, bFrom, bTo);
int bCa = at.compare(b, bFrom, bTo, a, aFrom, aTo);
int v = Integer.signum(aCb) * Integer.signum(bCa);
Assert.assertTrue(v == -1);
int anrCbnr = at.compare(anr, bnr);
int bnrCanr = at.compare(bnr, anr);
Assert.assertEquals(anrCbnr, aCb);
Assert.assertEquals(bnrCanr, bCa);
int aMb = at.mismatch(a, aFrom, aTo, b, bFrom, bTo);
int bMa = at.mismatch(b, bFrom, bTo, a, aFrom, aTo);
int anrMbnr = at.mismatch(anr, bnr);
int bnrManr = at.mismatch(bnr, anr);
Assert.assertNotEquals(aMb, -1);
Assert.assertEquals(aMb, bMa);
Assert.assertNotEquals(anrMbnr, -1);
Assert.assertEquals(anrMbnr, bnrManr);
Assert.assertEquals(aMb, anrMbnr);
Assert.assertEquals(bMa, bnrManr);
// Common or proper prefix
Assert.assertTrue(at.equals(a, aFrom, aFrom + aMb, b, bFrom, bFrom + aMb));
if (aMb < Math.min(aLength, bLength)) {
// Common prefix
Assert.assertFalse(isEqual(at, a, aFrom + aMb, b, bFrom + aMb));
}
}
}
}
if (aLength > 0) {
for (int i = aFrom; i < aTo; i++) {
Object ac = at.copyOf(a);
// Create common prefix with a length of i - aFrom
at.set(ac, i, -1);
Object acnr = at.copyOf(ac, aFrom, aTo);
Object anr = at.copyOf(a, aFrom, aTo);
Assert.assertFalse(at.equals(ac, aFrom, aTo, a, aFrom, aTo));
Assert.assertFalse(at.equals(acnr, anr));
int acCa = at.compare(ac, aFrom, aTo, a, aFrom, aTo);
int aCac = at.compare(a, aFrom, aTo, ac, aFrom, aTo);
int v = Integer.signum(acCa) * Integer.signum(aCac);
Assert.assertTrue(v == -1);
int acnrCanr = at.compare(acnr, anr);
int anrCacnr = at.compare(anr, acnr);
Assert.assertEquals(acnrCanr, acCa);
Assert.assertEquals(anrCacnr, aCac);
int acMa = at.mismatch(ac, aFrom, aTo, a, aFrom, aTo);
int aMac = at.mismatch(a, aFrom, aTo, ac, aFrom, aTo);
Assert.assertEquals(acMa, aMac);
Assert.assertEquals(acMa, i - aFrom);
int acnrManr = at.mismatch(acnr, anr);
int anrMacnr = at.mismatch(anr, acnr);
Assert.assertEquals(acnrManr, anrMacnr);
Assert.assertEquals(acnrManr, i - aFrom);
}
}
}
}
}
}
static boolean isEqual(ArrayType<?> at, Object a, int aFromIndex, int aToIndex,
Object b, int bFromIndex, int bToIndex) {
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
if (aLength != bLength)
return false;
for (int i = 0; i < aLength; i++) {
Object av = at.get(a, aFromIndex++);
Object bv = at.get(b, bFromIndex++);
if (!Objects.equals(av, bv)) return false;
}
return true;
}
static boolean isEqual(ArrayType<?> at, Object a, int aFrom, Object b, int bFrom) {
Object av = at.get(a, aFrom);
Object bv = at.get(b, bFrom);
return Objects.equals(av, bv);
}
static int[] ranges(int from, int to) {
int width = to - from;
switch (width) {
case 0:
return new int[]{};
case 1:
return new int[]{from, to};
case 2:
return new int[]{from, from + 1, to};
case 3:
return new int[]{from, from + 1, from + 2, to};
default:
return IntStream.of(from, from + 1, from + 2, to / 2 - 1, to / 2, to / 2 + 1, to - 2, to - 1, to)
.filter(i -> i >= from && i <= to)
.distinct().toArray();
}
}
// Null array reference tests
@Test(dataProvider = "arrayTypesProvider")
public void testNullArrayRefs(ArrayType<?> arrayType) {
Object n = null;
Object a = arrayType.construct(0);
Assert.assertTrue(arrayType.equals(n, n));
Assert.assertFalse(arrayType.equals(n, a));
Assert.assertFalse(arrayType.equals(a, n));
Assert.assertEquals(arrayType.compare(n, n), 0);
Assert.assertTrue(arrayType.compare(n, a) < 0);
Assert.assertTrue(arrayType.compare(a, n) > 0);
}
// Exception throwing tests
@Test(dataProvider = "arrayTypesProvider")
public void testNPEs(ArrayType<?> arrayType) {
Object[] values = new Object[]{null, arrayType.construct(0)};
for (Object o1 : values) {
for (Object o2 : values) {
if (o1 != null && o2 != null)
continue;
testNPE(() -> arrayType.equals(o1, 0, 0, o2, 0, 0));
testNPE(() -> arrayType.compare(o1, 0, 0, o2, 0, 0));
testNPE(() -> arrayType.mismatch(o1, o2));
testNPE(() -> arrayType.mismatch(o1, 0, 0, o2, 0, 0));
}
}
}
@Test
public void testObjectNPEs() {
String[][] values = new String[][]{null, new String[0]};
Comparator<String> c = String::compareTo;
Comparator[] cs = new Comparator[]{null, c};
for (String[] o1 : values) {
for (String[] o2 : values) {
for (Comparator o3 : cs) {
if (o1 != null && o2 != null && o3 != null)
continue;
if (o3 == null) {
testNPE(() -> Arrays.equals(o1, o2, o3));
testNPE(() -> Arrays.compare(o1, o2, o3));
testNPE(() -> Arrays.mismatch(o1, o2, o3));
}
testNPE(() -> Arrays.equals(o1, 0, 0, o2, 0, 0, o3));
testNPE(() -> Arrays.compare(o1, 0, 0, o2, 0, 0, o3));
testNPE(() -> Arrays.mismatch(o1, 0, 0, o2, 0, 0, o3));
}
}
}
}
@Test(dataProvider = "arrayTypesProvider")
public void testIAEs(ArrayType<?> arrayType) {
List<Integer> values = Arrays.asList(0, 1);
for (int s : values) {
Object a = arrayType.construct(s);
for (int o1 : values) {
for (int o2 : values) {
if (o1 <= o2) continue;
testIAE(() -> arrayType.equals(a, o1, 0, a, o2, 0));
testIAE(() -> arrayType.compare(a, o1, 0, a, o2, 0));
testIAE(() -> arrayType.mismatch(a, o1, 0, a, o2, 0));
}
}
}
}
@Test(dataProvider = "arrayTypesProvider")
public void testAIOBEs(ArrayType<?> arrayType) {
List<Integer> froms = Arrays.asList(-1, 0);
for (int s : Arrays.asList(0, 1)) {
List<Integer> tos = Arrays.asList(s, s + 1);
Object a = arrayType.construct(s);
for (int aFrom : froms) {
for (int aTo : tos) {
for (int bFrom : froms) {
for (int bTo : tos) {
if (aFrom >= 0 && aTo <= s &&
bFrom >= 0 && bTo <= s) continue;
testAIOBE(() -> arrayType.equals(a, aFrom, aTo, a, bFrom, bTo));
testAIOBE(() -> arrayType.compare(a, aFrom, aTo, a, bFrom, bTo));
testAIOBE(() -> arrayType.mismatch(a, aFrom, aTo, a, bFrom, bTo));
}
}
}
}
}
}
static void testNPE(Runnable r) {
testThrowable(r, NullPointerException.class);
}
static void testIAE(Runnable r) {
testThrowable(r, IllegalArgumentException.class);
}
static void testAIOBE(Runnable r) {
testThrowable(r, ArrayIndexOutOfBoundsException.class);
}
static void testThrowable(Runnable r, Class<? extends Throwable> expected) {
Throwable caught = null;
try {
r.run();
}
catch (Throwable t) {
caught = t;
}
Assert.assertNotNull(caught);
Assert.assertTrue(expected.isInstance(caught));
}
}