/*
 * Copyright (c) 2005, 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 5045358
 * @summary Test that Open MBeans support arrays of primitive types.
 * @author Luis-Miguel Alventosa
 * @run clean ArrayTypeTest
 * @run build ArrayTypeTest
 * @run main ArrayTypeTest
 */

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import javax.management.ObjectName;
import javax.management.openmbean.ArrayType;
import javax.management.openmbean.OpenDataException;
import javax.management.openmbean.SimpleType;

public class ArrayTypeTest {

    private static final String toStringResult[] = {
        "javax.management.openmbean.ArrayType(name=[[Ljava.lang.String;,dimension=2,elementType=javax.management.openmbean.SimpleType(name=java.lang.String),primitiveArray=false)",
        "javax.management.openmbean.ArrayType(name=[I,dimension=1,elementType=javax.management.openmbean.SimpleType(name=java.lang.Integer),primitiveArray=true)",
        "javax.management.openmbean.ArrayType(name=[Ljava.lang.Integer;,dimension=1,elementType=javax.management.openmbean.SimpleType(name=java.lang.Integer),primitiveArray=false)",
        "javax.management.openmbean.ArrayType(name=[[[[I,dimension=4,elementType=javax.management.openmbean.SimpleType(name=java.lang.Integer),primitiveArray=true)",
        "javax.management.openmbean.ArrayType(name=[[[[Ljava.lang.Integer;,dimension=4,elementType=javax.management.openmbean.SimpleType(name=java.lang.Integer),primitiveArray=false)",
        "javax.management.openmbean.ArrayType(name=[Ljava.lang.String;,dimension=1,elementType=javax.management.openmbean.SimpleType(name=java.lang.String),primitiveArray=false)",
        "OpenDataException",
        "javax.management.openmbean.ArrayType(name=[Ljava.lang.Integer;,dimension=1,elementType=javax.management.openmbean.SimpleType(name=java.lang.Integer),primitiveArray=false)",
        "javax.management.openmbean.ArrayType(name=[[Ljava.lang.Integer;,dimension=2,elementType=javax.management.openmbean.SimpleType(name=java.lang.Integer),primitiveArray=false)",
        "javax.management.openmbean.ArrayType(name=[[I,dimension=2,elementType=javax.management.openmbean.SimpleType(name=java.lang.Integer),primitiveArray=true)",
        "javax.management.openmbean.ArrayType(name=[[[I,dimension=3,elementType=javax.management.openmbean.SimpleType(name=java.lang.Integer),primitiveArray=true)",
        "javax.management.openmbean.ArrayType(name=[F,dimension=1,elementType=javax.management.openmbean.SimpleType(name=java.lang.Float),primitiveArray=true)",
        "javax.management.openmbean.ArrayType(name=[[F,dimension=2,elementType=javax.management.openmbean.SimpleType(name=java.lang.Float),primitiveArray=true)",
        "javax.management.openmbean.ArrayType(name=[Ljavax.management.ObjectName;,dimension=1,elementType=javax.management.openmbean.SimpleType(name=javax.management.ObjectName),primitiveArray=false)",
        "javax.management.openmbean.ArrayType(name=[[Ljavax.management.ObjectName;,dimension=2,elementType=javax.management.openmbean.SimpleType(name=javax.management.ObjectName),primitiveArray=false)",
        "javax.management.openmbean.ArrayType(name=[[[Ljava.lang.String;,dimension=3,elementType=javax.management.openmbean.SimpleType(name=java.lang.String),primitiveArray=false)",
        "javax.management.openmbean.ArrayType(name=[[[Ljava.lang.String;,dimension=3,elementType=javax.management.openmbean.SimpleType(name=java.lang.String),primitiveArray=false)",
        "javax.management.openmbean.ArrayType(name=[I,dimension=1,elementType=javax.management.openmbean.SimpleType(name=java.lang.Integer),primitiveArray=true)",
        "javax.management.openmbean.ArrayType(name=[[Z,dimension=2,elementType=javax.management.openmbean.SimpleType(name=java.lang.Boolean),primitiveArray=true)",
        "javax.management.openmbean.ArrayType(name=[Ljava.lang.Long;,dimension=1,elementType=javax.management.openmbean.SimpleType(name=java.lang.Long),primitiveArray=false)",
        "javax.management.openmbean.ArrayType(name=[Ljava.lang.Double;,dimension=1,elementType=javax.management.openmbean.SimpleType(name=java.lang.Double),primitiveArray=false)",
    };

    private static int checkResult(int i, ArrayType a) {
        if (a.toString().equals(toStringResult[i])) {
            System.out.println("Test passed!");
            return 0;
        } else {
            System.out.println("Test failed!");
            return 1;
        }
    }

