}

    def "allows configuring by test class and methodname"() {
        expect: spec.includePatterns.isEmpty()

        when:
        spec.includeTest("acme.FooTest", "bar")
        spec.includeTest("acme.BarTest", null)

        then: spec.includePatterns == ["acme.FooTest.bar", "acme.BarTest.*"] as Set
    }

    def "prevents empty names"() {

    def "can select test methods from test task with filters"() {
        setup:
        buildFile << '''
            secondTest {
                filter {
                    includeTest "example.MyTest", "foo"
                    includeTest "example.MyTest", "foo2"
                }
            }
        '''

        when:
        launchTests { TestLauncher launcher ->

                configureTestTask(testTask);
                for (InternalJvmTestRequest jvmTestRequest : entry.getValue()) {
                    final TestFilter filter = testTask.getFilter();
                    filter.includeTest(jvmTestRequest.getClassName(), jvmTestRequest.getMethodName());
                }
            }
        }

        for (InternalTaskSpec taskSpec : testExecutionRequest.getTaskSpecs()) {

 *          //specific test class
 *          includeTestsMatching "org.gradle.SomeTest"
 *
 *          //specific test class and method
 *          includeTestsMatching "org.gradle.SomeTest.someSpecificFeature"
 *          includeTest "org.gradle.SomeTest", "someTestMethod"
 *
 *          //specific test method, use wildcard
 *          includeTestsMatching "*SomeTest.someSpecificFeature"
 *
 *          //specific test class, wildcard for packages

        validateName(testNamePattern);
        excludeTestNames.add(testNamePattern);
        return this;
    }

    @Override
    public TestFilter includeTest(String className, String methodName) {
        return addToFilteringSet(includeTestNames, className, methodName);
    }

    @Override
    public TestFilter excludeTest(String className, String methodName) {

        when:
        buildConfigurationAction.applyTasksTo(context, executionPlan)
        buildConfigurationAction.postProcessExecutionPlan(context, executionPlanContents)

        then:
        1 * testFilter.includeTest(expectedClassFilter, expectedMethodFilter)

        (1..2) * testFilter.setFailOnNoMatchingTests(false)
        (1..2) * outputsInternal.upToDateWhen(Specs.SATISFIES_NONE)

        where:

			}
		}
	}

	return pkg, nil
}

// pkgFilenames returns the list of package filenames for the given directory.
func pkgFilenames(dir string, includeTest bool) ([]string, error) {
	ctxt := build.Default
	ctxt.CgoEnabled = false
	pkg, err := ctxt.ImportDir(dir, 0)
	if err != nil {
		if _, nogo := err.(*build.NoGoError); nogo {

			}
		}
	}

	return pkg, nil
}

// pkgFilenames returns the list of package filenames for the given directory.
func pkgFilenames(dir string, includeTest bool) ([]string, error) {
	ctxt := build.Default
	ctxt.CgoEnabled = false
	pkg, err := ctxt.ImportDir(dir, 0)
	if err != nil {
		if _, nogo := err.(*build.NoGoError); nogo {

@Timeout(120)
@TargetGradleVersion('>=6.8')
class CompositeBuildTestLauncherCrossVersionSpec extends TestLauncherSpec {

    def setup() {
        file("included-build/src/test/java/example/IncludedTest.java").text = """
            package example;
            public class IncludedTest {
                @org.junit.Test
                public void foo() {
                     org.junit.Assert.assertEquals(1, 1);
                }

            String includedTest = it.next();
            if (isIncludedTestCase(includedTest)) {
                if (testSuiteCache.contains(getTestSuiteName(includedTest))) {
                    it.remove();
                }
            }
        }
    }

    private static boolean isIncludedTestCase(String includedTest) {
        return includedTest.contains("/");
    }