31  * @compile -XDignore.symbol.file=true ApplyWildcardTest.java

    36 import com.sun.jmx.mbeanserver.Repository;

    37 import com.sun.jmx.mbeanserver.Util;

    80 

    81         // with namespaces

    82 

    83         { "*//:*", "d//:k=v" },

    84         { "//?:*", "///:k=v" },

    85         { "z*x//:*", "zaxcx//:k=v" },

    86         { "*//:*", "d/xx/q//:k=v" },

    87         { "z*x//:*", "z/a/x/c/x//:k=v" },

    88         { "*x?//:*", "dbdbdxk//:k=v" },

    89         { "z*x?x//:*", "zaxcx//:k=v" },

    90         { "*x?f//:*", "d/xxf/qxbf//:k=v" },

    91         { "z*x?c*x//:*", "z/a/x/c/x//:k=v" },

    92 

    93         { "*//*:*", "d/c/v//x/vgh/:k=v" },

    94         { "z*x//z*x:*", "zaxcx//zaxcxcx:k=v" },

    95         { "//*//:*", "//d/xx/q//:k=v" },

    96         { "z*//*//:*", "z/x/x/z//z/a/x/c/x//:k=v" },

    97         { "*x?//blur?g*:*", "dbdbdxk//blurhgblurgh/x/:k=v" },

    98         { "z*x??x//??:*", "zaxcxccx///.:k=v" },

    99         { "*x?f//?:*", "d/xxf/qxbf///:k=v" },

   100         { "z*x?c*x//*//z????//g:*", "z/a/x/c/x//gloubs/././/zargh//g:k=v" },

   101         { "z*x?c*x//*//:*", "z/a/x/c/x//gloubs/././/:k=v"},

   102         { "*//*//:*", "aza//bzb//:k=v" },

   103         { "*//:*", "aza//:k=v" },

   104 

   105         // with or without namespaces, * can also match nothing

   106         { "x*z:*", "xz:k=v"},

   107 

   108         { "*//:*", "//:k=v" },

   109         { "z*x//:*", "zx//:k=v" },

   110         { "*x?//:*", "xk//:k=v" },

   111         { "z*x?x//:*", "zxcx//:k=v" },

   112         { "*x?f//:*", "xbf//:k=v" },

   113         { "z*x?c*x//:*", "zx/cx//:k=v" },

   114 

   115         { "*//*:*", "//:k=v" },

   116         { "z*x//z*x:*", "zx//zx:k=v" },

   117         { "//*//:*", "////:k=v" },

   118         { "z*//*//:*", "z////:k=v" },

   119         { "*x?//blur?g*:*", "xk//blurhg:k=v" },

   120         { "z*x??x//??:*", "zxccx///.:k=v" },

   121         { "*x?f//?:*", "xbf///:k=v" },

   122         { "z*x?c*x//*//z????//g:*", "zx/cx////zargh//g:k=v" },

   123         { "z*x?c*x//*//:*", "zx/cx////:k=v"},

   124         { "*//*//:*", "////:k=v" },

   125         { "*//:*", "//:k=v" },

   126 

   127         // recursive namespace meta-wildcard

   128         {"**//D:k=v", "a//D:k=v"},

   129         {"**//D:k=v", "a//b//c//D:k=v"},

   130         {"a//**//D:k=v", "a//b//c//D:k=v"},

   131         {"a//**//d//D:k=v", "a//b//c//d//D:k=v"},

   132         {"a//**//d//D:k=v", "a//b//c//d//d//D:k=v"},

   133         {"a//**//d//D:k=v", "a//a//b//c//d//d//D:k=v"},

   134         {"a//**//d//**//e//D:k=v", "a//a//b//d//c//d//e//D:k=v"},

   135 

   136         // special cases for names ending with //

   137         { "*:*", "d//:k=v" },

   138         { "z*x*:*", "zaxcx//:k=v" },

   139         { "*:*", "d/xx/q//:k=v" },

   140         { "z*x??:*", "z/a/x/c/x//:k=v" },

   141         { "*x???:*", "dbdbdxk//:k=v" },

   142         { "z*x?c*x*:*", "z/a/x/c/x//:k=v" },

   143         { "?/*/?:*", "d/xx/q//:k=v" },

   144         { "**//*:*", "a//b//jmx.rmi:k=v"},

   145         { "**//*:*", "a//b//jmx.rmi//:k=v"},

   146         { "*//*:*", "wombat//:type=Wombat" },

   147         { "**//*:*", "jmx.rmi//:k=v"},

   148 

   189 

   190         // with namespaces

   191 

   192         { "z*x?x*:*", "zaxcx//blougs:k=v" },

   193         { "*x?f??rata:*", "d/xxf/qxbf//rata:k=v" },

   194         { "z*x?c*x*b*:*", "z/a/x/c/x//b//:k=v" },

   195 

   196         { "*:*", "d/c/v//x/vgh/:k=v" },

   197         { "z*x??z*x:*", "zaxcx//zaxcxcx:k=v" },

   198         { "?/*/?:*", "//d/xx/q//:k=v" },

   199         { "z*/?*/?:*", "z/x/x/z//z/a/x/c/x//:k=v" },

   200         { "*x?/?blur?g*:*", "dbdbdxk//blurhgblurgh/x/:k=v" },

   201         { "z*x??x/???:*", "zaxcxccx///.:k=v" },

   202         { "*x?f?/?:*", "d/xxf/qxbf///:k=v" },

   203         { "z*x?c*x/?*z????*g:*", "z/a/x/c/x//gloubs/././/zargh//g:k=v" },

   204 

   205         // recursive namespace meta-wildcard

   206         {"**//D:k=v", "D:k=v"},

   207         {"b//**//D:k=v", "a//b//c//D:k=v"},

   208         {"a//**//D:k=v", "a//D:k=v"},

   209         {"a//**//d//D:k=v", "a//b//c//d//e//D:k=v"},

   210         {"a//**//d//D:k=v", "a//b//c//D:k=v"},

   211         {"a//**//d//D:k=v", "a//b//c//d//d//e//D:k=v"},

   212         {"a//**//d//**//e//D:k=v", "a//a//b//c//d//e//D:k=v"},

   213         {"a//**//d//**//e//D:k=v", "a//a//b//c//e//D:k=v"},

   214         { "**//*:*", "jmx.rmi:k=v"},

   215 

   231                     throw new Error("test failed for "+

   232                             "\"" + on1 + "\".apply(\"" + on2 + "\")");

   272     private static int runRepositoryPositiveTests() {

   273         int error = 0;

   274         for (int i = 0; i < positiveTests.length; i++) {

   275             try {

   276                 ObjectName on1 = ObjectName.getInstance(positiveTests[i][0]);

   277                 ObjectName on2 = ObjectName.getInstance(positiveTests[i][1]);

   278                 if (on1.isPropertyPattern()) {

   279                     if (!on1.getKeyPropertyListString().equals("")) continue;

   280                 } else if (!on1.getCanonicalKeyPropertyListString()

   281                             .equals(on2.getCanonicalKeyPropertyListString())) {

   282                     continue;

   283                 }

   284                 System.out.println("Repository Positive Match Test ---------------");

   285                 final String dom1 = on1.getDomain();

   286                 final String dom2 = on2.getDomain();

   287                 System.out.println("Util.wildpathmatch(\"" + dom2 + "\",\"" + dom1 + "\")");

   288                 boolean result =

   289                         Util.wildpathmatch(dom2,dom1);

   290                 System.out.println("Result = " + result);

   291                 if (result == false) {

   292                     error++;

   293                     System.out.println("Test failed!");

   294                 } else {

   295                     System.out.println("Test passed!");

   296                 }

   297             } catch (Exception e) {

   298                 error++;

   299                 System.out.println("Got Unexpected Exception = " + e.toString());

   300                 System.out.println("Test failed!");

   301             }

   302             System.out.println("----------------------------------------------");

   303         }

   304         return error;

   305     }

   306 

   307     private static int runRepositoryNegativeTests() {

   308         int error = 0;

   309         for (int i = 0; i < negativeTests.length; i++) {

   310             try {

   311                 ObjectName on1 = ObjectName.getInstance(negativeTests[i][0]);

   312                 ObjectName on2 = ObjectName.getInstance(negativeTests[i][1]);

   313                 if (on1.isPropertyPattern()) {

   314                     if (!on1.getKeyPropertyListString().equals("")) continue;

   315                 } else if (!on1.getCanonicalKeyPropertyListString()

   316                             .equals(on2.getCanonicalKeyPropertyListString())) {

   317                     continue;

   318                 }

   319                 System.out.println("Repository Negative Match Test ---------------");

   320                 final String dom1 = on1.getDomain();

   321                 final String dom2 = on2.getDomain();

   322                 System.out.println("Util.wildpathmatch(\"" + dom2 + "\",\"" + dom1 + "\")");

   323                 boolean result =

   324                         Util.wildpathmatch(dom2,dom1);

   325                 System.out.println("Result = " + result);

   326                 if (result == true) {

   327                     error++;

   328                     System.out.println("Test failed!");

   329                 } else {

   330                     System.out.println("Test passed!");

   331                 }

   332             } catch (Exception e) {

   333                 error++;

   334                 System.out.println("Got Unexpected Exception = " + e.toString());

   335                 System.out.println("Test failed!");

   336             }

   337             System.out.println("----------------------------------------------");

   338         }

   339         return error;

   340     }

   341 

   344 

   346 

   347         if (!(new ObjectName("z*x*:*").apply(new ObjectName("zaxcx//:k=v"))))

   348                 throw new Exception();

   349 

   432         System.out.println("----------------------------------------------");

   433         error += runRepositoryPositiveTests();

   434         System.out.println("----------------------------------------------");

   435         error += runRepositoryNegativeTests();