diff --git a/slf4j-api/src/main/java/org/slf4j/event/EventRecodingLogger.java b/slf4j-api/src/main/java/org/slf4j/event/EventRecodingLogger.java index 402caf7e3..abb33ab14 100755 --- a/slf4j-api/src/main/java/org/slf4j/event/EventRecodingLogger.java +++ b/slf4j-api/src/main/java/org/slf4j/event/EventRecodingLogger.java @@ -5,6 +5,7 @@ import org.slf4j.Logger; import org.slf4j.Marker; import org.slf4j.helpers.SubstituteLogger; +import org.slf4j.helpers.Util; public class EventRecodingLogger implements Logger { @@ -22,6 +23,18 @@ public String getName() { return name; } + private void recordEvent(Level level, String msg, Object arg1, Object arg2) { + recordEvent(level, null, msg, arg1, arg2); + } + + private void recordEvent(Level level, Marker marker, String msg, Object arg1, Object arg2) { + if (arg2 instanceof Throwable) { + recordEvent(level, marker, msg, new Object[] { arg1 }, (Throwable) arg2); + } else { + recordEvent(level, marker, msg, new Object[] { arg1, arg2 }, null); + } + } + private void recordEvent(Level level, String msg, Object[] args, Throwable throwable) { recordEvent(level, null, msg, args, throwable); } @@ -35,9 +48,23 @@ private void recordEvent(Level level, Marker marker, String msg, Object[] args, loggingEvent.setLoggerName(name); loggingEvent.addMarker(marker); loggingEvent.setMessage(msg); - loggingEvent.setArgumentArray(args); - loggingEvent.setThrowable(throwable); loggingEvent.setThreadName(Thread.currentThread().getName()); + + // 1 and 2 args are covered by other methods + if (throwable == null && args != null && args.length > 2) { + Throwable throwableCandidate = Util.getThrowableCandidate(args); + if(throwableCandidate != null) { + loggingEvent.setArgumentArray(Util.trimmedCopy(args)); + loggingEvent.setThrowable(throwableCandidate); + } else { + loggingEvent.setArgumentArray(args); + loggingEvent.setThrowable(null); + } + } else { + loggingEvent.setArgumentArray(args); + loggingEvent.setThrowable(throwable); + } + eventQueue.add(loggingEvent); } @@ -54,7 +81,7 @@ public void trace(String format, Object arg) { } public void trace(String format, Object arg1, Object arg2) { - recordEvent(Level.TRACE, format, new Object[] { arg1, arg2 }, null); + recordEvent(Level.TRACE, format, arg1, arg2); } public void trace(String format, Object... arguments) { @@ -79,7 +106,7 @@ public void trace(Marker marker, String format, Object arg) { } public void trace(Marker marker, String format, Object arg1, Object arg2) { - recordEvent(Level.TRACE, marker, format, new Object[] { arg1, arg2 }, null); + recordEvent(Level.TRACE, marker, format, arg1, arg2); } public void trace(Marker marker, String format, Object... argArray) { @@ -105,8 +132,7 @@ public void debug(String format, Object arg) { } public void debug(String format, Object arg1, Object arg2) { - recordEvent(Level.DEBUG, format, new Object[] { arg1, arg2 }, null); - + recordEvent(Level.DEBUG, format, arg1, arg2); } public void debug(String format, Object... arguments) { @@ -130,7 +156,7 @@ public void debug(Marker marker, String format, Object arg) { } public void debug(Marker marker, String format, Object arg1, Object arg2) { - recordEvent(Level.DEBUG, marker, format, new Object[] { arg1, arg2 }, null); + recordEvent(Level.DEBUG, marker, format, arg1, arg2); } public void debug(Marker marker, String format, Object... arguments) { @@ -154,7 +180,7 @@ public void info(String format, Object arg) { } public void info(String format, Object arg1, Object arg2) { - recordEvent(Level.INFO, format, new Object[] { arg1, arg2 }, null); + recordEvent(Level.INFO, format, arg1, arg2); } public void info(String format, Object... arguments) { @@ -178,7 +204,7 @@ public void info(Marker marker, String format, Object arg) { } public void info(Marker marker, String format, Object arg1, Object arg2) { - recordEvent(Level.INFO, marker, format, new Object[] { arg1, arg2 }, null); + recordEvent(Level.INFO, marker, format, arg1, arg2); } public void info(Marker marker, String format, Object... arguments) { @@ -204,7 +230,7 @@ public void warn(String format, Object arg) { } public void warn(String format, Object arg1, Object arg2) { - recordEvent(Level.WARN, format, new Object[] { arg1, arg2 }, null); + recordEvent(Level.WARN, format, arg1, arg2); } public void warn(String format, Object... arguments) { @@ -224,12 +250,11 @@ public void warn(Marker marker, String msg) { } public void warn(Marker marker, String format, Object arg) { - recordEvent(Level.WARN, format, new Object[] { arg }, null); + recordEvent(Level.WARN, marker, format, new Object[] { arg }, null); } public void warn(Marker marker, String format, Object arg1, Object arg2) { - recordEvent(Level.WARN, marker, format, new Object[] { arg1, arg2 }, null); - + recordEvent(Level.WARN, marker, format, arg1, arg2); } public void warn(Marker marker, String format, Object... arguments) { @@ -254,7 +279,7 @@ public void error(String format, Object arg) { } public void error(String format, Object arg1, Object arg2) { - recordEvent(Level.ERROR, format, new Object[] { arg1, arg2 }, null); + recordEvent(Level.ERROR, format, arg1, arg2); } @@ -282,7 +307,7 @@ public void error(Marker marker, String format, Object arg) { } public void error(Marker marker, String format, Object arg1, Object arg2) { - recordEvent(Level.ERROR, marker, format, new Object[] { arg1, arg2 }, null); + recordEvent(Level.ERROR, marker, format, arg1, arg2); } public void error(Marker marker, String format, Object... arguments) { diff --git a/slf4j-api/src/main/java/org/slf4j/helpers/MessageFormatter.java b/slf4j-api/src/main/java/org/slf4j/helpers/MessageFormatter.java index e5df70e98..f26020668 100755 --- a/slf4j-api/src/main/java/org/slf4j/helpers/MessageFormatter.java +++ b/slf4j-api/src/main/java/org/slf4j/helpers/MessageFormatter.java @@ -153,34 +153,13 @@ final public static FormattingTuple format(final String messagePattern, Object a final public static FormattingTuple arrayFormat(final String messagePattern, final Object[] argArray) { - Throwable throwableCandidate = getThrowableCandidate(argArray); + Throwable throwableCandidate = Util.getThrowableCandidate(argArray); Object[] args = argArray; if (throwableCandidate != null) { - args = trimmedCopy(argArray); + args = Util.trimmedCopy(argArray); } return arrayFormat(messagePattern, args, throwableCandidate); } - - static final Throwable getThrowableCandidate(Object[] argArray) { - if (argArray == null || argArray.length == 0) { - return null; - } - - final Object lastEntry = argArray[argArray.length - 1]; - if (lastEntry instanceof Throwable) { - return (Throwable) lastEntry; - } - return null; - } - private static Object[] trimmedCopy(Object[] argArray) { - if (argArray == null || argArray.length == 0) { - throw new IllegalStateException("non-sensical empty or null argument array"); - } - final int trimemdLen = argArray.length - 1; - Object[] trimmed = new Object[trimemdLen]; - System.arraycopy(argArray, 0, trimmed, 0, trimemdLen); - return trimmed; - } final public static FormattingTuple arrayFormat(final String messagePattern, final Object[] argArray, Throwable throwable) { diff --git a/slf4j-api/src/main/java/org/slf4j/helpers/Util.java b/slf4j-api/src/main/java/org/slf4j/helpers/Util.java index 06017849b..ab92f326e 100755 --- a/slf4j-api/src/main/java/org/slf4j/helpers/Util.java +++ b/slf4j-api/src/main/java/org/slf4j/helpers/Util.java @@ -127,7 +127,50 @@ static final public void report(String msg, Throwable t) { static final public void report(String msg) { System.err.println("SLF4J: " + msg); } - - + + /** + * Helper method to determine if an {@link Object} array contains a {@link Throwable} as last element + * + * @param argArray + * The arguments off which we want to know if it contains a {@link Throwable} as last element + * @return if the last {@link Object} in argArray is a {@link Throwable} this method will return it, + * otherwise it returns null + */ + public static Throwable getThrowableCandidate(final Object[] argArray) { + if (argArray == null || argArray.length == 0) { + return null; + } + + final Object lastEntry = argArray[argArray.length - 1]; + if (lastEntry instanceof Throwable) { + return (Throwable) lastEntry; + } + + return null; + } + + /** + * Helper method to get all but the last element of an array + * + * @param argArray + * The arguments from which we want to remove the last element + * + * @return a copy of the array without the last element + */ + public static Object[] trimmedCopy(final Object[] argArray) { + if (argArray == null || argArray.length == 0) { + throw new IllegalStateException("non-sensical empty or null argument array"); + } + + final int trimmedLen = argArray.length - 1; + + Object[] trimmed = new Object[trimmedLen]; + + if (trimmedLen > 0) { + System.arraycopy(argArray, 0, trimmed, 0, trimmedLen); + } + + return trimmed; + } } diff --git a/slf4j-api/src/test/java/org/slf4j/event/EventRecodingLoggerTest.java b/slf4j-api/src/test/java/org/slf4j/event/EventRecodingLoggerTest.java new file mode 100644 index 000000000..68abff0ea --- /dev/null +++ b/slf4j-api/src/test/java/org/slf4j/event/EventRecodingLoggerTest.java @@ -0,0 +1,797 @@ +package org.slf4j.event; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.slf4j.Marker; +import org.slf4j.helpers.BasicMarkerFactory; +import org.slf4j.helpers.SubstituteLogger; + +import java.util.Queue; +import java.util.concurrent.LinkedBlockingQueue; + +import static org.junit.Assert.*; + +public class EventRecodingLoggerTest { + private Queue queue; + private EventRecodingLogger logger; + private String message; + private Object param1; + private Object param2; + private Object param3; + private Object[] oneParam; + private Object[] twoParams; + private Object[] threeParams; + private Throwable exception; + private Marker marker; + + @Before + public void setUp() { + queue = new LinkedBlockingQueue<>(); + logger = new EventRecodingLogger(new SubstituteLogger("testLogger", queue, true), queue); + message = "Test message with 3 parameters {} {} {} {}"; + param1 = 1; + param2 = 2; + param3 = 3; + oneParam = new Object[] { param1 }; + twoParams = new Object[] { param1, param2 }; + threeParams = new Object[] { param1, param2, param3 }; + exception = new IllegalStateException("We just need an exception"); + marker = new BasicMarkerFactory().getMarker("testMarker"); + } + + @After + public void tearDown() { + assertTrue(queue.isEmpty()); + } + + @Test + public void traceMessage() { + logger.trace(message); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.TRACE, null, null); + } + + @Test + public void traceMessageOneParameter() { + logger.trace(message, param1); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.TRACE, oneParam, null); + } + + @Test + public void traceMessageTwoParameters() { + logger.trace(message, param1, param2); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.TRACE, twoParams, null); + } + + @Test + public void traceMessageThreeParameters() { + logger.trace(message, param1, param2, param3); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.TRACE, threeParams, null); + } + + @Test + public void traceMessageThrowable() { + logger.trace(message, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.TRACE, null, exception); + } + + @Test + public void traceMessageOneParameterThrowable() { + logger.trace(message, param1, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.TRACE, oneParam, exception); + } + + @Test + public void traceMessageTwoParametersThrowable() { + logger.trace(message, param1, param2, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.TRACE, twoParams, exception); + } + + @Test + public void traceMessageThreeParametersThrowable() { + logger.trace(message, param1, param2, param3, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.TRACE, threeParams, exception); + } + + @Test + public void traceMarkerMessage() { + logger.trace(marker, message); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.TRACE, marker, null, null); + } + + @Test + public void traceMarkerMessageOneParameter() { + logger.trace(marker, message, param1); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.TRACE, marker, oneParam, null); + } + + @Test + public void traceMarkerMessageTwoParameters() { + logger.trace(marker, message, param1, param2); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.TRACE, marker, twoParams, null); + } + + @Test + public void traceMarkerMessageThreeParameters() { + logger.trace(marker, message, param1, param2, param3); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.TRACE, marker, threeParams, null); + } + + @Test + public void traceMarkerMessageThrowable() { + logger.trace(marker, message, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.TRACE, marker, null, exception); + } + + @Test + public void traceMarkerMessageOneParameterThrowable() { + logger.trace(marker, message, param1, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.TRACE, marker, oneParam, exception); + } + + @Test + public void traceMarkerMessageTwoParametersThrowable() { + logger.trace(marker, message, param1, param2, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.TRACE, marker, twoParams, exception); + } + + @Test + public void traceMarkerMessageThreeParametersThrowable() { + logger.trace(marker, message, param1, param2, param3, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.TRACE, marker, threeParams, exception); + } + + @Test + public void debugMessage() { + logger.debug(message); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.DEBUG, null, null); + } + + @Test + public void debugMessageOneParameter() { + logger.debug(message, param1); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.DEBUG, oneParam, null); + } + + @Test + public void debugMessageTwoParameters() { + logger.debug(message, param1, param2); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.DEBUG, twoParams, null); + } + + @Test + public void debugMessageThreeParameters() { + logger.debug(message, param1, param2, param3); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.DEBUG, threeParams, null); + } + + @Test + public void debugMessageThrowable() { + logger.debug(message, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.DEBUG, null, exception); + } + + @Test + public void debugMessageOneParameterThrowable() { + logger.debug(message, param1, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.DEBUG, oneParam, exception); + } + + @Test + public void debugMessageTwoParametersThrowable() { + logger.debug(message, param1, param2, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.DEBUG, twoParams, exception); + } + + @Test + public void debugMessageThreeParametersThrowable() { + logger.debug(message, param1, param2, param3, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.DEBUG, threeParams, exception); + } + + @Test + public void debugMarkerMessage() { + logger.debug(marker, message); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.DEBUG, marker, null, null); + } + + @Test + public void debugMarkerMessageOneParameter() { + logger.debug(marker, message, param1); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.DEBUG, marker, oneParam, null); + } + + @Test + public void debugMarkerMessageTwoParameters() { + logger.debug(marker, message, param1, param2); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.DEBUG, marker, twoParams, null); + } + + @Test + public void debugMarkerMessageThreeParameters() { + logger.debug(marker, message, param1, param2, param3); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.DEBUG, marker, threeParams, null); + } + + @Test + public void debugMarkerMessageThrowable() { + logger.debug(marker, message, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.DEBUG, marker, null, exception); + } + + @Test + public void debugMarkerMessageOneParameterThrowable() { + logger.debug(marker, message, param1, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.DEBUG, marker, oneParam, exception); + } + + @Test + public void debugMarkerMessageTwoParametersThrowable() { + logger.debug(marker, message, param1, param2, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.DEBUG, marker, twoParams, exception); + } + + @Test + public void debugMarkerMessageThreeParametersThrowable() { + logger.debug(marker, message, param1, param2, param3, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.DEBUG, marker, threeParams, exception); + } + + @Test + public void infoMessage() { + logger.info(message); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.INFO, null, null); + } + + @Test + public void infoMessageOneParameter() { + logger.info(message, param1); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.INFO, oneParam, null); + } + + @Test + public void infoMessageTwoParameters() { + logger.info(message, param1, param2); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.INFO, twoParams, null); + } + + @Test + public void infoMessageThreeParameters() { + logger.info(message, param1, param2, param3); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.INFO, threeParams, null); + } + + @Test + public void infoMessageThrowable() { + logger.info(message, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.INFO, null, exception); + } + + @Test + public void infoMessageOneParameterThrowable() { + logger.info(message, param1, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.INFO, oneParam, exception); + } + + @Test + public void infoMessageTwoParametersThrowable() { + logger.info(message, param1, param2, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.INFO, twoParams, exception); + } + + @Test + public void infoMessageThreeParametersThrowable() { + logger.info(message, param1, param2, param3, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.INFO, threeParams, exception); + } + + @Test + public void infoMarkerMessage() { + logger.info(marker, message); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.INFO, marker, null, null); + } + + @Test + public void infoMarkerMessageOneParameter() { + logger.info(marker, message, param1); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.INFO, marker, oneParam, null); + } + + @Test + public void infoMarkerMessageTwoParameters() { + logger.info(marker, message, param1, param2); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.INFO, marker, twoParams, null); + } + + @Test + public void infoMarkerMessageThreeParameters() { + logger.info(marker, message, param1, param2, param3); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.INFO, marker, threeParams, null); + } + + @Test + public void infoMarkerMessageThrowable() { + logger.info(marker, message, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.INFO, marker, null, exception); + } + + @Test + public void infoMarkerMessageOneParameterThrowable() { + logger.info(marker, message, param1, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.INFO, marker, oneParam, exception); + } + + @Test + public void infoMarkerMessageTwoParametersThrowable() { + logger.info(marker, message, param1, param2, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.INFO, marker, twoParams, exception); + } + + @Test + public void infoMarkerMessageThreeParametersThrowable() { + logger.info(marker, message, param1, param2, param3, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.INFO, marker, threeParams, exception); + } + + @Test + public void warnMessage() { + logger.warn(message); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.WARN, null, null); + } + + @Test + public void warnMessageOneParameter() { + logger.warn(message, param1); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.WARN, oneParam, null); + } + + @Test + public void warnMessageTwoParameters() { + logger.warn(message, param1, param2); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.WARN, twoParams, null); + } + + @Test + public void warnMessageThreeParameters() { + logger.warn(message, param1, param2, param3); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.WARN, threeParams, null); + } + + @Test + public void warnMessageThrowable() { + logger.warn(message, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.WARN, null, exception); + } + + @Test + public void warnMessageOneParameterThrowable() { + logger.warn(message, param1, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.WARN, oneParam, exception); + } + + @Test + public void warnMessageTwoParametersThrowable() { + logger.warn(message, param1, param2, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.WARN, twoParams, exception); + } + + @Test + public void warnMessageThreeParametersThrowable() { + logger.warn(message, param1, param2, param3, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.WARN, threeParams, exception); + } + + @Test + public void warnMarkerMessage() { + logger.warn(marker, message); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.WARN, marker, null, null); + } + + @Test + public void warnMarkerMessageOneParameter() { + logger.warn(marker, message, param1); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.WARN, marker, oneParam, null); + } + + @Test + public void warnMarkerMessageTwoParameters() { + logger.warn(marker, message, param1, param2); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.WARN, marker, twoParams, null); + } + + @Test + public void warnMarkerMessageThreeParameters() { + logger.warn(marker, message, param1, param2, param3); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.WARN, marker, threeParams, null); + } + + @Test + public void warnMarkerMessageThrowable() { + logger.warn(marker, message, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.WARN, marker, null, exception); + } + + @Test + public void warnMarkerMessageOneParameterThrowable() { + logger.warn(marker, message, param1, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.WARN, marker, oneParam, exception); + } + + @Test + public void warnMarkerMessageTwoParametersThrowable() { + logger.warn(marker, message, param1, param2, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.WARN, marker, twoParams, exception); + } + + @Test + public void warnMarkerMessageThreeParametersThrowable() { + logger.warn(marker, message, param1, param2, param3, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.WARN, marker, threeParams, exception); + } + + @Test + public void errorMessage() { + logger.error(message); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.ERROR, null, null); + } + + @Test + public void errorMessageOneParameter() { + logger.error(message, param1); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.ERROR, oneParam, null); + } + + @Test + public void errorMessageTwoParameters() { + logger.error(message, param1, param2); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.ERROR, twoParams, null); + } + + @Test + public void errorMessageThreeParameters() { + logger.error(message, param1, param2, param3); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.ERROR, threeParams, null); + } + + @Test + public void errorMessageThrowable() { + logger.error(message, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.ERROR, null, exception); + } + + @Test + public void errorMessageOneParameterThrowable() { + logger.error(message, param1, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.ERROR, oneParam, exception); + } + + @Test + public void errorMessageTwoParametersThrowable() { + logger.error(message, param1, param2, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.ERROR, twoParams, exception); + } + + @Test + public void errorMessageThreeParametersThrowable() { + logger.error(message, param1, param2, param3, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.ERROR, threeParams, exception); + } + + @Test + public void errorMarkerMessage() { + logger.error(marker, message); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.ERROR, marker, null, null); + } + + @Test + public void errorMarkerMessageOneParameter() { + logger.error(marker, message, param1); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.ERROR, marker, oneParam, null); + } + + @Test + public void errorMarkerMessageTwoParameters() { + logger.error(marker, message, param1, param2); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.ERROR, marker, twoParams, null); + } + + @Test + public void errorMarkerMessageThreeParameters() { + logger.error(marker, message, param1, param2, param3); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.ERROR, marker, threeParams, null); + } + + @Test + public void errorMarkerMessageThrowable() { + logger.error(marker, message, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.ERROR, marker, null, exception); + } + + @Test + public void errorMarkerMessageOneParameterThrowable() { + logger.error(marker, message, param1, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.ERROR, marker, oneParam, exception); + } + + @Test + public void errorMarkerMessageTwoParametersThrowable() { + logger.error(marker, message, param1, param2, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.ERROR, marker, twoParams, exception); + } + + @Test + public void errorMarkerMessageThreeParametersThrowable() { + logger.error(marker, message, param1, param2, param3, exception); + + SubstituteLoggingEvent event = queue.poll(); + + verifyMessage(event, Level.ERROR, marker, threeParams, exception); + } + + private void verifyMessage(SubstituteLoggingEvent event, Level level, Object[] arguments, Throwable exception) { + verifyMessage(event, level, null, arguments, exception); + } + + private void verifyMessage(SubstituteLoggingEvent event, Level level, Marker marker, Object[] arguments, Throwable exception) { + assertNotNull(event); + + if (marker == null) { + assertNull(event.getMarkers().get(0)); + } else { + assertEquals(marker, event.getMarkers().get(0)); + } + + assertEquals(message, event.getMessage()); + + if (arguments == null) { + assertNull(event.getArgumentArray()); + } else { + assertArrayEquals(arguments, event.getArgumentArray()); + } + + assertEquals(level, event.getLevel()); + + if (exception == null) { + assertNull(event.getThrowable()); + } else { + assertEquals(exception, event.getThrowable()); + } + } +}