more docs

.ignore

@@ -0,0 +1,3 @@
+
+*.iml
+.idea

src/main/java/slf4jtest/LogMessage.java

@@ -1,16 +1,20 @@
 package slf4jtest;
 
 class LogMessage {
+    final String logName;
     final LogLevel level;
-    final String message;
+    final String text;
+    final long timeStamp = System.currentTimeMillis();
+    final String threadName = Thread.currentThread().getName();
 
-    public LogMessage(LogLevel level, String message) {
+    public LogMessage(String logName, LogLevel level, String formattedMessage) {
+        this.logName = logName;
         this.level = level;
-        this.message = message;
+        this.text = formattedMessage;
     }
 
     @Override
     public String toString() {
-        return "LogMessage(" + level + "," + message + ")";
+        return "LogMessage(" + logName + "," + level + "," + text + ")";
     }
 }

src/main/java/slf4jtest/LoggerExtensionsImpl.java

@@ -8,21 +8,32 @@
 
 class LoggerExtensionsImpl implements LoggerExtensions {
     private final Settings settings;
+    private final long startTime;
     private final Queue<LogMessage> rows = new ConcurrentLinkedQueue<>();
 
-    public LoggerExtensionsImpl(Settings settings) {
+    public LoggerExtensionsImpl(Settings settings, long startTime) {
         this.settings = settings;
+        this.startTime = startTime;
     }
 
-    public void record(LogLevel level, String msg) {
-        rows.add(new LogMessage(level, msg));
-        if (settings.print && !isSuppressed(msg)) {
-            PrintStream out = settings.printStreams.get(level);
-            out.println(level + ": " + msg);
+    public void record(LogMessage message) {
+        rows.add(message);
+        if (settings.print && !isSuppressed(message.text)) {
+            PrintStream out = settings.printStreams.get(message.level);
+            out.println(layout(message));
             out.flush();
         }
     }
 
+    public String layout(LogMessage message) {
+        long delta = message.timeStamp - startTime;
+        return delta +
+                " " + message.level +
+                " [" + message.threadName + "] " +
+                message.logName +
+                " - " + message.text;
+    }
+
     private boolean isSuppressed(String msg) {
         for (String regex : settings.printSuppressions) {
             if (msg.matches(regex)) return true;
@@ -36,14 +47,14 @@ public Collection<LogMessage> lines() {
 
     public boolean contains(String regex) {
         for (LogMessage row : rows) {
-            if (row.message.matches(regex)) return true;
+            if (row.text.matches(regex)) return true;
         }
         return false;
     }
 
     public boolean contains(LogLevel level, String regex) {
         for (LogMessage row : rows) {
-            if (row.level == level && row.message.matches(regex)) return true;
+            if (row.level == level && row.text.matches(regex)) return true;
         }
         return false;
     }

src/main/java/slf4jtest/Settings.java

@@ -87,6 +87,10 @@ public Settings delegates(Map<String, Logger> delegates) {
         return new Settings(print, printStreams, printSuppressions, enabledLevels, delegates);
     }
 
+    public Settings delegate(Class<?> loggerName, Logger logger) {
+        return delegate(loggerName.getName(), logger);
+    }
+
     public Settings delegate(String loggerName, Logger logger) {
         Map<String, Logger> newDelegates = new HashMap<>(delegates);
         newDelegates.put(loggerName, logger);

src/main/java/slf4jtest/TestLoggerFactory.java

@@ -18,6 +18,8 @@
 import java.util.concurrent.ConcurrentMap;
 
 public class TestLoggerFactory implements LoggerFactoryExtensions {
+    private final long startTime = System.currentTimeMillis();
+
     private final Settings settings;
 
     private final ConcurrentMap<String, TestLogger> loggers = new ConcurrentHashMap<>();
@@ -30,6 +32,22 @@ public TestLoggerFactory() {
         this.settings = new Settings();
     }
 
+    /** check across all loggers */
+    public boolean contains(LogLevel level, String regex) {
+        for (TestLogger l : loggers.values()) {
+            if (l.contains(level, regex)) return true;
+        }
+        return false;
+    }
+
+    /** check across all loggers */
+    public boolean contains(String regex) {
+        for (TestLogger l : loggers.values()) {
+            if (l.contains(regex)) return true;
+        }
+        return false;
+    }
+
     @Override
     public TestLogger getLogger(String name) {
 
@@ -74,7 +92,7 @@ public boolean loggerExists(Class<?> name) {
     private TestLogger createMock(final Settings settings, final String logName) {
 
         InvocationHandler handler = new InvocationHandler() {
-            LoggerExtensionsImpl extension = new LoggerExtensionsImpl(settings);
+            LoggerExtensionsImpl extension = new LoggerExtensionsImpl(settings, startTime);
 
             @Override
             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
@@ -97,41 +115,10 @@ public Object invoke(Object proxy, Method method, Object[] args) throws Throwabl
 
                     if (logFnNameToLogLevel.containsKey(name)) {
                         LogLevel l = logFnNameToLogLevel.get(name);
-                        Class<?>[] paramTypes = method.getParameterTypes();
-
-                        StringBuilder s = new StringBuilder();
-                        int p = 0;
-                        if (paramTypes[0] == Marker.class) {
-                            p++;
-                        }
-
-                        if (paramTypes.length - p == 1) {
-                            s.append(args[p].toString());
-                        } else {
-                            String format = args[p].toString();
-
-                            FormattingTuple ft;
-                            if (paramTypes[p + 1] == Object[].class) {
-                                ft = MessageFormatter.arrayFormat(format, (Object[]) args[p + 1]);
-                            } else {
-                                Object[] arr = new Object[args.length - 1 - p];
-                                for (int i = 0; i < args.length - p - 1; i++) {
-                                    arr[i] = args[i + 1 + p];
-                                }
-
-                                ft = MessageFormatter.arrayFormat(format, arr);
-                            }
-                            s.append(ft.getMessage());
-
-                            if (null != ft.getThrowable()) {
-                                StringWriter sw = new StringWriter();
-                                ft.getThrowable().printStackTrace(new PrintWriter(sw));
-                                s.append("\n");
-                                s.append(sw.toString());
-                            }
-                        }
-
-                        extension.record(l, s.toString());
+                        String s = formatLogMessage(method, args);
+
+                        LogMessage message = new LogMessage(logName, l, s);
+                        extension.record(message);
                     }
 
                     return null;
@@ -157,4 +144,42 @@ no need to specify any expectation (when's) on that mock either.
                 new Class<?>[]{TestLogger.class},
                 handler);
     }
+
+    private String formatLogMessage(Method method, Object[] args) {
+        Class<?>[] paramTypes = method.getParameterTypes();
+        StringBuilder s = new StringBuilder();
+
+        int p = 0;
+        if (paramTypes[0] == Marker.class) {
+            p++;
+        }
+
+        if (paramTypes.length - p == 1) {
+            s.append(args[p].toString());
+        } else {
+            String format = args[p].toString();
+
+            FormattingTuple ft;
+            if (paramTypes[p + 1] == Object[].class) {
+                ft = MessageFormatter.arrayFormat(format, (Object[]) args[p + 1]);
+            } else {
+                Object[] arr = new Object[args.length - 1 - p];
+                for (int i = 0; i < args.length - p - 1; i++) {
+                    arr[i] = args[i + 1 + p];
+                }
+
+                ft = MessageFormatter.arrayFormat(format, arr);
+            }
+            s.append(ft.getMessage());
+
+            if (null != ft.getThrowable()) {
+                StringWriter sw = new StringWriter();
+                ft.getThrowable().printStackTrace(new PrintWriter(sw));
+                s.append("\n");
+                s.append(sw.toString());
+            }
+
+        }
+        return s.toString();
+    }
 }

src/test/java/slf4jtest/BasicExampleUnitTest.java

@@ -1,43 +1,34 @@
 package slf4jtest;
 
 import org.junit.Test;
-import org.mockito.Mockito;
+import org.slf4j.ILoggerFactory;
 import org.slf4j.Logger;
 
 import static org.junit.Assert.assertTrue;
 
-public class BasicExampleUnitTest {
+class BasicExample {
 
-    @Test
-    public void testAMethodThatLogs() throws Exception {
-        TestLoggerFactory loggerFactory = new TestLoggerFactory();
-
-        BasicExample sut = new BasicExample(loggerFactory);
-        sut.aMethodThatLogs();
+    private final Logger logger;
 
-        TestLogger logger = loggerFactory.getLogger(BasicExample.class.getName());
-        assertTrue(logger.contains(".*Hello.*"));
+    public BasicExample(ILoggerFactory lf) {
+        this.logger = lf.getLogger(BasicExample.class.getName());
     }
 
-    @Test
-    public void testAMethodThatLogsWithAMock() throws Exception {
-        Logger mockLogger = Mockito.mock(Logger.class);
-
-        Settings cfg = new Settings().delegate(BasicExample.class.getName(), mockLogger);
-        TestLoggerFactory loggerFactory = new TestLoggerFactory(cfg);
-
-        BasicExample sut = new BasicExample(loggerFactory);
-        sut.aMethodThatLogs();
-
-        Mockito.verify(mockLogger).info("Hello World!");
+    public void doLogging() {
+        logger.info("Hello World!");
     }
+}
 
-    @Test
-    public void testAMethodThatSuppresses() throws Exception {
+public class BasicExampleUnitTest {
 
-        Settings cfg = new Settings().suppressPrinting(".*Pattern to suppress.*");
-        TestLoggerFactory loggerFactory = new TestLoggerFactory(cfg);
+    @Test
+    public void testBasicDemo() throws Exception {
+        TestLoggerFactory loggerFactory = new TestLoggerFactory();
 
+        BasicExample sut = new BasicExample(loggerFactory);
+        sut.doLogging();
 
+        TestLogger logger = loggerFactory.getLogger(BasicExample.class);
+        assertTrue(logger.contains(".*Hello.*"));
     }
 }