private final Set<String> includePatterns;
    private final Set<String> commandLineIncludePatterns;
    private final Set<String> excludePatterns;
    private final Set<String> includeTags;
    private final Set<String> excludeTags;
    private final Set<String> includeEngines;
    private final Set<String> excludeEngines;

    DefaultTestTaskFilters(
        Set<String> includePatterns,

    }

    private List<TestPattern> preparePatternList(Collection<String> includedTests) {
        List<TestPattern> includePatterns = new ArrayList<TestPattern>(includedTests.size());
        for (String includedTest : includedTests) {
            includePatterns.add(new TestPattern(includedTest));
        }
        return includePatterns;
    }

    public boolean matchesTest(String className, String methodName) {

        def includePatterns = includes.collect { "include '$it'" }.join('\n')
        settingsFile << 'rootProject.name = "root"'
        buildFile <<
        """apply plugin: 'java'
           sourceSets {
               main {
                   java {
                       $excludePatterns
                       $includePatterns
                   }
               }
           }

        then:
        test.includes.empty
        test.excludes.empty
        test.filter.includePatterns == [TEST_PATTERN_1] as Set
        test.filter.commandLineIncludePatterns == [TEST_PATTERN_2] as Set
    }

    def "--tests is combined with filter.includePatterns"() {
        given:
        test.filter.includePatterns = [TEST_PATTERN_1]

        when:
        test.setTestNameIncludePatterns([TEST_PATTERN_2])

        "include and exclude"         | "include '*Test*'; exclude '*BTest*'"
        "filter.includeTestsMatching" | "filter { includeTestsMatching '*ATest*'; includeTestsMatching '*CTest*' }"
        "filter.includePatterns"      | "filter { includePatterns = ['*ATest*', '*CTest*'] }"
    }

    def "invoking testNameIncludePatterns does not influence include/exclude filter"() {
        given:
        buildFile << """
        test {

            if (classesForSourceSet == null) {
                // No classes included, disable
                testTask.enabled = false
            } else {
                testTask.filter.includePatterns.addAll(classesForSourceSet)
            }
        }
    }

    class ExcludeTestClassProvider(private val excludeTestClasses: Map<String, List<String>>) : BuildBucketProvider {

        with(new JsonSlurper().parse(file('build/testTaskProperties.json')), Map) {
            usingJUnitPlatform == true
            forkEvery == 42
            with(filters, Map) {
                includePatterns == ['*Class']
                excludePatterns == ['exclude-pattern']
                commandLineIncludePatterns == ['Test*']
                includeTags == ['included-tag']
                excludeTags == ['excluded-tag']

    }

    def "does not report task as failed if first suite contained tests"() {
        given:
        expectFirstTestSuiteContainsTestButSecondIsEmpty()
        task.filter {
            it.includePatterns = "Foo"
        }

        when:
        task.executeTests()

        then:
        noExceptionThrown()
    }

                        setTestNameIncludePatterns(scenariosFromFile)
                    }
                    doFirst {
                        assert((filter as DefaultTestFilter).includePatterns.isNotEmpty()) { "Running $name requires to add a test filter" }
                    }
                }
                mustRunAfter(currentlyRegisteredTestProjects)
                testSpecificConfigurator(this)