test(devtool): hold the coverage, parity and runner edits

go tool mutate left six edits no test refused. Pct of a package with no
statements is now tested (0, not NaN), and so is a cli file that is not
a test and a test outside internal/cli, which both run the full parity
matrix. ParseFloat's bitSize of 64 is exempt: any value but 32 means 64.

The exec helper process now gets a GOCOVERDIR, since a binary built with
coverage, as mutate builds it, warned on the helper's stderr and failed
TestOSRunnerProcessContract before any edit; that hid the nil-stream
edit in OSRunner.Run. A test with a single Env entry holds the len > 0
guard that the extra entry would otherwise leave untested.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: aledbf

internal/devtools/coverage.go

@@ -29,7 +29,8 @@ func (p PkgCov) Pct() float64 {
 	}
 	// Round to 1 decimal exactly as fmt "%.1f" would, so String() and numeric
 	// comparisons never disagree at a boundary.
-	v, _ := strconv.ParseFloat(fmt.Sprintf("%.1f", float64(p.Covered)*100/float64(p.Total)), 64)
+	rounded := fmt.Sprintf("%.1f", float64(p.Covered)*100/float64(p.Total))
+	v, _ := strconv.ParseFloat(rounded, 64) // mutate-exempt: ParseFloat reads any bitSize but 32 as 64
 	return v
 }
 
@@ -156,7 +157,7 @@ func ParseFloors(specs []string) ([]Floor, error) {
 		if !found || k == "" {
 			return nil, fmt.Errorf("invalid floor %q: want <key>=<min>", s)
 		}
-		min, err := strconv.ParseFloat(v, 64)
+		min, err := strconv.ParseFloat(v, 64) // mutate-exempt: ParseFloat reads any bitSize but 32 as 64
 		if err != nil {
 			return nil, fmt.Errorf("invalid floor %q: %w", s, err)
 		}

internal/devtools/coverage_test.go

@@ -117,3 +117,14 @@ func TestParseFloorsInvalid(t *testing.T) {
 		}
 	}
 }
+
+// TestPctOfAnEmptyPackage holds the guard a package without statements needs: its
+// coverage is 0, not the NaN of 0/0 that the report and the gate would print.
+func TestPctOfAnEmptyPackage(t *testing.T) {
+	if got := (PkgCov{Pkg: "p"}).Pct(); got != 0 {
+		t.Errorf("Pct of 0 statements = %v, want 0", got)
+	}
+	if got := (PkgCov{Pkg: "p", Covered: 1, Total: 1}).Pct(); got != 100 {
+		t.Errorf("Pct of 1/1 statements = %v, want 100", got)
+	}
+}

internal/devtools/parityaffected_test.go

@@ -38,6 +38,8 @@ func TestParityAffected(t *testing.T) {
 		{"Taskfile → all", []string{"Taskfile.yml"}, "all"},
 		{"go-cli workflow → all", []string{".github/workflows/go-cli.yml"}, "all"},
 		{"shared internal → all", []string{"internal/foo.go"}, "all"},
+		{"shared cli file → all", []string{"internal/cli/shared.go"}, "all"},
+		{"test outside cli → all", []string{"internal/docker/client_test.go"}, "all"},
 		{"cmd → all", []string{"cmd/devcontainer/main.go"}, "all"},
 		{"unknown path → all", []string{"totally-unknown-file"}, "all"},
 		{"full wins over leaf", []string{"internal/cli/exec.go", "docs/parity/parity-matrix.yaml"}, "all"},

internal/exec/exec_test.go

@@ -44,14 +44,17 @@ func helperArgs(args []string) []string {
 	return nil
 }
 
-func helperRunner(env ...string) OSRunner {
+// helperRunner runs this test binary as the helper process. GOCOVERDIR keeps a
+// binary built with coverage (as go tool mutate builds it) from warning on the
+// helper's stderr that it has nowhere to write its counters.
+func helperRunner(t *testing.T, env ...string) OSRunner {
 	return OSRunner{Env: append([]string{
-		"GO_WANT_EXEC_HELPER=1",
+		"GO_WANT_EXEC_HELPER=1", "GOCOVERDIR=" + t.TempDir(),
 	}, env...)}
 }
 
 func TestOSRunnerProcessContract(t *testing.T) {
-	stdout, stderr, code, err := helperRunner("EXEC_HELPER_STDERR=warning").Run(
+	stdout, stderr, code, err := helperRunner(t, "EXEC_HELPER_STDERR=warning").Run(
 		t.Context(), nil, os.Args[0], "-test.run=^TestHelperProcess$", "--", "echo", "one", "two",
 	)
 	if err != nil {
@@ -69,7 +72,7 @@ func TestOSRunnerProcessContract(t *testing.T) {
 }
 
 func TestOSRunnerNonZeroIsExitCodeNotTransportError(t *testing.T) {
-	_, _, code, err := helperRunner().Run(
+	_, _, code, err := helperRunner(t).Run(
 		t.Context(), nil, os.Args[0], "-test.run=^TestHelperProcess$", "--", "exit",
 	)
 	if err != nil {
@@ -83,7 +86,7 @@ func TestOSRunnerNonZeroIsExitCodeNotTransportError(t *testing.T) {
 func TestOSRunnerHonorsCancellation(t *testing.T) {
 	ctx, cancel := context.WithTimeout(t.Context(), 100*time.Millisecond)
 	defer cancel()
-	_, _, code, err := helperRunner().Run(
+	_, _, code, err := helperRunner(t).Run(
 		ctx, nil, os.Args[0], "-test.run=^TestHelperProcess$", "--", "wait",
 	)
 	if !errors.Is(err, context.DeadlineExceeded) {
@@ -108,7 +111,7 @@ func TestOSRunnerMissingBinaryIsTransportError(t *testing.T) {
 // output live while the return value still captures it.
 func TestOSRunnerStreamsToWriter(t *testing.T) {
 	var live strings.Builder
-	stdout, _, code, err := helperRunner("EXEC_HELPER_STDERR=warn").Run(
+	stdout, _, code, err := helperRunner(t, "EXEC_HELPER_STDERR=warn").Run(
 		t.Context(), &live, os.Args[0], "-test.run=^TestHelperProcess$", "--", "echo", "hi",
 	)
 	if err != nil || code != 0 {
@@ -123,3 +126,17 @@ func TestOSRunnerStreamsToWriter(t *testing.T) {
 		t.Errorf("captured stdout = %q, want hi", got)
 	}
 }
+
+// TestOSRunnerAppliesASingleEnvEntry holds that one entry is enough for Env to
+// reach the child: without it the helper below would not act as the helper.
+func TestOSRunnerAppliesASingleEnvEntry(t *testing.T) {
+	stdout, _, code, err := OSRunner{Env: []string{"GO_WANT_EXEC_HELPER=1"}}.Run(
+		t.Context(), nil, os.Args[0], "-test.run=^TestHelperProcess$", "--", "echo", "alone",
+	)
+	if err != nil || code != 0 {
+		t.Fatalf("Run: err=%v code=%d", err, code)
+	}
+	if got := string(stdout); got != "alone" {
+		t.Errorf("stdout = %q, want alone", got)
+	}
+}