/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package libcore.java.util.logging;
import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.Properties;
import java.util.logging.Handler;
import java.util.logging.LogManager;
import java.util.logging.LogRecord;
import java.util.logging.Logger;
import junit.framework.TestCase;
public class OldLogManagerTest extends TestCase {
private static final String FOO = "LogManagerTestFoo";
LogManager mockManager;
LogManager manager = LogManager.getLogManager();
Properties props;
private static String className = OldLogManagerTest.class.getName();
static Handler handler = null;
@Override protected void setUp() throws Exception {
super.setUp();
mockManager = new MockLogManager();
handler = new MockHandler();
props = new Properties();
props.put("handlers", className + "$MockHandler " + className + "$MockHandler");
props.put("java.util.logging.FileHandler.pattern", "%h/java%u.log");
props.put("java.util.logging.FileHandler.limit", "50000");
props.put("java.util.logging.FileHandler.count", "5");
props.put("java.util.logging.FileHandler.formatter", "java.util.logging.XMLFormatter");
props.put(".level", "FINE");
props.put("java.util.logging.ConsoleHandler.level", "OFF");
props.put("java.util.logging.ConsoleHandler.formatter","java.util.logging.SimpleFormatter");
props.put("LogManagerTestFoo.handlers", "java.util.logging.ConsoleHandler");
props.put("LogManagerTestFoo.level", "WARNING");
}
/*
* @see TestCase#tearDown()
*/
@Override
protected void tearDown() throws Exception {
super.tearDown();
handler = null;
}
public void testLogManager() {
class TestLogManager extends LogManager {
public TestLogManager() {
super();
}
}
TestLogManager tlm = new TestLogManager();
assertNotNull(tlm.toString());
}
/*
* test for method public Logger getLogger(String name)
* test covers following use cases:
* case 1: test default and valid value
* case 2: test throw NullPointerException
* case 3: test bad name
* case 4: check correct tested value
*/
public void testGetLogger() throws Exception {
// case 1: test default and valid value
Logger log = new MockLogger(FOO, null);
Logger foo = mockManager.getLogger(FOO);
assertNull("Logger should be null", foo);
assertTrue("logger wasn't registered successfully", mockManager.addLogger(log));
foo = mockManager.getLogger(FOO);
assertSame("two loggers not refer to the same object", foo, log);
assertNull("logger foo should not haven parent", foo.getParent());
// case 2: test throw NullPointerException
try {
mockManager.getLogger(null);
fail("get null should throw NullPointerException");
} catch (NullPointerException e) {
}
// case 3: test bad name
assertNull("LogManager should not have logger with unforeseen name", mockManager
.getLogger("bad name"));
// case 4: check correct tested value
Enumeration<String> enumar = mockManager.getLoggerNames();
int i = 0;
while (enumar.hasMoreElements()) {
String name = enumar.nextElement();
i++;
assertEquals("name logger should be equal to foreseen name", FOO, name);
}
assertEquals("LogManager should contain one element", 1, i);
}
/*
* test for method public Logger getLogger(String name)
*/
public void testGetLogger_duplicateName() throws Exception {
// test duplicate name
// add logger with duplicate name has no effect
mockManager.reset();
Logger foo2 = new MockLogger(FOO, null);
Logger foo3 = new MockLogger(FOO, null);
mockManager.addLogger(foo2);
assertSame(foo2, mockManager.getLogger(FOO));
mockManager.addLogger(foo3);
assertSame(foo2, mockManager.getLogger(FOO));
Enumeration<String> enumar2 = mockManager.getLoggerNames();
int i = 0;
while (enumar2.hasMoreElements()) {
enumar2.nextElement();
i++;
}
assertEquals(1, i);
}
/*
* test for method public Logger getLogger(String name)
*/
public void testGetLogger_hierarchy() throws Exception {
// test hierarchy
Logger foo = new MockLogger("testGetLogger_hierachy.foo", null);
// but for non-mock LogManager, foo's parent should be root
assertTrue(manager.addLogger(foo));
assertSame(manager.getLogger(""), manager.getLogger("testGetLogger_hierachy.foo")
.getParent());
}
/*
* test for method public Logger getLogger(String name)
*/
public void testGetLogger_nameSpace() throws Exception {
// test name with space
Logger foo = new MockLogger(FOO, null);
Logger fooBeforeSpace = new MockLogger(FOO + " ", null);
Logger fooAfterSpace = new MockLogger(" " + FOO, null);
Logger fooWithBothSpace = new MockLogger(" " + FOO + " ", null);
assertTrue(mockManager.addLogger(foo));
assertTrue(mockManager.addLogger(fooBeforeSpace));
assertTrue(mockManager.addLogger(fooAfterSpace));
assertTrue(mockManager.addLogger(fooWithBothSpace));
assertSame(foo, mockManager.getLogger(FOO));
assertSame(fooBeforeSpace, mockManager.getLogger(FOO + " "));
assertSame(fooAfterSpace, mockManager.getLogger(" " + FOO));
assertSame(fooWithBothSpace, mockManager.getLogger(" " + FOO + " "));
}
/*
* test for method public void checkAccess() throws SecurityException
*/
public void testCheckAccess() {
try {
manager.checkAccess();
} catch (SecurityException e) {
fail("securityException should not be thrown");
}
}
public void testReadConfiguration() throws SecurityException,
IOException {
MockConfigLogManager lm = new MockConfigLogManager();
assertFalse(lm.isCalled);
lm.readConfiguration();
assertTrue(lm.isCalled);
}
public void testReadConfigurationInputStream_IOException_1parm() throws SecurityException {
try {
mockManager.readConfiguration(new MockInputStream());
fail("should throw IOException");
} catch (IOException expected) {
}
}
public static class MockInputStream extends InputStream {
@Override public int read() throws IOException {
throw new IOException();
}
}
public static class MockLogger extends Logger {
public MockLogger(String name, String rbName) {
super(name, rbName);
}
}
public static class MockLogManager extends LogManager {}
public static class MockConfigLogManager extends LogManager {
public boolean isCalled = false;
public void readConfiguration(InputStream ins) throws IOException {
isCalled = true;
super.readConfiguration(ins);
}
}
public static class MockHandler extends Handler {
static int number = 0;
public MockHandler() {
addNumber();
}
private synchronized void addNumber() {
number++;
}
public void close() {
minusNumber();
}
private synchronized void minusNumber() {
number--;
}
public void flush() {}
public void publish(LogRecord record) {}
}
}