1 /*
   2  * Copyright (c) 2013, 2016, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 import java.security.CodeSource;
  25 import java.security.Permission;
  26 import java.security.PermissionCollection;
  27 import java.security.Permissions;
  28 import java.security.Policy;
  29 import java.security.ProtectionDomain;
  30 import java.util.EnumSet;
  31 import java.util.HashMap;
  32 import java.util.Map;
  33 import java.util.logging.LogManager;
  34 import java.util.logging.Logger;
  35 import java.util.logging.LoggingPermission;
  36 import jdk.internal.misc.JavaAWTAccess;
  37 import jdk.internal.misc.SharedSecrets;
  38 
  39 /*
  40  * @test
  41  * @bug 8017174 8010727 8019945
  42  * @summary  NPE when using Logger.getAnonymousLogger or
  43  *           LogManager.getLogManager().getLogger
  44  *
  45  * @modules java.base/jdk.internal.misc
  46  *          java.logging
  47  * @run main/othervm -Dtest.security=off TestAppletLoggerContext LoadingApplet
  48  * @run main/othervm -Dtest.security=on TestAppletLoggerContext  LoadingApplet
  49  * @run main/othervm -Dtest.security=off TestAppletLoggerContext LoadingMain
  50  * @run main/othervm -Dtest.security=on TestAppletLoggerContext  LoadingMain
  51  * @run main/othervm -Dtest.security=off TestAppletLoggerContext One
  52  * @run main/othervm -Dtest.security=on TestAppletLoggerContext  One
  53  * @run main/othervm -Dtest.security=off TestAppletLoggerContext Two
  54  * @run main/othervm -Dtest.security=on TestAppletLoggerContext  Two
  55  * @run main/othervm -Dtest.security=off TestAppletLoggerContext Three
  56  * @run main/othervm -Dtest.security=on TestAppletLoggerContext  Three
  57  * @run main/othervm -Dtest.security=off TestAppletLoggerContext Four
  58  * @run main/othervm -Dtest.security=on TestAppletLoggerContext  Four
  59  * @run main/othervm -Dtest.security=off TestAppletLoggerContext Five
  60  * @run main/othervm -Dtest.security=on TestAppletLoggerContext  Five
  61  * @run main/othervm -Dtest.security=off TestAppletLoggerContext Six
  62  * @run main/othervm -Dtest.security=on TestAppletLoggerContext  Six
  63  * @run main/othervm -Dtest.security=off TestAppletLoggerContext Seven
  64  * @run main/othervm -Dtest.security=on TestAppletLoggerContext  Seven
  65  * @run main/othervm -Dtest.security=off TestAppletLoggerContext
  66  * @run main/othervm -Dtest.security=on TestAppletLoggerContext
  67  */
  68 
  69 // NOTE: We run in other VM in order to 1. switch security manager and 2. cause
  70 // LogManager class to be loaded anew.
  71 public class TestAppletLoggerContext {
  72 
  73     // Avoids the hassle of dealing with files and system props...
  74     static class SimplePolicy extends Policy {
  75         private final Permissions perms;
  76         public SimplePolicy(Permission... permissions) {
  77             perms = new Permissions();
  78             for (Permission permission : permissions) {
  79                 perms.add(permission);
  80             }
  81         }
  82         @Override
  83         public PermissionCollection getPermissions(CodeSource cs) {
  84             return perms;
  85         }
  86         @Override
  87         public PermissionCollection getPermissions(ProtectionDomain pd) {
  88             return perms;
  89         }
  90         @Override
  91         public boolean implies(ProtectionDomain pd, Permission p) {
  92            return perms.implies(p);
  93         }
  94     }
  95 
  96     // The bridge class initializes the logging system.
  97     // It stubs the applet context in order to simulate context changes.
  98     //
  99     public static class Bridge {
 100 
 101         private static class JavaAWTAccessStub implements JavaAWTAccess {
 102             boolean active = true;
 103 
 104             private static class TestExc {
 105                 private final Map<Object, Object> map = new HashMap<>();
 106                 void put(Object key, Object v) { map.put(key, v); }
 107                 Object get(Object key) { return map.get(key); }
 108                 void remove(Object o) { map.remove(o); }
 109                 public static TestExc exc(Object o) {
 110                     return TestExc.class.cast(o);
 111                 }
 112             }
 113 
 114             TestExc exc;
 115 
 116             @Override
 117             public Object getAppletContext() { return active ? exc : null; }
 118         }
 119 
 120         static final JavaAWTAccessStub javaAwtAccess = new JavaAWTAccessStub();
 121         public static void init() {
 122             SharedSecrets.setJavaAWTAccess(javaAwtAccess);
 123             if (System.getProperty("test.security", "on").equals("on")) {
 124                 Policy p = new SimplePolicy(new LoggingPermission("control", null),
 125                     new RuntimePermission("setContextClassLoader"),
 126                     new RuntimePermission("shutdownHooks"));
 127                 Policy.setPolicy(p);
 128                 System.setSecurityManager(new SecurityManager());
 129             }
 130         }
 131 
 132         public static void changeContext() {
 133             System.out.println("... Switching to a new applet context ...");
 134             javaAwtAccess.active = true;
 135             javaAwtAccess.exc = new JavaAWTAccessStub.TestExc();
 136         }
 137 
 138         public static void desactivate() {
 139             System.out.println("... Running with no applet context ...");
 140             javaAwtAccess.exc = null;
 141             javaAwtAccess.active = false;
 142         }
 143 
 144         public static class CustomAnonymousLogger extends Logger {
 145             public CustomAnonymousLogger() {
 146                 this("");
 147             }
 148             public CustomAnonymousLogger(String name) {
 149                 super(null, null);
 150                 System.out.println( " LogManager: " +LogManager.getLogManager());
 151                 System.out.println( " getLogger: " +LogManager.getLogManager().getLogger(name));
 152                 setParent(LogManager.getLogManager().getLogger(name));
 153             }
 154         }
 155 
 156         public static class CustomLogger extends Logger {
 157             CustomLogger(String name) {
 158                 super(name, null);
 159             }
 160         }
 161     }
 162 
 163     public static enum TestCase {
 164         LoadingApplet, LoadingMain, One, Two, Three, Four, Five, Six, Seven;
 165         public void test() {
 166             switch(this) {
 167                 // When run - each of these two tests must be
 168                 // run before any other tests and before each other.
 169                 case LoadingApplet: testLoadingApplet(); break;
 170                 case LoadingMain:   testLoadingMain(); break;
 171                 case One:   testOne(); break;
 172                 case Two:   testTwo(); break;
 173                 case Three: testThree(); break;
 174                 case Four:  testFour(); break;
 175                 case Five:  testFive(); break;
 176                 case Six:   testSix(); break;
 177                 case Seven: testSeven(); break;
 178             }
 179         }
 180         public String describe() {
 181             switch(this) {
 182                 case LoadingApplet:
 183                     return "Test that when the LogManager class is"
 184                         + " loaded in  an applet thread first,"
 185                         + "\n all LoggerContexts are correctly initialized";
 186                 case LoadingMain:
 187                     return "Test that when the LogManager class is"
 188                         + " loaded in  the main thread first,"
 189                         + "\n all LoggerContexts are correctly initialized";
 190                 case One:
 191                     return "Test that Logger.getAnonymousLogger()"
 192                         + " and new CustomAnonymousLogger() don't throw NPE";
 193                 case Two:
 194                     return "Test that Logger.getLogger(\"\")"
 195                             + " does not return null nor throws NPE";
 196                 case Three:
 197                     return "Test that LogManager.getLogManager().getLogger(\"\")"
 198                             + " does not return null nor throws NPE";
 199                 case Four:
 200                     return "Test that Logger.getLogger(Logger.GLOBAL_LOGGER_NAME)"
 201                             + " does not return null,\n and that"
 202                             + " new CustomAnonymousLogger(Logger.GLOBAL_LOGGER_NAME)"
 203                             + " does not throw NPE";
 204                 case Five:
 205                     return "Test that LogManager.getLogManager().getLogger(Logger.GLOBAL_LOGGER_NAME)"
 206                             + "\n does not return null nor throws NPE";
 207                 case Six:
 208                     return "Test that manager.getLogger(Logger.GLOBAL_LOGGER_NAME)"
 209                             + " returns null\n when manager is not the default"
 210                             + " LogManager instance.\n"
 211                             + "Test adding a new logger named \"global\" in that"
 212                             + " non default instance.";
 213                 case Seven: return "Test that manager.getLogger(\"\")"
 214                             + " returns null\n when manager is not the default"
 215                             + " LogManager instance.\n"
 216                             + "Test adding a new logger named \"\" in that"
 217                             + " non default instance.";
 218                 default: return "Undefined";
 219             }
 220         }
 221     };
 222 
 223     /**
 224      * @param args the command line arguments
 225      */
 226     public static void main(String[] args) {
 227         Bridge.init();
 228         EnumSet<TestCase> tests = EnumSet.noneOf(TestCase.class);
 229         for (String arg : args) {
 230             tests.add(TestCase.valueOf(arg));
 231         }
 232         if (args.length == 0) {
 233             tests = EnumSet.complementOf(EnumSet.of(TestCase.LoadingMain));
 234         }
 235         final EnumSet<TestCase> loadingTests =
 236             EnumSet.of(TestCase.LoadingApplet, TestCase.LoadingMain);
 237         int testrun = 0;
 238         for (TestCase test : tests) {
 239             if (loadingTests.contains(test)) {
 240                 if (testrun > 0) {
 241                     throw new UnsupportedOperationException("Test case "
 242                           + test + " must be executed first!");
 243                 }
 244             }
 245             System.out.println("Testing "+ test+": ");
 246             System.out.println(test.describe());
 247             try {
 248                 test.test();
 249             } catch (Exception x) {
 250                throw new Error(String.valueOf(test)
 251                    + (System.getSecurityManager() == null ? " without " : " with ")
 252                    + "security failed: "+x+"\n "+"FAILED: "+test.describe()+"\n", x);
 253             } finally {
 254                 testrun++;
 255             }
 256             Bridge.changeContext();
 257             System.out.println("PASSED: "+ test);
 258         }
 259     }
 260 
 261     public static void testLoadingApplet() {
 262         Bridge.changeContext();
 263 
 264         Logger bar = new Bridge.CustomLogger("com.foo.Bar");
 265         LogManager.getLogManager().addLogger(bar);
 266         assertNotNull(bar.getParent());
 267         testParent(bar);
 268         testParent(LogManager.getLogManager().getLogger("global"));
 269         testParent(LogManager.getLogManager().getLogger(bar.getName()));
 270 
 271         Bridge.desactivate();
 272 
 273         Logger foo = new Bridge.CustomLogger("com.foo.Foo");
 274         boolean b = LogManager.getLogManager().addLogger(foo);
 275         assertEquals(Boolean.TRUE, Boolean.valueOf(b));
 276         assertNotNull(foo.getParent());
 277         testParent(foo);
 278         testParent(LogManager.getLogManager().getLogger("global"));
 279         testParent(LogManager.getLogManager().getLogger(foo.getName()));
 280     }
 281 
 282     public static void testLoadingMain() {
 283         Bridge.desactivate();
 284 
 285         Logger bar = new Bridge.CustomLogger("com.foo.Bar");
 286         LogManager.getLogManager().addLogger(bar);
 287         assertNotNull(bar.getParent());
 288         testParent(bar);
 289         testParent(LogManager.getLogManager().getLogger("global"));
 290         testParent(LogManager.getLogManager().getLogger(bar.getName()));
 291 
 292         Bridge.changeContext();
 293 
 294         Logger foo = new Bridge.CustomLogger("com.foo.Foo");
 295         boolean b = LogManager.getLogManager().addLogger(foo);
 296         assertEquals(Boolean.TRUE, Boolean.valueOf(b));
 297         assertNotNull(foo.getParent());
 298         testParent(foo);
 299         testParent(LogManager.getLogManager().getLogger("global"));
 300         testParent(LogManager.getLogManager().getLogger(foo.getName()));
 301 
 302     }
 303 
 304     public static void testOne() {
 305         for (int i=0; i<3 ; i++) {
 306             Logger logger1 = Logger.getAnonymousLogger();
 307             Logger logger1b = Logger.getAnonymousLogger();
 308             Bridge.changeContext();
 309             Logger logger2 = Logger.getAnonymousLogger();
 310             Logger logger2b = Logger.getAnonymousLogger();
 311             Bridge.changeContext();
 312             Logger logger3 = new Bridge.CustomAnonymousLogger();
 313             Logger logger3b = new Bridge.CustomAnonymousLogger();
 314             Bridge.changeContext();
 315             Logger logger4 = new Bridge.CustomAnonymousLogger();
 316             Logger logger4b = new Bridge.CustomAnonymousLogger();
 317         }
 318     }
 319 
 320 
 321     public static void testTwo() {
 322         for (int i=0; i<3 ; i++) {
 323             Logger logger1 = Logger.getLogger("");
 324             Logger logger1b = Logger.getLogger("");
 325             assertNotNull(logger1);
 326             assertNotNull(logger1b);
 327             assertEquals(logger1, logger1b);
 328             Bridge.changeContext();
 329             Logger logger2 = Logger.getLogger("");
 330             Logger logger2b = Logger.getLogger("");
 331             assertNotNull(logger2);
 332             assertNotNull(logger2b);
 333             assertEquals(logger2, logger2b);
 334             assertEquals(logger1, logger2);
 335         }
 336     }
 337 
 338     public static void testThree() {
 339         for (int i=0; i<3 ; i++) {
 340             Logger logger1 = LogManager.getLogManager().getLogger("");
 341             Logger logger1b = LogManager.getLogManager().getLogger("");
 342             assertNotNull(logger1);
 343             assertNotNull(logger1b);
 344             assertEquals(logger1, logger1b);
 345             Bridge.changeContext();
 346             Logger logger2 = LogManager.getLogManager().getLogger("");
 347             Logger logger2b = LogManager.getLogManager().getLogger("");
 348             assertNotNull(logger2);
 349             assertNotNull(logger2b);
 350             assertEquals(logger2, logger2b);
 351             assertEquals(logger1, logger2);
 352         }
 353     }
 354 
 355     public static void testFour() {
 356         for (int i=0; i<3 ; i++) {
 357             Logger logger1 = Logger.getLogger(Logger.GLOBAL_LOGGER_NAME);
 358             Logger logger1b = Logger.getLogger(Logger.GLOBAL_LOGGER_NAME);
 359             assertNotNull(logger1);
 360             assertNotNull(logger1b);
 361             assertEquals(logger1, logger1b);
 362             Bridge.changeContext();
 363 
 364             Logger logger2 = Logger.getLogger(Logger.GLOBAL_LOGGER_NAME);
 365             Logger logger2b = Logger.getLogger(Logger.GLOBAL_LOGGER_NAME);
 366             assertNotNull(logger2);
 367             assertNotNull(logger2b);
 368             assertEquals(logger2, logger2b);
 369 
 370             assertEquals(logger1, logger2);
 371 
 372             Bridge.changeContext();
 373             Logger logger3 = new Bridge.CustomAnonymousLogger(Logger.GLOBAL_LOGGER_NAME);
 374             Logger logger3b = new Bridge.CustomAnonymousLogger(Logger.GLOBAL_LOGGER_NAME);
 375             Bridge.changeContext();
 376             Logger logger4 = new Bridge.CustomAnonymousLogger(Logger.GLOBAL_LOGGER_NAME);
 377             Logger logger4b = new Bridge.CustomAnonymousLogger(Logger.GLOBAL_LOGGER_NAME);
 378         }
 379     }
 380 
 381     public static void testFive() {
 382         for (int i=0; i<3 ; i++) {
 383             Logger logger1 = LogManager.getLogManager().getLogger(Logger.GLOBAL_LOGGER_NAME);
 384             Logger logger1b = LogManager.getLogManager().getLogger(Logger.GLOBAL_LOGGER_NAME);
 385             assertNotNull(logger1);
 386             assertNotNull(logger1b);
 387             assertEquals(logger1, logger1b);
 388 
 389             Bridge.changeContext();
 390 
 391             Logger logger2 = LogManager.getLogManager().getLogger(Logger.GLOBAL_LOGGER_NAME);
 392             Logger logger2b = LogManager.getLogManager().getLogger(Logger.GLOBAL_LOGGER_NAME);
 393             assertNotNull(logger2);
 394             assertNotNull(logger2b);
 395             assertEquals(logger2, logger2b);
 396 
 397             assertEquals(logger1, logger2);
 398         }
 399     }
 400 
 401     /**
 402      * This test is designed to test the behavior of additional LogManager instances.
 403      * It must be noted that if the security manager is off, then calling
 404      * Bridge.changeContext() has actually no effect - which explains why we have
 405      * some differences between the cases security manager on & security manager
 406      * off.
 407      **/
 408     public static void testSix() {
 409         for (int i=0; i<3 ; i++) {
 410             Bridge.desactivate();
 411             LogManager manager = new LogManager() {};
 412             Logger logger1 = manager.getLogger(Logger.GLOBAL_LOGGER_NAME);
 413             Logger logger1b = manager.getLogger(Logger.GLOBAL_LOGGER_NAME);
 414             assertNull(logger1);
 415             assertNull(logger1b);
 416             Logger global = new Bridge.CustomLogger(Logger.GLOBAL_LOGGER_NAME);
 417             manager.addLogger(global);
 418             Logger logger2 = manager.getLogger(Logger.GLOBAL_LOGGER_NAME);
 419             Logger logger2b = manager.getLogger(Logger.GLOBAL_LOGGER_NAME);
 420             assertNotNull(logger2);
 421             assertNotNull(logger2b);
 422             assertEquals(logger2, global);
 423             assertEquals(logger2b, global);
 424             assertNull(manager.getLogger(""));
 425             assertNull(manager.getLogger(""));
 426 
 427             for (int j = 0; j<3; j++) {
 428                 Bridge.changeContext();
 429 
 430                 // this is not a supported configuration:
 431                 // We are in an applet context with several log managers.
 432                 // We however need to check our assumptions...
 433 
 434                 // Applet context => root logger and global logger should also be null.
 435 
 436                 Logger expected = (System.getSecurityManager() == null ? global : null);
 437                 Logger logger3 = manager.getLogger(Logger.GLOBAL_LOGGER_NAME);
 438                 Logger logger3b = manager.getLogger(Logger.GLOBAL_LOGGER_NAME);
 439                 assertEquals(expected, logger3);
 440                 assertEquals(expected, logger3b);
 441                 Logger global2 = new Bridge.CustomLogger(Logger.GLOBAL_LOGGER_NAME);
 442                 manager.addLogger(global2);
 443                 Logger logger4 = manager.getLogger(Logger.GLOBAL_LOGGER_NAME);
 444                 Logger logger4b = manager.getLogger(Logger.GLOBAL_LOGGER_NAME);
 445                 assertNotNull(logger4);
 446                 assertNotNull(logger4b);
 447                 expected = (System.getSecurityManager() == null ? global : global2);;
 448                 assertEquals(logger4,  expected);
 449                 assertEquals(logger4b, expected);
 450 
 451                 Logger logger5 = manager.getLogger("");
 452                 Logger logger5b = manager.getLogger("");
 453                 Logger expectedRoot = null;
 454                 assertEquals(logger5, expectedRoot);
 455                 assertEquals(logger5b, expectedRoot);
 456             }
 457 
 458         }
 459     }
 460 
 461     /**
 462      * This test is designed to test the behavior of additional LogManager instances.
 463      * It must be noted that if the security manager is off, then calling
 464      * Bridge.changeContext() has actually no effect - which explains why we have
 465      * some differences between the cases security manager on & security manager
 466      * off.
 467      **/
 468     public static void testSeven() {
 469         for (int i=0; i<3 ; i++) {
 470             Bridge.desactivate();
 471             LogManager manager = new LogManager() {};
 472             Logger logger1 = manager.getLogger("");
 473             Logger logger1b = manager.getLogger("");
 474             assertNull(logger1);
 475             assertNull(logger1b);
 476             Logger global = new Bridge.CustomLogger(Logger.GLOBAL_LOGGER_NAME);
 477             manager.addLogger(global);
 478             Logger logger2 = manager.getLogger(Logger.GLOBAL_LOGGER_NAME);
 479             Logger logger2b = manager.getLogger(Logger.GLOBAL_LOGGER_NAME);
 480             assertNotNull(logger2);
 481             assertNotNull(logger2b);
 482             assertEquals(logger2, global);
 483             assertEquals(logger2b, global);
 484             Logger logger3 = manager.getLogger("");
 485             Logger logger3b = manager.getLogger("");
 486             assertNull(logger3);
 487             assertNull(logger3b);
 488             Logger root = new Bridge.CustomLogger("");
 489             manager.addLogger(root);
 490             Logger logger4 = manager.getLogger("");
 491             Logger logger4b = manager.getLogger("");
 492             assertNotNull(logger4);
 493             assertNotNull(logger4b);
 494             assertEquals(logger4, root);
 495             assertEquals(logger4b, root);
 496 
 497             for (int j = 0 ; j < 3 ; j++) {
 498                 Bridge.changeContext();
 499 
 500                 // this is not a supported configuration:
 501                 // We are in an applet context with several log managers.
 502                 // We however need to check our assumptions...
 503 
 504                 // Applet context => root logger and global logger should also be null.
 505 
 506                 Logger logger5 = manager.getLogger("");
 507                 Logger logger5b = manager.getLogger("");
 508                 Logger expectedRoot = (System.getSecurityManager() == null ? root : null);
 509                 assertEquals(logger5, expectedRoot);
 510                 assertEquals(logger5b, expectedRoot);
 511 
 512                 if (System.getSecurityManager() != null) {
 513                     assertNull(manager.getLogger(Logger.GLOBAL_LOGGER_NAME));
 514                 } else {
 515                     assertEquals(global, manager.getLogger(Logger.GLOBAL_LOGGER_NAME));
 516                 }
 517 
 518                 Logger global2 = new Bridge.CustomLogger(Logger.GLOBAL_LOGGER_NAME);
 519                 manager.addLogger(global2);
 520                 Logger logger6 = manager.getLogger(Logger.GLOBAL_LOGGER_NAME);
 521                 Logger logger6b = manager.getLogger(Logger.GLOBAL_LOGGER_NAME);
 522                 Logger expectedGlobal = (System.getSecurityManager() == null ? global : global2);
 523 
 524                 assertNotNull(logger6);
 525                 assertNotNull(logger6b);
 526                 assertEquals(logger6, expectedGlobal);
 527                 assertEquals(logger6b, expectedGlobal);
 528                 if (System.getSecurityManager() != null) {
 529                     assertNull(manager.getLogger(""));
 530                 } else {
 531                     assertEquals(root, manager.getLogger(""));
 532                 }
 533 
 534                 Logger root2 = new Bridge.CustomLogger("");
 535                 manager.addLogger(root2);
 536                 expectedRoot = (System.getSecurityManager() == null ? root : root2);
 537                 Logger logger7 = manager.getLogger("");
 538                 Logger logger7b = manager.getLogger("");
 539                 assertNotNull(logger7);
 540                 assertNotNull(logger7b);
 541                 assertEquals(logger7, expectedRoot);
 542                 assertEquals(logger7b, expectedRoot);
 543             }
 544         }
 545     }
 546 
 547     public static void testParent(Logger logger) {
 548         Logger l = logger;
 549         while (l.getParent() != null) {
 550             l = l.getParent();
 551         }
 552         assertEquals("", l.getName());
 553     }
 554 
 555     public static class TestError extends RuntimeException {
 556         public TestError(String msg) {
 557             super(msg);
 558         }
 559     }
 560 
 561     public static void assertNotNull(Object obj) {
 562         if (obj == null) throw new NullPointerException();
 563     }
 564 
 565     public static void assertNull(Object obj) {
 566         if (obj != null) throw new TestError("Null expected, got "+obj);
 567     }
 568 
 569     public static void assertEquals(Object o1, Object o2) {
 570         if (o1 != o2) {
 571             throw new TestError(o1 + " != " + o2);
 572         }
 573     }
 574 
 575     public static void assertNotEquals(Object o1, Object o2) {
 576         if (o1 == o2) {
 577             throw new TestError(o1 + " == " + o2);
 578         }
 579     }
 580 }