/*
 * Copyright 2001-2004 The Apache Software Foundation.
 * 
 * Licensed 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 org.apache.commons.logging.log4j;


import java.io.InputStream;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Properties;

import junit.framework.Test;
import junit.framework.TestSuite;

import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
import org.apache.log4j.spi.LoggingEvent;


/**
 * <p>TestCase for Log4J logging when running on a system with Log4J present,
 * so that Log4J should be selected and an appropriate
 * logger configured per the configuration properties.</p>
 *
 * @author Craig R. McClanahan
 * @version $Revision: 1.9 $ $Date: 2004/05/19 20:59:56 $
 */

public class CustomConfigTestCase extends DefaultConfigTestCase {


    // ----------------------------------------------------------- Constructors


    /**
     * <p>Construct a new instance of this test case.</p>
     *
     * @param name Name of the test case
     */
    public CustomConfigTestCase(String name) {
        super(name);
    }


    // ----------------------------------------------------- Instance Variables


    /**
     * <p>The <code>Appender</code> we are utilizing.</p>
     */
    protected TestAppender appender = null;


    /**
     * <p>The <code>Logger</code> we are utilizing.</p>
     */
    protected Logger logger = null;


    /**
     * <p>The message levels that should have been logged.</p>
     */
    protected Level testLevels[] =
    { Level.INFO, Level.WARN, Level.ERROR, Level.FATAL };


    /**
     * <p>The message strings that should have been logged.</p>
     */
    protected String testMessages[] =
    { "info", "warn", "error", "fatal" };


    // ------------------------------------------- JUnit Infrastructure Methods


    /**
     * Set up instance variables required by this test case.
     */
    public void setUp() throws Exception {
        setUpAppender
            ("org/apache/commons/logging/log4j/CustomConfig.properties");
        setUpLogger("TestLogger");
        setUpFactory();
        setUpLog("TestLogger");
    }


    /**
     * Return the tests included in this test suite.
     */
    public static Test suite() {
        return (new TestSuite(CustomConfigTestCase.class));
    }

    /**
     * Tear down instance variables required by this test case.
     */
    public void tearDown() {
        super.tearDown();
        Logger.getRootLogger().removeAppender(appender);
        appender = null;
        logger = null;
    }


    // ----------------------------------------------------------- Test Methods


    // Test logging message strings with exceptions
    public void testExceptionMessages() throws Exception {

        logExceptionMessages();
        checkLoggingEvents(true);

    }


    // Test logging plain message strings
    public void testPlainMessages() throws Exception {

        logPlainMessages();
        checkLoggingEvents(false);

    }


    // Test pristine Appender instance
    public void testPristineAppender() {

        assertNotNull("Appender exists", appender);

    }


    // Test pristine Log instance
    public void testPristineLog() {

        super.testPristineLog();

    }


    // Test pristine Logger instance
    public void testPristineLogger() {

        assertNotNull("Logger exists", logger);
        assertEquals("Logger level", Level.INFO, logger.getEffectiveLevel());
        assertEquals("Logger name", "TestLogger", logger.getName());

    }


    // Test Serializability of Log instance
    public void testSerializable() throws Exception {

        super.testSerializable();
        testExceptionMessages();

    }


    // -------------------------------------------------------- Support Methods


    // Check the log instance
    protected void checkLog() {

        assertNotNull("Log exists", log);
        assertEquals("Log class",
                     "org.apache.commons.logging.impl.Log4JLogger",
                     log.getClass().getName());

        // Assert which logging levels have been enabled
        assertTrue(log.isErrorEnabled());
        assertTrue(log.isWarnEnabled());
        assertTrue(log.isInfoEnabled());
        assertTrue(!log.isDebugEnabled());
        assertTrue(!log.isTraceEnabled());

    }


    // Check the recorded messages
    protected void checkLoggingEvents(boolean thrown) {
        Iterator events = appender.events();
        for (int i = 0; i < testMessages.length; i++) {
            assertTrue("Logged event " + i + " exists",events.hasNext());
            LoggingEvent event = (LoggingEvent) events.next();
            assertEquals("LoggingEvent level",
                         testLevels[i], event.getLevel());
            assertEquals("LoggingEvent message",
                         testMessages[i], event.getMessage());
            /* Does not appear to be logged correctly?
            assertEquals("LoggingEvent class",
                         this.getClass().getName(),
                         event.getLocationInformation().getClassName());
            */
            /* Does not appear to be logged correctly?
            if (thrown) {
                assertEquals("LoggingEvent method",
                             "logExceptionMessages",
                             event.getLocationInformation().getMethodName());
            } else {
                assertEquals("LoggingEvent method",
                             "logPlainMessages",
                             event.getLocationInformation().getMethodName());
            }
            */
            if (thrown) {
                assertNotNull("LoggingEvent thrown",
                              event.getThrowableInformation().getThrowableStrRep());
                assertTrue("LoggingEvent thrown type",
                           event.getThrowableInformation()
                                .getThrowableStrRep()[0]
                                    .indexOf("IndexOutOfBoundsException")>0);
            } else {
                assertNull("LoggingEvent thrown",
                           event.getThrowableInformation());
            }
        }
        assertTrue(!events.hasNext());
        appender.flush();
    }


    // Log the messages with exceptions
    protected void logExceptionMessages() {
        Throwable t = new IndexOutOfBoundsException();
        log.trace("trace", t); // Should not actually get logged
        log.debug("debug", t); // Should not actually get logged
        log.info("info", t);
        log.warn("warn", t);
        log.error("error", t);
        log.fatal("fatal", t);
    }


    // Log the plain messages
    protected void logPlainMessages() {
        log.trace("trace"); // Should not actually get logged
        log.debug("debug"); // Should not actually get logged
        log.info("info");
        log.warn("warn");
        log.error("error");
        log.fatal("fatal");
    }


    // Set up our custom Appender
    protected void setUpAppender(String config) throws Exception {
        Properties props = new Properties();
        InputStream is =
            this.getClass().getClassLoader().getResourceAsStream(config);
        props.load(is);
        is.close();
        PropertyConfigurator.configure(props);
        Enumeration appenders = Logger.getRootLogger().getAllAppenders();
        appender = (TestAppender) appenders.nextElement();
    }


    // Set up our custom Logger
    protected void setUpLogger(String name) throws Exception {
        logger = Logger.getLogger(name);
    }


}