/*
    * 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 org.apache.commons.logging.jdk14;
  
  import java.io.InputStream;
  import java.lang.reflect.Method;
  import java.util.Iterator;
  import java.util.logging.Handler;
  import java.util.logging.Level;
  import java.util.logging.LogManager;
  import java.util.logging.LogRecord;
  import java.util.logging.Logger;
  
  import junit.framework.Test;
  
  import org.apache.commons.io.IOUtils;
  import org.apache.commons.logging.DummyException;
  import org.apache.commons.logging.PathableClassLoader;
  import org.apache.commons.logging.PathableTestSuite;
  
  /**
   * <p>TestCase for JDK 1.4 logging when running on a JDK 1.4 system with
   * custom configuration, so that JDK 1.4 should be selected and an appropriate
   * logger configured per the configuration properties.</p>
   */
  
  public class CustomConfigTestCase extends DefaultConfigTestCase {
  
      protected static final String HANDLER_NAME = "org.apache.commons.logging.jdk14.TestHandler";
  
      /**
       * Make a class available in the system class loader even when its classfile is
       * not present in the classpath configured for that class loader. This only
       * works for classes for which all dependencies are already loaded in
       * that class loader.
       */
      protected static void loadTestHandler(final String className, final ClassLoader targetCL) {
          try {
              targetCL.loadClass(className);
              // fail("Class already in target class loader");
              return;
          } catch (final ClassNotFoundException ex) {
              // ok, go ahead and load it
          }
  
          try {
              final ClassLoader srcCL = CustomConfigAPITestCase.class.getClassLoader();
              final byte[] classData = readClass(className, srcCL);
  
              final Class<?>[] params = { String.class, classData.getClass(), Integer.TYPE, Integer.TYPE };
              final Method m = ClassLoader.class.getDeclaredMethod("defineClass", params);
  
              final Object[] args = new Object[4];
              args[0] = className;
              args[1] = classData;
              args[2] = Integer.valueOf(0);
              args[3] = Integer.valueOf(classData.length);
              m.setAccessible(true);
              m.invoke(targetCL, args);
          } catch (final Exception e) {
              e.printStackTrace();
              fail("Unable to load class " + className);
          }
      }
  
      /**
       * Given the name of a class that is somewhere in the classpath of the provided
       * class loader, return the contents of the corresponding .class file.
       */
      protected static byte[] readClass(final String name, final ClassLoader srcCL) throws Exception {
          final String resName = name.replace('.', '/') + ".class";
          System.err.println("Trying to load resource [" + resName + "]");
          try (InputStream is = srcCL.getResourceAsStream(resName)) {
              System.err.println("Reading resource [" + resName + "]");
              return IOUtils.toByteArray(is);
          }
      }
  
      /**
       * Return the tests included in this test suite.
       */
      public static Test suite() throws Exception {
          final PathableClassLoader cl = new PathableClassLoader(null);
          cl.useExplicitLoader("junit.", Test.class.getClassLoader());
 
         // the TestHandler class must be accessible from the System class loader
         // in order for java.util.logging.LogManager.readConfiguration to
         // be able to instantiate it. And this test case must see the same
         // class in order to be able to access its data. Yes this is ugly
         // but the whole jdk14 API is a ******* mess anyway.
         final ClassLoader scl = ClassLoader.getSystemClassLoader();
         loadTestHandler(HANDLER_NAME, scl);
         cl.useExplicitLoader(HANDLER_NAME, scl);
         cl.addLogicalLib("commons-logging");
         cl.addLogicalLib("testclasses");
 
         final Class<?> testClass = cl.loadClass(CustomConfigTestCase.class.getName());
         return new PathableTestSuite(testClass, cl);
     }
 
     /**
      * <p>The customized {@code Handler} we will be using.</p>
      */
     protected TestHandler handler;
 
     /**
      * <p>The underlying {@code Handler}s we will be using.</p>
      */
     protected Handler handlers[];
 
     /**
      * <p>The underlying {@code Logger} we will be using.</p>
      */
     protected Logger logger;
 
     /**
      * <p>The underlying {@code LogManager} we will be using.</p>
      */
     protected LogManager manager;
 
     /**
      * <p>The message levels that should have been logged.</p>
      */
     protected Level[] testLevels =
     { Level.FINE, Level.INFO, Level.WARNING, Level.SEVERE, Level.SEVERE };
 
     /**
      * <p>The message strings that should have been logged.</p>
      */
     protected String[] testMessages =
     { "debug", "info", "warn", "error", "fatal" };
 
     /**
      * <p>Construct a new instance of this test case.</p>
      *
      * @param name Name of the test case
      */
     public CustomConfigTestCase(final String name) {
         super(name);
     }
 
     // Check the log instance
     @Override
     protected void checkLog() {
 
         assertNotNull("Log exists", log);
         assertEquals("Log class",
                      "org.apache.commons.logging.impl.Jdk14Logger",
                      log.getClass().getName());
 
         // Assert which logging levels have been enabled
         assertTrue(log.isFatalEnabled());
         assertTrue(log.isErrorEnabled());
         assertTrue(log.isWarnEnabled());
         assertTrue(log.isInfoEnabled());
         assertTrue(log.isDebugEnabled());
         assertFalse(log.isTraceEnabled());
 
     }
 
     // Check the recorded messages
     protected void checkLogRecords(final boolean thrown) {
         final Iterator<LogRecord> records = handler.records();
         for (int i = 0; i < testMessages.length; i++) {
             assertTrue(records.hasNext());
             final LogRecord record = records.next();
             assertEquals("LogRecord level",
                          testLevels[i], record.getLevel());
             assertEquals("LogRecord message",
                          testMessages[i], record.getMessage());
             assertTrue("LogRecord class",
                          record.getSourceClassName().startsWith(
                                  "org.apache.commons.logging.jdk14.CustomConfig"));
             if (thrown) {
                 assertEquals("LogRecord method",
                              "logExceptionMessages",
                              record.getSourceMethodName());
             } else {
                 assertEquals("LogRecord method",
                              "logPlainMessages",
                              record.getSourceMethodName());
             }
             if (thrown) {
                 assertNotNull("LogRecord thrown", record.getThrown());
                 assertTrue("LogRecord thrown type",
                            record.getThrown() instanceof DummyException);
             } else {
                 assertNull("LogRecord thrown",
                            record.getThrown());
             }
         }
         assertFalse(records.hasNext());
         handler.flush();
     }
 
     // Log the messages with exceptions
     protected void logExceptionMessages() {
         final Throwable t = new DummyException();
         log.trace("trace", t); // Should not actually get logged
         log.debug("debug", t);
         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");
         log.info("info");
         log.warn("warn");
         log.error("error");
         log.fatal("fatal");
     }
 
     /**
      * Sets up instance variables required by this test case.
      */
     @Override
     public void setUp() throws Exception {
         setUpManager
             ("org/apache/commons/logging/jdk14/CustomConfig.properties");
         setUpLogger(this.getClass().getName());
         setUpHandlers();
         setUpFactory();
         setUpLog(this.getClass().getName());
     }
 
     // Set up handlers instance
     protected void setUpHandlers() throws Exception {
         Logger parent = logger;
         while (parent.getParent() != null) {
             parent = parent.getParent();
         }
         handlers = parent.getHandlers();
 
         // The CustomConfig.properties file explicitly defines one handler class
         // to be attached to the root logger, so if it isn't there then
         // something is badly wrong...
         //
         // Yes this testing is also done in testPristineHandlers but
         // unfortunately:
         //  * we need to set up the handlers variable here,
         //  * we don't want that to be set up incorrectly, as that can
         //    produce weird error messages in other tests, and
         //  * we can't rely on testPristineHandlers being the first
         //    test to run.
         // so we need to test things here too.
         assertNotNull("No Handlers defined for JDK14 logging", handlers);
         assertEquals("Unexpected number of handlers for JDK14 logging", 1, handlers.length);
         assertNotNull("Handler is null", handlers[0]);
         assertTrue("Handler not of expected type", handlers[0] instanceof TestHandler);
         handler = (TestHandler) handlers[0];
     }
 
     // Set up logger instance
     protected void setUpLogger(final String name) throws Exception {
         logger = Logger.getLogger(name);
     }
 
     // Set up LogManager instance
     protected void setUpManager(final String config) throws Exception {
         manager = LogManager.getLogManager();
         try (InputStream is = this.getClass().getClassLoader().getResourceAsStream(config)) {
             manager.readConfiguration(is);
         }
     }
 
     /**
      * Tear down instance variables required by this test case.
      */
     @Override
     public void tearDown() {
         super.tearDown();
         handlers = null;
         logger = null;
         manager = null;
     }
 
     // Test logging message strings with exceptions
     public void testExceptionMessages() throws Exception {
         logExceptionMessages();
         checkLogRecords(true);
     }
 
     // Test logging plain message strings
     public void testPlainMessages() throws Exception {
         logPlainMessages();
         checkLogRecords(false);
     }
 
     // Test pristine Handlers instances
     public void testPristineHandlers() {
         assertNotNull(handlers);
         assertEquals(1, handlers.length);
         assertTrue(handlers[0] instanceof TestHandler);
         assertNotNull(handler);
     }
 
     // Test pristine Logger instance
     public void testPristineLogger() {
         assertNotNull("Logger exists", logger);
         assertEquals("Logger name", this.getClass().getName(), logger.getName());
 
         // Assert which logging levels have been enabled
         assertTrue(logger.isLoggable(Level.SEVERE));
         assertTrue(logger.isLoggable(Level.WARNING));
         assertTrue(logger.isLoggable(Level.INFO));
         assertTrue(logger.isLoggable(Level.CONFIG));
         assertTrue(logger.isLoggable(Level.FINE));
         assertFalse(logger.isLoggable(Level.FINER));
         assertFalse(logger.isLoggable(Level.FINEST));
     }
 
     // Test Serializability of Log instance
     @Override
     public void testSerializable() throws Exception {
         super.testSerializable();
         testExceptionMessages();
     }
 
 }