// Copyright 2026 Alibaba Group
// Licensed under the Apache License, Version 2.0 (the "License");

package main

import (
	"bytes"
	"errors"
	"os"
	"os/exec"
	"path/filepath"
	"reflect"
	"strings"
	"testing"
)

func TestRun(t *testing.T) {
	profile := filepath.Join(t.TempDir(), "coverage.out")
	body := "mode: atomic\nexample.com/project/internal/a.go:10.1,12.2 5 1\n"
	if err := os.WriteFile(profile, []byte(body), 0o600); err != nil {
		t.Fatal(err)
	}
	args := []string{
		"--overall-profile", profile,
		"--diff-profile", profile,
		"--base-ref", "base",
		"--module", "example.com/project",
		"--baseline-overall", "100",
		"--target", "80",
		"--enforce-overall-target=true",
	}
	loader := func(ref string) (map[string][]lineRange, error) {
		if ref != "base" {
			t.Fatalf("base ref=%q", ref)
		}
		return map[string][]lineRange{"internal/a.go": {{Start: 10, End: 12}}}, nil
	}
	var stdout, stderr bytes.Buffer
	if code := run(args, &stdout, &stderr, loader, nil); code != 0 {
		t.Fatalf("run code=%d stderr=%s", code, stderr.String())
	}
	if !strings.Contains(stdout.String(), "overall coverage: 100.0000%") || !strings.Contains(stdout.String(), "changed code coverage: 100.0000%") {
		t.Fatalf("unexpected output %q", stdout.String())
	}

	stderr.Reset()
	if code := run(nil, &stdout, &stderr, loader, nil); code != 2 {
		t.Fatalf("missing arguments code=%d, want 2", code)
	}
	stderr.Reset()
	badLoader := func(string) (map[string][]lineRange, error) { return nil, errors.New("diff failed") }
	if code := run(args, &stdout, &stderr, badLoader, nil); code != 2 || !strings.Contains(stderr.String(), "diff failed") {
		t.Fatalf("loader failure code=%d stderr=%q", code, stderr.String())
	}
}

func TestRunDefaultsToFullChangedCodeCoverage(t *testing.T) {
	profile := filepath.Join(t.TempDir(), "coverage.out")
	partialBody := "mode: atomic\n" +
		"example.com/project/internal/a.go:10.1,12.2 9 1\n" +
		"example.com/project/internal/a.go:13.1,13.2 1 0\n"
	if err := os.WriteFile(profile, []byte(partialBody), 0o600); err != nil {
		t.Fatal(err)
	}
	args := []string{
		"--changed-only",
		"--diff-profile", profile,
		"--base-ref", "base",
		"--module", "example.com/project",
	}
	loader := func(string) (map[string][]lineRange, error) {
		return map[string][]lineRange{"internal/a.go": {{Start: 10, End: 13}}}, nil
	}
	var stdout, stderr bytes.Buffer
	if code := run(args, &stdout, &stderr, loader, nil); code != 1 {
		t.Fatalf("run code=%d, want 1; stdout=%s stderr=%s", code, stdout.String(), stderr.String())
	}
	if !strings.Contains(stderr.String(), "changed code coverage 90.0000% is below target 100.0000%") {
		t.Fatalf("default target was not enforced: %q", stderr.String())
	}

	fullBody := "mode: atomic\n" +
		"example.com/project/internal/a.go:10.1,12.2 9 1\n" +
		"example.com/project/internal/a.go:13.1,13.2 1 1\n"
	if err := os.WriteFile(profile, []byte(fullBody), 0o600); err != nil {
		t.Fatal(err)
	}
	stdout.Reset()
	stderr.Reset()
	if code := run(args, &stdout, &stderr, loader, nil); code != 0 {
		t.Fatalf("100%% changed coverage code=%d; stdout=%s stderr=%s", code, stdout.String(), stderr.String())
	}
}

