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