[Bug Fix]: ScriptUtils converts adjacent string literals to invalid syntax #11206

I've implemented the whitespace handling fix in ScriptSplitter to preserve a newline only when whitespace with an EOL appears between two quoted strings, and added a unit test to cover the reported case. 

I identified the whitespace-collapsing logic in ScriptSplitter that turned EOLs into spaces, which broke PostgreSQL’s adjacent string literal concatenation when a newline is required between literals.

I updated ScriptSplitter to defer whitespace emission and only preserve a newline when the whitespace contains an EOL and it separates two quoted strings; otherwise it still collapses to a single space. This keeps current behavior broadly intact while fixing the bug.

Author: marktech0813

modules/database-commons/src/main/java/org/testcontainers/ext/ScriptSplitter.java

@@ -19,41 +19,78 @@ class ScriptSplitter {
 
     private final StringBuilder sb = new StringBuilder();
 
+		// Tracks deferred whitespace between lexems in standard parsing mode
+		private boolean pendingWhitespace = false;
+		private boolean pendingWhitespaceHadEol = false;
+
     /**
      * Standard parsing:
      * 1. Remove comments
      * 2. Shrink whitespace and eols
      * 3. Split on separator
      */
     void split() {
-        Lexem l;
-        while ((l = scanner.next()) != Lexem.EOF) {
-            switch (l) {
-                case SEPARATOR:
-                    flushStringBuilder();
-                    break;
-                case COMMENT:
-                    //skip
-                    break;
-                case WHITESPACE:
-                    if (sb.length() == 0 || sb.charAt(sb.length() - 1) != ' ') {
-                        sb.append(' ');
-                    }
-                    break;
-                case IDENTIFIER:
-                    appendMatch();
-                    if ("begin".equalsIgnoreCase(scanner.getCurrentMatch())) {
-                        compoundStatement(false);
-                        flushStringBuilder();
-                    }
-                    break;
-                default:
-                    appendMatch();
-            }
-        }
-        flushStringBuilder();
+		Lexem l;
+		while ((l = scanner.next()) != Lexem.EOF) {
+			switch (l) {
+				case SEPARATOR:
+					// statement boundary, reset any pending whitespace
+					pendingWhitespace = false;
+					pendingWhitespaceHadEol = false;
+					flushStringBuilder();
+					break;
+				case COMMENT:
+					// skip comments; keep pending whitespace as-is
+					break;
+				case WHITESPACE: {
+					// Defer emitting whitespace until we know what follows.
+					// This allows us to preserve a newline between adjacent quoted strings,
+					// which is required by some SQL dialects (e.g. PostgreSQL) to concatenate literals.
+					final String ws = scanner.getCurrentMatch();
+					pendingWhitespace = true;
+					pendingWhitespaceHadEol = ws.indexOf('\n') >= 0 || ws.indexOf('\r') >= 0;
+					break;
+				}
+				case IDENTIFIER: {
+					emitPendingWhitespaceIfNeeded(l);
+					appendMatch();
+					if ("begin".equalsIgnoreCase(scanner.getCurrentMatch())) {
+						compoundStatement(false);
+						flushStringBuilder();
+					}
+					break;
+				}
+				default:
+					emitPendingWhitespaceIfNeeded(l);
+					appendMatch();
+			}
+		}
+		flushStringBuilder();
     }
 
+		// helper: emits pending whitespace before the given next lexem
+		private void emitPendingWhitespaceIfNeeded(Lexem nextLexem) {
+			if (!pendingWhitespace) {
+				return;
+			}
+			// Decide between ' ' and '\n'
+			// Preserve a newline only when it appeared in the original whitespace
+			// and it separates two quoted strings.
+			final boolean prevEndsWithQuote =
+				sb.length() > 0 && (sb.charAt(sb.length() - 1) == '\'' || sb.charAt(sb.length() - 1) == '"');
+			if (pendingWhitespaceHadEol && prevEndsWithQuote && Lexem.QUOTED_STRING.equals(nextLexem)) {
+				if (sb.length() == 0 || sb.charAt(sb.length() - 1) != '\n') {
+					sb.append('\n');
+				}
+			} else {
+				if (sb.length() == 0 || sb.charAt(sb.length() - 1) != ' ') {
+					sb.append(' ');
+				}
+			}
+			pendingWhitespace = false;
+			pendingWhitespaceHadEol = false;
+		}
+
     /**
      * Compound statement ('create procedure') mode:
      * 1. Do not remove comments