Fix Ginkgo Reporter slice-bounds panic

Author: Stacey Birley

integration/flags_test.go

@@ -2,6 +2,7 @@ package integration_test
 
 import (
 	"strings"
+	"time"
 
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
@@ -46,7 +47,7 @@ var _ = Describe("Flags Specs", func() {
 		Ω(output).Should(ContainSubstring("Detected pending specs and --fail-on-pending is set"))
 	})
 
-	It("should run the race detector when told to", Label("slow"), func() {
+	It("should run the race detector when told to", Label("slow"), NodeTimeout(2*time.Minute), func(ctx SpecContext) {
 		if !raceDetectorSupported() {
 			Skip("race detection is not supported")
 		}

reporters/default_reporter.go

@@ -377,43 +377,40 @@ func (r *DefaultReporter) humanReadableState(state types.SpecState) string {
 
 func (r *DefaultReporter) emitTimeline(indent uint, report types.SpecReport, timeline types.Timeline) {
 	isVeryVerbose := r.conf.Verbosity().Is(types.VerbosityLevelVeryVerbose)
-	gw := report.CapturedGinkgoWriterOutput
-	cursor := 0
-	for _, entry := range timeline {
-		tl := entry.GetTimelineLocation()
-		if tl.Offset < len(gw) {
-			r.emit(r.fi(indent, "%s", gw[cursor:tl.Offset]))
-			cursor = tl.Offset
-		} else if cursor < len(gw) {
-			r.emit(r.fi(indent, "%s", gw[cursor:]))
-			cursor = len(gw)
-		}
-		switch x := entry.(type) {
-		case types.Failure:
-			if isVeryVerbose {
-				r.emitFailure(indent, report.State, x, false)
-			} else {
-				r.emitShortFailure(indent, report.State, x)
-			}
-		case types.AdditionalFailure:
-			if isVeryVerbose {
-				r.emitFailure(indent, x.State, x.Failure, true)
-			} else {
-				r.emitShortFailure(indent, x.State, x.Failure)
-			}
-		case types.ReportEntry:
-			r.emitReportEntry(indent, x)
-		case types.ProgressReport:
-			r.emitProgressReport(indent, false, false, x)
-		case types.SpecEvent:
-			if isVeryVerbose || !x.IsOnlyVisibleAtVeryVerbose() || r.conf.ShowNodeEvents {
-				r.emitSpecEvent(indent, x, isVeryVerbose)
-			}
-		}
-	}
-	if cursor < len(gw) {
-		r.emit(r.fi(indent, "%s", gw[cursor:]))
-	}
+    gw := report.CapturedGinkgoWriterOutput
+    cursor := 0
+    for _, entry := range timeline {
+        tl := entry.GetTimelineLocation()
+
+        end := tl.Offset
+        if end > len(gw) { end = len(gw) }
+        if end < cursor  { end = cursor  }
+        if cursor < end {
+            r.emit(r.fi(indent, "%s", gw[cursor:end]))
+            cursor = end
+        } else if cursor < len(gw) && end == len(gw) {
+            r.emit(r.fi(indent, "%s", gw[cursor:]))
+            cursor = len(gw)
+        }
+
+        switch x := entry.(type) {
+        case types.Failure:
+            if isVeryVerbose { r.emitFailure(indent, report.State, x, false) } else { r.emitShortFailure(indent, report.State, x) }
+        case types.AdditionalFailure:
+            if isVeryVerbose { r.emitFailure(indent, x.State, x.Failure, true) } else { r.emitShortFailure(indent, x.State, x.Failure) }
+        case types.ReportEntry:
+            r.emitReportEntry(indent, x)
+        case types.ProgressReport:
+            r.emitProgressReport(indent, false, isVeryVerbose, x)
+        case types.SpecEvent:
+            if isVeryVerbose || !x.IsOnlyVisibleAtVeryVerbose() || r.conf.ShowNodeEvents {
+                r.emitSpecEvent(indent, x, isVeryVerbose)
+            }
+        }
+    }
+    if cursor < len(gw) {
+        r.emit(r.fi(indent, "%s", gw[cursor:]))
+    }
 }
 
 func (r *DefaultReporter) EmitFailure(state types.SpecState, failure types.Failure) {

reporters/default_reporter_test.go

@@ -1553,6 +1553,39 @@ var _ = Describe("DefaultReporter", func() {
 				DELIMITER,
 				""),
 		),
+		Entry("a passing test with out-of-order timeline offsets (clamped safely)",
+			// Build a report whose timeline offsets go forward, then backward, then forward again.
+			// GW text is 3 lines: L1\nL2\nL3\n
+			S(
+				types.NodeTypeIt, "A", cl0, types.SpecStatePassed,
+				GW("L1\nL2\nL3\n"),
+				// tl.Offset = len("L1\n") -> forward
+				SE(types.SpecEventNodeStart, types.NodeTypeIt, "A", cl0, TL("L1\n")),
+				// tl.Offset = len("L1\nL2\n") -> further forward
+				SE(types.SpecEventByStart, "Step", cl1, TL("L1\nL2\n")),
+				// tl.Offset = len("L1\n") -> BACKWARD (this used to panic without clamping)
+				SE(types.SpecEventByEnd, "Step", cl1, time.Millisecond*100, TL("L1\n")),
+				// tl.Offset = len("L1\nL2\nL3\n") -> final
+				SE(types.SpecEventNodeEnd, types.NodeTypeIt, "A", cl0, time.Millisecond*100, TL("L1\nL2\nL3\n")),
+			),
+			// We assert using a config that shows the Timeline (Verbose|Parallel),
+			// matching the existing style of expectations in this table.
+			Case(Verbose|Parallel,
+				DELIMITER,
+				spr("{{green}}%s [1.000 seconds]{{/}}", DENOTER),
+				"{{green}}{{bold}}A{{/}}",
+				"{{gray}}cl0.go:12{{/}}",
+				"",
+				   "  {{gray}}Timeline >>{{/}}",
+				   "  L1",
+				   "  L2",
+				   spr("  {{bold}}STEP:{{/}} Step {{gray}}@ %s{{/}}", FORMATTED_TIME),
+				   "  L3",
+				   "  {{gray}}<< Timeline{{/}}",
+				DELIMITER,
+				"",
+			),
+		),
 		Entry("a failed test with timeline entries",
 			S(types.NodeTypeIt, CTS("A", "B"), CLS(cl0, cl1), "C", cl2, types.SpecStateInterrupted, SE(types.SpecEventByStart, "a by step", cl0),
 				F("failure\nmessage", cl3, types.FailureNodeIsLeafNode, FailureNodeLocation(cl2), types.NodeTypeIt, TL(0),