TT-1995 Integrate go test transformer into Flakeguard (#1667)

lukaszcl · web-flow · commit 126cfaf9521c · 2025-02-27T14:27:18.000+01:00
* Integrate go test transformer into Flakeguard

* Fix

* Update test
diff --git a/tools/flakeguard/cmd/run.go b/tools/flakeguard/cmd/run.go
@@ -41,6 +41,7 @@ var RunTestsCmd = &cobra.Command{
 		useShuffle, _ := cmd.Flags().GetBool("shuffle")
 		shuffleSeed, _ := cmd.Flags().GetString("shuffle-seed")
 		omitOutputsOnSuccess, _ := cmd.Flags().GetBool("omit-test-outputs-on-success")
+		ignoreParentFailuresOnSubtests, _ := cmd.Flags().GetBool("ignore-parent-failures-on-subtests")
 
 		outputDir := filepath.Dir(outputPath)
 		initialDirSize, err := getDirSize(outputDir)
@@ -63,7 +64,6 @@ var RunTestsCmd = &cobra.Command{
 		// Determine test packages
 		var testPackages []string
 		if len(testCmdStrings) == 0 {
-			// No custom command -> parse packages
 			if testPackagesJson != "" {
 				if err := json.Unmarshal([]byte(testPackagesJson), &testPackages); err != nil {
 					log.Error().Err(err).Msg("Error decoding test packages JSON")
@@ -79,18 +79,19 @@ var RunTestsCmd = &cobra.Command{
 
 		// Initialize the runner
 		testRunner := runner.Runner{
-			ProjectPath:          projectPath,
-			Verbose:              true,
-			RunCount:             runCount,
-			Timeout:              timeout,
-			Tags:                 tags,
-			UseRace:              useRace,
-			SkipTests:            skipTests,
-			SelectTests:          selectTests,
-			UseShuffle:           useShuffle,
-			ShuffleSeed:          shuffleSeed,
-			OmitOutputsOnSuccess: omitOutputsOnSuccess,
-			MaxPassRatio:         maxPassRatio,
+			ProjectPath:                    projectPath,
+			Verbose:                        true,
+			RunCount:                       runCount,
+			Timeout:                        timeout,
+			Tags:                           tags,
+			UseRace:                        useRace,
+			SkipTests:                      skipTests,
+			SelectTests:                    selectTests,
+			UseShuffle:                     useShuffle,
+			ShuffleSeed:                    shuffleSeed,
+			OmitOutputsOnSuccess:           omitOutputsOnSuccess,
+			MaxPassRatio:                   maxPassRatio,
+			IgnoreParentFailuresOnSubtests: ignoreParentFailuresOnSubtests,
 		}
 
 		// Run the tests
@@ -105,7 +106,6 @@ var RunTestsCmd = &cobra.Command{
 				os.Exit(ErrorExitCode)
 			}
 		} else {
-			// Otherwise, use the normal go test approach
 			testReport, err = testRunner.RunTestPackages(testPackages)
 			if err != nil {
 				log.Fatal().Err(err).Msg("Error running test packages")
@@ -180,6 +180,7 @@ func init() {
 	RunTestsCmd.Flags().StringSlice("select-tests", nil, "Comma-separated list of test names to specifically run")
 	RunTestsCmd.Flags().Float64("max-pass-ratio", 1.0, "The maximum pass ratio threshold for a test to be considered flaky. Any tests below this pass rate will be considered flaky.")
 	RunTestsCmd.Flags().Bool("omit-test-outputs-on-success", true, "Omit test outputs and package outputs for tests that pass")
+	RunTestsCmd.Flags().Bool("ignore-parent-failures-on-subtests", false, "Ignore failures in parent tests when only subtests fail")
 }
 
 func checkDependencies(projectPath string) error {
diff --git a/tools/flakeguard/go-test-transform/pkg/example/example_test.go b/tools/flakeguard/go-test-transform/pkg/example/example_test.go
@@ -199,9 +199,7 @@ func TestDeepNesting(t *testing.T) {
 			t.Run("Level3", func(t *testing.T) {
 				t.Run("Level4", func(t *testing.T) {
 					t.Run("Level5", func(t *testing.T) {
-						if !simulateFlaky() {
-							t.Error("Deep nested test failed")
-						}
+						t.Error("Deep nested test failed")
 					})
 				})
 			})
diff --git a/tools/flakeguard/go-test-transform/pkg/transformer/transformer.go b/tools/flakeguard/go-test-transform/pkg/transformer/transformer.go
@@ -37,7 +37,7 @@ type TestNode struct {
 }
 
 // TransformJSON transforms go test -json output according to the options
-func TransformJSON(input io.Reader, output io.Writer, opts *Options) (int, error) {
+func TransformJSON(input io.Reader, output io.Writer, opts *Options) error {
 	// Create scanner for JSON input
 	scanner := bufio.NewScanner(input)
 	scanner.Buffer(make([]byte, 1024*1024), 10*1024*1024) // 10MB max buffer
@@ -47,13 +47,13 @@ func TransformJSON(input io.Reader, output io.Writer, opts *Options) (int, error
 	for scanner.Scan() {
 		var event TestEvent
 		if err := json.Unmarshal(scanner.Bytes(), &event); err != nil {
-			return 1, fmt.Errorf("failed to parse JSON: %v", err)
+			return fmt.Errorf("failed to parse JSON: %v", err)
 		}
 		events = append(events, event)
 	}
 
 	if err := scanner.Err(); err != nil {
-		return 1, fmt.Errorf("error reading input: %v", err)
+		return fmt.Errorf("error reading input: %v", err)
 	}
 
 	// Build test tree
@@ -69,22 +69,18 @@ func TransformJSON(input io.Reader, output io.Writer, opts *Options) (int, error
 	identifyTestsToIgnore(testTree, opts)
 
 	// Transform events
-	transformedEvents, anyRemainingFailures := transformEvents(events, testTree)
+	transformedEvents, _ := transformEvents(events, testTree)
 
 	// Output transformed events
 	for _, event := range transformedEvents {
 		eventJSON, err := json.Marshal(event)
 		if err != nil {
-			return 1, fmt.Errorf("failed to marshal JSON: %v", err)
+			return fmt.Errorf("failed to marshal JSON: %v", err)
 		}
 		fmt.Fprintln(output, string(eventJSON))
 	}
 
-	// Return appropriate exit code
-	if anyRemainingFailures {
-		return 1, nil
-	}
-	return 0, nil
+	return nil
 }
 
 // buildTestTree builds a tree of tests from the events
diff --git a/tools/flakeguard/go-test-transform/pkg/transformer/transformer_test.go b/tools/flakeguard/go-test-transform/pkg/transformer/transformer_test.go
@@ -26,7 +26,7 @@ func createEvent(action, pkg, test string, elapsed float64, output string) testE
 }
 
 // transformAndVerify is a helper function to transform events and verify the results
-func transformAndVerify(t *testing.T, events []testEvent, opts *Options, expectedExitCode int, expectedActions map[string]string) {
+func transformAndVerify(t *testing.T, events []testEvent, opts *Options, expectedActions map[string]string) {
 	// Convert test events to JSON
 	var input bytes.Buffer
 	for _, event := range events {
@@ -39,16 +39,11 @@ func transformAndVerify(t *testing.T, events []testEvent, opts *Options, expecte
 
 	// Transform the events
 	var output bytes.Buffer
-	exitCode, err := TransformJSON(&input, &output, opts)
+	err := TransformJSON(&input, &output, opts)
 	if err != nil {
 		t.Fatalf("Failed to transform JSON: %v", err)
 	}
 
-	// Verify exit code
-	if exitCode != expectedExitCode {
-		t.Errorf("Expected exit code %d, got %d", expectedExitCode, exitCode)
-	}
-
 	// Parse the output
 	scanner := bufio.NewScanner(&output)
 	var resultEvents []TestEvent
@@ -105,7 +100,7 @@ func TestIgnoreAllSubtests(t *testing.T) {
 		"example/":                    "pass",
 	}
 
-	transformAndVerify(t, events, opts, 1, expectedActions)
+	transformAndVerify(t, events, opts, expectedActions)
 }
 
 // TestNestedSubtests tests handling nested subtests
@@ -139,7 +134,7 @@ func TestNestedSubtests(t *testing.T) {
 		"example/":                               "pass",
 	}
 
-	transformAndVerify(t, events, opts, 1, expectedActions)
+	transformAndVerify(t, events, opts, expectedActions)
 }
 
 // TestParallelTestsEventOrdering tests handling of parallel tests
@@ -171,7 +166,7 @@ func TestParallelTestsEventOrdering(t *testing.T) {
 		"example/":                  "pass",
 	}
 
-	transformAndVerify(t, events, opts, 1, expectedActions)
+	transformAndVerify(t, events, opts, expectedActions)
 }
 
 // TestOutputTransformation tests transformation of output text
@@ -191,16 +186,12 @@ func TestEmptyInput(t *testing.T) {
 	opts := DefaultOptions()
 
 	var input, output bytes.Buffer
-	exitCode, err := TransformJSON(&input, &output, opts)
+	err := TransformJSON(&input, &output, opts)
 
 	if err != nil {
 		t.Errorf("Expected no error for empty input, got: %v", err)
 	}
 
-	if exitCode != 0 {
-		t.Errorf("Expected exit code 0 for empty input, got: %d", exitCode)
-	}
-
 	if output.Len() != 0 {
 		t.Errorf("Expected empty output for empty input, got: %s", output.String())
 	}
@@ -213,7 +204,7 @@ func TestMalformedJSON(t *testing.T) {
 	input := strings.NewReader("This is not JSON\n{\"Action\":\"fail\"")
 	var output bytes.Buffer
 
-	_, err := TransformJSON(input, &output, opts)
+	err := TransformJSON(input, &output, opts)
 
 	if err == nil {
 		t.Error("Expected error for malformed JSON, got nil")
@@ -257,7 +248,7 @@ func TestParentWithDirectFailureAndFailingSubtest(t *testing.T) {
 		"example/":                               "pass",
 	}
 
-	transformAndVerify(t, events, opts, 1, expectedActions)
+	transformAndVerify(t, events, opts, expectedActions)
 }
 
 func TestParentWithOnlyDirectFailure(t *testing.T) {
@@ -290,7 +281,7 @@ func TestParentWithOnlyDirectFailure(t *testing.T) {
 		"example/":                    "pass",
 	}
 
-	transformAndVerify(t, events, opts, 1, expectedActions)
+	transformAndVerify(t, events, opts, expectedActions)
 }
 
 // TestMultiLevelNestedFailures tests multiple levels of nested failures
@@ -333,7 +324,7 @@ func TestMultiLevelNestedFailures(t *testing.T) {
 		"example/":                                        "pass",
 	}
 
-	transformAndVerify(t, events, opts, 1, expectedActions)
+	transformAndVerify(t, events, opts, expectedActions)
 }
 
 // TestOnlyDirectFailures tests a scenario where there are no failing subtests, only direct failures
@@ -377,7 +368,7 @@ func TestOnlyDirectFailures(t *testing.T) {
 	}
 
 	// Exit code should be 1 because there are still failing tests
-	transformAndVerify(t, events, opts, 1, expectedActions)
+	transformAndVerify(t, events, opts, expectedActions)
 }
 
 // TestLogMessagesNotDirectFailures tests that log messages are not treated as direct failures
@@ -417,7 +408,7 @@ func TestLogMessagesNotDirectFailures(t *testing.T) {
 		"example/":                          "pass",
 	}
 
-	transformAndVerify(t, events, opts, 1, expectedActions)
+	transformAndVerify(t, events, opts, expectedActions)
 }
 
 // TestNestedLogsAllPassing tests that log messages in passing tests are handled correctly
@@ -453,7 +444,7 @@ func TestNestedLogsAllPassing(t *testing.T) {
 		"example/":                                 "pass",
 	}
 
-	transformAndVerify(t, events, opts, 0, expectedActions)
+	transformAndVerify(t, events, opts, expectedActions)
 }
 
 // TestSkippedTests tests handling of skipped tests
@@ -483,7 +474,7 @@ func TestSkippedTests(t *testing.T) {
 		"example/TestSkippedTests":                      "pass",
 	}
 
-	transformAndVerify(t, events, opts, 0, expectedActions)
+	transformAndVerify(t, events, opts, expectedActions)
 }
 
 // TestDeepNesting tests handling of deeply nested test hierarchies
@@ -529,7 +520,7 @@ func TestDeepNesting(t *testing.T) {
 		"example/":                                                   "pass",
 	}
 
-	transformAndVerify(t, events, opts, 1, expectedActions)
+	transformAndVerify(t, events, opts, expectedActions)
 }
 
 // TestConcurrentTests tests handling of concurrent test execution
@@ -580,7 +571,7 @@ func TestConcurrentTests(t *testing.T) {
 		"example/":                                    "pass",
 	}
 
-	transformAndVerify(t, events, opts, 1, expectedActions)
+	transformAndVerify(t, events, opts, expectedActions)
 }
 
 // TestTableDrivenTests tests handling of table-driven tests
@@ -628,7 +619,7 @@ func TestTableDrivenTests(t *testing.T) {
 		"example/":                                     "pass",
 	}
 
-	transformAndVerify(t, events, opts, 1, expectedActions)
+	transformAndVerify(t, events, opts, expectedActions)
 }
 
 // TestSubtestReuse tests handling of tests that reuse the same subtest function
@@ -677,7 +668,7 @@ func TestSubtestReuse(t *testing.T) {
 		"example/":                            "pass",
 	}
 
-	transformAndVerify(t, events, opts, 1, expectedActions)
+	transformAndVerify(t, events, opts, expectedActions)
 }
 
 // TestSpecialCharactersInTestNames tests handling of tests with special characters in names
@@ -720,7 +711,7 @@ func TestSpecialCharactersInTestNames(t *testing.T) {
 		"example/":                                        "pass",
 	}
 
-	transformAndVerify(t, events, opts, 1, expectedActions)
+	transformAndVerify(t, events, opts, expectedActions)
 }
 
 func TestSubTestNameWithSlashes(t *testing.T) {
@@ -751,7 +742,7 @@ func TestSubTestNameWithSlashes(t *testing.T) {
 		"example/":                                                      "pass",
 	}
 
-	transformAndVerify(t, events, opts, 0, expectedActions)
+	transformAndVerify(t, events, opts, expectedActions)
 }
 
 func TestFuzzTestWithCorpus(t *testing.T) {
@@ -796,5 +787,5 @@ func TestFuzzTestWithCorpus(t *testing.T) {
 	}
 
 	// transformAndVerify should yield exit code 0 since everything passes
-	transformAndVerify(t, events, opts, 0, expectedActions)
+	transformAndVerify(t, events, opts, expectedActions)
 }
diff --git a/tools/flakeguard/runner/runner.go b/tools/flakeguard/runner/runner.go

Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ func createEvent(action, pkg, test string, elapsed float64, output string) testE`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`// transformAndVerify is a helper function to transform events and verify the results`
`29`		`-func transformAndVerify(t testing.T, events []testEvent, opts Options, expectedExitCode int, expectedActions map[string]string) {`
	`29`	`+func transformAndVerify(t testing.T, events []testEvent, opts Options, expectedActions map[string]string) {`
`30`	`30`	`// Convert test events to JSON`
`31`	`31`	`var input bytes.Buffer`
`32`	`32`	`for _, event := range events {`
`@@ -39,16 +39,11 @@ func transformAndVerify(t testing.T, events []testEvent, opts Options, expecte`
`39`	`39`
`40`	`40`	`// Transform the events`
`41`	`41`	`var output bytes.Buffer`
`42`		`- exitCode, err := TransformJSON(&input, &output, opts)`
	`42`	`+ err := TransformJSON(&input, &output, opts)`
`43`	`43`	`if err != nil {`
`44`	`44`	`t.Fatalf("Failed to transform JSON: %v", err)`
`45`	`45`	`}`
`46`	`46`
`47`		`- // Verify exit code`
`48`		`- if exitCode != expectedExitCode {`
`49`		`- t.Errorf("Expected exit code %d, got %d", expectedExitCode, exitCode)`
`50`		`- }`
`51`		`-`
`52`	`47`	`// Parse the output`
`53`	`48`	`scanner := bufio.NewScanner(&output)`
`54`	`49`	`var resultEvents []TestEvent`
`@@ -105,7 +100,7 @@ func TestIgnoreAllSubtests(t *testing.T) {`
`105`	`100`	`"example/": "pass",`
`106`	`101`	`}`
`107`	`102`
`108`		`- transformAndVerify(t, events, opts, 1, expectedActions)`
	`103`	`+ transformAndVerify(t, events, opts, expectedActions)`
`109`	`104`	`}`
`110`	`105`
`111`	`106`	`// TestNestedSubtests tests handling nested subtests`
`@@ -139,7 +134,7 @@ func TestNestedSubtests(t *testing.T) {`
`139`	`134`	`"example/": "pass",`
`140`	`135`	`}`
`141`	`136`
`142`		`- transformAndVerify(t, events, opts, 1, expectedActions)`
	`137`	`+ transformAndVerify(t, events, opts, expectedActions)`
`143`	`138`	`}`
`144`	`139`
`145`	`140`	`// TestParallelTestsEventOrdering tests handling of parallel tests`
`@@ -171,7 +166,7 @@ func TestParallelTestsEventOrdering(t *testing.T) {`
`171`	`166`	`"example/": "pass",`
`172`	`167`	`}`
`173`	`168`
`174`		`- transformAndVerify(t, events, opts, 1, expectedActions)`
	`169`	`+ transformAndVerify(t, events, opts, expectedActions)`
`175`	`170`	`}`
`176`	`171`
`177`	`172`	`// TestOutputTransformation tests transformation of output text`
`@@ -191,16 +186,12 @@ func TestEmptyInput(t *testing.T) {`
`191`	`186`	`opts := DefaultOptions()`
`192`	`187`
`193`	`188`	`var input, output bytes.Buffer`
`194`		`- exitCode, err := TransformJSON(&input, &output, opts)`
	`189`	`+ err := TransformJSON(&input, &output, opts)`
`195`	`190`
`196`	`191`	`if err != nil {`
`197`	`192`	`t.Errorf("Expected no error for empty input, got: %v", err)`
`198`	`193`	`}`
`199`	`194`
`200`		`- if exitCode != 0 {`
`201`		`- t.Errorf("Expected exit code 0 for empty input, got: %d", exitCode)`
`202`		`- }`
`203`		`-`
`204`	`195`	`if output.Len() != 0 {`
`205`	`196`	`t.Errorf("Expected empty output for empty input, got: %s", output.String())`
`206`	`197`	`}`
`@@ -213,7 +204,7 @@ func TestMalformedJSON(t *testing.T) {`
`213`	`204`	`input := strings.NewReader("This is not JSON\n{\"Action\":\"fail\"")`
`214`	`205`	`var output bytes.Buffer`
`215`	`206`
`216`		`- _, err := TransformJSON(input, &output, opts)`
	`207`	`+ err := TransformJSON(input, &output, opts)`
`217`	`208`
`218`	`209`	`if err == nil {`
`219`	`210`	`t.Error("Expected error for malformed JSON, got nil")`
`@@ -257,7 +248,7 @@ func TestParentWithDirectFailureAndFailingSubtest(t *testing.T) {`
`257`	`248`	`"example/": "pass",`
`258`	`249`	`}`
`259`	`250`
`260`		`- transformAndVerify(t, events, opts, 1, expectedActions)`
	`251`	`+ transformAndVerify(t, events, opts, expectedActions)`
`261`	`252`	`}`
`262`	`253`
`263`	`254`	`func TestParentWithOnlyDirectFailure(t *testing.T) {`
`@@ -290,7 +281,7 @@ func TestParentWithOnlyDirectFailure(t *testing.T) {`
`290`	`281`	`"example/": "pass",`
`291`	`282`	`}`
`292`	`283`
`293`		`- transformAndVerify(t, events, opts, 1, expectedActions)`
	`284`	`+ transformAndVerify(t, events, opts, expectedActions)`
`294`	`285`	`}`
`295`	`286`
`296`	`287`	`// TestMultiLevelNestedFailures tests multiple levels of nested failures`
`@@ -333,7 +324,7 @@ func TestMultiLevelNestedFailures(t *testing.T) {`
`333`	`324`	`"example/": "pass",`
`334`	`325`	`}`
`335`	`326`
`336`		`- transformAndVerify(t, events, opts, 1, expectedActions)`
	`327`	`+ transformAndVerify(t, events, opts, expectedActions)`
`337`	`328`	`}`
`338`	`329`
`339`	`330`	`// TestOnlyDirectFailures tests a scenario where there are no failing subtests, only direct failures`
`@@ -377,7 +368,7 @@ func TestOnlyDirectFailures(t *testing.T) {`
`377`	`368`	`}`
`378`	`369`
`379`	`370`	`// Exit code should be 1 because there are still failing tests`
`380`		`- transformAndVerify(t, events, opts, 1, expectedActions)`
	`371`	`+ transformAndVerify(t, events, opts, expectedActions)`
`381`	`372`	`}`
`382`	`373`
`383`	`374`	`// TestLogMessagesNotDirectFailures tests that log messages are not treated as direct failures`
`@@ -417,7 +408,7 @@ func TestLogMessagesNotDirectFailures(t *testing.T) {`
`417`	`408`	`"example/": "pass",`
`418`	`409`	`}`
`419`	`410`
`420`		`- transformAndVerify(t, events, opts, 1, expectedActions)`
	`411`	`+ transformAndVerify(t, events, opts, expectedActions)`
`421`	`412`	`}`
`422`	`413`
`423`	`414`	`// TestNestedLogsAllPassing tests that log messages in passing tests are handled correctly`
`@@ -453,7 +444,7 @@ func TestNestedLogsAllPassing(t *testing.T) {`
`453`	`444`	`"example/": "pass",`
`454`	`445`	`}`
`455`	`446`
`456`		`- transformAndVerify(t, events, opts, 0, expectedActions)`
	`447`	`+ transformAndVerify(t, events, opts, expectedActions)`
`457`	`448`	`}`
`458`	`449`
`459`	`450`	`// TestSkippedTests tests handling of skipped tests`
`@@ -483,7 +474,7 @@ func TestSkippedTests(t *testing.T) {`
`483`	`474`	`"example/TestSkippedTests": "pass",`
`484`	`475`	`}`
`485`	`476`
`486`		`- transformAndVerify(t, events, opts, 0, expectedActions)`
	`477`	`+ transformAndVerify(t, events, opts, expectedActions)`
`487`	`478`	`}`
`488`	`479`
`489`	`480`	`// TestDeepNesting tests handling of deeply nested test hierarchies`
`@@ -529,7 +520,7 @@ func TestDeepNesting(t *testing.T) {`
`529`	`520`	`"example/": "pass",`
`530`	`521`	`}`
`531`	`522`
`532`		`- transformAndVerify(t, events, opts, 1, expectedActions)`
	`523`	`+ transformAndVerify(t, events, opts, expectedActions)`
`533`	`524`	`}`
`534`	`525`
`535`	`526`	`// TestConcurrentTests tests handling of concurrent test execution`
`@@ -580,7 +571,7 @@ func TestConcurrentTests(t *testing.T) {`
`580`	`571`	`"example/": "pass",`
`581`	`572`	`}`
`582`	`573`
`583`		`- transformAndVerify(t, events, opts, 1, expectedActions)`
	`574`	`+ transformAndVerify(t, events, opts, expectedActions)`
`584`	`575`	`}`
`585`	`576`
`586`	`577`	`// TestTableDrivenTests tests handling of table-driven tests`
`@@ -628,7 +619,7 @@ func TestTableDrivenTests(t *testing.T) {`
`628`	`619`	`"example/": "pass",`
`629`	`620`	`}`
`630`	`621`
`631`		`- transformAndVerify(t, events, opts, 1, expectedActions)`
	`622`	`+ transformAndVerify(t, events, opts, expectedActions)`
`632`	`623`	`}`
`633`	`624`
`634`	`625`	`// TestSubtestReuse tests handling of tests that reuse the same subtest function`
`@@ -677,7 +668,7 @@ func TestSubtestReuse(t *testing.T) {`
`677`	`668`	`"example/": "pass",`
`678`	`669`	`}`
`679`	`670`
`680`		`- transformAndVerify(t, events, opts, 1, expectedActions)`
	`671`	`+ transformAndVerify(t, events, opts, expectedActions)`
`681`	`672`	`}`
`682`	`673`
`683`	`674`	`// TestSpecialCharactersInTestNames tests handling of tests with special characters in names`
`@@ -720,7 +711,7 @@ func TestSpecialCharactersInTestNames(t *testing.T) {`
`720`	`711`	`"example/": "pass",`
`721`	`712`	`}`
`722`	`713`
`723`		`- transformAndVerify(t, events, opts, 1, expectedActions)`
	`714`	`+ transformAndVerify(t, events, opts, expectedActions)`
`724`	`715`	`}`
`725`	`716`
`726`	`717`	`func TestSubTestNameWithSlashes(t *testing.T) {`
`@@ -751,7 +742,7 @@ func TestSubTestNameWithSlashes(t *testing.T) {`
`751`	`742`	`"example/": "pass",`
`752`	`743`	`}`
`753`	`744`
`754`		`- transformAndVerify(t, events, opts, 0, expectedActions)`
	`745`	`+ transformAndVerify(t, events, opts, expectedActions)`
`755`	`746`	`}`
`756`	`747`
`757`	`748`	`func TestFuzzTestWithCorpus(t *testing.T) {`
`@@ -796,5 +787,5 @@ func TestFuzzTestWithCorpus(t *testing.T) {`
`796`	`787`	`}`
`797`	`788`
`798`	`789`	`// transformAndVerify should yield exit code 0 since everything passes`
`799`		`- transformAndVerify(t, events, opts, 0, expectedActions)`
	`790`	`+ transformAndVerify(t, events, opts, expectedActions)`
`800`	`791`	`}`