Files.createDirectory(path);
    }

    @Benchmark
    public void java6walk(Blackhole blackhole) {
        File file = missing ? missingFile : existingFile;
        while (!file.equals(tempDirFile)) {
            file = file.getParentFile();
            blackhole.consume(file.exists());
        }
        blackhole.consume(file);
    }

    @Benchmark
    public void java7walk(Blackhole blackhole) {

package com.google.common.base;

import com.google.caliper.Benchmark;
import java.util.concurrent.TimeUnit;

/**
 * Simple benchmark: create, start, read. This does not currently report the most useful result
 * because it's ambiguous to what extent the stopwatch benchmark is being affected by GC.
 *
 * @author Kevin Bourrillion
 */
public class StopwatchBenchmark {
  @Benchmark
  long stopwatch(int reps) {
    long total = 0;

    }
    return r;
  }

  @Benchmark
  public long timeGetWith0Timeout(long reps) throws Exception {
    Facade<?> f = notDoneFuture;
    long r = 0;
    for (int i = 0; i < reps; i++) {
      try {
        f.get(0, TimeUnit.SECONDS);
        r += 1;
      } catch (TimeoutException e) {
        r += 2;
      }
    }
    return r;
  }

  @Benchmark

package com.google.common.io;

import com.google.caliper.BeforeExperiment;
import com.google.caliper.Benchmark;
import com.google.caliper.Param;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.Random;

/** Benchmark for {@code BaseEncoding} performance. */
public class BaseEncodingBenchmark {

			b.Fatalf("benchmark failed due to parse error: %s", err)
		}
	}
}

func BenchmarkParseOnly(b *testing.B) {
	b.SetBytes(int64(len(src)))
	for i := 0; i < b.N; i++ {
		if _, err := ParseFile(token.NewFileSet(), "", src, ParseComments|SkipObjectResolution); err != nil {
			b.Fatalf("benchmark failed due to parse error: %s", err)
		}
	}
}

	wantNot := []string{
		// The calling edge main->A is hot and the cost of A is large
		// than inlineHotCalleeMaxBudget.
		"A",
		// The calling edge BenchmarkA" -> benchmarkB is cold and the
		// cost of A is large than inlineMaxBudget.
		"benchmarkB",
	}

	must := map[string]bool{
		"(*BS).NS": true,
	}

	notInlinedReason := make(map[string]string)
	for _, fname := range want {

{"Action":"start"}
{"Action":"output","Output":"# This file ends in an early EOF to trigger the Benchmark prefix test,\n"}
{"Action":"output","Output":"# which only happens when a benchmark prefix is seen ahead of the \\n.\n"}
{"Action":"output","Output":"# Normally that's due to the benchmark running and the \\n coming later,\n"}
{"Action":"output","Output":"# but to avoid questions of timing, we just use a file with no \\n at all.\n"}

    unsafeImpl = UnsignedBytes.LexicographicalComparatorHolder.UnsafeComparator.INSTANCE;
  }

  @Benchmark
  void longEqualJava(int reps) {
    for (int i = 0; i < reps; ++i) {
      if (javaImpl.compare(ba1, ba2) != 0) {
        throw new Error(); // deoptimization
      }
    }
  }

  @Benchmark
  void longEqualUnsafe(int reps) {
    for (int i = 0; i < reps; ++i) {
      if (unsafeImpl.compare(ba1, ba2) != 0) {

# bazel test invocation as normal.
test:nonpip_filters --test_tag_filters=-no_oss,-oss_serial,-gpu,-tpu,-benchmark-test,-v1only,-no_aarch64,-no_oss_py38,-no_oss_py39,-no_oss_py310
test:nonpip_filters --build_tag_filters=-no_oss,-oss_serial,-gpu,-tpu,-benchmark-test,-v1only,-no_aarch64,-no_oss_py38,-no_oss_py39,-no_oss_py310
test:nonpip_filters --test_lang_filters=py --flaky_test_attempts=3 --test_size_filters=small,medium

    tags = [
        "manual",
    ],
)

# Utility library for benchmark binaries, used by the *_benchmark rules that are
# added by the tfcompile bazel macro.
cc_library(
    name = "benchmark",
    srcs = ["benchmark.cc"],
    hdrs = ["benchmark.h"],
    visibility = ["//visibility:public"],
    deps = [
        # The purpose of the benchmark library is to support building an aot