func TestCrossPlatformCoverageRunEvaluatesBaselineProfileWithCandidateCoverageModel(t *testing.T) {
	profile := filepath.Join(t.TempDir(), "coverage.out")
	body := "mode: atomic\n" +
		"example.com/project/internal/a.go:10.1,12.2 5 0\n" +
		"example.com/project/internal/a.go:10.1,12.2 5 1\n" +
		"example.com/project/internal/a.go:20.1,22.2 5 0\n"
	if err := os.WriteFile(profile, []byte(body), 0o600); err != nil {
		t.Fatal(err)
	}
	baseline := filepath.Join(t.TempDir(), "baseline.out")
	baselineBody := body + "example.com/project/internal/deleted.go:1.1,2.2 100 1\n"
	if err := os.WriteFile(baseline, []byte(baselineBody), 0o600); err != nil {
		t.Fatal(err)
	}
	args := []string{
		"--overall-profile", profile,
		"--baseline-profile", baseline,
		"--diff-profile", profile,
		"--base-ref", "base",
		"--module", "example.com/project",
	}
	loader := func(string) (map[string][]lineRange, error) {
		return map[string][]lineRange{}, nil
	}
	var stdout, stderr bytes.Buffer
	if code := run(args, &stdout, &stderr, loader, nil); code != 0 {
		t.Fatalf("run code=%d stderr=%s", code, stderr.String())
	}
	// Candidate overall stays 50%; merge-base ignores the deleted 100%-covered
	// package so non-regression compares the shared file set only.
	if !strings.Contains(stdout.String(), "overall coverage: 50.0000% (merge-base 50.0000%") {
		t.Fatalf("shared-file baseline comparison failed: %q", stdout.String())
	}
}

func TestRunFailsClosedWhenBaselineProfileIsMissing(t *testing.T) {
	profile := filepath.Join(t.TempDir(), "coverage.out")
	body := "mode: atomic\nexample.com/project/internal/a.go:10.1,12.2 5 1\n"
	if err := os.WriteFile(profile, []byte(body), 0o600); err != nil {
		t.Fatal(err)
	}
	args := []string{
		"--overall-profile", profile,
		"--baseline-profile", filepath.Join(t.TempDir(), "missing.out"),
		"--diff-profile", profile,
		"--base-ref", "base",
		"--module", "example.com/project",
	}
	loader := func(string) (map[string][]lineRange, error) {
		return map[string][]lineRange{}, nil
	}
	var stdout, stderr bytes.Buffer
	if code := run(args, &stdout, &stderr, loader, nil); code != 2 {
		t.Fatalf("missing baseline profile code=%d, want 2; stdout=%s stderr=%s", code, stdout.String(), stderr.String())
	}
	if !strings.Contains(stderr.String(), "open coverage profile") {
		t.Fatalf("missing baseline profile did not fail closed: %q", stderr.String())
	}
}

func TestRunRejectsConflictingBaselineSources(t *testing.T) {
	args := []string{
		"--overall-profile", "candidate.out",
		"--baseline-profile", "baseline.out",
		"--baseline-overall", "100",
		"--diff-profile", "candidate.out",
		"--base-ref", "base",
		"--module", "example.com/project",
	}
	var stdout, stderr bytes.Buffer
	if code := run(args, &stdout, &stderr, nil, nil); code != 2 {
		t.Fatalf("conflicting baseline sources code=%d, want 2; stdout=%s stderr=%s", code, stdout.String(), stderr.String())
	}
	if !strings.Contains(stderr.String(), "either --baseline-profile or --baseline-overall, not both") {
		t.Fatalf("conflicting baseline sources were not rejected clearly: %q", stderr.String())
	}
}

func TestCrossPlatformCoverageRunUnionsRepeatedOverallProfiles(t *testing.T) {
	dir := t.TempDir()
	uncovered := filepath.Join(dir, "uncovered.out")
	covered := filepath.Join(dir, "covered.out")
	if err := os.WriteFile(uncovered, []byte("mode: atomic\nexample.com/project/internal/a.go:10.1,12.2 5 0\n"), 0o600); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(covered, []byte("mode: atomic\nexample.com/project/internal/a.go:10.1,12.2 5 1\n"), 0o600); err != nil {
		t.Fatal(err)
	}
	args := []string{
		"--overall-profile", uncovered,
		"--overall-profile", covered,
		"--diff-profile", uncovered,
		"--diff-profile", covered,
		"--base-ref", "base",
		"--module", "example.com/project",
		"--baseline-overall", "100",
		"--target", "80",
	}
	loader := func(string) (map[string][]lineRange, error) {
		return map[string][]lineRange{"internal/a.go": {{Start: 10, End: 12}}}, nil
	}
	var stdout, stderr bytes.Buffer
	if code := run(args, &stdout, &stderr, loader, nil); code != 0 {
		t.Fatalf("run code=%d stderr=%s", code, stderr.String())
	}
	if !strings.Contains(stdout.String(), "overall coverage: 100.0000%") || !strings.Contains(stdout.String(), "changed code coverage: 100.0000%") {
		t.Fatalf("repeated profiles were not unioned: %q", stdout.String())
	}
}

