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 libcore.java.util.logging;
19
20import java.util.Locale;
21import java.util.MissingResourceException;
22import java.util.ResourceBundle;
23import java.util.logging.Filter;
24import java.util.logging.Handler;
25import java.util.logging.Level;
26import java.util.logging.LogManager;
27import java.util.logging.LogRecord;
28import java.util.logging.Logger;
29import junit.framework.TestCase;
30
31public class OldLoggerTest extends TestCase {
32    private final static String VALID_RESOURCE_BUNDLE = "bundles/java/util/logging/res";
33    private final static String INVALID_RESOURCE_BUNDLE = "impossible_not_existing";
34    private final static String VALID_KEY = "LOGGERTEST";
35    private final static String VALID_VALUE = "Test_ZH_CN";
36
37    @Override protected void setUp() throws Exception {
38        super.setUp();
39        LogManager.getLogManager().reset();
40        Locale.setDefault(new Locale("zh", "CN"));
41    }
42
43    @Override protected void tearDown() throws Exception {
44        LogManager.getLogManager().reset();
45        super.tearDown();
46    }
47
48    public void testGetLoggerWithRes_InvalidResourceBundle() {
49        assertNull(LogManager.getLogManager().getLogger(
50                "testMissingResourceException"));
51
52        assertNotNull(LogManager.getLogManager().getLogger(""));
53        // The root logger always exists TODO
54        try {
55            Logger.getLogger("", INVALID_RESOURCE_BUNDLE);
56            fail();
57        } catch (MissingResourceException expected) {
58        }
59    }
60
61    public void testGlobalLogger() {
62        assertNull(Logger.global.getFilter());
63        assertEquals(0, Logger.global.getHandlers().length);
64        assertNull(Logger.global.getLevel());
65        assertEquals("global", Logger.global.getName());
66        assertNull(Logger.global.getParent().getParent());
67        assertNull(Logger.global.getResourceBundle());
68        assertNull(Logger.global.getResourceBundleName());
69        assertTrue(Logger.global.getUseParentHandlers());
70        assertSame(Logger.global, Logger.getLogger("global"));
71        assertSame(Logger.global, LogManager.getLogManager().getLogger("global"));
72        assertSame(Logger.global, Logger.getGlobal());
73    }
74
75    public void testConstructor_Normal() {
76        MockLogger mlog = new MockLogger("myname", VALID_RESOURCE_BUNDLE);
77        assertNull(mlog.getFilter());
78        assertEquals(0, mlog.getHandlers().length);
79        assertNull(mlog.getLevel());
80        assertEquals("myname", mlog.getName());
81        assertNull(mlog.getParent());
82        ResourceBundle rb = mlog.getResourceBundle();
83        assertEquals(VALID_VALUE, rb.getString(VALID_KEY));
84        assertEquals(mlog.getResourceBundleName(), VALID_RESOURCE_BUNDLE);
85        assertTrue(mlog.getUseParentHandlers());
86    }
87
88    public void testConstructor_Null() {
89        MockLogger mlog = new MockLogger(null, null);
90        assertNull(mlog.getFilter());
91        assertEquals(0, mlog.getHandlers().length);
92        assertNull(mlog.getLevel());
93        assertNull(mlog.getName());
94        assertNull(mlog.getParent());
95        assertNull(mlog.getResourceBundle());
96        assertNull(mlog.getResourceBundleName());
97        assertTrue(mlog.getUseParentHandlers());
98    }
99
100    public void testConstructor_InvalidName() {
101        MockLogger mlog = new MockLogger("...#$%%^&&()-_+=!@~./,[]{};:'\\\"?|",
102                null);
103        assertEquals("...#$%%^&&()-_+=!@~./,[]{};:'\\\"?|", mlog.getName());
104    }
105
106    /*
107     * Test constructor with empty name.
108     */
109    public void testConstructor_EmptyName() {
110        MockLogger mlog = new MockLogger("", null);
111        assertEquals("", mlog.getName());
112    }
113
114    public void testConstructor_InvalidResourceBundle() {
115        try {
116            new MockLogger("testConstructor_InvalidResourceBundle",
117                    INVALID_RESOURCE_BUNDLE);
118            fail("Should throw MissingResourceException!");
119        } catch (MissingResourceException expected) {
120        }
121    }
122
123    public void testGetLogger_Null() {
124        try {
125            Logger.getLogger(null, null);
126            fail("Should throw NullPointerException!");
127        } catch (NullPointerException expected) {
128        }
129    }
130
131    public void testGetLogger_WithParent() {
132        assertNull(LogManager.getLogManager().getLogger(
133                "testGetLogger_WithParent_ParentLogger"));
134
135        // get root of hierarchy
136        Logger root = Logger.getLogger("");
137        // create the parent logger
138        Logger pLog = Logger.getLogger("testGetLogger_WithParent_ParentLogger",
139                VALID_RESOURCE_BUNDLE);
140        pLog.setLevel(Level.CONFIG);
141        pLog.addHandler(new MockHandler());
142        pLog.setFilter(new MockFilter());
143        pLog.setUseParentHandlers(false);
144        // check root parent
145        assertEquals("testGetLogger_WithParent_ParentLogger", pLog.getName());
146        assertSame(pLog.getParent(), root);
147
148        // child part
149        assertNull(LogManager.getLogManager().getLogger(
150                "testGetLogger_WithParent_ParentLogger.child"));
151        // create the child logger
152        Logger child = Logger
153                .getLogger("testGetLogger_WithParent_ParentLogger.child");
154        assertNull(child.getFilter());
155        assertEquals(0, child.getHandlers().length);
156        assertNull(child.getLevel());
157        assertEquals("testGetLogger_WithParent_ParentLogger.child", child
158                .getName());
159        assertSame(child.getParent(), pLog);
160        assertNull(child.getResourceBundle());
161        assertNull(child.getResourceBundleName());
162        assertTrue(child.getUseParentHandlers());
163
164        // create not valid child
165        Logger notChild = Logger
166                .getLogger("testGetLogger_WithParent_ParentLogger1.child");
167        assertNull(notChild.getFilter());
168        assertEquals(0, notChild.getHandlers().length);
169        assertNull(notChild.getLevel());
170        assertEquals("testGetLogger_WithParent_ParentLogger1.child", notChild
171                .getName());
172        assertNotSame(notChild.getParent(), pLog);
173        assertNull(notChild.getResourceBundle());
174        assertNull(notChild.getResourceBundleName());
175        assertTrue(notChild.getUseParentHandlers());
176        // verify two level root.parent
177        assertEquals("testGetLogger_WithParent_ParentLogger.child", child
178                .getName());
179        assertSame(child.getParent().getParent(), root);
180
181
182        // create three level child
183        Logger childOfChild = Logger
184                .getLogger("testGetLogger_WithParent_ParentLogger.child.child");
185        assertNull(childOfChild.getFilter());
186        assertEquals(0, childOfChild.getHandlers().length);
187        assertSame(child.getParent().getParent(), root);
188        assertNull(childOfChild.getLevel());
189        assertEquals("testGetLogger_WithParent_ParentLogger.child.child",
190                childOfChild.getName());
191
192        assertSame(childOfChild.getParent(), child);
193        assertSame(childOfChild.getParent().getParent(), pLog);
194        assertSame(childOfChild.getParent().getParent().getParent(), root);
195        assertNull(childOfChild.getResourceBundle());
196        assertNull(childOfChild.getResourceBundleName());
197        assertTrue(childOfChild.getUseParentHandlers());
198
199        // abnormal case : lookup to root parent in a hierarchy without a logger
200        // parent created between
201        assertEquals("testGetLogger_WithParent_ParentLogger1.child", notChild
202                .getName());
203        assertSame(child.getParent().getParent(), root);
204        assertNotSame(child.getParent(), root);
205
206        // abnormal cases
207        assertNotSame(root.getParent(), root);
208        Logger twoDot = Logger.getLogger("..");
209        assertSame(twoDot.getParent(), root);
210
211    }
212
213    public static class MockLogger extends Logger {
214        public MockLogger(String name, String resourceBundleName) {
215            super(name, resourceBundleName);
216        }
217    }
218
219    public static class MockHandler extends Handler {
220        public void close() {}
221        public void flush() {}
222        public void publish(LogRecord record) {}
223    }
224
225    public static class MockFilter implements Filter {
226        public boolean isLoggable(LogRecord record) {
227            return false;
228        }
229    }
230}
231