useful for testing and debugging the tracer in the runtime and more sophisticated
trace parsers.

# Text format specification

The trace text format produced and consumed by this package is a line-oriented
format.

The first line in each text trace is the header line.

	Trace Go1.XX

Following that is a series of event lines. Each event begins with an

	//
	// If URL is empty but a Category is specified, then the
	// Analysis driver should treat the URL as "#"+Category.
	//
	// The URL may be relative. If so, the base URL is that of the
	// Analyzer that produced the diagnostic;
	// see https://pkg.go.dev/net/url#URL.ResolveReference.
	URL string

	// SuggestedFixes is an optional list of fixes to address the
	// problem described by the diagnostic, each one representing

import java.util.Arrays;
import java.util.List;

import static org.gradle.util.internal.CollectionUtils.filter;
import static org.gradle.util.internal.CollectionUtils.join;

/**
 * Collects the output entries produced by a work item such as a task or an artifact transform,
 * and allows assertions to be made about the output.
 *
 * @see GroupedOutputFixture
 */
public abstract class GroupedWorkOutputFixture {

                        + "This can lead to incorrect results being produced, depending on what order the tasks are executed",
                    consumer,
                    producer
                ))
                .solution("Declare task '" + producer + "' as an input of '" + consumer + "'")
                .solution("Declare an explicit dependency on '" + producer + "' from '" + consumer + "' using Task#dependsOn")

// guide inlining heuristics; these properties may apply to the
// function as a whole, or to one or more function return values or
// parameters.
//
// IMPORTANT: function properties are produced on a "best effort"
// basis, meaning that the code that computes them doesn't verify that
// the properties are guaranteed to be true in 100% of cases. For this
// reason, properties should only be used to drive always-safe

            .anyMatch(s -> TARGET_DEFINING_PARAMETERS.stream().anyMatch(param -> param.equals(s) || s.startsWith(param + ":")));
    }

    /**
     * Computes parameter to specify how Scala should handle Java APIs and produced bytecode version.
     * <p>
     * The exact result depends on the Scala version in use and if the toolchain is user specified or not.
     *
     * @param scalaVersion The detected scala version

            });

        // Produce some example output (simulate executing cacheable work in a temporary sandbox)
        Path sandboxOutputDirectory = Files.createTempDirectory("sandbox-output");
        Path sandboxOutputTxt = sandboxOutputDirectory.resolve("output.txt");
        Files.write(sandboxOutputTxt, Collections.singleton("contents"));

        // Capture the snapshot of the produced output

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

// This is the input program for an end-to-end test of the DWARF produced
// by the compiler. It is compiled with various flags, then the resulting
// binary is "debugged" under the control of a harness.  Because the compile+debug
// step is time-consuming, the tests for different bugs are all accumulated here

non-control) are dead as well. For `tf_executor.Merge`, the output is dead only
when either an input control token is dead or all of the regular inputs are
dead. For `tf_executor.ControlTrigger`, a live control output is always produced
even when some control inputs are dead.

### `tf_executor.graph` Operation

The `tf_executor.graph` operation contains a region with a single block that

    by a `tf_executor.yield` operation. The operands of the terminator
    correspond to the result values of the `tf_executor.island` operation. An
    extra result of type `!tf_executor.control` is always produced by every
    `tf_executor.island`.
    Within an island, execution semantics follow standard sequential behavior as
    expected by TF2 and by compiler analyses and transformations, and values