| /* |
| * 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 6266438 |
| * @summary Query.match code for character sequences like [a-z] is wrong. |
| * @author Luis-Miguel Alventosa |
| * @run clean QueryMatchTest |
| * @run build QueryMatchTest |
| * @run main QueryMatchTest |
| */ |
| |
| import java.lang.management.ManagementFactory; |
| import javax.management.MBeanServer; |
| import javax.management.ObjectName; |
| import javax.management.Query; |
| import javax.management.QueryExp; |
| |
| public class QueryMatchTest { |
| |
| public static interface SimpleMBean { |
| public String getStringNumber(); |
| } |
| |
| public static class Simple implements SimpleMBean { |
| public Simple(String number) { |
| this.number = number; |
| } |
| public String getStringNumber() { |
| return number; |
| } |
| private String number; |
| } |
| |
| // Pattern = 2[7-9] |
| private static String[][] data11 = { |
| { "20", "KO" }, |
| { "21", "KO" }, |
| { "22", "KO" }, |
| { "23", "KO" }, |
| { "24", "KO" }, |
| { "25", "KO" }, |
| { "26", "KO" }, |
| { "27", "OK" }, |
| { "28", "OK" }, |
| { "29", "OK" }, |
| { "2-", "KO" }, |
| }; |
| |
| // Pattern = 2[7-9]5 |
| private static String[][] data12 = { |
| { "205", "KO" }, |
| { "215", "KO" }, |
| { "225", "KO" }, |
| { "235", "KO" }, |
| { "245", "KO" }, |
| { "255", "KO" }, |
| { "265", "KO" }, |
| { "275", "OK" }, |
| { "285", "OK" }, |
| { "295", "OK" }, |
| { "2-5", "KO" }, |
| }; |
| |
| // Pattern = 2[-9] |
| private static String[][] data13 = { |
| { "20", "KO" }, |
| { "21", "KO" }, |
| { "22", "KO" }, |
| { "23", "KO" }, |
| { "24", "KO" }, |
| { "25", "KO" }, |
| { "26", "KO" }, |
| { "27", "KO" }, |
| { "28", "KO" }, |
| { "29", "OK" }, |
| { "2-", "OK" }, |
| }; |
| |
| // Pattern = 2[-9]5 |
| private static String[][] data14 = { |
| { "205", "KO" }, |
| { "215", "KO" }, |
| { "225", "KO" }, |
| { "235", "KO" }, |
| { "245", "KO" }, |
| { "255", "KO" }, |
| { "265", "KO" }, |
| { "275", "KO" }, |
| { "285", "KO" }, |
| { "295", "OK" }, |
| { "2-5", "OK" }, |
| }; |
| |
| // Pattern = 2[9-] |
| private static String[][] data15 = { |
| { "20", "KO" }, |
| { "21", "KO" }, |
| { "22", "KO" }, |
| { "23", "KO" }, |
| { "24", "KO" }, |
| { "25", "KO" }, |
| { "26", "KO" }, |
| { "27", "KO" }, |
| { "28", "KO" }, |
| { "29", "OK" }, |
| { "2-", "OK" }, |
| }; |
| |
| // Pattern = 2[9-]5 |
| private static String[][] data16 = { |
| { "205", "KO" }, |
| { "215", "KO" }, |
| { "225", "KO" }, |
| { "235", "KO" }, |
| { "245", "KO" }, |
| { "255", "KO" }, |
| { "265", "KO" }, |
| { "275", "KO" }, |
| { "285", "KO" }, |
| { "295", "OK" }, |
| { "2-5", "OK" }, |
| }; |
| |
| // Pattern = 2[-] |
| private static String[][] data17 = { |
| { "20", "KO" }, |
| { "21", "KO" }, |
| { "22", "KO" }, |
| { "23", "KO" }, |
| { "24", "KO" }, |
| { "25", "KO" }, |
| { "26", "KO" }, |
| { "27", "KO" }, |
| { "28", "KO" }, |
| { "29", "KO" }, |
| { "2-", "OK" }, |
| }; |
| |
| // Pattern = 2[-]5 |
| private static String[][] data18 = { |
| { "205", "KO" }, |
| { "215", "KO" }, |
| { "225", "KO" }, |
| { "235", "KO" }, |
| { "245", "KO" }, |
| { "255", "KO" }, |
| { "265", "KO" }, |
| { "275", "KO" }, |
| { "285", "KO" }, |
| { "295", "KO" }, |
| { "2-5", "OK" }, |
| }; |
| |
| // Pattern = 2[1-36-8] |
| private static String[][] data19 = { |
| { "20", "KO" }, |
| { "21", "OK" }, |
| { "22", "OK" }, |
| { "23", "OK" }, |
| { "24", "KO" }, |
| { "25", "KO" }, |
| { "26", "OK" }, |
| { "27", "OK" }, |
| { "28", "OK" }, |
| { "29", "KO" }, |
| { "2-", "KO" }, |
| }; |
| |
| // Pattern = 2[1-36-8]5 |
| private static String[][] data20 = { |
| { "205", "KO" }, |
| { "215", "OK" }, |
| { "225", "OK" }, |
| { "235", "OK" }, |
| { "245", "KO" }, |
| { "255", "KO" }, |
| { "265", "OK" }, |
| { "275", "OK" }, |
| { "285", "OK" }, |
| { "295", "KO" }, |
| { "2-5", "KO" }, |
| }; |
| |
| // Pattern = 2[!7-9] |
| private static String[][] data21 = { |
| { "20", "OK" }, |
| { "21", "OK" }, |
| { "22", "OK" }, |
| { "23", "OK" }, |
| { "24", "OK" }, |
| { "25", "OK" }, |
| { "26", "OK" }, |
| { "27", "KO" }, |
| { "28", "KO" }, |
| { "29", "KO" }, |
| { "2-", "OK" }, |
| }; |
| |
| // Pattern = 2[!7-9]5 |
| private static String[][] data22 = { |
| { "205", "OK" }, |
| { "215", "OK" }, |
| { "225", "OK" }, |
| { "235", "OK" }, |
| { "245", "OK" }, |
| { "255", "OK" }, |
| { "265", "OK" }, |
| { "275", "KO" }, |
| { "285", "KO" }, |
| { "295", "KO" }, |
| { "2-5", "OK" }, |
| }; |
| |
| // Pattern = 2[!-9] |
| private static String[][] data23 = { |
| { "20", "OK" }, |
| { "21", "OK" }, |
| { "22", "OK" }, |
| { "23", "OK" }, |
| { "24", "OK" }, |
| { "25", "OK" }, |
| { "26", "OK" }, |
| { "27", "OK" }, |
| { "28", "OK" }, |
| { "29", "KO" }, |
| { "2-", "KO" }, |
| }; |
| |
| // Pattern = 2[!-9]5 |
| private static String[][] data24 = { |
| { "205", "OK" }, |
| { "215", "OK" }, |
| { "225", "OK" }, |
| { "235", "OK" }, |
| { "245", "OK" }, |
| { "255", "OK" }, |
| { "265", "OK" }, |
| { "275", "OK" }, |
| { "285", "OK" }, |
| { "295", "KO" }, |
| { "2-5", "KO" }, |
| }; |
| |
| // Pattern = 2[!9-] |
| private static String[][] data25 = { |
| { "20", "OK" }, |
| { "21", "OK" }, |
| { "22", "OK" }, |
| { "23", "OK" }, |
| { "24", "OK" }, |
| { "25", "OK" }, |
| { "26", "OK" }, |
| { "27", "OK" }, |
| { "28", "OK" }, |
| { "29", "KO" }, |
| { "2-", "KO" }, |
| }; |
| |
| // Pattern = 2[!9-]5 |
| private static String[][] data26 = { |
| { "205", "OK" }, |
| { "215", "OK" }, |
| { "225", "OK" }, |
| { "235", "OK" }, |
| { "245", "OK" }, |
| { "255", "OK" }, |
| { "265", "OK" }, |
| { "275", "OK" }, |
| { "285", "OK" }, |
| { "295", "KO" }, |
| { "2-5", "KO" }, |
| }; |
| |
| // Pattern = 2[!-] |
| private static String[][] data27 = { |
| { "20", "OK" }, |
| { "21", "OK" }, |
| { "22", "OK" }, |
| { "23", "OK" }, |
| { "24", "OK" }, |
| { "25", "OK" }, |
| { "26", "OK" }, |
| { "27", "OK" }, |
| { "28", "OK" }, |
| { "29", "OK" }, |
| { "2-", "KO" }, |
| }; |
| |
| // Pattern = 2[!-]5 |
| private static String[][] data28 = { |
| { "205", "OK" }, |
| { "215", "OK" }, |
| { "225", "OK" }, |
| { "235", "OK" }, |
| { "245", "OK" }, |
| { "255", "OK" }, |
| { "265", "OK" }, |
| { "275", "OK" }, |
| { "285", "OK" }, |
| { "295", "OK" }, |
| { "2-5", "KO" }, |
| }; |
| |
| // Pattern = 2[!1-36-8] |
| private static String[][] data29 = { |
| { "20", "OK" }, |
| { "21", "KO" }, |
| { "22", "KO" }, |
| { "23", "KO" }, |
| { "24", "OK" }, |
| { "25", "OK" }, |
| { "26", "KO" }, |
| { "27", "KO" }, |
| { "28", "KO" }, |
| { "29", "OK" }, |
| { "2-", "OK" }, |
| }; |
| |
| // Pattern = 2[!1-36-8]5 |
| private static String[][] data30 = { |
| { "205", "OK" }, |
| { "215", "KO" }, |
| { "225", "KO" }, |
| { "235", "KO" }, |
| { "245", "OK" }, |
| { "255", "OK" }, |
| { "265", "KO" }, |
| { "275", "KO" }, |
| { "285", "KO" }, |
| { "295", "OK" }, |
| { "2-5", "OK" }, |
| }; |
| |
| // Pattern = a*b?c[d-e] |
| private static String[][] data31 = { |
| { "a*b?cd", "OK" }, |
| { "a*b?ce", "OK" }, |
| { "a*b?cde", "KO" }, |
| { "[a]*b?[c]", "KO" }, |
| { "abc", "KO" }, |
| { "ab?c", "KO" }, |
| { "a*bc", "KO" }, |
| { "axxbxc", "KO" }, |
| { "axxbxcd", "OK" }, |
| }; |
| |
| // Pattern = a\*b\?c\[d-e] |
| private static String[][] data32 = { |
| { "a*b?cd", "KO" }, |
| { "a*b?ce", "KO" }, |
| { "a*b?cde", "KO" }, |
| { "[a]*b?[c]", "KO" }, |
| { "abc", "KO" }, |
| { "ab?c", "KO" }, |
| { "a*bc", "KO" }, |
| { "axxbxc", "KO" }, |
| { "axxbxcd", "KO" }, |
| { "a*b?c[d]", "KO" }, |
| { "a*b?c[e]", "KO" }, |
| { "a*b?c[d-e]", "OK" }, |
| }; |
| |
| // Pattern = a\*b\?c\[de] |
| private static String[][] data33 = { |
| { "a*b?cd", "KO" }, |
| { "a*b?ce", "KO" }, |
| { "a*b?cde", "KO" }, |
| { "[a]*b?[c]", "KO" }, |
| { "abc", "KO" }, |
| { "ab?c", "KO" }, |
| { "a*bc", "KO" }, |
| { "axxbxc", "KO" }, |
| { "axxbxcd", "KO" }, |
| { "a*b?c[d]", "KO" }, |
| { "a*b?c[e]", "KO" }, |
| { "a*b?c[d-e]", "KO" }, |
| { "a*b?c[de]", "OK" }, |
| }; |
| |
| // Pattern = abc[de]f |
| private static String[][] data34 = { |
| { "abcdf", "OK" }, |
| { "abcef", "OK" }, |
| { "abcdef", "KO" }, |
| { "abcedf", "KO" }, |
| { "abcd", "KO" }, |
| { "abce", "KO" }, |
| { "abcf", "KO" }, |
| }; |
| |
| // Pattern = abc[d]e |
| private static String[][] data35 = { |
| { "abcde", "OK" }, |
| { "abcd", "KO" }, |
| { "abcdf", "KO" }, |
| { "abcdef", "KO" }, |
| }; |
| |
| // Pattern = a[b] |
| private static String[][] data36 = { |
| { "a", "KO" }, |
| { "ab", "OK" }, |
| { "a[b]", "KO" }, |
| }; |
| |
| // Pattern = a\b |
| private static String[][] data37 = { |
| { "a", "KO" }, |
| { "ab", "KO" }, |
| { "a\\b", "OK" }, |
| }; |
| |
| private static Object[][] tests = { |
| { "2[7-9]", data11 }, |
| { "2[7-9]5", data12 }, |
| { "2[-9]", data13 }, |
| { "2[-9]5", data14 }, |
| { "2[9-]", data15 }, |
| { "2[9-]5", data16 }, |
| { "2[-]", data17 }, |
| { "2[-]5", data18 }, |
| { "2[1-36-8]", data19 }, |
| { "2[1-36-8]5", data20 }, |
| { "2[!7-9]", data21 }, |
| { "2[!7-9]5", data22 }, |
| { "2[!-9]", data23 }, |
| { "2[!-9]5", data24 }, |
| { "2[!9-]", data25 }, |
| { "2[!9-]5", data26 }, |
| { "2[!-]", data27 }, |
| { "2[!-]5", data28 }, |
| { "2[!1-36-8]", data29 }, |
| { "2[!1-36-8]5", data30 }, |
| { "a*b?c[d-e]", data31 }, |
| { "a\\*b\\?c\\[d-e]", data32 }, |
| { "a\\*b\\?c\\[de]", data33 }, |
| { "abc[de]f", data34 }, |
| { "abc[d]e", data35 }, |
| { "a[b]", data36 }, |
| { "a\\\\b", data37 }, |
| }; |
| |
| private static int query(MBeanServer mbs, |
| String pattern, |
| String[][] data) throws Exception { |
| |
| int error = 0; |
| |
| System.out.println("\nAttribute Value Pattern = " + pattern + "\n"); |
| for (int i = 0; i < data.length; i++) { |
| ObjectName on = new ObjectName("domain:type=Simple,pattern=" + |
| ObjectName.quote(pattern) + |
| ",name=" + i); |
| Simple s = new Simple(data[i][0]); |
| mbs.registerMBean(s, on); |
| QueryExp q = |
| Query.match(Query.attr("StringNumber"), Query.value(pattern)); |
| q.setMBeanServer(mbs); |
| boolean r = q.apply(on); |
| System.out.print("Attribute Value = " + |
| mbs.getAttribute(on, "StringNumber")); |
| if (r && "OK".equals(data[i][1])) { |
| System.out.println(" OK"); |
| } else if (!r && "KO".equals(data[i][1])) { |
| System.out.println(" KO"); |
| } else { |
| System.out.println(" Error"); |
| error++; |
| } |
| } |
| |
| return error; |
| } |
| |
| public static void main(String[] args) throws Exception { |
| |
| int error = 0; |
| |
| System.out.println("\n--- Test javax.management.Query.match ---"); |
| |
| MBeanServer mbs = ManagementFactory.getPlatformMBeanServer(); |
| |
| for (int i = 0; i < tests.length; i++) { |
| error += query(mbs, (String) tests[i][0], (String[][]) tests[i][1]); |
| } |
| |
| if (error > 0) { |
| System.out.println("\nTest failed! " + error + " errors.\n"); |
| throw new IllegalArgumentException("Test failed"); |
| } else { |
| System.out.println("\nTest passed!\n"); |
| } |
| } |
| } |
