// Copyright 2021 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

package fint

import (
	"context"
	"errors"
	"fmt"
	"io"
	"io/ioutil"
	"os"
	"path/filepath"
	"sort"
	"strings"
	"testing"
	"time"

	"github.com/google/go-cmp/cmp"
	"google.golang.org/protobuf/testing/protocmp"

	"go.fuchsia.dev/fuchsia/tools/build"
	fintpb "go.fuchsia.dev/fuchsia/tools/integration/fint/proto"
	"go.fuchsia.dev/fuchsia/tools/lib/streams"
)

func TestRunNinja(t *testing.T) {
	ctx := context.Background()
	// Don't emit the mock ninja logs to stdio while running tests, because
	// they're noisy.
	ctx = streams.ContextWithStdout(ctx, io.Discard)
	ctx = streams.ContextWithStderr(ctx, io.Discard)

	testCases := []struct {
		name string
		// Whether to mock a non-zero ninja retcode, in which case we should get
		// an error.
		fail bool
		// Mock Ninja stdout.
		stdout                 string
		expectedActionData     *fintpb.NinjaActionMetrics
		expectedFailureMessage string
	}{
		{
			name: "success",
			stdout: `
                [1/2] ACTION a.o
                [2/2] ACTION b.o
            `,
			expectedActionData: &fintpb.NinjaActionMetrics{
				InitialActions: 2,
				FinalActions:   2,
				ActionsByType: map[string]int32{
					"ACTION": 2,
				},
			},
		},
		{
			name: "success with regenerating ninja files",
			stdout: `
                [0/1] Regenerating ninja files
                [1/3] ACTION a.o
                [2/3] ACTION b.o
            `,
			expectedActionData: &fintpb.NinjaActionMetrics{
				InitialActions: 3,
				FinalActions:   3,
				ActionsByType: map[string]int32{
					"ACTION": 2,
				},
			},
		},
		{
			name: "multiple action types",
			stdout: `
                [1/3] CXX a.o
                [2/3] RUST crab.rlib
                [3/3] RUST lobster.rlib
            `,
			expectedActionData: &fintpb.NinjaActionMetrics{
				InitialActions: 3,
				FinalActions:   3,
				ActionsByType: map[string]int32{
					"CXX":  1,
					"RUST": 2,
				},
			},
		},
		{
			name: "restat decreasing action counts",
			stdout: `
                [1/300] CXX a.o
                [2/200] RUST crab.rlib
                [3/100] RUST lobster.rlib
            `,
			expectedActionData: &fintpb.NinjaActionMetrics{
				InitialActions: 300,
				FinalActions:   100,
				ActionsByType: map[string]int32{
					"CXX":  1,
					"RUST": 2,
				},
			},
		},
		{
			name: "single failed target",
			fail: true,
			stdout: `
                [35792/53672] CXX a.o b.o
                [35793/53672] CXX c.o d.o
                FAILED: c.o d.o
                output line 1
                output line 2
                [35794/53672] CXX successful/e.o
                [35795/53672] CXX f.o
            `,
			expectedFailureMessage: `
                [35793/53672] CXX c.o d.o
                FAILED: c.o d.o
                output line 1
                output line 2
            `,
			expectedActionData: &fintpb.NinjaActionMetrics{
				InitialActions: 53672,
				FinalActions:   53672,
				ActionsByType: map[string]int32{
					"CXX": 4,
				},
			},
		},
		{
			name: "single failed target decreasing action counts",
			fail: true,
			stdout: `
                [35792/53672] CXX a.o b.o
                [35793/53672] CXX c.o d.o
                FAILED: c.o d.o
                output line 1
                output line 2
                [35794/45678] CXX successful/e.o
                [35795/45678] CXX f.o
            `,
			expectedFailureMessage: `
                [35793/53672] CXX c.o d.o
                FAILED: c.o d.o
                output line 1
                output line 2
            `,
			expectedActionData: &fintpb.NinjaActionMetrics{
				InitialActions: 53672,
				FinalActions:   45678,
				ActionsByType: map[string]int32{
					"CXX": 4,
				},
			},
		},
		{
			name: "preserves indentation",
			fail: true,
			stdout: `
                [35793/53672] CXX a.o b.o
                FAILED: a.o b.o
                    output line 1
                        output line 2
                            output line 3
                [35794/53672] CXX successful/c.o
            `,
			expectedFailureMessage: `
                [35793/53672] CXX a.o b.o
                FAILED: a.o b.o
                    output line 1
                        output line 2
                            output line 3
            `,
			expectedActionData: &fintpb.NinjaActionMetrics{
				InitialActions: 53672,
				FinalActions:   53672,
				ActionsByType: map[string]int32{
					"CXX": 2,
				},
			},
		},
		{
			name: "multiple failed targets",
			fail: true,
			stdout: `
                [35790/53672] CXX foo
                [35791/53672] CXX a.o b.o
                FAILED: a.o b.o
                output line 1
                output line 2
                [35792/53672] CXX c.o d.o
                [35793/53672] CXX e.o
                FAILED: e.o
                output line 3
                output line 4
                [35794/53672] CXX f.o
            `,
			expectedFailureMessage: `
                [35791/53672] CXX a.o b.o
                FAILED: a.o b.o
                output line 1
                output line 2
                [35793/53672] CXX e.o
                FAILED: e.o
                output line 3
                output line 4
            `,
			expectedActionData: &fintpb.NinjaActionMetrics{
				InitialActions: 53672,
				FinalActions:   53672,
				ActionsByType: map[string]int32{
					"CXX": 5,
				},
			},
		},
		{
			name: "last target fails",
			fail: true,
			stdout: `
                [35790/53672] CXX foo
                [35791/53672] CXX a.o b.o
                FAILED: a.o b.o
                output line 1
                output line 2
                ninja: build stopped: subcommand failed.
            `,
			expectedFailureMessage: `
                [35791/53672] CXX a.o b.o
                FAILED: a.o b.o
                output line 1
                output line 2
            `,
			expectedActionData: &fintpb.NinjaActionMetrics{
				InitialActions: 53672,
				FinalActions:   53672,
				ActionsByType: map[string]int32{
					"CXX": 2,
				},
			},
		},
		{
			name: "gn gen fails",
			fail: true,
			stdout: `
				ninja: Entering directory '/usr/me/fuchsia/out/default'
				[0/1] Regenerating ninja files
				ERROR at //src/foo/BUILD.gn:41:5: Can't load input file.
					"//src/bar:tests",
					^----------------
				Unable to load:
				/usr/me/fuchsia/src/bar/BUILD.gn
				FAILED: build.ninja
				../../prebuilt/third_party/gn/linux-x64/gn --root=../.. gen .
				ninja: error: rebuilding 'build.ninja': subcommand failed
			`,
			expectedFailureMessage: `
				[0/1] Regenerating ninja files
				ERROR at //src/foo/BUILD.gn:41:5: Can't load input file.
					"//src/bar:tests",
					^----------------
				Unable to load:
				/usr/me/fuchsia/src/bar/BUILD.gn
				FAILED: build.ninja
				../../prebuilt/third_party/gn/linux-x64/gn --root=../.. gen .
				ninja: error: rebuilding 'build.ninja': subcommand failed
            `,
		},
		{
			name: "ninja internal error",
			fail: true,
			stdout: `
                [1/53672] CXX foo
                [2/53672] CXX a.o b.o
                ninja: build stopped: something went wrong
            `,
			expectedFailureMessage: `
                ninja: build stopped: something went wrong
			`,
			expectedActionData: &fintpb.NinjaActionMetrics{
				InitialActions: 53672,
				FinalActions:   53672,
				ActionsByType: map[string]int32{
					"CXX": 2,
				},
			},
		},
		{
			name: "graph error",
			fail: true,
			stdout: `
				ninja: Entering directory /foo
				ninja: error: bar.ninja: multiple rules generate baz
            `,
			expectedFailureMessage: `
				ninja: error: bar.ninja: multiple rules generate baz
            `,
		},
		{
			name: "fatal error",
			fail: true,
			stdout: `
				ninja: Entering directory /foo
				[1/1] ACTION //foo
				ninja: fatal: cannot create file foo
            `,
			expectedFailureMessage: `
				ninja: fatal: cannot create file foo
            `,
			expectedActionData: &fintpb.NinjaActionMetrics{
				InitialActions: 1,
				FinalActions:   1,
				ActionsByType: map[string]int32{
					"ACTION": 1,
				},
			},
		},
		{
			name: "unrecognized failure",
			fail: true,
			stdout: `
				ninja: Entering directory /foo
				...something went wrong...
            `,
			expectedFailureMessage: unrecognizedFailureMsg,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			tc.stdout = trimLines(tc.stdout)
			tc.expectedFailureMessage = trimLines(tc.expectedFailureMessage)

			sr := &fakeSubprocessRunner{
				mockStdout: []byte(tc.stdout),
				fail:       tc.fail,
			}
			r := ninjaRunner{
				runner:    sr,
				ninjaPath: filepath.Join(t.TempDir(), "ninja"),
				buildDir:  filepath.Join(t.TempDir(), "out"),
				jobCount:  23, // Arbitrary but distinctive value.
			}
			msg, gotActionData, err := runNinja(ctx, r, []string{}, []string{"foo", "bar"}, false, nil)
			if tc.fail {
				if !errors.Is(err, errSubprocessFailure) {
					t.Fatalf("Expected a subprocess failure error but got: %s", err)
				}
			} else if err != nil {
				t.Fatalf("Unexpected error: %s", err)
			}

			if len(sr.commandsRun) != 1 {
				t.Fatalf("Expected runNinja to run 1 command but got %d", len(sr.commandsRun))
			}
			cmd := sr.commandsRun[0]
			if cmd[0] != r.ninjaPath {
				t.Fatalf("runNinja ran wrong executable %q (expected %q)", cmd[0], r.ninjaPath)
			}
			foundJobCount := false
			for i, part := range cmd {
				if part == "-j" {
					foundJobCount = true
					if i+1 >= len(cmd) || cmd[i+1] != fmt.Sprintf("%d", r.jobCount) {
						t.Errorf("Wrong value for -j flag: %v", cmd)
					}
				}
			}
			if !foundJobCount {
				t.Errorf("runNinja didn't set the -j flag. Full command: %v", cmd)
			}

			wantMsg := tc.expectedFailureMessage
			if wantMsg != "" {
				wantMsg += "\n"
			}
			if diff := cmp.Diff(wantMsg, msg); diff != "" {
				t.Errorf("Unexpected failure message diff (-want +got):\n%s", diff)
			}
			if diff := cmp.Diff(tc.expectedActionData, gotActionData, protocmp.Transform()); diff != "" {
				t.Errorf("Unexpected action data diff (-want, +got):\n%s", diff)
			}
		})
	}
}

