where:
        numThreads << [1, 4]
    }

    def "generates report with aggregated index page for failing build - #numThreads parallel thread(s)"() {
        given:
        report = reportWithMaxThreads(numThreads)
        def testTestResults = failingBuildResults()

        when:

            }
        }

        Thread[] threads = new Thread[t.numThreads];
        int ti;

        for (ti = 0; ti < t.numThreads; ti++) {
            threads[ti] = new Thread(t);
            System.out.print(threads[ti].getName());
            threads[ti].start();
        }

        while (t.numComplete < t.numThreads) {
            long delay;

            do {
                delay = 2L;

    BuildOperationExecutor buildOperationExecutor
    Binary2JUnitXmlReportGenerator generator

    def generatorWithMaxThreads(int numThreads) {
        buildOperationExecutor = BuildOperationExecutorSupport.builder(numThreads)
            .withRunner(buildOperationRunner)
            .build()
        Binary2JUnitXmlReportGenerator reportGenerator = new Binary2JUnitXmlReportGenerator(

import org.gradle.internal.work.WorkerLeaseService;
import org.gradle.test.fixtures.work.TestWorkerLeaseService;

public class BuildOperationExecutorSupport {

    public static Builder builder(int numThreads) {
        return builder(new DefaultWorkerLimits(numThreads));
    }

    public static Builder builder(WorkerLimits workerLimits) {
        return new Builder(workerLimits);
    }

    public static class Builder {

  }

  @J2ktIncompatible
  @GwtIncompatible // blocking wait
  public void testRunIdempotency() throws Exception {
    final int numThreads = 10;
    final ExecutorService executor = Executors.newFixedThreadPool(numThreads);
    for (int i = 0; i < 1000; i++) {
      final AtomicInteger counter = new AtomicInteger();
      final TrustedListenableFutureTask<Integer> task =

        archiveFileToRoot(getArchiveFile());

        // Create some visitors that will count the number of lines in each file they encounter
        List<CountingVisitor> visitors = new ArrayList<>(numThreads);
        for (int i = 0; i < numThreads; i++) {
            visitors.add(new CountingVisitor());
        }

        // Create callables that will send the visitors to visit the archive

      true);
  return options;
}

class CustomThreadPoolImpl : public thread::ThreadPoolInterface {
 public:
  explicit CustomThreadPoolImpl(int numThreads) {
    underlying_threadpool_.reset(new thread::ThreadPool(
        tensorflow::Env::Default(), "custom_threadpool", numThreads));
    num_schedule_called_ = 0;
  }

  void Schedule(std::function<void()> fn) override {
    num_schedule_called_ += 1;

  }
}

// Trivial test that runs the generated function to ensure it doesn't crash.
TEST(TEST_NAME, NoCrash) {
  Eigen::ThreadPool pool(port::MaxParallelism());
  Eigen::ThreadPoolDevice device(&pool, pool.NumThreads());

  CPP_CLASS computation;
  computation.set_thread_pool(&device);
  zero_buffers(&computation);

  EXPECT_TRUE(computation.Run());
}

// Simple benchmark that repeatedly runs the generated function.

    def "invoking DefaultSerializerRegistry from multiple threads"() {
        given:
        def conditions = new AsyncConditions(numThreads)
        def serializer = Stub(Serializer)
        numThreads.times { threadId ->
            Thread.startDaemon("DefaultSerializerRegistry Test #$threadId") {
                conditions.evaluate {

  Eigen::ThreadPoolDevice device(&tp, tp.NumThreads());

  VariableReadonlyComp fn;
  float x = 23;
  fn.set_var_x_data(&x);

  fn.set_thread_pool(&device);
  fn.Run();
  EXPECT_EQ(fn.result0(), 65);
  EXPECT_EQ(fn.var_x(), 23);
}

TEST(TFCompileTest, Variable) {
  Eigen::ThreadPool tp(1);
  Eigen::ThreadPoolDevice device(&tp, tp.NumThreads());

  VariableComp fn;
  float x = 23;