/*
 * Copyright (c) 2003, 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     4906359 6239296
 * @summary Basic test for content-based array object methods
 * @author  Josh Bloch, Martin Buchholz
 * @key randomness
 */

import java.util.*;
import java.io.*;

public class ArrayObjectMethods {
    int[] sizes = {0, 10, 100, 200, 1000};

    void test(String[] args) throws Throwable {
        equal(Arrays.deepToString(null), "null");
        equal(Arrays.deepToString(new Object[]{}), "[]");
        equal(Arrays.deepToString(new Object[]{null}), "[null]");
        equal(Arrays.deepToString(new Object[]{null, 1}), "[null, 1]");
        equal(Arrays.deepToString(new Object[]{1, null}), "[1, null]");
        equal(Arrays.deepToString(new Object[]{new Object[]{}, null}), "[[], null]");

        {
            Object[] a = {1, null};
            a[1] = a;
            equal(Arrays.deepToString(a), "[1, [...]]");
            a[0] = a;
            equal(Arrays.deepToString(a), "[[...], [...]]");
            a[0] = a[1] = new Object[]{1, null, a};
            equal(Arrays.deepToString(a), "[[1, null, [...]], [1, null, [...]]]");
        }

        for (int size : sizes) {
            {
                long[] a = Rnd.longArray(size);
                equal(Arrays.toString(a), PrimitiveArrays.asList(a).toString());
                equal(Arrays.hashCode(a), PrimitiveArrays.asList(a).hashCode());
            }
            {
                int[] a = Rnd.intArray(size);
                equal(Arrays.toString(a), PrimitiveArrays.asList(a).toString());
                equal(Arrays.hashCode(a), PrimitiveArrays.asList(a).hashCode());
            }
            {
                short[] a = Rnd.shortArray(size);
                equal(Arrays.toString(a), PrimitiveArrays.asList(a).toString());
                equal(Arrays.hashCode(a), PrimitiveArrays.asList(a).hashCode());
            }
            {
                char[] a = Rnd.charArray(size);
                equal(Arrays.toString(a), PrimitiveArrays.asList(a).toString());
                equal(Arrays.hashCode(a), PrimitiveArrays.asList(a).hashCode());
            }
            {
                byte[] a = Rnd.byteArray(size);
                equal(Arrays.toString(a), PrimitiveArrays.asList(a).toString());
                equal(Arrays.hashCode(a), PrimitiveArrays.asList(a).hashCode());
            }
            {
                boolean[] a = Rnd.booleanArray(size);
                equal(Arrays.toString(a), PrimitiveArrays.asList(a).toString());
                equal(Arrays.hashCode(a), PrimitiveArrays.asList(a).hashCode());
            }
            {
                double[] a = Rnd.doubleArray(size);
                equal(Arrays.toString(a), PrimitiveArrays.asList(a).toString());
                equal(Arrays.hashCode(a), PrimitiveArrays.asList(a).hashCode());
            }
            {
                float[] a = Rnd.floatArray(size);
                equal(Arrays.toString(a), PrimitiveArrays.asList(a).toString());
                equal(Arrays.hashCode(a), PrimitiveArrays.asList(a).hashCode());
            }
            {
                Object[] a = Rnd.flatObjectArray(size);
                equal(Arrays.toString(a), Arrays.asList(a).toString());
                equal(Arrays.deepToString(a), Arrays.asList(a).toString());
                equal(Arrays.hashCode(a), Arrays.asList(a).hashCode());
            }

            if (size <= 200) {
                Object[] a = Rnd.nestedObjectArray(size);
                List aList = deepToList(a);
                equal(Arrays.toString(a), Arrays.asList(a).toString());
                equal(Arrays.deepToString(a), aList.toString());
                equal(Arrays.deepHashCode(a), aList.hashCode());
                equal(Arrays.hashCode(a), Arrays.asList(a).hashCode());

                Object[] deepCopy = (Object[]) deepCopy(a);
                check(Arrays.deepEquals(a, deepCopy));
                check(Arrays.deepEquals(deepCopy, a));

                // Make deepCopy != a
                if (size == 0)
                    deepCopy = new Object[] {"foo"};
                else if (deepCopy[deepCopy.length - 1] == null)
                    deepCopy[deepCopy.length - 1] = "baz";
                else
                    deepCopy[deepCopy.length - 1] = null;
                check(! Arrays.deepEquals(a, deepCopy));
                check(! Arrays.deepEquals(deepCopy, a));
            }
        }
    }