func TestRunWithNinjaExplain(t *testing.T) {
	gotStdout := new(strings.Builder)
	ctx := streams.ContextWithStdout(context.Background(), gotStdout)

	sr := &fakeSubprocessRunner{
		mockStdout: []byte(`ninja: Entering directory /foo
[1/1] ACTION //foo
ninja explain: obj/build/foo is dirty`),
	}
	r := ninjaRunner{
		runner:    sr,
		ninjaPath: filepath.Join(t.TempDir(), "ninja"),
		buildDir:  filepath.Join(t.TempDir(), "out"),
		jobCount:  32, // Arbitrary but distinctive value.
	}

	explainSink := new(strings.Builder)

	if _, _, err := runNinja(ctx, r, []string{}, []string{"foo", "bar"}, true /* explain */, explainSink); err != nil {
		t.Fatalf("runNinja failed: %s", err)
	}

	wantExplainOutput := "ninja explain: obj/build/foo is dirty\n"
	if diff := cmp.Diff(wantExplainOutput, explainSink.String()); diff != "" {
		t.Errorf("Unexpected explain output diff (-want +got):\n%s", diff)
	}

	wantStdout := `ninja: Entering directory /foo
[1/1] ACTION //foo
`
	if diff := cmp.Diff(wantStdout, gotStdout.String()); diff != "" {
		t.Errorf("Unexpected stdout output diff (-want +got):\n%s", diff)
	}
}