func TestRunChangedOnlyWithBuildableScope(t *testing.T) {
	profile := filepath.Join(t.TempDir(), "coverage.out")
	body := "mode: atomic\nexample.com/project/internal/a.go:10.1,12.2 5 1\n"
	if err := os.WriteFile(profile, []byte(body), 0o600); err != nil {
		t.Fatal(err)
	}
	args := []string{
		"--changed-only",
		"--scope-buildable",
		"--diff-profile", profile,
		"--base-ref", "base",
		"--module", "example.com/project",
		"--target", "80",
	}
	loader := func(string) (map[string][]lineRange, error) {
		return map[string][]lineRange{
			"internal/a.go":         {{Start: 10, End: 12}},
			"internal/a_windows.go": {{Start: 1, End: 3}},
		}, nil
	}
	buildableLoader := func() (map[string]bool, error) {
		return map[string]bool{"internal/a.go": true}, nil
	}
	var stdout, stderr bytes.Buffer
	if code := run(args, &stdout, &stderr, loader, buildableLoader); code != 0 {
		t.Fatalf("run code=%d stderr=%s", code, stderr.String())
	}
	if strings.Contains(stdout.String(), "overall coverage") || !strings.Contains(stdout.String(), "changed code coverage: 100.0000%") {
		t.Fatalf("unexpected changed-only output %q", stdout.String())
	}

	missingProfileScope := func() (map[string]bool, error) {
		return map[string]bool{"internal/a.go": true, "internal/a_windows.go": true}, nil
	}
	stdout.Reset()
	stderr.Reset()
	if code := run(args, &stdout, &stderr, loader, missingProfileScope); code != 1 || !strings.Contains(stderr.String(), "internal/a_windows.go") {
		t.Fatalf("missing native profile code=%d stderr=%q", code, stderr.String())
	}

	brokenScope := func() (map[string]bool, error) { return nil, errors.New("go list failed") }
	stdout.Reset()
	stderr.Reset()
	if code := run(args, &stdout, &stderr, loader, brokenScope); code != 2 || !strings.Contains(stderr.String(), "go list failed") {
		t.Fatalf("scope failure code=%d stderr=%q", code, stderr.String())
	}
}

func TestReadProfiles(t *testing.T) {
	path := filepath.Join(t.TempDir(), "coverage.out")
	if err := os.WriteFile(path, []byte("mode: set\nexample.com/project/internal/a.go:1.1,2.2 3 1\n"), 0o600); err != nil {
		t.Fatal(err)
	}
	blocks, err := readProfiles([]string{path}, "example.com/project")
	if err != nil {
		t.Fatal(err)
	}
	if len(blocks) != 1 ||
		blocks[0].File != "internal/a.go" ||
		blocks[0].StartColumn != 1 ||
		blocks[0].EndColumn != 2 ||
		blocks[0].Statements != 3 {
		t.Fatalf("blocks=%v", blocks)
	}
	if _, err := readProfiles([]string{filepath.Join(t.TempDir(), "missing")}, "example.com/project"); err == nil {
		t.Fatal("missing profile should fail")
	}
}

func TestParseChangedLinesRejectsInvalidHunk(t *testing.T) {
	_, err := parseChangedLines([]byte("+++ b/internal/a.go\n@@ invalid @@\n"))
	if err == nil {
		t.Fatal("invalid hunk should fail")
	}
}

