def "parallel #parallel execution with #threadCount threads, #maxWorkers workers fails fast"() {
        given:
        buildFile.text = generator.initBuildFile(maxWorkers)
        buildFile << """
            test {
                useTestNG() {
                    parallel = '$parallel'
                    threadCount = $threadCount
                }
            }
        """.stripIndent()

	if err != nil {
		return 0, err
	}
	return m.PagefileUsage, nil
}

func StackMemory() {
	mem1, err := getPagefileUsage()
	if err != nil {
		panic(err)
	}
	const threadCount = 100
	var wg sync.WaitGroup
	for i := 0; i < threadCount; i++ {
		wg.Add(1)
		go func() {
			runtime.LockOSThread()
			wg.Done()
			select {}
		}()
	}
	wg.Wait()
	mem2, err := getPagefileUsage()
	if err != nil {

  public Crawler(OkHttpClient client) {
    this.client = client;
  }

  private void parallelDrainQueue(int threadCount) {
    ExecutorService executor = Executors.newFixedThreadPool(threadCount);
    for (int i = 0; i < threadCount; i++) {
      executor.execute(() -> {
        try {
          drainQueue();
        } catch (Exception e) {
          e.printStackTrace();
        }

        assert System.getProperty(notsetPropertyName) == null
    }

    def "withProperty and withProperties are never run concurrently"() {
        final int threadCount = 100
        def id = UUID.randomUUID().toString()

        when:
        async {
            threadCount.times { i ->
                start {
                    SystemProperties.instance.withSystemProperty(id, "bar", {"baz"})
                }
                start {

        boolean isDryRun
    ) {
        this.filter = filter;
        this.defaultSuiteName = defaultSuiteName;
        this.defaultTestName = defaultTestName;
        this.parallel = parallel;
        this.threadCount = threadCount;
        this.suiteThreadPoolSize = suiteThreadPoolSize;
        this.useDefaultListener = useDefaultListener;
        this.threadPoolFactoryClass = threadPoolFactoryClass;
        this.includeGroups = includeGroups;

        assert workerLeaseService.currentProjectLocks.empty
    }

    def "multiple threads can coordinate locking of a project"() {
        def threadCount = 10
        def started = new CountDownLatch(threadCount)

        when:
        async {
            threadCount.times {
                start {
                    started.countDown()
                    thread.blockUntil.releaseAll

	if err != nil {
		return 0, err
	}
	return m.PagefileUsage, nil
}

func StackMemory() {
	mem1, err := getPagefileUsage()
	if err != nil {
		panic(err)
	}
	const threadCount = 100
	var wg sync.WaitGroup
	for i := 0; i < threadCount; i++ {
		wg.Add(1)
		go func() {
			runtime.LockOSThread()
			wg.Done()
			select {}
		}()
	}
	wg.Wait()
	mem2, err := getPagefileUsage()
	if err != nil {

            excludeGroups == source.excludeGroups
            configFailurePolicy == source.configFailurePolicy
            listeners == source.listeners
            parallel == source.parallel
            threadCount == source.threadCount
            suiteThreadPoolSize.get() == source.suiteThreadPoolSize.get()
            useDefaultListeners == source.useDefaultListeners
            threadPoolFactoryClass == source.threadPoolFactoryClass

        given:
        sharedResourceLeaseRegistry.registerSharedResource('resource', 1)
        def threadCount = 10
        def started = new CountDownLatch(threadCount)

        when:
        async {
            threadCount.times {
                start {
                    started.countDown()
                    thread.blockUntil.releaseAll

            }
            test {
              useTestNG {
                suites "suite.xml"
              }
            }
        """
    }

    def createTests(int testCount, int threadCount) {
        String suiteXml = ""
        testCount.times { x ->
            file("src/test/java/Foo${x}Test.java") << """
                public class Foo${x}Test {