// trimLines removes leading/trailing whitespace from each line of a multiline
// string.
func trimLines(s string) string {
	var res []string
	for _, line := range strings.Split(s, "\n") {
		trimmed := strings.TrimSpace(line)
		if trimmed != "" {
			res = append(res, trimmed)
		}
	}
	return strings.Join(res, "\n")
}

func TestCheckNinjaNoop(t *testing.T) {
	testCases := []struct {
		name       string
		isMac      bool
		stdout     string
		fail       bool
		expectNoop bool
		expectErr  bool
	}{
		{
			name:       "no-op",
			stdout:     "ninja: Entering directory /foo\nninja: no work to do.",
			expectNoop: true,
		},
		{
			name:      "ninja fails",
			stdout:    "ninja: Entering directory /foo\nninja: no work to do.",
			fail:      true,
			expectErr: true,
		},
		{
			name:       "dirty",
			stdout:     "ninja: Entering directory /foo\n[1/1] STAMP foo.stamp",
			expectNoop: false,
		},
		{
			name:       "mac dirty",
			isMac:      true,
			stdout:     "ninja: Entering directory /foo\n[1/1] STAMP foo.stamp",
			expectNoop: false,
		},
		{
			name:       "broken mac path",
			isMac:      true,
			stdout:     "ninja: Entering directory /foo\nninja explain: ../../../../usr/bin/env is dirty",
			expectNoop: true,
		},
		{
			name:       "ninja fails on mac, with known broken mac path",
			isMac:      true,
			fail:       true,
			stdout:     "ninja: Entering directory /foo\nninja explain: ../../../../usr/bin/env is dirty",
			expectNoop: true,
		},
		{
			name:      "ninja fails on mac, no broken path",
			isMac:     true,
			fail:      true,
			stdout:    "ninja: Entering directory /foo\n[1/1] STAMP foo.stamp",
			expectErr: true,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			r := ninjaRunner{
				runner: &fakeSubprocessRunner{
					mockStdout: []byte(tc.stdout),
					fail:       tc.fail,
				},
				ninjaPath: "ninja",
				buildDir:  t.TempDir(),
			}
			noop, logFiles, err := checkNinjaNoop(context.Background(), r, []string{"foo"}, tc.isMac)
			if err != nil {
				if !tc.expectErr {
					t.Fatal(err)
				}
				return
			} else if tc.expectErr {
				t.Fatalf("Expected an error but got nil")
			}
			if noop != tc.expectNoop {
				t.Fatalf("Unexpected ninja no-op result: got %t, expected %t", noop, tc.expectNoop)
			}
			if tc.expectNoop {
				if len(logFiles) > 0 {
					t.Errorf("Expected no log files in case of no-op, but got: %+v", logFiles)
				}
			} else if len(logFiles) != 2 {
				t.Errorf("Expected 2 log files in case of non-no-op, but got: %+v", logFiles)
			}
		})
	}
}

