mesh-delivery-checker: a package sent as its FAIL line alone is still worded, and the words keep their bound exactly (issue 1901, review round 1)

The build module on main sends a timeout, exit or kill as only 'FAIL <pkg>':
dropping summary lines left empty words. They now say the package failed with
no cause sent. Causes match at column 0 only, summary lines only in go's exact
forms, and the words count the cause, the marker and the newlines within
MaxWords.

modules/mesh-delivery-checker/internal/check/judge.go

@@ -541,19 +541,29 @@ func failureWords(f Failure) string {
 	if cause == "" {
 		cause = causeIn(out)
 	}
-	if cause == "" && out == "" && passed {
+	switch {
+	case cause == "" && out == "" && passed:
 		cause = "the tests passed, then the test program exited with a failure: an os.Exit or a panic in TestMain or after the tests"
+	case cause == "" && out == "":
+		// The build module on main sends a package that stopped (a timeout, an exit, a kill) as its "FAIL" line alone.
+		cause = "the package failed with no test to name and no panic, signal or build error in its output (an older build module sent no cause)"
 	}
 	if len(cause) > MaxCause {
 		cause = strings.ToValidUTF8(cause[:MaxCause], "") + "..."
 	}
-	if len(out) > MaxWords-len(cause) {
-		out = out[len(out)-(MaxWords-len(cause)):]
+	// The words keep MaxWords exactly: the cause and its newline, the marker and the kept lines (review round 1).
+	budget := MaxWords
+	if cause != "" {
+		budget -= len(cause) + 1
+	}
+	if len(out) > budget {
+		const marker = "... "
+		tail := out[len(out)-(budget-len(marker)):]
 		// Start on a whole line, and a whole character.
-		if i := strings.IndexByte(out, '\n'); i >= 0 {
-			out = "... " + strings.TrimLeft(out[i:], "\n")
+		if i := strings.IndexByte(tail, '\n'); i >= 0 {
+			tail = strings.TrimLeft(tail[i:], "\n")
 		}
-		out = strings.ToValidUTF8(out, "")
+		out = marker + strings.ToValidUTF8(tail, "")
 	}
 	if cause != "" && !strings.HasPrefix(firstLine(out), cause) {
 		out = strings.TrimRight(cause+"\n"+out, "\n")
@@ -572,10 +582,11 @@ func dropSummary(out string) (string, bool) {
 	lines := strings.Split(out, "\n")
 	kept := lines[:0]
 	for _, l := range lines {
-		switch t := strings.TrimSpace(l); {
+		// go's exact forms only (review round 1): "PASS" or "FAIL" alone, "ok  \t<pkg>\t<time>", "FAIL\t<pkg>\t<time>".
+		switch t := strings.TrimRight(l, "\r"); {
 		case t == "PASS":
 			passed = true
-		case t == "FAIL", strings.HasPrefix(t, "ok "), strings.HasPrefix(t, "ok\t"), strings.HasPrefix(t, "FAIL\t"), strings.HasPrefix(t, "FAIL "):
+		case t == "FAIL", strings.HasPrefix(t, "ok  \t"), strings.HasPrefix(t, "FAIL\t"):
 		default:
 			kept = append(kept, l)
 		}
@@ -585,11 +596,12 @@ func dropSummary(out string) (string, bool) {
 
 // causeIn is a race the race detector reported, as its heading, its access and the frame that made it ("WARNING: DATA
 // RACE: Write at 0x... by goroutine 9 in pkg.F.func1()"); else the first "panic:", "fatal error:" or "signal:" line of a
-// failure's output, in that order; or "".
+// failure's output, in that order; or "". **Only lines at column 0**, where go prints the runtime's: a test's indented log
+// line holding the same words is not the cause (review round 1).
 func causeIn(out string) string {
 	lines := strings.Split(out, "\n")
 	for i, l := range lines {
-		if strings.TrimSpace(l) != "WARNING: DATA RACE" {
+		if strings.TrimRight(l, "\r") != "WARNING: DATA RACE" {
 			continue
 		}
 		words := "WARNING: DATA RACE"
@@ -603,7 +615,7 @@ func causeIn(out string) string {
 	}
 	for _, prefix := range []string{"panic: ", "fatal error: ", "signal: "} {
 		for _, l := range lines {
-			if l = strings.TrimSpace(l); strings.HasPrefix(l, prefix) {
+			if l = strings.TrimRight(l, "\r"); strings.HasPrefix(l, prefix) {
 				return l
 			}
 		}

modules/mesh-delivery-checker/internal/check/package_cause_test.go

@@ -56,3 +56,37 @@ func TestALongCauseIsCutToALinesBound(t *testing.T) { // 1901/AC5
 		t.Errorf("1901/AC5: words are %d bytes, bound %d", len(v.Failed.Words), MaxWords)
 	}
 }
+
+// The build module on main sends a package that stopped (a timeout, an exit, a kill) as only go test's last line, with no
+// cause: the words then say so, never nothing (review round 1). Each output is what that build module sends for the
+// capture of the same name (go-test-json-pkg-timeout, -exiting, -killed): the package's own output, its "FAIL" line.
+func TestAPackageStoppedWithOnlyItsFailLineIsStillWorded(t *testing.T) { // 1901/AC5
+	for _, out := range []string{"FAIL\texample.com/timeout\t2.017s", "FAIL\texample.com/exiting\t0.006s", "FAIL\texample.com/killed\t0.006s"} {
+		v := levelFailure(&target{}, "integration", Tested{Failed: []Failure{{Package: "example.com/x", Output: out}}})
+		if !strings.HasPrefix(v.Failed.Words, "the package failed with no test to name and no panic, signal or build error in its output") {
+			t.Errorf("1901/AC5: %q is worded %q", out, v.Failed.Words)
+		}
+	}
+}
+
+// A line of the test's own that starts as go's summary does, or that holds a runtime's words indented, is not taken for
+// either (review round 1): go prints its summary in exact forms and the runtime's lines at column 0.
+func TestOnlyGosExactFormsAreSummaryOrCause(t *testing.T) { // 1901/AC5
+	out := "    x_test.go:3: ok so far\nok then: the seat is free\n        panic: child retried and recovered\npanic: the real one\nFAIL\tp\t1.0s"
+	v := levelFailure(&target{}, "unit", Tested{Failed: []Failure{{Package: "p", Output: out}}})
+	if !strings.HasPrefix(v.Failed.Words, "panic: the real one") || !strings.Contains(v.Failed.Words, "ok then: the seat is free") {
+		t.Errorf("1901/AC5: words = %q", v.Failed.Words)
+	}
+}
+
+// The words keep MaxWords exactly, counting the cause, the marker and the newlines (review round 1).
+func TestTheWordsKeepTheirBoundExactly(t *testing.T) { // 1901/AC5
+	for _, cause := range []string{"", "a cause", strings.Repeat("c", 3000)} {
+		for _, n := range []int{100, 170, 171, 172, 500} {
+			f := Failure{Package: "p", Test: "TestX", Cause: cause, Output: strings.Repeat("a log line of twenty\n", n) + "the end"}
+			if w := failureWords(f); len(w) > MaxWords {
+				t.Errorf("1901/AC5: cause %d bytes, %d lines: words are %d bytes, bound %d", len(cause), n, len(w), MaxWords)
+			}
+		}
+	}
+}