/*

 * 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!");

        }

    }

}