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;

 * limitations under the License.
 */

package com.google.common.collect;

import com.google.caliper.Benchmark;

/**
 * Benchmarking interners.
 *
 * @author Dimitris Andreou
 */
public class InternersBenchmark {
  @Benchmark
  int weakInterner(int reps) {
    Interner<String> interner = Interners.newWeakInterner();
    for (int i = 0; i < reps; i++) {

  }

  @Benchmark
  int hashString_4(int reps) {
    int dummy = 0;
    for (int i = 0; i < reps; i++) {
      dummy += Objects.hashCode(S0, S1, S2, S3);
    }
    return dummy;
  }

  @Benchmark
  int hashString_5(int reps) {
    int dummy = 0;
    for (int i = 0; i < reps; i++) {
      dummy += Objects.hashCode(S0, S1, S2, S3, S4);
    }
    return dummy;
  }

  @Benchmark

      factorials[i] = RANDOM_SOURCE.nextInt(100);
    }
  }

  @Benchmark
  long log2(int reps) {
    long tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & ARRAY_MASK;
      tmp += Double.doubleToRawLongBits(DoubleMath.log2(positiveDoubles[j]));
    }
    return tmp;
  }

  @Benchmark
  long factorial(int reps) {
    long tmp = 0;
    for (int i = 0; i < reps; i++) {

    // TODO(kevinb): convert to assert once benchmark tests enable asserts by default
    Preconditions.checkState(hashMultiset.size() == size);
  }

  @Benchmark
  int hashMultiset(int reps) {
    int sum = 0;
    for (int i = 0; i < reps; i++) {
      for (Object value : hashMultiset) {
        sum += value.hashCode();
      }
    }
    return sum;
  }

  @Benchmark
  int linkedHashMultiset(int reps) {

			benchmark: true,
		},
		{
			name:      "3MB of empty slices",
			data:      []byte(`[` + strings.Repeat(`[],`, 3*1024*1024/3-2) + `[]]`),
			benchmark: true,
		},
		{
			name:      "3MB of slices",
			data:      []byte(`[` + strings.Repeat(`[0],`, 3*1024*1024/4-2) + `[0]]`),
			benchmark: true,
		},
		{
			name:      "3MB of empty maps",

@Measurement(iterations = 10, time = 1, timeUnit = SECONDS)
@State(Scope.Benchmark)
public class OptionalBenchmark {

    final Path path = Paths.get(".");
    final Path pathRoot = Paths.get(".").toAbsolutePath().getRoot();

    @Benchmark
    public void nullCheck(Blackhole bh) {
        bh.consume(nullCheck(path));
        bh.consume(nullCheck(pathRoot));
    }

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

// code like:
//
//	func main() {
//	  enableBenchmarking := flag.Bool("enable", true, "enables benchmarking")
//	  flag.Parse()
//	  var bench *benchmark.Metrics
//	  if *enableBenchmarking {
//	    bench = benchmark.New(benchmark.GC)
//	  }
//	  bench.Start("foo")
//	  // etc.
//	}
func New(gc Flags, filebase string) *Metrics {
	if gc == GC {
		runtime.GC()
	}
	return &Metrics{gc: gc, filebase: filebase}
}

# CPU WHEEL
test:linux_cpu_wheel_test_filters --test_tag_filters=-no_oss,-oss_excluded,-oss_serial,-gpu,-tpu,-benchmark-test,-v1only,-no_oss_py38,-no_oss_py39,-no_oss_py310
test:linux_cpu_wheel_test_filters --build_tag_filters=-no_oss,-oss_excluded,-oss_serial,-gpu,-tpu,-benchmark-test,-v1only,-no_oss_py38,-no_oss_py39,-no_oss_py310
test:linux_cpu_wheel_test_filters --test_lang_filters=py --test_size_filters=small,medium