/*
 * 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) {}
    }
}