func TestAffectedTestsNoWork(t *testing.T) {
	mockTestManifest := []build.Test{
		{
			Name:  "host_test",
			Path:  "host/run.sh",
			Label: "//tools/foo:host_test(//toolchain)",
		},
		{
			Name:             "fuchsia_test",
			Label:            "//src/path/to:fuchsia_test(//toolchain)",
			PackageLabel:     "//src/path/to:fuchsia_test_pkg(//toolchain)",
			PackageManifests: []string{"obj/src/path/to/fuchsia_test/package_manifest.json"},
		},
		{
			Name:             "fuchsia_test2",
			Label:            "//src/path2:fuchsia_test(//toolchain)",
			PackageLabel:     "//src/path2/test:pkg(//toolchain)",
			PackageManifests: []string{"obj/src/path2/test/pkg/package_manifest.json"},
		},
		{
			Name:             "unaffected_test",
			Label:            "//src/path/to:unaffected_test(//toolchain)",
			PackageLabel:     "//src/path/to:unaffected_test_pkg(//toolchain)",
			PackageManifests: []string{"obj/src/path/to/unaffected_test/package_manifest.json"},
		},
		{
			Name:         "never_affected_test",
			PackageLabel: neverAffectedTestLabels[0] + "(//toolchain)",
		},
	}

	testCases := []struct {
		name                  string
		ninjaOutput           string
		affectedFiles         []string
		expectedAffectedTests []string
		expectedNoWork        bool
		expectedDryRuns       int
	}{
		{
			name:                  "unaffected",
			ninjaOutput:           "ninja: entering directory /foo" + noWorkString,
			affectedFiles:         []string{"foo.go"},
			expectedAffectedTests: nil,
			expectedNoWork:        true,
		},
		{
			name: "affected tests",
			ninjaOutput: `
ninja: entering directory /foo
ninja explain: obj/src/path/to/fuchsia_test/package_manifest.json is dirty
ninja explain: obj/another_test/package_manifest.json is dirty
[3/3] python build.py host/run.sh
            `,
			expectedAffectedTests: []string{"host_test", "fuchsia_test"},
			expectedNoWork:        false,
		},
		{
			name: "affected GN files",
			ninjaOutput: `
ninja: entering directory /foo
ninja explain: obj/src/path/to/fuchsia_test/package_manifest.json is dirty
ninja explain: obj/another_test/package_manifest.json is dirty
[3/3] python build.py host/run.sh
			`,
			affectedFiles:         []string{"foo.gn", "bar.gni", "foo.go"},
			expectedAffectedTests: []string{"host_test", "fuchsia_test"},
			expectedNoWork:        false,
			// If GN files are affected, the first dry run should not touch them
			// but the second one should.
			expectedDryRuns: 2,
		},
		{
			name:                  "affected BUILD.gn file defining fuchsia_test2",
			ninjaOutput:           "ninja: entering directory /foo" + noWorkString,
			affectedFiles:         []string{"src/path2/BUILD.gn"},
			expectedAffectedTests: []string{"fuchsia_test2"},
			expectedNoWork:        true,
			expectedDryRuns:       2,
		},
		{
			name:                  "affected BUILD.gn file defining fuchsia_test2 package",
			ninjaOutput:           "ninja: entering directory /foo" + noWorkString,
			affectedFiles:         []string{"src/path2/test/BUILD.gn"},
			expectedAffectedTests: []string{"fuchsia_test2"},
			expectedNoWork:        true,
			expectedDryRuns:       2,
		},
		{
			name:                  "affected BUILD.gn file defining host test",
			ninjaOutput:           "ninja: entering directory /foo" + noWorkString,
			affectedFiles:         []string{"tools/foo/BUILD.gn"},
			expectedAffectedTests: []string{"host_test"},
			expectedNoWork:        true,
			expectedDryRuns:       2,
		},
	}

	oneMinuteAgo := time.Now().Add(-1 * time.Minute)
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			// Apply default values and otherwise transform the test parameters
			// to make tests easier to specify.
			if tc.expectedDryRuns == 0 {
				tc.expectedDryRuns = 1
			}
			sort.Strings(tc.expectedAffectedTests)
			checkoutDir := t.TempDir()
			err := os.Chdir(checkoutDir)
			if err != nil {
				t.Fatal(err)
			}

			subprocessRunner := fakeSubprocessRunner{
				mockStdout: []byte(tc.ninjaOutput),
			}
			r := ninjaRunner{
				runner:    &subprocessRunner,
				ninjaPath: "ninja",
				buildDir:  "build",
			}

			contextSpec := &fintpb.Context{
				CheckoutDir: checkoutDir,
			}
			for _, path := range tc.affectedFiles {
				contextSpec.ChangedFiles = append(contextSpec.ChangedFiles, &fintpb.Context_ChangedFile{Path: path})

				absPath := filepath.Join(checkoutDir, path)
				if err := os.MkdirAll(filepath.Dir(absPath), 0o700); err != nil {
					t.Fatal(err)
				}
				if _, err := os.Create(absPath); err != nil {
					t.Fatal(err)
				}
				if err := os.Chtimes(absPath, oneMinuteAgo, oneMinuteAgo); err != nil {
					t.Fatal(err)
				}
			}

			targets := []string{"foo", "bar"}
			result, err := affectedTestsNoWork(context.Background(), r, contextSpec, mockTestManifest, targets)
			if err != nil {
				t.Fatal(err)
			}

			if len(result.logs) == 0 {
				t.Errorf("Expected logs to contain at least one log, but got none")
			}

			if len(subprocessRunner.commandsRun) != tc.expectedDryRuns {
				t.Errorf("Expected %d dry run(s) but got %d", tc.expectedDryRuns, len(subprocessRunner.commandsRun))
			}
			if diff := cmp.Diff(tc.expectedAffectedTests, result.affectedTests); diff != "" {
				t.Errorf("Unexpected affected tests diff (-want +got):\n%s", diff)
			}
			if tc.expectedNoWork != result.noWork {
				t.Errorf("Wrong no work result, wanted %v, got %v", tc.expectedNoWork, result.noWork)
			}

			// Ensure file timestamps weren't modified
			for _, path := range tc.affectedFiles {
				absPath := filepath.Join(checkoutDir, path)
				stat, err := os.Stat(absPath)
				if err != nil {
					t.Fatal(err)
				}
				if !stat.ModTime().Equal(oneMinuteAgo) {
					t.Errorf("Unexpected %v modified time, wanted %v, got %v", absPath, oneMinuteAgo, stat.ModTime())
				}
			}
		})
	}
}

