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:

    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 =

    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 {

  }

  @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 =

    List<Throwable> exceptions = runThreadsAndReturnExceptions(numThreads, task);

    assertThat(exceptions).isEmpty();
  }

  private static List<Throwable> runThreadsAndReturnExceptions(int numThreads, Runnable task) {
    List<Thread> threads = new ArrayList<>(numThreads);
    final List<Throwable> exceptions = new ArrayList<>(numThreads);
    for (int i = 0; i < numThreads; i++) {
      Thread thread = new Thread(task);

            if (executorService == null) {
                int numThreads = ComponentUtil.getFessConfig().getRankFusionThreadsAsInteger();
                if (numThreads <= 0) {
                    numThreads = (Runtime.getRuntime().availableProcessors() * 3) / 2 + 1;
                }
                executorService = Executors.newFixedThreadPool(numThreads);
            }
        }
    }

               std::max(1, static_cast<int32_t>(num_threads))) {}

  void Schedule(std::function<void()> fn) override {
    tpool_.Schedule(std::move(fn));
  }

  int NumThreads() const override { return tpool_.NumThreads(); }
  int CurrentThreadId() const override { return tpool_.CurrentThreadId(); }
  void Cancel() override {}

 private:
  ThreadPool tpool_;
};
}  // namespace