func TestGitChangedLines(t *testing.T) {
	repository := t.TempDir()
	runGit := func(args ...string) string {
		t.Helper()
		command := exec.Command("git", args...)
		command.Dir = repository
		output, err := command.CombinedOutput()
		if err != nil {
			t.Fatalf("git %v: %v\n%s", args, err, output)
		}
		return strings.TrimSpace(string(output))
	}
	runGit("init")
	runGit("config", "user.email", "coverage@example.com")
	runGit("config", "user.name", "Coverage Test")
	path := filepath.Join(repository, "a.go")
	if err := os.WriteFile(path, []byte("package sample\n"), 0o600); err != nil {
		t.Fatal(err)
	}
	runGit("add", "a.go")
	runGit("commit", "-m", "base")
	base := runGit("rev-parse", "HEAD")
	if err := os.WriteFile(path, []byte("package sample\n\nfunc added() int { return 1 }\n"), 0o600); err != nil {
		t.Fatal(err)
	}
	runGit("add", "a.go")
	runGit("commit", "-m", "change")
	if err := os.WriteFile(path, []byte("package sample\n\nfunc added() int { return 1 }\nfunc workingTree() int { return 2 }\n"), 0o600); err != nil {
		t.Fatal(err)
	}

	previous, err := os.Getwd()
	if err != nil {
		t.Fatal(err)
	}
	if err := os.Chdir(repository); err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = os.Chdir(previous) })
	changed, err := gitChangedLines(base)
	if err != nil {
		t.Fatal(err)
	}
	if len(changed["a.go"]) == 0 {
		t.Fatalf("changed lines=%v", changed)
	}
	last := changed["a.go"][len(changed["a.go"])-1]
	if last.End < 4 {
		t.Fatalf("working-tree line was not included: %v", changed["a.go"])
	}
}

func TestParseChangedLines(t *testing.T) {
	diff := []byte("diff --git a/internal/a.go b/internal/a.go\n+++ b/internal/a.go\n@@ -1,0 +2,3 @@\n+one\n+two\n+three\n" +
		"diff --git a/internal/a_test.go b/internal/a_test.go\n+++ b/internal/a_test.go\n@@ -0,0 +1,2 @@\n+test\n")
	got, err := parseChangedLines(diff)
	if err != nil {
		t.Fatal(err)
	}
	want := map[string][]lineRange{"internal/a.go": {{Start: 2, End: 4}}}
	if !reflect.DeepEqual(got, want) {
		t.Fatalf("parseChangedLines() = %#v, want %#v", got, want)
	}
}

func TestFilterChangedFiles(t *testing.T) {
	changed := map[string][]lineRange{
		"internal/a.go":         {{Start: 1, End: 2}},
		"internal/a_windows.go": {{Start: 3, End: 4}},
	}
	got := filterChangedFiles(changed, map[string]bool{"internal/a_windows.go": true})
	want := map[string][]lineRange{"internal/a_windows.go": {{Start: 3, End: 4}}}
	if !reflect.DeepEqual(got, want) {
		t.Fatalf("filterChangedFiles() = %#v, want %#v", got, want)
	}
}

func TestEvaluateAllowsNonRegressionAndCoveredChanges(t *testing.T) {
	result := evaluate(gateInput{
		Overall: []coverageBlock{
			{File: "internal/a.go", Statements: 8, Count: 1},
			{File: "internal/a.go", Statements: 2, Count: 0},
		},
		Diff: []coverageBlock{
			{File: "internal/a.go", StartLine: 10, EndLine: 12, Statements: 4, Count: 1},
			{File: "internal/a.go", StartLine: 20, EndLine: 22, Statements: 1, Count: 0},
		},
		Changed:         map[string][]lineRange{"internal/a.go": {{Start: 10, End: 22}}},
		BaselineOverall: 80,
		Target:          80,
	})
	if len(result.Failures) != 0 {
		t.Fatalf("unexpected failures: %v", result.Failures)
	}
	if result.ChangedCoverage != 80 {
		t.Fatalf("changed coverage = %.1f, want 80", result.ChangedCoverage)
	}
}

