/*

 * 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;

            }

        }