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,

            .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)")

	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.

	// one iteration.
	for _, x := range xl {
		if x != nil {
			return false
		}
	}
	return true
}

// isAll reports whether the termlist xl represents the set of all types.
func (xl termlist) isAll() bool {
	// If there's a 𝓤 term, the entire list is 𝓤.
	// If the termlist is in normal form, this requires at most
	// one iteration.
	for _, x := range xl {

	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

	// 

	}
}

func cpuHogger(f func(x int) int, y *int, dur time.Duration) {
	// We only need to get one 100 Hz clock tick, so we've got
	// a large safety buffer.
	// But do at least 500 iterations (which should take about 100ms),
	// otherwise TestCPUProfileMultithreaded can fail if only one
	// thread is scheduled during the testing period.
	t0 := time.Now()
	accum := *y

		}
	}
}

func TestBitwiseContended8(t *testing.T) {
	// Start with every bit in array set to 0.
	a := make([]uint8, 16)

	// Iterations to try.
	N := 1 << 16
	if testing.Short() {
		N = 1 << 10
	}

	// Set and then clear every bit in the array bit-by-bit in different goroutines.
	done := make(chan bool)
	for i := 0; i < 8; i++ {

	// one iteration.
	for _, x := range xl {
		if x != nil {
			return false
		}
	}
	return true
}

// isAll reports whether the termlist xl represents the set of all types.
func (xl termlist) isAll() bool {
	// If there's a 𝓤 term, the entire list is 𝓤.
	// If the termlist is in normal form, this requires at most
	// one iteration.
	for _, x := range xl {

  let summary = "Asynchronously execution of while op for tf_mlrt";
  let description = [{
    cond: The boolean to control whether the first iteration should be executed.
    arguments: The last $invariant_size elements are invariants between iterations.
    results: a list of futures.
    body_fn: input is [predicate_promise, arg0_future, arg0_promise, arg1_future, arg1_promise, ..., invariant_args] and has no returned results.