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
20
21import java.io.IOException;
22import java.io.InputStream;
23import java.util.Enumeration;
24import java.util.Properties;
25import java.util.logging.Handler;
26import java.util.logging.LogManager;
27import java.util.logging.LogRecord;
28import java.util.logging.Logger;
29import junit.framework.TestCase;
30
31public class OldLogManagerTest extends TestCase {
32
33    private static final String FOO = "LogManagerTestFoo";
34
35    LogManager mockManager;
36
37    LogManager manager = LogManager.getLogManager();
38
39    Properties props;
40
41    private static String className = OldLogManagerTest.class.getName();
42
43    static Handler handler = null;
44
45    @Override protected void setUp() throws Exception {
46        super.setUp();
47        mockManager = new MockLogManager();
48        handler = new MockHandler();
49        props = new Properties();
50        props.put("handlers", className + "$MockHandler " + className + "$MockHandler");
51        props.put("java.util.logging.FileHandler.pattern", "%h/java%u.log");
52        props.put("java.util.logging.FileHandler.limit", "50000");
53        props.put("java.util.logging.FileHandler.count", "5");
54        props.put("java.util.logging.FileHandler.formatter", "java.util.logging.XMLFormatter");
55        props.put(".level", "FINE");
56        props.put("java.util.logging.ConsoleHandler.level", "OFF");
57        props.put("java.util.logging.ConsoleHandler.formatter","java.util.logging.SimpleFormatter");
58        props.put("LogManagerTestFoo.handlers", "java.util.logging.ConsoleHandler");
59        props.put("LogManagerTestFoo.level", "WARNING");
60    }
61
62
63
64    /*
65     * @see TestCase#tearDown()
66     */
67    @Override
68    protected void tearDown() throws Exception {
69        super.tearDown();
70        handler = null;
71    }
72
73    public void testLogManager() {
74       class TestLogManager extends LogManager {
75           public TestLogManager() {
76               super();
77           }
78       }
79       TestLogManager tlm = new TestLogManager();
80       assertNotNull(tlm.toString());
81    }
82
83    /*
84     * test for method public Logger getLogger(String name)
85     * test covers following use cases:
86     * case 1: test default and valid value
87     * case 2: test throw NullPointerException
88     * case 3: test bad name
89     * case 4: check correct tested value
90     */
91
92    public void testGetLogger() throws Exception {
93
94        // case 1: test default and valid value
95        Logger log = new MockLogger(FOO, null);
96        Logger foo = mockManager.getLogger(FOO);
97        assertNull("Logger should be null", foo);
98        assertTrue("logger wasn't registered successfully", mockManager.addLogger(log));
99        foo = mockManager.getLogger(FOO);
100        assertSame("two loggers not refer to the same object", foo, log);
101        assertNull("logger foo should not haven parent", foo.getParent());
102
103        // case 2: test throw NullPointerException
104        try {
105            mockManager.getLogger(null);
106            fail("get null should throw NullPointerException");
107        } catch (NullPointerException e) {
108        }
109
110        // case 3: test bad name
111        assertNull("LogManager should not have logger with unforeseen name", mockManager
112                .getLogger("bad name"));
113
114        // case 4: check correct tested value
115        Enumeration<String> enumar = mockManager.getLoggerNames();
116        int i = 0;
117        while (enumar.hasMoreElements()) {
118            String name = enumar.nextElement();
119            i++;
120            assertEquals("name logger should be equal to foreseen name", FOO, name);
121        }
122        assertEquals("LogManager should contain one element", 1, i);
123    }
124
125    /*
126     * test for method public Logger getLogger(String name)
127     */
128    public void testGetLogger_duplicateName() throws Exception {
129        // test duplicate name
130        // add logger with duplicate name has no effect
131        mockManager.reset();
132        Logger foo2 = new MockLogger(FOO, null);
133        Logger foo3 = new MockLogger(FOO, null);
134        mockManager.addLogger(foo2);
135        assertSame(foo2, mockManager.getLogger(FOO));
136        mockManager.addLogger(foo3);
137        assertSame(foo2, mockManager.getLogger(FOO));
138
139        Enumeration<String> enumar2 = mockManager.getLoggerNames();
140        int i = 0;
141        while (enumar2.hasMoreElements()) {
142            enumar2.nextElement();
143            i++;
144        }
145        assertEquals(1, i);
146    }
147
148    /*
149     * test for method public Logger getLogger(String name)
150     */
151    public void testGetLogger_hierarchy() throws Exception {
152        // test hierarchy
153        Logger foo = new MockLogger("testGetLogger_hierachy.foo", null);
154        // but for non-mock LogManager, foo's parent should be root
155        assertTrue(manager.addLogger(foo));
156        assertSame(manager.getLogger(""), manager.getLogger("testGetLogger_hierachy.foo")
157                .getParent());
158    }
159
160    /*
161     * test for method public Logger getLogger(String name)
162     */
163    public void testGetLogger_nameSpace() throws Exception {
164        // test name with space
165        Logger foo = new MockLogger(FOO, null);
166        Logger fooBeforeSpace = new MockLogger(FOO + " ", null);
167        Logger fooAfterSpace = new MockLogger(" " + FOO, null);
168        Logger fooWithBothSpace = new MockLogger(" " + FOO + " ", null);
169        assertTrue(mockManager.addLogger(foo));
170        assertTrue(mockManager.addLogger(fooBeforeSpace));
171        assertTrue(mockManager.addLogger(fooAfterSpace));
172        assertTrue(mockManager.addLogger(fooWithBothSpace));
173
174        assertSame(foo, mockManager.getLogger(FOO));
175        assertSame(fooBeforeSpace, mockManager.getLogger(FOO + " "));
176        assertSame(fooAfterSpace, mockManager.getLogger(" " + FOO));
177        assertSame(fooWithBothSpace, mockManager.getLogger(" " + FOO + " "));
178    }
179
180    /*
181     * test for method public void checkAccess() throws SecurityException
182     */
183    public void testCheckAccess() {
184        try {
185            manager.checkAccess();
186        } catch (SecurityException e) {
187            fail("securityException should not be thrown");
188        }
189    }
190
191    public void testReadConfiguration() throws SecurityException,
192            IOException {
193
194        MockConfigLogManager lm = new MockConfigLogManager();
195        assertFalse(lm.isCalled);
196
197        lm.readConfiguration();
198        assertTrue(lm.isCalled);
199    }
200
201    public void testReadConfigurationInputStream_IOException_1parm() throws SecurityException {
202        try {
203            mockManager.readConfiguration(new MockInputStream());
204            fail("should throw IOException");
205        } catch (IOException expected) {
206        }
207    }
208
209    public static class MockInputStream extends InputStream {
210        @Override public int read() throws IOException {
211            throw new IOException();
212        }
213    }
214
215    public static class MockLogger extends Logger {
216        public MockLogger(String name, String rbName) {
217            super(name, rbName);
218        }
219    }
220
221    public static class MockLogManager extends LogManager {}
222
223    public static class MockConfigLogManager extends LogManager {
224        public boolean isCalled = false;
225
226        public void readConfiguration(InputStream ins) throws IOException {
227            isCalled = true;
228            super.readConfiguration(ins);
229        }
230    }
231
232    public static class MockHandler extends Handler {
233        static int number = 0;
234
235        public MockHandler() {
236            addNumber();
237        }
238
239        private synchronized void addNumber() {
240            number++;
241        }
242
243        public void close() {
244            minusNumber();
245        }
246
247        private synchronized void minusNumber() {
248            number--;
249        }
250
251        public void flush() {}
252
253        public void publish(LogRecord record) {}
254    }
255}
256