    // Utility method to turn an array into a list "deeply," turning
    // all primitives into objects
    List<Object> deepToList(Object[] a) {
        List<Object> result = new ArrayList<Object>();
        for (Object e : a) {
            if (e instanceof byte[])
                result.add(PrimitiveArrays.asList((byte[])e));
            else if (e instanceof short[])
                result.add(PrimitiveArrays.asList((short[])e));
            else if (e instanceof int[])
                result.add(PrimitiveArrays.asList((int[])e));
            else if (e instanceof long[])
                result.add(PrimitiveArrays.asList((long[])e));
            else if (e instanceof char[])
                result.add(PrimitiveArrays.asList((char[])e));
            else if (e instanceof double[])
                result.add(PrimitiveArrays.asList((double[])e));
            else if (e instanceof float[])
                result.add(PrimitiveArrays.asList((float[])e));
            else if (e instanceof boolean[])
                result.add(PrimitiveArrays.asList((boolean[])e));
            else if (e instanceof Object[])
                result.add(deepToList((Object[])e));
            else
                result.add(e);
        }
        return result;
    }

    // Utility method to do a deep copy of an object *very slowly* using
    // serialization/deserialization
    Object deepCopy(Object oldObj) {
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(oldObj);
            oos.flush();
            ByteArrayInputStream bin = new ByteArrayInputStream(
                bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bin);
            return ois.readObject();
        } catch(Exception e) {
            throw new IllegalArgumentException(e);
        }
    }

    //--------------------- Infrastructure ---------------------------
    volatile int passed = 0, failed = 0;
    void pass() {passed++;}
    void fail() {failed++; Thread.dumpStack();}
    void fail(String msg) {System.err.println(msg); fail();}
    void unexpected(Throwable t) {failed++; t.printStackTrace();}
    void check(boolean cond) {if (cond) pass(); else fail();}
    void equal(Object x, Object y) {
        if (x == null ? y == null : x.equals(y)) pass();
        else fail(x + " not equal to " + y);}
    public static void main(String[] args) throws Throwable {
        new ArrayObjectMethods().instanceMain(args);}
    void instanceMain(String[] args) throws Throwable {
        try {test(args);} catch (Throwable t) {unexpected(t);}
        System.out.printf("%nPassed = %d, failed = %d%n%n", passed, failed);
        if (failed > 0) throw new AssertionError("Some tests failed");}
}

/**
 * Methods to generate "interesting" random primitives and primitive
 * arrays.  Unlike Random.nextXxx, these methods return small values
 * and boundary values (e.g., 0, -1, NaN) with greater than normal
 * likelihood.
 */

class Rnd {
    private static Random rnd = new Random();

    public static long nextLong() {
        switch(rnd.nextInt(10)) {
            case 0:  return 0;
            case 1:  return Long.MIN_VALUE;
            case 2:  return Long.MAX_VALUE;
            case 3: case 4: case 5:
                     return (long) (rnd.nextInt(20) - 10);
            default: return rnd.nextLong();
        }
    }

    public static int nextInt() {
        switch(rnd.nextInt(10)) {
            case 0:  return 0;
            case 1:  return Integer.MIN_VALUE;
            case 2:  return Integer.MAX_VALUE;
            case 3: case 4: case 5:
                     return rnd.nextInt(20) - 10;
            default: return rnd.nextInt();
        }
    }

