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.io.IOException;
21import java.io.OutputStream;
22import java.io.PrintStream;
23import java.io.StringWriter;
24import java.security.Permission;
25import java.util.Properties;
26import java.util.logging.Filter;
27import java.util.logging.Formatter;
28import java.util.logging.Handler;
29import java.util.logging.Level;
30import java.util.logging.LogManager;
31import java.util.logging.LogRecord;
32import java.util.logging.LoggingPermission;
33import java.util.logging.MemoryHandler;
34import java.util.logging.SimpleFormatter;
35
36import junit.framework.TestCase;
37
38import org.apache.harmony.logging.tests.java.util.logging.HandlerTest.NullOutputStream;
39import org.apache.harmony.logging.tests.java.util.logging.util.EnvironmentHelper;
40
41/**
42 *
43 */
44public class MemoryHandlerTest extends TestCase {
45
46    final static LogManager manager = LogManager.getLogManager();
47
48    final static Properties props = new Properties();
49
50    final static String baseClassName = MemoryHandlerTest.class.getName();
51
52    final static StringWriter writer = new StringWriter();
53
54    private final PrintStream err = System.err;
55
56    private OutputStream errSubstituteStream = null;
57
58    MemoryHandler handler;
59
60    Handler target = new MockHandler();
61
62    /*
63      * @see TestCase#setUp()
64      */
65    protected void setUp() throws Exception {
66        super.setUp();
67        manager.reset();
68        initProps();
69        manager.readConfiguration(EnvironmentHelper
70                .PropertiesToInputStream(props));
71        handler = new MemoryHandler();
72        errSubstituteStream = new NullOutputStream();
73        System.setErr(new PrintStream(errSubstituteStream));
74    }
75
76    /**
77     *
78     */
79    private void initProps() {
80        props.put("java.util.logging.MemoryHandler.level", "FINE");
81        props.put("java.util.logging.MemoryHandler.filter", baseClassName
82                + "$MockFilter");
83        props.put("java.util.logging.MemoryHandler.size", "2");
84        props.put("java.util.logging.MemoryHandler.push", "WARNING");
85        props.put("java.util.logging.MemoryHandler.target", baseClassName
86                + "$MockHandler");
87        props.put("java.util.logging.MemoryHandler.formatter", baseClassName
88                + "$MockFormatter");
89    }
90
91    /*
92      * @see TestCase#tearDown()
93      */
94    protected void tearDown() throws Exception {
95        super.tearDown();
96        manager.readConfiguration();
97        props.clear();
98        System.setErr(err);
99    }
100
101    public void testClose() {
102        Filter filter = handler.getFilter();
103        Formatter formatter = handler.getFormatter();
104        writer.getBuffer().setLength(0);
105        handler.close();
106        assertEquals(writer.toString(), "close");
107        assertEquals(handler.getFilter(), filter);
108        assertEquals(handler.getFormatter(), formatter);
109        assertNull(handler.getEncoding());
110        assertNotNull(handler.getErrorManager());
111        assertEquals(handler.getLevel(), Level.OFF);
112        assertEquals(handler.getPushLevel(), Level.WARNING);
113        assertFalse(handler.isLoggable(new LogRecord(Level.SEVERE, "test")));
114    }
115
116    public void testFlush() {
117        Filter filter = handler.getFilter();
118        Formatter formatter = handler.getFormatter();
119        writer.getBuffer().setLength(0);
120        handler.flush();
121        assertEquals(writer.toString(), "flush");
122        assertEquals(handler.getFilter(), filter);
123        assertEquals(handler.getFormatter(), formatter);
124        assertNull(handler.getEncoding());
125        assertNotNull(handler.getErrorManager());
126        assertEquals(handler.getLevel(), Level.FINE);
127        assertEquals(handler.getPushLevel(), Level.WARNING);
128        assertTrue(handler.isLoggable(new LogRecord(Level.SEVERE, "test")));
129    }
130
131    public void testIsLoggable() {
132        try {
133            handler.isLoggable(null);
134            fail("should throw NullPointerException");
135        } catch (NullPointerException e) {
136            // expected
137        }
138        LogRecord record = new LogRecord(Level.FINER, "MSG1");
139        assertFalse(handler.isLoggable(record));
140
141        record = new LogRecord(Level.FINE, "MSG2");
142        assertTrue(handler.isLoggable(record));
143
144        record = new LogRecord(Level.CONFIG, "MSG3");
145        assertTrue(handler.isLoggable(record));
146
147        record = new LogRecord(Level.CONFIG, "false");
148        assertFalse(handler.isLoggable(record));
149
150        handler.setFilter(null);
151        record = new LogRecord(Level.CONFIG, "false");
152        assertTrue(handler.isLoggable(record));
153    }
154
155    /*
156      * Class under test for void MemoryHandler()
157      */
158    public void testMemoryHandler() {
159        assertTrue(handler.getFilter() instanceof MockFilter);
160        assertTrue(handler.getFormatter() instanceof MockFormatter);
161        assertNull(handler.getEncoding());
162        assertNotNull(handler.getErrorManager());
163        assertEquals(handler.getLevel(), Level.FINE);
164        assertEquals(handler.getPushLevel(), Level.WARNING);
165    }
166
167    public void testMemoryHandlerInvalidProps() throws IOException {
168        // null target
169        try {
170            props.remove("java.util.logging.MemoryHandler.target");
171            manager.readConfiguration(EnvironmentHelper
172                    .PropertiesToInputStream(props));
173            handler = new MemoryHandler();
174            fail("should throw RuntimeException: target must be set");
175        } catch (RuntimeException e) {
176        }
177
178        // invalid target
179        try {
180            props.put("java.util.logging.MemoryHandler.target", "badname");
181            manager.readConfiguration(EnvironmentHelper
182                    .PropertiesToInputStream(props));
183            handler = new MemoryHandler();
184            fail("should throw RuntimeException: target must be valid");
185        } catch (RuntimeException e) {
186        }
187
188        // invalid formatter
189        initProps();
190        props.put("java.util.logging.MemoryHandler.formatter", "badname");
191        manager.readConfiguration(EnvironmentHelper
192                .PropertiesToInputStream(props));
193        handler = new MemoryHandler();
194        assertTrue(handler.getFormatter() instanceof SimpleFormatter);
195
196        // invalid level
197        initProps();
198        props.put("java.util.logging.MemoryHandler.level", "badname");
199        manager.readConfiguration(EnvironmentHelper
200                .PropertiesToInputStream(props));
201        handler = new MemoryHandler();
202        assertEquals(handler.getLevel(), Level.ALL);
203
204        // invalid pushlevel
205        initProps();
206        props.put("java.util.logging.MemoryHandler.push", "badname");
207        manager.readConfiguration(EnvironmentHelper
208                .PropertiesToInputStream(props));
209        handler = new MemoryHandler();
210        assertEquals(handler.getPushLevel(), Level.SEVERE);
211
212        // invalid filter
213        initProps();
214        props.put("java.util.logging.MemoryHandler.filter", "badname");
215        manager.readConfiguration(EnvironmentHelper
216                .PropertiesToInputStream(props));
217        handler = new MemoryHandler();
218        assertNull(handler.getFilter());
219
220        // invalid size
221        initProps();
222        props.put("java.util.logging.MemoryHandler.size", "-1");
223        manager.readConfiguration(EnvironmentHelper
224                .PropertiesToInputStream(props));
225        handler = new MemoryHandler();
226        initProps();
227        props.put("java.util.logging.MemoryHandler.size", "badsize");
228        manager.readConfiguration(EnvironmentHelper
229                .PropertiesToInputStream(props));
230        handler = new MemoryHandler();
231
232    }
233
234    public void testMemoryHandlerDefaultValue() throws SecurityException,
235            IOException {
236        props.clear();
237        props.put("java.util.logging.MemoryHandler.target", baseClassName
238                + "$MockHandler");
239
240        manager.readConfiguration(EnvironmentHelper
241                .PropertiesToInputStream(props));
242        handler = new MemoryHandler();
243        assertNull(handler.getFilter());
244        assertTrue(handler.getFormatter() instanceof SimpleFormatter);
245        assertNull(handler.getEncoding());
246        assertNotNull(handler.getErrorManager());
247        assertEquals(handler.getLevel(), Level.ALL);
248        assertEquals(handler.getPushLevel(), Level.SEVERE);
249    }
250
251    /*
252      * Class under test for void MemoryHandler(Handler, int, Level)
253      */
254    public void testMemoryHandlerHandlerintLevel() {
255        handler = new MemoryHandler(target, 2, Level.FINEST);
256        assertTrue(handler.getFilter() instanceof MockFilter);
257        assertTrue(handler.getFormatter() instanceof MockFormatter);
258        assertNull(handler.getEncoding());
259        assertNotNull(handler.getErrorManager());
260        assertEquals(handler.getLevel(), Level.FINE);
261        assertEquals(handler.getPushLevel(), Level.FINEST);
262        assertNull(target.getFormatter());
263
264        try {
265            handler = new MemoryHandler(null, 2, Level.FINEST);
266            fail("should throw NullPointerException");
267        } catch (NullPointerException e) {
268        }
269        try {
270            handler = new MemoryHandler(target, 2, null);
271            fail("should throw NullPointerException");
272        } catch (NullPointerException e) {
273        }
274        try {
275            handler = new MemoryHandler(target, 0, Level.FINEST);
276            fail("should throw IllegalArgumentException");
277        } catch (IllegalArgumentException e) {
278        }
279        try {
280            handler = new MemoryHandler(target, -1, Level.FINEST);
281            fail("should throw IllegalArgumentException");
282        } catch (IllegalArgumentException e) {
283        }
284
285    }
286
287    public void testGetPushLevel() {
288        try {
289            handler.setPushLevel(null);
290            fail("should throw NullPointerException");
291        } catch (NullPointerException e) {
292        }
293        handler.setPushLevel(Level.parse("123"));
294        assertEquals(handler.getPushLevel(), Level.parse("123"));
295    }
296
297    public void testSetPushLevel() {
298        // change push level don't trigger push action
299        writer.getBuffer().setLength(0);
300        LogRecord lr = new LogRecord(Level.CONFIG, "lr");
301        assertTrue(handler.isLoggable(lr));
302        handler.publish(lr);
303        assertEquals(writer.toString(), "");
304        // assertEquals(writer.toString(), "flush");
305        writer.getBuffer().setLength(0);
306        handler.setPushLevel(Level.FINE);
307        assertEquals(writer.toString(), "");
308        handler.publish(lr);
309        assertEquals(writer.toString(), lr.getMessage() + lr.getMessage());
310    }
311
312    public void testPushPublic() {
313        writer.getBuffer().setLength(0);
314        // loggable but don't trig push
315        handler.publish(new LogRecord(Level.CONFIG, "MSG1"));
316        assertEquals("", writer.toString());
317        // trig push
318        handler.publish(new LogRecord(Level.SEVERE, "MSG2"));
319        assertEquals(writer.toString(), "MSG1MSG2");
320        writer.getBuffer().setLength(0);
321
322        // regression test for Harmony-1292
323        handler.publish(new LogRecord(Level.WARNING, "MSG"));
324        assertEquals("MSG", writer.toString());
325
326        writer.getBuffer().setLength(0);
327        // push nothing
328        handler.push();
329        assertEquals("", writer.toString());
330        // loggable but not push
331        handler.publish(new LogRecord(Level.CONFIG, "MSG3"));
332        assertEquals("", writer.toString());
333        // not loggable
334        handler.publish(new LogRecord(Level.FINEST, "MSG4"));
335        assertEquals("", writer.toString());
336        // loggable but not push
337        handler.publish(new LogRecord(Level.CONFIG, "MSG5"));
338        assertEquals("", writer.toString());
339        // not loggable
340        handler.publish(new LogRecord(Level.FINER, "MSG6"));
341        assertEquals("", writer.toString());
342        // not loggable
343        handler.publish(new LogRecord(Level.FINER, "false"));
344        assertEquals("", writer.toString());
345        // loggable but not push
346        handler.publish(new LogRecord(Level.CONFIG, "MSG8"));
347        assertEquals("", writer.toString());
348        // push all
349        handler.push();
350        assertEquals(writer.toString(), "MSG5MSG8");
351        writer.getBuffer().setLength(0);
352        handler.push();
353        assertEquals("", writer.toString());
354    }
355
356    /*
357      * mock classes
358      */
359    public static class MockFilter implements Filter {
360        public boolean isLoggable(LogRecord record) {
361            return !record.getMessage().equals("false");
362        }
363    }
364
365    public static class MockHandler extends Handler {
366        public void close() {
367            writer.write("close");
368        }
369
370        public void flush() {
371            writer.write("flush");
372        }
373
374        public void publish(LogRecord record) {
375            writer.write(record.getMessage());
376        }
377
378    }
379
380    public static class MockFormatter extends Formatter {
381        public String format(LogRecord r) {
382            return r.getMessage();
383        }
384    }
385
386}
387