Java example source code file (ArrayTypeTest.java)

This example Java source code file (ArrayTypeTest.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

arraytype, arraytypetest, exception, failed, fileinputstream, fileoutputstream, got, illegalargumentexception, management, objectinputstream, objectoutputstream, opendataexception, string

The ArrayTypeTest.java Java example source code

/*
 * 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(2, SimpleType.STRING)");
        ArrayType<String[][]> a1 = new ArrayType(2, SimpleType.STRING);
        printArrayType(a1);
        error += checkResult(index++, a1);

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

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

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

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

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

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

        System.out.println("\nArrayType<String[]> a17 = new ArrayType(1, SimpleType.STRING)");
        System.out.println("ArrayType<String[][]> a18 = new ArrayType(1, a17)");
        System.out.println("ArrayType<String[][][]> a19 = new ArrayType(1, a18)");
        ArrayType<String[]> a17 = new ArrayType(1, SimpleType.STRING);
        ArrayType<String[][]> a18 = new ArrayType(1, a17);
        ArrayType<String[][][]> a19 = new ArrayType(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(2, SimpleType.INTEGER)");
        ArrayType<Integer[][]> g1 = new ArrayType(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!");
        }
    }
}