*/
  fun cancel()

  /**
   * Carries an exchange. This is usually a connection, but it could also be a connect plan for
   * CONNECT tunnels. Note that CONNECT tunnels are significantly less capable than connections.
   */
  interface Carrier {
    val route: Route

    fun trackFailure(
      call: RealCall,
      e: IOException?,
    )

    fun noNewExchanges()

   *
   * <p>Ideally, this number should be close to the {@code fpp} parameter passed in {@linkplain
   * #create(Funnel, int, double)}, or smaller. If it is significantly higher, it is usually the
   * case that too many elements (more than expected) have been put in the {@code BloomFilter},
   * degenerating it.
   *
   * @since 14.0 (since 11.0 as expectedFalsePositiveProbability())

## Compiler {#compiler}

The build time overhead to building with [Profile Guided Optimization](/doc/pgo) has been reduced significantly.
Previously, large builds could see 100%+ build time increase from enabling PGO.
In Go 1.23, overhead should be in the single digit percentages.

<!-- https://go.dev/issue/62737 , https://golang.org/cl/576681,  https://golang.org/cl/577615 -->
The compiler in Go 1.23 can now overlap the stack frame slots of local variables

	var out []int64
	for i := 0; i < 10; i++ {
		out = append(out, Int64())
	}

	// Look for out in seeded output.
	// Strictly speaking, we should look for them in order,
	// but this is good enough and not significantly more
	// likely to have a false positive.
	r := New(NewPCG(1, 0))
	found := 0
	for i := 0; i < 1000; i++ {
		x := r.Int64()
		if x == out[found] {
			found++
			if found == len(out) {

Improving the network link between the build and the remote cache can significantly improve build cache performance.
How to do this depends on the remote cache in use and your network environment.

The multi-node remote build cache provided by Develocity is a fast and efficient, purpose built, remote build cache.

   *
   * <p>Ideally, this number should be close to the {@code fpp} parameter passed in {@linkplain
   * #create(Funnel, int, double)}, or smaller. If it is significantly higher, it is usually the
   * case that too many elements (more than expected) have been put in the {@code BloomFilter},
   * degenerating it.
   *
   * @since 14.0 (since 11.0 as expectedFalsePositiveProbability())

This translates into faster feedback for developers, and less money spent on the CI resources.

                    .severity(Severity.ERROR)
                    .details("If you don't declare the normalization, outputs can't be re-used between machines or locations on the same machine, therefore caching efficiency drops significantly")
                    .solution("Declare the normalization strategy by annotating the property with either @PathSensitive, @Classpath or @CompileClasspath");
            });
        }
    }

                + System.getProperty("line.separator") + "  "
                + setEnvironmentResult
                + System.getProperty("line.separator") + "  "
                + "If the daemon was started with a significantly different environment from the client, and your build "
                + System.getProperty("line.separator") + "  "
                + "relies on environment variables, you may experience unexpected behavior.");
        }

	"testing"

	"internal/trace"
	"internal/trace/raw"
	"internal/trace/testtrace"
	"internal/trace/version"
)

var (
	logEvents  = flag.Bool("log-events", false, "whether to log high-level events; significantly slows down tests")
	dumpTraces = flag.Bool("dump-traces", false, "dump traces even on success")
)

func TestReaderGolden(t *testing.T) {
	matches, err := filepath.Glob("./testdata/tests/*.test")
	if err != nil {