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);

        filter.getCommandLineIncludePatterns().each { includePattern ->
            def lastDot = includePattern.lastIndexOf(".")
            if (lastDot == -1) {
                classOnlyFilters.add(includePattern)
            } else {
                def className = includePattern.substring(0, lastDot)
                def methodName = includePattern.substring(lastDot + 1)

    }

    def "can select tests with pattern"() {
        when:
        launchTests { TestLauncher launcher ->
            launcher.withTestsFor { TestSpecs specs ->
                specs.forTaskPath(':secondTest').includePattern('example2.MyOtherTest*.ba*')
            }
        }

        then:
        events.testClassesAndMethods.size() == 4

    private static TestFile findFile(File baseDir, String includePattern) {
        List<TestFile> files = findFiles(baseDir, includePattern)
        assert files.size() == 1
        return files[0]
    }

    private static List<TestFile> findFiles(File baseDir, String includePattern) {
        List<TestFile> files = []
        new SingleIncludePatternFileTree(baseDir, includePattern).visit(new FileVisitor() {
            @Override

        }
        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)
    }

        1 * visitor.visitDir({ it.file == tempDir.file("dir2/dir2") })
        0 * _
    }

    def "include directory recursively"() {
        fileTree = new SingleIncludePatternFileTree(tempDir.testDirectory, includePattern)

        when:
        fileTree.visit(visitor)

        then:
        1 * visitor.visitDir({ it.file == tempDir.file("dir2") })
        1 * visitor.visitFile({ it.file == tempDir.file("dir2/file1") })

     *         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
    }