|
1 /* |
|
2 * Copyright 2005 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, |
|
20 * CA 95054 USA or visit www.sun.com if you need additional information or |
|
21 * have any questions. |
|
22 */ |
|
23 |
|
24 /* |
|
25 * @test |
|
26 * @bug 6266438 |
|
27 * @summary Query.match code for character sequences like [a-z] is wrong. |
|
28 * @author Luis-Miguel Alventosa |
|
29 * @run clean QueryMatchTest |
|
30 * @run build QueryMatchTest |
|
31 * @run main QueryMatchTest |
|
32 */ |
|
33 |
|
34 import java.lang.management.ManagementFactory; |
|
35 import javax.management.MBeanServer; |
|
36 import javax.management.ObjectName; |
|
37 import javax.management.Query; |
|
38 import javax.management.QueryExp; |
|
39 |
|
40 public class QueryMatchTest { |
|
41 |
|
42 public static interface SimpleMBean { |
|
43 public String getStringNumber(); |
|
44 } |
|
45 |
|
46 public static class Simple implements SimpleMBean { |
|
47 public Simple(String number) { |
|
48 this.number = number; |
|
49 } |
|
50 public String getStringNumber() { |
|
51 return number; |
|
52 } |
|
53 private String number; |
|
54 } |
|
55 |
|
56 // Pattern = 2[7-9] |
|
57 private static String[][] data11 = { |
|
58 { "20", "KO" }, |
|
59 { "21", "KO" }, |
|
60 { "22", "KO" }, |
|
61 { "23", "KO" }, |
|
62 { "24", "KO" }, |
|
63 { "25", "KO" }, |
|
64 { "26", "KO" }, |
|
65 { "27", "OK" }, |
|
66 { "28", "OK" }, |
|
67 { "29", "OK" }, |
|
68 { "2-", "KO" }, |
|
69 }; |
|
70 |
|
71 // Pattern = 2[7-9]5 |
|
72 private static String[][] data12 = { |
|
73 { "205", "KO" }, |
|
74 { "215", "KO" }, |
|
75 { "225", "KO" }, |
|
76 { "235", "KO" }, |
|
77 { "245", "KO" }, |
|
78 { "255", "KO" }, |
|
79 { "265", "KO" }, |
|
80 { "275", "OK" }, |
|
81 { "285", "OK" }, |
|
82 { "295", "OK" }, |
|
83 { "2-5", "KO" }, |
|
84 }; |
|
85 |
|
86 // Pattern = 2[-9] |
|
87 private static String[][] data13 = { |
|
88 { "20", "KO" }, |
|
89 { "21", "KO" }, |
|
90 { "22", "KO" }, |
|
91 { "23", "KO" }, |
|
92 { "24", "KO" }, |
|
93 { "25", "KO" }, |
|
94 { "26", "KO" }, |
|
95 { "27", "KO" }, |
|
96 { "28", "KO" }, |
|
97 { "29", "OK" }, |
|
98 { "2-", "OK" }, |
|
99 }; |
|
100 |
|
101 // Pattern = 2[-9]5 |
|
102 private static String[][] data14 = { |
|
103 { "205", "KO" }, |
|
104 { "215", "KO" }, |
|
105 { "225", "KO" }, |
|
106 { "235", "KO" }, |
|
107 { "245", "KO" }, |
|
108 { "255", "KO" }, |
|
109 { "265", "KO" }, |
|
110 { "275", "KO" }, |
|
111 { "285", "KO" }, |
|
112 { "295", "OK" }, |
|
113 { "2-5", "OK" }, |
|
114 }; |
|
115 |
|
116 // Pattern = 2[9-] |
|
117 private static String[][] data15 = { |
|
118 { "20", "KO" }, |
|
119 { "21", "KO" }, |
|
120 { "22", "KO" }, |
|
121 { "23", "KO" }, |
|
122 { "24", "KO" }, |
|
123 { "25", "KO" }, |
|
124 { "26", "KO" }, |
|
125 { "27", "KO" }, |
|
126 { "28", "KO" }, |
|
127 { "29", "OK" }, |
|
128 { "2-", "OK" }, |
|
129 }; |
|
130 |
|
131 // Pattern = 2[9-]5 |
|
132 private static String[][] data16 = { |
|
133 { "205", "KO" }, |
|
134 { "215", "KO" }, |
|
135 { "225", "KO" }, |
|
136 { "235", "KO" }, |
|
137 { "245", "KO" }, |
|
138 { "255", "KO" }, |
|
139 { "265", "KO" }, |
|
140 { "275", "KO" }, |
|
141 { "285", "KO" }, |
|
142 { "295", "OK" }, |
|
143 { "2-5", "OK" }, |
|
144 }; |
|
145 |
|
146 // Pattern = 2[-] |
|
147 private static String[][] data17 = { |
|
148 { "20", "KO" }, |
|
149 { "21", "KO" }, |
|
150 { "22", "KO" }, |
|
151 { "23", "KO" }, |
|
152 { "24", "KO" }, |
|
153 { "25", "KO" }, |
|
154 { "26", "KO" }, |
|
155 { "27", "KO" }, |
|
156 { "28", "KO" }, |
|
157 { "29", "KO" }, |
|
158 { "2-", "OK" }, |
|
159 }; |
|
160 |
|
161 // Pattern = 2[-]5 |
|
162 private static String[][] data18 = { |
|
163 { "205", "KO" }, |
|
164 { "215", "KO" }, |
|
165 { "225", "KO" }, |
|
166 { "235", "KO" }, |
|
167 { "245", "KO" }, |
|
168 { "255", "KO" }, |
|
169 { "265", "KO" }, |
|
170 { "275", "KO" }, |
|
171 { "285", "KO" }, |
|
172 { "295", "KO" }, |
|
173 { "2-5", "OK" }, |
|
174 }; |
|
175 |
|
176 // Pattern = 2[1-36-8] |
|
177 private static String[][] data19 = { |
|
178 { "20", "KO" }, |
|
179 { "21", "OK" }, |
|
180 { "22", "OK" }, |
|
181 { "23", "OK" }, |
|
182 { "24", "KO" }, |
|
183 { "25", "KO" }, |
|
184 { "26", "OK" }, |
|
185 { "27", "OK" }, |
|
186 { "28", "OK" }, |
|
187 { "29", "KO" }, |
|
188 { "2-", "KO" }, |
|
189 }; |
|
190 |
|
191 // Pattern = 2[1-36-8]5 |
|
192 private static String[][] data20 = { |
|
193 { "205", "KO" }, |
|
194 { "215", "OK" }, |
|
195 { "225", "OK" }, |
|
196 { "235", "OK" }, |
|
197 { "245", "KO" }, |
|
198 { "255", "KO" }, |
|
199 { "265", "OK" }, |
|
200 { "275", "OK" }, |
|
201 { "285", "OK" }, |
|
202 { "295", "KO" }, |
|
203 { "2-5", "KO" }, |
|
204 }; |
|
205 |
|
206 // Pattern = 2[!7-9] |
|
207 private static String[][] data21 = { |
|
208 { "20", "OK" }, |
|
209 { "21", "OK" }, |
|
210 { "22", "OK" }, |
|
211 { "23", "OK" }, |
|
212 { "24", "OK" }, |
|
213 { "25", "OK" }, |
|
214 { "26", "OK" }, |
|
215 { "27", "KO" }, |
|
216 { "28", "KO" }, |
|
217 { "29", "KO" }, |
|
218 { "2-", "OK" }, |
|
219 }; |
|
220 |
|
221 // Pattern = 2[!7-9]5 |
|
222 private static String[][] data22 = { |
|
223 { "205", "OK" }, |
|
224 { "215", "OK" }, |
|
225 { "225", "OK" }, |
|
226 { "235", "OK" }, |
|
227 { "245", "OK" }, |
|
228 { "255", "OK" }, |
|
229 { "265", "OK" }, |
|
230 { "275", "KO" }, |
|
231 { "285", "KO" }, |
|
232 { "295", "KO" }, |
|
233 { "2-5", "OK" }, |
|
234 }; |
|
235 |
|
236 // Pattern = 2[!-9] |
|
237 private static String[][] data23 = { |
|
238 { "20", "OK" }, |
|
239 { "21", "OK" }, |
|
240 { "22", "OK" }, |
|
241 { "23", "OK" }, |
|
242 { "24", "OK" }, |
|
243 { "25", "OK" }, |
|
244 { "26", "OK" }, |
|
245 { "27", "OK" }, |
|
246 { "28", "OK" }, |
|
247 { "29", "KO" }, |
|
248 { "2-", "KO" }, |
|
249 }; |
|
250 |
|
251 // Pattern = 2[!-9]5 |
|
252 private static String[][] data24 = { |
|
253 { "205", "OK" }, |
|
254 { "215", "OK" }, |
|
255 { "225", "OK" }, |
|
256 { "235", "OK" }, |
|
257 { "245", "OK" }, |
|
258 { "255", "OK" }, |
|
259 { "265", "OK" }, |
|
260 { "275", "OK" }, |
|
261 { "285", "OK" }, |
|
262 { "295", "KO" }, |
|
263 { "2-5", "KO" }, |
|
264 }; |
|
265 |
|
266 // Pattern = 2[!9-] |
|
267 private static String[][] data25 = { |
|
268 { "20", "OK" }, |
|
269 { "21", "OK" }, |
|
270 { "22", "OK" }, |
|
271 { "23", "OK" }, |
|
272 { "24", "OK" }, |
|
273 { "25", "OK" }, |
|
274 { "26", "OK" }, |
|
275 { "27", "OK" }, |
|
276 { "28", "OK" }, |
|
277 { "29", "KO" }, |
|
278 { "2-", "KO" }, |
|
279 }; |
|
280 |
|
281 // Pattern = 2[!9-]5 |
|
282 private static String[][] data26 = { |
|
283 { "205", "OK" }, |
|
284 { "215", "OK" }, |
|
285 { "225", "OK" }, |
|
286 { "235", "OK" }, |
|
287 { "245", "OK" }, |
|
288 { "255", "OK" }, |
|
289 { "265", "OK" }, |
|
290 { "275", "OK" }, |
|
291 { "285", "OK" }, |
|
292 { "295", "KO" }, |
|
293 { "2-5", "KO" }, |
|
294 }; |
|
295 |
|
296 // Pattern = 2[!-] |
|
297 private static String[][] data27 = { |
|
298 { "20", "OK" }, |
|
299 { "21", "OK" }, |
|
300 { "22", "OK" }, |
|
301 { "23", "OK" }, |
|
302 { "24", "OK" }, |
|
303 { "25", "OK" }, |
|
304 { "26", "OK" }, |
|
305 { "27", "OK" }, |
|
306 { "28", "OK" }, |
|
307 { "29", "OK" }, |
|
308 { "2-", "KO" }, |
|
309 }; |
|
310 |
|
311 // Pattern = 2[!-]5 |
|
312 private static String[][] data28 = { |
|
313 { "205", "OK" }, |
|
314 { "215", "OK" }, |
|
315 { "225", "OK" }, |
|
316 { "235", "OK" }, |
|
317 { "245", "OK" }, |
|
318 { "255", "OK" }, |
|
319 { "265", "OK" }, |
|
320 { "275", "OK" }, |
|
321 { "285", "OK" }, |
|
322 { "295", "OK" }, |
|
323 { "2-5", "KO" }, |
|
324 }; |
|
325 |
|
326 // Pattern = 2[!1-36-8] |
|
327 private static String[][] data29 = { |
|
328 { "20", "OK" }, |
|
329 { "21", "KO" }, |
|
330 { "22", "KO" }, |
|
331 { "23", "KO" }, |
|
332 { "24", "OK" }, |
|
333 { "25", "OK" }, |
|
334 { "26", "KO" }, |
|
335 { "27", "KO" }, |
|
336 { "28", "KO" }, |
|
337 { "29", "OK" }, |
|
338 { "2-", "OK" }, |
|
339 }; |
|
340 |
|
341 // Pattern = 2[!1-36-8]5 |
|
342 private static String[][] data30 = { |
|
343 { "205", "OK" }, |
|
344 { "215", "KO" }, |
|
345 { "225", "KO" }, |
|
346 { "235", "KO" }, |
|
347 { "245", "OK" }, |
|
348 { "255", "OK" }, |
|
349 { "265", "KO" }, |
|
350 { "275", "KO" }, |
|
351 { "285", "KO" }, |
|
352 { "295", "OK" }, |
|
353 { "2-5", "OK" }, |
|
354 }; |
|
355 |
|
356 // Pattern = a*b?c[d-e] |
|
357 private static String[][] data31 = { |
|
358 { "a*b?cd", "OK" }, |
|
359 { "a*b?ce", "OK" }, |
|
360 { "a*b?cde", "KO" }, |
|
361 { "[a]*b?[c]", "KO" }, |
|
362 { "abc", "KO" }, |
|
363 { "ab?c", "KO" }, |
|
364 { "a*bc", "KO" }, |
|
365 { "axxbxc", "KO" }, |
|
366 { "axxbxcd", "OK" }, |
|
367 }; |
|
368 |
|
369 // Pattern = a\*b\?c\[d-e] |
|
370 private static String[][] data32 = { |
|
371 { "a*b?cd", "KO" }, |
|
372 { "a*b?ce", "KO" }, |
|
373 { "a*b?cde", "KO" }, |
|
374 { "[a]*b?[c]", "KO" }, |
|
375 { "abc", "KO" }, |
|
376 { "ab?c", "KO" }, |
|
377 { "a*bc", "KO" }, |
|
378 { "axxbxc", "KO" }, |
|
379 { "axxbxcd", "KO" }, |
|
380 { "a*b?c[d]", "KO" }, |
|
381 { "a*b?c[e]", "KO" }, |
|
382 { "a*b?c[d-e]", "OK" }, |
|
383 }; |
|
384 |
|
385 // Pattern = a\*b\?c\[de] |
|
386 private static String[][] data33 = { |
|
387 { "a*b?cd", "KO" }, |
|
388 { "a*b?ce", "KO" }, |
|
389 { "a*b?cde", "KO" }, |
|
390 { "[a]*b?[c]", "KO" }, |
|
391 { "abc", "KO" }, |
|
392 { "ab?c", "KO" }, |
|
393 { "a*bc", "KO" }, |
|
394 { "axxbxc", "KO" }, |
|
395 { "axxbxcd", "KO" }, |
|
396 { "a*b?c[d]", "KO" }, |
|
397 { "a*b?c[e]", "KO" }, |
|
398 { "a*b?c[d-e]", "KO" }, |
|
399 { "a*b?c[de]", "OK" }, |
|
400 }; |
|
401 |
|
402 // Pattern = abc[de]f |
|
403 private static String[][] data34 = { |
|
404 { "abcdf", "OK" }, |
|
405 { "abcef", "OK" }, |
|
406 { "abcdef", "KO" }, |
|
407 { "abcedf", "KO" }, |
|
408 { "abcd", "KO" }, |
|
409 { "abce", "KO" }, |
|
410 { "abcf", "KO" }, |
|
411 }; |
|
412 |
|
413 // Pattern = abc[d]e |
|
414 private static String[][] data35 = { |
|
415 { "abcde", "OK" }, |
|
416 { "abcd", "KO" }, |
|
417 { "abcdf", "KO" }, |
|
418 { "abcdef", "KO" }, |
|
419 }; |
|
420 |
|
421 // Pattern = a[b] |
|
422 private static String[][] data36 = { |
|
423 { "a", "KO" }, |
|
424 { "ab", "OK" }, |
|
425 { "a[b]", "KO" }, |
|
426 }; |
|
427 |
|
428 // Pattern = a\b |
|
429 private static String[][] data37 = { |
|
430 { "a", "KO" }, |
|
431 { "ab", "KO" }, |
|
432 { "a\\b", "OK" }, |
|
433 }; |
|
434 |
|
435 private static Object[][] tests = { |
|
436 { "2[7-9]", data11 }, |
|
437 { "2[7-9]5", data12 }, |
|
438 { "2[-9]", data13 }, |
|
439 { "2[-9]5", data14 }, |
|
440 { "2[9-]", data15 }, |
|
441 { "2[9-]5", data16 }, |
|
442 { "2[-]", data17 }, |
|
443 { "2[-]5", data18 }, |
|
444 { "2[1-36-8]", data19 }, |
|
445 { "2[1-36-8]5", data20 }, |
|
446 { "2[!7-9]", data21 }, |
|
447 { "2[!7-9]5", data22 }, |
|
448 { "2[!-9]", data23 }, |
|
449 { "2[!-9]5", data24 }, |
|
450 { "2[!9-]", data25 }, |
|
451 { "2[!9-]5", data26 }, |
|
452 { "2[!-]", data27 }, |
|
453 { "2[!-]5", data28 }, |
|
454 { "2[!1-36-8]", data29 }, |
|
455 { "2[!1-36-8]5", data30 }, |
|
456 { "a*b?c[d-e]", data31 }, |
|
457 { "a\\*b\\?c\\[d-e]", data32 }, |
|
458 { "a\\*b\\?c\\[de]", data33 }, |
|
459 { "abc[de]f", data34 }, |
|
460 { "abc[d]e", data35 }, |
|
461 { "a[b]", data36 }, |
|
462 { "a\\\\b", data37 }, |
|
463 }; |
|
464 |
|
465 private static int query(MBeanServer mbs, |
|
466 String pattern, |
|
467 String[][] data) throws Exception { |
|
468 |
|
469 int error = 0; |
|
470 |
|
471 System.out.println("\nAttribute Value Pattern = " + pattern + "\n"); |
|
472 for (int i = 0; i < data.length; i++) { |
|
473 ObjectName on = new ObjectName("domain:type=Simple,pattern=" + |
|
474 ObjectName.quote(pattern) + |
|
475 ",name=" + i); |
|
476 Simple s = new Simple(data[i][0]); |
|
477 mbs.registerMBean(s, on); |
|
478 QueryExp q = |
|
479 Query.match(Query.attr("StringNumber"), Query.value(pattern)); |
|
480 q.setMBeanServer(mbs); |
|
481 boolean r = q.apply(on); |
|
482 System.out.print("Attribute Value = " + |
|
483 mbs.getAttribute(on, "StringNumber")); |
|
484 if (r && "OK".equals(data[i][1])) { |
|
485 System.out.println(" OK"); |
|
486 } else if (!r && "KO".equals(data[i][1])) { |
|
487 System.out.println(" KO"); |
|
488 } else { |
|
489 System.out.println(" Error"); |
|
490 error++; |
|
491 } |
|
492 } |
|
493 |
|
494 return error; |
|
495 } |
|
496 |
|
497 public static void main(String[] args) throws Exception { |
|
498 |
|
499 int error = 0; |
|
500 |
|
501 System.out.println("\n--- Test javax.management.Query.match ---"); |
|
502 |
|
503 MBeanServer mbs = ManagementFactory.getPlatformMBeanServer(); |
|
504 |
|
505 for (int i = 0; i < tests.length; i++) { |
|
506 error += query(mbs, (String) tests[i][0], (String[][]) tests[i][1]); |
|
507 } |
|
508 |
|
509 if (error > 0) { |
|
510 System.out.println("\nTest failed! " + error + " errors.\n"); |
|
511 throw new IllegalArgumentException("Test failed"); |
|
512 } else { |
|
513 System.out.println("\nTest passed!\n"); |
|
514 } |
|
515 } |
|
516 } |