    private static int checkGetters(ArrayType a,
                                    String className,
                                    String description,
                                    String typeName,
                                    boolean isArray,
                                    boolean isPrimitiveArray,
                                    int dimension) {
        int error = 0;
        if (a.getClassName().equals(className)) {
            System.out.println("\tArrayType.getClassName() OK!");
        } else {
            System.out.println("\tArrayType.getClassName() KO!");
            System.out.println("\t\t---> expecting " + className);
            error++;
        }
        if (a.getDescription().equals(description)) {
            System.out.println("\tArrayType.getDescription() OK!");
        } else {
            System.out.println("\tArrayType.getDescription() KO!");
            System.out.println("\t\t---> expecting " + description);
            error++;
        }
        if (a.getTypeName().equals(typeName)) {
            System.out.println("\tArrayType.getTypeName() OK!");
        } else {
            System.out.println("\tArrayType.getTypeName() KO!");
            System.out.println("\t\t---> expecting " + typeName);
            error++;
        }
        if (a.isArray() == isArray) {
            System.out.println("\tArrayType.isArray() OK!");
        } else {
            System.out.println("\tArrayType.isArray() KO!");
            System.out.println("\t\t---> expecting " + isArray);
            error++;
        }
        if (a.isPrimitiveArray() == isPrimitiveArray) {
            System.out.println("\tArrayType.isPrimitiveArray() OK!");
        } else {
            System.out.println("\tArrayType.isPrimitiveArray() KO!");
            System.out.println("\t\t---> expecting " + isPrimitiveArray);
            error++;
        }
        if (a.getDimension() == dimension) {
            System.out.println("\tArrayType.getDimension() OK!");
        } else {
            System.out.println("\tArrayType.getDimension() KO!");
            System.out.println("\t\t---> expecting " + dimension);
            error++;
        }

        if (error > 0) {
            System.out.println("Test failed!");
            return 1;
        } else {
            System.out.println("Test passed!");
            return 0;
        }
    }

    private static void printArrayType(ArrayType a) {
        System.out.println("\tArrayType.getClassName() = " + a.getClassName());
        System.out.println("\tArrayType.getDescription() = " + a.getDescription());
        System.out.println("\tArrayType.getTypeName() = " + a.getTypeName());
        System.out.println("\tArrayType.isArray() = " + a.isArray());
        System.out.println("\tArrayType.isPrimitiveArray() = " + a.isPrimitiveArray());
        System.out.println("\tArrayType.getDimension() = " + a.getDimension());
    }

