package org.slf4j.ext;

import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.slf4j.spi.LocationAwareLogger.DEBUG_INT;
import static org.slf4j.spi.LocationAwareLogger.ERROR_INT;
import static org.slf4j.spi.LocationAwareLogger.INFO_INT;
import static org.slf4j.spi.LocationAwareLogger.TRACE_INT;
import static org.slf4j.spi.LocationAwareLogger.WARN_INT;

import org.junit.Before;
import org.junit.Test;
import org.slf4j.Marker;
import org.slf4j.helpers.BasicMarkerFactory;
import org.slf4j.helpers.MarkerIgnoringBase;
import org.slf4j.spi.LocationAwareLogger;


public class LocationAwareLoggerWrapperTest {

   private static final Marker MARKER = new BasicMarkerFactory()
         .getMarker("JUNIT");

   private static final Object ARG1 = new Object();

   private static final Throwable T = new Throwable();

   private static final Object T_OBJ = T;

   private static final Object[] T_ARR = { T };

   private static final Object[] ARGS = { ARG1, T };

   private static final String MSG = "msg";

   private static final String FQCN = LoggerWrapper.class.getName();

   private class MockLogger extends MarkerIgnoringBase implements
         LocationAwareLogger {

      private static final long serialVersionUID = 1L;

      private Marker marker;
      private String fqcn;
      private int level;
      private String message;
      private Object[] args;
      private Throwable t;
      private boolean called = false;
      {
         name = this.getClass().getName();
      }

      @Override
      public boolean isTraceEnabled() {

         return true;
      }

      @Override
      public void trace(String msg) {

         fail();
      }

      @Override
      public void trace(String format, Object arg) {

         fail();
      }

      @Override
      public void trace(String format, Object arg1, Object arg2) {

         fail();
      }

      @Override
      public void trace(String format, Object... arguments) {

         fail();
      }

      @Override
      public void trace(String msg, Throwable t) {

         fail();
      }

      @Override
      public boolean isDebugEnabled() {

         return true;
      }

      @Override
      public void debug(String msg) {

         fail();
      }

      @Override
      public void debug(String format, Object arg) {

         fail();
      }

      @Override
      public void debug(String format, Object arg1, Object arg2) {

         fail();
      }

      @Override
      public void debug(String format, Object... arguments) {

         fail();
      }

      @Override
      public void debug(String msg, Throwable t) {

         fail();
      }


      @Override
      public boolean isInfoEnabled() {

         return true;
      }

      @Override
      public void info(String msg) {

         fail();
      }

      @Override
      public void info(String format, Object arg) {

         fail();
      }

      @Override
      public void info(String format, Object arg1, Object arg2) {

         fail();
      }

      @Override
      public void info(String format, Object... arguments) {

         fail();
      }

      @Override
      public void info(String msg, Throwable t) {

         fail();
      }


      @Override
      public boolean isWarnEnabled() {

         return true;
      }

      @Override
      public void warn(String msg) {

         fail();
      }

      @Override
      public void warn(String format, Object arg) {

         fail();
      }

      @Override
      public void warn(String format, Object... arguments) {

         fail();
      }

      @Override
      public void warn(String format, Object arg1, Object arg2) {

         fail();
      }

      @Override
      public void warn(String msg, Throwable t) {

         fail();
      }

      @Override
      public boolean isErrorEnabled() {

         return true;
      }

      @Override
      public void error(String msg) {

         fail();
      }

      @Override
      public void error(String format, Object arg) {

         fail();
      }

      @Override
      public void error(String format, Object arg1, Object arg2) {

         fail();
      }

      @Override
      public void error(String format, Object... arguments) {

         fail();
      }

      @Override
      public void error(String msg, Throwable t) {

         fail();
      }


      @Override
      public void log(Marker marker, String fqcn, int level, String message,
            Object[] argArray, Throwable t) {

         this.called = true;
         this.marker = marker;
         this.fqcn = fqcn;
         this.level = level;
         this.message = message;
         this.args = argArray;
         this.t = t;
      }

      public void assertLogged(Marker marker, String fqcn, int level,
            String message, Object[] argArray, Throwable t) {

         assertTrue(called);
         assertEquals(marker, mock.marker);
         assertEquals(fqcn, mock.fqcn);
         assertEquals(level, mock.level);
         assertEquals(message, mock.message);
         assertArrayEquals(argArray, mock.args);
         assertEquals(t, mock.t);
      }
   }

   private LoggerWrapper testObj;

   private MockLogger mock;

   @Before
   public void setup() {

      testObj = new LoggerWrapper(mock = new MockLogger(), FQCN);
   }

   @Test
   public void testTraceString() {

      testObj.trace(MSG);
      mock.assertLogged(null, FQCN, TRACE_INT, MSG, null,
            null);
   }

   @Test
   public void testTraceStringObject() {

      testObj.trace(MSG, T_OBJ);
      mock.assertLogged(null, FQCN, TRACE_INT, MSG, T_ARR,
            T);
   }

