/*
 * Copyright (c) 2005, 2015, 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
 * @modules java.management
 * @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");
        }
    }
}