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 20import java.security.Permission; 21import java.util.Locale; 22import java.util.MissingResourceException; 23import java.util.Properties; 24import java.util.ResourceBundle; 25import java.util.logging.Filter; 26import java.util.logging.Handler; 27import java.util.logging.Level; 28import java.util.logging.LogManager; 29import java.util.logging.LogRecord; 30import java.util.logging.Logger; 31import java.util.logging.LoggingPermission; 32import java.io.File; 33import java.io.FileInputStream; 34 35import dalvik.annotation.KnownFailure; 36import junit.framework.TestCase; 37 38import org.apache.harmony.logging.tests.java.util.logging.util.EnvironmentHelper; 39 40import tests.util.CallVerificationStack; 41import dalvik.annotation.SideEffect; 42import dalvik.annotation.TestLevel; 43import dalvik.annotation.TestTargetClass; 44import dalvik.annotation.TestTargetNew; 45import dalvik.annotation.TestTargets; 46 47/** 48 * Test suite for the class java.util.logging.Logger. 49 */ 50@TestTargetClass(Logger.class) 51public class LoggerTest extends TestCase { 52 53 private final static String VALID_RESOURCE_BUNDLE = "bundles/java/util/logging/res"; 54 55 private final static String VALID_RESOURCE_BUNDLE2 = "bundles/java/util/logging/res2"; 56 57 private final static String VALID_RESOURCE_BUNDLE3 = "bundles/java/util/logging/res3"; 58 59 private final static String INVALID_RESOURCE_BUNDLE = "impossible_not_existing"; 60 61 private final static String LOGGING_CONFIG_FILE = "src/test/resources/config/java/util/logging/logging.config"; 62 63 private final static String VALID_KEY = "LOGGERTEST"; 64 65 private final static String VALID_VALUE = "Test_ZH_CN"; 66 67 private final static String VALID_VALUE2 = "Test_NoLocale2"; 68 69 private Logger sharedLogger = null; 70 71 private Locale oldLocale = null; 72 73 /* 74 * @see TestCase#setUp() Notice : Logger constructor is protected => 75 * MockLogger 76 */ 77 protected void setUp() throws Exception { 78 super.setUp(); 79 LogManager.getLogManager().reset(); 80 oldLocale = Locale.getDefault(); 81 Locale.setDefault(new Locale("zh", "CN")); 82 sharedLogger = new MockLogger("SharedLogger", VALID_RESOURCE_BUNDLE); 83 sharedLogger.addHandler(new MockHandler()); 84 } 85 86 /* 87 * Reset the log manager. 88 */ 89 protected void tearDown() throws Exception { 90 CallVerificationStack.getInstance().clear(); 91 Locale.setDefault(oldLocale); 92 LogManager.getLogManager().reset(); 93 super.tearDown(); 94 } 95 96 /* 97 * Test the global logger 98 */ 99 @TestTargetNew( 100 level = TestLevel.COMPLETE, 101 notes = "", 102 method = "Logger", 103 args = {java.lang.String.class, java.lang.String.class} 104 ) 105 public void testGlobalLogger() { 106 assertNull(Logger.global.getFilter()); 107 assertEquals(0, Logger.global.getHandlers().length); 108 assertNull(Logger.global.getLevel()); 109 assertEquals("global", Logger.global.getName()); 110 assertNull(Logger.global.getParent().getParent()); 111 assertNull(Logger.global.getResourceBundle()); 112 assertNull(Logger.global.getResourceBundleName()); 113 assertTrue(Logger.global.getUseParentHandlers()); 114 assertSame(Logger.global, Logger.getLogger("global")); 115 assertSame(Logger.global, LogManager.getLogManager() 116 .getLogger("global")); 117 } 118 119 /* 120 * Test constructor under normal conditions. 121 */ 122 @TestTargetNew( 123 level = TestLevel.PARTIAL_COMPLETE, 124 notes = "Verifies constructor under normal conditions.", 125 method = "Logger", 126 args = {java.lang.String.class, java.lang.String.class} 127 ) 128 public void testConstructor_Normal() { 129 MockLogger mlog = new MockLogger("myname", VALID_RESOURCE_BUNDLE); 130 assertNull(mlog.getFilter()); 131 assertEquals(0, mlog.getHandlers().length); 132 assertNull(mlog.getLevel()); 133 assertEquals("myname", mlog.getName()); 134 assertNull(mlog.getParent()); 135 ResourceBundle rb = mlog.getResourceBundle(); 136 assertEquals(VALID_VALUE, rb.getString(VALID_KEY)); 137 assertEquals(mlog.getResourceBundleName(), VALID_RESOURCE_BUNDLE); 138 assertTrue(mlog.getUseParentHandlers()); 139 } 140 141 /* 142 * Test constructor with null parameters. 143 */ 144 @TestTargetNew( 145 level = TestLevel.PARTIAL_COMPLETE, 146 notes = "Verifies constructor with null parameters.", 147 method = "Logger", 148 args = {java.lang.String.class, java.lang.String.class} 149 ) 150 public void testConstructor_Null() { 151 MockLogger mlog = new MockLogger(null, null); 152 assertNull(mlog.getFilter()); 153 assertEquals(0, mlog.getHandlers().length); 154 assertNull(mlog.getLevel()); 155 assertNull(mlog.getName()); 156 assertNull(mlog.getParent()); 157 assertNull(mlog.getResourceBundle()); 158 assertNull(mlog.getResourceBundleName()); 159 assertTrue(mlog.getUseParentHandlers()); 160 } 161 162 /* 163 * Test constructor with invalid name. 164 */ 165 @TestTargetNew( 166 level = TestLevel.PARTIAL_COMPLETE, 167 notes = "Verifies constructor with invalid name.", 168 method = "Logger", 169 args = {java.lang.String.class, java.lang.String.class} 170 ) 171 public void testConstructor_InvalidName() { 172 MockLogger mlog = new MockLogger("...#$%%^&&()-_+=!@~./,[]{};:'\\\"?|", 173 null); 174 assertEquals("...#$%%^&&()-_+=!@~./,[]{};:'\\\"?|", mlog.getName()); 175 } 176 177 /* 178 * Test constructor with empty name. 179 */ 180 @TestTargetNew( 181 level = TestLevel.PARTIAL_COMPLETE, 182 notes = "Verifies constructor with empty name.", 183 method = "Logger", 184 args = {java.lang.String.class, java.lang.String.class} 185 ) 186 public void testConstructor_EmptyName() { 187 MockLogger mlog = new MockLogger("", null); 188 assertEquals("", mlog.getName()); 189 } 190 191 /* 192 * Test constructor with invalid resource bundle name. 193 */ 194 @TestTargetNew( 195 level = TestLevel.PARTIAL_COMPLETE, 196 notes = "Verifies MissingResourceException.", 197 method = "Logger", 198 args = {java.lang.String.class, java.lang.String.class} 199 ) 200 public void testConstructor_InvalidResourceBundle() { 201 202 // try anonymous with invalid resource 203 try { 204 new MockLogger(null, INVALID_RESOURCE_BUNDLE); 205 fail("Should throw MissingResourceException!"); 206 } catch (MissingResourceException e) { 207 // ok ! 208 } 209 // try named Logger with invalid resource 210 try { 211 new MockLogger("testConstructor_InvalidResourceBundle", 212 INVALID_RESOURCE_BUNDLE); 213 fail("Should throw MissingResourceException!"); 214 } catch (MissingResourceException e) { 215 // ok ! 216 } 217 // try empty string 218 try { 219 new MockLogger(null, ""); 220 fail("Should throw MissingResourceException!"); 221 } catch (MissingResourceException e) { 222 // ok ! 223 } 224 } 225 226 /* 227 * Test getAnonymousLogger() 228 */ 229 @TestTargetNew( 230 level = TestLevel.COMPLETE, 231 notes = "", 232 method = "getAnonymousLogger", 233 args = {} 234 ) 235 public void testGetAnonymousLogger() { 236 Logger alog = Logger.getAnonymousLogger(); 237 assertNotSame(alog, Logger.getAnonymousLogger()); 238 assertNull(alog.getFilter()); 239 assertEquals(0, alog.getHandlers().length); 240 assertNull(alog.getLevel()); 241 assertNull(alog.getName()); 242 assertEquals("", alog.getParent().getName()); 243 assertNull(alog.getParent().getParent()); 244 assertNull(alog.getResourceBundle()); 245 assertNull(alog.getResourceBundleName()); 246 assertTrue(alog.getUseParentHandlers()); 247 } 248 249 /* 250 * Test getAnonymousLogger(String resourceBundleName) with valid resource 251 * bundle. 252 */ 253 @TestTargetNew( 254 level = TestLevel.PARTIAL_COMPLETE, 255 notes = "Verifies getAnonymousLogger(String resourceBundleName) with valid resource bundle.", 256 method = "getAnonymousLogger", 257 args = {java.lang.String.class} 258 ) 259 public void testGetAnonymousLogger_ValidResourceBundle() { 260 Logger alog = Logger.getAnonymousLogger(VALID_RESOURCE_BUNDLE); 261 assertNotSame(alog, Logger.getAnonymousLogger(VALID_RESOURCE_BUNDLE)); 262 assertNull(alog.getFilter()); 263 assertEquals(0, alog.getHandlers().length); 264 assertNull(alog.getLevel()); 265 assertNull(alog.getName()); 266 assertEquals("", alog.getParent().getName()); 267 assertNull(alog.getParent().getParent()); 268 assertEquals(VALID_VALUE, alog.getResourceBundle().getString(VALID_KEY)); 269 assertEquals(alog.getResourceBundleName(), VALID_RESOURCE_BUNDLE); 270 assertTrue(alog.getUseParentHandlers()); 271 } 272 273 /* 274 * Test getAnonymousLogger(String resourceBundleName) with null resource 275 * bundle. 276 */ 277 @TestTargetNew( 278 level = TestLevel.PARTIAL_COMPLETE, 279 notes = "Verifies getAnonymousLogger(String resourceBundleName) with null resource bundle.", 280 method = "getAnonymousLogger", 281 args = {java.lang.String.class} 282 ) 283 public void testGetAnonymousLogger_NullResourceBundle() { 284 Logger alog = Logger.getAnonymousLogger(null); 285 assertNotSame(alog, Logger.getAnonymousLogger(null)); 286 assertNull(alog.getFilter()); 287 assertEquals(0, alog.getHandlers().length); 288 assertNull(alog.getLevel()); 289 assertNull(alog.getName()); 290 assertEquals("", alog.getParent().getName()); 291 assertNull(alog.getParent().getParent()); 292 assertNull(alog.getResourceBundle()); 293 assertNull(alog.getResourceBundleName()); 294 assertTrue(alog.getUseParentHandlers()); 295 } 296 297 /* 298 * Test getAnonymousLogger(String resourceBundleName) with invalid resource 299 * bundle. 300 */ 301 @TestTargetNew( 302 level = TestLevel.PARTIAL_COMPLETE, 303 notes = "Verifies getAnonymousLogger(String resourceBundleName) with invalid resource bundle.", 304 method = "getAnonymousLogger", 305 args = {java.lang.String.class} 306 ) 307 public void testGetAnonymousLogger_InvalidResourceBundle() { 308 try { 309 Logger.getAnonymousLogger(INVALID_RESOURCE_BUNDLE); 310 fail("Should throw MissingResourceException!"); 311 } catch (MissingResourceException e) { 312 } 313 // try empty name 314 try { 315 Logger.getAnonymousLogger(""); 316 fail("Should throw MissingResourceException!"); 317 } catch (MissingResourceException e) { 318 } 319 } 320 321 /* 322 * Test getLogger(String), getting a logger with no parent. 323 */ 324 @TestTargetNew( 325 level = TestLevel.PARTIAL_COMPLETE, 326 notes = "Verifies getLogger(String), getting a logger with no parent.", 327 method = "getLogger", 328 args = {java.lang.String.class} 329 ) 330 public void testGetLogger_Normal() throws Exception { 331 // config the level 332 Properties p = new Properties(); 333 p.put("testGetLogger_Normal_ANewLogger.level", "ALL"); 334 LogManager.getLogManager().readConfiguration( 335 EnvironmentHelper.PropertiesToInputStream(p)); 336 337 assertNull(LogManager.getLogManager().getLogger( 338 "testGetLogger_Normal_ANewLogger")); 339 // create a new logger 340 Logger log = Logger.getLogger("testGetLogger_Normal_ANewLogger"); 341 // get an existing logger 342 assertSame(log, Logger.getLogger("testGetLogger_Normal_ANewLogger")); 343 // check it has been registered 344 assertSame(log, LogManager.getLogManager().getLogger( 345 "testGetLogger_Normal_ANewLogger")); 346 347 assertNull(log.getFilter()); 348 assertEquals(0, log.getHandlers().length); 349 // check it's set to the preconfigured level 350 assertSame(Level.ALL, log.getLevel()); 351 assertEquals("testGetLogger_Normal_ANewLogger", log.getName()); 352 assertNull(log.getParent().getParent()); 353 assertNull(log.getResourceBundle()); 354 assertNull(log.getResourceBundleName()); 355 assertTrue(log.getUseParentHandlers()); 356 357 358 } 359 360 /* 361 * Test getLogger(String), getting a logger with invalid level configured. 362 */ 363 @TestTargetNew( 364 level = TestLevel.PARTIAL_COMPLETE, 365 notes = "Verifies getLogger(String), getting a logger with invalid level configured.", 366 method = "getLogger", 367 args = {java.lang.String.class} 368 ) 369 public void testGetLogger_InvalidLevel() throws Exception { 370 // config the level 371 Properties p = new Properties(); 372 p 373 .put("testGetLogger_InvalidLevel_ANewLogger.level", 374 "impossible_level"); 375 LogManager.getLogManager().readConfiguration( 376 EnvironmentHelper.PropertiesToInputStream(p)); 377 378 assertNull(LogManager.getLogManager().getLogger( 379 "testGetLogger_InvalidLevel_ANewLogger")); 380 // create a new logger 381 Logger log = Logger.getLogger("testGetLogger_InvalidLevel_ANewLogger"); 382 // get an existing logger 383 assertSame(log, Logger 384 .getLogger("testGetLogger_InvalidLevel_ANewLogger")); 385 // check it has been registered 386 assertSame(log, LogManager.getLogManager().getLogger( 387 "testGetLogger_InvalidLevel_ANewLogger")); 388 assertNull(log.getLevel()); 389 } 390 391 /* 392 * Test getLogger(String) with null name. 393 */ 394 @TestTargetNew( 395 level = TestLevel.PARTIAL_COMPLETE, 396 notes = "Verifies getLogger(String) with null name.", 397 method = "getLogger", 398 args = {java.lang.String.class} 399 ) 400 public void testGetLogger_Null() { 401 try { 402 Logger.getLogger(null); 403 fail("Should throw NullPointerException!"); 404 } catch (NullPointerException e) { 405 // ok ! 406 } 407 try { 408 Logger.getLogger(null, null); 409 fail("Should throw NullPointerException!"); 410 } catch (NullPointerException e) { 411 // ok ! 412 } 413 } 414 415 /* 416 * Test getLogger(String) with invalid name. 417 */ 418 @TestTargetNew( 419 level = TestLevel.PARTIAL_COMPLETE, 420 notes = "Verifies getLogger(String) with invalid name.", 421 method = "getLogger", 422 args = {java.lang.String.class} 423 ) 424 public void testGetLogger_Invalid() { 425 Logger log = Logger.getLogger("...#$%%^&&()-_+=!@~./,[]{};:'\\\"?|"); 426 assertEquals("...#$%%^&&()-_+=!@~./,[]{};:'\\\"?|", log.getName()); 427 } 428 429 /* 430 * Test getLogger(String) with empty name. 431 */ 432 @TestTargetNew( 433 level = TestLevel.PARTIAL_COMPLETE, 434 notes = "Verifies getLogger(String) with empty name.", 435 method = "getLogger", 436 args = {java.lang.String.class} 437 ) 438 public void testGetLogger_Empty() { 439 assertNotNull(LogManager.getLogManager().getLogger("")); 440 Logger log = Logger.getLogger(""); 441 assertSame(log, LogManager.getLogManager().getLogger("")); 442 assertNull(log.getFilter()); 443 assertEquals(0, log.getHandlers().length); 444 // check it's set to the preconfigured level 445 assertSame(Level.INFO, log.getLevel()); 446 assertEquals("", log.getName()); 447 assertNull(log.getParent()); 448 assertTrue(log.getUseParentHandlers()); 449 assertNull(log.getResourceBundle()); 450 assertNull(log.getResourceBundleName()); 451 } 452 453 /* 454 * Test getLogger(String), getting a logger with existing parent. 455 */ 456 @TestTargetNew( 457 level = TestLevel.PARTIAL_COMPLETE, 458 notes = "Verifies getLogger(String), getting a logger with existing parent.", 459 method = "getLogger", 460 args = {java.lang.String.class, java.lang.String.class} 461 ) 462 public void testGetLogger_WithParent() { 463 assertNull(LogManager.getLogManager().getLogger( 464 "testGetLogger_WithParent_ParentLogger")); 465 466 // get root of hierarchy 467 Logger root = Logger.getLogger(""); 468 // create the parent logger 469 Logger pLog = Logger.getLogger("testGetLogger_WithParent_ParentLogger", 470 VALID_RESOURCE_BUNDLE); 471 pLog.setLevel(Level.CONFIG); 472 pLog.addHandler(new MockHandler()); 473 pLog.setFilter(new MockFilter()); 474 pLog.setUseParentHandlers(false); 475 // check root parent 476 assertEquals("testGetLogger_WithParent_ParentLogger", pLog.getName()); 477 assertSame(pLog.getParent(), root); 478 479 // child part 480 assertNull(LogManager.getLogManager().getLogger( 481 "testGetLogger_WithParent_ParentLogger.child")); 482 // create the child logger 483 Logger child = Logger 484 .getLogger("testGetLogger_WithParent_ParentLogger.child"); 485 assertNull(child.getFilter()); 486 assertEquals(0, child.getHandlers().length); 487 assertNull(child.getLevel()); 488 assertEquals("testGetLogger_WithParent_ParentLogger.child", child 489 .getName()); 490 assertSame(child.getParent(), pLog); 491 assertNull(child.getResourceBundle()); 492 assertNull(child.getResourceBundleName()); 493 assertTrue(child.getUseParentHandlers()); 494 495 // create not valid child 496 Logger notChild = Logger 497 .getLogger("testGetLogger_WithParent_ParentLogger1.child"); 498 assertNull(notChild.getFilter()); 499 assertEquals(0, notChild.getHandlers().length); 500 assertNull(notChild.getLevel()); 501 assertEquals("testGetLogger_WithParent_ParentLogger1.child", notChild 502 .getName()); 503 assertNotSame(notChild.getParent(), pLog); 504 assertNull(notChild.getResourceBundle()); 505 assertNull(notChild.getResourceBundleName()); 506 assertTrue(notChild.getUseParentHandlers()); 507 // verify two level root.parent 508 assertEquals("testGetLogger_WithParent_ParentLogger.child", child 509 .getName()); 510 assertSame(child.getParent().getParent(), root); 511 512 513 // create three level child 514 Logger childOfChild = Logger 515 .getLogger("testGetLogger_WithParent_ParentLogger.child.child"); 516 assertNull(childOfChild.getFilter()); 517 assertEquals(0, childOfChild.getHandlers().length); 518 assertSame(child.getParent().getParent(), root); 519 assertNull(childOfChild.getLevel()); 520 assertEquals("testGetLogger_WithParent_ParentLogger.child.child", 521 childOfChild.getName()); 522 523 assertSame(childOfChild.getParent(), child); 524 assertSame(childOfChild.getParent().getParent(), pLog); 525 assertSame(childOfChild.getParent().getParent().getParent(), root); 526 assertNull(childOfChild.getResourceBundle()); 527 assertNull(childOfChild.getResourceBundleName()); 528 assertTrue(childOfChild.getUseParentHandlers()); 529 530 // abnormal case : lookup to root parent in a hierarchy without a logger 531 // parent created between 532 assertEquals("testGetLogger_WithParent_ParentLogger1.child", notChild 533 .getName()); 534 assertSame(child.getParent().getParent(), root); 535 assertNotSame(child.getParent(), root); 536 537 // abnormal cases 538 assertNotSame(root.getParent(), root); 539 Logger twoDot = Logger.getLogger(".."); 540 assertSame(twoDot.getParent(), root); 541 542 } 543 544 545 /* 546 * Test getLogger(String, String), getting a logger with no parent. 547 */ 548 @TestTargetNew( 549 level = TestLevel.PARTIAL_COMPLETE, 550 notes = "Verifies getLogger(String, String), getting a logger with no parent.", 551 method = "getLogger", 552 args = {java.lang.String.class, java.lang.String.class} 553 ) 554 public void testGetLoggerWithRes_Normal() throws Exception { 555 // config the level 556 Properties p = new Properties(); 557 p.put("testGetLoggerWithRes_Normal_ANewLogger.level", "ALL"); 558 LogManager.getLogManager().readConfiguration( 559 EnvironmentHelper.PropertiesToInputStream(p)); 560 561 assertNull(LogManager.getLogManager().getLogger( 562 "testGetLoggerWithRes_Normal_ANewLogger")); 563 // create a new logger 564 Logger log = Logger.getLogger("testGetLoggerWithRes_Normal_ANewLogger", 565 VALID_RESOURCE_BUNDLE); 566 // get an existing logger 567 assertSame(log, Logger 568 .getLogger("testGetLoggerWithRes_Normal_ANewLogger")); 569 // check it has been registered 570 assertSame(log, LogManager.getLogManager().getLogger( 571 "testGetLoggerWithRes_Normal_ANewLogger")); 572 573 assertNull(log.getFilter()); 574 assertEquals(0, log.getHandlers().length); 575 // check it's set to the preconfigured level 576 assertSame(Level.ALL, log.getLevel()); 577 assertEquals("testGetLoggerWithRes_Normal_ANewLogger", log.getName()); 578 assertNull(log.getParent().getParent()); 579 assertEquals(VALID_VALUE, log.getResourceBundle().getString(VALID_KEY)); 580 assertEquals(log.getResourceBundleName(), VALID_RESOURCE_BUNDLE); 581 assertTrue(log.getUseParentHandlers()); 582 } 583 584 /* 585 * Test getLogger(String, String) with null parameters. 586 */ 587 @TestTargetNew( 588 level = TestLevel.PARTIAL_COMPLETE, 589 notes = "Verifies getLogger(String, String) with null parameters.", 590 method = "getLogger", 591 args = {java.lang.String.class, java.lang.String.class} 592 ) 593 public void testGetLoggerWithRes_Null() { 594 Logger.getLogger("testGetLoggerWithRes_Null_ANewLogger", null); 595 try { 596 Logger.getLogger(null, VALID_RESOURCE_BUNDLE); 597 fail("Should throw NullPointerException!"); 598 } catch (NullPointerException e) { 599 } 600 } 601 602 603 /* 604 * Test getLogger(String, String) with invalid resource bundle. 605 */ 606 @TestTargetNew( 607 level = TestLevel.PARTIAL_COMPLETE, 608 notes = "Verifies getLogger(String, String) with invalid resource bundle.", 609 method = "getLogger", 610 args = {java.lang.String.class, java.lang.String.class} 611 ) 612 public void testGetLoggerWithRes_InvalidResourceBundle() { 613 614 assertNull(LogManager.getLogManager().getLogger( 615 "testMissingResourceException")); 616 617 try { 618 Logger.getLogger("testMissingResourceException", 619 INVALID_RESOURCE_BUNDLE); 620 fail("Should throw MissingResourceException!"); 621 } catch (MissingResourceException e) { 622 // correct 623 } 624 assertNull(Logger.getLogger("testMissingResourceException") 625 .getResourceBundle()); 626 assertNull(Logger.getLogger("testMissingResourceException") 627 .getResourceBundleName()); 628 // try empty string 629 try { 630 Logger.getLogger("testMissingResourceException", ""); 631 fail("Should throw MissingResourceException!"); 632 } catch (MissingResourceException e) { 633 // correct 634 } 635 636 assertNotNull(LogManager.getLogManager().getLogger("")); 637 // The root logger always exists TODO 638 try { 639 Logger.getLogger("", INVALID_RESOURCE_BUNDLE); 640 } catch (MissingResourceException e) { 641 //correct 642 } 643 } 644 645 /* 646 * Test getLogger(String, String) with valid resource bundle, to get an 647 * existing logger with no associated resource bundle. 648 */ 649 @TestTargetNew( 650 level = TestLevel.PARTIAL_COMPLETE, 651 notes = "Verifies getLogger(String, String) with valid resource bundle, to get an existing logger with no associated resource bundle.", 652 method = "getLogger", 653 args = {java.lang.String.class, java.lang.String.class} 654 ) 655 public void testGetLoggerWithRes_ExistingLoggerWithNoRes() { 656 assertNull(LogManager.getLogManager().getLogger( 657 "testGetLoggerWithRes_ExistingLoggerWithNoRes_ANewLogger")); 658 // create a new logger 659 Logger log1 = Logger 660 .getLogger("testGetLoggerWithRes_ExistingLoggerWithNoRes_ANewLogger"); 661 // get an existing logger 662 Logger log2 = Logger.getLogger( 663 "testGetLoggerWithRes_ExistingLoggerWithNoRes_ANewLogger", 664 VALID_RESOURCE_BUNDLE); 665 assertSame(log1, log2); 666 assertEquals(VALID_VALUE, log1.getResourceBundle().getString(VALID_KEY)); 667 assertEquals(log1.getResourceBundleName(), VALID_RESOURCE_BUNDLE); 668 669 } 670 671 /* 672 * Test getLogger(String, String) with valid resource bundle, to get an 673 * existing logger with the same associated resource bundle. 674 */ 675 @TestTargetNew( 676 level = TestLevel.PARTIAL_COMPLETE, 677 notes = "Verifies getLogger(String, String) with valid resource bundle, to get an existing logger with the same associated resource bundle.", 678 method = "getLogger", 679 args = {java.lang.String.class, java.lang.String.class} 680 ) 681 public void testGetLoggerWithRes_ExistingLoggerWithSameRes() { 682 assertNull(LogManager.getLogManager().getLogger( 683 "testGetLoggerWithRes_ExistingLoggerWithSameRes_ANewLogger")); 684 // create a new logger 685 Logger log1 = Logger.getLogger( 686 "testGetLoggerWithRes_ExistingLoggerWithSameRes_ANewLogger", 687 VALID_RESOURCE_BUNDLE); 688 // get an existing logger 689 Logger log2 = Logger.getLogger( 690 "testGetLoggerWithRes_ExistingLoggerWithSameRes_ANewLogger", 691 VALID_RESOURCE_BUNDLE); 692 assertSame(log1, log2); 693 assertEquals(VALID_VALUE, log1.getResourceBundle().getString(VALID_KEY)); 694 assertEquals(log1.getResourceBundleName(), VALID_RESOURCE_BUNDLE); 695 } 696 697 /* 698 * Test getLogger(String, String) with valid resource bundle, to get an 699 * existing logger with different associated resource bundle. 700 */ 701 @TestTargetNew( 702 level = TestLevel.PARTIAL_COMPLETE, 703 notes = "Verifies getLogger(String, String) with valid resource bundle, to get an existing logger with different associated resource bundle.", 704 method = "getLogger", 705 args = {java.lang.String.class, java.lang.String.class} 706 ) 707 public void testGetLoggerWithRes_ExistingLoggerWithDiffRes() { 708 assertNull(LogManager.getLogManager().getLogger( 709 "testGetLoggerWithRes_ExistingLoggerWithDiffRes_ANewLogger")); 710 // create a new logger 711 Logger log1 = Logger.getLogger( 712 "testGetLoggerWithRes_ExistingLoggerWithDiffRes_ANewLogger", 713 VALID_RESOURCE_BUNDLE); 714 assertNotNull(log1); 715 // get an existing logger 716 try { 717 Logger 718 .getLogger( 719 "testGetLoggerWithRes_ExistingLoggerWithDiffRes_ANewLogger", 720 VALID_RESOURCE_BUNDLE2); 721 fail("Should throw IllegalArgumentException!"); 722 } catch (IllegalArgumentException e) { 723 } 724 725 try { 726 Logger 727 .getLogger( 728 "testGetLoggerWithRes_ExistingLoggerWithDiffRes_ANewLogger", 729 null); 730 fail("Should throw IllegalArgumentException!"); 731 } catch (IllegalArgumentException e) { 732 } 733 } 734 735 /* 736 * Test getLogger(String, String) with invalid name. 737 */ 738 @TestTargetNew( 739 level = TestLevel.PARTIAL_COMPLETE, 740 notes = "Verifies getLogger(String, String) with invalid name.", 741 method = "getLogger", 742 args = {java.lang.String.class, java.lang.String.class} 743 ) 744 public void testGetLoggerWithRes_InvalidName() { 745 Logger log = Logger.getLogger( 746 "...#$%%^&&()-_+=!@~./,[]{};:'\\\"?|WithRes", 747 VALID_RESOURCE_BUNDLE); 748 assertEquals("...#$%%^&&()-_+=!@~./,[]{};:'\\\"?|WithRes", log 749 .getName()); 750 } 751 752 /* 753 * Test getLogger(String, String) with empty name. 754 */ 755 @TestTargetNew( 756 level = TestLevel.PARTIAL_COMPLETE, 757 notes = "Verifies getLogger(String, String) with empty name.", 758 method = "getLogger", 759 args = {java.lang.String.class, java.lang.String.class} 760 ) 761 @SideEffect("Attaches ResourceBundle to anonymous logger; irreversible") 762 public void testGetLoggerWithRes_Empty() { 763 Logger log = Logger.getLogger("", VALID_RESOURCE_BUNDLE); 764 assertSame(log, LogManager.getLogManager().getLogger("")); 765 assertNull(log.getFilter()); 766 assertEquals(0, log.getHandlers().length); 767 // check it's set to the preconfigured level 768 assertSame(Level.INFO, log.getLevel()); 769 assertEquals("", log.getName()); 770 assertNull(log.getParent()); 771 assertEquals(VALID_VALUE, log.getResourceBundle().getString(VALID_KEY)); 772 assertEquals(log.getResourceBundleName(), VALID_RESOURCE_BUNDLE); 773 assertTrue(log.getUseParentHandlers()); 774 } 775 776 /* 777 * Test getLogger(String, String), getting a logger with existing parent. 778 */ 779 @TestTargetNew( 780 level = TestLevel.PARTIAL_COMPLETE, 781 notes = "Verifies getLogger(String, String), getting a logger with existing parent.", 782 method = "getLogger", 783 args = {java.lang.String.class, java.lang.String.class} 784 ) 785 public void testGetLoggerWithRes_WithParentNormal() { 786 assertNull(LogManager.getLogManager().getLogger( 787 "testGetLoggerWithRes_WithParent_ParentLogger")); 788 // create the parent logger 789 Logger pLog = Logger 790 .getLogger("testGetLoggerWithRes_WithParent_ParentLogger"); 791 pLog.setLevel(Level.CONFIG); 792 pLog.addHandler(new MockHandler()); 793 pLog.setFilter(new MockFilter()); 794 pLog.setUseParentHandlers(false); 795 796 assertNull(LogManager.getLogManager().getLogger( 797 "testGetLoggerWithRes_WithParent_ParentLogger.child")); 798 // create the child logger 799 Logger log = Logger.getLogger( 800 "testGetLoggerWithRes_WithParent_ParentLogger.child", 801 VALID_RESOURCE_BUNDLE); 802 assertNull(log.getFilter()); 803 assertEquals(0, log.getHandlers().length); 804 assertNull(log.getLevel()); 805 assertEquals("testGetLoggerWithRes_WithParent_ParentLogger.child", log 806 .getName()); 807 assertSame(log.getParent(), pLog); 808 assertEquals(VALID_VALUE, log.getResourceBundle().getString(VALID_KEY)); 809 assertEquals(log.getResourceBundleName(), VALID_RESOURCE_BUNDLE); 810 assertTrue(log.getUseParentHandlers()); 811 } 812 813 /* 814 * Test addHandler(Handler) for a named logger with sufficient privilege. 815 */ 816 @TestTargetNew( 817 level = TestLevel.PARTIAL_COMPLETE, 818 notes = "", 819 method = "addHandler", 820 args = {java.util.logging.Handler.class} 821 ) 822 public void testAddHandler_NamedLoggerSufficientPrivilege() { 823 Logger log = Logger 824 .getLogger("testAddHandler_NamedLoggerSufficientPrivilege"); 825 MockHandler h = new MockHandler(); 826 assertEquals(log.getHandlers().length, 0); 827 log.addHandler(h); 828 assertEquals(log.getHandlers().length, 1); 829 830 } 831 832 /* 833 * Test addHandler(Handler) for a named logger with sufficient privilege, 834 * add duplicate handlers. 835 */ 836 @TestTargetNew( 837 level = TestLevel.PARTIAL_COMPLETE, 838 notes = "", 839 method = "addHandler", 840 args = {java.util.logging.Handler.class} 841 ) 842 public void testAddHandler_NamedLoggerSufficientPrivilegeDuplicate() { 843 Logger log = Logger 844 .getLogger("testAddHandler_NamedLoggerSufficientPrivilegeDuplicate"); 845 MockHandler h = new MockHandler(); 846 assertEquals(log.getHandlers().length, 0); 847 for (int i = 0; i < 12; i++) { 848 log.addHandler(h); 849 } 850 assertEquals(log.getHandlers().length, 12); 851 assertSame(log.getHandlers()[0], h); 852 assertSame(log.getHandlers()[5], h); 853 assertSame(log.getHandlers()[11], h); 854 } 855 856 /* 857 * Test addHandler(Handler) with a null handler. 858 */ 859 @TestTargetNew( 860 level = TestLevel.PARTIAL_COMPLETE, 861 notes = "Verifies NullPointerException.", 862 method = "addHandler", 863 args = {java.util.logging.Handler.class} 864 ) 865 public void testAddHandler_Null() { 866 Logger log = Logger.getLogger("testAddHandler_Null"); 867 try { 868 log.addHandler(null); 869 fail("Should throw NullPointerException!"); 870 } catch (NullPointerException e) { 871 } 872 assertEquals(log.getHandlers().length, 0); 873 } 874 875 /* 876 * Test addHandler(Handler) for a named logger with insufficient privilege. 877 */ 878 @TestTargetNew( 879 level = TestLevel.PARTIAL_COMPLETE, 880 notes = "", 881 method = "addHandler", 882 args = {java.util.logging.Handler.class} 883 ) 884 public void testAddHandler_NamedLoggerInsufficientPrivilege() { 885 Logger log = Logger 886 .getLogger("testAddHandler_NamedLoggerInsufficientPrivilege"); 887 MockHandler h = new MockHandler(); 888 SecurityManager oldMan = System.getSecurityManager(); 889 System.setSecurityManager(new MockSecurityManager()); 890 891 try { 892 log.addHandler(h); 893 fail("Should throw SecurityException!"); 894 } catch (SecurityException e) { 895 } finally { 896 System.setSecurityManager(oldMan); 897 } 898 } 899 900 /* 901 * Test addHandler(Handler) for a named logger with insufficient privilege, 902 * using a null handler. 903 */ 904 @TestTargetNew( 905 level = TestLevel.PARTIAL_COMPLETE, 906 notes = "", 907 method = "addHandler", 908 args = {java.util.logging.Handler.class} 909 ) 910 public void testAddHandler_NamedLoggerInsufficientPrivilegeNull() { 911 Logger log = Logger 912 .getLogger("testAddHandler_NamedLoggerInsufficientPrivilege"); 913 SecurityManager oldMan = System.getSecurityManager(); 914 System.setSecurityManager(new MockSecurityManager()); 915 916 try { 917 log.addHandler(null); 918 fail("Should throw NullPointerException!"); 919 } catch (NullPointerException e) { 920 } finally { 921 System.setSecurityManager(oldMan); 922 } 923 } 924 925 /* 926 * Test addHandler(Handler) for an anonymous logger with sufficient 927 * privilege. 928 */ 929 @TestTargetNew( 930 level = TestLevel.PARTIAL_COMPLETE, 931 notes = "", 932 method = "addHandler", 933 args = {java.util.logging.Handler.class} 934 ) 935 public void testAddHandler_AnonyLoggerSufficientPrivilege() { 936 Logger log = Logger.getAnonymousLogger(); 937 MockHandler h = new MockHandler(); 938 assertEquals(log.getHandlers().length, 0); 939 log.addHandler(h); 940 assertEquals(log.getHandlers().length, 1); 941 assertSame(log.getHandlers()[0], h); 942 } 943 944 /* 945 * Test addHandler(Handler) for an anonymous logger with insufficient 946 * privilege. 947 */ 948 @TestTargetNew( 949 level = TestLevel.PARTIAL_COMPLETE, 950 notes = "", 951 method = "addHandler", 952 args = {java.util.logging.Handler.class} 953 ) 954 public void testAddHandler_AnonyLoggerInsufficientPrivilege() { 955 Logger log = Logger.getAnonymousLogger(); 956 MockHandler h = new MockHandler(); 957 SecurityManager oldMan = System.getSecurityManager(); 958 System.setSecurityManager(new MockSecurityManager()); 959 try { 960 assertEquals(log.getHandlers().length, 0); 961 log.addHandler(h); 962 assertEquals(log.getHandlers().length, 1); 963 assertSame(log.getHandlers()[0], h); 964 } finally { 965 System.setSecurityManager(oldMan); 966 } 967 } 968 969 /* 970 * Test addHandler(Handler) for a null-named mock logger with insufficient 971 * privilege. 972 */ 973 @TestTargetNew( 974 level = TestLevel.PARTIAL_COMPLETE, 975 notes = "Verifies addHandler(Handler) for a null-named mock logger with insufficient privilege, SecurityException.", 976 method = "addHandler", 977 args = {java.util.logging.Handler.class} 978 ) 979 public void testAddHandler_NullNamedMockLoggerInsufficientPrivilege() { 980 MockLogger mlog = new MockLogger(null, null); 981 MockHandler h = new MockHandler(); 982 SecurityManager oldMan = System.getSecurityManager(); 983 System.setSecurityManager(new MockSecurityManager()); 984 try { 985 mlog.addHandler(h); 986 fail("Should throw SecurityException!"); 987 } catch (SecurityException e) { 988 } finally { 989 System.setSecurityManager(oldMan); 990 } 991 } 992 993 /* 994 * Test removeHandler(Handler) for a named logger with sufficient privilege, 995 * remove an existing handler. 996 */ 997 @TestTargetNew( 998 level = TestLevel.COMPLETE, 999 notes = "", 1000 method = "addHandler", 1001 args = {java.util.logging.Handler.class} 1002 ) 1003 public void testRemoveHandler_NamedLoggerSufficientPrivilege() { 1004 Logger log = Logger 1005 .getLogger("testRemoveHandler_NamedLoggerSufficientPrivilege"); 1006 MockHandler h = new MockHandler(); 1007 log.addHandler(h); 1008 assertEquals(log.getHandlers().length, 1); 1009 log.removeHandler(h); 1010 assertEquals(log.getHandlers().length, 0); 1011 } 1012 1013 /* 1014 * Test removeHandler(Handler) for a named logger with sufficient privilege, 1015 * remove a non-existing handler. 1016 */ 1017 @TestTargetNew( 1018 level = TestLevel.COMPLETE, 1019 notes = "", 1020 method = "removeHandler", 1021 args = {java.util.logging.Handler.class} 1022 ) 1023 public void testRemoveHandler_NamedLoggerSufficientPrivilegeNotExisting() { 1024 Logger log = Logger 1025 .getLogger("testRemoveHandler_NamedLoggerSufficientPrivilegeNotExisting"); 1026 MockHandler h = new MockHandler(); 1027 assertEquals(log.getHandlers().length, 0); 1028 log.removeHandler(h); 1029 assertEquals(log.getHandlers().length, 0); 1030 } 1031 1032 /* 1033 * Test removeHandler(Handler) with a null handler. 1034 */ 1035 @TestTargetNew( 1036 level = TestLevel.COMPLETE, 1037 notes = "", 1038 method = "removeHandler", 1039 args = {java.util.logging.Handler.class} 1040 ) 1041 public void testRemoveHandler_Null() { 1042 Logger log = Logger.getLogger("testRemoveHandler_Null"); 1043 log.removeHandler(null); 1044 assertEquals(log.getHandlers().length, 0); 1045 } 1046 1047 /* 1048 * Test removeHandler(Handler) for a named logger with insufficient 1049 * privilege. 1050 */ 1051 @TestTargetNew( 1052 level = TestLevel.COMPLETE, 1053 notes = "", 1054 method = "removeHandler", 1055 args = {java.util.logging.Handler.class} 1056 ) 1057 public void testRemoveHandler_NamedLoggerInsufficientPrivilege() { 1058 Logger log = Logger 1059 .getLogger("testRemoveHandler_NamedLoggerInsufficientPrivilege"); 1060 MockHandler h = new MockHandler(); 1061 SecurityManager oldMan = System.getSecurityManager(); 1062 System.setSecurityManager(new MockSecurityManager()); 1063 1064 try { 1065 log.removeHandler(h); 1066 fail("Should throw SecurityException!"); 1067 } catch (SecurityException e) { 1068 } finally { 1069 System.setSecurityManager(oldMan); 1070 } 1071 } 1072 1073 /* 1074 * Test removeHandler(Handler) for a named logger with insufficient 1075 * privilege, using a null handler. 1076 */ 1077 @TestTargetNew( 1078 level = TestLevel.COMPLETE, 1079 notes = "", 1080 method = "removeHandler", 1081 args = {java.util.logging.Handler.class} 1082 ) 1083 public void testRemoveHandler_NamedLoggerInsufficientPrivilegeNull() { 1084 Logger log = Logger 1085 .getLogger("testRemoveHandler_NamedLoggerInsufficientPrivilege"); 1086 SecurityManager oldMan = System.getSecurityManager(); 1087 System.setSecurityManager(new MockSecurityManager()); 1088 1089 try { 1090 log.removeHandler(null); 1091 fail("Should throw SecurityException!"); 1092 } catch (SecurityException e) { 1093 } finally { 1094 System.setSecurityManager(oldMan); 1095 } 1096 } 1097 1098 /* 1099 * Test removeHandler(Handler) for an anonymous logger with sufficient 1100 * privilege. 1101 */ 1102 @TestTargetNew( 1103 level = TestLevel.COMPLETE, 1104 notes = "", 1105 method = "removeHandler", 1106 args = {java.util.logging.Handler.class} 1107 ) 1108 public void testRemoveHandler_AnonyLoggerSufficientPrivilege() { 1109 Logger log = Logger.getAnonymousLogger(); 1110 MockHandler h = new MockHandler(); 1111 log.addHandler(h); 1112 assertEquals(log.getHandlers().length, 1); 1113 log.removeHandler(h); 1114 assertEquals(log.getHandlers().length, 0); 1115 } 1116 1117 /* 1118 * Test removeHandler(Handler) for an anonymous logger with insufficient 1119 * privilege. 1120 */ 1121 @TestTargetNew( 1122 level = TestLevel.COMPLETE, 1123 notes = "", 1124 method = "removeHandler", 1125 args = {java.util.logging.Handler.class} 1126 ) 1127 public void testRemoveHandler_AnonyLoggerInsufficientPrivilege() { 1128 Logger log = Logger.getAnonymousLogger(); 1129 MockHandler h = new MockHandler(); 1130 SecurityManager oldMan = System.getSecurityManager(); 1131 System.setSecurityManager(new MockSecurityManager()); 1132 try { 1133 log.addHandler(h); 1134 assertEquals(log.getHandlers().length, 1); 1135 log.removeHandler(h); 1136 assertEquals(log.getHandlers().length, 0); 1137 } finally { 1138 System.setSecurityManager(oldMan); 1139 } 1140 } 1141 1142 /* 1143 * Test removeHandler(Handler) for a null-named mock logger with 1144 * insufficient privilege. 1145 */ 1146 @TestTargetNew( 1147 level = TestLevel.COMPLETE, 1148 notes = "", 1149 method = "removeHandler", 1150 args = {java.util.logging.Handler.class} 1151 ) 1152 public void testRemoveHandler_NullNamedMockLoggerInsufficientPrivilege() { 1153 MockLogger mlog = new MockLogger(null, null); 1154 MockHandler h = new MockHandler(); 1155 SecurityManager oldMan = System.getSecurityManager(); 1156 System.setSecurityManager(new MockSecurityManager()); 1157 try { 1158 mlog.removeHandler(h); 1159 fail("Should throw SecurityException!"); 1160 } catch (SecurityException e) { 1161 } finally { 1162 System.setSecurityManager(oldMan); 1163 } 1164 } 1165 1166 /* 1167 * Test getHandlers() when there's no handler. 1168 */ 1169 @TestTargetNew( 1170 level = TestLevel.PARTIAL_COMPLETE, 1171 notes = "Verifies getHandlers() when there's no handler.", 1172 method = "getHandlers", 1173 args = {} 1174 ) 1175 public void testGetHandlers_None() { 1176 Logger log = Logger.getLogger("testGetHandlers_None"); 1177 assertEquals(log.getHandlers().length, 0); 1178 } 1179 1180 /* 1181 * Test getHandlers() when there are several handlers. 1182 */ 1183 @TestTargetNew( 1184 level = TestLevel.PARTIAL_COMPLETE, 1185 notes = "Verifies getHandlers() when there are several handlers.", 1186 method = "getHandlers", 1187 args = {} 1188 ) 1189 public void testGetHandlers_Several() { 1190 Logger log = Logger.getLogger("testGetHandlers_None"); 1191 assertEquals(log.getHandlers().length, 0); 1192 MockHandler h1 = new MockHandler(); 1193 MockHandler h2 = new MockHandler(); 1194 MockHandler h3 = new MockHandler(); 1195 log.addHandler(h1); 1196 log.addHandler(h2); 1197 log.addHandler(h3); 1198 assertEquals(log.getHandlers().length, 3); 1199 assertSame(log.getHandlers()[0], h1); 1200 assertSame(log.getHandlers()[1], h2); 1201 assertSame(log.getHandlers()[2], h3); 1202 // remove one 1203 log.removeHandler(h2); 1204 assertEquals(log.getHandlers().length, 2); 1205 assertSame(log.getHandlers()[0], h1); 1206 assertSame(log.getHandlers()[1], h3); 1207 1208 } 1209 1210 /* 1211 * Test getFilter & setFilter with normal value for a named logger, having 1212 * sufficient privilege. 1213 */ 1214 @TestTargets({ 1215 @TestTargetNew( 1216 level = TestLevel.PARTIAL, 1217 notes = "Verifies getFilter & setFilter with normal value for a named logger, having sufficient privilege.", 1218 method = "getFilter", 1219 args = {} 1220 ), 1221 @TestTargetNew( 1222 level = TestLevel.PARTIAL, 1223 notes = "Verifies getFilter & setFilter with normal value for a named logger, having sufficient privilege.", 1224 method = "setFilter", 1225 args = {java.util.logging.Filter.class} 1226 ) 1227 }) 1228 public void testGetSetFilter_NamedLoggerSufficientPrivilege() { 1229 Logger log = Logger 1230 .getLogger("testGetSetFilter_NamedLoggerSufficientPrivilege"); 1231 Filter f = new MockFilter(); 1232 1233 assertNull(log.getFilter()); 1234 log.setFilter(f); 1235 assertSame(f, log.getFilter()); 1236 } 1237 1238 /* 1239 * Test getFilter & setFilter with null value, having sufficient privilege. 1240 */ 1241 @TestTargets({ 1242 @TestTargetNew( 1243 level = TestLevel.PARTIAL, 1244 notes = "Verifies getFilter & setFilter with null value, having sufficient privilege.", 1245 method = "getFilter", 1246 args = {} 1247 ), 1248 @TestTargetNew( 1249 level = TestLevel.PARTIAL, 1250 notes = "Verifies getFilter & setFilter with null value, having sufficient privilege.", 1251 method = "setFilter", 1252 args = {java.util.logging.Filter.class} 1253 ) 1254 }) 1255 public void testGetSetFilter_Null() { 1256 Logger log = Logger.getLogger("testGetSetFilter_Null"); 1257 1258 assertNull(log.getFilter()); 1259 log.setFilter(null); 1260 assertNull(log.getFilter()); 1261 log.setFilter(new MockFilter()); 1262 log.setFilter(null); 1263 assertNull(log.getFilter()); 1264 } 1265 1266 /* 1267 * Test setFilter with normal value for a named logger, having insufficient 1268 * privilege. 1269 */ 1270 @TestTargets({ 1271 @TestTargetNew( 1272 level = TestLevel.PARTIAL, 1273 notes = "Verifies setFilter with normal value for a named logger, having insufficient privilege.", 1274 method = "getFilter", 1275 args = {} 1276 ), 1277 @TestTargetNew( 1278 level = TestLevel.PARTIAL, 1279 notes = "Verifies setFilter with normal value for a named logger, having insufficient privilege.", 1280 method = "setFilter", 1281 args = {java.util.logging.Filter.class} 1282 ) 1283 }) 1284 public void testGetSetFilter_NamedLoggerInsufficientPrivilege() { 1285 Logger log = Logger 1286 .getLogger("testGetSetFilter_NamedLoggerInsufficientPrivilege"); 1287 Filter f = new MockFilter(); 1288 SecurityManager oldMan = System.getSecurityManager(); 1289 System.setSecurityManager(new MockSecurityManager()); 1290 try { 1291 log.setFilter(f); 1292 fail("Should throw SecurityException!"); 1293 } catch (SecurityException e) { 1294 } finally { 1295 System.setSecurityManager(oldMan); 1296 } 1297 } 1298 1299 /* 1300 * Test setFilter for an anonymous logger with sufficient privilege. 1301 */ 1302 @TestTargets({ 1303 @TestTargetNew( 1304 level = TestLevel.COMPLETE, 1305 notes = "", 1306 method = "getFilter", 1307 args = {} 1308 ), 1309 @TestTargetNew( 1310 level = TestLevel.COMPLETE, 1311 notes = "", 1312 method = "setFilter", 1313 args = {java.util.logging.Filter.class} 1314 ) 1315 }) 1316 public void testSetFilter_AnonyLoggerSufficientPrivilege() { 1317 Logger log = Logger.getAnonymousLogger(); 1318 Filter f = new MockFilter(); 1319 assertNull(log.getFilter()); 1320 log.setFilter(f); 1321 assertSame(f, log.getFilter()); 1322 } 1323 1324 /* 1325 * Test setFilter for an anonymous logger with insufficient privilege. 1326 */ 1327 @TestTargets({ 1328 @TestTargetNew( 1329 level = TestLevel.COMPLETE, 1330 notes = "", 1331 method = "getFilter", 1332 args = {} 1333 ), 1334 @TestTargetNew( 1335 level = TestLevel.COMPLETE, 1336 notes = "", 1337 method = "setFilter", 1338 args = {java.util.logging.Filter.class} 1339 ) 1340 }) 1341 public void testSetFilter_AnonyLoggerInsufficientPrivilege() { 1342 Logger log = Logger.getAnonymousLogger(); 1343 Filter f = new MockFilter(); 1344 SecurityManager oldMan = System.getSecurityManager(); 1345 System.setSecurityManager(new MockSecurityManager()); 1346 try { 1347 assertNull(log.getFilter()); 1348 log.setFilter(f); 1349 assertSame(f, log.getFilter()); 1350 } finally { 1351 System.setSecurityManager(oldMan); 1352 } 1353 } 1354 1355 /* 1356 * Test setFilter for a null-named mock logger with insufficient privilege. 1357 */ 1358 @TestTargets({ 1359 @TestTargetNew( 1360 level = TestLevel.COMPLETE, 1361 notes = "", 1362 method = "getFilter", 1363 args = {} 1364 ), 1365 @TestTargetNew( 1366 level = TestLevel.COMPLETE, 1367 notes = "", 1368 method = "setFilter", 1369 args = {java.util.logging.Filter.class} 1370 ) 1371 }) 1372 public void testSetFilter_NullNamedMockLoggerInsufficientPrivilege() { 1373 MockLogger mlog = new MockLogger(null, null); 1374 Filter f = new MockFilter(); 1375 SecurityManager oldMan = System.getSecurityManager(); 1376 System.setSecurityManager(new MockSecurityManager()); 1377 try { 1378 mlog.setFilter(f); 1379 fail("Should throw SecurityException!"); 1380 } catch (SecurityException e) { 1381 } finally { 1382 System.setSecurityManager(oldMan); 1383 } 1384 } 1385 1386 /* 1387 * Test getLevel & setLevel with normal value for a named logger, having 1388 * sufficient privilege. 1389 */ 1390 @TestTargets({ 1391 @TestTargetNew( 1392 level = TestLevel.PARTIAL, 1393 notes = "Verifies getLevel & setLevel with normal value for a named logger, having sufficient privilege.", 1394 method = "setLevel", 1395 args = {java.util.logging.Level.class} 1396 ), 1397 @TestTargetNew( 1398 level = TestLevel.PARTIAL, 1399 notes = "Verifies getLevel & setLevel with normal value for a named logger, having sufficient privilege.", 1400 method = "getLevel", 1401 args = {} 1402 ) 1403 }) 1404 public void testGetSetLevel_NamedLoggerSufficientPrivilege() { 1405 Logger log = Logger 1406 .getLogger("testGetSetLevel_NamedLoggerSufficientPrivilege"); 1407 1408 assertNull(log.getLevel()); 1409 log.setLevel(Level.CONFIG); 1410 assertSame(Level.CONFIG, log.getLevel()); 1411 } 1412 1413 /* 1414 * Test getLevel & setLevel with null value, having sufficient privilege. 1415 */ 1416 @TestTargets({ 1417 @TestTargetNew( 1418 level = TestLevel.PARTIAL, 1419 notes = "Verifies getLevel & setLevel with null value, having sufficient privilege.", 1420 method = "getLevel", 1421 args = {} 1422 ), 1423 @TestTargetNew( 1424 level = TestLevel.PARTIAL, 1425 notes = "Verifies getLevel & setLevel with null value, having sufficient privilege.", 1426 method = "setLevel", 1427 args = {java.util.logging.Level.class} 1428 ) 1429 }) 1430 public void testGetSetLevel_Null() { 1431 Logger log = Logger.getLogger("testGetSetLevel_Null"); 1432 1433 assertNull(log.getLevel()); 1434 log.setLevel(null); 1435 assertNull(log.getLevel()); 1436 log.setLevel(Level.CONFIG); 1437 log.setLevel(null); 1438 assertNull(log.getLevel()); 1439 } 1440 1441 /* 1442 * Test setLevel with normal value for a named logger, having insufficient 1443 * privilege. 1444 */ 1445 @TestTargets({ 1446 @TestTargetNew( 1447 level = TestLevel.PARTIAL, 1448 notes = "Verifies setLevel with normal value for a named logger, having insufficient privilege.", 1449 method = "setLevel", 1450 args = {java.util.logging.Level.class} 1451 ), 1452 @TestTargetNew( 1453 level = TestLevel.PARTIAL, 1454 notes = "Verifies setLevel with normal value for a named logger, having insufficient privilege.", 1455 method = "getLevel", 1456 args = {} 1457 ) 1458 }) 1459 public void testGetSetLevel_NamedLoggerInsufficientPrivilege() { 1460 Logger log = Logger 1461 .getLogger("testGetSetLevel_NamedLoggerInsufficientPrivilege"); 1462 SecurityManager oldMan = System.getSecurityManager(); 1463 System.setSecurityManager(new MockSecurityManager()); 1464 try { 1465 log.setLevel(Level.CONFIG); 1466 fail("Should throw SecurityException!"); 1467 } catch (SecurityException e) { 1468 } finally { 1469 System.setSecurityManager(oldMan); 1470 } 1471 } 1472 1473 /* 1474 * Test setLevel for an anonymous logger with sufficient privilege. 1475 */ 1476 @TestTargets({ 1477 @TestTargetNew( 1478 level = TestLevel.COMPLETE, 1479 notes = "", 1480 method = "getLevel", 1481 args = {} 1482 ), 1483 @TestTargetNew( 1484 level = TestLevel.COMPLETE, 1485 notes = "", 1486 method = "setLevel", 1487 args = {java.util.logging.Level.class} 1488 ) 1489 }) 1490 public void testSetLevel_AnonyLoggerSufficientPrivilege() { 1491 Logger log = Logger.getAnonymousLogger(); 1492 assertNull(log.getLevel()); 1493 log.setLevel(Level.CONFIG); 1494 assertSame(Level.CONFIG, log.getLevel()); 1495 } 1496 1497 /* 1498 * Test setLevel for an anonymous logger with insufficient privilege. 1499 */ 1500 @TestTargets({ 1501 @TestTargetNew( 1502 level = TestLevel.COMPLETE, 1503 notes = "", 1504 method = "getLevel", 1505 args = {} 1506 ), 1507 @TestTargetNew( 1508 level = TestLevel.COMPLETE, 1509 notes = "", 1510 method = "setLevel", 1511 args = {java.util.logging.Level.class} 1512 ) 1513 }) 1514 public void testSetLevel_AnonyLoggerInsufficientPrivilege() { 1515 Logger log = Logger.getAnonymousLogger(); 1516 SecurityManager oldMan = System.getSecurityManager(); 1517 System.setSecurityManager(new MockSecurityManager()); 1518 try { 1519 assertNull(log.getLevel()); 1520 log.setLevel(Level.CONFIG); 1521 assertSame(Level.CONFIG, log.getLevel()); 1522 } finally { 1523 System.setSecurityManager(oldMan); 1524 } 1525 } 1526 1527 /* 1528 * Test setLevel for a null-named mock logger with insufficient privilege. 1529 */ 1530 @TestTargets({ 1531 @TestTargetNew( 1532 level = TestLevel.COMPLETE, 1533 notes = "", 1534 method = "getLevel", 1535 args = {} 1536 ), 1537 @TestTargetNew( 1538 level = TestLevel.COMPLETE, 1539 notes = "", 1540 method = "setLevel", 1541 args = {java.util.logging.Level.class} 1542 ) 1543 }) 1544 public void testSetLevel_NullNamedMockLoggerInsufficientPrivilege() { 1545 MockLogger mlog = new MockLogger(null, null); 1546 SecurityManager oldMan = System.getSecurityManager(); 1547 System.setSecurityManager(new MockSecurityManager()); 1548 try { 1549 mlog.setLevel(Level.CONFIG); 1550 fail("Should throw SecurityException!"); 1551 } catch (SecurityException e) { 1552 } finally { 1553 System.setSecurityManager(oldMan); 1554 } 1555 } 1556 1557 /* 1558 * Test getUseParentHandlers & setUseParentHandlers with normal value for a 1559 * named logger, having sufficient privilege. 1560 */ 1561 @TestTargets({ 1562 @TestTargetNew( 1563 level = TestLevel.COMPLETE, 1564 notes = "", 1565 method = "getUseParentHandlers", 1566 args = {} 1567 ), 1568 @TestTargetNew( 1569 level = TestLevel.COMPLETE, 1570 notes = "", 1571 method = "setUseParentHandlers", 1572 args = {boolean.class} 1573 ) 1574 }) 1575 public void testGetSetUseParentHandlers_NamedLoggerSufficientPrivilege() { 1576 Logger log = Logger 1577 .getLogger("testGetSetUseParentHandlers_NamedLoggerSufficientPrivilege"); 1578 1579 assertTrue(log.getUseParentHandlers()); 1580 log.setUseParentHandlers(false); 1581 assertFalse(log.getUseParentHandlers()); 1582 } 1583 1584 /* 1585 * Test setUseParentHandlers with normal value for a named logger, having 1586 * insufficient privilege. 1587 */ 1588 @TestTargets({ 1589 @TestTargetNew( 1590 level = TestLevel.COMPLETE, 1591 notes = "", 1592 method = "getUseParentHandlers", 1593 args = {} 1594 ), 1595 @TestTargetNew( 1596 level = TestLevel.COMPLETE, 1597 notes = "", 1598 method = "setUseParentHandlers", 1599 args = {boolean.class} 1600 ) 1601 }) 1602 public void testGetSetUseParentHandlers_NamedLoggerInsufficientPrivilege() { 1603 Logger log = Logger 1604 .getLogger("testGetSetUseParentHandlers_NamedLoggerInsufficientPrivilege"); 1605 SecurityManager oldMan = System.getSecurityManager(); 1606 System.setSecurityManager(new MockSecurityManager()); 1607 try { 1608 log.setUseParentHandlers(true); 1609 fail("Should throw SecurityException!"); 1610 } catch (SecurityException e) { 1611 } finally { 1612 System.setSecurityManager(oldMan); 1613 } 1614 } 1615 1616 /* 1617 * Test setUseParentHandlers for an anonymous logger with sufficient 1618 * privilege. 1619 */ 1620 @TestTargets({ 1621 @TestTargetNew( 1622 level = TestLevel.COMPLETE, 1623 notes = "", 1624 method = "getUseParentHandlers", 1625 args = {} 1626 ), 1627 @TestTargetNew( 1628 level = TestLevel.COMPLETE, 1629 notes = "", 1630 method = "setUseParentHandlers", 1631 args = {boolean.class} 1632 ) 1633 }) 1634 public void testSetUseParentHandlers_AnonyLoggerSufficientPrivilege() { 1635 Logger log = Logger.getAnonymousLogger(); 1636 assertTrue(log.getUseParentHandlers()); 1637 log.setUseParentHandlers(false); 1638 assertFalse(log.getUseParentHandlers()); 1639 } 1640 1641 /* 1642 * Test setUseParentHandlers for an anonymous logger with insufficient 1643 * privilege. 1644 */ 1645 @TestTargets({ 1646 @TestTargetNew( 1647 level = TestLevel.COMPLETE, 1648 notes = "", 1649 method = "getUseParentHandlers", 1650 args = {} 1651 ), 1652 @TestTargetNew( 1653 level = TestLevel.COMPLETE, 1654 notes = "", 1655 method = "setUseParentHandlers", 1656 args = {boolean.class} 1657 ) 1658 }) 1659 public void testSetUseParentHandlers_AnonyLoggerInsufficientPrivilege() { 1660 Logger log = Logger.getAnonymousLogger(); 1661 SecurityManager oldMan = System.getSecurityManager(); 1662 System.setSecurityManager(new MockSecurityManager()); 1663 try { 1664 assertTrue(log.getUseParentHandlers()); 1665 log.setUseParentHandlers(false); 1666 assertFalse(log.getUseParentHandlers()); 1667 } finally { 1668 System.setSecurityManager(oldMan); 1669 } 1670 } 1671 1672 /* 1673 * Test setUseParentHandlers for a null-named mock logger with insufficient 1674 * privilege. 1675 */ 1676 @TestTargets({ 1677 @TestTargetNew( 1678 level = TestLevel.COMPLETE, 1679 notes = "", 1680 method = "getUseParentHandlers", 1681 args = {} 1682 ), 1683 @TestTargetNew( 1684 level = TestLevel.COMPLETE, 1685 notes = "", 1686 method = "setUseParentHandlers", 1687 args = {boolean.class} 1688 ) 1689 }) 1690 public void testSetUseParentHandlers_NullNamedMockLoggerInsufficientPrivilege() { 1691 MockLogger mlog = new MockLogger(null, null); 1692 SecurityManager oldMan = System.getSecurityManager(); 1693 System.setSecurityManager(new MockSecurityManager()); 1694 try { 1695 mlog.setUseParentHandlers(true); 1696 fail("Should throw SecurityException!"); 1697 } catch (SecurityException e) { 1698 } finally { 1699 System.setSecurityManager(oldMan); 1700 } 1701 } 1702 1703 /* 1704 * Test getParent() for root logger. 1705 */ 1706 @TestTargetNew( 1707 level = TestLevel.PARTIAL_COMPLETE, 1708 notes = "Verifies getParent() for root logger.", 1709 method = "getParent", 1710 args = {} 1711 ) 1712 public void testGetParent_Root() { 1713 assertNull(Logger.getLogger("").getParent()); 1714 } 1715 1716 /* 1717 * Test getParent() for normal named loggers. 1718 */ 1719 @TestTargetNew( 1720 level = TestLevel.PARTIAL_COMPLETE, 1721 notes = "Verifies getParent() for normal named loggers.", 1722 method = "getParent", 1723 args = {} 1724 ) 1725 public void testGetParent_NormalNamed() { 1726 Logger log = Logger.getLogger("testGetParent_NormalNamed"); 1727 assertSame(log.getParent(), Logger.getLogger("")); 1728 Logger child = Logger.getLogger("testGetParent_NormalNamed.child"); 1729 assertSame(child.getParent(), log); 1730 Logger child2 = Logger.getLogger("testGetParent_NormalNamed.a.b.c"); 1731 assertSame(child2.getParent(), log); 1732 } 1733 1734 /* 1735 * Test getParent() for anonymous loggers. 1736 */ 1737 @TestTargetNew( 1738 level = TestLevel.PARTIAL_COMPLETE, 1739 notes = "Verifies getParent() for anonymous loggers.", 1740 method = "getParent", 1741 args = {} 1742 ) 1743 public void testGetParent_Anonymous() { 1744 assertSame(Logger.getAnonymousLogger().getParent(), Logger 1745 .getLogger("")); 1746 } 1747 1748 /* 1749 * Test setParent(Logger) for the mock logger since it is advised not to 1750 * call this method on named loggers. Test normal conditions. 1751 */ 1752 @TestTargetNew( 1753 level = TestLevel.COMPLETE, 1754 notes = "", 1755 method = "setParent", 1756 args = {java.util.logging.Logger.class} 1757 ) 1758 public void testSetParent_Normal() { 1759 Logger log = new MockLogger(null, null); 1760 Logger parent = new MockLogger(null, null); 1761 assertNull(log.getParent()); 1762 log.setParent(parent); 1763 assertSame(log.getParent(), parent); 1764 } 1765 1766 /* 1767 * Test setParent(Logger) with null. 1768 */ 1769 @TestTargetNew( 1770 level = TestLevel.COMPLETE, 1771 notes = "", 1772 method = "setParent", 1773 args = {java.util.logging.Logger.class} 1774 ) 1775 public void testSetParent_Null() { 1776 try { 1777 (new MockLogger(null, null)).setParent(null); 1778 fail("Should throw NullPointerException!"); 1779 } catch (NullPointerException e) { 1780 } 1781 } 1782 1783 /* 1784 * Test setParent(Logger), having insufficient privilege. 1785 */ 1786 @TestTargetNew( 1787 level = TestLevel.COMPLETE, 1788 notes = "", 1789 method = "setParent", 1790 args = {java.util.logging.Logger.class} 1791 ) 1792 public void testSetParent_InsufficientPrivilege() { 1793 MockLogger log = new MockLogger(null, null); 1794 SecurityManager oldMan = System.getSecurityManager(); 1795 System.setSecurityManager(new MockSecurityManager()); 1796 try { 1797 log.setParent(log); 1798 fail("Should throw SecurityException!"); 1799 } catch (SecurityException e) { 1800 } finally { 1801 System.setSecurityManager(oldMan); 1802 } 1803 } 1804 1805 /* 1806 * Test setParent(Logger) with null, having insufficient privilege. 1807 */ 1808 @TestTargetNew( 1809 level = TestLevel.COMPLETE, 1810 notes = "", 1811 method = "setParent", 1812 args = {java.util.logging.Logger.class} 1813 ) 1814 public void testSetParent_InsufficientPrivilegeNull() { 1815 MockLogger log = new MockLogger(null, null); 1816 SecurityManager oldMan = System.getSecurityManager(); 1817 System.setSecurityManager(new MockSecurityManager()); 1818 try { 1819 log.setParent(null); 1820 fail("Should throw NullPointerException!"); 1821 } catch (NullPointerException e) { 1822 } finally { 1823 System.setSecurityManager(oldMan); 1824 } 1825 } 1826 1827 /* 1828 * Test setParent(Logger) for an anonymous logger with insufficient 1829 * privilege. 1830 */ 1831 @TestTargetNew( 1832 level = TestLevel.COMPLETE, 1833 notes = "", 1834 method = "setParent", 1835 args = {java.util.logging.Logger.class} 1836 ) 1837 public void testSetParent_AnonyLoggerInsufficientPrivilege() { 1838 Logger log = Logger.getAnonymousLogger(); 1839 SecurityManager oldMan = System.getSecurityManager(); 1840 System.setSecurityManager(new MockSecurityManager()); 1841 try { 1842 log.setParent(log); 1843 fail("Should throw SecurityException!"); 1844 } catch (SecurityException e) { 1845 } finally { 1846 System.setSecurityManager(oldMan); 1847 } 1848 } 1849 1850 /* 1851 * Test getName() for normal names. 1852 */ 1853 @TestTargetNew( 1854 level = TestLevel.PARTIAL_COMPLETE, 1855 notes = "Verifies getName() for normal names.", 1856 method = "getName", 1857 args = {} 1858 ) 1859 public void testGetName_Normal() { 1860 Logger log = Logger.getLogger("testGetName_Normal"); 1861 assertEquals("testGetName_Normal", log.getName()); 1862 1863 Logger mlog = new MockLogger("testGetName_Normal", null); 1864 assertEquals("testGetName_Normal", mlog.getName()); 1865 } 1866 1867 /* 1868 * Test getName() for empty name. 1869 */ 1870 @TestTargetNew( 1871 level = TestLevel.PARTIAL_COMPLETE, 1872 notes = "Verifies getName() for empty name.", 1873 method = "getName", 1874 args = {} 1875 ) 1876 public void testGetName_Empty() { 1877 Logger log = Logger.getLogger(""); 1878 assertEquals("", log.getName()); 1879 1880 Logger mlog = new MockLogger("", null); 1881 assertEquals("", mlog.getName()); 1882 } 1883 1884 /* 1885 * Test getName() for null name. 1886 */ 1887 @TestTargetNew( 1888 level = TestLevel.PARTIAL_COMPLETE, 1889 notes = "Verifies getName() for null name.", 1890 method = "getName", 1891 args = {} 1892 ) 1893 public void testGetName_Null() { 1894 Logger log = Logger.getAnonymousLogger(); 1895 assertNull(log.getName()); 1896 1897 Logger mlog = new MockLogger(null, null); 1898 assertNull(mlog.getName()); 1899 } 1900 1901 /* 1902 * Test getResourceBundle() when it it not null. 1903 */ 1904 @TestTargetNew( 1905 level = TestLevel.PARTIAL_COMPLETE, 1906 notes = "Verifies getResourceBundle() when it it not null.", 1907 method = "getResourceBundle", 1908 args = {} 1909 ) 1910 public void testGetResourceBundle_Normal() { 1911 Logger log = Logger.getLogger("testGetResourceBundle_Normal", 1912 VALID_RESOURCE_BUNDLE); 1913 assertEquals(VALID_VALUE, log.getResourceBundle().getString(VALID_KEY)); 1914 1915 Logger mlog = new MockLogger(null, VALID_RESOURCE_BUNDLE); 1916 assertEquals(VALID_VALUE, mlog.getResourceBundle().getString(VALID_KEY)); 1917 } 1918 1919 /* 1920 * Test getResourceBundle() when it it null. 1921 */ 1922 @TestTargetNew( 1923 level = TestLevel.PARTIAL_COMPLETE, 1924 notes = "Verifies getResourceBundle() when it it null.", 1925 method = "getResourceBundle", 1926 args = {} 1927 ) 1928 public void testGetResourceBundle_Null() { 1929 Logger log = Logger.getLogger("testGetResourceBundle_Null", null); 1930 assertNull(log.getResourceBundle()); 1931 1932 Logger mlog = new MockLogger(null, null); 1933 assertNull(mlog.getResourceBundle()); 1934 } 1935 1936 1937 /* 1938 * Test getResourceBundleName() when it it not null. 1939 */ 1940 @TestTargetNew( 1941 level = TestLevel.PARTIAL_COMPLETE, 1942 notes = "Verifies getResourceBundleName() when it it not null.", 1943 method = "getResourceBundleName", 1944 args = {} 1945 ) 1946 public void testGetResourceBundleName_Normal() { 1947 Logger log = Logger.getLogger("testGetResourceBundleName_Normal", 1948 VALID_RESOURCE_BUNDLE); 1949 assertEquals(VALID_RESOURCE_BUNDLE, log.getResourceBundleName()); 1950 1951 Logger mlog = new MockLogger(null, null); 1952 assertNull(mlog.getResourceBundleName()); 1953 } 1954 1955 /* 1956 * Test getResourceBundleName() when it it null. 1957 */ 1958 @TestTargetNew( 1959 level = TestLevel.PARTIAL_COMPLETE, 1960 notes = "Verifies getResourceBundleName() when it it null.", 1961 method = "getResourceBundleName", 1962 args = {} 1963 ) 1964 public void testGetResourceBundleName_Null() { 1965 Logger log = Logger.getLogger("testGetResourceBundleName_Null", null); 1966 assertNull(log.getResourceBundleName()); 1967 1968 Logger mlog = new MockLogger(null, null); 1969 assertNull(mlog.getResourceBundleName()); 1970 } 1971 1972 1973 /* 1974 * Test isLoggable(Level). 1975 */ 1976 @TestTargetNew( 1977 level = TestLevel.COMPLETE, 1978 notes = "", 1979 method = "isLoggable", 1980 args = {java.util.logging.Level.class} 1981 ) 1982 public void testIsLoggable() { 1983 MockLogger mlog = new MockLogger(null, null); 1984 assertNull(mlog.getLevel()); 1985 assertNull(mlog.getParent()); 1986 1987 assertTrue(mlog.isLoggable(Level.SEVERE)); 1988 assertTrue(mlog.isLoggable(Level.WARNING)); 1989 assertTrue(mlog.isLoggable(Level.INFO)); 1990 assertFalse(mlog.isLoggable(Level.CONFIG)); 1991 assertFalse(mlog.isLoggable(Level.FINE)); 1992 assertFalse(mlog.isLoggable(Level.ALL)); 1993 assertTrue(mlog.isLoggable(Level.OFF)); 1994 1995 mlog.setLevel(Level.CONFIG); 1996 assertTrue(mlog.isLoggable(Level.SEVERE)); 1997 assertTrue(mlog.isLoggable(Level.CONFIG)); 1998 assertFalse(mlog.isLoggable(Level.ALL)); 1999 assertTrue(mlog.isLoggable(Level.OFF)); 2000 2001 mlog.setLevel(Level.ALL); 2002 assertTrue(mlog.isLoggable(Level.ALL)); 2003 assertTrue(mlog.isLoggable(Level.SEVERE)); 2004 assertTrue(mlog.isLoggable(Level.OFF)); 2005 2006 mlog.setLevel(Level.OFF); 2007 assertFalse(mlog.isLoggable(Level.ALL)); 2008 assertFalse(mlog.isLoggable(Level.SEVERE)); 2009 assertFalse(mlog.isLoggable(Level.OFF)); 2010 } 2011 2012 /* 2013 * Test throwing(String, String, Throwable) with normal values. 2014 */ 2015 @TestTargetNew( 2016 level = TestLevel.COMPLETE, 2017 notes = "", 2018 method = "throwing", 2019 args = {java.lang.String.class, java.lang.String.class, java.lang.Throwable.class} 2020 ) 2021 public void testThrowing_Normal() { 2022 Throwable t = new Throwable(); 2023 this.sharedLogger.setLevel(Level.FINER); 2024 this.sharedLogger.throwing("sourceClass", "sourceMethod", t); 2025 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 2026 assertTrue(CallVerificationStack.getInstance().empty()); 2027 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 2028 assertEquals(r.getMessage(), "THROW"); 2029 assertSame(r.getResourceBundleName(), this.sharedLogger 2030 .getResourceBundleName()); 2031 assertSame(r.getResourceBundle(), this.sharedLogger.getResourceBundle()); 2032 assertSame(r.getSourceClassName(), "sourceClass"); 2033 assertSame(r.getSourceMethodName(), "sourceMethod"); 2034 assertSame(r.getLevel(), Level.FINER); 2035 assertSame(r.getParameters(), null); 2036 assertSame(r.getThrown(), t); 2037 2038 2039 this.sharedLogger.setLevel(Level.FINE); 2040 this.sharedLogger.throwing("sourceClass", "sourceMethod", t); 2041 2042 // FINE is a level too low, message will be lost => empty 2043 assertTrue(CallVerificationStack.getInstance().empty()); 2044 } 2045 2046 /* 2047 * Test throwing(String, String, Throwable) with null values. 2048 */ 2049 @TestTargetNew( 2050 level = TestLevel.COMPLETE, 2051 notes = "", 2052 method = "throwing", 2053 args = {java.lang.String.class, java.lang.String.class, java.lang.Throwable.class} 2054 ) 2055 public void testThrowing_Null() { 2056 Logger child = new MockLogger("childLogger", null); 2057 Logger parent = new MockLogger("parentLogger", VALID_RESOURCE_BUNDLE2); 2058 child.addHandler(new MockHandler()); 2059 child.setParent(parent); 2060 2061 child.setLevel(Level.FINER); 2062 child.throwing(null, null, null); 2063 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 2064 assertTrue(CallVerificationStack.getInstance().empty()); 2065 assertSame(r.getLoggerName(), child.getName()); 2066 assertEquals(r.getMessage(), "THROW"); 2067 assertSame(r.getResourceBundleName(), parent.getResourceBundleName()); 2068 assertSame(r.getResourceBundle(), parent.getResourceBundle()); 2069 assertSame(r.getSourceClassName(), null); 2070 assertSame(r.getSourceMethodName(), null); 2071 assertSame(r.getLevel(), Level.FINER); 2072 assertSame(r.getParameters(), null); 2073 assertSame(r.getThrown(), null); 2074 } 2075 2076 /* 2077 * Test entering(String, String) with normal values. 2078 */ 2079 @TestTargetNew( 2080 level = TestLevel.PARTIAL_COMPLETE, 2081 notes = "Verifies entering(String, String) with normal values.", 2082 method = "entering", 2083 args = {java.lang.String.class, java.lang.String.class} 2084 ) 2085 public void testEntering_StringString_Normal() { 2086 this.sharedLogger.setLevel(Level.FINER); 2087 this.sharedLogger.entering("sourceClass", "sourceMethod"); 2088 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 2089 assertTrue(CallVerificationStack.getInstance().empty()); 2090 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 2091 assertEquals(r.getMessage(), "ENTRY"); 2092 assertSame(r.getResourceBundleName(), this.sharedLogger 2093 .getResourceBundleName()); 2094 assertSame(r.getResourceBundle(), this.sharedLogger.getResourceBundle()); 2095 assertSame(r.getSourceClassName(), "sourceClass"); 2096 assertSame(r.getSourceMethodName(), "sourceMethod"); 2097 assertSame(r.getLevel(), Level.FINER); 2098 assertSame(r.getParameters(), null); 2099 assertSame(r.getThrown(), null); 2100 2101 this.sharedLogger.setLevel(Level.FINE); 2102 this.sharedLogger.entering("sourceClass", "sourceMethod"); 2103 assertTrue(CallVerificationStack.getInstance().empty()); 2104 } 2105 2106 /* 2107 * Test entering(String, String) with null values. 2108 */ 2109 @TestTargetNew( 2110 level = TestLevel.PARTIAL_COMPLETE, 2111 notes = "Verifies entering(String, String) with null values.", 2112 method = "entering", 2113 args = {java.lang.String.class, java.lang.String.class} 2114 ) 2115 public void testEntering_StringString_Null() { 2116 Logger child = new MockLogger("childLogger", null); 2117 Logger parent = new MockLogger("parentLogger", VALID_RESOURCE_BUNDLE2); 2118 child.addHandler(new MockHandler()); 2119 child.setParent(parent); 2120 2121 child.setLevel(Level.FINER); 2122 child.entering(null, null); 2123 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 2124 assertTrue(CallVerificationStack.getInstance().empty()); 2125 assertSame(r.getLoggerName(), child.getName()); 2126 assertEquals(r.getMessage(), "ENTRY"); 2127 assertSame(r.getResourceBundleName(), parent.getResourceBundleName()); 2128 assertSame(r.getResourceBundle(), parent.getResourceBundle()); 2129 assertSame(r.getSourceClassName(), null); 2130 assertSame(r.getSourceMethodName(), null); 2131 assertSame(r.getLevel(), Level.FINER); 2132 assertSame(r.getParameters(), null); 2133 assertSame(r.getThrown(), null); 2134 } 2135 2136 /* 2137 * Test entering(String, String, Object) with normal values. 2138 */ 2139 @TestTargetNew( 2140 level = TestLevel.PARTIAL_COMPLETE, 2141 notes = "Verifies entering(String, String, Object) with normal values.", 2142 method = "entering", 2143 args = {java.lang.String.class, java.lang.String.class, java.lang.Object.class} 2144 ) 2145 public void testEntering_StringStringObject_Normal() { 2146 Object param = new Object(); 2147 this.sharedLogger.setLevel(Level.FINER); 2148 this.sharedLogger.entering("sourceClass", "sourceMethod", param); 2149 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 2150 assertTrue(CallVerificationStack.getInstance().empty()); 2151 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 2152 assertEquals(r.getMessage(), "ENTRY {0}"); 2153 assertSame(r.getResourceBundleName(), this.sharedLogger 2154 .getResourceBundleName()); 2155 assertSame(r.getResourceBundle(), this.sharedLogger.getResourceBundle()); 2156 assertSame(r.getSourceClassName(), "sourceClass"); 2157 assertSame(r.getSourceMethodName(), "sourceMethod"); 2158 assertSame(r.getLevel(), Level.FINER); 2159 assertSame(r.getParameters()[0], param); 2160 assertEquals(1, r.getParameters().length); 2161 assertSame(r.getThrown(), null); 2162 2163 this.sharedLogger.setLevel(Level.FINE); 2164 this.sharedLogger.entering("sourceClass", "sourceMethod", param); 2165 assertTrue(CallVerificationStack.getInstance().empty()); 2166 } 2167 2168 /* 2169 * Test entering(String, String, Object) with null values. 2170 */ 2171 @TestTargetNew( 2172 level = TestLevel.PARTIAL_COMPLETE, 2173 notes = "Verifies entering(String, String, Object) with null values.", 2174 method = "entering", 2175 args = {java.lang.String.class, java.lang.String.class, java.lang.Object.class} 2176 ) 2177 public void testEntering_StringStringObject_Null() { 2178 Logger child = new MockLogger("childLogger", null); 2179 Logger parent = new MockLogger("parentLogger", VALID_RESOURCE_BUNDLE2); 2180 child.addHandler(new MockHandler()); 2181 child.setParent(parent); 2182 2183 child.setLevel(Level.FINER); 2184 child.entering(null, null, (Object) null); 2185 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 2186 assertTrue(CallVerificationStack.getInstance().empty()); 2187 assertSame(r.getLoggerName(), child.getName()); 2188 assertEquals(r.getMessage(), "ENTRY {0}"); 2189 assertSame(r.getResourceBundleName(), parent.getResourceBundleName()); 2190 assertSame(r.getResourceBundle(), parent.getResourceBundle()); 2191 assertSame(r.getSourceClassName(), null); 2192 assertSame(r.getSourceMethodName(), null); 2193 assertSame(r.getLevel(), Level.FINER); 2194 assertEquals(r.getParameters().length, 1); 2195 assertNull(r.getParameters()[0]); 2196 assertSame(r.getThrown(), null); 2197 } 2198 2199 /* 2200 * Test entering(String, String, Object[]) with normal values. 2201 */ 2202 @TestTargetNew( 2203 level = TestLevel.PARTIAL_COMPLETE, 2204 notes = "Verifies entering(String, String, Object[]) with normal values.", 2205 method = "entering", 2206 args = {java.lang.String.class, java.lang.String.class, java.lang.Object[].class} 2207 ) 2208 public void testEntering_StringStringObjects_Normal() { 2209 Object[] params = new Object[2]; 2210 params[0] = new Object(); 2211 params[1] = new Object(); 2212 this.sharedLogger.setLevel(Level.FINER); 2213 this.sharedLogger.entering("sourceClass", "sourceMethod", params); 2214 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 2215 assertTrue(CallVerificationStack.getInstance().empty()); 2216 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 2217 assertEquals(r.getMessage(), "ENTRY {0} {1}"); 2218 assertSame(r.getResourceBundleName(), this.sharedLogger 2219 .getResourceBundleName()); 2220 assertSame(r.getResourceBundle(), this.sharedLogger.getResourceBundle()); 2221 assertSame(r.getSourceClassName(), "sourceClass"); 2222 assertSame(r.getSourceMethodName(), "sourceMethod"); 2223 assertSame(r.getLevel(), Level.FINER); 2224 assertSame(r.getParameters()[0], params[0]); 2225 assertSame(r.getParameters()[1], params[1]); 2226 assertEquals(2, r.getParameters().length); 2227 assertSame(r.getThrown(), null); 2228 2229 this.sharedLogger.setLevel(Level.FINE); 2230 this.sharedLogger.entering("sourceClass", "sourceMethod", params); 2231 assertTrue(CallVerificationStack.getInstance().empty()); 2232 } 2233 2234 /* 2235 * Test entering(String, String, Object[]) with null class name and method 2236 * name and empty parameter array. 2237 */ 2238 @TestTargetNew( 2239 level = TestLevel.PARTIAL_COMPLETE, 2240 notes = "Verifies entering(String, String, Object[]) with null class name and method name and empty parameter array.", 2241 method = "entering", 2242 args = {java.lang.String.class, java.lang.String.class, java.lang.Object[].class} 2243 ) 2244 public void testEntering_StringStringObjects_NullEmpty() { 2245 Logger child = new MockLogger("childLogger", null); 2246 Logger parent = new MockLogger("parentLogger", VALID_RESOURCE_BUNDLE2); 2247 child.addHandler(new MockHandler()); 2248 child.setParent(parent); 2249 2250 child.setLevel(Level.FINER); 2251 child.entering(null, null, new Object[0]); 2252 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 2253 assertTrue(CallVerificationStack.getInstance().empty()); 2254 assertSame(r.getLoggerName(), child.getName()); 2255 assertEquals(r.getMessage(), "ENTRY"); 2256 assertSame(r.getResourceBundleName(), parent.getResourceBundleName()); 2257 assertSame(r.getResourceBundle(), parent.getResourceBundle()); 2258 assertSame(r.getSourceClassName(), null); 2259 assertSame(r.getSourceMethodName(), null); 2260 assertSame(r.getLevel(), Level.FINER); 2261 assertEquals(0, r.getParameters().length); 2262 assertSame(r.getThrown(), null); 2263 } 2264 2265 /* 2266 * Test entering(String, String, Object[]) with null values with appropriate 2267 * logging level set. 2268 */ 2269 @TestTargetNew( 2270 level = TestLevel.PARTIAL_COMPLETE, 2271 notes = "Verifies entering(String, String, Object[]) with null values with appropriate logging level set.", 2272 method = "entering", 2273 args = {java.lang.String.class, java.lang.String.class, java.lang.Object[].class} 2274 ) 2275 public void testEntering_StringStringObjects_Null() { 2276 sharedLogger.setLevel(Level.FINER); 2277 sharedLogger.entering(null, null, (Object[]) null); 2278 // regression test for Harmony-1265 2279 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 2280 assertTrue(CallVerificationStack.getInstance().empty()); 2281 assertSame(sharedLogger.getName(), r.getLoggerName()); 2282 assertEquals("ENTRY", r.getMessage()); 2283 assertSame(sharedLogger.getResourceBundleName(), r 2284 .getResourceBundleName()); 2285 assertSame(sharedLogger.getResourceBundle(), r.getResourceBundle()); 2286 assertNull(r.getSourceClassName()); 2287 assertNull(r.getSourceMethodName()); 2288 assertSame(Level.FINER, r.getLevel()); 2289 assertNull(r.getParameters()); 2290 assertNull(r.getThrown()); 2291 } 2292 2293 /* 2294 * Test entering(String, String, Object[]) with null values with 2295 * inappropriate logging level set. 2296 */ 2297 @TestTargetNew( 2298 level = TestLevel.PARTIAL_COMPLETE, 2299 notes = "Verifies entering(String, String, Object[]) with null values with inappropriate logging level set.", 2300 method = "entering", 2301 args = {java.lang.String.class, java.lang.String.class, java.lang.Object[].class} 2302 ) 2303 public void testEntering_StringStringObjects_NullDisabled() { 2304 this.sharedLogger.setLevel(Level.FINE); 2305 this.sharedLogger.entering(null, null, (Object[]) null); 2306 assertTrue(CallVerificationStack.getInstance().empty()); 2307 } 2308 2309 /* 2310 * Test exiting(String, String) with normal values. 2311 */ 2312 @TestTargetNew( 2313 level = TestLevel.PARTIAL_COMPLETE, 2314 notes = "Verifies exiting(String, String) with normal values.", 2315 method = "exiting", 2316 args = {java.lang.String.class, java.lang.String.class} 2317 ) 2318 public void testExiting_StringString_Normal() { 2319 this.sharedLogger.setLevel(Level.FINER); 2320 this.sharedLogger.exiting("sourceClass", "sourceMethod"); 2321 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 2322 assertTrue(CallVerificationStack.getInstance().empty()); 2323 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 2324 assertEquals(r.getMessage(), "RETURN"); 2325 assertSame(r.getResourceBundleName(), this.sharedLogger 2326 .getResourceBundleName()); 2327 assertSame(r.getResourceBundle(), this.sharedLogger.getResourceBundle()); 2328 assertSame(r.getSourceClassName(), "sourceClass"); 2329 assertSame(r.getSourceMethodName(), "sourceMethod"); 2330 assertSame(r.getLevel(), Level.FINER); 2331 assertNull(r.getParameters()); 2332 assertSame(r.getThrown(), null); 2333 2334 this.sharedLogger.setLevel(Level.FINE); 2335 this.sharedLogger.exiting("sourceClass", "sourceMethod"); 2336 assertTrue(CallVerificationStack.getInstance().empty()); 2337 } 2338 2339 /* 2340 * Test exiting(String, String) with null values. 2341 */ 2342 @TestTargetNew( 2343 level = TestLevel.PARTIAL_COMPLETE, 2344 notes = "Verifies exiting(String, String) with null values.", 2345 method = "exiting", 2346 args = {java.lang.String.class, java.lang.String.class} 2347 ) 2348 public void testExiting_StringString_Null() { 2349 Logger child = new MockLogger("childLogger", null); 2350 Logger parent = new MockLogger("parentLogger", VALID_RESOURCE_BUNDLE2); 2351 child.addHandler(new MockHandler()); 2352 child.setParent(parent); 2353 2354 child.setLevel(Level.FINER); 2355 child.exiting(null, null); 2356 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 2357 assertTrue(CallVerificationStack.getInstance().empty()); 2358 assertSame(r.getLoggerName(), child.getName()); 2359 assertEquals(r.getMessage(), "RETURN"); 2360 assertSame(r.getResourceBundleName(), parent.getResourceBundleName()); 2361 assertSame(r.getResourceBundle(), parent.getResourceBundle()); 2362 assertSame(r.getSourceClassName(), null); 2363 assertSame(r.getSourceMethodName(), null); 2364 assertSame(r.getLevel(), Level.FINER); 2365 assertSame(r.getParameters(), null); 2366 assertSame(r.getThrown(), null); 2367 } 2368 2369 /* 2370 * Test exiting(String, String, Object) with normal values. 2371 */ 2372 @TestTargetNew( 2373 level = TestLevel.PARTIAL_COMPLETE, 2374 notes = "Verifies exiting(String, String, Object) with normal values.", 2375 method = "exiting", 2376 args = {java.lang.String.class, java.lang.String.class, java.lang.Object.class} 2377 ) 2378 public void testExiting_StringStringObject_Normal() { 2379 Object param = new Object(); 2380 this.sharedLogger.setLevel(Level.FINER); 2381 this.sharedLogger.exiting("sourceClass", "sourceMethod", param); 2382 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 2383 assertTrue(CallVerificationStack.getInstance().empty()); 2384 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 2385 assertEquals(r.getMessage(), "RETURN {0}"); 2386 assertSame(r.getResourceBundleName(), this.sharedLogger 2387 .getResourceBundleName()); 2388 assertSame(r.getResourceBundle(), this.sharedLogger.getResourceBundle()); 2389 assertSame(r.getSourceClassName(), "sourceClass"); 2390 assertSame(r.getSourceMethodName(), "sourceMethod"); 2391 assertSame(r.getLevel(), Level.FINER); 2392 assertSame(r.getParameters()[0], param); 2393 assertEquals(1, r.getParameters().length); 2394 assertSame(r.getThrown(), null); 2395 2396 this.sharedLogger.setLevel(Level.FINE); 2397 this.sharedLogger.exiting("sourceClass", "sourceMethod", param); 2398 assertTrue(CallVerificationStack.getInstance().empty()); 2399 } 2400 2401 /* 2402 * Test exiting(String, String, Object) with null values. 2403 */ 2404 @TestTargetNew( 2405 level = TestLevel.PARTIAL_COMPLETE, 2406 notes = "Verifies exiting(String, String, Object) with null values.", 2407 method = "exiting", 2408 args = {java.lang.String.class, java.lang.String.class, java.lang.Object.class} 2409 ) 2410 public void testExiting_StringStringObject_Null() { 2411 Logger child = new MockLogger("childLogger", null); 2412 Logger parent = new MockLogger("parentLogger", VALID_RESOURCE_BUNDLE2); 2413 child.addHandler(new MockHandler()); 2414 child.setParent(parent); 2415 2416 child.setLevel(Level.FINER); 2417 child.exiting(null, null, (Object) null); 2418 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 2419 assertTrue(CallVerificationStack.getInstance().empty()); 2420 assertSame(r.getLoggerName(), child.getName()); 2421 assertEquals(r.getMessage(), "RETURN {0}"); 2422 assertSame(r.getResourceBundleName(), parent.getResourceBundleName()); 2423 assertSame(r.getResourceBundle(), parent.getResourceBundle()); 2424 assertSame(r.getSourceClassName(), null); 2425 assertSame(r.getSourceMethodName(), null); 2426 assertSame(r.getLevel(), Level.FINER); 2427 assertEquals(r.getParameters().length, 1); 2428 assertNull(r.getParameters()[0]); 2429 assertSame(r.getThrown(), null); 2430 } 2431 2432 /* 2433 * Test config(String) with normal values. 2434 */ 2435 @TestTargetNew( 2436 level = TestLevel.PARTIAL_COMPLETE, 2437 notes = "", 2438 method = "config", 2439 args = {java.lang.String.class} 2440 ) 2441 public void testConfig_Normal() { 2442 this.sharedLogger.setLevel(Level.CONFIG); 2443 this.sharedLogger.config("config msg"); 2444 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 2445 assertTrue(CallVerificationStack.getInstance().empty()); 2446 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 2447 assertEquals(r.getMessage(), "config msg"); 2448 assertSame(r.getResourceBundleName(), this.sharedLogger 2449 .getResourceBundleName()); 2450 assertSame(r.getResourceBundle(), this.sharedLogger.getResourceBundle()); 2451 assertSame(r.getSourceClassName(), null); 2452 assertSame(r.getSourceMethodName(), null); 2453 assertSame(r.getLevel(), Level.CONFIG); 2454 assertNull(r.getParameters()); 2455 assertSame(r.getThrown(), null); 2456 2457 this.sharedLogger.setLevel(Level.INFO); 2458 this.sharedLogger.config("config again"); 2459 assertTrue(CallVerificationStack.getInstance().empty()); 2460 } 2461 2462 /* 2463 * Test config(String) with null values. 2464 */ 2465 @TestTargetNew( 2466 level = TestLevel.PARTIAL_COMPLETE, 2467 notes = "Verifies null as a parameter.", 2468 method = "config", 2469 args = {java.lang.String.class} 2470 ) 2471 public void testConfig_Null() { 2472 Logger child = new MockLogger("childLogger", null); 2473 Logger parent = new MockLogger("parentLogger", VALID_RESOURCE_BUNDLE2); 2474 child.addHandler(new MockHandler()); 2475 child.setParent(parent); 2476 2477 child.setLevel(Level.CONFIG); 2478 child.config(null); 2479 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 2480 assertTrue(CallVerificationStack.getInstance().empty()); 2481 assertSame(r.getLoggerName(), child.getName()); 2482 assertNull(r.getMessage()); 2483 assertSame(r.getResourceBundleName(), parent.getResourceBundleName()); 2484 assertSame(r.getResourceBundle(), parent.getResourceBundle()); 2485 assertSame(r.getSourceClassName(), null); 2486 assertSame(r.getSourceMethodName(), null); 2487 assertSame(r.getLevel(), Level.CONFIG); 2488 assertNull(r.getParameters()); 2489 assertSame(r.getThrown(), null); 2490 2491 this.sharedLogger.setLevel(Level.INFO); 2492 this.sharedLogger.config(null); 2493 assertTrue(CallVerificationStack.getInstance().empty()); 2494 } 2495 2496 /* 2497 * Test fine(String) with normal values. 2498 */ 2499 @TestTargetNew( 2500 level = TestLevel.PARTIAL_COMPLETE, 2501 notes = "", 2502 method = "fine", 2503 args = {java.lang.String.class} 2504 ) 2505 public void testFine_Normal() { 2506 this.sharedLogger.setLevel(Level.FINE); 2507 this.sharedLogger.fine("fine msg"); 2508 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 2509 assertTrue(CallVerificationStack.getInstance().empty()); 2510 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 2511 assertSame(r.getResourceBundle(), this.sharedLogger.getResourceBundle()); 2512 assertEquals(r.getMessage(), "fine msg"); 2513 assertSame(r.getResourceBundleName(), this.sharedLogger 2514 .getResourceBundleName()); 2515 assertSame(r.getSourceClassName(), null); 2516 assertSame(r.getSourceMethodName(), null); 2517 assertSame(r.getLevel(), Level.FINE); 2518 assertNull(r.getParameters()); 2519 assertSame(r.getThrown(), null); 2520 2521 this.sharedLogger.setLevel(Level.CONFIG); 2522 this.sharedLogger.fine("fine again"); 2523 assertTrue(CallVerificationStack.getInstance().empty()); 2524 } 2525 2526 /* 2527 * Test fine(String) with null values. 2528 */ 2529 @TestTargetNew( 2530 level = TestLevel.PARTIAL_COMPLETE, 2531 notes = "Verifies fine(String) with null values.", 2532 method = "fine", 2533 args = {java.lang.String.class} 2534 ) 2535 public void testFine_Null() { 2536 Logger child = new MockLogger("childLogger", null); 2537 Logger parent = new MockLogger("parentLogger", VALID_RESOURCE_BUNDLE2); 2538 child.addHandler(new MockHandler()); 2539 child.setParent(parent); 2540 2541 child.setLevel(Level.FINE); 2542 child.fine(null); 2543 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 2544 assertTrue(CallVerificationStack.getInstance().empty()); 2545 assertSame(r.getLoggerName(), child.getName()); 2546 assertNull(r.getMessage()); 2547 assertSame(r.getResourceBundleName(), parent.getResourceBundleName()); 2548 assertSame(r.getResourceBundle(), parent.getResourceBundle()); 2549 assertSame(r.getSourceClassName(), null); 2550 assertSame(r.getSourceMethodName(), null); 2551 assertSame(r.getLevel(), Level.FINE); 2552 assertNull(r.getParameters()); 2553 assertSame(r.getThrown(), null); 2554 2555 this.sharedLogger.setLevel(Level.CONFIG); 2556 this.sharedLogger.fine(null); 2557 assertTrue(CallVerificationStack.getInstance().empty()); 2558 } 2559 2560 /* 2561 * Test finer(String) with normal values. 2562 */ 2563 @TestTargetNew( 2564 level = TestLevel.PARTIAL_COMPLETE, 2565 notes = "Verifies finer(String) with normal values.", 2566 method = "finer", 2567 args = {java.lang.String.class} 2568 ) 2569 public void testFiner_Normal() { 2570 this.sharedLogger.setLevel(Level.FINER); 2571 this.sharedLogger.finer("finer msg"); 2572 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 2573 assertTrue(CallVerificationStack.getInstance().empty()); 2574 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 2575 assertEquals(r.getMessage(), "finer msg"); 2576 assertSame(r.getResourceBundleName(), this.sharedLogger 2577 .getResourceBundleName()); 2578 assertSame(r.getResourceBundle(), this.sharedLogger.getResourceBundle()); 2579 assertSame(r.getSourceClassName(), null); 2580 assertSame(r.getSourceMethodName(), null); 2581 assertSame(r.getLevel(), Level.FINER); 2582 assertNull(r.getParameters()); 2583 assertSame(r.getThrown(), null); 2584 2585 this.sharedLogger.setLevel(Level.FINE); 2586 this.sharedLogger.finer("finer again"); 2587 assertTrue(CallVerificationStack.getInstance().empty()); 2588 } 2589 2590 /* 2591 * Test finer(String) with null values. 2592 */ 2593 @TestTargetNew( 2594 level = TestLevel.PARTIAL_COMPLETE, 2595 notes = "Verifies finer(String) with null values.", 2596 method = "finer", 2597 args = {java.lang.String.class} 2598 ) 2599 public void testFiner_Null() { 2600 Logger child = new MockLogger("childLogger", null); 2601 Logger parent = new MockLogger("parentLogger", VALID_RESOURCE_BUNDLE2); 2602 child.addHandler(new MockHandler()); 2603 child.setParent(parent); 2604 2605 child.setLevel(Level.FINER); 2606 child.finer(null); 2607 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 2608 assertTrue(CallVerificationStack.getInstance().empty()); 2609 assertSame(r.getLoggerName(), child.getName()); 2610 assertNull(r.getMessage()); 2611 assertSame(r.getResourceBundleName(), parent.getResourceBundleName()); 2612 assertSame(r.getResourceBundle(), parent.getResourceBundle()); 2613 assertSame(r.getSourceClassName(), null); 2614 assertSame(r.getSourceMethodName(), null); 2615 assertSame(r.getLevel(), Level.FINER); 2616 assertNull(r.getParameters()); 2617 assertSame(r.getThrown(), null); 2618 2619 this.sharedLogger.setLevel(Level.FINE); 2620 this.sharedLogger.finer(null); 2621 assertTrue(CallVerificationStack.getInstance().empty()); 2622 } 2623 2624 /* 2625 * Test finest(String) with normal values. 2626 */ 2627 @TestTargetNew( 2628 level = TestLevel.PARTIAL_COMPLETE, 2629 notes = "Verifies finest(String) with normal values.", 2630 method = "finest", 2631 args = {java.lang.String.class} 2632 ) 2633 public void testFinest_Normal() { 2634 this.sharedLogger.setLevel(Level.FINEST); 2635 this.sharedLogger.finest("finest msg"); 2636 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 2637 assertTrue(CallVerificationStack.getInstance().empty()); 2638 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 2639 assertEquals(r.getMessage(), "finest msg"); 2640 assertSame(r.getResourceBundleName(), this.sharedLogger 2641 .getResourceBundleName()); 2642 assertSame(r.getResourceBundle(), this.sharedLogger.getResourceBundle()); 2643 assertSame(r.getSourceClassName(), null); 2644 assertSame(r.getSourceMethodName(), null); 2645 assertSame(r.getLevel(), Level.FINEST); 2646 assertNull(r.getParameters()); 2647 assertSame(r.getThrown(), null); 2648 2649 this.sharedLogger.setLevel(Level.FINER); 2650 this.sharedLogger.finest("finest again"); 2651 assertTrue(CallVerificationStack.getInstance().empty()); 2652 } 2653 2654 /* 2655 * Test finest(String) with null values. 2656 */ 2657 @TestTargetNew( 2658 level = TestLevel.PARTIAL_COMPLETE, 2659 notes = "Verifies finest(String) with null values.", 2660 method = "finest", 2661 args = {java.lang.String.class} 2662 ) 2663 public void testFinest_Null() { 2664 Logger child = new MockLogger("childLogger", null); 2665 Logger parent = new MockLogger("parentLogger", VALID_RESOURCE_BUNDLE2); 2666 child.addHandler(new MockHandler()); 2667 child.setParent(parent); 2668 2669 child.setLevel(Level.FINEST); 2670 child.finest(null); 2671 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 2672 assertTrue(CallVerificationStack.getInstance().empty()); 2673 assertSame(r.getLoggerName(), child.getName()); 2674 assertNull(r.getMessage()); 2675 assertSame(r.getResourceBundleName(), parent.getResourceBundleName()); 2676 assertSame(r.getResourceBundle(), parent.getResourceBundle()); 2677 assertSame(r.getSourceClassName(), null); 2678 assertSame(r.getSourceMethodName(), null); 2679 assertSame(r.getLevel(), Level.FINEST); 2680 assertNull(r.getParameters()); 2681 assertSame(r.getThrown(), null); 2682 2683 this.sharedLogger.setLevel(Level.FINER); 2684 this.sharedLogger.finest(null); 2685 assertTrue(CallVerificationStack.getInstance().empty()); 2686 } 2687 2688 /* 2689 * Test info(String) with normal values. 2690 */ 2691 @TestTargetNew( 2692 level = TestLevel.COMPLETE, 2693 notes = "", 2694 method = "info", 2695 args = {java.lang.String.class} 2696 ) 2697 public void testInfo_Normal() { 2698 this.sharedLogger.setLevel(Level.INFO); 2699 this.sharedLogger.info("info msg"); 2700 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 2701 assertTrue(CallVerificationStack.getInstance().empty()); 2702 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 2703 assertEquals(r.getMessage(), "info msg"); 2704 assertSame(r.getResourceBundleName(), this.sharedLogger 2705 .getResourceBundleName()); 2706 assertSame(r.getResourceBundle(), this.sharedLogger.getResourceBundle()); 2707 assertSame(r.getSourceClassName(), null); 2708 assertSame(r.getSourceMethodName(), null); 2709 assertSame(r.getLevel(), Level.INFO); 2710 assertNull(r.getParameters()); 2711 assertSame(r.getThrown(), null); 2712 2713 this.sharedLogger.setLevel(Level.WARNING); 2714 this.sharedLogger.info("info again"); 2715 assertTrue(CallVerificationStack.getInstance().empty()); 2716 } 2717 2718 /* 2719 * Test info(String) with null values. 2720 */ 2721 @TestTargetNew( 2722 level = TestLevel.COMPLETE, 2723 notes = "", 2724 method = "info", 2725 args = {java.lang.String.class} 2726 ) 2727 public void testInfo_Null() { 2728 Logger child = new MockLogger("childLogger", null); 2729 Logger parent = new MockLogger("parentLogger", VALID_RESOURCE_BUNDLE2); 2730 child.addHandler(new MockHandler()); 2731 child.setParent(parent); 2732 2733 child.setLevel(Level.INFO); 2734 child.info(null); 2735 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 2736 assertTrue(CallVerificationStack.getInstance().empty()); 2737 assertSame(r.getLoggerName(), child.getName()); 2738 assertNull(r.getMessage()); 2739 assertSame(r.getResourceBundleName(), parent.getResourceBundleName()); 2740 assertSame(r.getResourceBundle(), parent.getResourceBundle()); 2741 assertSame(r.getSourceClassName(), null); 2742 assertSame(r.getSourceMethodName(), null); 2743 assertSame(r.getLevel(), Level.INFO); 2744 assertNull(r.getParameters()); 2745 assertSame(r.getThrown(), null); 2746 2747 this.sharedLogger.setLevel(Level.WARNING); 2748 this.sharedLogger.info(null); 2749 assertTrue(CallVerificationStack.getInstance().empty()); 2750 } 2751 2752 /* 2753 * Test warning(String) with normal values. 2754 */ 2755 @TestTargetNew( 2756 level = TestLevel.COMPLETE, 2757 notes = "", 2758 method = "warning", 2759 args = {java.lang.String.class} 2760 ) 2761 public void testWarning_Normal() { 2762 this.sharedLogger.setLevel(Level.WARNING); 2763 this.sharedLogger.warning("warning msg"); 2764 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 2765 assertTrue(CallVerificationStack.getInstance().empty()); 2766 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 2767 assertEquals(r.getMessage(), "warning msg"); 2768 assertSame(r.getResourceBundleName(), this.sharedLogger 2769 .getResourceBundleName()); 2770 assertSame(r.getResourceBundle(), this.sharedLogger.getResourceBundle()); 2771 assertSame(r.getSourceClassName(), null); 2772 assertSame(r.getSourceMethodName(), null); 2773 assertSame(r.getLevel(), Level.WARNING); 2774 assertNull(r.getParameters()); 2775 assertSame(r.getThrown(), null); 2776 2777 this.sharedLogger.setLevel(Level.SEVERE); 2778 this.sharedLogger.warning("warning again"); 2779 assertTrue(CallVerificationStack.getInstance().empty()); 2780 } 2781 2782 /* 2783 * Test warning(String) with null values. 2784 */ 2785 @TestTargetNew( 2786 level = TestLevel.COMPLETE, 2787 notes = "", 2788 method = "warning", 2789 args = {java.lang.String.class} 2790 ) 2791 public void testWarning_Null() { 2792 Logger child = new MockLogger("childLogger", null); 2793 Logger parent = new MockLogger("parentLogger", VALID_RESOURCE_BUNDLE2); 2794 child.addHandler(new MockHandler()); 2795 child.setParent(parent); 2796 2797 child.setLevel(Level.WARNING); 2798 child.warning(null); 2799 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 2800 assertTrue(CallVerificationStack.getInstance().empty()); 2801 assertSame(r.getLoggerName(), child.getName()); 2802 assertNull(r.getMessage()); 2803 assertSame(r.getResourceBundleName(), parent.getResourceBundleName()); 2804 assertSame(r.getResourceBundle(), parent.getResourceBundle()); 2805 assertSame(r.getSourceClassName(), null); 2806 assertSame(r.getSourceMethodName(), null); 2807 assertSame(r.getLevel(), Level.WARNING); 2808 assertNull(r.getParameters()); 2809 assertSame(r.getThrown(), null); 2810 2811 this.sharedLogger.setLevel(Level.SEVERE); 2812 this.sharedLogger.warning(null); 2813 assertTrue(CallVerificationStack.getInstance().empty()); 2814 } 2815 2816 /* 2817 * Test severe(String) with normal values. 2818 */ 2819 @TestTargetNew( 2820 level = TestLevel.COMPLETE, 2821 notes = "", 2822 method = "severe", 2823 args = {java.lang.String.class} 2824 ) 2825 public void testSevere_Normal() { 2826 this.sharedLogger.setLevel(Level.SEVERE); 2827 this.sharedLogger.severe("severe msg"); 2828 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 2829 assertTrue(CallVerificationStack.getInstance().empty()); 2830 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 2831 assertEquals(r.getMessage(), "severe msg"); 2832 assertSame(r.getResourceBundleName(), this.sharedLogger 2833 .getResourceBundleName()); 2834 assertSame(r.getResourceBundle(), this.sharedLogger.getResourceBundle()); 2835 assertSame(r.getSourceClassName(), null); 2836 assertSame(r.getSourceMethodName(), null); 2837 assertSame(r.getLevel(), Level.SEVERE); 2838 assertNull(r.getParameters()); 2839 assertSame(r.getThrown(), null); 2840 2841 this.sharedLogger.setLevel(Level.OFF); 2842 this.sharedLogger.severe("severe again"); 2843 assertTrue(CallVerificationStack.getInstance().empty()); 2844 } 2845 2846 /* 2847 * Test severe(String) with null values. 2848 */ 2849 @TestTargetNew( 2850 level = TestLevel.COMPLETE, 2851 notes = "", 2852 method = "severe", 2853 args = {java.lang.String.class} 2854 ) 2855 public void testSevere_Null() { 2856 Logger child = new MockLogger("childLogger", null); 2857 Logger parent = new MockLogger("parentLogger", VALID_RESOURCE_BUNDLE2); 2858 child.addHandler(new MockHandler()); 2859 child.setParent(parent); 2860 2861 child.setLevel(Level.SEVERE); 2862 child.severe(null); 2863 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 2864 assertTrue(CallVerificationStack.getInstance().empty()); 2865 assertSame(r.getLoggerName(), child.getName()); 2866 assertNull(r.getMessage()); 2867 assertSame(r.getResourceBundleName(), parent.getResourceBundleName()); 2868 assertSame(r.getResourceBundle(), parent.getResourceBundle()); 2869 assertSame(r.getSourceClassName(), null); 2870 assertSame(r.getSourceMethodName(), null); 2871 assertSame(r.getLevel(), Level.SEVERE); 2872 assertNull(r.getParameters()); 2873 assertSame(r.getThrown(), null); 2874 2875 this.sharedLogger.setLevel(Level.OFF); 2876 this.sharedLogger.severe(null); 2877 assertTrue(CallVerificationStack.getInstance().empty()); 2878 } 2879 2880 /* 2881 * Test log(Level, String) with normal values. 2882 */ 2883 @TestTargetNew( 2884 level = TestLevel.COMPLETE, 2885 notes = "", 2886 method = "log", 2887 args = {java.util.logging.Level.class, java.lang.String.class} 2888 ) 2889 public void testLog_LevelString_Normal() { 2890 this.sharedLogger.setLevel(Level.INFO); 2891 this.sharedLogger.log(Level.INFO, "log(Level, String) msg"); 2892 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 2893 assertTrue(CallVerificationStack.getInstance().empty()); 2894 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 2895 assertEquals(r.getMessage(), "log(Level, String) msg"); 2896 assertSame(r.getResourceBundleName(), this.sharedLogger 2897 .getResourceBundleName()); 2898 assertSame(r.getResourceBundle(), this.sharedLogger.getResourceBundle()); 2899 assertSame(r.getSourceClassName(), null); 2900 assertSame(r.getSourceMethodName(), null); 2901 assertSame(r.getLevel(), Level.INFO); 2902 assertNull(r.getParameters()); 2903 assertSame(r.getThrown(), null); 2904 2905 this.sharedLogger.log(Level.CONFIG, "log(Level, String) msg"); 2906 assertTrue(CallVerificationStack.getInstance().empty()); 2907 this.sharedLogger.setLevel(Level.OFF); 2908 this.sharedLogger.log(Level.OFF, "log(Level, String) msg"); 2909 assertTrue(CallVerificationStack.getInstance().empty()); 2910 } 2911 2912 /* 2913 * Test log(Level, String) with null message. 2914 */ 2915 @TestTargetNew( 2916 level = TestLevel.COMPLETE, 2917 notes = "", 2918 method = "log", 2919 args = {java.util.logging.Level.class, java.lang.String.class} 2920 ) 2921 public void testLog_LevelString_NullMsg() { 2922 Logger child = new MockLogger("childLogger", null); 2923 Logger parent = new MockLogger("parentLogger", VALID_RESOURCE_BUNDLE2); 2924 child.addHandler(new MockHandler()); 2925 child.setParent(parent); 2926 2927 child.setLevel(Level.INFO); 2928 child.log(Level.INFO, null); 2929 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 2930 assertTrue(CallVerificationStack.getInstance().empty()); 2931 assertSame(r.getLoggerName(), child.getName()); 2932 assertNull(r.getMessage()); 2933 assertSame(r.getResourceBundleName(), parent.getResourceBundleName()); 2934 assertSame(r.getResourceBundle(), parent.getResourceBundle()); 2935 assertSame(r.getSourceClassName(), null); 2936 assertSame(r.getSourceMethodName(), null); 2937 assertSame(r.getLevel(), Level.INFO); 2938 assertNull(r.getParameters()); 2939 assertSame(r.getThrown(), null); 2940 } 2941 2942 /* 2943 * Test log(Level, String) with null level. 2944 */ 2945 @TestTargetNew( 2946 level = TestLevel.COMPLETE, 2947 notes = "", 2948 method = "log", 2949 args = {java.util.logging.Level.class, java.lang.String.class} 2950 ) 2951 public void testLog_LevelString_NullLevel() { 2952 // this.sharedLogger.setLevel(Level.OFF); 2953 try { 2954 this.sharedLogger.log(null, "log(Level, String) msg"); 2955 fail("Should throw NullPointerException!"); 2956 } catch (NullPointerException e) { 2957 } 2958 } 2959 2960 /* 2961 * Test log(Level, String, Object) with normal values. 2962 */ 2963 @TestTargetNew( 2964 level = TestLevel.COMPLETE, 2965 notes = "", 2966 method = "log", 2967 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.Object.class} 2968 ) 2969 public void testLog_LevelStringObject_Normal() { 2970 Object param = new Object(); 2971 this.sharedLogger.setLevel(Level.INFO); 2972 this.sharedLogger.log(Level.INFO, "log(Level, String, Object) msg", 2973 param); 2974 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 2975 assertTrue(CallVerificationStack.getInstance().empty()); 2976 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 2977 assertEquals(r.getMessage(), "log(Level, String, Object) msg"); 2978 assertSame(r.getResourceBundleName(), this.sharedLogger 2979 .getResourceBundleName()); 2980 assertSame(r.getResourceBundle(), this.sharedLogger.getResourceBundle()); 2981 assertSame(r.getSourceClassName(), null); 2982 assertSame(r.getSourceMethodName(), null); 2983 assertSame(r.getLevel(), Level.INFO); 2984 assertEquals(1, r.getParameters().length); 2985 assertSame(param, r.getParameters()[0]); 2986 assertSame(r.getThrown(), null); 2987 2988 this.sharedLogger.log(Level.CONFIG, "log(Level, String, Object) msg", 2989 param); 2990 assertTrue(CallVerificationStack.getInstance().empty()); 2991 this.sharedLogger.setLevel(Level.OFF); 2992 this.sharedLogger.log(Level.OFF, "log(Level, String, Object) msg", 2993 param); 2994 assertTrue(CallVerificationStack.getInstance().empty()); 2995 } 2996 2997 /* 2998 * Test log(Level, String, Object) with null message and object. 2999 */ 3000 @TestTargetNew( 3001 level = TestLevel.COMPLETE, 3002 notes = "", 3003 method = "log", 3004 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.Object.class} 3005 ) 3006 public void testLog_LevelStringObject_NullMsgObj() { 3007 Logger child = new MockLogger("childLogger", null); 3008 Logger parent = new MockLogger("parentLogger", VALID_RESOURCE_BUNDLE2); 3009 child.addHandler(new MockHandler()); 3010 child.setParent(parent); 3011 3012 child.setLevel(Level.INFO); 3013 child.log(Level.INFO, null, (Object) null); 3014 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 3015 assertTrue(CallVerificationStack.getInstance().empty()); 3016 assertSame(r.getLoggerName(), child.getName()); 3017 assertNull(r.getMessage()); 3018 assertSame(r.getResourceBundleName(), parent.getResourceBundleName()); 3019 assertSame(r.getResourceBundle(), parent.getResourceBundle()); 3020 assertSame(r.getSourceClassName(), null); 3021 assertSame(r.getSourceMethodName(), null); 3022 assertSame(r.getLevel(), Level.INFO); 3023 assertEquals(1, r.getParameters().length); 3024 assertNull(r.getParameters()[0]); 3025 assertSame(r.getThrown(), null); 3026 } 3027 3028 /* 3029 * Test log(Level, String, Object) with null level. 3030 */ 3031 @TestTargetNew( 3032 level = TestLevel.COMPLETE, 3033 notes = "", 3034 method = "log", 3035 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.Object.class} 3036 ) 3037 public void testLog_LevelStringObject_NullLevel() { 3038 // this.sharedLogger.setLevel(Level.OFF); 3039 try { 3040 this.sharedLogger.log(null, "log(Level, String, Object) msg", 3041 new Object()); 3042 fail("Should throw NullPointerException!"); 3043 } catch (NullPointerException e) { 3044 } 3045 } 3046 3047 /* 3048 * Test log(Level, String, Object[]) with normal values. 3049 */ 3050 @TestTargetNew( 3051 level = TestLevel.COMPLETE, 3052 notes = "", 3053 method = "log", 3054 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.Object[].class} 3055 ) 3056 3057 public void testLog_LevelStringObjects_Normal() { 3058 Object[] params = new Object[2]; 3059 params[0] = new Object(); 3060 params[1] = new Object(); 3061 this.sharedLogger.setLevel(Level.INFO); 3062 this.sharedLogger.log(Level.INFO, "log(Level, String, Object[]) msg", 3063 params); 3064 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 3065 assertTrue(CallVerificationStack.getInstance().empty()); 3066 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 3067 assertEquals(r.getMessage(), "log(Level, String, Object[]) msg"); 3068 assertSame(r.getResourceBundleName(), this.sharedLogger 3069 .getResourceBundleName()); 3070 assertSame(r.getResourceBundle(), this.sharedLogger.getResourceBundle()); 3071 assertSame(r.getSourceClassName(), null); 3072 assertSame(r.getSourceMethodName(), null); 3073 assertSame(r.getLevel(), Level.INFO); 3074 assertEquals(2, r.getParameters().length); 3075 assertSame(params[0], r.getParameters()[0]); 3076 assertSame(params[1], r.getParameters()[1]); 3077 assertSame(r.getThrown(), null); 3078 3079 this.sharedLogger.log(Level.CONFIG, "log(Level, String, Object[]) msg", 3080 params); 3081 assertTrue(CallVerificationStack.getInstance().empty()); 3082 this.sharedLogger.setLevel(Level.OFF); 3083 this.sharedLogger.log(Level.OFF, "log(Level, String, Object[]) msg", 3084 params); 3085 assertTrue(CallVerificationStack.getInstance().empty()); 3086 } 3087 3088 /* 3089 * Test log(Level, String, Object[]) with null message and object. 3090 */ 3091 @TestTargetNew( 3092 level = TestLevel.COMPLETE, 3093 notes = "", 3094 method = "log", 3095 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.Object[].class} 3096 ) 3097 public void testLog_LevelStringObjects_NullMsgObj() { 3098 Logger child = new MockLogger("childLogger", null); 3099 Logger parent = new MockLogger("parentLogger", VALID_RESOURCE_BUNDLE2); 3100 child.addHandler(new MockHandler()); 3101 child.setParent(parent); 3102 3103 child.setLevel(Level.INFO); 3104 child.log(Level.INFO, null, (Object[]) null); 3105 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 3106 assertTrue(CallVerificationStack.getInstance().empty()); 3107 assertSame(r.getLoggerName(), child.getName()); 3108 assertNull(r.getMessage()); 3109 assertSame(r.getResourceBundleName(), parent.getResourceBundleName()); 3110 assertSame(r.getResourceBundle(), parent.getResourceBundle()); 3111 assertSame(r.getSourceClassName(), null); 3112 assertSame(r.getSourceMethodName(), null); 3113 assertSame(r.getLevel(), Level.INFO); 3114 assertNull(r.getParameters()); 3115 assertSame(r.getThrown(), null); 3116 } 3117 3118 /* 3119 * Test log(Level, String, Object[]) with null level. 3120 */ 3121 @TestTargetNew( 3122 level = TestLevel.COMPLETE, 3123 notes = "", 3124 method = "log", 3125 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.Object[].class} 3126 ) 3127 public void testLog_LevelStringObjects_NullLevel() { 3128 try { 3129 this.sharedLogger.log(null, "log(Level, String, Object[]) msg", 3130 new Object[0]); 3131 fail("Should throw NullPointerException!"); 3132 } catch (NullPointerException e) { 3133 } 3134 } 3135 3136 /* 3137 * Test log(Level, String, Throwable) with normal values. 3138 */ 3139 @TestTargetNew( 3140 level = TestLevel.COMPLETE, 3141 notes = "", 3142 method = "log", 3143 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.Throwable.class} 3144 ) 3145 public void testLog_LevelStringThrowable_Normal() { 3146 Throwable t = new Throwable(); 3147 this.sharedLogger.setLevel(Level.INFO); 3148 this.sharedLogger.log(Level.INFO, "log(Level, String, Throwable) msg", 3149 t); 3150 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 3151 assertTrue(CallVerificationStack.getInstance().empty()); 3152 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 3153 assertEquals(r.getMessage(), "log(Level, String, Throwable) msg"); 3154 assertSame(r.getResourceBundleName(), this.sharedLogger 3155 .getResourceBundleName()); 3156 assertSame(r.getResourceBundle(), this.sharedLogger.getResourceBundle()); 3157 assertSame(r.getSourceClassName(), null); 3158 assertSame(r.getSourceMethodName(), null); 3159 assertSame(r.getLevel(), Level.INFO); 3160 assertNull(r.getParameters()); 3161 assertSame(r.getThrown(), t); 3162 3163 this.sharedLogger.log(Level.CONFIG, 3164 "log(Level, String, Throwable) msg", t); 3165 assertTrue(CallVerificationStack.getInstance().empty()); 3166 this.sharedLogger.setLevel(Level.OFF); 3167 this.sharedLogger 3168 .log(Level.OFF, "log(Level, String, Throwable) msg", t); 3169 assertTrue(CallVerificationStack.getInstance().empty()); 3170 } 3171 3172 /* 3173 * Test log(Level, String, Throwable) with null message and throwable. 3174 */ 3175 @TestTargetNew( 3176 level = TestLevel.COMPLETE, 3177 notes = "", 3178 method = "log", 3179 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.Throwable.class} 3180 ) 3181 public void testLog_LevelStringThrowable_Null() { 3182 Logger child = new MockLogger("childLogger", null); 3183 Logger parent = new MockLogger("parentLogger", VALID_RESOURCE_BUNDLE2); 3184 child.addHandler(new MockHandler()); 3185 child.setParent(parent); 3186 3187 child.setLevel(Level.INFO); 3188 child.log(Level.INFO, null, (Throwable) null); 3189 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 3190 assertTrue(CallVerificationStack.getInstance().empty()); 3191 assertSame(r.getLoggerName(), child.getName()); 3192 assertNull(r.getMessage()); 3193 assertSame(r.getResourceBundleName(), parent.getResourceBundleName()); 3194 assertSame(r.getResourceBundle(), parent.getResourceBundle()); 3195 assertSame(r.getSourceClassName(), null); 3196 assertSame(r.getSourceMethodName(), null); 3197 assertSame(r.getLevel(), Level.INFO); 3198 assertNull(r.getParameters()); 3199 assertSame(r.getThrown(), null); 3200 } 3201 3202 /* 3203 * Test log(Level, String, Throwable) with null level. 3204 */ 3205 @TestTargetNew( 3206 level = TestLevel.COMPLETE, 3207 notes = "", 3208 method = "log", 3209 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.Throwable.class} 3210 ) 3211 public void testLog_LevelStringThrowable_NullLevel() { 3212 // this.sharedLogger.setLevel(Level.OFF); 3213 try { 3214 this.sharedLogger.log(null, "log(Level, String, Throwable) msg", 3215 new Throwable()); 3216 fail("Should throw NullPointerException!"); 3217 } catch (NullPointerException e) { 3218 } 3219 } 3220 3221 /* 3222 * Test logp(Level, String, String, String) with normal values. 3223 */ 3224 @TestTargetNew( 3225 level = TestLevel.COMPLETE, 3226 notes = "", 3227 method = "logp", 3228 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.String.class, java.lang.String.class} 3229 ) 3230 public void testLogp_LevelStringStringString_Normal() { 3231 this.sharedLogger.setLevel(Level.INFO); 3232 this.sharedLogger.logp(Level.INFO, "sourceClass", "sourceMethod", 3233 "logp(Level, String, String, String) msg"); 3234 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 3235 assertTrue(CallVerificationStack.getInstance().empty()); 3236 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 3237 assertEquals(r.getMessage(), "logp(Level, String, String, String) msg"); 3238 assertSame(r.getResourceBundleName(), this.sharedLogger 3239 .getResourceBundleName()); 3240 assertSame(r.getResourceBundle(), this.sharedLogger.getResourceBundle()); 3241 assertSame(r.getSourceClassName(), "sourceClass"); 3242 assertSame(r.getSourceMethodName(), "sourceMethod"); 3243 assertSame(r.getLevel(), Level.INFO); 3244 assertNull(r.getParameters()); 3245 assertSame(r.getThrown(), null); 3246 3247 this.sharedLogger.logp(Level.CONFIG, "sourceClass", "sourceMethod", 3248 "logp(Level, String, String, String) msg"); 3249 assertTrue(CallVerificationStack.getInstance().empty()); 3250 this.sharedLogger.setLevel(Level.OFF); 3251 this.sharedLogger.logp(Level.OFF, "sourceClass", "sourceMethod", 3252 "logp(Level, String, String, String) msg"); 3253 assertTrue(CallVerificationStack.getInstance().empty()); 3254 } 3255 3256 /* 3257 * Test logp(Level, String, String, String) with null message. 3258 */ 3259 @TestTargetNew( 3260 level = TestLevel.COMPLETE, 3261 notes = "", 3262 method = "logp", 3263 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.String.class, java.lang.String.class} 3264 ) 3265 public void testLogp_LevelStringStringString_NullMsg() { 3266 Logger child = new MockLogger("childLogger", null); 3267 Logger parent = new MockLogger("parentLogger", VALID_RESOURCE_BUNDLE2); 3268 child.addHandler(new MockHandler()); 3269 child.setParent(parent); 3270 3271 child.setLevel(Level.INFO); 3272 child.logp(Level.INFO, null, null, null); 3273 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 3274 assertTrue(CallVerificationStack.getInstance().empty()); 3275 assertSame(r.getLoggerName(), child.getName()); 3276 assertNull(r.getMessage()); 3277 assertSame(r.getResourceBundleName(), parent.getResourceBundleName()); 3278 assertSame(r.getResourceBundle(), parent.getResourceBundle()); 3279 assertSame(r.getSourceClassName(), null); 3280 assertSame(r.getSourceMethodName(), null); 3281 assertSame(r.getLevel(), Level.INFO); 3282 assertNull(r.getParameters()); 3283 assertSame(r.getThrown(), null); 3284 } 3285 3286 /* 3287 * Test logp(Level, String, String, String) with null level. 3288 */ 3289 @TestTargetNew( 3290 level = TestLevel.COMPLETE, 3291 notes = "", 3292 method = "logp", 3293 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.String.class, java.lang.String.class} 3294 ) 3295 public void testLogp_LevelStringStringString_NullLevel() { 3296 // this.sharedLogger.setLevel(Level.OFF); 3297 try { 3298 this.sharedLogger.logp(null, "sourceClass", "sourceMethod", 3299 "logp(Level, String, String, String) msg"); 3300 fail("Should throw NullPointerException!"); 3301 } catch (NullPointerException e) { 3302 } 3303 } 3304 3305 /* 3306 * Test logp(Level, String, String, String, Object) with normal values. 3307 */ 3308 @TestTargetNew( 3309 level = TestLevel.COMPLETE, 3310 notes = "", 3311 method = "logp", 3312 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.Object.class} 3313 ) 3314 public void testLogp_LevelStringStringStringObject_Normal() { 3315 Object param = new Object(); 3316 this.sharedLogger.setLevel(Level.INFO); 3317 this.sharedLogger.logp(Level.INFO, "sourceClass", "sourceMethod", 3318 "logp(Level, String, String, String, Object) msg", param); 3319 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 3320 assertTrue(CallVerificationStack.getInstance().empty()); 3321 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 3322 assertEquals(r.getMessage(), 3323 "logp(Level, String, String, String, Object) msg"); 3324 assertSame(r.getResourceBundleName(), this.sharedLogger 3325 .getResourceBundleName()); 3326 assertSame(r.getResourceBundle(), this.sharedLogger.getResourceBundle()); 3327 assertSame(r.getSourceClassName(), "sourceClass"); 3328 assertSame(r.getSourceMethodName(), "sourceMethod"); 3329 assertSame(r.getLevel(), Level.INFO); 3330 assertEquals(1, r.getParameters().length); 3331 assertSame(param, r.getParameters()[0]); 3332 assertSame(r.getThrown(), null); 3333 3334 this.sharedLogger.logp(Level.CONFIG, "sourceClass", "sourceMethod", 3335 "logp(Level, String, String, String, Object) msg", param); 3336 assertTrue(CallVerificationStack.getInstance().empty()); 3337 this.sharedLogger.setLevel(Level.OFF); 3338 this.sharedLogger.logp(Level.OFF, "sourceClass", "sourceMethod", 3339 "logp(Level, String, String, String, Object) msg", param); 3340 assertTrue(CallVerificationStack.getInstance().empty()); 3341 } 3342 3343 /* 3344 * Test logp(Level, String, String, String, Object) with null message and 3345 * object. 3346 */ 3347 @TestTargetNew( 3348 level = TestLevel.COMPLETE, 3349 notes = "", 3350 method = "logp", 3351 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.Object.class} 3352 ) 3353 public void testLogp_LevelStringStringStringObject_NullMsgObj() { 3354 Logger child = new MockLogger("childLogger", null); 3355 Logger parent = new MockLogger("parentLogger", VALID_RESOURCE_BUNDLE2); 3356 child.addHandler(new MockHandler()); 3357 child.setParent(parent); 3358 3359 child.setLevel(Level.INFO); 3360 child.logp(Level.INFO, null, null, null, (Object) null); 3361 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 3362 assertTrue(CallVerificationStack.getInstance().empty()); 3363 assertSame(r.getLoggerName(), child.getName()); 3364 assertNull(r.getMessage()); 3365 assertSame(r.getResourceBundleName(), parent.getResourceBundleName()); 3366 assertSame(r.getResourceBundle(), parent.getResourceBundle()); 3367 assertSame(r.getSourceClassName(), null); 3368 assertSame(r.getSourceMethodName(), null); 3369 assertSame(r.getLevel(), Level.INFO); 3370 assertEquals(1, r.getParameters().length); 3371 assertNull(r.getParameters()[0]); 3372 assertSame(r.getThrown(), null); 3373 } 3374 3375 /* 3376 * Test logp(Level, String, String, String, Object) with null level. 3377 */ 3378 @TestTargetNew( 3379 level = TestLevel.COMPLETE, 3380 notes = "", 3381 method = "logp", 3382 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.Object.class} 3383 ) 3384 3385 public void testLogp_LevelStringStringStringObject_NullLevel() { 3386 // this.sharedLogger.setLevel(Level.OFF); 3387 try { 3388 this.sharedLogger.logp(null, "sourceClass", "sourceMethod", 3389 "logp(Level, String, String, String, Object) msg", 3390 new Object()); 3391 fail("Should throw NullPointerException!"); 3392 } catch (NullPointerException e) { 3393 } 3394 } 3395 3396 /* 3397 * Test logp(Level, String, String, String, Object[]) with normal values. 3398 */ 3399 @TestTargetNew( 3400 level = TestLevel.COMPLETE, 3401 notes = "", 3402 method = "logp", 3403 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.Object[].class} 3404 ) 3405 3406 public void testLogp_LevelStringStringStringObjects_Normal() { 3407 Object[] params = new Object[2]; 3408 params[0] = new Object(); 3409 params[1] = new Object(); 3410 this.sharedLogger.setLevel(Level.INFO); 3411 this.sharedLogger.logp(Level.INFO, "sourceClass", "sourceMethod", 3412 "logp(Level, String, String, String, Object[]) msg", params); 3413 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 3414 assertTrue(CallVerificationStack.getInstance().empty()); 3415 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 3416 assertEquals(r.getMessage(), 3417 "logp(Level, String, String, String, Object[]) msg"); 3418 assertSame(r.getResourceBundleName(), this.sharedLogger 3419 .getResourceBundleName()); 3420 assertSame(r.getResourceBundle(), this.sharedLogger.getResourceBundle()); 3421 assertSame(r.getSourceClassName(), "sourceClass"); 3422 assertSame(r.getSourceMethodName(), "sourceMethod"); 3423 assertSame(r.getLevel(), Level.INFO); 3424 assertEquals(2, r.getParameters().length); 3425 assertSame(params[0], r.getParameters()[0]); 3426 assertSame(params[1], r.getParameters()[1]); 3427 assertSame(r.getThrown(), null); 3428 3429 this.sharedLogger.logp(Level.CONFIG, "sourceClass", "sourceMethod", 3430 "logp(Level, String, String, String, Object[]) msg", params); 3431 assertTrue(CallVerificationStack.getInstance().empty()); 3432 this.sharedLogger.setLevel(Level.OFF); 3433 this.sharedLogger.logp(Level.OFF, "sourceClass", "sourceMethod", 3434 "logp(Level, String, String, String, Object[]) msg", params); 3435 assertTrue(CallVerificationStack.getInstance().empty()); 3436 } 3437 3438 /* 3439 * Test logp(Level, String, String, String, Object[]) with null message and 3440 * object. 3441 */ 3442 @TestTargetNew( 3443 level = TestLevel.COMPLETE, 3444 notes = "", 3445 method = "logp", 3446 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.Object[].class} 3447 ) 3448 public void testLogp_LevelStringStringStringObjects_NullMsgObj() { 3449 Logger child = new MockLogger("childLogger", null); 3450 Logger parent = new MockLogger("parentLogger", VALID_RESOURCE_BUNDLE2); 3451 child.addHandler(new MockHandler()); 3452 child.setParent(parent); 3453 3454 child.setLevel(Level.INFO); 3455 child.logp(Level.INFO, null, null, null, (Object[]) null); 3456 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 3457 assertTrue(CallVerificationStack.getInstance().empty()); 3458 assertSame(r.getLoggerName(), child.getName()); 3459 assertNull(r.getMessage()); 3460 assertSame(r.getResourceBundleName(), parent.getResourceBundleName()); 3461 assertSame(r.getResourceBundle(), parent.getResourceBundle()); 3462 assertSame(r.getSourceClassName(), null); 3463 assertSame(r.getSourceMethodName(), null); 3464 assertSame(r.getLevel(), Level.INFO); 3465 assertNull(r.getParameters()); 3466 assertSame(r.getThrown(), null); 3467 } 3468 3469 /* 3470 * Test logp(Level, String, String, String, Object[]) with null level. 3471 */ 3472 @TestTargetNew( 3473 level = TestLevel.COMPLETE, 3474 notes = "", 3475 method = "logp", 3476 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.Object[].class} 3477 ) 3478 public void testLogp_LevelStringStringStringObjects_NullLevel() { 3479 // this.sharedLogger.setLevel(Level.OFF); 3480 try { 3481 this.sharedLogger.logp(null, "sourceClass", "sourceMethod", 3482 "logp(Level, String, String, String, Object[]) msg", 3483 new Object[0]); 3484 fail("Should throw NullPointerException!"); 3485 } catch (NullPointerException e) { 3486 } 3487 } 3488 3489 /* 3490 * Test logp(Level, String, String, String, Throwable) with normal values. 3491 */ 3492 @TestTargetNew( 3493 level = TestLevel.COMPLETE, 3494 notes = "", 3495 method = "logp", 3496 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.Throwable.class} 3497 ) 3498 public void testLogp_LevelStringStringStringThrowable_Normal() { 3499 Throwable t = new Throwable(); 3500 this.sharedLogger.setLevel(Level.INFO); 3501 this.sharedLogger.logp(Level.INFO, "sourceClass", "sourceMethod", 3502 "logp(Level, String, String, String, Throwable) msg", t); 3503 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 3504 assertTrue(CallVerificationStack.getInstance().empty()); 3505 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 3506 assertEquals(r.getMessage(), 3507 "logp(Level, String, String, String, Throwable) msg"); 3508 assertSame(r.getResourceBundleName(), this.sharedLogger 3509 .getResourceBundleName()); 3510 assertSame(r.getResourceBundle(), this.sharedLogger.getResourceBundle()); 3511 assertSame(r.getSourceClassName(), "sourceClass"); 3512 assertSame(r.getSourceMethodName(), "sourceMethod"); 3513 assertSame(r.getLevel(), Level.INFO); 3514 assertNull(r.getParameters()); 3515 assertSame(r.getThrown(), t); 3516 3517 this.sharedLogger.logp(Level.CONFIG, "sourceClass", "sourceMethod", 3518 "logp(Level, String, String, String, Throwable) msg", t); 3519 assertTrue(CallVerificationStack.getInstance().empty()); 3520 this.sharedLogger.setLevel(Level.OFF); 3521 this.sharedLogger.logp(Level.OFF, "sourceClass", "sourceMethod", 3522 "logp(Level, String, String, String, Throwable) msg", t); 3523 assertTrue(CallVerificationStack.getInstance().empty()); 3524 } 3525 3526 /* 3527 * Test logp(Level, String, String, String, Throwable) with null message and 3528 * throwable. 3529 */ 3530 @TestTargetNew( 3531 level = TestLevel.COMPLETE, 3532 notes = "", 3533 method = "logp", 3534 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.Throwable.class} 3535 ) 3536 public void testLogp_LevelStringStringStringThrowable_Null() { 3537 Logger child = new MockLogger("childLogger", null); 3538 Logger parent = new MockLogger("parentLogger", VALID_RESOURCE_BUNDLE2); 3539 child.addHandler(new MockHandler()); 3540 child.setParent(parent); 3541 3542 child.setLevel(Level.INFO); 3543 child.logp(Level.INFO, null, null, null, (Throwable) null); 3544 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 3545 assertTrue(CallVerificationStack.getInstance().empty()); 3546 assertSame(r.getLoggerName(), child.getName()); 3547 assertNull(r.getMessage()); 3548 assertSame(r.getResourceBundleName(), parent.getResourceBundleName()); 3549 assertSame(r.getResourceBundle(), parent.getResourceBundle()); 3550 assertSame(r.getSourceClassName(), null); 3551 assertSame(r.getSourceMethodName(), null); 3552 assertSame(r.getLevel(), Level.INFO); 3553 assertNull(r.getParameters()); 3554 assertSame(r.getThrown(), null); 3555 } 3556 3557 /* 3558 * Test logp(Level, String, String, String, Throwable) with null level. 3559 */ 3560 @TestTargetNew( 3561 level = TestLevel.COMPLETE, 3562 notes = "", 3563 method = "logp", 3564 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.Throwable.class} 3565 ) 3566 public void testLogp_LevelStringStringStringThrowable_NullLevel() { 3567 // this.sharedLogger.setLevel(Level.OFF); 3568 try { 3569 this.sharedLogger.logp(null, "sourceClass", "sourceMethod", 3570 "log(Level, String, String, String, Throwable) msg", 3571 new Throwable()); 3572 fail("Should throw NullPointerException!"); 3573 } catch (NullPointerException e) { 3574 } 3575 } 3576 3577 /* 3578 * Test logrb(Level, String, String, String, String) with normal values. 3579 */ 3580 @TestTargetNew( 3581 level = TestLevel.COMPLETE, 3582 notes = "", 3583 method = "logrb", 3584 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class} 3585 ) 3586 public void testLogrb_LevelStringStringString_Normal() { 3587 this.sharedLogger.setLevel(Level.INFO); 3588 this.sharedLogger.logrb(Level.INFO, "sourceClass", "sourceMethod", 3589 VALID_RESOURCE_BUNDLE2, 3590 "logrb(Level, String, String, String, String) msg"); 3591 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 3592 assertTrue(CallVerificationStack.getInstance().empty()); 3593 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 3594 assertEquals(r.getMessage(), 3595 "logrb(Level, String, String, String, String) msg"); 3596 assertSame(r.getResourceBundleName(), VALID_RESOURCE_BUNDLE2); 3597 assertEquals(VALID_VALUE2, r.getResourceBundle().getString(VALID_KEY)); 3598 assertSame(r.getSourceClassName(), "sourceClass"); 3599 assertSame(r.getSourceMethodName(), "sourceMethod"); 3600 assertSame(r.getLevel(), Level.INFO); 3601 assertNull(r.getParameters()); 3602 assertSame(r.getThrown(), null); 3603 3604 this.sharedLogger.logrb(Level.CONFIG, "sourceClass", "sourceMethod", 3605 VALID_RESOURCE_BUNDLE2, 3606 "logrb(Level, String, String, String, String) msg"); 3607 assertTrue(CallVerificationStack.getInstance().empty()); 3608 this.sharedLogger.setLevel(Level.OFF); 3609 this.sharedLogger.logrb(Level.OFF, "sourceClass", "sourceMethod", 3610 VALID_RESOURCE_BUNDLE2, 3611 "logrb(Level, String, String, String, String) msg"); 3612 assertTrue(CallVerificationStack.getInstance().empty()); 3613 } 3614 3615 /* 3616 * Test logrb(Level, String, String, String, String) with null message. 3617 */ 3618 @TestTargetNew( 3619 level = TestLevel.COMPLETE, 3620 notes = "", 3621 method = "logrb", 3622 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class} 3623 ) 3624 public void testLogrb_LevelStringStringString_NullMsg() { 3625 this.sharedLogger.setLevel(Level.INFO); 3626 this.sharedLogger.logrb(Level.INFO, null, null, null, null); 3627 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 3628 assertTrue(CallVerificationStack.getInstance().empty()); 3629 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 3630 assertNull(r.getMessage()); 3631 assertSame(r.getResourceBundleName(), null); 3632 assertSame(r.getSourceClassName(), null); 3633 assertSame(r.getSourceMethodName(), null); 3634 assertSame(r.getLevel(), Level.INFO); 3635 assertNull(r.getParameters()); 3636 assertSame(r.getThrown(), null); 3637 } 3638 3639 /* 3640 * Test logrb(Level, String, String, String) with null level. 3641 */ 3642 @TestTargetNew( 3643 level = TestLevel.COMPLETE, 3644 notes = "", 3645 method = "logrb", 3646 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class} 3647 ) 3648 public void testLogrb_LevelStringStringString_NullLevel() { 3649 try { 3650 this.sharedLogger.logrb(null, "sourceClass", "sourceMethod", 3651 VALID_RESOURCE_BUNDLE2, 3652 "logrb(Level, String, String, String, String) msg"); 3653 fail("Should throw NullPointerException!"); 3654 } catch (NullPointerException e) { 3655 } 3656 } 3657 3658 /* 3659 * Test logrb(Level, String, String, String, String) with invalid resource 3660 * bundle. 3661 */ 3662 @TestTargetNew( 3663 level = TestLevel.COMPLETE, 3664 notes = "", 3665 method = "logrb", 3666 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class} 3667 ) 3668 public void testLogrb_LevelStringStringString_InvalidRes() { 3669 this.sharedLogger.setLevel(Level.ALL); 3670 this.sharedLogger.logrb(Level.ALL, "sourceClass", "sourceMethod", 3671 INVALID_RESOURCE_BUNDLE, 3672 "logrb(Level, String, String, String, String) msg"); 3673 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 3674 assertTrue(CallVerificationStack.getInstance().empty()); 3675 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 3676 assertEquals(r.getMessage(), 3677 "logrb(Level, String, String, String, String) msg"); 3678 assertSame(r.getResourceBundleName(), INVALID_RESOURCE_BUNDLE); 3679 assertSame(r.getResourceBundle(), null); 3680 assertSame(r.getSourceClassName(), "sourceClass"); 3681 assertSame(r.getSourceMethodName(), "sourceMethod"); 3682 assertSame(r.getLevel(), Level.ALL); 3683 assertNull(r.getParameters()); 3684 assertSame(r.getThrown(), null); 3685 } 3686 3687 /* 3688 * Test logrb(Level, String, String, String, String, Object) with normal 3689 * values. 3690 */ 3691 @TestTargetNew( 3692 level = TestLevel.COMPLETE, 3693 notes = "", 3694 method = "logrb", 3695 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.Object.class} 3696 ) 3697 public void testLogrb_LevelStringStringStringObject_Normal() { 3698 Object param = new Object(); 3699 this.sharedLogger.setLevel(Level.INFO); 3700 this.sharedLogger.logrb(Level.INFO, "sourceClass", "sourceMethod", 3701 VALID_RESOURCE_BUNDLE2, 3702 "logrb(Level, String, String, String, String, Object) msg", 3703 param); 3704 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 3705 assertTrue(CallVerificationStack.getInstance().empty()); 3706 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 3707 assertEquals(r.getMessage(), 3708 "logrb(Level, String, String, String, String, Object) msg"); 3709 assertSame(r.getResourceBundleName(), VALID_RESOURCE_BUNDLE2); 3710 assertSame(r.getSourceClassName(), "sourceClass"); 3711 assertSame(r.getSourceMethodName(), "sourceMethod"); 3712 assertSame(r.getLevel(), Level.INFO); 3713 assertEquals(1, r.getParameters().length); 3714 assertSame(param, r.getParameters()[0]); 3715 assertSame(r.getThrown(), null); 3716 3717 this.sharedLogger.logrb(Level.CONFIG, "sourceClass", "sourceMethod", 3718 VALID_RESOURCE_BUNDLE2, 3719 "logrb(Level, String, String, String, String, Object) msg", 3720 param); 3721 assertTrue(CallVerificationStack.getInstance().empty()); 3722 this.sharedLogger.setLevel(Level.OFF); 3723 this.sharedLogger.logrb(Level.OFF, "sourceClass", "sourceMethod", 3724 VALID_RESOURCE_BUNDLE2, 3725 "logrb(Level, String, String, String, String, Object) msg", 3726 param); 3727 assertTrue(CallVerificationStack.getInstance().empty()); 3728 } 3729 3730 /* 3731 * Test logrb(Level, String, String, String, String, Object) with null 3732 * message and object. 3733 */ 3734 @TestTargetNew( 3735 level = TestLevel.COMPLETE, 3736 notes = "", 3737 method = "logrb", 3738 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.Object.class} 3739 ) 3740 public void testLogrb_LevelStringStringStringObject_NullMsgObj() { 3741 this.sharedLogger.setLevel(Level.INFO); 3742 this.sharedLogger.logrb(Level.INFO, null, null, null, null, 3743 (Object) null); 3744 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 3745 assertTrue(CallVerificationStack.getInstance().empty()); 3746 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 3747 assertNull(r.getMessage()); 3748 assertSame(r.getResourceBundleName(), null); 3749 assertSame(r.getSourceClassName(), null); 3750 assertSame(r.getSourceMethodName(), null); 3751 assertSame(r.getLevel(), Level.INFO); 3752 assertEquals(1, r.getParameters().length); 3753 assertNull(r.getParameters()[0]); 3754 assertSame(r.getThrown(), null); 3755 } 3756 3757 /** 3758 * java.util.logging.Logger#logrb(Level, String, String, String, String, 3759 * Object) 3760 */ 3761 @TestTargetNew( 3762 level = TestLevel.PARTIAL_COMPLETE, 3763 notes = "Regression test.", 3764 method = "logrb", 3765 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class} 3766 ) 3767 public void test_logrbLLevel_LString_LString_LObject_Security() 3768 throws Exception { 3769 // regression test for Harmony-1290 3770 SecurityManager originalSecurityManager = System.getSecurityManager(); 3771 try { 3772 System.setSecurityManager(new MockSecurityManager()); 3773 Logger.global.logrb(Level.OFF, null, null, "abc", "def"); 3774 } finally { 3775 System.setSecurityManager(originalSecurityManager); 3776 } 3777 } 3778 3779 /* 3780 * Test logrb(Level, String, String, String, String, Object) with null 3781 * level. 3782 */ 3783 @TestTargetNew( 3784 level = TestLevel.COMPLETE, 3785 notes = "", 3786 method = "logrb", 3787 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.Object.class} 3788 ) 3789 public void testLogrb_LevelStringStringStringObject_NullLevel() { 3790 // this.sharedLogger.setLevel(Level.OFF); 3791 try { 3792 this.sharedLogger.logrb(null, "sourceClass", "sourceMethod", 3793 VALID_RESOURCE_BUNDLE2, 3794 "logrb(Level, String, String, String, String, Object) msg", 3795 new Object()); 3796 fail("Should throw NullPointerException!"); 3797 } catch (NullPointerException e) { 3798 } 3799 } 3800 3801 /* 3802 * Test logrb(Level, String, String, String, String, Object) with invalid 3803 * resource bundle. 3804 */ 3805 @TestTargetNew( 3806 level = TestLevel.COMPLETE, 3807 notes = "", 3808 method = "logrb", 3809 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.Object.class} 3810 ) 3811 public void testLogrb_LevelStringStringStringObject_InvalidRes() { 3812 Object param = new Object(); 3813 this.sharedLogger.setLevel(Level.ALL); 3814 this.sharedLogger.logrb(Level.ALL, "sourceClass", "sourceMethod", 3815 INVALID_RESOURCE_BUNDLE, 3816 "logrb(Level, String, String, String, String) msg", param); 3817 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 3818 assertTrue(CallVerificationStack.getInstance().empty()); 3819 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 3820 assertEquals(r.getMessage(), 3821 "logrb(Level, String, String, String, String) msg"); 3822 assertSame(r.getResourceBundleName(), INVALID_RESOURCE_BUNDLE); 3823 assertSame(r.getResourceBundle(), null); 3824 assertSame(r.getSourceClassName(), "sourceClass"); 3825 assertSame(r.getSourceMethodName(), "sourceMethod"); 3826 assertSame(r.getLevel(), Level.ALL); 3827 assertEquals(1, r.getParameters().length); 3828 assertSame(param, r.getParameters()[0]); 3829 assertSame(r.getThrown(), null); 3830 } 3831 3832 /* 3833 * Test logrb(Level, String, String, String, String, Object[]) with normal 3834 * values. 3835 */ 3836 @TestTargetNew( 3837 level = TestLevel.COMPLETE, 3838 notes = "", 3839 method = "logrb", 3840 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.Object[].class} 3841 ) 3842 public void testLogrb_LevelStringStringStringObjects_Normal() { 3843 Object[] params = new Object[2]; 3844 params[0] = new Object(); 3845 params[1] = new Object(); 3846 this.sharedLogger.setLevel(Level.INFO); 3847 this.sharedLogger.logrb(Level.INFO, "sourceClass", "sourceMethod", 3848 VALID_RESOURCE_BUNDLE2, 3849 "logrb(Level, String, String, String, String, Object[]) msg", 3850 params); 3851 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 3852 assertTrue(CallVerificationStack.getInstance().empty()); 3853 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 3854 assertEquals(r.getMessage(), 3855 "logrb(Level, String, String, String, String, Object[]) msg"); 3856 assertSame(r.getResourceBundleName(), VALID_RESOURCE_BUNDLE2); 3857 assertSame(r.getSourceClassName(), "sourceClass"); 3858 assertSame(r.getSourceMethodName(), "sourceMethod"); 3859 assertSame(r.getLevel(), Level.INFO); 3860 assertEquals(2, r.getParameters().length); 3861 assertSame(params[0], r.getParameters()[0]); 3862 assertSame(params[1], r.getParameters()[1]); 3863 assertSame(r.getThrown(), null); 3864 3865 this.sharedLogger.logrb(Level.CONFIG, "sourceClass", "sourceMethod", 3866 VALID_RESOURCE_BUNDLE2, 3867 "logrb(Level, String, String, String, String, Object[]) msg", 3868 params); 3869 assertTrue(CallVerificationStack.getInstance().empty()); 3870 this.sharedLogger.setLevel(Level.OFF); 3871 this.sharedLogger.logrb(Level.OFF, "sourceClass", "sourceMethod", 3872 VALID_RESOURCE_BUNDLE2, 3873 "logrb(Level, String, String, String, String, Object[]) msg", 3874 params); 3875 assertTrue(CallVerificationStack.getInstance().empty()); 3876 } 3877 3878 /* 3879 * Test logrb(Level, String, String, String, String, Object[]) with null 3880 * message and object. 3881 */ 3882 @TestTargetNew( 3883 level = TestLevel.COMPLETE, 3884 notes = "", 3885 method = "logrb", 3886 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.Object[].class} 3887 ) 3888 public void testLogrb_LevelStringStringStringObjects_NullMsgObj() { 3889 this.sharedLogger.setLevel(Level.INFO); 3890 this.sharedLogger.logrb(Level.INFO, null, null, null, null, 3891 (Object[]) null); 3892 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 3893 assertTrue(CallVerificationStack.getInstance().empty()); 3894 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 3895 assertNull(r.getMessage()); 3896 assertSame(r.getResourceBundleName(), null); 3897 assertSame(r.getSourceClassName(), null); 3898 assertSame(r.getSourceMethodName(), null); 3899 assertSame(r.getLevel(), Level.INFO); 3900 assertNull(r.getParameters()); 3901 assertSame(r.getThrown(), null); 3902 } 3903 3904 /* 3905 * Test logrb(Level, String, String, String, String, Object[]) with null 3906 * level. 3907 */ 3908 @TestTargetNew( 3909 level = TestLevel.COMPLETE, 3910 notes = "", 3911 method = "logrb", 3912 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.Object[].class} 3913 ) 3914 public void testLogrb_LevelStringStringStringObjects_NullLevel() { 3915 try { 3916 this.sharedLogger.logrb( 3917 null, 3918 "sourceClass", 3919 "sourceMethod", 3920 VALID_RESOURCE_BUNDLE2, 3921 "logrb(Level, String, String, String, String, Object[]) msg", 3922 new Object[0]); 3923 fail("Should throw NullPointerException!"); 3924 } catch (NullPointerException e) { 3925 } 3926 } 3927 3928 /* 3929 * Test logrb(Level, String, String, String, String, Object[]) with invalid 3930 * resource bundle. 3931 */ 3932 @TestTargetNew( 3933 level = TestLevel.COMPLETE, 3934 notes = "", 3935 method = "logrb", 3936 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.Object[].class} 3937 ) 3938 public void testLogrb_LevelStringStringStringObjects_InvalidRes() { 3939 Object[] params = new Object[2]; 3940 params[0] = new Object(); 3941 params[1] = new Object(); 3942 this.sharedLogger.setLevel(Level.ALL); 3943 this.sharedLogger.logrb(Level.ALL, "sourceClass", "sourceMethod", 3944 INVALID_RESOURCE_BUNDLE, 3945 "logrb(Level, String, String, String, String) msg", params); 3946 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 3947 assertTrue(CallVerificationStack.getInstance().empty()); 3948 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 3949 assertEquals(r.getMessage(), 3950 "logrb(Level, String, String, String, String) msg"); 3951 assertSame(r.getResourceBundleName(), INVALID_RESOURCE_BUNDLE); 3952 assertSame(r.getResourceBundle(), null); 3953 assertSame(r.getSourceClassName(), "sourceClass"); 3954 assertSame(r.getSourceMethodName(), "sourceMethod"); 3955 assertSame(r.getLevel(), Level.ALL); 3956 assertEquals(2, r.getParameters().length); 3957 assertSame(params[0], r.getParameters()[0]); 3958 assertSame(params[1], r.getParameters()[1]); 3959 assertSame(r.getThrown(), null); 3960 } 3961 3962 /* 3963 * Test logrb(Level, String, String, String, String, Throwable) with normal 3964 * values. 3965 */ 3966 @TestTargetNew( 3967 level = TestLevel.COMPLETE, 3968 notes = "", 3969 method = "logrb", 3970 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.Throwable.class} 3971 ) 3972 public void testLogrb_LevelStringStringStringThrowable_Normal() { 3973 Throwable t = new Throwable(); 3974 this.sharedLogger.setLevel(Level.INFO); 3975 this.sharedLogger.logrb(Level.parse("1611"), "sourceClass", 3976 "sourceMethod", VALID_RESOURCE_BUNDLE2, 3977 "logrb(Level, String, String, String, String, Throwable) msg", 3978 t); 3979 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 3980 assertTrue(CallVerificationStack.getInstance().empty()); 3981 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 3982 assertEquals(r.getMessage(), 3983 "logrb(Level, String, String, String, String, Throwable) msg"); 3984 assertSame(r.getResourceBundleName(), VALID_RESOURCE_BUNDLE2); 3985 assertSame(r.getSourceClassName(), "sourceClass"); 3986 assertSame(r.getSourceMethodName(), "sourceMethod"); 3987 assertSame(r.getLevel(), Level.parse("1611")); 3988 assertNull(r.getParameters()); 3989 assertSame(r.getThrown(), t); 3990 assertNull(Level.parse("1611").getResourceBundleName()); 3991 3992 this.sharedLogger.logrb(Level.CONFIG, "sourceClass", "sourceMethod", 3993 VALID_RESOURCE_BUNDLE2, 3994 "logrb(Level, String, String, String, String, Throwable) msg", 3995 t); 3996 assertTrue(CallVerificationStack.getInstance().empty()); 3997 this.sharedLogger.setLevel(Level.OFF); 3998 this.sharedLogger.logrb(Level.OFF, "sourceClass", "sourceMethod", 3999 VALID_RESOURCE_BUNDLE2, 4000 "logrb(Level, String, String, String, String, Throwable) msg", 4001 t); 4002 assertTrue(CallVerificationStack.getInstance().empty()); 4003 } 4004 4005 /* 4006 * Test logrb(Level, String, String, String, String, Throwable) with null 4007 * message and throwable. 4008 */ 4009 @TestTargetNew( 4010 level = TestLevel.COMPLETE, 4011 notes = "", 4012 method = "logrb", 4013 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.Throwable.class} 4014 ) 4015 public void testLogrb_LevelStringTStringStringhrowable_NullMsgObj() { 4016 this.sharedLogger.setLevel(Level.INFO); 4017 this.sharedLogger.logrb(Level.INFO, null, null, null, null, 4018 (Throwable) null); 4019 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 4020 assertTrue(CallVerificationStack.getInstance().empty()); 4021 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 4022 assertNull(r.getMessage()); 4023 assertSame(r.getResourceBundleName(), null); 4024 assertSame(r.getSourceClassName(), null); 4025 assertSame(r.getSourceMethodName(), null); 4026 assertSame(r.getLevel(), Level.INFO); 4027 assertNull(r.getParameters()); 4028 assertSame(r.getThrown(), null); 4029 } 4030 4031 /* 4032 * Test logrb(Level, String, String, String, String, Throwable) with null 4033 * level. 4034 */ 4035 @TestTargetNew( 4036 level = TestLevel.COMPLETE, 4037 notes = "", 4038 method = "logrb", 4039 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.Throwable.class} 4040 ) 4041 public void testLogrb_LevelStringStringStringThrowable_NullLevel() { 4042 // this.sharedLogger.setLevel(Level.OFF); 4043 try { 4044 this.sharedLogger.logrb( 4045 null, 4046 "sourceClass", 4047 "sourceMethod", 4048 VALID_RESOURCE_BUNDLE2, 4049 "log(Level, String, String, String, String, Throwable) msg", 4050 new Throwable()); 4051 fail("Should throw NullPointerException!"); 4052 } catch (NullPointerException e) { 4053 } 4054 } 4055 4056 /* 4057 * Test logrb(Level, String, String, String, String, Throwable) with invalid 4058 * resource bundle. 4059 */ 4060 @TestTargetNew( 4061 level = TestLevel.COMPLETE, 4062 notes = "", 4063 method = "logrb", 4064 args = {java.util.logging.Level.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.Throwable.class} 4065 ) 4066 public void testLogrb_LevelStringStringStringThrowable_InvalidRes() { 4067 Throwable t = new Throwable(); 4068 this.sharedLogger.setLevel(Level.ALL); 4069 this.sharedLogger.logrb(Level.ALL, "sourceClass", "sourceMethod", 4070 INVALID_RESOURCE_BUNDLE, 4071 "logrb(Level, String, String, String, String) msg", t); 4072 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 4073 assertTrue(CallVerificationStack.getInstance().empty()); 4074 assertSame(r.getLoggerName(), this.sharedLogger.getName()); 4075 assertEquals(r.getMessage(), 4076 "logrb(Level, String, String, String, String) msg"); 4077 assertSame(r.getResourceBundleName(), INVALID_RESOURCE_BUNDLE); 4078 assertSame(r.getResourceBundle(), null); 4079 assertSame(r.getSourceClassName(), "sourceClass"); 4080 assertSame(r.getSourceMethodName(), "sourceMethod"); 4081 assertSame(r.getLevel(), Level.ALL); 4082 assertNull(r.getParameters()); 4083 assertSame(r.getThrown(), t); 4084 } 4085 4086 /* 4087 * Test log(LogRecord) for a normal log record. Meanwhile the logger has an 4088 * appropriate level, no filter, no parent. 4089 */ 4090 @TestTargetNew( 4091 level = TestLevel.COMPLETE, 4092 notes = "", 4093 method = "log", 4094 args = {java.util.logging.LogRecord.class} 4095 ) 4096 public void testLog_LogRecord_AppropriateLevelNoFilterNoParent() { 4097 LogRecord r = new LogRecord(Level.INFO, 4098 "testLog_LogRecord_AppropriateLevelNoFilterNoParent"); 4099 4100 this.sharedLogger.setLevel(Level.INFO); 4101 this.sharedLogger.log(r); 4102 4103 assertSame(r, CallVerificationStack.getInstance().pop()); 4104 assertTrue(CallVerificationStack.getInstance().empty()); 4105 assertSame(r.getLoggerName(), null); 4106 assertEquals(r.getMessage(), 4107 "testLog_LogRecord_AppropriateLevelNoFilterNoParent"); 4108 assertSame(r.getResourceBundleName(), null); 4109 assertSame(r.getSourceClassName(), null); 4110 assertSame(r.getSourceMethodName(), null); 4111 assertSame(r.getLevel(), Level.INFO); 4112 assertNull(r.getParameters()); 4113 assertSame(r.getThrown(), null); 4114 } 4115 4116 /* 4117 * Test log(LogRecord) with null log record. 4118 */ 4119 @TestTargetNew( 4120 level = TestLevel.COMPLETE, 4121 notes = "", 4122 method = "log", 4123 args = {java.util.logging.LogRecord.class} 4124 ) 4125 public void testLog_LogRecord_Null() { 4126 this.sharedLogger.setLevel(Level.INFO); 4127 try { 4128 this.sharedLogger.log(null); 4129 fail("Should throw NullPointerException!"); 4130 } catch (NullPointerException e) { 4131 } 4132 } 4133 4134 /* 4135 * Test log(LogRecord) for a normal log record. Meanwhile the logger has an 4136 * inappropriate level, no filter, no parent. 4137 */ 4138 @TestTargetNew( 4139 level = TestLevel.COMPLETE, 4140 notes = "", 4141 method = "log", 4142 args = {java.util.logging.LogRecord.class} 4143 ) 4144 public void testLog_LogRecord_InppropriateLevelNoFilterNoParent() { 4145 LogRecord r = new LogRecord(Level.INFO, 4146 "testLog_LogRecord_InppropriateLevelNoFilterNoParent"); 4147 4148 this.sharedLogger.setLevel(Level.WARNING); 4149 this.sharedLogger.log(r); 4150 assertTrue(CallVerificationStack.getInstance().empty()); 4151 4152 r.setLevel(Level.OFF); 4153 this.sharedLogger.setLevel(Level.OFF); 4154 this.sharedLogger.log(r); 4155 assertTrue(CallVerificationStack.getInstance().empty()); 4156 } 4157 4158 /* 4159 * Test log(LogRecord) for a normal log record. Meanwhile the logger has an 4160 * appropriate level, a filter that accepts the fed log record, no parent. 4161 */ 4162 @TestTargetNew( 4163 level = TestLevel.COMPLETE, 4164 notes = "", 4165 method = "log", 4166 args = {java.util.logging.LogRecord.class} 4167 ) 4168 public void testLog_LogRecord_AppropriateLevelTrueFilterNoParent() { 4169 LogRecord r = new LogRecord(Level.INFO, 4170 "testLog_LogRecord_AppropriateLevelTrueFilterNoParent"); 4171 4172 this.sharedLogger.setLevel(Level.INFO); 4173 this.sharedLogger.setFilter(new MockTrueFilter()); 4174 this.sharedLogger.log(r); 4175 4176 // pop twice, one pushed by mock handler, one by true mock filter 4177 assertSame(r, CallVerificationStack.getInstance().pop()); 4178 assertSame(r, CallVerificationStack.getInstance().pop()); 4179 assertTrue(CallVerificationStack.getInstance().empty()); 4180 4181 assertSame(r.getLoggerName(), null); 4182 assertEquals(r.getMessage(), 4183 "testLog_LogRecord_AppropriateLevelTrueFilterNoParent"); 4184 assertSame(r.getResourceBundleName(), null); 4185 assertSame(r.getSourceClassName(), null); 4186 assertSame(r.getSourceMethodName(), null); 4187 assertSame(r.getLevel(), Level.INFO); 4188 assertNull(r.getParameters()); 4189 assertSame(r.getThrown(), null); 4190 } 4191 4192 /* 4193 * Test log(LogRecord) for a normal log record. Meanwhile the logger has an 4194 * appropriate level, a filter that rejects the fed log record, no parent. 4195 */ 4196 @TestTargetNew( 4197 level = TestLevel.COMPLETE, 4198 notes = "", 4199 method = "log", 4200 args = {java.util.logging.LogRecord.class} 4201 ) 4202 public void testLog_LogRecord_AppropriateLevelFalseFilterNoParent() { 4203 LogRecord r = new LogRecord(Level.INFO, 4204 "testLog_LogRecord_AppropriateLevelFalseFilterNoParent"); 4205 4206 this.sharedLogger.setLevel(Level.INFO); 4207 this.sharedLogger.setFilter(new MockFilter()); 4208 this.sharedLogger.log(r); 4209 4210 // pop only once, pushed by mock filter 4211 assertSame(r, CallVerificationStack.getInstance().pop()); 4212 assertTrue(CallVerificationStack.getInstance().empty()); 4213 4214 assertSame(r.getLoggerName(), null); 4215 assertEquals(r.getMessage(), 4216 "testLog_LogRecord_AppropriateLevelFalseFilterNoParent"); 4217 assertSame(r.getResourceBundleName(), null); 4218 assertSame(r.getSourceClassName(), null); 4219 assertSame(r.getSourceMethodName(), null); 4220 assertSame(r.getLevel(), Level.INFO); 4221 assertNull(r.getParameters()); 4222 assertSame(r.getThrown(), null); 4223 } 4224 4225 /* 4226 * Test that the parent's handler is notified for a new log record when 4227 * getUseParentHandlers() is true. 4228 */ 4229 @TestTargetNew( 4230 level = TestLevel.COMPLETE, 4231 notes = "", 4232 method = "log", 4233 args = {java.util.logging.LogRecord.class} 4234 ) 4235 public void testLog_ParentInformed() { 4236 Logger child = new MockLogger("childLogger", VALID_RESOURCE_BUNDLE); 4237 Logger parent = new MockParentLogger("parentLogger", 4238 VALID_RESOURCE_BUNDLE2); 4239 4240 child.setParent(parent); 4241 child.setLevel(Level.INFO); 4242 parent.setLevel(Level.INFO); 4243 parent.addHandler(new MockHandler()); 4244 LogRecord r = new LogRecord(Level.INFO, "testLog_ParentInformed"); 4245 child.log(r); 4246 assertTrue(child.getUseParentHandlers()); 4247 // pop only once, pushed by the parent logger's handler, not by the 4248 // parent itself! 4249 assertSame(r, CallVerificationStack.getInstance().pop()); 4250 assertTrue(CallVerificationStack.getInstance().empty()); 4251 assertSame(r.getLoggerName(), null); 4252 assertEquals(r.getMessage(), "testLog_ParentInformed"); 4253 assertSame(r.getResourceBundleName(), null); 4254 assertSame(r.getSourceClassName(), null); 4255 assertSame(r.getSourceMethodName(), null); 4256 assertSame(r.getLevel(), Level.INFO); 4257 assertNull(r.getParameters()); 4258 assertSame(r.getThrown(), null); 4259 4260 // set the child logger to disabling level 4261 child.setLevel(Level.SEVERE); 4262 child.log(r); 4263 assertTrue(CallVerificationStack.getInstance().empty()); 4264 4265 // set the parent logger to disabling level 4266 child.setLevel(Level.INFO); 4267 parent.setLevel(Level.SEVERE); 4268 child.log(r); 4269 assertSame(r, CallVerificationStack.getInstance().pop()); 4270 assertTrue(CallVerificationStack.getInstance().empty()); 4271 4272 // set the child logger off 4273 child.setLevel(Level.OFF); 4274 child.log(r); 4275 assertTrue(CallVerificationStack.getInstance().empty()); 4276 4277 // set the record off 4278 r.setLevel(Level.OFF); 4279 child.log(r); 4280 assertTrue(CallVerificationStack.getInstance().empty()); 4281 } 4282 4283 /* 4284 * Test that the ancestor's handler is notified for a new log record when 4285 * getUseParentHandlers() is true. 4286 */ 4287 @TestTargetNew( 4288 level = TestLevel.COMPLETE, 4289 notes = "", 4290 method = "log", 4291 args = {java.util.logging.LogRecord.class} 4292 ) 4293 public void testLog_AncestorInformed() { 4294 Logger child = new MockLogger("childLogger", VALID_RESOURCE_BUNDLE); 4295 Logger parent = new MockParentLogger("parentLogger", 4296 VALID_RESOURCE_BUNDLE2); 4297 Logger ancestor = new MockParentLogger("ancestorLogger", 4298 VALID_RESOURCE_BUNDLE3); 4299 4300 child.setParent(parent); 4301 parent.setParent(ancestor); 4302 child.setLevel(Level.INFO); 4303 parent.setLevel(Level.INFO); 4304 ancestor.setLevel(Level.OFF); 4305 ancestor.addHandler(new MockHandler()); 4306 LogRecord r = new LogRecord(Level.INFO, "testLog_AncestorInformed"); 4307 child.log(r); 4308 assertTrue(child.getUseParentHandlers()); 4309 assertTrue(parent.getUseParentHandlers()); 4310 // pop only once, pushed by the ancestor's logger's handler, not by the 4311 // parent itself! 4312 assertSame(r, CallVerificationStack.getInstance().pop()); 4313 assertTrue(CallVerificationStack.getInstance().empty()); 4314 4315 // set parent's level to a disabling one 4316 parent.setLevel(Level.WARNING); 4317 child.log(r); 4318 assertSame(r, CallVerificationStack.getInstance().pop()); 4319 assertTrue(CallVerificationStack.getInstance().empty()); 4320 4321 // set child's level to a disabling one 4322 parent.setLevel(Level.INFO); 4323 child.setLevel(Level.WARNING); 4324 child.log(r); 4325 assertTrue(CallVerificationStack.getInstance().empty()); 4326 4327 // set parent's useParentHandlers to false 4328 parent.setLevel(Level.INFO); 4329 child.setLevel(Level.INFO); 4330 parent.setUseParentHandlers(false); 4331 child.log(r); 4332 assertTrue(CallVerificationStack.getInstance().empty()); 4333 } 4334 4335 /* 4336 * Test that the parent's handler is notified for a new log record when 4337 * getUseParentHandlers() is false. 4338 */ 4339 @TestTargetNew( 4340 level = TestLevel.COMPLETE, 4341 notes = "", 4342 method = "log", 4343 args = {java.util.logging.LogRecord.class} 4344 ) 4345 public void testLog_ParentNotInformed() { 4346 Logger child = new MockLogger("childLogger", VALID_RESOURCE_BUNDLE); 4347 Logger parent = new MockParentLogger("parentLogger", 4348 VALID_RESOURCE_BUNDLE2); 4349 4350 child.setParent(parent); 4351 child.setLevel(Level.INFO); 4352 parent.setLevel(Level.INFO); 4353 parent.addHandler(new MockHandler()); 4354 LogRecord r = new LogRecord(Level.INFO, "testLog_ParentInformed"); 4355 child.setUseParentHandlers(false); 4356 child.log(r); 4357 assertFalse(child.getUseParentHandlers()); 4358 assertTrue(CallVerificationStack.getInstance().empty()); 4359 } 4360 4361 /* 4362 * Test that a logger with null level and no parent. Defaulted to 4363 * Level.INFO. 4364 */ 4365 @TestTargetNew( 4366 level = TestLevel.COMPLETE, 4367 notes = "", 4368 method = "log", 4369 args = {java.util.logging.LogRecord.class} 4370 ) 4371 public void testLog_NullLevelNoParent() { 4372 LogRecord r = new LogRecord(Level.INFO, "testLog_NullLevelNoParent"); 4373 assertNull(this.sharedLogger.getLevel()); 4374 assertNull(this.sharedLogger.getParent()); 4375 assertTrue(this.sharedLogger.isLoggable(r.getLevel())); 4376 this.sharedLogger.log(r); 4377 assertSame(r, CallVerificationStack.getInstance().pop()); 4378 assertTrue(CallVerificationStack.getInstance().empty()); 4379 assertNull(this.sharedLogger.getLevel()); 4380 4381 r.setLevel(Level.WARNING); 4382 assertTrue(this.sharedLogger.isLoggable(r.getLevel())); 4383 this.sharedLogger.log(r); 4384 assertSame(r, CallVerificationStack.getInstance().pop()); 4385 assertTrue(CallVerificationStack.getInstance().empty()); 4386 4387 r.setLevel(Level.CONFIG); 4388 this.sharedLogger.log(r); 4389 assertFalse(this.sharedLogger.isLoggable(r.getLevel())); 4390 assertTrue(CallVerificationStack.getInstance().empty()); 4391 } 4392 4393 /* 4394 * Test that a logger inherits its parent level when its level is null. 4395 */ 4396 @TestTargetNew( 4397 level = TestLevel.COMPLETE, 4398 notes = "", 4399 method = "log", 4400 args = {java.util.logging.LogRecord.class} 4401 ) 4402 public void testLog_NullLevelHasParent() { 4403 Logger child = new MockLogger("childLogger", VALID_RESOURCE_BUNDLE); 4404 Logger parent = new MockLogger("parentLogger", VALID_RESOURCE_BUNDLE2); 4405 child.addHandler(new MockHandler()); 4406 child.setParent(parent); 4407 parent.setLevel(Level.FINER); 4408 4409 assertNull(child.getLevel()); 4410 4411 LogRecord r = new LogRecord(Level.FINE, "testLog_NullLevelHasParent"); 4412 child.log(r); 4413 assertTrue(child.isLoggable(r.getLevel())); 4414 // pop only once, pushed by the child logger's handler 4415 assertSame(r, CallVerificationStack.getInstance().pop()); 4416 assertTrue(CallVerificationStack.getInstance().empty()); 4417 4418 assertSame(r.getLoggerName(), null); 4419 assertEquals(r.getMessage(), "testLog_NullLevelHasParent"); 4420 assertSame(r.getResourceBundleName(), null); 4421 assertSame(r.getSourceClassName(), null); 4422 assertSame(r.getSourceMethodName(), null); 4423 assertSame(r.getLevel(), Level.FINE); 4424 assertNull(r.getParameters()); 4425 assertSame(r.getThrown(), null); 4426 assertNull(child.getLevel()); 4427 4428 // set the parent logger to disabling level 4429 parent.setLevel(Level.CONFIG); 4430 assertFalse(child.isLoggable(r.getLevel())); 4431 child.log(r); 4432 assertTrue(CallVerificationStack.getInstance().empty()); 4433 assertNull(child.getLevel()); 4434 4435 // test ancestor 4436 Logger ancestor = new MockLogger("ancestorLogger", 4437 VALID_RESOURCE_BUNDLE3); 4438 parent.setParent(ancestor); 4439 parent.setLevel(null); 4440 parent.setUseParentHandlers(false); 4441 ancestor.setLevel(Level.ALL); 4442 child.log(r); 4443 assertTrue(child.isLoggable(r.getLevel())); 4444 assertSame(r, CallVerificationStack.getInstance().pop()); 4445 assertTrue(CallVerificationStack.getInstance().empty()); 4446 assertNull(child.getLevel()); 4447 assertNull(parent.getLevel()); 4448 } 4449 4450 /* 4451 * Test that a logger with null resource bundle and no parent. Defaulted to 4452 * null. 4453 */ 4454 @TestTargetNew( 4455 level = TestLevel.COMPLETE, 4456 notes = "", 4457 method = "log", 4458 args = {java.util.logging.LogRecord.class} 4459 ) 4460 public void testLog_NullResNoParent() { 4461 Logger log = new MockLogger("Logger", null); 4462 log.addHandler(new MockHandler()); 4463 log.setLevel(Level.FINE); 4464 4465 assertNull(log.getResourceBundle()); 4466 assertNull(log.getResourceBundleName()); 4467 assertNull(log.getParent()); 4468 log.log(Level.INFO, "testLog_NullResNoParent"); 4469 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 4470 assertTrue(CallVerificationStack.getInstance().empty()); 4471 assertNull(log.getResourceBundle()); 4472 assertNull(log.getResourceBundleName()); 4473 assertNull(r.getResourceBundle()); 4474 assertNull(r.getResourceBundleName()); 4475 } 4476 4477 /* 4478 * Test that a logger inherits its parent resource bundle when its resource 4479 * bundle is null. 4480 */ 4481 @TestTargetNew( 4482 level = TestLevel.COMPLETE, 4483 notes = "", 4484 method = "log", 4485 args = {java.util.logging.LogRecord.class} 4486 ) 4487 public void testLog_NullResHasParent() { 4488 Logger child = new MockLogger("childLogger", null); 4489 Logger parent = new MockLogger("parentLogger", VALID_RESOURCE_BUNDLE2); 4490 child.addHandler(new MockHandler()); 4491 child.setParent(parent); 4492 parent.setLevel(Level.FINER); 4493 assertNull(child.getResourceBundle()); 4494 assertNull(child.getResourceBundleName()); 4495 4496 child.log(Level.FINE, "testLog_NullResHasParent"); 4497 // pop only once, pushed by the child logger's handler 4498 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 4499 assertTrue(CallVerificationStack.getInstance().empty()); 4500 4501 assertSame(r.getLoggerName(), "childLogger"); 4502 assertEquals(r.getMessage(), "testLog_NullResHasParent"); 4503 assertSame(r.getResourceBundleName(), VALID_RESOURCE_BUNDLE2); 4504 assertSame(r.getSourceClassName(), null); 4505 assertSame(r.getSourceMethodName(), null); 4506 assertSame(r.getLevel(), Level.FINE); 4507 assertNull(r.getParameters()); 4508 assertSame(r.getThrown(), null); 4509 assertNull(child.getResourceBundle()); 4510 assertNull(child.getResourceBundleName()); 4511 } 4512 4513 /* 4514 * Test that a logger inherits its ancestor's resource bundle when its 4515 * resource bundle and its parent's resource bundle are both null. 4516 */ 4517 @TestTargetNew( 4518 level = TestLevel.COMPLETE, 4519 notes = "", 4520 method = "log", 4521 args = {java.util.logging.LogRecord.class} 4522 ) 4523 public void testLog_NullResHasAncestor() { 4524 Logger child = new MockLogger("childLogger", null); 4525 Logger parent = new MockLogger("parentLogger", null); 4526 Logger ancestor = new MockLogger("ancestorLogger", 4527 VALID_RESOURCE_BUNDLE3); 4528 child.addHandler(new MockHandler()); 4529 child.setParent(parent); 4530 parent.setParent(ancestor); 4531 parent.setLevel(Level.FINER); 4532 assertNull(child.getResourceBundle()); 4533 assertNull(child.getResourceBundleName()); 4534 4535 child.log(Level.FINE, "testLog_NullResHasAncestor"); 4536 // pop only once, pushed by the child logger's handler 4537 LogRecord r = (LogRecord) CallVerificationStack.getInstance().pop(); 4538 assertTrue(CallVerificationStack.getInstance().empty()); 4539 4540 assertSame(r.getLoggerName(), "childLogger"); 4541 assertEquals(r.getMessage(), "testLog_NullResHasAncestor"); 4542 assertSame(r.getResourceBundleName(), VALID_RESOURCE_BUNDLE3); 4543 assertSame(r.getSourceClassName(), null); 4544 assertSame(r.getSourceMethodName(), null); 4545 assertSame(r.getLevel(), Level.FINE); 4546 assertNull(r.getParameters()); 4547 assertSame(r.getThrown(), null); 4548 assertNull(child.getResourceBundle()); 4549 assertNull(child.getResourceBundleName()); 4550 } 4551 4552 /* 4553 * Test when one handler throws an exception. 4554 */ 4555 @TestTargetNew( 4556 level = TestLevel.COMPLETE, 4557 notes = "", 4558 method = "log", 4559 args = {java.util.logging.LogRecord.class} 4560 ) 4561 public void testLog_ExceptionalHandler() { 4562 MockLogger l = new MockLogger("testLog_ExceptionalHandler", null); 4563 l.addHandler(new MockExceptionalHandler()); 4564 l.addHandler(new MockHandler()); 4565 try { 4566 l.severe("testLog_ExceptionalHandler"); 4567 fail("Should throw RuntimeException!"); 4568 } catch (RuntimeException e) { 4569 } 4570 assertTrue(CallVerificationStack.getInstance().empty()); 4571 } 4572 4573 /* 4574 * Test whether privileged code is used to load resource bundles. 4575 */ 4576 @TestTargetNew( 4577 level = TestLevel.COMPLETE, 4578 notes = "", 4579 method = "getAnonymousLogger", 4580 args = {java.lang.String.class} 4581 ) 4582 public void testLoadResourceBundle() { 4583 // 4584 SecurityManager oldMan = System.getSecurityManager(); 4585 System.setSecurityManager(new MockNoLoadingClassSecurityManager()); 4586 try { 4587 Logger.getAnonymousLogger(VALID_RESOURCE_BUNDLE); 4588 } finally { 4589 System.setSecurityManager(oldMan); 4590 } 4591 } 4592 4593 4594 /** 4595 * java.util.logging.Logger#logrb(Level, String, String, String, String, 4596 * Object) 4597 */ 4598 @TestTargetNew( 4599 level = TestLevel.PARTIAL_COMPLETE, 4600 notes = "", 4601 method = "getLogger", 4602 args = {java.lang.String.class} 4603 ) 4604 public void test_init_logger() throws Exception { 4605 Properties p = new Properties(); 4606 p.put("testGetLogger_Normal_ANewLogger2.level", "ALL"); 4607 LogManager.getLogManager().readConfiguration( 4608 EnvironmentHelper.PropertiesToInputStream(p)); 4609 4610 assertNull(LogManager.getLogManager().getLogger( 4611 "testGetLogger_Normal_ANewLogger2")); 4612 SecurityManager originalSecurityManager = System.getSecurityManager(); 4613 try { 4614 Logger logger = Logger 4615 .getLogger("testGetLogger_Normal_ANewLogger2"); 4616 System.setSecurityManager(new MockSecurityManager()); 4617 try { 4618 logger.setLevel(Level.ALL); 4619 fail("should throw SecurityException"); 4620 } catch (SecurityException e) { 4621 // expected 4622 } 4623 try { 4624 logger.setParent(Logger.getLogger("")); 4625 fail("should throw SecurityException"); 4626 } catch (SecurityException e) { 4627 // expected 4628 } 4629 } finally { 4630 System.setSecurityManager(originalSecurityManager); 4631 } 4632 } 4633 4634 /* 4635 * test initHandler 4636 */ 4637 @TestTargetNew( 4638 level = TestLevel.PARTIAL_COMPLETE, 4639 notes = "", 4640 method = "initHandler", 4641 args = {} 4642 ) 4643 @KnownFailure("This test doesn't load its resources properly") 4644 public void test_initHandler() throws Exception { 4645 File logProps = new File(LOGGING_CONFIG_FILE); 4646 LogManager lm = LogManager.getLogManager(); 4647 lm.readConfiguration(new FileInputStream(logProps)); 4648 4649 Logger log = Logger.getLogger(""); 4650 // can log properly 4651 Handler[] handlers = log.getHandlers(); 4652 assertEquals(2, handlers.length); 4653 } 4654 4655 4656 /* 4657 * A mock logger, used to test the protected constructors and fields. 4658 */ 4659 public static class MockLogger extends Logger { 4660 4661 public MockLogger(String name, String resourceBundleName) { 4662 super(name, resourceBundleName); 4663 } 4664 } 4665 4666 /* 4667 * A mock logger, used to test inheritance. 4668 */ 4669 public static class MockParentLogger extends Logger { 4670 4671 public MockParentLogger(String name, String resourceBundleName) { 4672 super(name, resourceBundleName); 4673 } 4674 4675 public void log(LogRecord record) { 4676 CallVerificationStack.getInstance().push(record); 4677 super.log(record); 4678 } 4679 4680 } 4681 4682 /* 4683 * A mock handler, used to validate the expected method is called with the 4684 * expected parameters. 4685 */ 4686 public static class MockHandler extends Handler { 4687 4688 public void close() { 4689 // System.out.println("close!"); 4690 } 4691 4692 public void flush() { 4693 // System.out.println("flushed!"); 4694 } 4695 4696 public void publish(LogRecord record) { 4697 // System.out.println("publish!"); 4698 CallVerificationStack.getInstance().push(record); 4699 } 4700 } 4701 4702 /* 4703 * A mock handler that throws an exception when publishing a log record. 4704 */ 4705 public static class MockExceptionalHandler extends Handler { 4706 4707 public void close() { 4708 // System.out.println("close!"); 4709 } 4710 4711 public void flush() { 4712 // System.out.println("flushed!"); 4713 } 4714 4715 public void publish(LogRecord record) { 4716 // System.out.println("publish!"); 4717 throw new RuntimeException(); 4718 } 4719 } 4720 4721 /* 4722 * Used to grant all permissions except logging control. 4723 */ 4724 public static class MockSecurityManager extends SecurityManager { 4725 4726 public MockSecurityManager() { 4727 } 4728 4729 public void checkPermission(Permission perm) { 4730 // grant all permissions except logging control 4731 if (perm instanceof LoggingPermission) { 4732 throw new SecurityException(); 4733 } 4734 } 4735 4736 public void checkPermission(Permission perm, Object context) { 4737 // grant all permissions except logging control 4738 if (perm instanceof LoggingPermission) { 4739 throw new SecurityException(); 4740 } 4741 } 4742 } 4743 4744 /* 4745 * Used to grant all permissions except getting class loader. 4746 */ 4747 public static class MockNoLoadingClassSecurityManager extends 4748 SecurityManager { 4749 4750 public MockNoLoadingClassSecurityManager() { 4751 } 4752 4753 public void checkPermission(Permission perm) { 4754 // grant all permissions except getting class loader 4755 if (perm instanceof RuntimePermission) { 4756 if ("getClassLoader".equals(perm.getName())) { 4757 throw new SecurityException(); 4758 } 4759 } 4760 } 4761 4762 public void checkPermission(Permission perm, Object context) { 4763 // grant all permissions except logging control 4764 if (perm instanceof LoggingPermission) { 4765 throw new SecurityException(); 4766 } 4767 } 4768 } 4769 4770 4771 /* 4772 * A mock filter, always return false. 4773 */ 4774 public static class MockFilter implements Filter { 4775 4776 public boolean isLoggable(LogRecord record) { 4777 CallVerificationStack.getInstance().push(record); 4778 return false; 4779 } 4780 } 4781 4782 /* 4783 * A mock filter, always return true. 4784 */ 4785 public static class MockTrueFilter implements Filter { 4786 4787 public boolean isLoggable(LogRecord record) { 4788 CallVerificationStack.getInstance().push(record); 4789 return true; 4790 } 4791 } 4792} 4793