+ * The failure it describes has happened once and is not reproducible on demand, so the summary is + * the only thing that will be read when it happens again. That makes it worth testing on its own: + * a description which misreports what changed is worse than none, because it sends the next person + * looking in the wrong place. + */ +public class DeterminismDiffReportTest { + + /** + * A block appearing in one script and not the other reads as one addition. Comparing equal + * indexes instead would report every line after the insertion as differing, which is the case + * emission-order nondeterminism actually produces. + */ + @Test + public void anInsertedBlockIsOneAdditionRatherThanEverythingAfterIt() { + String first = "a\nb\nc\nd\ne\nf\ng\nh\n"; + String second = "a\nb\nINSERTED\nc\nd\ne\nf\ng\nh\n"; + + String report = LuaTranslationTests.describeFirstDifferences(first, second); + + assertTrue(report.contains("0 line(s) only in the first, 1 only in the second"), + "one inserted line should read as one addition:\n" + report); + assertTrue(report.contains("INSERTED"), "the added line should be named:\n" + report); + assertTrue(report.contains("line 3"), "the added line's number should be given:\n" + report); + } + + /** A block moved rather than inserted reads as one removal and one addition, not a cascade. */ + @Test + public void aMovedLineIsOneRemovalAndOneAddition() { + String first = "one\nmoved\ntwo\nthree\nfour\n"; + String second = "one\ntwo\nthree\nmoved\nfour\n"; + + String report = LuaTranslationTests.describeFirstDifferences(first, second); + + assertTrue(report.contains("1 line(s) only in the first, 1 only in the second"), + "a moved line should read as one removal and one addition:\n" + report); + } + + /** Replacing a line in place is a removal and an addition at the same position. */ + @Test + public void aReplacedLineNamesBothVersions() { + String first = "x\nbefore\nz\n"; + String second = "x\nafter\nz\n"; + + String report = LuaTranslationTests.describeFirstDifferences(first, second); + + assertTrue(report.contains("before"), "the first version should be named:\n" + report); + assertTrue(report.contains("after"), "the second version should be named:\n" + report); + } + + /** + * Two scripts whose lines all match but which are not equal differ in how the lines end. The + * caller only asks after finding them unequal, so passing identical strings would test a state + * production never reaches — this passes CRLF against LF, which it can. + */ + @Test + public void differingOnlyInLineEndingsSaysSoRatherThanListingEveryLine() { + String crlf = "alpha\r\nbeta\r\ngamma\r\n"; + String lf = "alpha\nbeta\ngamma\n"; + assertNotEquals(crlf, lf, "the two inputs must be unequal for this to mean anything"); + + String report = LuaTranslationTests.describeFirstDifferences(crlf, lf); + + assertTrue(report.contains("line terminators"), + "line endings should be named rather than every line reported as changed:\n" + report); + assertFalse(report.contains("only in the first"), + "no line should be reported as removed:\n" + report); + } + + /** Bytes after the last line reach the same branch: every line matches, the scripts do not. */ + @Test + public void trailingBytesReachTheSameCase() { + String report = LuaTranslationTests.describeFirstDifferences("a\nb\n", "a\nb"); + + assertTrue(report.contains("line terminators") || report.contains("only in the"), + "a trailing difference should be described one way or the other:\n" + report); + } +} diff --git a/de.peeeq.wurstscript/src/test/java/tests/wurstscript/tests/LuaTranslationTests.java b/de.peeeq.wurstscript/src/test/java/tests/wurstscript/tests/LuaTranslationTests.java index 014a3d9ce..c64ac4144 100644 --- a/de.peeeq.wurstscript/src/test/java/tests/wurstscript/tests/LuaTranslationTests.java +++ b/de.peeeq.wurstscript/src/test/java/tests/wurstscript/tests/LuaTranslationTests.java @@ -1418,7 +1418,102 @@ public void luaOutputIsDeterministicForGenericOverrideSlots() throws IOException test().testLua(true).compilationUnits(genericOverrideReproUnits()); String second = Files.toString(new File("test-output/lua/LuaTranslationTests_luaOutputIsDeterministicForGenericOverrideSlots.lua"), Charsets.UTF_8); - assertEquals(first, second); + if (!first.equals(second)) { + // This has failed once on CI and not since, and 250 compiles in one JVM did not + // reproduce it. A bare "expected X but got Y" over two whole scripts is unreadable and + // the run's output is gone by the time anyone looks, so the failure carries what it + // takes to act on: both scripts kept beside the test output, and the differing lines + // named. Without this the next occurrence is as unactionable as the first. + File firstFile = new File(TEST_OUTPUT_PATH, "determinism-first.lua"); + File secondFile = new File(TEST_OUTPUT_PATH, "determinism-second.lua"); + Files.write(first.getBytes(Charsets.UTF_8), firstFile); + Files.write(second.getBytes(Charsets.UTF_8), secondFile); + fail("the same program compiled to different Lua twice in one run." + + "\n" + describeFirstDifferences(first, second) + + "\nboth kept at " + firstFile.getPath() + " and " + secondFile.getPath()); + } + } + + /** + * What changed between the two scripts, aligned rather than compared line by line. + *
+ * Comparing equal indexes is not a diff: emission order moving a block shifts every line after + * it, so the count becomes "everything from here down" and the listed pairs are unrelated. That + * is the shape this diagnostic exists to investigate, so it is the shape it has to describe. + * Aligned on the longest common subsequence, a moved block reads as one removal and one addition. + *
+ * The scripts are also uploaded as an artifact on a failing CI run, but the message has to stand
+ * on its own: an artifact needs fetching, and the check is what gets read first. Bounded so a
+ * wholesale difference does not bury the report, with the totals stated either way.
+ */
+ /**
+ * Splits on either terminator, so a CRLF script aligns against an LF one line for line. Splitting
+ * on "\n" alone leaves the carriage return in the line text, which makes every line of a CRLF
+ * script differ from its LF counterpart and buries the actual difference.
+ */
+ private static final String NEWLINE_RE = "\r?\n";
+ private static final char NEWLINE = '\n';
+
+ static String describeFirstDifferences(String first, String second) {
+ final int reportLimit = 40;
+ String[] a = first.split(NEWLINE_RE, -1);
+ String[] b = second.split(NEWLINE_RE, -1);
+
+ // O(n*m) in memory, so a pathological pair falls back to reporting the sizes rather than
+ // exhausting the worker. The scripts this compares are a few hundred lines.
+ if ((long) a.length * b.length > 4_000_000L) {
+ return " too large to align: " + a.length + " lines against " + b.length;
+ }
+
+ int[][] common = new int[a.length + 1][b.length + 1];
+ for (int i = a.length - 1; i >= 0; i--) {
+ for (int j = b.length - 1; j >= 0; j--) {
+ common[i][j] = a[i].equals(b[j])
+ ? common[i + 1][j + 1] + 1
+ : Math.max(common[i + 1][j], common[i][j + 1]);
+ }
+ }
+
+ List