func TestCrossPlatformCoverageUnionsDuplicateCrossPackageCoverageBlocks(t *testing.T) {
	duplicate := coverageBlock{File: "internal/a.go", StartLine: 10, EndLine: 12, Statements: 4}
	covered := duplicate
	covered.Count = 3
	result := evaluate(gateInput{
		Overall: []coverageBlock{duplicate, covered},
		Diff:    []coverageBlock{duplicate, covered},
		Changed: map[string][]lineRange{"internal/a.go": {{Start: 10, End: 12}}},
		Target:  80,
	})
	if len(result.Failures) != 0 {
		t.Fatalf("duplicate blocks should be unioned: %v", result.Failures)
	}
	if result.Overall != 100 || result.ChangedCoverage != 100 || result.ChangedStatements != 4 {
		t.Fatalf("result = %#v, want one fully covered four-statement block", result)
	}
}

func TestCoverageKeepsDistinctBlocksOnTheSameLine(t *testing.T) {
	result := evaluate(gateInput{
		Diff: []coverageBlock{
			{
				File:        "internal/a.go",
				StartLine:   10,
				StartColumn: 1,
				EndLine:     10,
				EndColumn:   5,
				Statements:  1,
				Count:       1,
			},
			{
				File:        "internal/a.go",
				StartLine:   10,
				StartColumn: 6,
				EndLine:     10,
				EndColumn:   10,
				Statements:  1,
				Count:       0,
			},
		},
		Changed:     map[string][]lineRange{"internal/a.go": {{Start: 10, End: 10}}},
		Target:      100,
		ChangedOnly: true,
	})
	if result.ChangedCoverage != 50 || result.ChangedStatements != 2 {
		t.Fatalf("same-line blocks were collapsed: %#v", result)
	}
	if len(result.Failures) != 1 ||
		!strings.Contains(result.Failures[0], "changed code coverage 50.0000% is below target 100.0000%") {
		t.Fatalf("same-line uncovered block did not fail the gate: %v", result.Failures)
	}
}

func TestEvaluateAllowsMeasurementTolerance(t *testing.T) {
	result := evaluate(gateInput{
		Overall:          []coverageBlock{{Statements: 403, Count: 1}, {Statements: 597, Count: 0}},
		Changed:          map[string][]lineRange{},
		BaselineOverall:  40.4,
		OverallTolerance: 0.1,
		Target:           80,
	})
	if len(result.Failures) != 0 {
		t.Fatalf("measurement tolerance should allow 40.3%% vs 40.4%%: %v", result.Failures)
	}
}

func TestCrossPlatformCoverageFilterBlocksByFilesDropsDeletedPackages(t *testing.T) {
	if filtered := filterBlocksByFiles([]coverageBlock{{File: "internal/keep.go", Statements: 1, Count: 1}}, nil); filtered != nil {
		t.Fatalf("empty allowlist = %#v, want nil", filtered)
	}
	baseline := []coverageBlock{
		{File: "internal/keep.go", StartLine: 1, EndLine: 10, Statements: 50, Count: 1},
		{File: "internal/keep.go", StartLine: 11, EndLine: 20, Statements: 50, Count: 0},
		{File: "internal/deleted.go", StartLine: 1, EndLine: 40, Statements: 100, Count: 1},
	}
	currentFiles := profileFiles([]coverageBlock{
		{File: "internal/keep.go", StartLine: 1, EndLine: 8, Statements: 40, Count: 1},
	})
	filtered := filterBlocksByFiles(baseline, currentFiles)
	got := coveragePercent(filtered)
	if got != 50 {
		t.Fatalf("shared-file baseline = %.4f%%, want 50%% (deleted 100%%-covered package excluded)", got)
	}
	if len(profileFiles(filtered)) != 1 || !profileFiles(filtered)["internal/keep.go"] {
		t.Fatalf("filtered files = %#v, want only keep.go", profileFiles(filtered))
	}
}

func TestEvaluateDefaultsToZeroOverallTolerance(t *testing.T) {
	result := evaluate(gateInput{
		Overall:          []coverageBlock{{Statements: 403, Count: 1}, {Statements: 597, Count: 0}},
		Changed:          map[string][]lineRange{},
		BaselineOverall:  40.4,
		OverallTolerance: 0,
		Target:           100,
	})
	if len(result.Failures) != 1 ||
		!strings.Contains(result.Failures[0], "overall coverage regressed from 40.4000% to 40.3000%") {
		t.Fatalf("zero-tolerance regression failures = %v", result.Failures)
	}
}

