1 /*
2  * Copyright (c) 2005, 2015, Oracle and/or its affiliates. All rights reserved.
3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4  *
5  * This code is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License version 2 only, as
7  * published by the Free Software Foundation.
8  *
9  * This code is distributed in the hope that it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12  * version 2 for more details (a copy is included in the LICENSE file that
13  * accompanied this code).
14  *
15  * You should have received a copy of the GNU General Public License version
16  * 2 along with this work; if not, write to the Free Software Foundation,
17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18  *
19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20  * or visit www.oracle.com if you need additional information or have any
21  * questions.
22  */
23 
24 /*
25  * @test
26  * @bug 5045358
27  * @summary Test that Open MBeans support arrays of primitive types.
28  * @author Luis-Miguel Alventosa
29  *
30  * @run clean ArrayTypeTest
31  * @run build ArrayTypeTest
32  * @run main ArrayTypeTest
33  */
34 
35 import java.io.FileInputStream;
36 import java.io.FileOutputStream;
37 import java.io.ObjectInputStream;
38 import java.io.ObjectOutputStream;
39 import javax.management.ObjectName;
40 import javax.management.openmbean.ArrayType;
41 import javax.management.openmbean.OpenDataException;
42 import javax.management.openmbean.SimpleType;
43 
44 public class ArrayTypeTest {
45 
46     private static final String toStringResult[] = {
47         "javax.management.openmbean.ArrayType(name=[[Ljava.lang.String;,dimension=2,elementType=javax.management.openmbean.SimpleType(name=java.lang.String),primitiveArray=false)",
48         "javax.management.openmbean.ArrayType(name=[I,dimension=1,elementType=javax.management.openmbean.SimpleType(name=java.lang.Integer),primitiveArray=true)",
49         "javax.management.openmbean.ArrayType(name=[Ljava.lang.Integer;,dimension=1,elementType=javax.management.openmbean.SimpleType(name=java.lang.Integer),primitiveArray=false)",
50         "javax.management.openmbean.ArrayType(name=[[[[I,dimension=4,elementType=javax.management.openmbean.SimpleType(name=java.lang.Integer),primitiveArray=true)",
51         "javax.management.openmbean.ArrayType(name=[[[[Ljava.lang.Integer;,dimension=4,elementType=javax.management.openmbean.SimpleType(name=java.lang.Integer),primitiveArray=false)",
52         "javax.management.openmbean.ArrayType(name=[Ljava.lang.String;,dimension=1,elementType=javax.management.openmbean.SimpleType(name=java.lang.String),primitiveArray=false)",
53         "OpenDataException",
54         "javax.management.openmbean.ArrayType(name=[Ljava.lang.Integer;,dimension=1,elementType=javax.management.openmbean.SimpleType(name=java.lang.Integer),primitiveArray=false)",
55         "javax.management.openmbean.ArrayType(name=[[Ljava.lang.Integer;,dimension=2,elementType=javax.management.openmbean.SimpleType(name=java.lang.Integer),primitiveArray=false)",
56         "javax.management.openmbean.ArrayType(name=[[I,dimension=2,elementType=javax.management.openmbean.SimpleType(name=java.lang.Integer),primitiveArray=true)",
57         "javax.management.openmbean.ArrayType(name=[[[I,dimension=3,elementType=javax.management.openmbean.SimpleType(name=java.lang.Integer),primitiveArray=true)",
58         "javax.management.openmbean.ArrayType(name=[F,dimension=1,elementType=javax.management.openmbean.SimpleType(name=java.lang.Float),primitiveArray=true)",
59         "javax.management.openmbean.ArrayType(name=[[F,dimension=2,elementType=javax.management.openmbean.SimpleType(name=java.lang.Float),primitiveArray=true)",
60         "javax.management.openmbean.ArrayType(name=[Ljavax.management.ObjectName;,dimension=1,elementType=javax.management.openmbean.SimpleType(name=javax.management.ObjectName),primitiveArray=false)",
61         "javax.management.openmbean.ArrayType(name=[[Ljavax.management.ObjectName;,dimension=2,elementType=javax.management.openmbean.SimpleType(name=javax.management.ObjectName),primitiveArray=false)",
62         "javax.management.openmbean.ArrayType(name=[[[Ljava.lang.String;,dimension=3,elementType=javax.management.openmbean.SimpleType(name=java.lang.String),primitiveArray=false)",
63         "javax.management.openmbean.ArrayType(name=[[[Ljava.lang.String;,dimension=3,elementType=javax.management.openmbean.SimpleType(name=java.lang.String),primitiveArray=false)",
64         "javax.management.openmbean.ArrayType(name=[I,dimension=1,elementType=javax.management.openmbean.SimpleType(name=java.lang.Integer),primitiveArray=true)",
65         "javax.management.openmbean.ArrayType(name=[[Z,dimension=2,elementType=javax.management.openmbean.SimpleType(name=java.lang.Boolean),primitiveArray=true)",
66         "javax.management.openmbean.ArrayType(name=[Ljava.lang.Long;,dimension=1,elementType=javax.management.openmbean.SimpleType(name=java.lang.Long),primitiveArray=false)",
67         "javax.management.openmbean.ArrayType(name=[Ljava.lang.Double;,dimension=1,elementType=javax.management.openmbean.SimpleType(name=java.lang.Double),primitiveArray=false)",
68     };
69 
checkResult(int i, ArrayType a)70     private static int checkResult(int i, ArrayType a) {
71         if (a.toString().equals(toStringResult[i])) {
72             System.out.println("Test passed!");
73             return 0;
74         } else {
75             System.out.println("Test failed!");
76             return 1;
77         }
78     }
79 
checkGetters(ArrayType a, String className, String description, String typeName, boolean isArray, boolean isPrimitiveArray, int dimension)80     private static int checkGetters(ArrayType a,
81                                     String className,
82                                     String description,
83                                     String typeName,
84                                     boolean isArray,
85                                     boolean isPrimitiveArray,
86                                     int dimension) {
87         int error = 0;
88         if (a.getClassName().equals(className)) {
89             System.out.println("\tArrayType.getClassName() OK!");
90         } else {
91             System.out.println("\tArrayType.getClassName() KO!");
92             System.out.println("\t\t---> expecting " + className);
93             error++;
94         }
95         if (a.getDescription().equals(description)) {
96             System.out.println("\tArrayType.getDescription() OK!");
97         } else {
98             System.out.println("\tArrayType.getDescription() KO!");
99             System.out.println("\t\t---> expecting " + description);
100             error++;
101         }
102         if (a.getTypeName().equals(typeName)) {
103             System.out.println("\tArrayType.getTypeName() OK!");
104         } else {
105             System.out.println("\tArrayType.getTypeName() KO!");
106             System.out.println("\t\t---> expecting " + typeName);
107             error++;
108         }
109         if (a.isArray() == isArray) {
110             System.out.println("\tArrayType.isArray() OK!");
111         } else {
112             System.out.println("\tArrayType.isArray() KO!");
113             System.out.println("\t\t---> expecting " + isArray);
114             error++;
115         }
116         if (a.isPrimitiveArray() == isPrimitiveArray) {
117             System.out.println("\tArrayType.isPrimitiveArray() OK!");
118         } else {
119             System.out.println("\tArrayType.isPrimitiveArray() KO!");
120             System.out.println("\t\t---> expecting " + isPrimitiveArray);
121             error++;
122         }
123         if (a.getDimension() == dimension) {
124             System.out.println("\tArrayType.getDimension() OK!");
125         } else {
126             System.out.println("\tArrayType.getDimension() KO!");
127             System.out.println("\t\t---> expecting " + dimension);
128             error++;
129         }
130 
131         if (error > 0) {
132             System.out.println("Test failed!");
133             return 1;
134         } else {
135             System.out.println("Test passed!");
136             return 0;
137         }
138     }
139 
printArrayType(ArrayType a)140     private static void printArrayType(ArrayType a) {
141         System.out.println("\tArrayType.getClassName() = " + a.getClassName());
142         System.out.println("\tArrayType.getDescription() = " + a.getDescription());
143         System.out.println("\tArrayType.getTypeName() = " + a.getTypeName());
144         System.out.println("\tArrayType.isArray() = " + a.isArray());
145         System.out.println("\tArrayType.isPrimitiveArray() = " + a.isPrimitiveArray());
146         System.out.println("\tArrayType.getDimension() = " + a.getDimension());
147     }
148 
main(String[] args)149     public static void main(String[] args) throws Exception {
150 
151         System.out.println("\nTest that Open MBeans support arrays of primitive types.");
152 
153         int index = 0;
154         int error = 0;
155 
156         //
157         // Constructor tests
158         //
159         System.out.println("\n>>> Constructor tests");
160 
161         System.out.println("\nArrayType<String[][]> a1 = new ArrayType<String[][]>(2, SimpleType.STRING)");
162         ArrayType<String[][]> a1 = new ArrayType<String[][]>(2, SimpleType.STRING);
163         printArrayType(a1);
164         error += checkResult(index++, a1);
165 
166         System.out.println("\nArrayType<int[]> a2 = new ArrayType<int[]>(SimpleType.INTEGER, true)");
167         ArrayType<int[]> a2 = new ArrayType<int[]>(SimpleType.INTEGER, true);
168         printArrayType(a2);
169         error += checkResult(index++, a2);
170 
171         System.out.println("\nArrayType<Integer[]> a3 = new ArrayType<Integer[]>(SimpleType.INTEGER, false)");
172         ArrayType<Integer[]> a3 = new ArrayType<Integer[]>(SimpleType.INTEGER, false);
173         printArrayType(a3);
174         error += checkResult(index++, a3);
175 
176         System.out.println("\nArrayType<int[][][][]> a4 = new ArrayType<int[][][][]>(3, a2)");
177         ArrayType<int[][][][]> a4 = new ArrayType<int[][][][]>(3, a2);
178         printArrayType(a4);
179         error += checkResult(index++, a4);
180 
181         System.out.println("\nArrayType<Integer[][][][]> a5 = new ArrayType<Integer[][][][]>(3, a3)");
182         ArrayType<Integer[][][][]> a5 = new ArrayType<Integer[][][][]>(3, a3);
183         printArrayType(a5);
184         error += checkResult(index++, a5);
185 
186         System.out.println("\nArrayType<String[]> a6 = new ArrayType<String[]>(SimpleType.STRING, false)");
187         ArrayType<String[]> a6 = new ArrayType<String[]>(SimpleType.STRING, false);
188         printArrayType(a6);
189         error += checkResult(index++, a6);
190 
191         System.out.println("\nArrayType<String[]> a7 = new ArrayType<String[]>(SimpleType.STRING, true)");
192         index++; // skip this dummy entry in the toStringResult array
193         try {
194             ArrayType<String[]> a7 =
195                 new ArrayType<String[]>(SimpleType.STRING, true);
196             System.out.println("\tDid not get expected OpenDataException!");
197             System.out.println("Test failed!");
198             error++;
199         } catch (OpenDataException e) {
200             System.out.println("\tGot expected OpenDataException: " + e);
201             System.out.println("Test passed!");
202         }
203 
204         //
205         // Factory tests
206         //
207         System.out.println("\n>>> Factory tests");
208 
209         System.out.println("\nArrayType<Integer[]> a8 = ArrayType.getArrayType(SimpleType.INTEGER)");
210         ArrayType<Integer[]> a8 = ArrayType.getArrayType(SimpleType.INTEGER);
211         printArrayType(a8);
212         error += checkResult(index++, a8);
213 
214         System.out.println("\nArrayType<Integer[][]> a9 = ArrayType.getArrayType(a8)");
215         ArrayType<Integer[][]> a9 = ArrayType.getArrayType(a8);
216         printArrayType(a9);
217         error += checkResult(index++, a9);
218 
219         System.out.println("\nArrayType<int[][]> a10 = ArrayType.getPrimitiveArrayType(int[][].class)");
220         ArrayType<int[][]> a10 = ArrayType.getPrimitiveArrayType(int[][].class);
221         printArrayType(a10);
222         error += checkResult(index++, a10);
223 
224         System.out.println("\nArrayType<int[][][]> a11 = ArrayType.getArrayType(a10)");
225         ArrayType<int[][][]> a11 = ArrayType.getArrayType(a10);
226         printArrayType(a11);
227         error += checkResult(index++, a11);
228 
229         System.out.println("\nArrayType<float[]> a12 = ArrayType.getPrimitiveArrayType(float[].class)");
230         ArrayType<float[]> a12 = ArrayType.getPrimitiveArrayType(float[].class);
231         printArrayType(a12);
232         error += checkResult(index++, a12);
233 
234         System.out.println("\nArrayType<float[][]> a13 = ArrayType.getArrayType(a12)");
235         ArrayType<float[][]> a13 = ArrayType.getArrayType(a12);
236         printArrayType(a13);
237         error += checkResult(index++, a13);
238 
239         System.out.println("\nArrayType<ObjectName[]> a14 = ArrayType.getArrayType(SimpleType.OBJECTNAME)");
240         ArrayType<ObjectName[]> a14 = ArrayType.getArrayType(SimpleType.OBJECTNAME);
241         printArrayType(a14);
242         error += checkResult(index++, a14);
243 
244         System.out.println("\nArrayType<ObjectName[][]> a15 = ArrayType.getArrayType(a14)");
245         ArrayType<ObjectName[][]> a15 = ArrayType.getArrayType(a14);
246         printArrayType(a15);
247         error += checkResult(index++, a15);
248 
249         System.out.println("\nArrayType<String[][][]> a16 = new ArrayType<String[][][]>(3, SimpleType.STRING)");
250         ArrayType<String[][][]> a16 = new ArrayType<String[][][]>(3, SimpleType.STRING);
251         printArrayType(a16);
252         error += checkResult(index++, a16);
253 
254         System.out.println("\nArrayType<String[]> a17 = new ArrayType<String[]>(1, SimpleType.STRING)");
255         System.out.println("ArrayType<String[][]> a18 = new ArrayType<String[][]>(1, a17)");
256         System.out.println("ArrayType<String[][][]> a19 = new ArrayType<String[][][]>(1, a18)");
257         ArrayType<String[]> a17 = new ArrayType<String[]>(1, SimpleType.STRING);
258         ArrayType<String[][]> a18 = new ArrayType<String[][]>(1, a17);
259         ArrayType<String[][][]> a19 = new ArrayType<String[][][]>(1, a18);
260         printArrayType(a19);
261         error += checkResult(index++, a19);
262 
263         //
264         // Serialization tests
265         //
266         System.out.println("\n>>> Serialization tests\n");
267 
268         ArrayType<int[]> i1 = ArrayType.getPrimitiveArrayType(int[].class);
269         ArrayType<int[]> i2 = null;
270 
271         ArrayType<boolean[][]> b1 = ArrayType.getPrimitiveArrayType(boolean[][].class);
272         ArrayType<boolean[][]> b2 = null;
273 
274         ArrayType<Long[]> l1 = ArrayType.getArrayType(SimpleType.LONG);
275         ArrayType<Long[]> l2 = null;
276 
277         ArrayType<Double[]> d1 = ArrayType.getArrayType(SimpleType.DOUBLE);
278         ArrayType<Double[]> d2 = null;
279 
280         // serialize the objects
281         try {
282             FileOutputStream fo = new FileOutputStream("serial.tmp");
283             ObjectOutputStream so = new ObjectOutputStream(fo);
284             System.out.println("Serialize ArrayType<int[]> i1 = ArrayType.getPrimitiveArrayType(int[].class)");
285             so.writeObject(i1);
286             System.out.println("Serialize ArrayType<boolean[][]> b1 = ArrayType.getPrimitiveArrayType(boolean[][].class)");
287             so.writeObject(b1);
288             System.out.println("Serialize ArrayType<Long[]> l1 = ArrayType.getArrayType(SimpleType.LONG)");
289             so.writeObject(l1);
290             System.out.println("Serialize ArrayType<Double[]> d1 = ArrayType.getArrayType(SimpleType.DOUBLE)");
291             so.writeObject(d1);
292             so.flush();
293         } catch (Exception e) {
294             System.out.println(e);
295             System.exit(1);
296         }
297 
298         // deserialize the objects
299         try {
300             FileInputStream fi = new FileInputStream("serial.tmp");
301             ObjectInputStream si = new ObjectInputStream(fi);
302             System.out.println("Deserialize ArrayType<int[]> i1 = ArrayType.getPrimitiveArrayType(int[].class)");
303             i2 = (ArrayType<int[]>) si.readObject();
304             System.out.println("Deserialize ArrayType<boolean[][]> b1 = ArrayType.getPrimitiveArrayType(boolean[][].class)");
305             b2 = (ArrayType<boolean[][]>) si.readObject();
306             System.out.println("Deserialize ArrayType<Long[]> l1 = ArrayType.getArrayType(SimpleType.LONG)");
307             l2 = (ArrayType<Long[]>) si.readObject();
308             System.out.println("Deserialize ArrayType<Double[]> d1 = ArrayType.getArrayType(SimpleType.DOUBLE)");
309             d2 = (ArrayType<Double[]>) si.readObject();
310         } catch (Exception e) {
311             System.out.println(e);
312             System.exit(1);
313         }
314 
315         if (i1.toString().equals(toStringResult[index++]) &&
316             i1.toString().equals(i2.toString())) {
317             System.out.println("Test passed for ArrayType<int[]> i1 = ArrayType.getPrimitiveArrayType(int[].class)");
318         } else {
319             System.out.println("Test failed for ArrayType<int[]> i1 = ArrayType.getPrimitiveArrayType(int[].class)");
320             error++;
321         }
322         if (b1.toString().equals(toStringResult[index++]) &&
323             b1.toString().equals(b2.toString())) {
324             System.out.println("Test passed for ArrayType<boolean[][]> b1 = ArrayType.getPrimitiveArrayType(boolean[][].class)");
325         } else {
326             System.out.println("Test failed for ArrayType<boolean[][]> b1 = ArrayType.getPrimitiveArrayType(boolean[][].class)");
327             error++;
328         }
329         if (l1.toString().equals(toStringResult[index++]) &&
330             l1.toString().equals(l2.toString())) {
331             System.out.println("Test passed for ArrayType<Long[]> l1 = ArrayType.getArrayType(SimpleType.LONG)");
332         } else {
333             System.out.println("Test failed for ArrayType<Long[]> l1 = ArrayType.getArrayType(SimpleType.LONG)");
334             error++;
335         }
336         if (d1.toString().equals(toStringResult[index++]) &&
337             d1.toString().equals(d2.toString())) {
338             System.out.println("Test passed for ArrayType<Double[]> d1 = ArrayType.getArrayType(SimpleType.DOUBLE)");
339         } else {
340             System.out.println("Test failed for ArrayType<Double[]> d1 = ArrayType.getArrayType(SimpleType.DOUBLE)");
341             error++;
342         }
343 
344         //
345         // Test getters
346         //
347         System.out.println("\n>>> Getter tests");
348 
349         System.out.println("\nArrayType<Integer[][]> g1 = new ArrayType<Integer[][]>(2, SimpleType.INTEGER)");
350         ArrayType<Integer[][]> g1 = new ArrayType<Integer[][]>(2, SimpleType.INTEGER);
351         printArrayType(g1);
352         error += checkGetters(g1,
353                               "[[Ljava.lang.Integer;",
354                               "2-dimension array of java.lang.Integer",
355                               "[[Ljava.lang.Integer;",
356                               true,
357                               false,
358                               2);
359 
360         System.out.println("\nArrayType<int[][]> g2 = ArrayType.getPrimitiveArrayType(int[][].class)");
361         ArrayType<int[][]> g2 = ArrayType.getPrimitiveArrayType(int[][].class);
362         printArrayType(g2);
363         error += checkGetters(g2,
364                               "[[I",
365                               "2-dimension array of int",
366                               "[[I",
367                               true,
368                               true,
369                               2);
370 
371         if (error > 0) {
372             final String msg = "\nTest FAILED! Got " + error + " error(s)";
373             System.out.println(msg);
374             throw new IllegalArgumentException(msg);
375         } else {
376             System.out.println("\nTest PASSED!");
377         }
378     }
379 }
380