    public static short nextShort() {
        switch(rnd.nextInt(10)) {
            case 0:  return 0;
            case 1:  return Short.MIN_VALUE;
            case 2:  return Short.MAX_VALUE;
            case 3: case 4: case 5:
                     return (short) (rnd.nextInt(20) - 10);
            default: return (short) rnd.nextInt();
        }
    }

    public static char nextChar() {
        switch(rnd.nextInt(10)) {
            case 0:  return 0;
            case 1:  return Character.MIN_VALUE;
            case 2:  return Character.MAX_VALUE;
            case 3: case 4: case 5:
                     return (char) (rnd.nextInt(20) - 10);
            default: return (char) rnd.nextInt();
        }
    }

    public static byte nextByte() {
        switch(rnd.nextInt(10)) {
            case 0:  return 0;
            case 1:  return Byte.MIN_VALUE;
            case 2:  return Byte.MAX_VALUE;
            case 3: case 4: case 5:
                     return (byte) (rnd.nextInt(20) - 10);
            default: return (byte) rnd.nextInt();
        }
    }

    public static boolean nextBoolean() {
        return rnd.nextBoolean();
    }

    public static double nextDouble() {
        switch(rnd.nextInt(20)) {
            case 0:  return 0;
            case 1:  return -0.0;
            case 2:  return Double.MIN_VALUE;
            case 3:  return Double.MAX_VALUE;
            case 4:  return Double.NaN;
            case 5:  return Double.NEGATIVE_INFINITY;
            case 6:  return Double.POSITIVE_INFINITY;
            case 7: case 8: case 9:
                     return (rnd.nextInt(20) - 10);
            default: return rnd.nextDouble();
        }
    }

    public static float nextFloat() {
        switch(rnd.nextInt(20)) {
            case 0:  return 0;
            case 1:  return -0.0f;
            case 2:  return Float.MIN_VALUE;
            case 3:  return Float.MAX_VALUE;
            case 4:  return Float.NaN;
            case 5:  return Float.NEGATIVE_INFINITY;
            case 6:  return Float.POSITIVE_INFINITY;
            case 7: case 8: case 9:
                     return (rnd.nextInt(20) - 10);
            default: return rnd.nextFloat();
        }
    }

    public static Object nextObject() {
        switch(rnd.nextInt(10)) {
            case 0:  return null;
            case 1:  return "foo";
            case 2:  case 3: case 4:
                     return Double.valueOf(nextDouble());
            default: return Integer.valueOf(nextInt());
        }
    }

    public static long[] longArray(int length) {
        long[] result = new long[length];
        for (int i = 0; i < length; i++)
            result[i] = Rnd.nextLong();
        return result;
    }

    public static int[] intArray(int length) {
        int[] result = new int[length];
        for (int i = 0; i < length; i++)
            result[i] = Rnd.nextInt();
        return result;
    }

    public static short[] shortArray(int length) {
        short[] result = new short[length];
        for (int i = 0; i < length; i++)
            result[i] = Rnd.nextShort();
        return result;
    }

    public static char[] charArray(int length) {
        char[] result = new char[length];
        for (int i = 0; i < length; i++)
            result[i] = Rnd.nextChar();
        return result;
    }

    public static byte[] byteArray(int length) {
        byte[] result = new byte[length];
        for (int i = 0; i < length; i++)
            result[i] = Rnd.nextByte();
        return result;
    }

    public static boolean[] booleanArray(int length) {
        boolean[] result = new boolean[length];
        for (int i = 0; i < length; i++)
            result[i] = Rnd.nextBoolean();
        return result;
    }

    public static double[] doubleArray(int length) {
        double[] result = new double[length];
        for (int i = 0; i < length; i++)
            result[i] = Rnd.nextDouble();
        return result;
    }

    public static float[] floatArray(int length) {
        float[] result = new float[length];
        for (int i = 0; i < length; i++)
            result[i] = Rnd.nextFloat();
        return result;
    }

