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 18package org.apache.harmony.logging.tests.java.util.logging; 19 20 21 22import java.beans.PropertyChangeEvent; 23import java.beans.PropertyChangeListener; 24import java.io.IOException; 25import java.io.InputStream; 26import java.io.PrintStream; 27import java.security.Permission; 28import java.util.Enumeration; 29import java.util.Properties; 30import java.util.logging.ConsoleHandler; 31import java.util.logging.Handler; 32import java.util.logging.Level; 33import java.util.logging.LogManager; 34import java.util.logging.LogRecord; 35import java.util.logging.Logger; 36import java.util.logging.LoggingPermission; 37 38import dalvik.annotation.KnownFailure; 39import junit.framework.TestCase; 40 41import org.apache.harmony.logging.tests.java.util.logging.HandlerTest.NullOutputStream; 42import org.apache.harmony.logging.tests.java.util.logging.util.EnvironmentHelper; 43 44import dalvik.annotation.SideEffect; 45import dalvik.annotation.TestLevel; 46import dalvik.annotation.TestTargetClass; 47import dalvik.annotation.TestTargetNew; 48import dalvik.annotation.TestTargets; 49import tests.util.TestEnvironment; 50 51/** 52 * 53 * add/get logger(dot) 54 * 55 */ 56@TestTargetClass(LogManager.class) 57public class LogManagerTest extends TestCase { 58 59 private static final String FOO = "LogManagerTestFoo"; 60 61 LogManager mockManager; 62 63 LogManager manager = LogManager.getLogManager(); 64 65 MockPropertyChangeListener listener; 66 67 Properties props; 68 69 private static String className = LogManagerTest.class.getName(); 70 71 static Handler handler = null; 72 73 static final String CONFIG_CLASS = "java.util.logging.config.class"; 74 75 static final String CONFIG_FILE = "java.util.logging.config.file"; 76 77 static final String MANAGER_CLASS = "java.util.logging.config.manager"; 78 79 static final SecurityManager securityManager = System.getSecurityManager(); 80 81 static final String clearPath = System.getProperty("clearpath"); 82 83 /* 84 * @see TestCase#setUp() 85 */ 86 @Override 87 protected void setUp() throws Exception { 88 super.setUp(); 89 mockManager = new MockLogManager(); 90 // listener = new MockPropertyChangeListener(); 91 handler = new MockHandler(); 92 props = new Properties(); 93 props.put("handlers", className + "$MockHandler " + className + "$MockHandler"); 94 props.put("java.util.logging.FileHandler.pattern", "%h/java%u.log"); 95 props.put("java.util.logging.FileHandler.limit", "50000"); 96 props.put("java.util.logging.FileHandler.count", "5"); 97 props.put("java.util.logging.FileHandler.formatter", "java.util.logging.XMLFormatter"); 98 props.put(".level", "FINE"); 99 props.put("java.util.logging.ConsoleHandler.level", "OFF"); 100 props.put("java.util.logging.ConsoleHandler.formatter","java.util.logging.SimpleFormatter"); 101 props.put("LogManagerTestFoo.handlers", "java.util.logging.ConsoleHandler"); 102 props.put("LogManagerTestFoo.level", "WARNING"); 103 } 104 105 106 107 /* 108 * @see TestCase#tearDown() 109 */ 110 @Override 111 protected void tearDown() throws Exception { 112 TestEnvironment.reset(); 113 super.tearDown(); 114 handler = null; 115 } 116 117 @TestTargetNew( 118 level = TestLevel.COMPLETE, 119 notes = "", 120 method = "LogManager", 121 args = {} 122 ) 123 public void testLogManager() { 124 class TestLogManager extends LogManager { 125 public TestLogManager() { 126 super(); 127 } 128 } 129 TestLogManager tlm = new TestLogManager(); 130 assertNotNull(tlm.toString()); 131 } 132 133 @TestTargets({ 134 @TestTargetNew( 135 level = TestLevel.PARTIAL_COMPLETE, 136 notes = "Verifies NullPointerException.", 137 method = "addLogger", 138 args = {java.util.logging.Logger.class} 139 ), 140 @TestTargetNew( 141 level = TestLevel.PARTIAL_COMPLETE, 142 notes = "Verifies NullPointerException.", 143 method = "getLogger", 144 args = {java.lang.String.class} 145 ) 146 }) 147 public void testAddGetLogger() { 148 Logger log = new MockLogger(FOO, null); 149 Logger foo = mockManager.getLogger(FOO); 150 assertNull(foo); 151 assertTrue(mockManager.addLogger(log)); 152 foo = mockManager.getLogger(FOO); 153 assertSame(foo, log); 154 assertNull(foo.getParent()); 155 156 try { 157 mockManager.addLogger(null); 158 fail("add null should throw NullPointerException"); 159 } catch (NullPointerException e) { 160 } 161 162 try { 163 mockManager.getLogger(null); 164 fail("get null should throw NullPointerException"); 165 } catch (NullPointerException e) { 166 } 167 168 assertNull(mockManager.getLogger("bad name")); 169 170 Enumeration<String> enumar = mockManager.getLoggerNames(); 171 int i = 0; 172 while (enumar.hasMoreElements()) { 173 String name = enumar.nextElement(); 174 i++; 175 assertEquals(FOO, name); 176 } 177 assertEquals(i, 1); 178 } 179 180 @TestTargets({ 181 @TestTargetNew( 182 level = TestLevel.PARTIAL_COMPLETE, 183 notes = "", 184 method = "addLogger", 185 args = {java.util.logging.Logger.class} 186 ), 187 @TestTargetNew( 188 level = TestLevel.PARTIAL_COMPLETE, 189 notes = "", 190 method = "getLogger", 191 args = {java.lang.String.class} 192 ) 193 }) 194 public void testAddGetLogger_duplicateName() { 195 // add logger with duplicate name has no effect 196 Logger foo = new MockLogger(FOO, null); 197 Logger foo2 = new MockLogger(FOO, null); 198 assertTrue(mockManager.addLogger(foo)); 199 assertSame(foo, mockManager.getLogger(FOO)); 200 assertFalse(mockManager.addLogger(foo2)); 201 assertSame(foo, mockManager.getLogger(FOO)); 202 Enumeration<String> enumar = mockManager.getLoggerNames(); 203 int i = 0; 204 while (enumar.hasMoreElements()) { 205 enumar.nextElement(); 206 i++; 207 } 208 assertEquals(1, i); 209 } 210 211 @TestTargets({ 212 @TestTargetNew( 213 level = TestLevel.PARTIAL_COMPLETE, 214 notes = "", 215 method = "addLogger", 216 args = {java.util.logging.Logger.class} 217 ), 218 @TestTargetNew( 219 level = TestLevel.PARTIAL_COMPLETE, 220 notes = "", 221 method = "getLogger", 222 args = {java.lang.String.class} 223 ) 224 }) 225 public void testAddGetLogger_Hierachy() { 226 Logger foo = new MockLogger("testAddGetLogger_Hierachy.foo", null); 227 Logger child = new MockLogger("testAddGetLogger_Hierachy.foo.child", null); 228 Logger fakeChild = new MockLogger("testAddGetLogger_Hierachy.foo2.child", null); 229 Logger grandson = new MockLogger("testAddGetLogger_Hierachy.foo.child.grandson", null); 230 Logger otherChild = new MockLogger("testAddGetLogger_Hierachy.foo.child", null); 231 assertNull(foo.getParent()); 232 assertNull(child.getParent()); 233 assertNull(grandson.getParent()); 234 assertNull(otherChild.getParent()); 235 236 // whenever a logger is added to a LogManager, hierarchy will be updated 237 // accordingly 238 assertTrue(mockManager.addLogger(child)); 239 assertNull(child.getParent()); 240 241 assertTrue(mockManager.addLogger(fakeChild)); 242 assertNull(fakeChild.getParent()); 243 244 assertTrue(mockManager.addLogger(grandson)); 245 assertSame(child, grandson.getParent()); 246 247 assertTrue(mockManager.addLogger(foo)); 248 assertSame(foo, child.getParent()); 249 assertNull(foo.getParent()); 250 assertNull(fakeChild.getParent()); 251 252 // but for non-mock LogManager, foo's parent should be root 253 assertTrue(manager.addLogger(foo)); 254 assertSame(manager.getLogger(""), manager.getLogger("testAddGetLogger_Hierachy.foo") 255 .getParent()); 256 257 // if we add one logger to two LogManager, parent will changed 258 assertTrue(manager.addLogger(otherChild)); 259 assertTrue(manager.addLogger(grandson)); 260 assertSame(foo, otherChild.getParent()); 261 assertSame(otherChild, grandson.getParent()); 262 } 263 264 @TestTargets({ 265 @TestTargetNew( 266 level = TestLevel.PARTIAL_COMPLETE, 267 notes = "", 268 method = "addLogger", 269 args = {java.util.logging.Logger.class} 270 ), 271 @TestTargetNew( 272 level = TestLevel.PARTIAL_COMPLETE, 273 notes = "", 274 method = "getLogger", 275 args = {java.lang.String.class} 276 ) 277 }) 278 public void testAddLoggerReverseOrder() { 279 Logger root = new MockLogger("testAddLoggerReverseOrder", null); 280 Logger foo = new MockLogger("testAddLoggerReverseOrder.foo", null); 281 Logger fooChild = new MockLogger("testAddLoggerReverseOrder.foo.child", null); 282 Logger fooGrandChild = new MockLogger("testAddLoggerReverseOrder.foo.child.grand", null); 283 Logger fooGrandChild2 = new MockLogger("testAddLoggerReverseOrder.foo.child.grand2", null); 284 285 Logger realRoot = manager.getLogger(""); 286 287 manager.addLogger(fooGrandChild); 288 assertEquals(realRoot, fooGrandChild.getParent()); 289 290 manager.addLogger(root); 291 assertSame(root, fooGrandChild.getParent()); 292 assertSame(realRoot, root.getParent()); 293 294 manager.addLogger(foo); 295 assertSame(root, foo.getParent()); 296 assertSame(foo, fooGrandChild.getParent()); 297 298 manager.addLogger(fooGrandChild2); 299 assertSame(foo, fooGrandChild2.getParent()); 300 assertSame(foo, fooGrandChild.getParent()); 301 302 manager.addLogger(fooChild); 303 assertSame(fooChild, fooGrandChild2.getParent()); 304 assertSame(fooChild, fooGrandChild.getParent()); 305 assertSame(foo, fooChild.getParent()); 306 assertSame(root, foo.getParent()); 307 assertSame(realRoot, root.getParent()); 308 } 309 310 @TestTargetNew( 311 level = TestLevel.PARTIAL_COMPLETE, 312 notes = "", 313 method = "addLogger", 314 args = {java.util.logging.Logger.class} 315 ) 316 public void testAddSimiliarLogger() { 317 Logger root = new MockLogger("testAddSimiliarLogger", null); 318 Logger foo = new MockLogger("testAddSimiliarLogger.foo", null); 319 Logger similiarFoo = new MockLogger("testAddSimiliarLogger.fop", null); 320 Logger fooo = new MockLogger("testAddSimiliarLogger.fooo", null); 321 Logger fooChild = new MockLogger("testAddSimiliarLogger.foo.child", null); 322 Logger similiarFooChild = new MockLogger("testAddSimiliarLogger.fop.child", null); 323 Logger foooChild = new MockLogger("testAddSimiliarLogger.fooo.child", null); 324 325 manager.addLogger(root); 326 manager.addLogger(fooChild); 327 manager.addLogger(similiarFooChild); 328 manager.addLogger(foooChild); 329 assertSame(root, fooChild.getParent()); 330 assertSame(root, similiarFooChild.getParent()); 331 assertSame(root, foooChild.getParent()); 332 333 manager.addLogger(foo); 334 assertSame(foo, fooChild.getParent()); 335 assertSame(root, similiarFooChild.getParent()); 336 assertSame(root, foooChild.getParent()); 337 338 manager.addLogger(similiarFoo); 339 assertSame(foo, fooChild.getParent()); 340 assertSame(similiarFoo, similiarFooChild.getParent()); 341 assertSame(root, foooChild.getParent()); 342 343 manager.addLogger(fooo); 344 assertSame(fooo, foooChild.getParent()); 345 } 346 347 @TestTargets({ 348 @TestTargetNew( 349 level = TestLevel.PARTIAL_COMPLETE, 350 notes = "", 351 method = "addLogger", 352 args = {java.util.logging.Logger.class} 353 ), 354 @TestTargetNew( 355 level = TestLevel.PARTIAL_COMPLETE, 356 notes = "", 357 method = "getLogger", 358 args = {java.lang.String.class} 359 ) 360 }) 361 public void testAddGetLogger_nameWithSpace() { 362 Logger foo = new MockLogger(FOO, null); 363 Logger fooBeforeSpace = new MockLogger(FOO + " ", null); 364 Logger fooAfterSpace = new MockLogger(" " + FOO, null); 365 Logger fooWithBothSpace = new MockLogger(" " + FOO + " ", null); 366 assertTrue(mockManager.addLogger(foo)); 367 assertTrue(mockManager.addLogger(fooBeforeSpace)); 368 assertTrue(mockManager.addLogger(fooAfterSpace)); 369 assertTrue(mockManager.addLogger(fooWithBothSpace)); 370 371 assertSame(foo, mockManager.getLogger(FOO)); 372 assertSame(fooBeforeSpace, mockManager.getLogger(FOO + " ")); 373 assertSame(fooAfterSpace, mockManager.getLogger(" " + FOO)); 374 assertSame(fooWithBothSpace, mockManager.getLogger(" " + FOO + " ")); 375 } 376 377 @TestTargets({ 378 @TestTargetNew( 379 level = TestLevel.PARTIAL_COMPLETE, 380 notes = "Doesn't verify NullPointerException", 381 method = "addLogger", 382 args = {java.util.logging.Logger.class} 383 ), 384 @TestTargetNew( 385 level = TestLevel.PARTIAL_COMPLETE, 386 notes = "", 387 method = "getLogger", 388 args = {java.lang.String.class} 389 ) 390 }) 391 public void testAddGetLogger_addRoot() { 392 Logger foo = new MockLogger(FOO, null); 393 Logger fooChild = new MockLogger(FOO + ".child", null); 394 Logger other = new MockLogger("other", null); 395 Logger root = new MockLogger("", null); 396 assertNull(foo.getParent()); 397 assertNull(root.getParent()); 398 assertNull(other.getParent()); 399 400 // add root to mock logmanager and it works as "root" logger 401 assertTrue(mockManager.addLogger(foo)); 402 assertTrue(mockManager.addLogger(other)); 403 assertTrue(mockManager.addLogger(fooChild)); 404 assertNull(foo.getParent()); 405 assertNull(other.getParent()); 406 assertSame(foo, fooChild.getParent()); 407 408 assertTrue(mockManager.addLogger(root)); 409 assertSame(root, foo.getParent()); 410 assertSame(root, other.getParent()); 411 assertNull(root.getParent()); 412 413 // try to add root logger to non-mock LogManager, no effect 414 assertFalse(manager.addLogger(root)); 415 assertNotSame(root, manager.getLogger("")); 416 } 417 418 /** 419 * @tests java.util.logging.LogManager#addLogger(Logger) 420 */ 421 @TestTargets({ 422 @TestTargetNew( 423 level = TestLevel.PARTIAL_COMPLETE, 424 notes = "", 425 method = "addLogger", 426 args = {java.util.logging.Logger.class} 427 ), 428 @TestTargetNew( 429 level = TestLevel.PARTIAL_COMPLETE, 430 notes = "", 431 method = "getLogManager", 432 args = {} 433 ) 434 }) 435 public void test_addLoggerLLogger_Security() throws Exception { 436 // regression test for Harmony-1286 437 SecurityManager originalSecurityManager = System.getSecurityManager(); 438 System.setSecurityManager(new SecurityManager() { 439 @Override 440 public void checkPermission(Permission perm) { 441 442 } 443 }); 444 try { 445 LogManager manager = LogManager.getLogManager(); 446 manager.addLogger(new MockLogger("mock", null)); 447 manager.addLogger(new MockLogger("mock.child", null)); 448 } finally { 449 System.setSecurityManager(originalSecurityManager); 450 } 451 } 452 453 @TestTargetNew( 454 level = TestLevel.COMPLETE, 455 notes = "", 456 method = "readConfiguration", 457 args = {java.io.InputStream.class} 458 ) 459 public void testDefaultLoggerProperties() throws Exception { 460 // mock LogManager has no default logger 461 assertNull(mockManager.getLogger("")); 462 assertNull(mockManager.getLogger("global")); 463 464 // non-mock LogManager has two default logger 465 Logger global = manager.getLogger("global"); 466 Logger root = manager.getLogger(""); 467 468 assertSame(global, Logger.global); 469 assertSame(root, global.getParent()); 470 471 Logger oldGlobal = global; 472 Logger oldRoot = root; 473 474 // root properties 475 manager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props)); 476 477 global = manager.getLogger("global"); 478 root = manager.getLogger(""); 479 480 assertSame(oldGlobal, global); 481 assertSame(oldRoot, root); 482 483 assertNull(root.getFilter()); 484 assertEquals(2, root.getHandlers().length); 485 assertEquals(Level.FINE, root.getLevel()); 486 assertEquals("", root.getName()); 487 assertSame(root.getParent(), null); 488 assertTrue(root.getUseParentHandlers()); 489 490 // The following two fail if other tests are run before this one. 491 assertNull(root.getResourceBundle()); 492 assertNull(root.getResourceBundleName()); 493 } 494 495 /* 496 * test for method public Logger getLogger(String name) 497 * test covers following usecases: 498 * case 1: test default and valid value 499 * case 2: test throw NullPointerException 500 * case 3: test bad name 501 * case 4: check correct tested value 502 */ 503 504 @TestTargets({ 505 @TestTargetNew( 506 level = TestLevel.PARTIAL_COMPLETE, 507 notes = "", 508 method = "getLogger", 509 args = {java.lang.String.class} 510 ), 511 @TestTargetNew( 512 level = TestLevel.COMPLETE, 513 notes = "", 514 method = "getLoggerNames", 515 args = {} 516 ) 517 }) 518 public void testGetLogger() throws Exception { 519 520 // case 1: test default and valid value 521 Logger log = new MockLogger(FOO, null); 522 Logger foo = mockManager.getLogger(FOO); 523 assertNull("Logger should be null", foo); 524 assertTrue("logger was't registered successfully", mockManager.addLogger(log)); 525 foo = mockManager.getLogger(FOO); 526 assertSame("two loggers not refer to the same object", foo, log); 527 assertNull("logger foo should not haven parent", foo.getParent()); 528 529 // case 2: test throw NullPointerException 530 try { 531 mockManager.getLogger(null); 532 fail("get null should throw NullPointerException"); 533 } catch (NullPointerException e) { 534 } 535 536 // case 3: test bad name 537 assertNull("LogManager should not have logger with unforeseen name", mockManager 538 .getLogger("bad name")); 539 540 // case 4: check correct tested value 541 Enumeration<String> enumar = mockManager.getLoggerNames(); 542 int i = 0; 543 while (enumar.hasMoreElements()) { 544 String name = enumar.nextElement(); 545 i++; 546 assertEquals("name logger should be equal to foreseen name", FOO, name); 547 } 548 assertEquals("LogManager should contain one element", 1, i); 549 } 550 551 /* 552 * test for method public Logger getLogger(String name) 553 */ 554 @TestTargets({ 555 @TestTargetNew( 556 level = TestLevel.PARTIAL_COMPLETE, 557 notes = "", 558 method = "getLogger", 559 args = {java.lang.String.class} 560 ), 561 @TestTargetNew( 562 level = TestLevel.PARTIAL, 563 notes = "", 564 method = "getLoggerNames", 565 args = {} 566 ) 567 }) 568 public void testGetLogger_duplicateName() throws Exception { 569 // test duplicate name 570 // add logger with duplicate name has no effect 571 mockManager.reset(); 572 Logger foo2 = new MockLogger(FOO, null); 573 Logger foo3 = new MockLogger(FOO, null); 574 mockManager.addLogger(foo2); 575 assertSame(foo2, mockManager.getLogger(FOO)); 576 mockManager.addLogger(foo3); 577 assertSame(foo2, mockManager.getLogger(FOO)); 578 579 Enumeration<String> enumar2 = mockManager.getLoggerNames(); 580 int i = 0; 581 while (enumar2.hasMoreElements()) { 582 enumar2.nextElement(); 583 i++; 584 } 585 assertEquals(1, i); 586 } 587 588 /* 589 * test for method public Logger getLogger(String name) 590 */ 591 @TestTargetNew( 592 level = TestLevel.PARTIAL_COMPLETE, 593 notes = "", 594 method = "getLogger", 595 args = {java.lang.String.class} 596 ) 597 public void testGetLogger_hierachy() throws Exception { 598 // test hierachy 599 Logger foo = new MockLogger("testGetLogger_hierachy.foo", null); 600 // but for non-mock LogManager, foo's parent should be root 601 assertTrue(manager.addLogger(foo)); 602 assertSame(manager.getLogger(""), manager.getLogger("testGetLogger_hierachy.foo") 603 .getParent()); 604 } 605 606 /* 607 * test for method public Logger getLogger(String name) 608 */ 609 @TestTargetNew( 610 level = TestLevel.PARTIAL_COMPLETE, 611 notes = "", 612 method = "getLogger", 613 args = {java.lang.String.class} 614 ) 615 public void testGetLogger_nameSpace() throws Exception { 616 // test name with space 617 Logger foo = new MockLogger(FOO, null); 618 Logger fooBeforeSpace = new MockLogger(FOO + " ", null); 619 Logger fooAfterSpace = new MockLogger(" " + FOO, null); 620 Logger fooWithBothSpace = new MockLogger(" " + FOO + " ", null); 621 assertTrue(mockManager.addLogger(foo)); 622 assertTrue(mockManager.addLogger(fooBeforeSpace)); 623 assertTrue(mockManager.addLogger(fooAfterSpace)); 624 assertTrue(mockManager.addLogger(fooWithBothSpace)); 625 626 assertSame(foo, mockManager.getLogger(FOO)); 627 assertSame(fooBeforeSpace, mockManager.getLogger(FOO + " ")); 628 assertSame(fooAfterSpace, mockManager.getLogger(" " + FOO)); 629 assertSame(fooWithBothSpace, mockManager.getLogger(" " + FOO + " ")); 630 } 631 632 /* 633 * test for method public void checkAccess() throws SecurityException 634 */ 635 @TestTargets({ 636 @TestTargetNew( 637 level = TestLevel.COMPLETE, 638 notes = "", 639 method = "checkAccess", 640 args = {} 641 ), 642 @TestTargetNew( 643 level = TestLevel.COMPLETE, 644 notes = "", 645 method = "getLogManager", 646 args = {} 647 ) 648 }) 649 public void testCheckAccess() { 650 try { 651 manager.checkAccess(); 652 } catch (SecurityException e) { 653 fail("securityException should not be thrown"); 654 } 655 System.setSecurityManager(new MockSecurityManagerLogPermission()); 656 mockManager.addLogger(new MockLogger("abc", null)); 657 mockManager.getLogger(""); 658 mockManager.getLoggerNames(); 659 mockManager.getProperty(".level"); 660 LogManager.getLogManager(); 661 try { 662 manager.checkAccess(); 663 fail("should throw securityException"); 664 } catch (SecurityException e) { 665 } 666 667 System.setSecurityManager(securityManager); 668 } 669 670 @TestTargets({ 671 @TestTargetNew( 672 level = TestLevel.PARTIAL_COMPLETE, 673 notes = "Verifies SecurityException.", 674 method = "readConfiguration", 675 args = {java.io.InputStream.class} 676 ), 677 @TestTargetNew( 678 level = TestLevel.PARTIAL_COMPLETE, 679 notes = "Verifies SecurityException.", 680 method = "readConfiguration", 681 args = {} 682 ), 683 @TestTargetNew( 684 level = TestLevel.PARTIAL_COMPLETE, 685 notes = "Verifies SecurityException.", 686 method = "checkAccess", 687 args = {} 688 ), 689 @TestTargetNew( 690 level = TestLevel.PARTIAL_COMPLETE, 691 notes = "Verifies SecurityException.", 692 method = "reset", 693 args = {} 694 ), 695 @TestTargetNew( 696 level = TestLevel.PARTIAL_COMPLETE, 697 notes = "Verifies SecurityException.", 698 method = "getLogManager", 699 args = {} 700 ), 701 @TestTargetNew( 702 level = TestLevel.PARTIAL_COMPLETE, 703 notes = "Verifies SecurityException.", 704 method = "addPropertyChangeListener", 705 args = {java.beans.PropertyChangeListener.class} 706 ) 707 }) 708 public void testLoggingPermission() throws IOException { 709 System.setSecurityManager(new MockSecurityManagerLogPermission()); 710 mockManager.addLogger(new MockLogger("abc", null)); 711 mockManager.getLogger(""); 712 mockManager.getLoggerNames(); 713 mockManager.getProperty(".level"); 714 LogManager.getLogManager(); 715 try { 716 manager.checkAccess(); 717 fail("should throw securityException"); 718 } catch (SecurityException e) { 719 } 720 try { 721 mockManager.readConfiguration(); 722 fail("should throw SecurityException"); 723 } catch (SecurityException e) { 724 } 725 try { 726 mockManager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props)); 727 fail("should throw SecurityException"); 728 } catch (SecurityException e) { 729 } 730 try { 731 mockManager.readConfiguration(null); 732 fail("should throw SecurityException"); 733 } catch (SecurityException e) { 734 } 735 try { 736 mockManager 737 .addPropertyChangeListener(new MockPropertyChangeListener()); 738 fail("should throw SecurityException"); 739 } catch (SecurityException e) { 740 } 741 try { 742 mockManager.addPropertyChangeListener(null); 743 fail("should throw NPE"); 744 } catch (NullPointerException e) { 745 } 746 try { 747 mockManager.removePropertyChangeListener(null); 748 fail("should throw SecurityException"); 749 } catch (SecurityException e) { 750 } 751 try { 752 mockManager.reset(); 753 fail("should throw SecurityException"); 754 } catch (SecurityException e) { 755 } 756 System.setSecurityManager(securityManager); 757 } 758 759 760 @TestTargets({ 761 @TestTargetNew( 762 level = TestLevel.PARTIAL_COMPLETE, 763 notes = "", 764 method = "readConfiguration", 765 args = {java.io.InputStream.class} 766 ), 767 @TestTargetNew( 768 level = TestLevel.PARTIAL_COMPLETE, 769 notes = "", 770 method = "getProperty", 771 args = {java.lang.String.class} 772 ) 773 }) 774 public void testMockGetProperty() throws Exception { 775 // mock manager doesn't read configuration until you call 776 // readConfiguration() 777 Logger root = new MockLogger("", null); 778 assertTrue(mockManager.addLogger(root)); 779 root = mockManager.getLogger(""); 780 checkPropertyNull(mockManager); 781 assertEquals(0, root.getHandlers().length); 782 assertNull(root.getLevel()); 783 mockManager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props)); 784 assertEquals(Level.FINE, root.getLevel()); 785 checkProperty(mockManager); 786 mockManager.reset(); 787 checkPropertyNull(mockManager); 788 assertEquals(Level.INFO, root.getLevel()); 789 assertEquals(0, mockManager.getLogger("").getHandlers().length); 790 } 791 792 @TestTargetNew( 793 level = TestLevel.COMPLETE, 794 notes = "", 795 method = "getProperty", 796 args = {java.lang.String.class} 797 ) 798 public void testGetProperty() throws SecurityException, IOException { 799 800 Logger root = manager.getLogger(""); 801 manager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props)); 802 checkProperty(manager); 803 assertEquals(2, root.getHandlers().length); 804 assertEquals(Level.FINE, root.getLevel()); 805 806 manager.reset(); 807 checkPropertyNull(manager); 808 assertEquals(0, root.getHandlers().length); 809 assertEquals(Level.INFO, root.getLevel()); 810 manager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props)); 811 manager.reset(); 812 } 813 814 @TestTargetNew( 815 level = TestLevel.PARTIAL_COMPLETE, 816 notes = "Verifies NullPointerException.", 817 method = "readConfiguration", 818 args = {java.io.InputStream.class} 819 ) 820 public void testReadConfiguration_null() throws SecurityException, IOException { 821 try { 822 manager.readConfiguration(null); 823 fail("should throw null pointer exception"); 824 } catch (NullPointerException e) { 825 } 826 827 } 828 829 private static void checkPropertyNull(LogManager m) { 830 // assertNull(m.getProperty(".level")); 831 assertNull(m.getProperty("java.util.logging.FileHandler.limit")); 832 assertNull(m.getProperty("java.util.logging.ConsoleHandler.formatter")); 833 // assertNull(m.getProperty("handlers")); 834 assertNull(m.getProperty("java.util.logging.FileHandler.count")); 835 assertNull(m.getProperty("com.xyz.foo.level")); 836 assertNull(m.getProperty("java.util.logging.FileHandler.formatter")); 837 assertNull(m.getProperty("java.util.logging.ConsoleHandler.level")); 838 assertNull(m.getProperty("java.util.logging.FileHandler.pattern")); 839 } 840 841 @KnownFailure("We're ignoring a missing logging.properties. See bug 2487364") 842 public void testReadConfiguration() throws SecurityException, 843 IOException { 844 845 MockConfigLogManager lm = new MockConfigLogManager(); 846 assertFalse(lm.isCalled); 847 848 lm.readConfiguration(); 849 assertTrue(lm.isCalled); 850 } 851 852 private static void checkProperty(LogManager m) { 853 // assertEquals(m.getProperty(".level"), "INFO"); 854 assertEquals(m.getProperty("java.util.logging.FileHandler.limit"), "50000"); 855 assertEquals(m.getProperty("java.util.logging.ConsoleHandler.formatter"), 856 "java.util.logging.SimpleFormatter"); 857 // assertEquals(m.getProperty("handlers"), 858 // "java.util.logging.ConsoleHandler"); 859 assertEquals(m.getProperty("java.util.logging.FileHandler.count"), "5"); 860 assertEquals(m.getProperty("LogManagerTestFoo.level"), "WARNING"); 861 assertEquals(m.getProperty("java.util.logging.FileHandler.formatter"), 862 "java.util.logging.XMLFormatter"); 863 assertEquals(m.getProperty("java.util.logging.ConsoleHandler.level"), "OFF"); 864 assertEquals(m.getProperty("java.util.logging.FileHandler.pattern"), "%h/java%u.log"); 865 } 866 867 // public void testReadConfiguration() throws SecurityException, IOException { 868 // FIXME: move the support_exec 869 // Logger foo = new MockLogger("foo", null); 870 // assertNull(foo.getLevel()); 871 // assertTrue(mockManager.addLogger(foo)); 872 // 873 // Logger fo = new MockLogger("foo2", null); 874 // fo.setLevel(Level.ALL); 875 // assertTrue(mockManager.addLogger(fo)); 876 // 877 // Handler h = new ConsoleHandler(); 878 // Level l = h.getLevel(); 879 // assertNotSame(Level.OFF, h.getLevel()); 880 // 881 // // read configuration 882 // mockManager.readConfiguration(); 883 // // level DO has effect 884 // assertEquals(Level.WARNING, foo.getLevel()); 885 // // for non specified logger, level is reset to null 886 // assertNull(fo.getLevel()); 887 // 888 // // read properties don't affect handler 889 // assertNotSame(Level.OFF, h.getLevel()); 890 // assertSame(l, h.getLevel()); 891 // 892 // } 893 894 /* 895 * Class under test for void readConfiguration(InputStream) 896 */ 897 @TestTargetNew( 898 level = TestLevel.PARTIAL_COMPLETE, 899 notes = "", 900 method = "readConfiguration", 901 args = {java.io.InputStream.class} 902 ) 903 public void testReadConfigurationInputStream() throws IOException { 904 905 Logger foo = new MockLogger(FOO, null); 906 assertNull(foo.getLevel()); 907 assertTrue(mockManager.addLogger(foo)); 908 909 Logger fo = new MockLogger(FOO + "2", null); 910 fo.setLevel(Level.ALL); 911 assertTrue(mockManager.addLogger(fo)); 912 913 Handler h = new ConsoleHandler(); 914 Level l = h.getLevel(); 915 assertSame(Level.INFO, h.getLevel()); 916 917 // read configuration from stream 918 InputStream stream = EnvironmentHelper.PropertiesToInputStream(props); 919 mockManager.readConfiguration(stream); 920 stream.close(); 921 922 // level DOES have an effect on LogManagerTestFoo 923 assertEquals(Level.WARNING, foo.getLevel()); 924 925 // for non specified logger, level is reset to null 926 assertNull(fo.getLevel()); 927 928 // read properties don't affect handler 929 assertSame(Level.INFO, h.getLevel()); 930 assertSame(l, h.getLevel()); 931 } 932 933 @TestTargetNew( 934 level = TestLevel.PARTIAL_COMPLETE, 935 notes = "Verifies NullPointerException.", 936 method = "readConfiguration", 937 args = {java.io.InputStream.class} 938 ) 939 public void testReadConfigurationInputStream_null() throws SecurityException, IOException { 940 try { 941 mockManager.readConfiguration(null); 942 fail("should throw null pointer exception"); 943 } catch (NullPointerException e) { 944 } 945 946 } 947 @TestTargetNew( 948 level = TestLevel.PARTIAL_COMPLETE, 949 notes = "Verifies IOException.", 950 method = "readConfiguration", 951 args = {java.io.InputStream.class} 952 ) 953 public void testReadConfigurationInputStream_IOException_1parm() throws SecurityException { 954 try { 955 mockManager.readConfiguration(new MockInputStream()); 956 fail("should throw IOException"); 957 } catch (IOException e) { 958 //ignore 959 } 960 961 } 962 963 @TestTargetNew( 964 level = TestLevel.PARTIAL_COMPLETE, 965 notes = "", 966 method = "readConfiguration", 967 args = {java.io.InputStream.class} 968 ) 969 public void testReadConfigurationInputStream_root() throws IOException { 970 manager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props)); 971 972 Logger logger = new MockLogger("testReadConfigurationInputStream_root.foo", null); 973 Logger root = manager.getLogger(""); 974 Logger logger2 = Logger.getLogger("testReadConfigurationInputStream_root.foo2"); 975 976 manager.addLogger(logger); 977 assertNull(logger.getLevel()); 978 assertEquals(0, logger.getHandlers().length); 979 assertSame(root, logger.getParent()); 980 981 assertNull(logger2.getLevel()); 982 assertEquals(0, logger2.getHandlers().length); 983 assertSame(root, logger2.getParent()); 984 // if (!hasConfigClass) { 985 assertEquals(Level.FINE, root.getLevel()); 986 assertEquals(2, root.getHandlers().length); 987 // } 988 989 // after read stream 990 InputStream stream = EnvironmentHelper.PropertiesToInputStream(props); 991 manager.readConfiguration(stream); 992 stream.close(); 993 assertEquals(Level.FINE, root.getLevel()); 994 assertEquals(2, root.getHandlers().length); 995 assertNull(logger.getLevel()); 996 assertEquals(0, logger.getHandlers().length); 997 manager.reset(); 998 } 999 1000 public void testReadConfigurationUpdatesRootLoggersHandlers() 1001 throws IOException { 1002 Properties properties = new Properties(); 1003 LogManager.getLogManager().readConfiguration( 1004 EnvironmentHelper.PropertiesToInputStream(properties)); 1005 1006 Logger root = Logger.getLogger(""); 1007 assertEquals(0, root.getHandlers().length); 1008 1009 properties.put("handlers", "java.util.logging.ConsoleHandler"); 1010 LogManager.getLogManager().readConfiguration( 1011 EnvironmentHelper.PropertiesToInputStream(properties)); 1012 1013 assertEquals(1, root.getHandlers().length); 1014 } 1015 1016 public void testReadConfigurationDoesNotUpdateOtherLoggers() 1017 throws IOException { 1018 Properties properties = new Properties(); 1019 LogManager.getLogManager().readConfiguration( 1020 EnvironmentHelper.PropertiesToInputStream(properties)); 1021 1022 Logger logger = Logger.getLogger("testReadConfigurationDoesNotUpdateOtherLoggers"); 1023 assertEquals(0, logger.getHandlers().length); 1024 1025 properties.put("testReadConfigurationDoesNotUpdateOtherLoggers.handlers", 1026 "java.util.logging.ConsoleHandler"); 1027 LogManager.getLogManager().readConfiguration( 1028 EnvironmentHelper.PropertiesToInputStream(properties)); 1029 1030 assertEquals(0, logger.getHandlers().length); 1031 } 1032 1033 @TestTargets({ 1034 @TestTargetNew( 1035 level = TestLevel.PARTIAL_COMPLETE, 1036 notes = "", 1037 method = "addPropertyChangeListener", 1038 args = {java.beans.PropertyChangeListener.class} 1039 ), 1040 @TestTargetNew( 1041 level = TestLevel.PARTIAL_COMPLETE, 1042 notes = "", 1043 method = "removePropertyChangeListener", 1044 args = {java.beans.PropertyChangeListener.class} 1045 ) 1046 }) 1047 public void testAddRemovePropertyChangeListener() throws Exception { 1048 MockPropertyChangeListener listener1 = new MockPropertyChangeListener(); 1049 MockPropertyChangeListener listener2 = new MockPropertyChangeListener(); 1050 // add same listener1 two times 1051 mockManager.addPropertyChangeListener(listener1); 1052 mockManager.addPropertyChangeListener(listener1); 1053 mockManager.addPropertyChangeListener(listener2); 1054 1055 assertNull(listener1.getEvent()); 1056 assertNull(listener2.getEvent()); 1057 mockManager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props)); 1058 // if (!hasConfigClass) { 1059 assertNotNull(listener1.getEvent()); 1060 assertNotNull(listener2.getEvent()); 1061 // } 1062 1063 listener1.reset(); 1064 listener2.reset(); 1065 1066 // remove listener1, no effect 1067 mockManager.removePropertyChangeListener(listener1); 1068 mockManager.readConfiguration(EnvironmentHelper 1069 .PropertiesToInputStream(props)); 1070 assertNotNull(listener1.getEvent()); 1071 assertNotNull(listener2.getEvent()); 1072 listener1.reset(); 1073 listener2.reset(); 1074 1075 // remove listener1 again and it works 1076 mockManager.removePropertyChangeListener(listener1); 1077 mockManager.readConfiguration(EnvironmentHelper 1078 .PropertiesToInputStream(props)); 1079 assertNull(listener1.getEvent()); 1080 assertNotNull(listener2.getEvent()); 1081 listener2.reset(); 1082 1083 // reset don't produce event 1084 mockManager.reset(); 1085 assertNull(listener2.getEvent()); 1086 1087 mockManager.removePropertyChangeListener(listener2); 1088 mockManager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props)); 1089 assertNull(listener1.getEvent()); 1090 assertNull(listener2.getEvent()); 1091 } 1092 1093 @TestTargets({ 1094 @TestTargetNew( 1095 level = TestLevel.PARTIAL_COMPLETE, 1096 notes = "", 1097 method = "addPropertyChangeListener", 1098 args = {java.beans.PropertyChangeListener.class} 1099 ), 1100 @TestTargetNew( 1101 level = TestLevel.PARTIAL_COMPLETE, 1102 notes = "", 1103 method = "removePropertyChangeListener", 1104 args = {java.beans.PropertyChangeListener.class} 1105 ) 1106 }) 1107 public void testAddRemovePropertyChangeListener_null() { 1108 // seems nothing happened 1109 try{ 1110 mockManager.addPropertyChangeListener(null); 1111 fail("Should throw NPE"); 1112 }catch(NullPointerException e){ 1113 } 1114 mockManager.removePropertyChangeListener(null); 1115 } 1116 1117 @TestTargetNew( 1118 level = TestLevel.PARTIAL_COMPLETE, 1119 notes = "Doesn't verify SecurityException.", 1120 method = "reset", 1121 args = {} 1122 ) 1123 public void testReset() throws SecurityException, IOException { 1124 // mock LogManager 1125 mockManager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props)); 1126 assertNotNull(mockManager.getProperty("handlers")); 1127 Logger foo = new MockLogger(FOO, null); 1128 assertNull(foo.getLevel()); 1129 assertEquals(0, foo.getHandlers().length); 1130 foo.setLevel(Level.ALL); 1131 foo.addHandler(new ConsoleHandler()); 1132 assertTrue(mockManager.addLogger(foo)); 1133 assertEquals(Level.WARNING, foo.getLevel()); 1134 assertEquals(2, foo.getHandlers().length); 1135 1136 // reset 1137 mockManager.reset(); 1138 1139 // properties is cleared 1140 assertNull(mockManager.getProperty("handlers")); 1141 1142 // level is null 1143 assertNull(foo.getLevel()); 1144 // handlers are all closed 1145 assertEquals(0, foo.getHandlers().length); 1146 1147 // for root logger 1148 manager.reset(); 1149 assertNull(manager.getProperty("handlers")); 1150 Logger root = manager.getLogger(""); 1151 // level reset to info 1152 assertEquals(Level.INFO, root.getLevel()); 1153 // also close root's handler 1154 assertEquals(0, root.getHandlers().length); 1155 } 1156 1157 1158 @TestTargetNew( 1159 level = TestLevel.PARTIAL_COMPLETE, 1160 notes = "Doesn't verify SecurityException.", 1161 method = "readConfiguration", 1162 args = {java.io.InputStream.class} 1163 ) 1164 public void testGlobalPropertyConfig() throws Exception { 1165 PrintStream err = System.err; 1166 try { 1167 System.setErr(new PrintStream(new NullOutputStream())); 1168 // before add config property, root has two handler 1169 manager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props)); 1170 assertEquals(2, manager.getLogger("").getHandlers().length); 1171 1172 // one valid config class 1173 props.setProperty("config", className + "$MockValidConfig"); 1174 manager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props)); 1175 assertEquals(3, manager.getLogger("").getHandlers().length); 1176 1177 // two config class take effect orderly 1178 props.setProperty("config", className + "$MockValidConfig " + className 1179 + "$MockValidConfig2"); 1180 manager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props)); 1181 assertEquals(2, manager.getLogger("").getHandlers().length); 1182 1183 props.setProperty("config", className + "$MockValidConfig2 " + className 1184 + "$MockValidConfig"); 1185 manager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props)); 1186 assertEquals(3, manager.getLogger("").getHandlers().length); 1187 1188 // invalid config class which throw exception, just print exception 1189 // and 1190 // message 1191 props.setProperty("config", className + "$MockInvalidConfigException"); 1192 manager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props)); 1193 1194 // invalid config class without default constructor, just print 1195 // exception and message 1196 props.setProperty("config", className + "$MockInvalidConfigNoDefaultConstructor"); 1197 manager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props)); 1198 1199 // bad config class name, just print exception and message 1200 props.setProperty("config", "badname"); 1201 manager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props)); 1202 1203 // invalid separator, nothing happened 1204 props.setProperty("config", className + "$MockValidConfig2;" + className 1205 + "$MockValidConfig"); 1206 manager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props)); 1207 assertEquals(2, manager.getLogger("").getHandlers().length); 1208 props.setProperty("config", className + "$MockValidConfig2;" + className 1209 + "$MockValidConfig " + className + "$MockValidConfig"); 1210 manager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props)); 1211 assertEquals(3, manager.getLogger("").getHandlers().length); 1212 1213 // duplicate config class, take effect twice 1214 props.setProperty("config", className + "$MockValidConfig " + className 1215 + "$MockValidConfig"); 1216 manager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props)); 1217 assertEquals(4, manager.getLogger("").getHandlers().length); 1218 1219 // invalid config classes mixed with valid config classes, valid 1220 // config 1221 // classes take effect 1222 props.setProperty("config", "badname " + className + "$MockValidConfig " + className 1223 + "$MockInvalidConfigNoDefaultConstructor " + className + "$MockValidConfig"); 1224 manager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props)); 1225 assertEquals(4, manager.getLogger("").getHandlers().length); 1226 1227 // global property take effect before logger specified property 1228 props.setProperty("config", className + "$MockValidConfig"); 1229 manager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props)); 1230 assertEquals(Level.FINE, manager.getLogger("").getLevel()); 1231 } finally { 1232 System.setErr(err); 1233 manager.reset(); 1234 } 1235 1236 } 1237 @TestTargetNew( 1238 level = TestLevel.PARTIAL_COMPLETE, 1239 notes = "", 1240 method = "readConfiguration", 1241 args = {} 1242 ) 1243 public void testValidConfigClass() throws Exception { 1244 // System.setProperty("java.util.logging.config.class", "org.apache.harmony.logging.tests.java.util.logging.LogManagerTest$ConfigClass"); 1245 System.setProperty("java.util.logging.config.class", this.getClass().getName() 1246 + "$ConfigClass"); 1247 assertNull(manager.getLogger("testConfigClass.foo")); 1248 1249 manager.readConfiguration(); 1250 assertNull(manager.getLogger("testConfigClass.foo")); 1251 Logger l = Logger.getLogger("testConfigClass.foo.child"); 1252 assertSame(Level.FINEST, manager.getLogger("").getLevel()); 1253 assertEquals(0, manager.getLogger("").getHandlers().length); 1254 assertEquals("testConfigClass.foo", l.getParent().getName()); 1255 } 1256 1257 /* 1258 * ---------------------------------------------------- 1259 * mock classes 1260 * ---------------------------------------------------- 1261 */ 1262 1263 1264 public static class ConfigClass { 1265 public ConfigClass() throws Exception { 1266 LogManager man = LogManager.getLogManager(); 1267 Properties props = new Properties(); 1268 props.put("handlers", className + "$MockHandler " + className + "$MockHandler"); 1269 props.put("java.util.logging.FileHandler.pattern", "%h/java%u.log"); 1270 props.put("java.util.logging.FileHandler.limit", "50000"); 1271 props.put("java.util.logging.FileHandler.count", "5"); 1272 props.put("java.util.logging.FileHandler.formatter", "java.util.logging.XMLFormatter"); 1273 props.put(".level", "FINE"); 1274 props.put("java.util.logging.ConsoleHandler.level", "OFF"); 1275 props.put("java.util.logging.ConsoleHandler.formatter","java.util.logging.SimpleFormatter"); 1276 props.put("LogManagerTestFoo.handlers", "java.util.logging.ConsoleHandler"); 1277 props.put("LogManagerTestFoo.level", "WARNING"); 1278 props.put("testConfigClass.foo.level", "OFF"); 1279 props.put("testConfigClass.foo.handlers", "java.util.logging.ConsoleHandler"); 1280 props.put(".level", "FINEST"); 1281 props.remove("handlers"); 1282 InputStream in = EnvironmentHelper.PropertiesToInputStream(props); 1283 man.readConfiguration(in); 1284 } 1285 } 1286 1287 public static class MockInvalidInitClass { 1288 public MockInvalidInitClass() { 1289 throw new RuntimeException(); 1290 } 1291 } 1292 1293 public static class TestInvalidConfigFile { 1294 public static void main(String[] args) { 1295 LogManager manager = LogManager.getLogManager(); 1296 Logger root = manager.getLogger(""); 1297 checkPropertyNull(manager); 1298 assertEquals(0, root.getHandlers().length); 1299 assertEquals(Level.INFO, root.getLevel()); 1300 1301 try { 1302 manager.readConfiguration(); 1303 } catch (Exception e) { 1304 e.printStackTrace(); 1305 } 1306 checkProperty(manager); 1307 assertNull(root.getHandlers()[0].getLevel()); 1308 assertEquals(1, root.getHandlers().length); 1309 assertEquals(Level.INFO, root.getLevel()); 1310 1311 manager.reset(); 1312 checkProperty(manager); 1313 assertEquals(0, root.getHandlers().length); 1314 assertEquals(Level.INFO, root.getLevel()); 1315 try { 1316 manager.readConfiguration(); 1317 } catch (Exception e) { 1318 e.printStackTrace(); 1319 } 1320 manager.reset(); 1321 } 1322 } 1323 1324 public static class TestValidConfigFile { 1325 public static void main(String[] args) { 1326 LogManager manager = LogManager.getLogManager(); 1327 Logger root = manager.getLogger(""); 1328 checkPropertyNull(manager); 1329 assertEquals(2, root.getHandlers().length); 1330 assertEquals(root.getHandlers()[0].getLevel(), Level.OFF); 1331 assertEquals(Level.ALL, root.getLevel()); 1332 1333 try { 1334 manager.readConfiguration(); 1335 } catch (Exception e) { 1336 e.printStackTrace(); 1337 } 1338 checkPropertyNull(manager); 1339 assertEquals(root.getHandlers()[0].getLevel(), Level.OFF); 1340 assertEquals(2, root.getHandlers().length); 1341 assertEquals(Level.ALL, root.getLevel()); 1342 1343 manager.reset(); 1344 checkPropertyNull(manager); 1345 assertEquals(0, root.getHandlers().length); 1346 assertEquals(Level.INFO, root.getLevel()); 1347 try { 1348 manager.readConfiguration(); 1349 } catch (Exception e) { 1350 e.printStackTrace(); 1351 } 1352 manager.reset(); 1353 } 1354 } 1355 1356 public static class TestMockLogManager { 1357 public static void main(String[] args) { 1358 LogManager manager = LogManager.getLogManager(); 1359 assertTrue(manager instanceof MockLogManager); 1360 } 1361 } 1362 1363 public static class TestValidConfigClass { 1364 public static void main(String[] args) { 1365 LogManager manager = LogManager.getLogManager(); 1366 Logger root = manager.getLogger(""); 1367 checkPropertyNull(manager); 1368 assertEquals(1, root.getHandlers().length); 1369 assertEquals(Level.OFF, root.getLevel()); 1370 1371 try { 1372 manager.readConfiguration(); 1373 } catch (Exception e) { 1374 e.printStackTrace(); 1375 } 1376 checkPropertyNull(manager); 1377 assertEquals(1, root.getHandlers().length); 1378 assertEquals(Level.OFF, root.getLevel()); 1379 1380 try { 1381 manager.readConfiguration(); 1382 } catch (Exception e) { 1383 e.printStackTrace(); 1384 } 1385 checkPropertyNull(manager); 1386 assertEquals(1, root.getHandlers().length); 1387 assertEquals(Level.OFF, root.getLevel()); 1388 1389 manager.reset(); 1390 checkPropertyNull(manager); 1391 assertEquals(0, root.getHandlers().length); 1392 assertEquals(Level.INFO, root.getLevel()); 1393 try { 1394 manager.readConfiguration(); 1395 } catch (Exception e) { 1396 e.printStackTrace(); 1397 } 1398 manager.reset(); 1399 } 1400 } 1401 1402 public static class MockLogger extends Logger { 1403 public MockLogger(String name, String rbName) { 1404 super(name, rbName); 1405 } 1406 } 1407 1408 public static class MockLogManager extends LogManager { 1409 } 1410 1411 public static class MockConfigLogManager extends LogManager { 1412 public boolean isCalled = false; 1413 1414 public void readConfiguration(InputStream ins) throws IOException { 1415 isCalled = true; 1416 super.readConfiguration(ins); 1417 } 1418 } 1419 1420 public static class MockHandler extends Handler { 1421 static int number = 0; 1422 1423 public MockHandler() { 1424 addNumber(); 1425 // System.out.println(this + ":start:" + number); 1426 } 1427 1428 private synchronized void addNumber() { 1429 number++; 1430 } 1431 1432 public void close() { 1433 minusNumber(); 1434 // System.out.println(this + ":close:" + number); 1435 } 1436 1437 private synchronized void minusNumber() { 1438 number--; 1439 } 1440 1441 public void flush() { 1442 // System.out.println(this + ":flush"); 1443 } 1444 1445 public void publish(LogRecord record) { 1446 } 1447 1448 } 1449 1450 public static class MockValidInitClass { 1451 public MockValidInitClass() { 1452 Properties p = new Properties(); 1453 p.put("handlers", className + "$MockHandler"); 1454 p.put(".level", "OFF"); 1455 InputStream in = null; 1456 try { 1457 in = EnvironmentHelper.PropertiesToInputStream(p); 1458 LogManager manager = LogManager.getLogManager(); 1459 manager.readConfiguration(in); 1460 } catch (Exception e) { 1461 e.printStackTrace(); 1462 } finally { 1463 try { 1464 in.close(); 1465 } catch (Exception e) { 1466 } 1467 } 1468 } 1469 } 1470 1471 public static class MockValidConfig { 1472 public MockValidConfig() { 1473 handler = new MockHandler(); 1474 LogManager manager = LogManager.getLogManager(); 1475 Logger root = null; 1476 if (null != manager) { 1477 root = manager.getLogger(""); 1478 } else { 1479 System.out.println("null manager"); 1480 } 1481 if (null != root) { 1482 root.addHandler(handler); 1483 root.setLevel(Level.OFF); 1484 } 1485 } 1486 } 1487 1488 public static class MockValidConfig2 { 1489 1490 static Logger root = null; 1491 1492 public MockValidConfig2() { 1493 root = LogManager.getLogManager().getLogger(""); 1494 root.removeHandler(handler); 1495 } 1496 } 1497 1498 public static class MockInvalidConfigException { 1499 public MockInvalidConfigException() { 1500 throw new RuntimeException("invalid config class - throw exception"); 1501 } 1502 } 1503 1504 public static class MockInvalidConfigNoDefaultConstructor { 1505 public MockInvalidConfigNoDefaultConstructor(int i) { 1506 throw new RuntimeException("invalid config class - no default constructor"); 1507 } 1508 } 1509 1510 public static class MockPropertyChangeListener implements 1511 PropertyChangeListener { 1512 1513 PropertyChangeEvent event = null; 1514 1515 public void propertyChange(PropertyChangeEvent event) { 1516 this.event = event; 1517 } 1518 1519 public PropertyChangeEvent getEvent() { 1520 return event; 1521 } 1522 1523 public void reset() { 1524 event = null; 1525 } 1526 1527 } 1528 1529 public static class MockSecurityManagerLogPermission extends SecurityManager { 1530 1531 public void checkPermission(Permission permission, Object context) { 1532 if (permission instanceof LoggingPermission) { 1533 throw new SecurityException(); 1534 } 1535 } 1536 1537 public void checkPermission(Permission permission) { 1538 if (permission instanceof LoggingPermission) { 1539 StackTraceElement[] stack = (new Throwable()).getStackTrace(); 1540 for (int i = 0; i < stack.length; i++) { 1541 if (stack[i].getClassName().equals("java.util.logging.Logger")) { 1542 return; 1543 } 1544 } 1545 throw new SecurityException("Found LogManager checkAccess()"); 1546 } 1547 } 1548 } 1549 1550 public static class MockSecurityManagerOtherPermission extends SecurityManager { 1551 1552 public void checkPermission(Permission permission, Object context) { 1553 if (permission instanceof LoggingPermission) { 1554 return; 1555 } 1556 if (permission.getName().equals("setSecurityManager")) { 1557 return; 1558 } 1559 // throw new SecurityException(); 1560 super.checkPermission(permission, context); 1561 } 1562 1563 public void checkPermission(Permission permission) { 1564 if (permission instanceof LoggingPermission) { 1565 return; 1566 } 1567 if (permission.getName().equals("setSecurityManager")) { 1568 return; 1569 } 1570 super.checkPermission(permission); 1571 } 1572 } 1573 1574 /* 1575 * Test config class loading 1576 * java -Djava.util.logging.config.class=badConfigClassName ClassLoadingTest 1577 */ 1578 public static class ClassLoadingTest { 1579 public static void main(String[] args) { 1580 Thread.currentThread().setContextClassLoader(new MockErrorClassLoader()); 1581 try { 1582 LogManager.getLogManager(); 1583 fail("Should throw mock error"); 1584 } catch (MockError e) { 1585 } 1586 } 1587 1588 static class MockErrorClassLoader extends ClassLoader { 1589 public Class<?> loadClass(String name) { 1590 throw new MockError(); 1591 } 1592 } 1593 1594 static class MockError extends Error { 1595 } 1596 } 1597 1598 public static class MockInputStream extends InputStream { 1599 1600 @Override 1601 public int read() throws IOException { 1602 throw new IOException(); 1603 } 1604 1605 1606 } 1607 1608 1609} 1610