More accurate log processing.

core/src/main/java/org/testcontainers/containers/output/BaseConsumer.java

@@ -0,0 +1,76 @@
+package org.testcontainers.containers.output;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Consumer;
+
+@SuppressWarnings("Duplicates")
+public abstract class BaseConsumer<SELF extends BaseConsumer<SELF>> implements Consumer<OutputFrame> {
+    private StringBuilder logString = new StringBuilder();
+    private OutputFrame brokenFrame;
+    private boolean removeColorCodes = true;
+
+    public SELF withRemoveAnsiCodes(boolean removeAnsiCodes) {
+        this.removeColorCodes = removeAnsiCodes;
+        return (SELF) this;
+    }
+
+    public abstract void process(OutputFrame outputFrame);
+
+    @Override
+    public final synchronized void accept(OutputFrame outputFrame) {
+        if (outputFrame != null) {
+            String utf8String = outputFrame.getUtf8String();
+            byte[] bytes = outputFrame.getBytes();
+
+            if (utf8String != null && !utf8String.isEmpty()) {
+                // Merging the strings by bytes to solve the problem breaking non-latin unicode symbols.
+                if (brokenFrame != null) {
+                    bytes = merge(brokenFrame.getBytes(), bytes);
+                    utf8String = new String(bytes);
+                    brokenFrame = null;
+                }
+                // Logger chunks can break the string in middle of multibyte unicode character.
+                // Backup the bytes to reconstruct proper char sequence with bytes from next line.
+                if (Character.getType(utf8String.charAt(utf8String.length() - 1)) == Character.OTHER_SYMBOL) {
+                    brokenFrame = new OutputFrame(outputFrame.getType(), bytes);
+                    return;
+                }
+
+                if (removeColorCodes) {
+                    utf8String = utf8String.replaceAll("\u001B\\[[0-9;]+m", "");
+                }
+
+                // Reformat strings to normalize enters.
+                List<String> lines = new ArrayList<>(Arrays.asList(utf8String.split("((\\r?\\n)|(\\r))")));
+                if (lines.isEmpty()) {
+                    process(new OutputFrame(outputFrame.getType(), "".getBytes()));
+                    return;
+                }
+                if (utf8String.startsWith("\n") || utf8String.startsWith("\r")) {
+                    lines.add(0, "");
+                }
+                if (utf8String.endsWith("\n") || utf8String.endsWith("\r")) {
+                    lines.add("");
+                }
+                for (int i = 0; i < lines.size() - 1; i++) {
+                    String line = lines.get(i);
+                    if (i == 0 && logString.length() > 0) {
+                        line = logString.toString() + line;
+                        logString.setLength(0);
+                    }
+                    process(new OutputFrame(outputFrame.getType(), line.getBytes()));
+                }
+                logString.append(lines.get(lines.size() - 1));
+            }
+        }
+    }
+
+    private byte[] merge(byte[] str1, byte[] str2) {
+        byte[] mergedString = new byte[str1.length + str2.length];
+        System.arraycopy(str1, 0, mergedString, 0, str1.length);
+        System.arraycopy(str2, 0, mergedString, str1.length, str2.length);
+        return mergedString;
+    }
+}

core/src/main/java/org/testcontainers/containers/output/Slf4jLogConsumer.java

@@ -2,18 +2,13 @@
 
 import org.slf4j.Logger;
 
-import java.util.function.Consumer;
-import java.util.regex.Pattern;
-
 /**
  * A consumer for container output that logs output to an SLF4J logger.
  */
-public class Slf4jLogConsumer implements Consumer<OutputFrame> {
+public class Slf4jLogConsumer extends BaseConsumer<Slf4jLogConsumer> {
     private final Logger logger;
     private String prefix = "";
 
-    private static final Pattern ANSI_CODE_PATTERN = Pattern.compile("\\[\\d[ABCD]");
-
     public Slf4jLogConsumer(Logger logger) {
         this.logger = logger;
     }
@@ -24,29 +19,19 @@ public Slf4jLogConsumer withPrefix(String prefix) {
     }
 
     @Override
-    public void accept(OutputFrame outputFrame) {
-        if (outputFrame != null) {
-            String utf8String = outputFrame.getUtf8String();
-
-            if (utf8String != null) {
-                OutputFrame.OutputType outputType = outputFrame.getType();
-                String message = utf8String.trim();
-
-                if (ANSI_CODE_PATTERN.matcher(message).matches()) {
-                    return;
-                }
-
-                switch (outputType) {
-                    case END:
-                        break;
-                    case STDOUT:
-                    case STDERR:
-                        logger.info("{}{}: {}", prefix, outputType, message);
-                        break;
-                    default:
-                        throw new IllegalArgumentException("Unexpected outputType " + outputType);
-                }
-            }
+    public void process(OutputFrame outputFrame) {
+        OutputFrame.OutputType outputType = outputFrame.getType();
+
+        String utf8String = outputFrame.getUtf8String();
+        switch (outputType) {
+            case END:
+                break;
+            case STDOUT:
+            case STDERR:
+                logger.info("{}{}: {}", prefix, outputType, utf8String);
+                break;
+            default:
+                throw new IllegalArgumentException("Unexpected outputType " + outputType);
         }
     }
 }

core/src/main/java/org/testcontainers/containers/output/ToStringConsumer.java

@@ -5,20 +5,21 @@
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.nio.charset.Charset;
-import java.util.function.Consumer;
 
 /**
  * Created by rnorth on 26/03/2016.
  */
-public class ToStringConsumer implements Consumer<OutputFrame> {
+public class ToStringConsumer extends BaseConsumer<ToStringConsumer> {
+    private static final byte[] ENTER_BYTES = "\n".getBytes();
 
     private ByteArrayOutputStream stringBuffer = new ByteArrayOutputStream();
 
     @Override
-    public void accept(OutputFrame outputFrame) {
+    public void process(OutputFrame outputFrame) {
         try {
             if (outputFrame.getBytes() != null) {
                 stringBuffer.write(outputFrame.getBytes());
+                stringBuffer.write(ENTER_BYTES);
                 stringBuffer.flush();
             }
         } catch (IOException e) {

core/src/main/java/org/testcontainers/containers/output/WaitingConsumer.java

@@ -6,21 +6,20 @@
 import java.util.concurrent.LinkedBlockingDeque;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
-import java.util.function.Consumer;
 import java.util.function.Predicate;
 
 /**
  * A consumer for container output that buffers lines in a {@link java.util.concurrent.BlockingDeque} and enables tests
  * to wait for a matching condition.
  */
-public class WaitingConsumer implements Consumer<OutputFrame> {
+public class WaitingConsumer extends BaseConsumer<WaitingConsumer> {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(WaitingConsumer.class);
 
     private LinkedBlockingDeque<OutputFrame> frames = new LinkedBlockingDeque<>();
 
     @Override
-    public void accept(OutputFrame frame) {
+    public void process(OutputFrame frame) {
         frames.add(frame);
     }