func TestEvaluateRejectsRegressionHiddenByOneDecimalRounding(t *testing.T) {
	result := evaluate(gateInput{
		Overall: []coverageBlock{
			{Statements: 1999, Count: 1},
			{Statements: 1, Count: 0},
		},
		Changed:         map[string][]lineRange{},
		BaselineOverall: 100,
		Target:          100,
	})
	if len(result.Failures) != 1 ||
		!strings.Contains(result.Failures[0], "overall coverage regressed from 100.0000% to 99.9500%") {
		t.Fatalf("sub-tenth regression failures = %v", result.Failures)
	}
}

func TestEvaluateRejectsChangedCoverageBelow100WithoutRounding(t *testing.T) {
	result := evaluate(gateInput{
		Diff: []coverageBlock{
			{File: "internal/a.go", StartLine: 1, EndLine: 1999, Statements: 1999, Count: 1},
			{File: "internal/a.go", StartLine: 2000, EndLine: 2000, Statements: 1, Count: 0},
		},
		Changed:     map[string][]lineRange{"internal/a.go": {{Start: 1, End: 2000}}},
		Target:      100,
		ChangedOnly: true,
	})
	if len(result.Failures) != 1 ||
		!strings.Contains(result.Failures[0], "changed code coverage 99.9500% is below target 100.0000%") {
		t.Fatalf("sub-100 changed-code failures = %v", result.Failures)
	}
}

func TestEvaluateFailsClosed(t *testing.T) {
	result := evaluate(gateInput{
		Overall: []coverageBlock{
			{File: "internal/base.go", StartLine: 1, EndLine: 2, Statements: 10, Count: 1},
			{File: "internal/base.go", StartLine: 3, EndLine: 4, Statements: 10, Count: 0},
		},
		Diff:            []coverageBlock{{File: "internal/a.go", StartLine: 1, EndLine: 2, Statements: 2, Count: 0}},
		Changed:         map[string][]lineRange{"internal/a.go": {{Start: 1, End: 2}}, "internal/missing.go": {{Start: 1, End: 1}}},
		BaselineOverall: 54.2,
		Target:          80,
	})
	if len(result.Failures) != 3 {
		t.Fatalf("got failures %v, want overall, changed-code, and missing-profile failures", result.Failures)
	}
}

func TestEvaluateOverallTargetCanBeEnabled(t *testing.T) {
	result := evaluate(gateInput{
		Overall:         []coverageBlock{{Statements: 60, Count: 1}, {Statements: 40, Count: 0}},
		Diff:            []coverageBlock{},
		Changed:         map[string][]lineRange{},
		BaselineOverall: 54.2,
		Target:          80,
		EnforceOverall:  true,
	})
	if len(result.Failures) != 1 {
		t.Fatalf("failures = %v, want overall target failure", result.Failures)
	}
}

func TestExemptNonExecutableFiles(t *testing.T) {
	changed := map[string][]lineRange{
		"internal/cli/gen.go":  {{Start: 1, End: 5}},
		"internal/cli/doc.go":  {{Start: 1, End: 2}},
		"internal/cli/code.go": {{Start: 10, End: 12}},
	}
	filtered, exempted := exemptNonExecutableFiles(changed, func(path string) bool {
		return path == "internal/cli/code.go"
	})
	want := map[string][]lineRange{"internal/cli/code.go": {{Start: 10, End: 12}}}
	if !reflect.DeepEqual(filtered, want) {
		t.Fatalf("filtered = %#v, want %#v", filtered, want)
	}
	// 豁免列表按字典序返回，供调用方日志化而非静默丢弃。
	if !reflect.DeepEqual(exempted, []string{"internal/cli/doc.go", "internal/cli/gen.go"}) {
		t.Fatalf("exempted = %v, want sorted exempted paths", exempted)
	}
}