func TestTouchFiles(t *testing.T) {
	oneMinuteAgo := time.Now().Add(-1 * time.Minute)
	dir := t.TempDir()
	exists1 := filepath.Join(dir, "exists1")
	if _, err := os.Create(exists1); err != nil {
		t.Fatal(err)
	}
	if err := os.Chtimes(exists1, oneMinuteAgo, oneMinuteAgo); err != nil {
		t.Fatal(err)
	}
	exists2 := filepath.Join(dir, "exists2")
	if _, err := os.Create(exists2); err != nil {
		t.Fatal(err)
	}
	if err := os.Chtimes(exists2, oneMinuteAgo, oneMinuteAgo); err != nil {
		t.Fatal(err)
	}
	doesntExist := filepath.Join(dir, "doesntExist")

	resetMap, err := touchFiles([]string{exists1, exists2, doesntExist})
	if err != nil {
		t.Fatal(err)
	}

	stat, err := os.Stat(exists1)
	if err != nil {
		t.Fatal(err)
	}
	if !stat.ModTime().After(oneMinuteAgo) {
		t.Errorf("Did not touch exists1, ModTime was %v", stat.ModTime())
	}
	stat, err = os.Stat(exists2)
	if err != nil {
		t.Fatal(err)
	}
	if !stat.ModTime().After(oneMinuteAgo) {
		t.Errorf("Did not touch exists2, ModTime was %v", stat.ModTime())
	}
	if _, err := os.Stat(doesntExist); !os.IsNotExist(err) {
		t.Errorf("Touched non-existent file doesntExist or other error %v", err)
	}

	if err := resetTouchFiles(resetMap); err != nil {
		t.Fatal(err)
	}
	stat, err = os.Stat(exists1)
	if err != nil {
		t.Fatal(err)
	}
	if !stat.ModTime().Equal(oneMinuteAgo) {
		t.Errorf("Did not reset exists1, ModTime was %v, wanted %v", stat.ModTime(), oneMinuteAgo)
	}
	stat, err = os.Stat(exists2)
	if err != nil {
		t.Fatal(err)
	}
	if !stat.ModTime().Equal(oneMinuteAgo) {
		t.Errorf("Did not reset exists2, ModTime was %v, wanted %v", stat.ModTime(), oneMinuteAgo)
	}
	if _, err := os.Stat(doesntExist); !os.IsNotExist(err) {
		t.Errorf("Reset non-existent file doesntExist or other error %v", err)
	}
}

