def testExecution = server.expectConcurrentAndBlock(2, SERVER_RESOURCE_1, SERVER_RESOURCE_2)

        when:
        def gradleHandle = executer.withTasks('test').start()
        testExecution.waitForAllPendingCalls()

        then:
        ConcurrentTestUtil.poll {

        when:
        queue.stop()

        then:
        1 * executor.stop()
    }

    TestExecution testExecution(Callable<String> callable) {
        return new TestExecution(callable)
    }

    class TestExecution extends AbstractConditionalExecution {
        TestExecution(Callable callable) {
            super(callable)
        }
    }

        generator.withNonfailingTest()
        def testExecution = server.expectConcurrentAndBlock(DEFAULT_MAX_WORKERS, FAILED_RESOURCE, OTHER_RESOURCE)

        when:
        def gradleHandle = executer.withTasks(taskList).start()
        testExecution.waitForAllPendingCalls()

        then:
        testExecution.release(FAILED_RESOURCE)
        testExecution.release(OTHER_RESOURCE)
        gradleHandle.waitForFailure()

                        performanceResults.setGradleOpts(ResultsStoreHelper.toList(testExecutions.getObject(7)));
                        performanceResults.setDaemon((Boolean) testExecutions.getObject(8));
                        performanceResults.setOperatingSystem(testExecutions.getString(9));
                        performanceResults.setJvm(testExecutions.getString(10));

        def resourceForTest = generator.withFailingTests(6)
        def testExecution = server.expectOptionalAndBlock(maxWorkers * threadCount, resourceForTest.values() as String[])

        when:
        def gradleHandle = executer.withTasks('test', '--fail-fast').start()
        testExecution.waitForAllPendingCalls()

        then:
        testExecution.release(1)
        gradleHandle.waitForFailure()

        writeTestClassFiles()

        def testExecution = server.expectConcurrentAndBlock('failingTest', 'enabledParameterizedTest')

        when:
        def gradle = executer.withTasks('test', '--fail-fast').start()

        then:
        testExecution.waitForAllPendingCalls()

        when:
        testExecution.release('failingTest')

        then:
        gradle.waitForFailure()

                try (ResultSet testExecutions = testIdsStatement.executeQuery()) {
                    while (testExecutions.next()) {
                        String testClass = testExecutions.getString(1);
                        String testName = testExecutions.getString(2);
                        String testProject = testExecutions.getString(3);

            select
               testClass,
               testId,
               testProject,
               '${os.name()}' as os,
               avg(TIMESTAMPDIFF(SECOND, testExecution.startTime, testExecution.endTime)) as duration
            from testExecution
           where startTime > ?
             and (channel in (?, ?))
              or channel like ?
             and testProject is not null

     *
     * <pre>
     *  SELECT TESTID, TESTPROJECT, AVG(CONVERT(CASEWHEN(DIFFCONFIDENCE &gt; 0.97, 1, 0), DECIMAL)) AS FAILURE_RATE,
     *  FROM TESTEXECUTION
     *  WHERE (CHANNEL = 'flakiness-detection-master' OR CHANNEL = 'flakiness-detection-release')
     *  GROUP BY TESTID
     * </pre>
     *
     * @return the flakiness rate in DB, null if not exists.
     */

        List<MeasuredOperationList> nonEmptyExecutions = performanceTestExecution
            .getScenarios()
            .stream()
            .filter(testExecution -> !testExecution.getTotalTime().isEmpty())
            .collect(toList());
        if (nonEmptyExecutions.size() > 1) {
            int size = nonEmptyExecutions.size();