func TestFileHasExecutableStatements(t *testing.T) {
	dir := t.TempDir()
	write := func(name, source string) string {
		path := filepath.Join(dir, name)
		if err := os.WriteFile(path, []byte(source), 0o600); err != nil {
			t.Fatal(err)
		}
		return path
	}
	cases := []struct {
		name string
		path string
		want bool
	}{
		{
			name: "pragma-only file has no executable statements",
			path: write("gen.go", "// Comment only.\npackage cli\n\n//go:generate echo hi\n"),
			want: false,
		},
		{
			name: "function body counts as executable",
			path: write("code.go", "package cli\n\nfunc f() int { return 1 }\n"),
			want: true,
		},
		{
			name: "empty function body is not executable",
			path: write("empty.go", "package cli\n\nfunc f() {}\n"),
			want: false,
		},
		{
			name: "package-level function literal counts as executable",
			path: write("lit.go", "package cli\n\nvar f = func() int { return 1 }\n"),
			want: true,
		},
		{
			name: "missing file stays conservative",
			path: filepath.Join(dir, "nonexistent.go"),
			want: true,
		},
		{
			name: "unparsable file stays conservative",
			path: write("broken.go", "package cli\n\nfunc {{{\n"),
			want: true,
		},
	}
	for _, tc := range cases {
		if got := fileHasExecutableStatements(tc.path); got != tc.want {
			t.Errorf("%s: fileHasExecutableStatements() = %v, want %v", tc.name, got, tc.want)
		}
	}
}

func TestRunLogsExemptedNonExecutableFiles(t *testing.T) {
	dir := t.TempDir()
	pragmaOnly := filepath.Join(dir, "gen.go")
	if err := os.WriteFile(pragmaOnly, []byte("// pragma carrier\npackage cli\n\n//go:generate echo hi\n"), 0o600); err != nil {
		t.Fatal(err)
	}
	profile := filepath.Join(dir, "coverage.out")
	body := "mode: atomic\nexample.com/project/internal/a.go:10.1,12.2 5 1\n"
	if err := os.WriteFile(profile, []byte(body), 0o600); err != nil {
		t.Fatal(err)
	}
	args := []string{
		"--overall-profile", profile,
		"--diff-profile", profile,
		"--base-ref", "base",
		"--module", "example.com/project",
		"--baseline-overall", "100",
		"--target", "80",
	}
	loader := func(string) (map[string][]lineRange, error) {
		return map[string][]lineRange{
			"internal/a.go": {{Start: 10, End: 12}},
			pragmaOnly:      {{Start: 1, End: 4}},
		}, nil
	}
	var stdout, stderr bytes.Buffer
	if code := run(args, &stdout, &stderr, loader, nil); code != 0 {
		t.Fatalf("run code=%d stderr=%s", code, stderr.String())
	}
	if !strings.Contains(stderr.String(), "exempting "+pragmaOnly) {
		t.Fatalf("stderr = %q, want exemption log for pragma-only file", stderr.String())
	}
}

func TestCrossPlatformCoveragePhysicalPath(t *testing.T) {
	real := t.TempDir()
	link := filepath.Join(t.TempDir(), "link")
	if err := os.Symlink(real, link); err != nil {
		t.Fatalf("symlink: %v", err)
	}
	expected, err := filepath.EvalSymlinks(real)
	if err != nil {
		t.Fatalf("EvalSymlinks(real): %v", err)
	}
	if got := physicalPath(link); got != expected {
		t.Fatalf("physicalPath(%q) = %q, want %q", link, got, expected)
	}
	missing := filepath.Join(t.TempDir(), "missing")
	if got := physicalPath(missing); got != missing {
		t.Fatalf("physicalPath(%q) = %q, want path returned unchanged", missing, got)
	}
}

func TestCrossPlatformCoverageGoListBuildableFilesIncludesSelfPackage(t *testing.T) {
	buildable, err := goListBuildableFiles()
	if err != nil {
		t.Fatalf("goListBuildableFiles: %v", err)
	}
	if !buildable["scripts/policy/coverage-gate/main.go"] {
		t.Fatalf("buildable files missing self package; sample keys: %v", firstKeys(buildable, 3))
	}
}

func firstKeys(m map[string]bool, n int) []string {
	keys := make([]string, 0, n)
	for key := range m {
		keys = append(keys, key)
		if len(keys) == n {
			break
		}
	}
	return keys
}