func TestNinjaDryRun(t *testing.T) {
	testCases := []struct {
		name string
		fail bool
	}{
		{
			name: "success",
		},
		{
			name: "fail",
			fail: true,
		},
	}
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			var gotStdout strings.Builder
			ctx := streams.ContextWithStdout(context.Background(), &gotStdout)
			mockStdout := "ninja\nstdout\n"
			subprocessRunner := &fakeSubprocessRunner{
				mockStdout: []byte(mockStdout),
				fail:       tc.fail,
			}
			r := ninjaRunner{
				runner:    subprocessRunner,
				ninjaPath: "ninja",
				buildDir:  t.TempDir(),
			}
			stdout, stderr, err := ninjaDryRun(ctx, r, []string{"foo"})
			if err != nil {
				if !tc.fail {
					t.Errorf("Unexpected error: %s", err)
				}
			} else if tc.fail {
				t.Errorf("Expected error but got none")
			}
			if diff := cmp.Diff(mockStdout, stdout); diff != "" {
				t.Errorf("stdout differs from expected (-want +got): %s", diff)
			}
			if stderr != "" {
				t.Errorf("stderr is unexpectedly non-empty: %s", stderr)
			}

			if tc.fail {
				if diff := cmp.Diff(mockStdout, gotStdout.String()); diff != "" {
					t.Errorf("os.Stdout differs from expected (-want +got): %s", diff)
				}
			} else if gotStdout.String() != "" {
				t.Errorf("ninjaDryRun should not emit to os.Stdout if it succeeds")
			}
		})
	}
}

