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