this.baseDir = baseDir;
        if (includePattern.endsWith("/") || includePattern.endsWith("\\")) {
            includePattern += "**";
        }
        this.includePattern = includePattern;
        this.patternSegments = Arrays.asList(includePattern.split("[/\\\\]"));
        this.excludeSpec = excludeSpec;
    }

    @Override
    public File getDir() {

     * @return this
     */
    TestSpec includePattern(String pattern);

    /**
     * Adds all test classes and methods to the test execution that matches the target patterns.
     *
     * @see #includePattern(String)
     * @param patterns the patterns to select tests.
     * @return this
     */
    TestSpec includePatterns(Collection<String> patterns);

        }
        methods.addAll(newMethods);
        return this;
    }

    @Override
    public TestSpec includePattern(String pattern) {
        return includePatterns(Collections.singletonList(pattern));
    }

    @Override
    public TestSpec includePatterns(Collection<String> patterns) {
        this.patterns.addAll(patterns);
        return this;
    }

    @Override

        assertNodesAccessing("${root}/child/some/subdir", includingWithChildren)
    }

    def nodesRelatedTo(TestFile location, String includePattern) {
        return hierarchy.getNodesAccessing(location.absolutePath, includes(includePattern))
    }

    def nodesRelatedTo(TestFile location) {
        return hierarchy.getNodesAccessing(location.absolutePath)
    }

     *         spec.forTaskPath(":test")
     *             .includePackage("org.pkg")
     *             .includeClass("com.TestClass")
     *             .includeMethod("com.TestClass")
     *             .includePattern("io.*")
     *     }).run();
     * </pre>
     *
     * <p>
     * Note: These tests are ignored for target Gradle version earlier than 7.6.
     *

    def "allows configuring test names"() {
        expect: spec.includePatterns.isEmpty()

        when:
        spec.includeTestsMatching("*fooMethod")
        spec.includeTestsMatching("*.FooTest.*")

        then: spec.includePatterns == ["*fooMethod", "*.FooTest.*"] as Set

        when: spec.setIncludePatterns("x")

        then: spec.includePatterns == ["x"] as Set
    }

    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,

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

            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']