*
 * @since 7.6
 */
@Incubating
public interface TestSpec {

    /**
     * Adds all tests declared in the target package to the test execution.
     * <p>
     * The effect is recursive, meaning that the tests defined in sub-packages will also be executed.
     *
     * @param pkg The target package.
     * @return this
     */
    TestSpec includePackage(String pkg);

    /**

        if (methodName != null && testSpec != null) {
            if (testSpec.hasProperty('testId') && testSpec.testId == null) {
                testSpec.testId = methodName
            } else if (testSpec.hasProperty('displayName') && testSpec.displayName == null) {
                testSpec.displayName = methodName
            }

            if(testSpec.hasProperty('testClassName') && testSpec.testClassName == null) {

        this.patterns = patterns;
    }

    @Override
    public TestSpec includePackage(String pkg) {
        return includePackages(Collections.singletonList(pkg));
    }

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

    @Override
    public TestSpec includeClass(String cls) {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.tooling.internal.consumer;

import org.gradle.tooling.TestSpec;
import org.gradle.tooling.TestSpecs;

import java.util.ArrayList;
import java.util.List;

public class DefaultTestSpecs implements TestSpecs {

                InternalTestSpec testSpec = (InternalTestSpec) taskSpec;
                for (String cls : testSpec.getClasses()) {
                    requestDetails.append("\n").append(twoIndent()).append("Test class: ").append(cls).append(" in task " + taskSpec.getTaskPath());
                }
                for (Map.Entry<String, List<String>> methods : testSpec.getMethods().entrySet()) {

                InternalTestSpec testSpec = (InternalTestSpec) taskSpec;
                Set<AbstractTestTask> tasks = queryTestTasks(context, taskSpec.getTaskPath());
                for (AbstractTestTask task : tasks) {
                    DefaultTestFilter filter = (DefaultTestFilter) task.getFilter();
                    for (String cls : testSpec.getClasses()) {

@Incubating
public interface TestSpecs {

    /**
     * Creates a new test selection for the target task.
     *
     * @param taskPath The target task.
     * @return A new test selection.
     */
    TestSpec forTaskPath(String taskPath);

                }

                void call() {
                   callable.call()
                }
            }
        """
        file("src/test/groovy/TestSpec.groovy") << """
            import spock.lang.Specification

            class TestSpec extends Specification {
                def testMethod() {
                    final callable = Mock(MockIt)
                    def caller = new Caller(callable)

     *
     * <p>
     * Note: These tests are ignored for target Gradle version earlier than 7.6.
     *
     * @param testSpec The action selecting the target tests.
     * @return this
     * @since 7.6
     */
    @Incubating
    TestLauncher withTestsFor(Action<TestSpecs> testSpec);

                buildContext
        )
        runner.workingDir = temporaryFolder.testDirectory
        runner.current = new UnderDevelopmentGradleDistribution(buildContext)
        performanceTestIdProvider.testSpec = runner
    }

    CrossVersionPerformanceTestRunner getRunner() {
        runner
    }

    void applyDevelocityPlugin() {
        runner.addBuildMutator { invocationSettings ->