fix: fix sporadic ConcurrentModificationExceptions

Logback's ListAppender isn't thread safe unfortunately. Replace it with
our own ConcurrentListAppender.

Author: netmikey

logunit-logback/src/main/java/io/github/netmikey/logunit/logback/ConcurrentListAppender.java

@@ -0,0 +1,37 @@
+package io.github.netmikey.logunit.logback;
+
+import java.util.List;
+import java.util.Spliterator;
+import java.util.concurrent.ConcurrentLinkedQueue;
+
+import ch.qos.logback.core.AppenderBase;
+import ch.qos.logback.core.read.ListAppender;
+
+/**
+ * Unfortunately, Logback's {@link ListAppender} isn't thread safe. This is a
+ * thread-safe variant based on it. Technically speaking, it doesn't use a
+ * {@link List} but a {@link ConcurrentLinkedQueue} and exposes items using a
+ * {@link Splierator}.
+ * 
+ * @See ListAppender
+ * 
+ * @param <E>
+ *            The list element type.
+ */
+public class ConcurrentListAppender<E> extends AppenderBase<E> {
+
+    private ConcurrentLinkedQueue<E> list = new ConcurrentLinkedQueue<E>();
+
+    protected void append(E e) {
+        list.add(e);
+    }
+
+    /**
+     * Get the items.
+     * 
+     * @return A {@link Spliterator} over the items.
+     */
+    public Spliterator<E> spliterator() {
+        return list.spliterator();
+    }
+}

logunit-logback/src/main/java/io/github/netmikey/logunit/logback/LogbackLogProvider.java

@@ -5,6 +5,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
+import java.util.stream.StreamSupport;
 
 import org.junit.jupiter.api.extension.ExtensionContext;
 import org.slf4j.LoggerFactory;
@@ -16,7 +17,6 @@
 import ch.qos.logback.classic.spi.ILoggingEvent;
 import ch.qos.logback.classic.spi.IThrowableProxy;
 import ch.qos.logback.classic.spi.ThrowableProxy;
-import ch.qos.logback.core.read.ListAppender;
 import io.github.netmikey.logunit.api.LogCapturer;
 import io.github.netmikey.logunit.api.LogProvider;
 
@@ -47,7 +47,7 @@ public class LogbackLogProvider implements LogProvider {
         LEVEL_MAPPING_REVERSE = Collections.unmodifiableMap(levelMappingReverse);
     }
 
-    private final ListAppender<ILoggingEvent> listAppender = new ListAppender<ILoggingEvent>();
+    private final ConcurrentListAppender<ILoggingEvent> listAppender = new ConcurrentListAppender<ILoggingEvent>();
 
     private final Map<Class<?>, Level> loggerTypes = new HashMap<>();
 
@@ -75,7 +75,9 @@ public void provideForLogger(String name, org.slf4j.event.Level level) {
 
     @Override
     public List<LoggingEvent> getEvents() {
-        return listAppender.list.stream().map(this::mapEvent).collect(Collectors.toList());
+        return StreamSupport.stream(listAppender.spliterator(), false)
+            .map(this::mapEvent)
+            .collect(Collectors.toList());
     }
 
     @Override

logunit-logback/src/test/java/io/github/netmikey/logunit/logback/LogbackLogProviderConcurrencyTest.java

@@ -0,0 +1,79 @@
+package io.github.netmikey.logunit.logback;
+
+import java.util.ConcurrentModificationException;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.RepeatedTest;
+import org.junit.jupiter.api.Test;
+import org.slf4j.LoggerFactory;
+import org.slf4j.event.Level;
+
+import ch.qos.logback.core.read.ListAppender;
+
+/**
+ * There have been sightings of {@link ConcurrentModificationException}s caused
+ * by Logback's {@link ListAppender}. This test aims at reproducing this and
+ * testing the implemented {@link ConcurrentListAppender} solution.
+ */
+public class LogbackLogProviderConcurrencyTest {
+
+    private static final org.slf4j.Logger LOGGER = LoggerFactory.getLogger(LogbackLogProviderConcurrencyTest.class);
+
+    private static final int LOG_COUNT = 100;
+
+    private LogbackLogProvider tested;
+
+    private Thread loggingThread;
+
+    /**
+     * JUnit's beforeEach method.
+     */
+    @BeforeEach
+    public void beforeEach() {
+        // Prepare unit under test
+        tested = new LogbackLogProvider();
+        tested.provideForLogger(LOGGER.getName(), Level.TRACE);
+        tested.beforeTestExecution(null);
+
+        // Prepare a thread that is going to write logs
+        loggingThread = new Thread(() -> {
+            for (int i = 0; i < LOG_COUNT; i++) {
+                LOGGER.trace("It makes BOOM!");
+            }
+        });
+    }
+
+    /**
+     * JUnit's afterEach method.
+     * 
+     * @throws Exception
+     *             An unexpected exception occured.
+     */
+    @AfterEach
+    public void afterEach() throws Exception {
+        // Wait for the thread to terminate
+        loggingThread.join();
+
+        // Cleanup
+        tested.afterTestExecution(null);
+    }
+
+    /**
+     * Test the {@link LogbackLogProvider} for concurrency.
+     * 
+     * @throws Exception
+     *             An unexpected exception occurred.
+     */
+    @Test
+    @RepeatedTest(value = 15)
+    public void testConcurrency() throws Exception {
+        // Start the logging thread, and...
+        loggingThread.start();
+
+        // ... try to fetc log events concurrently
+        for (int i = 0; i < LOG_COUNT; i++) {
+            tested.getEvents();
+        }
+    }
+}