1 /* 2 * Licensed to the Apache Software Foundation (ASF) under one or more 3 * contributor license agreements. See the NOTICE file distributed with 4 * this work for additional information regarding copyright ownership. 5 * The ASF licenses this file to You under the Apache License, Version 2.0 6 * (the "License"); you may not use this file except in compliance with 7 * the License. You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18 package org.apache.harmony.logging.tests.java.util.logging; 19 20 import java.beans.PropertyChangeEvent; 21 import java.beans.PropertyChangeListener; 22 import java.io.FileNotFoundException; 23 import java.io.IOException; 24 import java.io.InputStream; 25 import java.io.PrintStream; 26 import java.security.Permission; 27 import java.util.Enumeration; 28 import java.util.Properties; 29 import java.util.logging.ConsoleHandler; 30 import java.util.logging.Handler; 31 import java.util.logging.Level; 32 import java.util.logging.LogManager; 33 import java.util.logging.LogRecord; 34 import java.util.logging.Logger; 35 import java.util.logging.LoggingPermission; 36 37 import junit.framework.TestCase; 38 39 import org.apache.harmony.logging.tests.java.util.logging.HandlerTest.NullOutputStream; 40 import org.apache.harmony.logging.tests.java.util.logging.util.EnvironmentHelper; 41 42 /** 43 * add/get logger(dot) 44 */ 45 public class LogManagerTest extends TestCase { 46 47 private static final String FOO = "LogManagerTestFoo"; 48 49 LogManager mockManager; 50 51 LogManager manager = LogManager.getLogManager(); 52 53 MockPropertyChangeListener listener; 54 55 Properties props; 56 57 private static String className = LogManagerTest.class.getName(); 58 59 static Handler handler = null; 60 61 static final String CONFIG_CLASS = "java.util.logging.config.class"; 62 63 static final String CONFIG_FILE = "java.util.logging.config.file"; 64 65 static final String MANAGER_CLASS = "java.util.logging.config.manager"; 66 67 static final String clearPath = System.getProperty("clearpath"); 68 69 70 /* 71 * @see TestCase#setUp() 72 */ setUp()73 protected void setUp() throws Exception { 74 super.setUp(); 75 mockManager = new MockLogManager(); 76 listener = new MockPropertyChangeListener(); 77 handler = new MockHandler(); 78 props = initProps(); 79 } 80 initProps()81 static Properties initProps() throws Exception { 82 Properties props = new Properties(); 83 props.put("handlers", className + "$MockHandler " + className 84 + "$MockHandler"); 85 props.put("java.util.logging.FileHandler.pattern", "%h/java%u.log"); 86 props.put("java.util.logging.FileHandler.limit", "50000"); 87 props.put("java.util.logging.FileHandler.count", "5"); 88 props.put("java.util.logging.FileHandler.formatter", 89 "java.util.logging.XMLFormatter"); 90 props.put(".level", "FINE"); 91 props.put("java.util.logging.ConsoleHandler.level", "OFF"); 92 props.put("java.util.logging.ConsoleHandler.formatter", 93 "java.util.logging.SimpleFormatter"); 94 props.put("LogManagerTestFoo.handlers", "java.util.logging.ConsoleHandler"); 95 props.put("LogManagerTestFoo.level", "WARNING"); 96 return props; 97 } 98 99 /* 100 * @see TestCase#tearDown() 101 */ tearDown()102 protected void tearDown() throws Exception { 103 super.tearDown(); 104 handler = null; 105 } 106 testAddGetLogger()107 public void testAddGetLogger() { 108 Logger log = new MockLogger(FOO, null); 109 Logger foo = mockManager.getLogger(FOO); 110 assertNull(foo); 111 assertTrue(mockManager.addLogger(log)); 112 foo = mockManager.getLogger(FOO); 113 assertSame(foo, log); 114 assertNull(foo.getParent()); 115 116 try { 117 mockManager.addLogger(null); 118 fail("add null should throw NullPointerException"); 119 } catch (NullPointerException e) { 120 } 121 122 try { 123 mockManager.getLogger(null); 124 fail("get null should throw NullPointerException"); 125 } catch (NullPointerException e) { 126 } 127 128 assertNull(mockManager.getLogger("bad name")); 129 130 Enumeration<String> enumar = mockManager.getLoggerNames(); 131 int i = 0; 132 while (enumar.hasMoreElements()) { 133 String name = (String) enumar.nextElement(); 134 i++; 135 assertEquals(FOO, name); 136 } 137 assertEquals(i, 1); 138 } 139 testAddGetLogger_duplicateName()140 public void testAddGetLogger_duplicateName() { 141 // add logger with duplicate name has no effect 142 Logger foo = new MockLogger(FOO, null); 143 Logger foo2 = new MockLogger(FOO, null); 144 assertTrue(mockManager.addLogger(foo)); 145 assertSame(foo, mockManager.getLogger(FOO)); 146 assertFalse(mockManager.addLogger(foo2)); 147 assertSame(foo, mockManager.getLogger(FOO)); 148 Enumeration<String> enumar = mockManager.getLoggerNames(); 149 int i = 0; 150 while (enumar.hasMoreElements()) { 151 enumar.nextElement(); 152 i++; 153 } 154 assertEquals(1, i); 155 } 156 testAddGetLogger_Hierachy()157 public void testAddGetLogger_Hierachy() { 158 Logger foo = new MockLogger("testAddGetLogger_Hierachy.foo", null); 159 Logger child = new MockLogger("testAddGetLogger_Hierachy.foo.child", 160 null); 161 Logger fakeChild = new MockLogger( 162 "testAddGetLogger_Hierachy.foo2.child", null); 163 Logger grandson = new MockLogger( 164 "testAddGetLogger_Hierachy.foo.child.grandson", null); 165 Logger otherChild = new MockLogger( 166 "testAddGetLogger_Hierachy.foo.child", null); 167 assertNull(foo.getParent()); 168 assertNull(child.getParent()); 169 assertNull(grandson.getParent()); 170 assertNull(otherChild.getParent()); 171 172 // whenever a logger is added to a LogManager, hierarchy will be updated 173 // accordingly 174 assertTrue(mockManager.addLogger(child)); 175 assertNull(child.getParent()); 176 177 assertTrue(mockManager.addLogger(fakeChild)); 178 assertNull(fakeChild.getParent()); 179 180 assertTrue(mockManager.addLogger(grandson)); 181 assertSame(child, grandson.getParent()); 182 183 assertTrue(mockManager.addLogger(foo)); 184 assertSame(foo, child.getParent()); 185 assertNull(foo.getParent()); 186 assertNull(fakeChild.getParent()); 187 188 // but for non-mock LogManager, foo's parent should be root 189 assertTrue(manager.addLogger(foo)); 190 assertSame(manager.getLogger(""), manager.getLogger( 191 "testAddGetLogger_Hierachy.foo").getParent()); 192 193 // if we add one logger to two LogManager, parent will changed 194 assertTrue(manager.addLogger(otherChild)); 195 assertTrue(manager.addLogger(grandson)); 196 assertSame(foo, otherChild.getParent()); 197 assertSame(otherChild, grandson.getParent()); 198 } 199 testAddLoggerReverseOrder()200 public void testAddLoggerReverseOrder() { 201 Logger root = new MockLogger("testAddLoggerReverseOrder", null); 202 Logger foo = new MockLogger("testAddLoggerReverseOrder.foo", null); 203 Logger fooChild = new MockLogger("testAddLoggerReverseOrder.foo.child", 204 null); 205 Logger fooGrandChild = new MockLogger( 206 "testAddLoggerReverseOrder.foo.child.grand", null); 207 Logger fooGrandChild2 = new MockLogger( 208 "testAddLoggerReverseOrder.foo.child.grand2", null); 209 210 Logger realRoot = manager.getLogger(""); 211 212 manager.addLogger(fooGrandChild); 213 assertEquals(realRoot, fooGrandChild.getParent()); 214 215 manager.addLogger(root); 216 assertSame(root, fooGrandChild.getParent()); 217 assertSame(realRoot, root.getParent()); 218 219 manager.addLogger(foo); 220 assertSame(root, foo.getParent()); 221 assertSame(foo, fooGrandChild.getParent()); 222 223 manager.addLogger(fooGrandChild2); 224 assertSame(foo, fooGrandChild2.getParent()); 225 assertSame(foo, fooGrandChild.getParent()); 226 227 manager.addLogger(fooChild); 228 assertSame(fooChild, fooGrandChild2.getParent()); 229 assertSame(fooChild, fooGrandChild.getParent()); 230 assertSame(foo, fooChild.getParent()); 231 assertSame(root, foo.getParent()); 232 assertSame(realRoot, root.getParent()); 233 } 234 testAddSimiliarLogger()235 public void testAddSimiliarLogger() { 236 Logger root = new MockLogger("testAddSimiliarLogger", null); 237 Logger foo = new MockLogger("testAddSimiliarLogger.foo", null); 238 Logger similiarFoo = new MockLogger("testAddSimiliarLogger.fop", null); 239 Logger fooo = new MockLogger("testAddSimiliarLogger.fooo", null); 240 Logger fooChild = new MockLogger("testAddSimiliarLogger.foo.child", 241 null); 242 Logger similiarFooChild = new MockLogger( 243 "testAddSimiliarLogger.fop.child", null); 244 Logger foooChild = new MockLogger("testAddSimiliarLogger.fooo.child", 245 null); 246 247 manager.addLogger(root); 248 manager.addLogger(fooChild); 249 manager.addLogger(similiarFooChild); 250 manager.addLogger(foooChild); 251 assertSame(root, fooChild.getParent()); 252 assertSame(root, similiarFooChild.getParent()); 253 assertSame(root, foooChild.getParent()); 254 255 manager.addLogger(foo); 256 assertSame(foo, fooChild.getParent()); 257 assertSame(root, similiarFooChild.getParent()); 258 assertSame(root, foooChild.getParent()); 259 260 manager.addLogger(similiarFoo); 261 assertSame(foo, fooChild.getParent()); 262 assertSame(similiarFoo, similiarFooChild.getParent()); 263 assertSame(root, foooChild.getParent()); 264 265 manager.addLogger(fooo); 266 assertSame(fooo, foooChild.getParent()); 267 } 268 testAddGetLogger_nameWithSpace()269 public void testAddGetLogger_nameWithSpace() { 270 Logger foo = new MockLogger(FOO, null); 271 Logger fooBeforeSpace = new MockLogger(FOO + " ", null); 272 Logger fooAfterSpace = new MockLogger(" " + FOO, null); 273 Logger fooWithBothSpace = new MockLogger(" " + FOO + " ", null); 274 assertTrue(mockManager.addLogger(foo)); 275 assertTrue(mockManager.addLogger(fooBeforeSpace)); 276 assertTrue(mockManager.addLogger(fooAfterSpace)); 277 assertTrue(mockManager.addLogger(fooWithBothSpace)); 278 279 assertSame(foo, mockManager.getLogger(FOO)); 280 assertSame(fooBeforeSpace, mockManager.getLogger(FOO + " ")); 281 assertSame(fooAfterSpace, mockManager.getLogger(" " + FOO)); 282 assertSame(fooWithBothSpace, mockManager.getLogger(" " + FOO + " ")); 283 } 284 testAddGetLogger_addRoot()285 public void testAddGetLogger_addRoot() throws IOException { 286 Logger foo = new MockLogger(FOO, null); 287 Logger fooChild = new MockLogger(FOO + ".child", null); 288 Logger other = new MockLogger("other", null); 289 Logger root = new MockLogger("", null); 290 assertNull(foo.getParent()); 291 assertNull(root.getParent()); 292 assertNull(other.getParent()); 293 294 // add root to mock logmanager and it works as "root" logger 295 assertTrue(mockManager.addLogger(foo)); 296 assertTrue(mockManager.addLogger(other)); 297 assertTrue(mockManager.addLogger(fooChild)); 298 assertNull(foo.getParent()); 299 assertNull(other.getParent()); 300 assertSame(foo, fooChild.getParent()); 301 302 assertTrue(mockManager.addLogger(root)); 303 assertSame(root, foo.getParent()); 304 assertSame(root, other.getParent()); 305 assertNull(root.getParent()); 306 307 // try to add root logger to non-mock LogManager, no effect 308 assertFalse(manager.addLogger(root)); 309 assertNotSame(root, manager.getLogger("")); 310 } 311 testDefaultLoggerProperties()312 public void testDefaultLoggerProperties() throws Exception { 313 // mock LogManager has no default logger 314 assertNull(mockManager.getLogger("")); 315 assertNull(mockManager.getLogger("global")); 316 317 // non-mock LogManager has two default logger 318 Logger global = manager.getLogger("global"); 319 Logger root = manager.getLogger(""); 320 321 assertSame(global, Logger.global); 322 assertSame(root, global.getParent()); 323 324 // root properties 325 manager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props)); 326 assertNull(root.getFilter()); 327 assertEquals(2, root.getHandlers().length); 328 assertEquals(Level.FINE, root.getLevel()); 329 assertEquals("", root.getName()); 330 assertSame(root.getParent(), null); 331 assertNull(root.getResourceBundle()); 332 assertNull(root.getResourceBundleName()); 333 assertTrue(root.getUseParentHandlers()); 334 335 } 336 testMockGetProperty()337 public void testMockGetProperty() throws Exception { 338 // mock manager doesn't read configuration until you call 339 // readConfiguration() 340 Logger root = new MockLogger("", null); 341 assertTrue(mockManager.addLogger(root)); 342 root = mockManager.getLogger(""); 343 checkPropertyNull(mockManager); 344 assertEquals(0, root.getHandlers().length); 345 assertNull(root.getLevel()); 346 mockManager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props)); 347 assertEquals(Level.FINE, root.getLevel()); 348 checkProperty(mockManager); 349 mockManager.reset(); 350 checkPropertyNull(mockManager); 351 assertEquals(Level.INFO, root.getLevel()); 352 assertEquals(0, mockManager.getLogger("").getHandlers().length); 353 } 354 testGetProperty()355 public void testGetProperty() throws SecurityException, IOException { 356 // //FIXME: move it to exec 357 // manager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props)); 358 // Logger root = manager.getLogger(""); 359 //// checkProperty(manager); 360 // assertEquals(Level.FINE, root.getLevel()); 361 // assertEquals(2, root.getHandlers().length); 362 363 // but non-mock manager DO read it from the very beginning 364 Logger root = manager.getLogger(""); 365 manager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props)); 366 checkProperty(manager); 367 assertEquals(2, root.getHandlers().length); 368 assertEquals(Level.FINE, root.getLevel()); 369 370 manager.reset(); 371 checkPropertyNull(manager); 372 assertEquals(0, root.getHandlers().length); 373 assertEquals(Level.INFO, root.getLevel()); 374 manager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props)); 375 } 376 testReadConfiguration_null()377 public void testReadConfiguration_null() throws SecurityException, 378 IOException { 379 try { 380 manager.readConfiguration(null); 381 fail("should throw null pointer exception"); 382 } catch (NullPointerException e) { 383 } 384 385 } 386 testReadConfiguration()387 public void testReadConfiguration() throws SecurityException, 388 IOException { 389 390 MockConfigLogManager lm = new MockConfigLogManager(); 391 assertFalse(lm.isCalled); 392 393 lm.readConfiguration(); 394 assertTrue(lm.isCalled); 395 } 396 checkPropertyNull(LogManager m)397 private static void checkPropertyNull(LogManager m) { 398 // assertNull(m.getProperty(".level")); 399 assertNull(m.getProperty("java.util.logging.FileHandler.limit")); 400 assertNull(m.getProperty("java.util.logging.ConsoleHandler.formatter")); 401 // assertNull(m.getProperty("handlers")); 402 assertNull(m.getProperty("java.util.logging.FileHandler.count")); 403 assertNull(m.getProperty("com.xyz.foo.level")); 404 assertNull(m.getProperty("java.util.logging.FileHandler.formatter")); 405 assertNull(m.getProperty("java.util.logging.ConsoleHandler.level")); 406 assertNull(m.getProperty("java.util.logging.FileHandler.pattern")); 407 } 408 checkProperty(LogManager m)409 private static void checkProperty(LogManager m) { 410 // assertEquals(m.getProperty(".level"), "INFO"); 411 assertEquals(m.getProperty("java.util.logging.FileHandler.limit"), 412 "50000"); 413 assertEquals(m 414 .getProperty("java.util.logging.ConsoleHandler.formatter"), 415 "java.util.logging.SimpleFormatter"); 416 // assertEquals(m.getProperty("handlers"), 417 // "java.util.logging.ConsoleHandler"); 418 assertEquals(m.getProperty("java.util.logging.FileHandler.count"), "5"); 419 assertEquals(m.getProperty("LogManagerTestFoo.level"), "WARNING"); 420 assertEquals(m.getProperty("java.util.logging.FileHandler.formatter"), 421 "java.util.logging.XMLFormatter"); 422 assertEquals(m.getProperty("java.util.logging.ConsoleHandler.level"), 423 "OFF"); 424 assertEquals(m.getProperty("java.util.logging.FileHandler.pattern"), 425 "%h/java%u.log"); 426 } 427 428 // public void testReadConfiguration() throws SecurityException, IOException { 429 // FIXME: move the support_exec 430 // Logger foo = new MockLogger("foo", null); 431 // assertNull(foo.getLevel()); 432 // assertTrue(mockManager.addLogger(foo)); 433 // 434 // Logger fo = new MockLogger("foo2", null); 435 // fo.setLevel(Level.ALL); 436 // assertTrue(mockManager.addLogger(fo)); 437 // 438 // Handler h = new ConsoleHandler(); 439 // Level l = h.getLevel(); 440 // assertNotSame(Level.OFF, h.getLevel()); 441 // 442 // // read configuration 443 // mockManager.readConfiguration(); 444 // // level DO has effect 445 // assertEquals(Level.WARNING, foo.getLevel()); 446 // // for non specified logger, level is reset to null 447 // assertNull(fo.getLevel()); 448 // 449 // // read properties don't affect handler 450 // assertNotSame(Level.OFF, h.getLevel()); 451 // assertSame(l, h.getLevel()); 452 // 453 // } 454 455 /* 456 * Class under test for void readConfiguration(InputStream) 457 */ testReadConfigurationInputStream()458 public void testReadConfigurationInputStream() throws IOException { 459 // mock LogManager 460 InputStream stream = EnvironmentHelper.PropertiesToInputStream(props); 461 462 Logger foo = new MockLogger(FOO, null); 463 assertNull(foo.getLevel()); 464 assertTrue(mockManager.addLogger(foo)); 465 466 Logger fo = new MockLogger("LogManagerTestFoo2", null); 467 fo.setLevel(Level.ALL); 468 assertTrue(mockManager.addLogger(fo)); 469 470 Handler h = new ConsoleHandler(); 471 Level l = h.getLevel(); 472 assertNotSame(Level.OFF, h.getLevel()); 473 474 // read configuration from stream 475 mockManager.readConfiguration(stream); 476 stream.close(); 477 478 // level DO has effect 479 assertEquals(Level.WARNING, foo.getLevel()); 480 481 // for non specified logger, level is reset to null 482 assertNull(fo.getLevel()); 483 484 // read properties don't affect handler 485 assertNotSame(Level.OFF, h.getLevel()); 486 assertSame(l, h.getLevel()); 487 } 488 testReadConfigurationInputStream_null()489 public void testReadConfigurationInputStream_null() 490 throws SecurityException, IOException { 491 try { 492 mockManager.readConfiguration(null); 493 fail("should throw null pointer exception"); 494 } catch (NullPointerException e) { 495 } 496 497 } 498 testReadConfigurationInputStream_root()499 public void testReadConfigurationInputStream_root() throws IOException { 500 InputStream stream = EnvironmentHelper.PropertiesToInputStream(props); 501 manager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props)); 502 503 Logger logger = new MockLogger( 504 "testReadConfigurationInputStream_root.foo", null); 505 Logger root = manager.getLogger(""); 506 Logger logger2 = Logger 507 .getLogger("testReadConfigurationInputStream_root.foo2"); 508 509 manager.addLogger(logger); 510 assertNull(logger.getLevel()); 511 assertEquals(0, logger.getHandlers().length); 512 assertSame(root, logger.getParent()); 513 514 assertNull(logger2.getLevel()); 515 assertEquals(0, logger2.getHandlers().length); 516 assertSame(root, logger2.getParent()); 517 // if (!hasConfigClass) { 518 assertEquals(Level.FINE, root.getLevel()); 519 assertEquals(2, root.getHandlers().length); 520 // } 521 522 // after read stream 523 manager.readConfiguration(stream); 524 assertEquals(Level.FINE, root.getLevel()); 525 assertEquals(2, root.getHandlers().length); 526 assertNull(logger.getLevel()); 527 assertEquals(0, logger.getHandlers().length); 528 stream.close(); 529 } 530 testReadConfigurationUpdatesRootLoggersHandlers()531 public void testReadConfigurationUpdatesRootLoggersHandlers() 532 throws IOException { 533 Properties properties = new Properties(); 534 LogManager.getLogManager().readConfiguration( 535 EnvironmentHelper.PropertiesToInputStream(properties)); 536 537 Logger root = Logger.getLogger(""); 538 assertEquals(0, root.getHandlers().length); 539 540 properties.put("handlers", "java.util.logging.ConsoleHandler"); 541 LogManager.getLogManager().readConfiguration( 542 EnvironmentHelper.PropertiesToInputStream(properties)); 543 544 assertEquals(1, root.getHandlers().length); 545 } 546 testReadConfigurationDoesNotUpdateOtherLoggers()547 public void testReadConfigurationDoesNotUpdateOtherLoggers() 548 throws IOException { 549 Properties properties = new Properties(); 550 LogManager.getLogManager().readConfiguration( 551 EnvironmentHelper.PropertiesToInputStream(properties)); 552 553 Logger logger = Logger.getLogger("testReadConfigurationDoesNotUpdateOtherLoggers"); 554 assertEquals(0, logger.getHandlers().length); 555 556 properties.put("testReadConfigurationDoesNotUpdateOtherLoggers.handlers", 557 "java.util.logging.ConsoleHandler"); 558 LogManager.getLogManager().readConfiguration( 559 EnvironmentHelper.PropertiesToInputStream(properties)); 560 561 assertEquals(0, logger.getHandlers().length); 562 } 563 testAddRemovePropertyChangeListener()564 public void testAddRemovePropertyChangeListener() throws Exception { 565 MockPropertyChangeListener listener1 = new MockPropertyChangeListener(); 566 MockPropertyChangeListener listener2 = new MockPropertyChangeListener(); 567 // add same listener1 two times 568 mockManager.addPropertyChangeListener(listener1); 569 mockManager.addPropertyChangeListener(listener1); 570 mockManager.addPropertyChangeListener(listener2); 571 572 assertNull(listener1.getEvent()); 573 assertNull(listener2.getEvent()); 574 mockManager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props)); 575 // if (!hasConfigClass) { 576 assertNotNull(listener1.getEvent()); 577 assertNotNull(listener2.getEvent()); 578 // } 579 580 listener1.reset(); 581 listener2.reset(); 582 583 // remove listener1, no effect 584 mockManager.removePropertyChangeListener(listener1); 585 mockManager.readConfiguration(EnvironmentHelper 586 .PropertiesToInputStream(props)); 587 assertNotNull(listener1.getEvent()); 588 assertNotNull(listener2.getEvent()); 589 listener1.reset(); 590 listener2.reset(); 591 592 // remove listener1 again and it works 593 mockManager.removePropertyChangeListener(listener1); 594 mockManager.readConfiguration(EnvironmentHelper 595 .PropertiesToInputStream(props)); 596 assertNull(listener1.getEvent()); 597 assertNotNull(listener2.getEvent()); 598 listener2.reset(); 599 600 // reset don't produce event 601 mockManager.reset(); 602 assertNull(listener2.getEvent()); 603 604 mockManager.removePropertyChangeListener(listener2); 605 mockManager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props)); 606 assertNull(listener1.getEvent()); 607 assertNull(listener2.getEvent()); 608 } 609 testAddRemovePropertyChangeListener_null()610 public void testAddRemovePropertyChangeListener_null() { 611 // seems nothing happened 612 try { 613 mockManager.addPropertyChangeListener(null); 614 fail("Should throw NPE"); 615 } catch (NullPointerException e) { 616 } 617 mockManager.removePropertyChangeListener(null); 618 } 619 testReset()620 public void testReset() throws SecurityException, IOException { 621 // mock LogManager 622 mockManager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props)); 623 assertNotNull(mockManager.getProperty("handlers")); 624 Logger foo = new MockLogger(FOO, null); 625 assertNull(foo.getLevel()); 626 assertEquals(0, foo.getHandlers().length); 627 foo.setLevel(Level.ALL); 628 foo.addHandler(new ConsoleHandler()); 629 assertTrue(mockManager.addLogger(foo)); 630 assertEquals(Level.WARNING, foo.getLevel()); 631 assertEquals(2, foo.getHandlers().length); 632 633 // reset 634 mockManager.reset(); 635 636 // properties is cleared 637 assertNull(mockManager.getProperty("handlers")); 638 639 // level is null 640 assertNull(foo.getLevel()); 641 // handlers are all closed 642 assertEquals(0, foo.getHandlers().length); 643 644 // for root logger 645 manager.reset(); 646 assertNull(manager.getProperty("handlers")); 647 Logger root = manager.getLogger(""); 648 // level reset to info 649 assertEquals(Level.INFO, root.getLevel()); 650 // also close root's handler 651 assertEquals(0, root.getHandlers().length); 652 } 653 testGlobalPropertyConfig()654 public void testGlobalPropertyConfig() throws Exception { 655 PrintStream err = System.err; 656 try { 657 System.setErr(new PrintStream(new NullOutputStream())); 658 // before add config property, root has two handler 659 manager.readConfiguration(EnvironmentHelper 660 .PropertiesToInputStream(props)); 661 assertEquals(2, manager.getLogger("").getHandlers().length); 662 663 // one valid config class 664 props.setProperty("config", className + "$MockValidConfig"); 665 manager.readConfiguration(EnvironmentHelper 666 .PropertiesToInputStream(props)); 667 assertEquals(3, manager.getLogger("").getHandlers().length); 668 669 // two config class take effect orderly 670 props.setProperty("config", className + "$MockValidConfig " 671 + className + "$MockValidConfig2"); 672 manager.readConfiguration(EnvironmentHelper 673 .PropertiesToInputStream(props)); 674 assertEquals(2, manager.getLogger("").getHandlers().length); 675 676 props.setProperty("config", className + "$MockValidConfig2 " 677 + className + "$MockValidConfig"); 678 manager.readConfiguration(EnvironmentHelper 679 .PropertiesToInputStream(props)); 680 assertEquals(3, manager.getLogger("").getHandlers().length); 681 682 // invalid config class which throw exception, just print exception 683 // and 684 // message 685 props.setProperty("config", className 686 + "$MockInvalidConfigException"); 687 manager.readConfiguration(EnvironmentHelper 688 .PropertiesToInputStream(props)); 689 690 // invalid config class without default constructor, just print 691 // exception and message 692 props.setProperty("config", className 693 + "$MockInvalidConfigNoDefaultConstructor"); 694 manager.readConfiguration(EnvironmentHelper 695 .PropertiesToInputStream(props)); 696 697 // bad config class name, just print exception and message 698 props.setProperty("config", "badname"); 699 manager.readConfiguration(EnvironmentHelper 700 .PropertiesToInputStream(props)); 701 702 // invalid separator, nothing happened 703 props.setProperty("config", className + "$MockValidConfig2;" 704 + className + "$MockValidConfig"); 705 manager.readConfiguration(EnvironmentHelper 706 .PropertiesToInputStream(props)); 707 assertEquals(2, manager.getLogger("").getHandlers().length); 708 props.setProperty("config", className + "$MockValidConfig2;" 709 + className + "$MockValidConfig " + className 710 + "$MockValidConfig"); 711 manager.readConfiguration(EnvironmentHelper 712 .PropertiesToInputStream(props)); 713 assertEquals(3, manager.getLogger("").getHandlers().length); 714 715 // duplicate config class, take effect twice 716 props.setProperty("config", className + "$MockValidConfig " 717 + className + "$MockValidConfig"); 718 manager.readConfiguration(EnvironmentHelper 719 .PropertiesToInputStream(props)); 720 assertEquals(4, manager.getLogger("").getHandlers().length); 721 722 // invalid config classes mixed with valid config classes, valid 723 // config 724 // classes take effect 725 props.setProperty("config", "badname " + className 726 + "$MockValidConfig " + className 727 + "$MockInvalidConfigNoDefaultConstructor " + className 728 + "$MockValidConfig"); 729 manager.readConfiguration(EnvironmentHelper 730 .PropertiesToInputStream(props)); 731 assertEquals(4, manager.getLogger("").getHandlers().length); 732 733 // global property take effect before logger specified property 734 props.setProperty("config", className + "$MockValidConfig"); 735 manager.readConfiguration(EnvironmentHelper 736 .PropertiesToInputStream(props)); 737 assertEquals(Level.FINE, manager.getLogger("").getLevel()); 738 } finally { 739 System.setErr(err); 740 } 741 742 } 743 testValidConfigClass()744 public void testValidConfigClass() throws Exception { 745 String oldPropertyValue = System.getProperty(CONFIG_CLASS); 746 try { 747 System.setProperty(CONFIG_CLASS, this.getClass().getName() 748 + "$ConfigClass"); 749 assertNull(manager.getLogger("testConfigClass.foo")); 750 751 manager.readConfiguration(); 752 assertNull(manager.getLogger("testConfigClass.foo")); 753 Logger l = Logger.getLogger("testConfigClass.foo.child"); 754 assertSame(Level.FINEST, manager.getLogger("").getLevel()); 755 assertEquals(0, manager.getLogger("").getHandlers().length); 756 assertEquals("testConfigClass.foo", l.getParent().getName()); 757 } finally { 758 Properties systemProperties = System.getProperties(); 759 if (oldPropertyValue != null) { 760 systemProperties.setProperty(CONFIG_CLASS, oldPropertyValue); 761 } else { 762 systemProperties.remove(CONFIG_CLASS); 763 } 764 } 765 } 766 testNotExistConfigFile()767 public void testNotExistConfigFile() throws Exception { 768 String oldPropertyValue = System.getProperty(CONFIG_FILE); 769 System.setProperty(CONFIG_FILE, "not.exist.config.file"); 770 try { 771 LogManager.getLogManager().readConfiguration(); 772 fail("should throw FileNotFoundException"); 773 } catch (FileNotFoundException e) { 774 // Expected 775 } finally { 776 Properties systemProperties = System.getProperties(); 777 if (oldPropertyValue != null) { 778 systemProperties.setProperty(CONFIG_FILE, oldPropertyValue); 779 } else { 780 systemProperties.remove(CONFIG_FILE); 781 } 782 } 783 } 784 785 // regression for HARMONY-3075 testGetLoggingMXBean()786 public void testGetLoggingMXBean() throws Exception { 787 assertNotNull(LogManager.getLoggingMXBean()); 788 } 789 790 /* 791 * ---------------------------------------------------- 792 * mock classes 793 * ---------------------------------------------------- 794 */ 795 public static class ConfigClass { ConfigClass()796 public ConfigClass() throws Exception { 797 LogManager man = LogManager.getLogManager(); 798 Properties props = LogManagerTest.initProps(); 799 props.put("testConfigClass.foo.level", "OFF"); 800 props.put("testConfigClass.foo.handlers", "java.util.logging.ConsoleHandler"); 801 props.put(".level", "FINEST"); 802 props.remove("handlers"); 803 InputStream in = EnvironmentHelper.PropertiesToInputStream(props); 804 man.readConfiguration(in); 805 } 806 } 807 808 public static class MockInvalidInitClass { MockInvalidInitClass()809 public MockInvalidInitClass() { 810 throw new RuntimeException(); 811 } 812 } 813 814 public static class TestInvalidConfigFile { main(String[] args)815 public static void main(String[] args) { 816 LogManager manager = LogManager.getLogManager(); 817 Logger root = manager.getLogger(""); 818 checkPropertyNull(manager); 819 assertEquals(0, root.getHandlers().length); 820 assertEquals(Level.INFO, root.getLevel()); 821 822 try { 823 manager.readConfiguration(); 824 } catch (Exception e) { 825 e.printStackTrace(); 826 } 827 checkProperty(manager); 828 assertNull(root.getHandlers()[0].getLevel()); 829 assertEquals(1, root.getHandlers().length); 830 assertEquals(Level.INFO, root.getLevel()); 831 832 manager.reset(); 833 checkProperty(manager); 834 assertEquals(0, root.getHandlers().length); 835 assertEquals(Level.INFO, root.getLevel()); 836 try { 837 manager.readConfiguration(); 838 } catch (Exception e) { 839 e.printStackTrace(); 840 } 841 } 842 } 843 844 public static class TestValidConfigFile { main(String[] args)845 public static void main(String[] args) { 846 LogManager manager = LogManager.getLogManager(); 847 Logger root = manager.getLogger(""); 848 checkPropertyNull(manager); 849 assertEquals(2, root.getHandlers().length); 850 assertEquals(root.getHandlers()[0].getLevel(), Level.OFF); 851 assertEquals(Level.ALL, root.getLevel()); 852 853 try { 854 manager.readConfiguration(); 855 } catch (Exception e) { 856 e.printStackTrace(); 857 } 858 checkPropertyNull(manager); 859 assertEquals(root.getHandlers()[0].getLevel(), Level.OFF); 860 assertEquals(2, root.getHandlers().length); 861 assertEquals(Level.ALL, root.getLevel()); 862 863 manager.reset(); 864 checkPropertyNull(manager); 865 assertEquals(0, root.getHandlers().length); 866 assertEquals(Level.INFO, root.getLevel()); 867 try { 868 manager.readConfiguration(); 869 } catch (Exception e) { 870 e.printStackTrace(); 871 } 872 } 873 } 874 875 public static class TestMockLogManager { main(String[] args)876 public static void main(String[] args) { 877 LogManager manager = LogManager.getLogManager(); 878 assertTrue(manager instanceof MockLogManager); 879 } 880 } 881 882 public static class TestValidConfigClass { main(String[] args)883 public static void main(String[] args) { 884 LogManager manager = LogManager.getLogManager(); 885 Logger root = manager.getLogger(""); 886 checkPropertyNull(manager); 887 assertEquals(1, root.getHandlers().length); 888 assertEquals(Level.OFF, root.getLevel()); 889 890 try { 891 manager.readConfiguration(); 892 } catch (Exception e) { 893 e.printStackTrace(); 894 } 895 checkPropertyNull(manager); 896 assertEquals(1, root.getHandlers().length); 897 assertEquals(Level.OFF, root.getLevel()); 898 899 try { 900 manager.readConfiguration(); 901 } catch (Exception e) { 902 e.printStackTrace(); 903 } 904 checkPropertyNull(manager); 905 assertEquals(1, root.getHandlers().length); 906 assertEquals(Level.OFF, root.getLevel()); 907 908 manager.reset(); 909 checkPropertyNull(manager); 910 assertEquals(0, root.getHandlers().length); 911 assertEquals(Level.INFO, root.getLevel()); 912 try { 913 manager.readConfiguration(); 914 } catch (Exception e) { 915 e.printStackTrace(); 916 } 917 } 918 } 919 920 public static class MockLogger extends Logger { MockLogger(String name, String rbName)921 public MockLogger(String name, String rbName) { 922 super(name, rbName); 923 } 924 } 925 926 public static class MockLogManager extends LogManager { 927 } 928 929 public static class MockConfigLogManager extends LogManager { 930 public boolean isCalled = false; 931 readConfiguration(InputStream ins)932 public void readConfiguration(InputStream ins) throws IOException { 933 isCalled = true; 934 super.readConfiguration(ins); 935 } 936 } 937 938 public static class MockHandler extends Handler { 939 static int number = 0; 940 MockHandler()941 public MockHandler() { 942 addNumber(); 943 // System.out.println(this + ":start:" + number); 944 } 945 addNumber()946 private synchronized void addNumber() { 947 number++; 948 } 949 close()950 public void close() { 951 minusNumber(); 952 // System.out.println(this + ":close:" + number); 953 } 954 minusNumber()955 private synchronized void minusNumber() { 956 number--; 957 } 958 flush()959 public void flush() { 960 // System.out.println(this + ":flush"); 961 } 962 publish(LogRecord record)963 public void publish(LogRecord record) { 964 } 965 966 } 967 968 public static class MockValidInitClass { MockValidInitClass()969 public MockValidInitClass() { 970 Properties p = new Properties(); 971 p.put("handlers", className + "$MockHandler"); 972 p.put(".level", "OFF"); 973 InputStream in = null; 974 try { 975 in = EnvironmentHelper.PropertiesToInputStream(p); 976 LogManager manager = LogManager.getLogManager(); 977 manager.readConfiguration(in); 978 } catch (Exception e) { 979 e.printStackTrace(); 980 } finally { 981 try { 982 in.close(); 983 } catch (Exception e) { 984 } 985 } 986 } 987 } 988 989 public static class MockValidConfig { MockValidConfig()990 public MockValidConfig() { 991 handler = new MockHandler(); 992 LogManager manager = LogManager.getLogManager(); 993 Logger root = null; 994 if (null != manager) { 995 root = manager.getLogger(""); 996 } else { 997 System.out.println("null manager"); 998 } 999 if (null != root) { 1000 root.addHandler(handler); 1001 root.setLevel(Level.OFF); 1002 } 1003 } 1004 } 1005 1006 public static class MockValidConfig2 { 1007 1008 static Logger root = null; 1009 MockValidConfig2()1010 public MockValidConfig2() { 1011 root = LogManager.getLogManager().getLogger(""); 1012 root.removeHandler(handler); 1013 } 1014 } 1015 1016 public static class MockInvalidConfigException { MockInvalidConfigException()1017 public MockInvalidConfigException() { 1018 throw new RuntimeException("invalid config class - throw exception"); 1019 } 1020 } 1021 1022 public static class MockInvalidConfigNoDefaultConstructor { MockInvalidConfigNoDefaultConstructor(int i)1023 public MockInvalidConfigNoDefaultConstructor(int i) { 1024 throw new RuntimeException( 1025 "invalid config class - no default constructor"); 1026 } 1027 } 1028 1029 public static class MockPropertyChangeListener implements 1030 PropertyChangeListener { 1031 1032 PropertyChangeEvent event = null; 1033 propertyChange(PropertyChangeEvent event)1034 public void propertyChange(PropertyChangeEvent event) { 1035 this.event = event; 1036 } 1037 getEvent()1038 public PropertyChangeEvent getEvent() { 1039 return event; 1040 } 1041 reset()1042 public void reset() { 1043 event = null; 1044 } 1045 1046 } 1047 1048 /* 1049 * Test config class loading 1050 * java -Djava.util.logging.config.class=badConfigClassName ClassLoadingTest 1051 */ 1052 public static class ClassLoadingTest { main(String[] args)1053 public static void main(String[] args) { 1054 Thread.currentThread().setContextClassLoader(new MockErrorClassLoader()); 1055 try { 1056 LogManager.getLogManager(); 1057 fail("Should throw mock error"); 1058 } catch (MockError e) { 1059 } 1060 } 1061 1062 static class MockErrorClassLoader extends ClassLoader { loadClass(String name)1063 public Class<?> loadClass(String name) { 1064 throw new MockError(); 1065 } 1066 } 1067 1068 static class MockError extends Error { 1069 } 1070 } 1071 1072 } 1073