1 /*

     2  * Copyright 2008 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  * @test JMXNamespacesTest.java

    25  * @summary Test the static method that rewrite ObjectNames in JMXNamespacesTest

    26  * @author Daniel Fuchs

    27  * @bug 5072476

    28  * @run clean JMXNamespacesTest

    29  * @compile -XDignore.symbol.file=true JMXNamespacesTest.java

    30  * @run main JMXNamespacesTest

    31  */

    32 

    33 import com.sun.jmx.namespace.ObjectNameRouter;

    34 import java.io.Serializable;

    35 import java.util.Arrays;

    36 import java.util.logging.Logger;

    37 import javax.management.MalformedObjectNameException;

    38 import javax.management.ObjectName;

    39 import javax.management.namespace.JMXNamespaces;

    40 

    41 /**

    42  * Class JMXNamespacesTest

    43  * @author Sun Microsystems, 2005 - All rights reserved.

    44  */

    45 public class JMXNamespacesTest {

    46 

    47     /**

    48      * A logger for this class.

    49      **/

    50     private static final Logger LOG =

    51             Logger.getLogger(JMXNamespacesTest.class.getName());

    52 

    53     /** Creates a new instance of JMXNamespacesTest */

    54     public JMXNamespacesTest() {

    55     }

    56 

    57     public static class CustomObject implements Serializable {

    58         ObjectName toto;

    59         String titi;

    60         CustomObject(String toto, String titi) {

    61             try {

    62                 this.toto = new ObjectName(toto);

    63             } catch (MalformedObjectNameException m) {

    64                 throw new IllegalArgumentException(m);

    65             }

    66             this.titi = titi;

    67         }

    68         private Object[] data() {

    69             return new Object[] {toto, titi};

    70         }

    71         @Override

    72         public boolean equals(Object other) {

    73             if (! (other instanceof CustomObject)) return false;

    74             return Arrays.deepEquals(data(),((CustomObject)other).data());

    75         }

    76         @Override

    77         public int hashCode() {

    78             return Arrays.deepHashCode(data());

    79         }

    80     }

    81 

    82     public static CustomObject obj(String toto, String titi) {

    83         return new CustomObject(toto,titi);

    84     }

    85 

    86     private static String failure;

    87 

    88     public static void testDeepRewrite() throws Exception {

    89         failure = null;

    90         String s1 = "x//y//d:k=v";

    91         String s2 = "v//w//x//y//d:k=v";

    92         String p1 = "v//w";

    93         String p3 = "a//b";

    94 

    95         System.out.println("inserting "+p1);

    96         final CustomObject foo1 =

    97                 JMXNamespaces.deepReplaceHeadNamespace(obj(s1,s1),"",p1);

    98         assertEquals(foo1.toto.toString(),p1+"//"+s1);

    99         assertEquals(foo1.titi,s1);

   100 

   101        System.out.println("removing "+p1);

   102        final CustomObject foo2 =

   103                 JMXNamespaces.deepReplaceHeadNamespace(obj(s2,s2),p1,"");

   104         assertEquals(foo2.toto.toString(),s1);

   105         assertEquals(foo2.titi,s2);

   106 

   107         System.out.println("removing "+p1);

   108         final CustomObject foo3 =

   109                 JMXNamespaces.deepReplaceHeadNamespace(obj(p1+"//"+s2,s2),p1,"");

   110         assertEquals(foo3.toto.toString(),s2);

   111         assertEquals(foo3.titi,s2);

   112 

   113         System.out.println("replacing "+p1+" with "+p3);

   114         final CustomObject foo4 =

   115                 JMXNamespaces.deepReplaceHeadNamespace(obj(s2,s2),p1,p3);

   116         assertEquals(foo4.toto.toString(),p3+"//"+s1);

   117         assertEquals(foo4.titi,s2);

   118 

   119         System.out.println("replacing "+p1+" with "+p1);

   120         final CustomObject foo5 =

   121                 JMXNamespaces.deepReplaceHeadNamespace(obj(s2,s2),p1,p1);

   122         assertEquals(foo5.toto.toString(),s2);

   123         assertEquals(foo5.titi,s2);

   124 

   125         System.out.println("removing x//y in "+s2);

   126         try {

   127             final CustomObject foo7 =

   128                 JMXNamespaces.deepReplaceHeadNamespace(obj(s2,s2),"x//y","");

   129             failed("Remove x//y in "+s2+" should have failed!");

   130         } catch (IllegalArgumentException x) {

   131             System.out.println("Received expected exception: "+x);

   132         }

   133 

   134         System.out.println("replacing x//y with "+p3+" in "+s2);

   135         try {

   136             final CustomObject foo7 =

   137                 JMXNamespaces.deepReplaceHeadNamespace(obj(s2,s2),"x//y",p3);

   138             failed("Replace x//y in "+s2+" should have failed!");

   139         } catch (IllegalArgumentException x) {

   140             System.out.println("Received expected exception: "+x);

   141         }

   142 

   143         if (failure != null) throw new Exception(failure);

   144     }

   145 

   146     private static String[][] wildcards = {

   147         { "", "*:*" },

   148         { "//", "//*:*" },

   149         { "foo", "foo//*:*" },

   150         { "//foo", "//foo//*:*" },

   151         { "////foo", "//foo//*:*" },

   152         { "foo//", "foo//*:*" },

   153         { "foo////", "foo//*:*" },

   154         { "//foo//", "//foo//*:*" },

   155         { "////foo//", "//foo//*:*" },

   156         { "////foo////", "//foo//*:*" },

   157         { "foo//bar", "foo//bar//*:*" },

   158         { "//foo//bar", "//foo//bar//*:*" },

   159         { "////foo//bar", "//foo//bar//*:*" },

   160         { "foo//bar//", "foo//bar//*:*" },

   161         { "foo//bar////", "foo//bar//*:*" },

   162         { "//foo//bar//", "//foo//bar//*:*" },

   163         { "////foo//bar//", "//foo//bar//*:*" },

   164         { "////foo//bar////", "//foo//bar//*:*" },

   165         { "foo////bar", "foo//bar//*:*" },

   166         { "//foo////bar", "//foo//bar//*:*" },

   167         { "////foo////bar", "//foo//bar//*:*" },

   168         { "foo////bar//", "foo//bar//*:*" },

   169         { "foo////bar////", "foo//bar//*:*" },

   170         { "//foo////bar//", "//foo//bar//*:*" },

   171         { "////foo////bar//", "//foo//bar//*:*" },

   172         { "////foo////bar////", "//foo//bar//*:*" },

   173         { "fo/o", "fo/o//*:*" },

   174         { "//f/oo", "//f/oo//*:*" },

   175         { "////f/o/o", "//f/o/o//*:*" },

   176         { "fo/o//", "fo/o//*:*" },

   177         { "f/oo////", "f/oo//*:*" },

   178         { "//fo/o//", "//fo/o//*:*" },

   179         { "////f/oo//", "//f/oo//*:*" },

   180         { "////f/o/o////", "//f/o/o//*:*" },

   181         { "foo//b/a/r", "foo//b/a/r//*:*" },

   182         { "//fo/o//bar", "//fo/o//bar//*:*" },

   183         { "////foo//b/ar", "//foo//b/ar//*:*" },

   184         { "foo//ba/r//", "foo//ba/r//*:*" },

   185         { "f/oo//bar////", "f/oo//bar//*:*" },

   186         { "//f/o/o//bar//", "//f/o/o//bar//*:*" },

   187         { "////foo//b/a/r//", "//foo//b/a/r//*:*" },

   188         { "////f/o/o//b/a/r////", "//f/o/o//b/a/r//*:*" },

   189         { "foo////ba/r", "foo//ba/r//*:*" },

   190         { "//foo////b/ar", "//foo//b/ar//*:*" },

   191         { "////f/oo////bar", "//f/oo//bar//*:*" },

   192         { "fo/o////bar//", "fo/o//bar//*:*" },

   193         { "foo////ba/r////", "foo//ba/r//*:*" },

   194         { "//fo/o////ba/r//", "//fo/o//ba/r//*:*" },

   195         { "////f/oo////b/ar//", "//f/oo//b/ar//*:*" },

   196         { "////f/o/o////b/a/r////", "//f/o/o//b/a/r//*:*" },

   197     };

   198     private final static String[] badguys = {

   199         null,

   200         "/",         "/*:*",

   201         "///",       "///*:*" ,

   202         "/foo",      "/foo//*:*",

   203         "//foo/",    "//foo///*:*" ,

   204         "/////foo",  "///foo//*:*",

   205         "/foo//",    "/foo//*:*",

   206         "foo/////",  "foo///*:*",

   207         "///foo//",  "///foo//*:*",

   208         "////foo///", "//foo///*:*" ,

   209         "/////foo/////", "///foo///*:*",

   210         "/foo//bar", "/foo//bar//*:*",

   211         "//foo///bar", "//foo///bar//*:*",

   212         "/////foo////bar/", "///foo//bar///*:*",

   213         "foo///bar//", "foo//bar///*:*",

   214         "foo//bar/////", "foo///bar//*:*",

   215         "///foo//bar//", "//foo///bar//*:*" ,

   216     };

   217     public static void testWildcard() throws Exception {

   218         int i = 0;

   219         for (String[] pair : wildcards) {

   220             i++;

   221             final String msg = "testWildcard[good,"+i+"] "+Arrays.asList(pair)+": ";

   222             assertEquals(msg, new ObjectName(pair[1]),

   223                     JMXNamespaces.getWildcardFor(pair[0]));

   224         }

   225         i=0;

   226         for (String bad : badguys) {

   227             i++;

   228             try {

   229                 JMXNamespaces.getWildcardFor(bad);

   230                 failed("testWildcard[bad,"+i+"] "+bad+" incorrectly accepted. " +

   231                         "IllegalArgumentException was expected");

   232             } catch (IllegalArgumentException x) {

   233                 // OK

   234             }

   235         }

   236         if (failure != null) throw new Exception(failure);

   237     }

   238 

   239     private static String[][] goodinsert = {

   240         {"","d:k=v","d:k=v"},

   241         {"","//d:k=v","//d:k=v"},

   242         {"//","d:k=v","//d:k=v"},

   243         {"//","//d:k=v","//d:k=v"},

   244         {"//","a//d:k=v","//a//d:k=v"},

   245         {"//","//a//d:k=v","//a//d:k=v"},

   246         {"//","////a////d:k=v","//a//d:k=v"},

   247         {"//b","////a////d:k=v","//b//a//d:k=v"},

   248         {"b","////a////d:k=v","b//a//d:k=v"},

   249         {"b","d:k=v","b//d:k=v"},

   250         {"b//","d:k=v","b//d:k=v"},

   251         {"//b//","d:k=v","//b//d:k=v"},

   252         {"//b","////a////d:k=v","//b//a//d:k=v"},

   253         {"b//c","////a////d:k=v","b//c//a//d:k=v"},

   254         {"b//c","d:k=v","b//c//d:k=v"},

   255         {"b//c//","d:k=v","b//c//d:k=v"},

   256         {"//b//c//","d:k=v","//b//c//d:k=v"},

   257         {"","/d:k=v","/d:k=v"},

   258         {"","///d:k=v","///d:k=v"},

   259         {"//","/d:k=v","///d:k=v"},

   260         {"//","///d:k=v","///d:k=v"},

   261         {"//","a///d:k=v","//a///d:k=v"},

   262         {"//","//a///d:k=v","//a///d:k=v"},

   263         {"//","////a////d/:k=v","//a//d/:k=v"},

   264         {"//b","////a/////d:k=v","//b//a///d:k=v"},

   265         {"b","////a////d/:k=v","b//a//d/:k=v"},

   266         {"b","/d:k=v","b///d:k=v"},

   267         {"b//","/d:k=v","b///d:k=v"},

   268         {"//b//","/d:k=v","//b///d:k=v"},

   269         {"//b","////a/////d:k=v","//b//a///d:k=v"},

   270         {"b//c","////a/////d:k=v","b//c//a///d:k=v"},

   271         {"b//c","/d:k=v","b//c///d:k=v"},

   272         {"b//c//","/d:k=v","b//c///d:k=v"},

   273         {"//b//c//","d/:k=v","//b//c//d/:k=v"},

   274     };

   275 

   276     private static String[][] badinsert = {

   277         {"/","d:k=v"},

   278         {"/","//d:k=v"},

   279         {"///","d:k=v"},

   280         {"///","//d:k=v"},

   281         {"///","/a//d:k=v"},

   282         {"///","///a//d:k=v"},

   283         {"///","/////a////d:k=v"},

   284         {"//b","/////a////d:k=v"},

   285         {"b/","////a////d:k=v"},

   286         {"b/","d:k=v"},

   287         {"b///","d:k=v"},

   288         {"//b///","d:k=v"},

   289         {"//b/","////a////d:k=v"},

   290         {"b///c","////a////d:k=v"},

   291         {"b//c/","d:k=v"},

   292         {"b///c//","d:k=v"},

   293         {"//b///c//","d:k=v"},

   294 

   295     };

   296 

   297     public static void testInsertPath() throws Exception {

   298         int i = 0;

   299         for (String[] pair : goodinsert) {

   300             i++;

   301             final String msg = "testInsertPath[good,"+i+"] "+Arrays.asList(pair)+": ";

   302             assertEquals(msg,new ObjectName(pair[2]),

   303                     JMXNamespaces.insertPath(pair[0],

   304                     new ObjectName(pair[1])));

   305         }

   306         i=0;

   307         for (String[] bad : badinsert) {

   308             i++;

   309             try {

   310                 JMXNamespaces.insertPath(bad[0],

   311                     new ObjectName(bad[1]));

   312                 failed("testInsertPath[bad,"+i+"] "+

   313                         Arrays.asList(bad)+" incorrectly accepted. " +

   314                         "IllegalArgumentException was expected");

   315             } catch (IllegalArgumentException x) {

   316                 // OK

   317             }

   318         }

   319         if (failure != null) throw new Exception(failure);

   320     }

   321 

   322     private static String[][] testpath  = {

   323         {"/a/a/:k=v",""},

   324         {"/:k=v",""},

   325         {"bli:k=v",""},

   326         {"///a/a/:k=v",""},

   327         {"///:k=v",""},

   328         {"//bli:k=v",""},

   329         {"/////a/a/:k=v",""},

   330         {"/////:k=v",""},

   331         {"////bli:k=v",""},

   332         {"y///a/a/:k=v","y"},

   333         {"y///:k=v","y"},

   334         {"y//bli:k=v","y"},

   335         {"y/////a/a/:k=v","y"},

   336         {"y/////:k=v","y"},

   337         {"y////bli:k=v","y"},

   338         {"//y///a/a/:k=v","y"},

   339         {"//y///:k=v","y"},

   340         {"//y//bli:k=v","y"},

   341         {"//y/////a/a/:k=v","y"},

   342         {"//y/////:k=v","y"},

   343         {"//y////bli:k=v","y"},

   344         {"////y///a/a/:k=v","y"},

   345         {"////y///:k=v","y"},

   346         {"////y//bli:k=v","y"},

   347         {"////y/////a/a/:k=v","y"},

   348         {"////y/////:k=v","y"},

   349         {"////y////bli:k=v","y"},

   350 

   351         {"z//y///a/a/:k=v","z//y"},

   352         {"z//y///:k=v","z//y"},

   353         {"z//y//bli:k=v","z//y"},

   354         {"z//y/////a/a/:k=v","z//y"},

   355         {"z//y/////:k=v","z//y"},

   356         {"z//y////bli:k=v","z//y"},

   357         {"//z//y///a/a/:k=v","z//y"},

   358         {"//z//y///:k=v","z//y"},

   359         {"//z//y//bli:k=v","z//y"},

   360         {"//z//y/////a/a/:k=v","z//y"},

   361         {"//z//y/////:k=v","z//y"},

   362         {"//z//y////bli:k=v","z//y"},

   363         {"z////y///a/a/:k=v","z//y"},

   364         {"z////y///:k=v","z//y"},

   365         {"z////y//bli:k=v","z//y"},

   366         {"z////y/////a/a/:k=v","z//y"},

   367         {"z////y/////:k=v","z//y"},

   368         {"z////y////bli:k=v","z//y"},

   369         {"//z////y///a/a/:k=v","z//y"},

   370         {"//z////y///:k=v","z//y"},

   371         {"//z////y//bli:k=v","z//y"},

   372         {"//z////y/////a/a/:k=v","z//y"},

   373         {"//z////y/////:k=v","z//y"},

   374         {"//z////y////bli:k=v","z//y"},

   375         {"////z////y///a/a/:k=v","z//y"},

   376         {"////z////y///:k=v","z//y"},

   377         {"////z////y//bli:k=v","z//y"},

   378         {"////z////y/////a/a/:k=v","z//y"},

   379         {"////z////y/////:k=v","z//y"},

   380         {"////z////y////bli:k=v","z//y"},

   381 

   382     };

   383 

   384     public static void testGetNormalizedPath() throws Exception {

   385         int i = 0;

   386         for (String[] pair : testpath) {

   387             i++;

   388             final String msg = "testGetNormalizedPath["+i+"] "+Arrays.asList(pair)+": ";

   389             assertEquals(msg,pair[1],

   390                     JMXNamespaces.getContainingNamespace(new ObjectName(pair[0])));

   391         }

   392         if (failure != null) throw new Exception(failure);

   393     }

   394 

   395     private static String[][] testdomain  = {

   396         {"/a/a/","/a/a/"},

   397         {"/","/"},

   398         {"bli","bli"},

   399         {"///a/a/","///a/a/"},

   400         {"///","///"},

   401         {"//bli","//bli"},

   402         {"/////a/a/","///a/a/"},

   403         {"/////","///"},

   404         {"////bli","//bli"},

   405         {"y///a/a/","y///a/a/"},

   406         {"y///","y///"},

   407         {"y//bli","y//bli"},

   408         {"y/////a/a/","y///a/a/"},

   409         {"y/////","y///"},

   410         {"y////bli","y//bli"},

   411         {"//y///a/a/","//y///a/a/"},

   412         {"//y///","//y///"},

   413         {"//y//bli","//y//bli"},

   414         {"//y/////a/a/","//y///a/a/"},

   415         {"//y/////","//y///"},

   416         {"//y////bli","//y//bli"},

   417         {"////y///a/a/","//y///a/a/"},

   418         {"////y///","//y///"},

   419         {"////y//bli","//y//bli"},

   420         {"////y/////a/a/","//y///a/a/"},

   421         {"////y/////","//y///"},

   422         {"////y////bli","//y//bli"},

   423 

   424         {"z//y///a/a/","z//y///a/a/"},

   425         {"z//y///","z//y///"},

   426         {"z//y//bli","z//y//bli"},

   427         {"z//y/////a/a/","z//y///a/a/"},

   428         {"z//y/////","z//y///"},

   429         {"z//y////bli","z//y//bli"},

   430         {"//z//y///a/a/","//z//y///a/a/"},

   431         {"//z//y///","//z//y///"},

   432         {"//z//y//bli","//z//y//bli"},

   433         {"//z//y/////a/a/","//z//y///a/a/"},

   434         {"//z//y/////","//z//y///"},

   435         {"//z//y////bli","//z//y//bli"},

   436         {"z////y///a/a/","z//y///a/a/"},

   437         {"z////y///","z//y///"},

   438         {"z////y//bli","z//y//bli"},

   439         {"z////y/////a/a/","z//y///a/a/"},

   440         {"z////y/////","z//y///"},

   441         {"z////y////bli","z//y//bli"},

   442         {"//z////y///a/a/","//z//y///a/a/"},

   443         {"//z////y///","//z//y///"},

   444         {"//z////y//bli","//z//y//bli"},

   445         {"//z////y/////a/a/","//z//y///a/a/"},

   446         {"//z////y/////","//z//y///"},

   447         {"//z////y////bli","//z//y//bli"},

   448         {"////z////y///a/a/","//z//y///a/a/"},

   449         {"////z////y///","//z//y///"},

   450         {"////z////y//bli","//z//y//bli"},

   451         {"////z////y/////a/a/","//z//y///a/a/"},

   452         {"////z////y/////","//z//y///"},

   453         {"////z////y////bli","//z//y//bli"},

   454 

   455         {"bli//","bli//"},

   456         {"//bli//","//bli//"},

   457         {"////bli//","//bli//"},

   458         {"y////","y//"},

   459         {"y//bli//","y//bli//"},

   460         {"y////","y//"},

   461         {"y////bli//","y//bli//"},

   462         {"//y////","//y//"},

   463         {"//y//bli//","//y//bli//"},

   464         {"//y//////","//y//"},

   465         {"//y////bli//","//y//bli//"},

   466         {"////y////","//y//"},

   467         {"////y//bli////","//y//bli//"},

   468         {"////y//////","//y//"},

   469         {"////y////bli////","//y//bli//"},

   470         {"z//y////","z//y//"},

   471         {"z//y//bli//","z//y//bli//"},

   472         {"z//y//////","z//y//"},

   473         {"z//y////bli//","z//y//bli//"},

   474         {"//z//y////","//z//y//"},

   475         {"//z//y//bli//","//z//y//bli//"},

   476         {"//z//y//////","//z//y//"},

   477         {"//z//y////bli//","//z//y//bli//"},

   478         {"z////y////","z//y//"},

   479         {"z////y//bli//","z//y//bli//"},

   480         {"z////y//////","z//y//"},

   481         {"z////y////bli//","z//y//bli//"},

   482         {"//z////y////","//z//y//"},

   483         {"//z////y//bli//","//z//y//bli//"},

   484         {"//z////y//////","//z//y//"},

   485         {"//z////y////bli//","//z//y//bli//"},

   486         {"////z////y////","//z//y//"},

   487         {"////z////y//bli//","//z//y//bli//"},

   488         {"////z////y//////","//z//y//"},

   489         {"////z////y////bli//","//z//y//bli//"},

   490 

   491     };

   492     private static String[][] testnolead  = {

   493         {"/a/a/","/a/a/"},

   494         {"/","/"},

   495         {"bli","bli"},

   496         {"///a/a/","/a/a/"},

   497         {"///","/"},

   498         {"//bli","bli"},

   499         {"/////a/a/","/a/a/"},

   500         {"/////","/"},

   501         {"////bli","bli"},

   502         {"y///a/a/","y///a/a/"},

   503         {"y///","y///"},

   504         {"y//bli","y//bli"},

   505         {"y/////a/a/","y///a/a/"},

   506         {"y/////","y///"},

   507         {"y////bli","y//bli"},

   508         {"//y///a/a/","y///a/a/"},

   509         {"//y///","y///"},

   510         {"//y//bli","y//bli"},

   511         {"//y/////a/a/","y///a/a/"},

   512         {"//y/////","y///"},

   513         {"//y////bli","y//bli"},

   514         {"////y///a/a/","y///a/a/"},

   515         {"////y///","y///"},

   516         {"////y//bli","y//bli"},

   517         {"////y/////a/a/","y///a/a/"},

   518         {"////y/////","y///"},

   519         {"////y////bli","y//bli"},

   520 

   521         {"z//y///a/a/","z//y///a/a/"},

   522         {"z//y///","z//y///"},

   523         {"z//y//bli","z//y//bli"},

   524         {"z//y/////a/a/","z//y///a/a/"},

   525         {"z//y/////","z//y///"},

   526         {"z//y////bli","z//y//bli"},

   527         {"//z//y///a/a/","z//y///a/a/"},

   528         {"//z//y///","z//y///"},

   529         {"//z//y//bli","z//y//bli"},

   530         {"//z//y/////a/a/","z//y///a/a/"},

   531         {"//z//y/////","z//y///"},

   532         {"//z//y////bli","z//y//bli"},

   533         {"z////y///a/a/","z//y///a/a/"},

   534         {"z////y///","z//y///"},

   535         {"z////y//bli","z//y//bli"},

   536         {"z////y/////a/a/","z//y///a/a/"},

   537         {"z////y/////","z//y///"},

   538         {"z////y////bli","z//y//bli"},

   539         {"//z////y///a/a/","z//y///a/a/"},

   540         {"//z////y///","z//y///"},

   541         {"//z////y//bli","z//y//bli"},

   542         {"//z////y/////a/a/","z//y///a/a/"},

   543         {"//z////y/////","z//y///"},

   544         {"//z////y////bli","z//y//bli"},

   545         {"////z////y///a/a/","z//y///a/a/"},

   546         {"////z////y///","z//y///"},

   547         {"////z////y//bli","z//y//bli"},

   548         {"////z////y/////a/a/","z//y///a/a/"},

   549         {"////z////y/////","z//y///"},

   550         {"////z////y////bli","z//y//bli"},

   551 

   552         {"bli//","bli//"},

   553         {"//bli//","bli//"},

   554         {"////bli//","bli//"},

   555         {"y////","y//"},

   556         {"y//bli//","y//bli//"},

   557         {"y////","y//"},

   558         {"y////bli//","y//bli//"},

   559         {"//y////","y//"},

   560         {"//y//bli//","y//bli//"},

   561         {"//y//////","y//"},

   562         {"//y////bli//","y//bli//"},

   563         {"////y////","y//"},

   564         {"////y//bli////","y//bli//"},

   565         {"////y//////","y//"},

   566         {"////y////bli////","y//bli//"},

   567         {"z//y////","z//y//"},

   568         {"z//y//bli//","z//y//bli//"},

   569         {"z//y//////","z//y//"},

   570         {"z//y////bli//","z//y//bli//"},

   571         {"//z//y////","z//y//"},

   572         {"//z//y//bli//","z//y//bli//"},

   573         {"//z//y//////","z//y//"},

   574         {"//z//y////bli//","z//y//bli//"},

   575         {"z////y////","z//y//"},

   576         {"z////y//bli//","z//y//bli//"},

   577         {"z////y//////","z//y//"},

   578         {"z////y////bli//","z//y//bli//"},

   579         {"//z////y////","z//y//"},

   580         {"//z////y//bli//","z//y//bli//"},

   581         {"//z////y//////","z//y//"},

   582         {"//z////y////bli//","z//y//bli//"},

   583         {"////z////y////","z//y//"},

   584         {"////z////y//bli//","z//y//bli//"},

   585         {"////z////y//////","z//y//"},

   586         {"////z////y////bli//","z//y//bli//"},

   587 

   588     };

   589 

   590     public static void testNormalizeDomain() throws Exception {

   591         int i = 0;

   592         for (String[] pair : testdomain) {

   593             i++;

   594             final String msg = "testNormalizeDomain["+i+", false] "+Arrays.asList(pair)+": ";

   595             assertEquals(msg,pair[1],

   596                     ObjectNameRouter.normalizeDomain(pair[0],false));

   597         }

   598         if (failure != null) throw new Exception(failure);

   599         i = 0;

   600         for (String[] pair : testnolead) {

   601             i++;

   602             final String msg = "testNormalizeDomain["+i+", true] "+Arrays.asList(pair)+": ";

   603             assertEquals(msg,pair[1],

   604                     ObjectNameRouter.normalizeDomain(pair[0],true));

   605         }

   606         if (failure != null) throw new Exception(failure);

   607     }

   608 

   609     public static void main(String[] args) throws Exception {

   610         testDeepRewrite();

   611         testNormalizeDomain();

   612         testInsertPath();

   613         testWildcard();

   614         testGetNormalizedPath();

   615     }

   616 

   617     private static void assertEquals(Object x, Object y) {

   618         assertEquals("",x,y);

   619     }

   620 

   621     private static void assertEquals(String msg, Object x, Object y) {

   622         if (msg == null) msg="";

   623         if (!equal(x, y))

   624             failed(msg+"expected " + string(x) + "; got " + string(y));

   625     }

   626 

   627     private static boolean equal(Object x, Object y) {

   628         if (x == y)

   629             return true;

   630         if (x == null || y == null)

   631             return false;

   632         if (x.getClass().isArray())

   633             return Arrays.deepEquals(new Object[] {x}, new Object[] {y});

   634         return x.equals(y);

   635     }

   636 

   637     private static String string(Object x) {

   638         String s = Arrays.deepToString(new Object[] {x});

   639         return s.substring(1, s.length() - 1);

   640     }

   641 

   642 

   643     private static void failed(String why) {

   644         failure = why;

   645         new Throwable("FAILED: " + why).printStackTrace(System.out);

   646     }

   647 

   648 }