func TestNinjaGraph(t *testing.T) {
	ctx := context.Background()
	stdout := "ninja\ngraph\nstdout"
	r := ninjaRunner{
		runner: &fakeSubprocessRunner{
			mockStdout: []byte(stdout),
		},
		ninjaPath: "ninja",
		buildDir:  t.TempDir(),
	}
	path := filepath.Join(t.TempDir(), "foo.txt")
	if err := ninjaGraph(ctx, r, []string{"foo", "bar"}, path); err != nil {
		t.Fatal(err)
	}
	defer os.Remove(path)
	fileContentsBytes, err := ioutil.ReadFile(path)
	if err != nil {
		t.Fatal(err)
	}

	fileContents := string(fileContentsBytes)
	if diff := cmp.Diff(stdout, fileContents); diff != "" {
		t.Errorf("Unexpected ninja graph file diff (-want +got):\n%s", diff)
	}
}

func TestNinjaCompdb(t *testing.T) {
	ctx := context.Background()
	stdout := "ninja\ncompdb\nstdout"
	r := ninjaRunner{
		runner: &fakeSubprocessRunner{
			mockStdout: []byte(stdout),
		},
		ninjaPath: "ninja",
		buildDir:  t.TempDir(),
	}
	path := filepath.Join(t.TempDir(), "foo.txt")
	if err := ninjaCompdb(ctx, r, path); err != nil {
		t.Fatal(err)
	}
	defer os.Remove(path)
	fileContentsBytes, err := ioutil.ReadFile(path)
	if err != nil {
		t.Fatal(err)
	}

	fileContents := string(fileContentsBytes)
	if diff := cmp.Diff(stdout, fileContents); diff != "" {
		t.Errorf("Unexpected ninja compdb file diff (-want +got):\n%s", diff)
	}
}

func TestStripNinjaExplain(t *testing.T) {
	for _, tc := range []struct {
		name  string
		input string
		want  string
	}{
		{
			name: "empty",
		},
		{
			name:  "space",
			input: " ",
			want:  " ",
		},
		{
			name: "strip ninja explains",
			input: `ninja explain: blah
to keep
  ninja explain: discard
should keep
`,
			want: `to keep
should keep
`,
		},
		{
			name: "no ninja explains",
			input: `build
build more
build even more
`,
			want: `build
build more
build even more
`,
		},
		{
			name:  "no newline",
			input: "oneliner",
			want:  "oneliner",
		},
		{
			name: "ninja explain only",
			input: `ninja explain: I have reasons
  ninja explain: you know`,
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			got := new(strings.Builder)
			w := stripNinjaExplain(got)

			if _, err := w.Write([]byte(tc.input)); err != nil {
				t.Fatalf("Write failed: %v", err)
			}
			w.Flush()
			if diff := cmp.Diff(tc.want, got.String()); diff != "" {
				t.Errorf("Got unexpected output diff when writing in one pass (-want +got):\n%s", diff)
			}

			got.Reset()
			for _, b := range tc.input {
				if _, err := w.Write([]byte{byte(b)}); err != nil {
					t.Fatalf("Write failed: %v", err)
				}
			}
			w.Flush()
			if diff := cmp.Diff(tc.want, got.String()); diff != "" {
				t.Errorf("Got unexpected output diff when writing byte by byte (-want +got):\n%s", diff)
			}
		})
	}
}