root {
            'common.gradle'('println "poke"')
        }

        when:
        def allCompileOperations = 0
        def iterations = 3
        def builder = root
        iterations.times { n ->
            createJarWithProperties("foo${n}.jar", [value: n])
            new File(root.baseDir, 'build.gradle').delete()
            builder {
                'build.gradle'("""

      } else if (pivotNewIndex < k) {
        left = Math.max(pivotNewIndex, left + 1);
        minThresholdPosition = pivotNewIndex;
      } else {
        break;
      }
      iterations++;
      if (iterations >= maxIterations) {
        @SuppressWarnings("nullness") // safe because we pass sort() a range that contains real Ts
        T[] castBuffer = (T[]) buffer;

		p.Reg = int16(s390x.REGSP)
		reg = s390x.REGRT1
		off = 0
	}

	// Generate a loop of large clears.
	if cnt > clearLoopCutoff {
		ireg := int16(s390x.REGRT2) // register holds number of remaining loop iterations
		p = pp.Append(p, s390x.AMOVD, obj.TYPE_CONST, 0, cnt/256, obj.TYPE_REG, ireg, 0)
		p = pp.Append(p, s390x.ACLEAR, obj.TYPE_CONST, 0, 256, obj.TYPE_MEM, reg, off)
		pl := p

# a worker process terminates without communicating the crashing input back
# to the coordinator.

[short] skip
env GOCACHE=$WORK/cache

# Start fuzzing. The worker crashes after 100 iterations.
# The fuzz function writes the crashing input to "want" before exiting.
# The fuzzing engine reconstructs the crashing input and saves it to testdata.
! exists want

	}

	l := NewGCCPULimiter(ticks, procs)

	// Do the whole test twice to make sure state doesn't leak across.
	var baseOverflow uint64 // Track total overflow across iterations.
	for i := 0; i < 2; i++ {
		t.Logf("Iteration %d", i+1)

		if l.Capacity() != procs*CapacityPerProc {
			t.Fatalf("unexpected capacity: %d", l.Capacity())
		}
		if l.Fill() != 0 {
			t.Fatalf("expected empty bucket to start")
		}

            .assertTestPassed("$testMethod param=value2")

        where:
        testMethod << ["sub unrolled test", "super unrolled test", "super super unrolled test"]
    }

    def "can not filter specific iterations of unrolled tests"() {
        when:
        fails("test", "--tests", "SubClass.$testMethod")

        then:
        failureCauseContains("No tests found for given includes: [SubClass.$testMethod](--tests filter)")

	func (b *B) StopTimer()

	// The results of a benchmark run. 
	type BenchmarkResult struct {
		N	int		// The number of iterations.
		T	time.Duration	// The total time taken.
		Bytes	int64		// Bytes processed in one iteration.
	}

	// Benchmark benchmarks a single function. Useful for creating ...
	func Benchmark(f func(b *B)) BenchmarkResult

	// 

    ScenarioType type()

    OperatingSystem[] operatingSystems()

    String[] testProjects() default []

    /**
     * Declare regular expressions matching the iteration name.
     * Defaults to an empty string, meaning this annotation applies to all iterations of the annotated feature.
     */
    String iterationMatcher() default "";

    String comment() default "";
}

enum ScenarioType {
    PER_COMMIT,

	k, err := GenerateKey(rand.Reader, 2048)
	if err != nil {
		t.Fatal(err)
	}

	// Run test with GOGC=10, to make bug more likely.
	// Without the KeepAlives, the loop usually dies after
	// about 30 iterations.
	defer debug.SetGCPercent(debug.SetGCPercent(10))
	for n := 0; n < 200; n++ {
		// Clear the underlying BoringCrypto object cache.
		privCache.Clear()

		// Race to create the underlying BoringCrypto object.

	seenSources := sets.New[string](TestSource)
	var wg sync.WaitGroup
	const iterations = 100
	wg.Add(2)

	go func() {
		ctx, cancel := context.WithCancel(tCtx)
		defer cancel()
		defer wg.Done()
		for i := 0; i < iterations; i++ {
			config.Channel(ctx, strconv.Itoa(i))
		}
	}()
	go func() {
		defer wg.Done()
		for i := 0; i < iterations; i++ {
			config.SeenAllSources(seenSources)
		}
	}()