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