    public static Object[] flatObjectArray(int length) {
        Object[] result = new Object[length];
        for (int i = 0; i < length; i++)
            result[i] = Rnd.nextObject();
        return result;
    }

    // Calling this for length >> 100 is likely to run out of memory!  It
    // should be perhaps be tuned to allow for longer arrays
    public static Object[] nestedObjectArray(int length) {
        Object[] result = new Object[length];
        for (int i = 0; i < length; i++) {
            switch(rnd.nextInt(16)) {
                case 0:  result[i] = nestedObjectArray(length/2);
                         break;
                case 1:  result[i] = longArray(length/2);
                         break;
                case 2:  result[i] = intArray(length/2);
                         break;
                case 3:  result[i] = shortArray(length/2);
                         break;
                case 4:  result[i] = charArray(length/2);
                         break;
                case 5:  result[i] = byteArray(length/2);
                         break;
                case 6:  result[i] = floatArray(length/2);
                         break;
                case 7:  result[i] = doubleArray(length/2);
                         break;
                case 8:  result[i] = longArray(length/2);
                         break;
                default: result[i] = Rnd.nextObject();
            }
        }
        return result;
    }
}

/**
 * Primitive arrays viewed as lists.  Inefficient but cool.
 * This utility should be generally useful in writing regression/unit/basic
 * tests.
 */

class PrimitiveArrays {
    public static List<Long> asList(final long[] a) {
        return new AbstractList<Long>() {
            public Long get(int i) { return a[i]; }
            public int size()      { return a.length; }

            public Long set(int i, Long e) {
                long oldVal = a[i];
                a[i] = e;
                return oldVal;
            }
        };
    }

    public static List<Integer> asList(final int[] a) {
        return new AbstractList<Integer>() {
            public Integer get(int i) { return a[i]; }
            public int size()         { return a.length; }

            public Integer set(int i, Integer e) {
                int oldVal = a[i];
                a[i] = e;
                return oldVal;
            }
        };
    }

    public static List<Short> asList(final short[] a) {
        return new AbstractList<Short>() {
            public Short get(int i) { return a[i]; }
            public int size()       { return a.length; }

            public Short set(int i, Short e) {
                short oldVal = a[i];
                a[i] = e;
                return oldVal;
            }
        };
    }

    public static List<Character> asList(final char[] a) {
        return new AbstractList<Character>() {
            public Character get(int i) { return a[i]; }
            public int size()           { return a.length; }

            public Character set(int i, Character e) {
                Character oldVal = a[i];
                a[i] = e;
                return oldVal;
            }
        };
    }

    public static List<Byte> asList(final byte[] a) {
        return new AbstractList<Byte>() {
            public Byte get(int i) { return a[i]; }
            public int size()      { return a.length; }

            public Byte set(int i, Byte e) {
                Byte oldVal = a[i];
                a[i] = e;
                return oldVal;
            }
        };
    }

    public static List<Boolean> asList(final boolean[] a) {
        return new AbstractList<Boolean>() {
            public Boolean get(int i) { return a[i]; }
            public int size()         { return a.length; }

            public Boolean set(int i, Boolean e) {
                Boolean oldVal = a[i];
                a[i] = e;
                return oldVal;
            }
        };
    }

    public static List<Double> asList(final double[] a) {
        return new AbstractList<Double>() {
            public Double get(int i) { return a[i]; }
            public int size()        { return a.length; }

            public Double set(int i, Double e) {
                Double oldVal = a[i];
                a[i] = e;
                return oldVal;
            }
        };
    }

    public static List<Float> asList(final float[] a) {
        return new AbstractList<Float>() {
            public Float get(int i) { return a[i]; }
            public int size()       { return a.length; }

            public Float set(int i, Float e) {
                Float oldVal = a[i];
                a[i] = e;
                return oldVal;
            }
        };
    }
}