test/jdk/java/util/Arrays/ArraysEqCmpTest.java

/*
 * 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));
    }
}