You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@logging.apache.org by rp...@apache.org on 2015/08/09 17:53:26 UTC
logging-log4j2 git commit: LOG4J2-599 additional Logger2 tests
Repository: logging-log4j2
Updated Branches:
refs/heads/LOG4J2-599-LambdaSupport 2d924ce7d -> b3ce3fcac
LOG4J2-599 additional Logger2 tests
Project: http://git-wip-us.apache.org/repos/asf/logging-log4j2/repo
Commit: http://git-wip-us.apache.org/repos/asf/logging-log4j2/commit/b3ce3fca
Tree: http://git-wip-us.apache.org/repos/asf/logging-log4j2/tree/b3ce3fca
Diff: http://git-wip-us.apache.org/repos/asf/logging-log4j2/diff/b3ce3fca
Branch: refs/heads/LOG4J2-599-LambdaSupport
Commit: b3ce3fcacd8504e72712eb8e3dc3bbf690828e58
Parents: 2d924ce
Author: rpopma <rp...@apache.org>
Authored: Mon Aug 10 00:53:27 2015 +0900
Committer: rpopma <rp...@apache.org>
Committed: Mon Aug 10 00:53:27 2015 +0900
----------------------------------------------------------------------
.../org/apache/logging/log4j/Logger2Test.java | 1091 +++++++++++++++++-
1 file changed, 1079 insertions(+), 12 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/b3ce3fca/log4j-api/src/test/java/org/apache/logging/log4j/Logger2Test.java
----------------------------------------------------------------------
diff --git a/log4j-api/src/test/java/org/apache/logging/log4j/Logger2Test.java b/log4j-api/src/test/java/org/apache/logging/log4j/Logger2Test.java
index 14dd36b..7509fc4 100644
--- a/log4j-api/src/test/java/org/apache/logging/log4j/Logger2Test.java
+++ b/log4j-api/src/test/java/org/apache/logging/log4j/Logger2Test.java
@@ -24,6 +24,7 @@ import org.apache.logging.log4j.message.Message;
import org.apache.logging.log4j.message.SimpleMessage;
import org.apache.logging.log4j.spi.AbstractLogger;
import org.apache.logging.log4j.util.MessageSupplier;
+import org.apache.logging.log4j.util.Supplier;
import org.junit.Before;
import org.junit.Test;
@@ -37,7 +38,6 @@ public class Logger2Test {
private static class LogEvent {
@SuppressWarnings("unused")
final String fqcn;
- @SuppressWarnings("unused")
final Level level;
final Marker marker;
final Message message;
@@ -105,39 +105,54 @@ public class Logger2Test {
}
final Logger2Impl logger2 = new Logger2Impl();
+ final String stringMessage = "Hi";
final Message message = new SimpleMessage("HiMessage");
final Throwable throwable = new Error("I'm Bad");
final Marker marker = MarkerManager.getMarker("test");
class MyMessageSupplier implements MessageSupplier {
- public int count = 0;
+ public boolean invoked = false;
@Override
public Message get() {
- count++;
+ invoked = true;
return message;
}
};
final MyMessageSupplier messageSupplier = new MyMessageSupplier();
+ class MySupplier implements Supplier<String> {
+ public boolean invoked = false;
+
+ @Override
+ public String get() {
+ invoked = true;
+ return stringMessage;
+ }
+ }
+
+ final MySupplier supplier = new MySupplier();
+
@Before
public void beforeEachTest() {
logger2.list.clear();
- messageSupplier.count = 0;
+ supplier.invoked = false;
+ messageSupplier.invoked = false;
}
@Test
public void testDebugMarkerMessageSupplier() {
logger2.disable().debug(marker, messageSupplier);
assertTrue(logger2.list.isEmpty());
- assertEquals(0, messageSupplier.count);
+ assertFalse(messageSupplier.invoked);
logger2.enable().debug(marker, messageSupplier);
assertEquals(1, logger2.list.size());
- assertEquals(1, messageSupplier.count);
+ assertTrue(messageSupplier.invoked);
LogEvent event = logger2.list.get(0);
+ assertEquals(Level.DEBUG, event.level);
assertSame(message, event.message);
assertSame(marker, event.marker);
}
@@ -146,13 +161,14 @@ public class Logger2Test {
public void testDebugMessageSupplier() {
logger2.disable().debug(messageSupplier);
assertTrue(logger2.list.isEmpty());
- assertEquals(0, messageSupplier.count);
+ assertFalse(messageSupplier.invoked);
logger2.enable().debug(messageSupplier);
assertEquals(1, logger2.list.size());
- assertEquals(1, messageSupplier.count);
+ assertTrue(messageSupplier.invoked);
LogEvent event = logger2.list.get(0);
+ assertEquals(Level.DEBUG, event.level);
assertSame(message, event.message);
}
@@ -160,13 +176,14 @@ public class Logger2Test {
public void testDebugMarkerMessageSupplierThrowable() {
logger2.disable().debug(marker, messageSupplier, throwable);
assertTrue(logger2.list.isEmpty());
- assertEquals(0, messageSupplier.count);
+ assertFalse(messageSupplier.invoked);
logger2.enable().debug(marker, messageSupplier, throwable);
assertEquals(1, logger2.list.size());
- assertEquals(1, messageSupplier.count);
+ assertTrue(messageSupplier.invoked);
LogEvent event = logger2.list.get(0);
+ assertEquals(Level.DEBUG, event.level);
assertSame(marker, event.marker);
assertSame(message, event.message);
assertSame(throwable, event.throwable);
@@ -176,15 +193,1065 @@ public class Logger2Test {
public void testDebugMessageSupplierThrowable() {
logger2.disable().debug(messageSupplier, throwable);
assertTrue(logger2.list.isEmpty());
- assertEquals(0, messageSupplier.count);
+ assertFalse(messageSupplier.invoked);
logger2.enable().debug(messageSupplier, throwable);
assertEquals(1, logger2.list.size());
- assertEquals(1, messageSupplier.count);
+ assertTrue(messageSupplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.DEBUG, event.level);
+ assertSame(message, event.message);
+ assertSame(throwable, event.throwable);
+ }
+
+ @Test
+ public void testDebugMarkerSupplier() {
+ logger2.disable().debug(marker, supplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().debug(marker, supplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.DEBUG, event.level);
+ assertSame(stringMessage, event.message.getFormattedMessage());
+ assertSame(marker, event.marker);
+ }
+
+ @Test
+ public void testDebugSupplier() {
+ logger2.disable().debug(supplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().debug(supplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.DEBUG, event.level);
+ assertSame(stringMessage, event.message.getFormattedMessage());
+ }
+
+ @Test
+ public void testDebugMarkerSupplierThrowable() {
+ logger2.disable().debug(marker, supplier, throwable);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().debug(marker, supplier, throwable);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.DEBUG, event.level);
+ assertSame(marker, event.marker);
+ assertSame(stringMessage, event.message.getFormattedMessage());
+ assertSame(throwable, event.throwable);
+ }
+
+ @Test
+ public void testDebugSupplierThrowable() {
+ logger2.disable().debug(supplier, throwable);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().debug(supplier, throwable);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.DEBUG, event.level);
+ assertSame(stringMessage, event.message.getFormattedMessage());
+ assertSame(throwable, event.throwable);
+ }
+
+ @Test
+ public void testDebugStringParamSupplier() {
+ logger2.disable().debug("abc {}", supplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().debug("abc {}", supplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.DEBUG, event.level);
+ assertEquals("abc Hi", event.message.getFormattedMessage());
+ }
+
+ @Test
+ public void testDebugMarkerStringParamSupplier() {
+ logger2.disable().debug(marker, "abc {}", supplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().debug(marker, "abc {}", supplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.DEBUG, event.level);
+ assertSame(marker, event.marker);
+ assertEquals("abc Hi", event.message.getFormattedMessage());
+ }
+
+ @Test
+ public void testErrorMarkerMessageSupplier() {
+ logger2.disable().error(marker, messageSupplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(messageSupplier.invoked);
+
+ logger2.enable().error(marker, messageSupplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(messageSupplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.ERROR, event.level);
+ assertSame(message, event.message);
+ assertSame(marker, event.marker);
+ }
+
+ @Test
+ public void testErrorMessageSupplier() {
+ logger2.disable().error(messageSupplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(messageSupplier.invoked);
+
+ logger2.enable().error(messageSupplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(messageSupplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.ERROR, event.level);
+ assertSame(message, event.message);
+ }
+
+ @Test
+ public void testErrorMarkerMessageSupplierThrowable() {
+ logger2.disable().error(marker, messageSupplier, throwable);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(messageSupplier.invoked);
+
+ logger2.enable().error(marker, messageSupplier, throwable);
+ assertEquals(1, logger2.list.size());
+ assertTrue(messageSupplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.ERROR, event.level);
+ assertSame(marker, event.marker);
+ assertSame(message, event.message);
+ assertSame(throwable, event.throwable);
+ }
+
+ @Test
+ public void testErrorMessageSupplierThrowable() {
+ logger2.disable().error(messageSupplier, throwable);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(messageSupplier.invoked);
+
+ logger2.enable().error(messageSupplier, throwable);
+ assertEquals(1, logger2.list.size());
+ assertTrue(messageSupplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.ERROR, event.level);
+ assertSame(message, event.message);
+ assertSame(throwable, event.throwable);
+ }
+
+ @Test
+ public void testErrorMarkerSupplier() {
+ logger2.disable().error(marker, supplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().error(marker, supplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.ERROR, event.level);
+ assertSame(stringMessage, event.message.getFormattedMessage());
+ assertSame(marker, event.marker);
+ }
+
+ @Test
+ public void testErrorSupplier() {
+ logger2.disable().error(supplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().error(supplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.ERROR, event.level);
+ assertSame(stringMessage, event.message.getFormattedMessage());
+ }
+
+ @Test
+ public void testErrorMarkerSupplierThrowable() {
+ logger2.disable().error(marker, supplier, throwable);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().error(marker, supplier, throwable);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.ERROR, event.level);
+ assertSame(marker, event.marker);
+ assertSame(stringMessage, event.message.getFormattedMessage());
+ assertSame(throwable, event.throwable);
+ }
+
+ @Test
+ public void testErrorSupplierThrowable() {
+ logger2.disable().error(supplier, throwable);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().error(supplier, throwable);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.ERROR, event.level);
+ assertSame(stringMessage, event.message.getFormattedMessage());
+ assertSame(throwable, event.throwable);
+ }
+
+ @Test
+ public void testErrorStringParamSupplier() {
+ logger2.disable().error("abc {}", supplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().error("abc {}", supplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.ERROR, event.level);
+ assertEquals("abc Hi", event.message.getFormattedMessage());
+ }
+
+ @Test
+ public void testErrorMarkerStringParamSupplier() {
+ logger2.disable().error(marker, "abc {}", supplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().error(marker, "abc {}", supplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.ERROR, event.level);
+ assertSame(marker, event.marker);
+ assertEquals("abc Hi", event.message.getFormattedMessage());
+ }
+
+ @Test
+ public void testFatalMarkerMessageSupplier() {
+ logger2.disable().fatal(marker, messageSupplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(messageSupplier.invoked);
+
+ logger2.enable().fatal(marker, messageSupplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(messageSupplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.FATAL, event.level);
+ assertSame(message, event.message);
+ assertSame(marker, event.marker);
+ }
+
+ @Test
+ public void testFatalMessageSupplier() {
+ logger2.disable().fatal(messageSupplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(messageSupplier.invoked);
+
+ logger2.enable().fatal(messageSupplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(messageSupplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.FATAL, event.level);
+ assertSame(message, event.message);
+ }
+
+ @Test
+ public void testFatalMarkerMessageSupplierThrowable() {
+ logger2.disable().fatal(marker, messageSupplier, throwable);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(messageSupplier.invoked);
+
+ logger2.enable().fatal(marker, messageSupplier, throwable);
+ assertEquals(1, logger2.list.size());
+ assertTrue(messageSupplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.FATAL, event.level);
+ assertSame(marker, event.marker);
+ assertSame(message, event.message);
+ assertSame(throwable, event.throwable);
+ }
+
+ @Test
+ public void testFatalMessageSupplierThrowable() {
+ logger2.disable().fatal(messageSupplier, throwable);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(messageSupplier.invoked);
+
+ logger2.enable().fatal(messageSupplier, throwable);
+ assertEquals(1, logger2.list.size());
+ assertTrue(messageSupplier.invoked);
LogEvent event = logger2.list.get(0);
+ assertEquals(Level.FATAL, event.level);
assertSame(message, event.message);
assertSame(throwable, event.throwable);
}
+ @Test
+ public void testFatalMarkerSupplier() {
+ logger2.disable().fatal(marker, supplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().fatal(marker, supplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.FATAL, event.level);
+ assertSame(stringMessage, event.message.getFormattedMessage());
+ assertSame(marker, event.marker);
+ }
+
+ @Test
+ public void testFatalSupplier() {
+ logger2.disable().fatal(supplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().fatal(supplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.FATAL, event.level);
+ assertSame(stringMessage, event.message.getFormattedMessage());
+ }
+
+ @Test
+ public void testFatalMarkerSupplierThrowable() {
+ logger2.disable().fatal(marker, supplier, throwable);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().fatal(marker, supplier, throwable);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.FATAL, event.level);
+ assertSame(marker, event.marker);
+ assertSame(stringMessage, event.message.getFormattedMessage());
+ assertSame(throwable, event.throwable);
+ }
+
+ @Test
+ public void testFatalSupplierThrowable() {
+ logger2.disable().fatal(supplier, throwable);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().fatal(supplier, throwable);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.FATAL, event.level);
+ assertSame(stringMessage, event.message.getFormattedMessage());
+ assertSame(throwable, event.throwable);
+ }
+
+ @Test
+ public void testFatalStringParamSupplier() {
+ logger2.disable().fatal("abc {}", supplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().fatal("abc {}", supplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.FATAL, event.level);
+ assertEquals("abc Hi", event.message.getFormattedMessage());
+ }
+
+ @Test
+ public void testFatalMarkerStringParamSupplier() {
+ logger2.disable().fatal(marker, "abc {}", supplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().fatal(marker, "abc {}", supplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.FATAL, event.level);
+ assertSame(marker, event.marker);
+ assertEquals("abc Hi", event.message.getFormattedMessage());
+ }
+
+ @Test
+ public void testInfoMarkerMessageSupplier() {
+ logger2.disable().info(marker, messageSupplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(messageSupplier.invoked);
+
+ logger2.enable().info(marker, messageSupplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(messageSupplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.INFO, event.level);
+ assertSame(message, event.message);
+ assertSame(marker, event.marker);
+ }
+
+ @Test
+ public void testInfoMessageSupplier() {
+ logger2.disable().info(messageSupplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(messageSupplier.invoked);
+
+ logger2.enable().info(messageSupplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(messageSupplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.INFO, event.level);
+ assertSame(message, event.message);
+ }
+
+ @Test
+ public void testInfoMarkerMessageSupplierThrowable() {
+ logger2.disable().info(marker, messageSupplier, throwable);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(messageSupplier.invoked);
+
+ logger2.enable().info(marker, messageSupplier, throwable);
+ assertEquals(1, logger2.list.size());
+ assertTrue(messageSupplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.INFO, event.level);
+ assertSame(marker, event.marker);
+ assertSame(message, event.message);
+ assertSame(throwable, event.throwable);
+ }
+
+ @Test
+ public void testInfoMessageSupplierThrowable() {
+ logger2.disable().info(messageSupplier, throwable);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(messageSupplier.invoked);
+
+ logger2.enable().info(messageSupplier, throwable);
+ assertEquals(1, logger2.list.size());
+ assertTrue(messageSupplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.INFO, event.level);
+ assertSame(message, event.message);
+ assertSame(throwable, event.throwable);
+ }
+
+ @Test
+ public void testInfoMarkerSupplier() {
+ logger2.disable().info(marker, supplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().info(marker, supplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.INFO, event.level);
+ assertSame(stringMessage, event.message.getFormattedMessage());
+ assertSame(marker, event.marker);
+ }
+
+ @Test
+ public void testInfoSupplier() {
+ logger2.disable().info(supplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().info(supplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.INFO, event.level);
+ assertSame(stringMessage, event.message.getFormattedMessage());
+ }
+
+ @Test
+ public void testInfoMarkerSupplierThrowable() {
+ logger2.disable().info(marker, supplier, throwable);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().info(marker, supplier, throwable);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.INFO, event.level);
+ assertSame(marker, event.marker);
+ assertSame(stringMessage, event.message.getFormattedMessage());
+ assertSame(throwable, event.throwable);
+ }
+
+ @Test
+ public void testInfoSupplierThrowable() {
+ logger2.disable().info(supplier, throwable);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().info(supplier, throwable);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.INFO, event.level);
+ assertSame(stringMessage, event.message.getFormattedMessage());
+ assertSame(throwable, event.throwable);
+ }
+
+ @Test
+ public void testInfoStringParamSupplier() {
+ logger2.disable().info("abc {}", supplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().info("abc {}", supplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.INFO, event.level);
+ assertEquals("abc Hi", event.message.getFormattedMessage());
+ }
+
+ @Test
+ public void testInfoMarkerStringParamSupplier() {
+ logger2.disable().info(marker, "abc {}", supplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().info(marker, "abc {}", supplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.INFO, event.level);
+ assertSame(marker, event.marker);
+ assertEquals("abc Hi", event.message.getFormattedMessage());
+ }
+
+ @Test
+ public void testTraceMarkerMessageSupplier() {
+ logger2.disable().trace(marker, messageSupplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(messageSupplier.invoked);
+
+ logger2.enable().trace(marker, messageSupplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(messageSupplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.TRACE, event.level);
+ assertSame(message, event.message);
+ assertSame(marker, event.marker);
+ }
+
+ @Test
+ public void testTraceMessageSupplier() {
+ logger2.disable().trace(messageSupplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(messageSupplier.invoked);
+
+ logger2.enable().trace(messageSupplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(messageSupplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.TRACE, event.level);
+ assertSame(message, event.message);
+ }
+
+ @Test
+ public void testTraceMarkerMessageSupplierThrowable() {
+ logger2.disable().trace(marker, messageSupplier, throwable);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(messageSupplier.invoked);
+
+ logger2.enable().trace(marker, messageSupplier, throwable);
+ assertEquals(1, logger2.list.size());
+ assertTrue(messageSupplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.TRACE, event.level);
+ assertSame(marker, event.marker);
+ assertSame(message, event.message);
+ assertSame(throwable, event.throwable);
+ }
+
+ @Test
+ public void testTraceMessageSupplierThrowable() {
+ logger2.disable().trace(messageSupplier, throwable);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(messageSupplier.invoked);
+
+ logger2.enable().trace(messageSupplier, throwable);
+ assertEquals(1, logger2.list.size());
+ assertTrue(messageSupplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.TRACE, event.level);
+ assertSame(message, event.message);
+ assertSame(throwable, event.throwable);
+ }
+
+ @Test
+ public void testTraceMarkerSupplier() {
+ logger2.disable().trace(marker, supplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().trace(marker, supplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.TRACE, event.level);
+ assertSame(stringMessage, event.message.getFormattedMessage());
+ assertSame(marker, event.marker);
+ }
+
+ @Test
+ public void testTraceSupplier() {
+ logger2.disable().trace(supplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().trace(supplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.TRACE, event.level);
+ assertSame(stringMessage, event.message.getFormattedMessage());
+ }
+
+ @Test
+ public void testTraceMarkerSupplierThrowable() {
+ logger2.disable().trace(marker, supplier, throwable);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().trace(marker, supplier, throwable);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.TRACE, event.level);
+ assertSame(marker, event.marker);
+ assertSame(stringMessage, event.message.getFormattedMessage());
+ assertSame(throwable, event.throwable);
+ }
+
+ @Test
+ public void testTraceSupplierThrowable() {
+ logger2.disable().trace(supplier, throwable);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().trace(supplier, throwable);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.TRACE, event.level);
+ assertSame(stringMessage, event.message.getFormattedMessage());
+ assertSame(throwable, event.throwable);
+ }
+
+ @Test
+ public void testTraceStringParamSupplier() {
+ logger2.disable().trace("abc {}", supplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().trace("abc {}", supplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.TRACE, event.level);
+ assertEquals("abc Hi", event.message.getFormattedMessage());
+ }
+
+ @Test
+ public void testTraceMarkerStringParamSupplier() {
+ logger2.disable().trace(marker, "abc {}", supplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().trace(marker, "abc {}", supplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.TRACE, event.level);
+ assertSame(marker, event.marker);
+ assertEquals("abc Hi", event.message.getFormattedMessage());
+ }
+
+ @Test
+ public void testWarnMarkerMessageSupplier() {
+ logger2.disable().warn(marker, messageSupplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(messageSupplier.invoked);
+
+ logger2.enable().warn(marker, messageSupplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(messageSupplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.WARN, event.level);
+ assertSame(message, event.message);
+ assertSame(marker, event.marker);
+ }
+
+ @Test
+ public void testWarnMessageSupplier() {
+ logger2.disable().warn(messageSupplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(messageSupplier.invoked);
+
+ logger2.enable().warn(messageSupplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(messageSupplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.WARN, event.level);
+ assertSame(message, event.message);
+ }
+
+ @Test
+ public void testWarnMarkerMessageSupplierThrowable() {
+ logger2.disable().warn(marker, messageSupplier, throwable);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(messageSupplier.invoked);
+
+ logger2.enable().warn(marker, messageSupplier, throwable);
+ assertEquals(1, logger2.list.size());
+ assertTrue(messageSupplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.WARN, event.level);
+ assertSame(marker, event.marker);
+ assertSame(message, event.message);
+ assertSame(throwable, event.throwable);
+ }
+
+ @Test
+ public void testWarnMessageSupplierThrowable() {
+ logger2.disable().warn(messageSupplier, throwable);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(messageSupplier.invoked);
+
+ logger2.enable().warn(messageSupplier, throwable);
+ assertEquals(1, logger2.list.size());
+ assertTrue(messageSupplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.WARN, event.level);
+ assertSame(message, event.message);
+ assertSame(throwable, event.throwable);
+ }
+
+ @Test
+ public void testWarnMarkerSupplier() {
+ logger2.disable().warn(marker, supplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().warn(marker, supplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.WARN, event.level);
+ assertSame(stringMessage, event.message.getFormattedMessage());
+ assertSame(marker, event.marker);
+ }
+
+ @Test
+ public void testWarnSupplier() {
+ logger2.disable().warn(supplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().warn(supplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.WARN, event.level);
+ assertSame(stringMessage, event.message.getFormattedMessage());
+ }
+
+ @Test
+ public void testWarnMarkerSupplierThrowable() {
+ logger2.disable().warn(marker, supplier, throwable);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().warn(marker, supplier, throwable);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.WARN, event.level);
+ assertSame(marker, event.marker);
+ assertSame(stringMessage, event.message.getFormattedMessage());
+ assertSame(throwable, event.throwable);
+ }
+
+ @Test
+ public void testWarnSupplierThrowable() {
+ logger2.disable().warn(supplier, throwable);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().warn(supplier, throwable);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.WARN, event.level);
+ assertSame(stringMessage, event.message.getFormattedMessage());
+ assertSame(throwable, event.throwable);
+ }
+
+ @Test
+ public void testWarnStringParamSupplier() {
+ logger2.disable().warn("abc {}", supplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().warn("abc {}", supplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.WARN, event.level);
+ assertEquals("abc Hi", event.message.getFormattedMessage());
+ }
+
+ @Test
+ public void testWarnMarkerStringParamSupplier() {
+ logger2.disable().warn(marker, "abc {}", supplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().warn(marker, "abc {}", supplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.WARN, event.level);
+ assertSame(marker, event.marker);
+ assertEquals("abc Hi", event.message.getFormattedMessage());
+ }
+
+ @Test
+ public void testLogMarkerMessageSupplier() {
+ logger2.disable().log(Level.WARN, marker, messageSupplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(messageSupplier.invoked);
+
+ logger2.enable().log(Level.WARN, marker, messageSupplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(messageSupplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.WARN, event.level);
+ assertSame(message, event.message);
+ assertSame(marker, event.marker);
+ }
+
+ @Test
+ public void testLogMessageSupplier() {
+ logger2.disable().log(Level.WARN, messageSupplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(messageSupplier.invoked);
+
+ logger2.enable().log(Level.WARN, messageSupplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(messageSupplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.WARN, event.level);
+ assertSame(message, event.message);
+ }
+
+ @Test
+ public void testLogMarkerMessageSupplierThrowable() {
+ logger2.disable().log(Level.WARN, marker, messageSupplier, throwable);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(messageSupplier.invoked);
+
+ logger2.enable().log(Level.WARN, marker, messageSupplier, throwable);
+ assertEquals(1, logger2.list.size());
+ assertTrue(messageSupplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.WARN, event.level);
+ assertSame(marker, event.marker);
+ assertSame(message, event.message);
+ assertSame(throwable, event.throwable);
+ }
+
+ @Test
+ public void testLogMessageSupplierThrowable() {
+ logger2.disable().log(Level.WARN, messageSupplier, throwable);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(messageSupplier.invoked);
+
+ logger2.enable().log(Level.WARN, messageSupplier, throwable);
+ assertEquals(1, logger2.list.size());
+ assertTrue(messageSupplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.WARN, event.level);
+ assertSame(message, event.message);
+ assertSame(throwable, event.throwable);
+ }
+
+ @Test
+ public void testLogMarkerSupplier() {
+ logger2.disable().log(Level.WARN, marker, supplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().log(Level.WARN, marker, supplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.WARN, event.level);
+ assertSame(stringMessage, event.message.getFormattedMessage());
+ assertSame(marker, event.marker);
+ }
+
+ @Test
+ public void testLogSupplier() {
+ logger2.disable().log(Level.WARN, supplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().log(Level.WARN, supplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.WARN, event.level);
+ assertSame(stringMessage, event.message.getFormattedMessage());
+ }
+
+ @Test
+ public void testLogMarkerSupplierThrowable() {
+ logger2.disable().log(Level.WARN, marker, supplier, throwable);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().log(Level.WARN, marker, supplier, throwable);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.WARN, event.level);
+ assertSame(marker, event.marker);
+ assertSame(stringMessage, event.message.getFormattedMessage());
+ assertSame(throwable, event.throwable);
+ }
+
+ @Test
+ public void testLogSupplierThrowable() {
+ logger2.disable().log(Level.WARN, supplier, throwable);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().log(Level.WARN, supplier, throwable);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.WARN, event.level);
+ assertSame(stringMessage, event.message.getFormattedMessage());
+ assertSame(throwable, event.throwable);
+ }
+
+ @Test
+ public void testLogStringParamSupplier() {
+ logger2.disable().log(Level.WARN, "abc {}", supplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().log(Level.WARN, "abc {}", supplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.WARN, event.level);
+ assertEquals("abc Hi", event.message.getFormattedMessage());
+ }
+
+ @Test
+ public void testLogMarkerStringParamSupplier() {
+ logger2.disable().log(Level.WARN, marker, "abc {}", supplier);
+ assertTrue(logger2.list.isEmpty());
+ assertFalse(supplier.invoked);
+
+ logger2.enable().log(Level.WARN, marker, "abc {}", supplier);
+ assertEquals(1, logger2.list.size());
+ assertTrue(supplier.invoked);
+
+ LogEvent event = logger2.list.get(0);
+ assertEquals(Level.WARN, event.level);
+ assertSame(marker, event.marker);
+ assertEquals("abc Hi", event.message.getFormattedMessage());
+ }
+
}