   @Test
   public void testTraceStringObjectObject() {

      testObj.trace(MSG, ARG1, T);
      mock.assertLogged(null, FQCN, TRACE_INT, MSG, ARGS, T);
   }

   @Test
   public void testTraceStringObjectArray() {

      testObj.trace(MSG, ARGS);
      mock.assertLogged(null, FQCN, TRACE_INT, MSG, ARGS, T);
   }

   @Test
   public void testTraceStringThrowable() {

      testObj.trace(MSG, T);
      mock.assertLogged(null, FQCN, TRACE_INT, MSG, null, T);
   }

   @Test
   public void testTraceMarkerString() {

      testObj.trace(MARKER, MSG);
      mock.assertLogged(MARKER, FQCN, TRACE_INT, MSG, null, null);
   }

   @Test
   public void testTraceMarkerStringObject() {

      testObj.trace(MARKER, MSG, T_OBJ);
      mock.assertLogged(MARKER, FQCN, TRACE_INT, MSG, T_ARR, T);
   }

   @Test
   public void testTraceMarkerStringObjectObject() {

      testObj.trace(MARKER, MSG, ARG1, T);
      mock.assertLogged(MARKER, FQCN, TRACE_INT, MSG, ARGS, T);
   }

   @Test
   public void testTraceMarkerStringObjectArray() {

      testObj.trace(MARKER, MSG, ARGS);
      mock.assertLogged(MARKER, FQCN, TRACE_INT, MSG, ARGS, T);
   }

   @Test
   public void testTraceMarkerStringThrowable() {

      testObj.trace(MARKER, MSG, T);
      mock.assertLogged(MARKER, FQCN, TRACE_INT, MSG, null, T);
   }

   @Test
   public void testDebugString() {

      testObj.debug(MSG);
      mock.assertLogged(null, FQCN, DEBUG_INT, MSG, null, null);
   }

   @Test
   public void testDebugStringObject() {

      testObj.debug(MSG, T_OBJ);
      mock.assertLogged(null, FQCN, DEBUG_INT, MSG, T_ARR, T);
   }

   @Test
   public void testDebugStringObjectObject() {

      testObj.debug(MSG, ARG1, T);
      mock.assertLogged(null, FQCN, DEBUG_INT, MSG, ARGS, T);
   }

   @Test
   public void testDebugStringObjectArray() {

      testObj.debug(MSG, ARGS);
      mock.assertLogged(null, FQCN, DEBUG_INT, MSG, ARGS, T);
   }

   @Test
   public void testDebugStringThrowable() {

      testObj.debug(MSG, T);
      mock.assertLogged(null, FQCN, DEBUG_INT, MSG, null, T);
   }

   @Test
   public void testDebugMarkerString() {

      testObj.debug(MARKER, MSG);
      mock.assertLogged(MARKER, FQCN, DEBUG_INT, MSG, null, null);
   }

   @Test
   public void testDebugMarkerStringObject() {

      testObj.debug(MARKER, MSG, T_OBJ);
      mock.assertLogged(MARKER, FQCN, DEBUG_INT, MSG, T_ARR, T);
   }

   @Test
   public void testDebugMarkerStringObjectObject() {

      testObj.debug(MARKER, MSG, ARG1, T);
      mock.assertLogged(MARKER, FQCN, DEBUG_INT, MSG, ARGS, T);
   }

   @Test
   public void testDebugMarkerStringObjectArray() {

      testObj.debug(MARKER, MSG, ARGS);
      mock.assertLogged(MARKER, FQCN, DEBUG_INT, MSG, ARGS, T);
   }

   @Test
   public void testDebugMarkerStringThrowable() {

      testObj.debug(MARKER, MSG, T);
      mock.assertLogged(MARKER, FQCN, DEBUG_INT, MSG, null, T);
   }

   @Test
   public void testInfoString() {

      testObj.info(MSG);
      mock.assertLogged(null, FQCN, INFO_INT, MSG, null, null);
   }

   @Test
   public void testInfoStringObject() {

      testObj.info(MSG, T_OBJ);
      mock.assertLogged(null, FQCN, INFO_INT, MSG, T_ARR, T);
   }

   @Test
   public void testInfoStringObjectObject() {

      testObj.info(MSG, ARG1, T);
      mock.assertLogged(null, FQCN, INFO_INT, MSG, ARGS, T);
   }

   @Test
   public void testInfoStringObjectArray() {

      testObj.info(MSG, ARGS);
      mock.assertLogged(null, FQCN, INFO_INT, MSG, ARGS, T);
   }

   @Test
   public void testInfoStringThrowable() {

      testObj.info(MSG, T);
      mock.assertLogged(null, FQCN, INFO_INT, MSG, null, T);
   }

   @Test
   public void testInfoMarkerString() {

      testObj.info(MARKER, MSG);
      mock.assertLogged(MARKER, FQCN, INFO_INT, MSG, null, null);
   }

