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