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