tools/integration/fint/ninja.go - fuchsia - Git at Google

 // 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 (
 	"bufio"
 	"context"
 	"fmt"
 	"io"
 	"io/ioutil"
 	"os"
 	"path"
 	"path/filepath"
 	"regexp"
 	"strings"
 	"time"
 	"unicode"

 	"go.fuchsia.dev/fuchsia/tools/build"
 )

 var (
 	// ruleRegex matches a regular line of Ninja stdout in the default format,
 	// e.g. "[56/1234] CXX host_x64/foo.o"
 	ruleRegex = regexp.MustCompile(`^\s*\[\d+/\d+\] \S+`)

 	// errorRegex matches a single-line error message that Ninja prints at the
 	// end of its output if it encounters an error that prevents it from even
 	// starting the build (e.g. multiple rules generating the same target file),
 	// or a fatal error in the middle of the build (e.g. OS error). These error
 	// strings are defined here:
 	// https://github.com/ninja-build/ninja/blob/master/src/util.cc
 	errorRegex = regexp.MustCompile(`^\s*ninja: (error|fatal): .+`)

 	// failureStartRegex matches the first line of a failure message, e.g.
 	// "FAILED: foo.o"
 	failureStartRegex = regexp.MustCompile(`^\s*FAILED: .*`)

 	// failureEndRegex indicates the end of Ninja's execution as a result of a
 	// build failure. When present, it will be the last line of stdout.
 	failureEndRegex = regexp.MustCompile(`^\s*ninja: build stopped:.*`)

 	// noWorkString in the Ninja output indicates a null build (i.e. all the
 	// requested targets have already been built).
 	noWorkString = "\nninja: no work to do."

 	// Allow dirty no-op builds, but only if they appear to be failing on these
 	// paths on Mac where the filesystem has a bug. See https://fxbug.dev/61784.
 	brokenMacPaths = []string{
 		"/usr/bin/env",
 		"/bin/ln",
 		"/bin/bash",
 	}

 	// The following tests should never be considered affected. These tests use
 	// a system image as data, so they appear affected by a broad range of
 	// changes, but they're almost never actually sensitive to said changes.
 	// https://fxbug.dev/67305 tracks generating this list automatically.
 	neverAffectedTestLabels = []string{
 		"//src/connectivity/overnet/tests/serial:overnet_serial_tests",
 		"//src/recovery/simulator:recovery_simulator_boot_test",
 		"//src/recovery/simulator:recovery_simulator_serial_test",
 	}
 )

 const (
 	// unrecognizedFailureMsg is the message we'll output if ninja fails but its
 	// output doesn't match any of the known failure modes.
 	unrecognizedFailureMsg = "Unrecognized failures, please check the original stdout instead."
 )

 // ninjaRunner provides logic for running ninja commands using common flags
 // (e.g. build directory name).
 type ninjaRunner struct {
 	runner    subprocessRunner
 	ninjaPath string
 	buildDir  string
 	jobCount  int
 }

 // run runs a ninja command as a subprocess, passing `args` in addition to the
 // common args configured on the ninjaRunner.
 func (r ninjaRunner) run(ctx context.Context, args []string, stdout, stderr io.Writer) error {
 	cmd := []string{r.ninjaPath, "-C", r.buildDir}
 	if r.jobCount > 0 {
 		cmd = append(cmd, "-j", fmt.Sprintf("%d", r.jobCount))
 	}
 	cmd = append(cmd, args...)
 	return r.runner.Run(ctx, cmd, stdout, stderr)
 }

 // ninjaParser is a container for tracking the stdio of a ninja subprocess and
 // aggregating the logs from any failed targets.
 type ninjaParser struct {
 	// ninjaStdio emits the combined stdout and stderr of a Ninja command.
 	ninjaStdio io.Reader

 	// Lines of output produced by failed Ninja steps, with all successful steps
 	// filtered out to make the logs easy to read.
 	failureOutputLines []string

 	// Whether we're currently processing a failed step's logs (haven't yet hit
 	// a line indicating the end of the error).
 	processingFailure bool

 	// The previous line that we checked.
 	previousLine string
 }

 func (p *ninjaParser) parse(ctx context.Context) error {
 	scanner := bufio.NewScanner(p.ninjaStdio)
 	for scanner.Scan() {
 		if ctx.Err() != nil {
 			return ctx.Err()
 		}
 		line := scanner.Text()
 		p.parseLine(line)
 	}
 	return scanner.Err()
 }

 func (p *ninjaParser) parseLine(line string) {
 	// Trailing whitespace isn't significant, as it doesn't affect the way the
 	// line shows up in the logs. However, leading whitespace may be
 	// significant, especially for compiler error messages.
 	line = strings.TrimRightFunc(line, unicode.IsSpace)

 	if p.processingFailure {
 		if ruleRegex.MatchString(line) || failureEndRegex.MatchString(line) {
 			// Found the end of the info for this failure (either a new rule
 			// started or we hit the end of the Ninja logs).
 			p.processingFailure = false
 		} else {
 			// Found another line of the error message.
 			p.failureOutputLines = append(p.failureOutputLines, line)
 		}
 	} else if failureStartRegex.MatchString(line) {
 		// We found a line that indicates the start of a build failure error
 		// message. Start recording information about this failure.
 		p.processingFailure = true
 		p.failureOutputLines = append(p.failureOutputLines, p.previousLine, line)
 	} else if errorRegex.MatchString(line) {
 		// An "error" log comes at the end of the output and should only be one
 		// line.
 		p.failureOutputLines = append(p.failureOutputLines, line)
 	}
 	p.previousLine = line
 }

 func (p *ninjaParser) failureMessage() string {
 	if len(p.failureOutputLines) == 0 {
 		return unrecognizedFailureMsg
 	}
 	// Add a blank line at the end to ensure a trailing newline.
 	lines := append(p.failureOutputLines, "")
 	return strings.Join(lines, "\n")
 }

 func runNinja(
 	ctx context.Context,
 	r ninjaRunner,
 	targets []string,
 	explain bool,
 ) (string, error) {
 	stdioReader, stdioWriter := io.Pipe()
 	defer stdioReader.Close()
 	parser := &ninjaParser{ninjaStdio: stdioReader}

 	parserErrs := make(chan error)
 	go func() {
 		parserErrs <- parser.parse(ctx)
 	}()

 	var ninjaErr error
 	func() {
 		// Close the pipe as soon as the subprocess completes so that the pipe
 		// reader will return an EOF.
 		defer stdioWriter.Close()
 		if explain {
 			targets = append(targets, "-d", "explain")
 		}
 		ninjaErr = r.run(
 			ctx,
 			targets,
 			// Ninja writes "ninja: ..." logs to stderr, but step logs like
 			// "[1/12345] ..." to stdout. The parser should consider both of
 			// these kinds of logs. In theory stdout and stderr should be
 			// handled by separate parsers, but it's simpler to dump them to the
 			// same stream and have the parser read from that stream. The writer
 			// returned by io.Pipe() is thread-safe, so there's no need to worry
 			// about interleaving characters of stdout and stderr.
 			io.MultiWriter(os.Stdout, stdioWriter),
 			io.MultiWriter(os.Stderr, stdioWriter),
 		)
 	}()
 	// Wait for parsing to complete.
 	if parserErr := <-parserErrs; parserErr != nil {
 		return "", parserErr
 	}

 	if ninjaErr != nil {
 		return parser.failureMessage(), ninjaErr
 	}

 	// No failure message necessary if Ninja succeeded.
 	return "", nil
 }

 // ninjaDryRun does a `ninja explain` dry run against a build directory and
 // returns the stdout and stderr.
 func ninjaDryRun(ctx context.Context, r ninjaRunner, targets []string) (string, string, error) {
 	// -n means dry-run.
 	args := []string{"-d", "explain", "--verbose", "-n"}
 	args = append(args, targets...)

 	var stdout, stderr strings.Builder
 	err := r.run(ctx, args, &stdout, &stderr)
 	return stdout.String(), stderr.String(), err
 }

 // checkNinjaNoop runs `ninja explain` against a build directory to determine
 // whether an incremental build would be a no-op (i.e. all requested targets
 // have already been built). It returns true if the build would be a no-op,
 // false otherwise.
 //
 // It also returns a map of logs produced by the no-op check, which can be
 // presented to the user for help with debugging in case the check fails.
 func checkNinjaNoop(
 	ctx context.Context,
 	r ninjaRunner,
 	targets []string,
 	isMac bool,
 ) (bool, map[string]string, error) {
 	stdout, stderr, err := ninjaDryRun(ctx, r, targets)
 	if err != nil {
 		return false, nil, err
 	}

 	// Different versions of Ninja choose to emit "explain" logs to stderr
 	// instead of stdout, so we want to analyze both streams.
 	// Concatenate the two streams for simplicity so that we don't need to do
 	// the same operation separately on each stream.
 	allStdio := strings.Join([]string{stdout, stderr}, "\n\n")
 	if !strings.Contains(allStdio, noWorkString) {
 		if isMac {
 			// TODO(https://fxbug.dev/61784): Dirty builds should be an error even on Mac.
 			for _, path := range brokenMacPaths {
 				if strings.Contains(allStdio, path) {
 					return true, nil, nil
 				}
 			}
 		}
 		logs := map[string]string{
 			"`ninja -d explain -v -n` stdout": stdout,
 			"`ninja -d explain -v -n` stderr": stderr,
 		}
 		return false, logs, nil
 	}

 	return true, nil, nil
 }

 // touchFiles updates the modified time on all the specified files to the
 // current timestamp, skipping any nonexistent files.
 func touchFiles(paths []string) error {
 	now := time.Now()
 	for _, path := range paths {
 		err := os.Chtimes(path, now, now)
 		// Skip any paths that don't exist.
 		// TODO(olivernewman): Should we somehow include deleted files in the
 		// build graph analysis for determining affected tests?
 		if err != nil && !os.IsNotExist(err) {
 			return err
 		}
 	}
 	return nil
 }

 func affectedTestsNoWork(
 	ctx context.Context,
 	runner ninjaRunner,
 	allTests []build.Test,
 	affectedFiles []string,
 	targets []string,
 ) ([]string, bool, error) {
 	testsByStamp := map[string][]string{}
 	testsByPath := map[string]string{}

 	for _, test := range allTests {
 		// Ignore any tests that shouldn't be considered affected.
 		labelNoToolchain := strings.Split(test.Label, "(")[0]
 		if contains(neverAffectedTestLabels, labelNoToolchain) {
 			continue
 		}

 		path := test.Path
 		// For host tests we use the executable path.
 		if path != "" {
 			testsByPath[path] = test.Name
 			continue
 		}
 		// For Fuchsia tests we derive the stamp path from the GN label.
 		stamp, err := stampFileForTest(test.Label)
 		if err != nil {
 			return nil, false, err
 		}
 		testsByStamp[stamp] = append(testsByStamp[stamp], test.Name)
 	}

 	var nonGNFiles []string
 	for _, path := range affectedFiles {
 		ext := filepath.Ext(path)
 		if ext != ".gn" && ext != ".gni" {
 			nonGNFiles = append(nonGNFiles, path)
 		}
 	}

 	// Our Ninja graph is set up in such a way that touching any GN files
 	// triggers an action to regenerate the entire graph. So if GN files were
 	// modified and we touched them then the following dry run results are not
 	// useful for determining affected tests.
 	if err := touchFiles(nonGNFiles); err != nil {
 		return nil, false, err
 	}
 	stdout, stderr, err := ninjaDryRun(ctx, runner, targets)
 	if err != nil {
 		return nil, false, err
 	}
 	ninjaOutput := strings.Join([]string{stdout, stderr}, "\n\n")

 	var affectedTests []string
 	for _, line := range strings.Split(ninjaOutput, "\n") {
 		// Trim the bracketed progress number from the beginning of the line.
 		split := strings.Split(line, "] ")
 		if len(split) < 2 {
 			continue
 		}
 		action := split[1]
 		if strings.HasPrefix(action, "touch ") && strings.Contains(action, "obj/") {
 			// Matches actions like "touch baz/obj/foo/bar.stamp".
 			stampFile := action[strings.Index(action, "obj/"):]
 			affectedTests = append(affectedTests, testsByStamp[stampFile]...)
 		} else {
 			// Look for actions that reference host test path. Different types
 			// of host tests have different actions, but they all mention the
 			// final executable path.
 			for _, maybeTestPath := range strings.Split(action, " ") {
 				maybeTestPath = strings.Trim(maybeTestPath, `"`)
 				testName, ok := testsByPath[maybeTestPath]
 				if !ok {
 					continue
 				}
 				affectedTests = append(affectedTests, testName)
 			}
 		}
 	}

 	// For determination of "no work to do", we want to consider all files,
 	// *including* GN files. If no GN files are affected, then we already have
 	// the necessary output from the first ninja dry run, so we can skip doing
 	// the second dry run that includes GN files.
 	if len(nonGNFiles) < len(affectedFiles) {
 		if err := touchFiles(affectedFiles); err != nil {
 			return nil, false, err
 		}
 		stdout, stderr, err := ninjaDryRun(ctx, runner, targets)
 		if err != nil {
 			return nil, false, err
 		}
 		ninjaOutput = strings.Join([]string{stdout, stderr}, "\n\n")
 	}
 	noWork := strings.Contains(ninjaOutput, noWorkString)

 	return removeDuplicates(affectedTests), noWork, nil
 }

 func stampFileForTest(label string) (string, error) {
 	// Remove the "//" prefix and parenthesized toolchain suffix from the label.
 	trimmedLabel := strings.TrimPrefix(strings.Split(label, "(")[0], "//")

 	var directory, targetName string
 	if strings.Contains(trimmedLabel, ":") {
 		// Label looks like "//foo/bar:baz"
 		parts := strings.Split(trimmedLabel, ":")
 		directory = parts[0]
 		targetName = parts[1]
 	} else {
 		// Label looks like "//foo/bar"
 		directory = trimmedLabel
 		targetName = path.Base(trimmedLabel)
 	}

 	if directory == "" || targetName == "" {
 		return "", fmt.Errorf("failed to parse test label %q", label)
 	}

 	var stampPath string
 	if targetName == path.Base(directory) {
 		stampPath = directory
 	} else {
 		stampPath = path.Join(directory, targetName)
 	}

 	// GN labels always use forward slashes, so make sure to convert to
 	// platform-specific file path format when returning the stamp file path.
 	return filepath.Join("obj", filepath.FromSlash(stampPath)+".stamp"), nil
 }

 // ninjaGraph runs the ninja graph tool and pipes its stdout to a temporary
 // file, returning the path to the resulting file.
 func ninjaGraph(ctx context.Context, r ninjaRunner, targets []string) (string, error) {
 	graphFile, err := ioutil.TempFile("", "*-graph.dot")
 	if err != nil {
 		return "", err
 	}
 	defer graphFile.Close()
 	args := append([]string{"-t", "graph"}, targets...)
 	if err := r.run(ctx, args, graphFile, os.Stderr); err != nil {
 		return "", err
 	}
 	return graphFile.Name(), nil
 }

 // ninjaCompdb runs the ninja compdb tool and pipes its stdout to a temporary
 // file, returning the path to the resulting file.
 func ninjaCompdb(ctx context.Context, r ninjaRunner) (string, error) {
 	compdbFile, err := ioutil.TempFile("", "*-compile-commands.json")
 	if err != nil {
 		return "", err
 	}
 	defer compdbFile.Close()
 	// Don't specify targets, as we want all build edges to be generated.
 	args := []string{"-t", "compdb"}
 	if err := r.run(ctx, args, compdbFile, os.Stderr); err != nil {
 		return "", err
 	}
 	return compdbFile.Name(), nil
 }

 func ninjaCleanDead(ctx context.Context, r ninjaRunner) error {
 	return r.run(ctx, []string{"-t", "cleandead"}, os.Stdout, os.Stderr)
 }
	// 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 (
	"bufio"
	"context"
	"fmt"
	"io"
	"io/ioutil"
	"os"
	"path"
	"path/filepath"
	"regexp"
	"strings"
	"time"
	"unicode"

	"go.fuchsia.dev/fuchsia/tools/build"
	)

	var (
	// ruleRegex matches a regular line of Ninja stdout in the default format,
	// e.g. "[56/1234] CXX host_x64/foo.o"
	ruleRegex = regexp.MustCompile(`^\s*\[\d+/\d+\] \S+`)

	// errorRegex matches a single-line error message that Ninja prints at the
	// end of its output if it encounters an error that prevents it from even
	// starting the build (e.g. multiple rules generating the same target file),
	// or a fatal error in the middle of the build (e.g. OS error). These error
	// strings are defined here:
	// https://github.com/ninja-build/ninja/blob/master/src/util.cc
	errorRegex = regexp.MustCompile(`^\s*ninja: (error\|fatal): .+`)

	// failureStartRegex matches the first line of a failure message, e.g.
	// "FAILED: foo.o"
	failureStartRegex = regexp.MustCompile(`^\sFAILED: .`)

	// failureEndRegex indicates the end of Ninja's execution as a result of a
	// build failure. When present, it will be the last line of stdout.
	failureEndRegex = regexp.MustCompile(`^\sninja: build stopped:.`)

	// noWorkString in the Ninja output indicates a null build (i.e. all the
	// requested targets have already been built).
	noWorkString = "\nninja: no work to do."

	// Allow dirty no-op builds, but only if they appear to be failing on these
	// paths on Mac where the filesystem has a bug. See https://fxbug.dev/61784.
	brokenMacPaths = []string{
	"/usr/bin/env",
	"/bin/ln",
	"/bin/bash",
	}

	// The following tests should never be considered affected. These tests use
	// a system image as data, so they appear affected by a broad range of
	// changes, but they're almost never actually sensitive to said changes.
	// https://fxbug.dev/67305 tracks generating this list automatically.
	neverAffectedTestLabels = []string{
	"//src/connectivity/overnet/tests/serial:overnet_serial_tests",
	"//src/recovery/simulator:recovery_simulator_boot_test",
	"//src/recovery/simulator:recovery_simulator_serial_test",
	}
	)

	const (
	// unrecognizedFailureMsg is the message we'll output if ninja fails but its
	// output doesn't match any of the known failure modes.
	unrecognizedFailureMsg = "Unrecognized failures, please check the original stdout instead."
	)

	// ninjaRunner provides logic for running ninja commands using common flags
	// (e.g. build directory name).
	type ninjaRunner struct {
	runner subprocessRunner
	ninjaPath string
	buildDir string
	jobCount int
	}

	// run runs a ninja command as a subprocess, passing `args` in addition to the
	// common args configured on the ninjaRunner.
	func (r ninjaRunner) run(ctx context.Context, args []string, stdout, stderr io.Writer) error {
	cmd := []string{r.ninjaPath, "-C", r.buildDir}
	if r.jobCount > 0 {
	cmd = append(cmd, "-j", fmt.Sprintf("%d", r.jobCount))
	}
	cmd = append(cmd, args...)
	return r.runner.Run(ctx, cmd, stdout, stderr)
	}

	// ninjaParser is a container for tracking the stdio of a ninja subprocess and
	// aggregating the logs from any failed targets.
	type ninjaParser struct {
	// ninjaStdio emits the combined stdout and stderr of a Ninja command.
	ninjaStdio io.Reader

	// Lines of output produced by failed Ninja steps, with all successful steps
	// filtered out to make the logs easy to read.
	failureOutputLines []string

	// Whether we're currently processing a failed step's logs (haven't yet hit
	// a line indicating the end of the error).
	processingFailure bool

	// The previous line that we checked.
	previousLine string
	}

	func (p *ninjaParser) parse(ctx context.Context) error {
	scanner := bufio.NewScanner(p.ninjaStdio)
	for scanner.Scan() {
	if ctx.Err() != nil {
	return ctx.Err()
	}
	line := scanner.Text()
	p.parseLine(line)
	}
	return scanner.Err()
	}

	func (p *ninjaParser) parseLine(line string) {
	// Trailing whitespace isn't significant, as it doesn't affect the way the
	// line shows up in the logs. However, leading whitespace may be
	// significant, especially for compiler error messages.
	line = strings.TrimRightFunc(line, unicode.IsSpace)

	if p.processingFailure {
	if ruleRegex.MatchString(line) \|\| failureEndRegex.MatchString(line) {
	// Found the end of the info for this failure (either a new rule
	// started or we hit the end of the Ninja logs).
	p.processingFailure = false
	} else {
	// Found another line of the error message.
	p.failureOutputLines = append(p.failureOutputLines, line)
	}
	} else if failureStartRegex.MatchString(line) {
	// We found a line that indicates the start of a build failure error
	// message. Start recording information about this failure.
	p.processingFailure = true
	p.failureOutputLines = append(p.failureOutputLines, p.previousLine, line)
	} else if errorRegex.MatchString(line) {
	// An "error" log comes at the end of the output and should only be one
	// line.
	p.failureOutputLines = append(p.failureOutputLines, line)
	}
	p.previousLine = line
	}

	func (p *ninjaParser) failureMessage() string {
	if len(p.failureOutputLines) == 0 {
	return unrecognizedFailureMsg
	}
	// Add a blank line at the end to ensure a trailing newline.
	lines := append(p.failureOutputLines, "")
	return strings.Join(lines, "\n")
	}

	func runNinja(
	ctx context.Context,
	r ninjaRunner,
	targets []string,
	explain bool,
	) (string, error) {
	stdioReader, stdioWriter := io.Pipe()
	defer stdioReader.Close()
	parser := &ninjaParser{ninjaStdio: stdioReader}

	parserErrs := make(chan error)
	go func() {
	parserErrs <- parser.parse(ctx)
	}()

	var ninjaErr error
	func() {
	// Close the pipe as soon as the subprocess completes so that the pipe
	// reader will return an EOF.
	defer stdioWriter.Close()
	if explain {
	targets = append(targets, "-d", "explain")
	}
	ninjaErr = r.run(
	ctx,
	targets,
	// Ninja writes "ninja: ..." logs to stderr, but step logs like
	// "[1/12345] ..." to stdout. The parser should consider both of
	// these kinds of logs. In theory stdout and stderr should be
	// handled by separate parsers, but it's simpler to dump them to the
	// same stream and have the parser read from that stream. The writer
	// returned by io.Pipe() is thread-safe, so there's no need to worry
	// about interleaving characters of stdout and stderr.
	io.MultiWriter(os.Stdout, stdioWriter),
	io.MultiWriter(os.Stderr, stdioWriter),
	)
	}()
	// Wait for parsing to complete.
	if parserErr := <-parserErrs; parserErr != nil {
	return "", parserErr
	}

	if ninjaErr != nil {
	return parser.failureMessage(), ninjaErr
	}

	// No failure message necessary if Ninja succeeded.
	return "", nil
	}

	// ninjaDryRun does a `ninja explain` dry run against a build directory and
	// returns the stdout and stderr.
	func ninjaDryRun(ctx context.Context, r ninjaRunner, targets []string) (string, string, error) {
	// -n means dry-run.
	args := []string{"-d", "explain", "--verbose", "-n"}
	args = append(args, targets...)

	var stdout, stderr strings.Builder
	err := r.run(ctx, args, &stdout, &stderr)
	return stdout.String(), stderr.String(), err
	}

	// checkNinjaNoop runs `ninja explain` against a build directory to determine
	// whether an incremental build would be a no-op (i.e. all requested targets
	// have already been built). It returns true if the build would be a no-op,
	// false otherwise.
	//
	// It also returns a map of logs produced by the no-op check, which can be
	// presented to the user for help with debugging in case the check fails.
	func checkNinjaNoop(
	ctx context.Context,
	r ninjaRunner,
	targets []string,
	isMac bool,
	) (bool, map[string]string, error) {
	stdout, stderr, err := ninjaDryRun(ctx, r, targets)
	if err != nil {
	return false, nil, err
	}

	// Different versions of Ninja choose to emit "explain" logs to stderr
	// instead of stdout, so we want to analyze both streams.
	// Concatenate the two streams for simplicity so that we don't need to do
	// the same operation separately on each stream.
	allStdio := strings.Join([]string{stdout, stderr}, "\n\n")
	if !strings.Contains(allStdio, noWorkString) {
	if isMac {
	// TODO(https://fxbug.dev/61784): Dirty builds should be an error even on Mac.
	for _, path := range brokenMacPaths {
	if strings.Contains(allStdio, path) {
	return true, nil, nil
	}
	}
	}
	logs := map[string]string{
	"`ninja -d explain -v -n` stdout": stdout,
	"`ninja -d explain -v -n` stderr": stderr,
	}
	return false, logs, nil
	}

	return true, nil, nil
	}

	// touchFiles updates the modified time on all the specified files to the
	// current timestamp, skipping any nonexistent files.
	func touchFiles(paths []string) error {
	now := time.Now()
	for _, path := range paths {
	err := os.Chtimes(path, now, now)
	// Skip any paths that don't exist.
	// TODO(olivernewman): Should we somehow include deleted files in the
	// build graph analysis for determining affected tests?
	if err != nil && !os.IsNotExist(err) {
	return err
	}
	}
	return nil
	}

	func affectedTestsNoWork(
	ctx context.Context,
	runner ninjaRunner,
	allTests []build.Test,
	affectedFiles []string,
	targets []string,
	) ([]string, bool, error) {
	testsByStamp := map[string][]string{}
	testsByPath := map[string]string{}

	for _, test := range allTests {
	// Ignore any tests that shouldn't be considered affected.
	labelNoToolchain := strings.Split(test.Label, "(")[0]
	if contains(neverAffectedTestLabels, labelNoToolchain) {
	continue
	}

	path := test.Path
	// For host tests we use the executable path.
	if path != "" {
	testsByPath[path] = test.Name
	continue
	}
	// For Fuchsia tests we derive the stamp path from the GN label.
	stamp, err := stampFileForTest(test.Label)
	if err != nil {
	return nil, false, err
	}
	testsByStamp[stamp] = append(testsByStamp[stamp], test.Name)
	}

	var nonGNFiles []string
	for _, path := range affectedFiles {
	ext := filepath.Ext(path)
	if ext != ".gn" && ext != ".gni" {
	nonGNFiles = append(nonGNFiles, path)
	}
	}

	// Our Ninja graph is set up in such a way that touching any GN files
	// triggers an action to regenerate the entire graph. So if GN files were
	// modified and we touched them then the following dry run results are not
	// useful for determining affected tests.
	if err := touchFiles(nonGNFiles); err != nil {
	return nil, false, err
	}
	stdout, stderr, err := ninjaDryRun(ctx, runner, targets)
	if err != nil {
	return nil, false, err
	}
	ninjaOutput := strings.Join([]string{stdout, stderr}, "\n\n")

	var affectedTests []string
	for _, line := range strings.Split(ninjaOutput, "\n") {
	// Trim the bracketed progress number from the beginning of the line.
	split := strings.Split(line, "] ")
	if len(split) < 2 {
	continue
	}
	action := split[1]
	if strings.HasPrefix(action, "touch ") && strings.Contains(action, "obj/") {
	// Matches actions like "touch baz/obj/foo/bar.stamp".
	stampFile := action[strings.Index(action, "obj/"):]
	affectedTests = append(affectedTests, testsByStamp[stampFile]...)
	} else {
	// Look for actions that reference host test path. Different types
	// of host tests have different actions, but they all mention the
	// final executable path.
	for _, maybeTestPath := range strings.Split(action, " ") {
	maybeTestPath = strings.Trim(maybeTestPath, `"`)
	testName, ok := testsByPath[maybeTestPath]
	if !ok {
	continue
	}
	affectedTests = append(affectedTests, testName)
	}
	}
	}

	// For determination of "no work to do", we want to consider all files,
	// including GN files. If no GN files are affected, then we already have
	// the necessary output from the first ninja dry run, so we can skip doing
	// the second dry run that includes GN files.
	if len(nonGNFiles) < len(affectedFiles) {
	if err := touchFiles(affectedFiles); err != nil {
	return nil, false, err
	}
	stdout, stderr, err := ninjaDryRun(ctx, runner, targets)
	if err != nil {
	return nil, false, err
	}
	ninjaOutput = strings.Join([]string{stdout, stderr}, "\n\n")
	}
	noWork := strings.Contains(ninjaOutput, noWorkString)

	return removeDuplicates(affectedTests), noWork, nil
	}

	func stampFileForTest(label string) (string, error) {
	// Remove the "//" prefix and parenthesized toolchain suffix from the label.
	trimmedLabel := strings.TrimPrefix(strings.Split(label, "(")[0], "//")

	var directory, targetName string
	if strings.Contains(trimmedLabel, ":") {
	// Label looks like "//foo/bar:baz"
	parts := strings.Split(trimmedLabel, ":")
	directory = parts[0]
	targetName = parts[1]
	} else {
	// Label looks like "//foo/bar"
	directory = trimmedLabel
	targetName = path.Base(trimmedLabel)
	}

	if directory == "" \|\| targetName == "" {
	return "", fmt.Errorf("failed to parse test label %q", label)
	}

	var stampPath string
	if targetName == path.Base(directory) {
	stampPath = directory
	} else {
	stampPath = path.Join(directory, targetName)
	}

	// GN labels always use forward slashes, so make sure to convert to
	// platform-specific file path format when returning the stamp file path.
	return filepath.Join("obj", filepath.FromSlash(stampPath)+".stamp"), nil
	}

	// ninjaGraph runs the ninja graph tool and pipes its stdout to a temporary
	// file, returning the path to the resulting file.
	func ninjaGraph(ctx context.Context, r ninjaRunner, targets []string) (string, error) {
	graphFile, err := ioutil.TempFile("", "*-graph.dot")
	if err != nil {
	return "", err
	}
	defer graphFile.Close()
	args := append([]string{"-t", "graph"}, targets...)
	if err := r.run(ctx, args, graphFile, os.Stderr); err != nil {
	return "", err
	}
	return graphFile.Name(), nil
	}

	// ninjaCompdb runs the ninja compdb tool and pipes its stdout to a temporary
	// file, returning the path to the resulting file.
	func ninjaCompdb(ctx context.Context, r ninjaRunner) (string, error) {
	compdbFile, err := ioutil.TempFile("", "*-compile-commands.json")
	if err != nil {
	return "", err
	}
	defer compdbFile.Close()
	// Don't specify targets, as we want all build edges to be generated.
	args := []string{"-t", "compdb"}
	if err := r.run(ctx, args, compdbFile, os.Stderr); err != nil {
	return "", err
	}
	return compdbFile.Name(), nil
	}

	func ninjaCleanDead(ctx context.Context, r ninjaRunner) error {
	return r.run(ctx, []string{"-t", "cleandead"}, os.Stdout, os.Stderr)
	}