   @Test
   public void testInfoMarkerStringObject() {

      testObj.info(MARKER, MSG, T_OBJ);
      mock.assertLogged(MARKER, FQCN, INFO_INT, MSG, T_ARR, T);
   }

   @Test
   public void testInfoMarkerStringObjectObject() {

      testObj.info(MARKER, MSG, ARG1, T);
      mock.assertLogged(MARKER, FQCN, INFO_INT, MSG, ARGS, T);
   }

   @Test
   public void testInfoMarkerStringObjectArray() {

      testObj.info(MARKER, MSG, ARGS);
      mock.assertLogged(MARKER, FQCN, INFO_INT, MSG, ARGS, T);
   }

   @Test
   public void testInfoMarkerStringThrowable() {

      testObj.info(MARKER, MSG, T);
      mock.assertLogged(MARKER, FQCN, INFO_INT, MSG, null, T);
   }

   @Test
   public void testWarnString() {

      testObj.warn(MSG);
      mock.assertLogged(null, FQCN, WARN_INT, MSG, null, null);
   }

   @Test
   public void testWarnStringObject() {

      testObj.warn(MSG, T_OBJ);
      mock.assertLogged(null, FQCN, WARN_INT, MSG, T_ARR, T);
   }

   @Test
   public void testWarnStringObjectObject() {

      testObj.warn(MSG, ARG1, T);
      mock.assertLogged(null, FQCN, WARN_INT, MSG, ARGS, T);
   }

   @Test
   public void testWarnStringObjectArray() {

      testObj.warn(MSG, ARGS);
      mock.assertLogged(null, FQCN, WARN_INT, MSG, ARGS, T);
   }

   @Test
   public void testWarnStringThrowable() {

      testObj.warn(MSG, T);
      mock.assertLogged(null, FQCN, WARN_INT, MSG, null, T);
   }

   @Test
   public void testWarnMarkerString() {

      testObj.warn(MARKER, MSG);
      mock.assertLogged(MARKER, FQCN, WARN_INT, MSG, null, null);
   }

   @Test
   public void testWarnMarkerStringObject() {

      testObj.warn(MARKER, MSG, T_OBJ);
      mock.assertLogged(MARKER, FQCN, WARN_INT, MSG, T_ARR, T);
   }

   @Test
   public void testWarnMarkerStringObjectObject() {

      testObj.warn(MARKER, MSG, ARG1, T);
      mock.assertLogged(MARKER, FQCN, WARN_INT, MSG, ARGS, T);
   }

   @Test
   public void testWarnMarkerStringObjectArray() {

      testObj.warn(MARKER, MSG, ARGS);
      mock.assertLogged(MARKER, FQCN, WARN_INT, MSG, ARGS, T);
   }

   @Test
   public void testWarnMarkerStringThrowable() {

      testObj.warn(MARKER, MSG, T);
      mock.assertLogged(MARKER, FQCN, WARN_INT, MSG, null, T);
   }

   @Test
   public void testErrorString() {

      testObj.error(MSG);
      mock.assertLogged(null, FQCN, ERROR_INT, MSG, null, null);
   }

   @Test
   public void testErrorStringObject() {

      testObj.error(MSG, T_OBJ);
      mock.assertLogged(null, FQCN, ERROR_INT, MSG, T_ARR, T);
   }

   @Test
   public void testErrorStringObjectObject() {

      testObj.error(MSG, ARG1, T);
      mock.assertLogged(null, FQCN, ERROR_INT, MSG, ARGS, T);
   }

   @Test
   public void testErrorStringObjectArray() {

      testObj.error(MSG, ARGS);
      mock.assertLogged(null, FQCN, ERROR_INT, MSG, ARGS, T);
   }

   @Test
   public void testErrorStringThrowable() {

      testObj.error(MSG, T);
      mock.assertLogged(null, FQCN, ERROR_INT, MSG, null, T);
   }

   @Test
   public void testErrorMarkerString() {

      testObj.error(MARKER, MSG);
      mock.assertLogged(MARKER, FQCN, ERROR_INT, MSG, null, null);
   }

   @Test
   public void testErrorMarkerStringObject() {

      testObj.error(MARKER, MSG, T_OBJ);
      mock.assertLogged(MARKER, FQCN, ERROR_INT, MSG, T_ARR, T);
   }

   @Test
   public void testErrorMarkerStringObjectObject() {

      testObj.error(MARKER, MSG, ARG1, T);
      mock.assertLogged(MARKER, FQCN, ERROR_INT, MSG, ARGS, T);
   }

   @Test
   public void testErrorMarkerStringObjectArray() {

      testObj.error(MARKER, MSG, ARGS);
      mock.assertLogged(MARKER, FQCN, ERROR_INT, MSG, ARGS, T);
   }

   @Test
   public void testErrorMarkerStringThrowable() {

      testObj.error(MARKER, MSG, T);
      mock.assertLogged(MARKER, FQCN, ERROR_INT, MSG, null, T);
   }

   @Test
   public void testGetName() {

      assertEquals(mock.getName(), testObj.getName());
   }
}