    public static void main(String[] args) throws Exception {

        System.out.println("\nTest that Open MBeans support arrays of primitive types.");

        int index = 0;
        int error = 0;

        //
        // Constructor tests
        //
        System.out.println("\n>>> Constructor tests");

        System.out.println("\nArrayType<String[][]> a1 = new ArrayType<String[][]>(2, SimpleType.STRING)");
        ArrayType<String[][]> a1 = new ArrayType<String[][]>(2, SimpleType.STRING);
        printArrayType(a1);
        error += checkResult(index++, a1);

        System.out.println("\nArrayType<int[]> a2 = new ArrayType<int[]>(SimpleType.INTEGER, true)");
        ArrayType<int[]> a2 = new ArrayType<int[]>(SimpleType.INTEGER, true);
        printArrayType(a2);
        error += checkResult(index++, a2);

        System.out.println("\nArrayType<Integer[]> a3 = new ArrayType<Integer[]>(SimpleType.INTEGER, false)");
        ArrayType<Integer[]> a3 = new ArrayType<Integer[]>(SimpleType.INTEGER, false);
        printArrayType(a3);
        error += checkResult(index++, a3);

        System.out.println("\nArrayType<int[][][][]> a4 = new ArrayType<int[][][][]>(3, a2)");
        ArrayType<int[][][][]> a4 = new ArrayType<int[][][][]>(3, a2);
        printArrayType(a4);
        error += checkResult(index++, a4);

        System.out.println("\nArrayType<Integer[][][][]> a5 = new ArrayType<Integer[][][][]>(3, a3)");
        ArrayType<Integer[][][][]> a5 = new ArrayType<Integer[][][][]>(3, a3);
        printArrayType(a5);
        error += checkResult(index++, a5);

        System.out.println("\nArrayType<String[]> a6 = new ArrayType<String[]>(SimpleType.STRING, false)");
        ArrayType<String[]> a6 = new ArrayType<String[]>(SimpleType.STRING, false);
        printArrayType(a6);
        error += checkResult(index++, a6);

        System.out.println("\nArrayType<String[]> a7 = new ArrayType<String[]>(SimpleType.STRING, true)");
        index++; // skip this dummy entry in the toStringResult array
        try {
            ArrayType<String[]> a7 =
                new ArrayType<String[]>(SimpleType.STRING, true);
            System.out.println("\tDid not get expected OpenDataException!");
            System.out.println("Test failed!");
            error++;
        } catch (OpenDataException e) {
            System.out.println("\tGot expected OpenDataException: " + e);
            System.out.println("Test passed!");
        }

        //
        // Factory tests
        //
        System.out.println("\n>>> Factory tests");

        System.out.println("\nArrayType<Integer[]> a8 = ArrayType.getArrayType(SimpleType.INTEGER)");
        ArrayType<Integer[]> a8 = ArrayType.getArrayType(SimpleType.INTEGER);
        printArrayType(a8);
        error += checkResult(index++, a8);

        System.out.println("\nArrayType<Integer[][]> a9 = ArrayType.getArrayType(a8)");
        ArrayType<Integer[][]> a9 = ArrayType.getArrayType(a8);
        printArrayType(a9);
        error += checkResult(index++, a9);

        System.out.println("\nArrayType<int[][]> a10 = ArrayType.getPrimitiveArrayType(int[][].class)");
        ArrayType<int[][]> a10 = ArrayType.getPrimitiveArrayType(int[][].class);
        printArrayType(a10);
        error += checkResult(index++, a10);

        System.out.println("\nArrayType<int[][][]> a11 = ArrayType.getArrayType(a10)");
        ArrayType<int[][][]> a11 = ArrayType.getArrayType(a10);
        printArrayType(a11);
        error += checkResult(index++, a11);

        System.out.println("\nArrayType<float[]> a12 = ArrayType.getPrimitiveArrayType(float[].class)");
        ArrayType<float[]> a12 = ArrayType.getPrimitiveArrayType(float[].class);
        printArrayType(a12);
        error += checkResult(index++, a12);

        System.out.println("\nArrayType<float[][]> a13 = ArrayType.getArrayType(a12)");
        ArrayType<float[][]> a13 = ArrayType.getArrayType(a12);
        printArrayType(a13);
        error += checkResult(index++, a13);

        System.out.println("\nArrayType<ObjectName[]> a14 = ArrayType.getArrayType(SimpleType.OBJECTNAME)");
        ArrayType<ObjectName[]> a14 = ArrayType.getArrayType(SimpleType.OBJECTNAME);
        printArrayType(a14);
        error += checkResult(index++, a14);

        System.out.println("\nArrayType<ObjectName[][]> a15 = ArrayType.getArrayType(a14)");
        ArrayType<ObjectName[][]> a15 = ArrayType.getArrayType(a14);
        printArrayType(a15);
        error += checkResult(index++, a15);

        System.out.println("\nArrayType<String[][][]> a16 = new ArrayType<String[][][]>(3, SimpleType.STRING)");
        ArrayType<String[][][]> a16 = new ArrayType<String[][][]>(3, SimpleType.STRING);
        printArrayType(a16);
        error += checkResult(index++, a16);

        System.out.println("\nArrayType<String[]> a17 = new ArrayType<String[]>(1, SimpleType.STRING)");
        System.out.println("ArrayType<String[][]> a18 = new ArrayType<String[][]>(1, a17)");
        System.out.println("ArrayType<String[][][]> a19 = new ArrayType<String[][][]>(1, a18)");
        ArrayType<String[]> a17 = new ArrayType<String[]>(1, SimpleType.STRING);
        ArrayType<String[][]> a18 = new ArrayType<String[][]>(1, a17);
        ArrayType<String[][][]> a19 = new ArrayType<String[][][]>(1, a18);
        printArrayType(a19);
        error += checkResult(index++, a19);

        //
        // Serialization tests
        //
        System.out.println("\n>>> Serialization tests\n");

        ArrayType<int[]> i1 = ArrayType.getPrimitiveArrayType(int[].class);
        ArrayType<int[]> i2 = null;

        ArrayType<boolean[][]> b1 = ArrayType.getPrimitiveArrayType(boolean[][].class);
        ArrayType<boolean[][]> b2 = null;

        ArrayType<Long[]> l1 = ArrayType.getArrayType(SimpleType.LONG);
        ArrayType<Long[]> l2 = null;

        ArrayType<Double[]> d1 = ArrayType.getArrayType(SimpleType.DOUBLE);
        ArrayType<Double[]> d2 = null;

        // serialize the objects
        try {
            FileOutputStream fo = new FileOutputStream("serial.tmp");
            ObjectOutputStream so = new ObjectOutputStream(fo);
            System.out.println("Serialize ArrayType<int[]> i1 = ArrayType.getPrimitiveArrayType(int[].class)");
            so.writeObject(i1);
            System.out.println("Serialize ArrayType<boolean[][]> b1 = ArrayType.getPrimitiveArrayType(boolean[][].class)");
            so.writeObject(b1);
            System.out.println("Serialize ArrayType<Long[]> l1 = ArrayType.getArrayType(SimpleType.LONG)");
            so.writeObject(l1);
            System.out.println("Serialize ArrayType<Double[]> d1 = ArrayType.getArrayType(SimpleType.DOUBLE)");
            so.writeObject(d1);
            so.flush();
        } catch (Exception e) {
            System.out.println(e);
            System.exit(1);
        }

        // deserialize the objects
        try {
            FileInputStream fi = new FileInputStream("serial.tmp");
            ObjectInputStream si = new ObjectInputStream(fi);
            System.out.println("Deserialize ArrayType<int[]> i1 = ArrayType.getPrimitiveArrayType(int[].class)");
            i2 = (ArrayType<int[]>) si.readObject();
            System.out.println("Deserialize ArrayType<boolean[][]> b1 = ArrayType.getPrimitiveArrayType(boolean[][].class)");
            b2 = (ArrayType<boolean[][]>) si.readObject();
            System.out.println("Deserialize ArrayType<Long[]> l1 = ArrayType.getArrayType(SimpleType.LONG)");
            l2 = (ArrayType<Long[]>) si.readObject();
            System.out.println("Deserialize ArrayType<Double[]> d1 = ArrayType.getArrayType(SimpleType.DOUBLE)");
            d2 = (ArrayType<Double[]>) si.readObject();
        } catch (Exception e) {
            System.out.println(e);
            System.exit(1);
        }

        if (i1.toString().equals(toStringResult[index++]) &&
            i1.toString().equals(i2.toString())) {
            System.out.println("Test passed for ArrayType<int[]> i1 = ArrayType.getPrimitiveArrayType(int[].class)");
        } else {
            System.out.println("Test failed for ArrayType<int[]> i1 = ArrayType.getPrimitiveArrayType(int[].class)");
            error++;
        }
        if (b1.toString().equals(toStringResult[index++]) &&
            b1.toString().equals(b2.toString())) {
            System.out.println("Test passed for ArrayType<boolean[][]> b1 = ArrayType.getPrimitiveArrayType(boolean[][].class)");
        } else {
            System.out.println("Test failed for ArrayType<boolean[][]> b1 = ArrayType.getPrimitiveArrayType(boolean[][].class)");
            error++;
        }
        if (l1.toString().equals(toStringResult[index++]) &&
            l1.toString().equals(l2.toString())) {
            System.out.println("Test passed for ArrayType<Long[]> l1 = ArrayType.getArrayType(SimpleType.LONG)");
        } else {
            System.out.println("Test failed for ArrayType<Long[]> l1 = ArrayType.getArrayType(SimpleType.LONG)");
            error++;
        }
        if (d1.toString().equals(toStringResult[index++]) &&
            d1.toString().equals(d2.toString())) {
            System.out.println("Test passed for ArrayType<Double[]> d1 = ArrayType.getArrayType(SimpleType.DOUBLE)");
        } else {
            System.out.println("Test failed for ArrayType<Double[]> d1 = ArrayType.getArrayType(SimpleType.DOUBLE)");
            error++;
        }

        //
        // Test getters
        //
        System.out.println("\n>>> Getter tests");

        System.out.println("\nArrayType<Integer[][]> g1 = new ArrayType<Integer[][]>(2, SimpleType.INTEGER)");
        ArrayType<Integer[][]> g1 = new ArrayType<Integer[][]>(2, SimpleType.INTEGER);
        printArrayType(g1);
        error += checkGetters(g1,
                              "[[Ljava.lang.Integer;",
                              "2-dimension array of java.lang.Integer",
                              "[[Ljava.lang.Integer;",
                              true,
                              false,
                              2);

        System.out.println("\nArrayType<int[][]> g2 = ArrayType.getPrimitiveArrayType(int[][].class)");
        ArrayType<int[][]> g2 = ArrayType.getPrimitiveArrayType(int[][].class);
        printArrayType(g2);
        error += checkGetters(g2,
                              "[[I",
                              "2-dimension array of int",
                              "[[I",
                              true,
                              true,
                              2);

        if (error > 0) {
            final String msg = "\nTest FAILED! Got " + error + " error(s)";
            System.out.println(msg);
            throw new IllegalArgumentException(msg);
        } else {
            System.out.println("\nTest PASSED!");
        }
    }
}