String testTaskPath = entry.getKey();
            for (AbstractTestTask testTask : queryTestTasks(context, testTaskPath)) {
                configureTestTask(testTask);
                for (InternalJvmTestRequest jvmTestRequest : entry.getValue()) {
                    final TestFilter filter = testTask.getFilter();
                    filter.includeTest(jvmTestRequest.getClassName(), jvmTestRequest.getMethodName());

        buildFile << """
            class TestTask extends SourceTask {
                @TaskAction
                def list() {
                    source.visit { fte -> println("visit " + fte.relativePath) }
                }
            }

            def location = null

            task source(type: TestTask) {
                source { file(location) }
            }

    private project = ProjectBuilder.builder().build()
    Test testTask = TestUtil.createTask(Test, project)

    def "can configure JUnit with an Action"() {
        when:
        testTask.useJUnit({ JUnitOptions options ->
            options.includeCategories = ['ExcludedCategory'] as Set
        } as Action<JUnitOptions>)

        then:
        (testTask.options as JUnitOptions).includeCategories == ['ExcludedCategory'] as Set

        _ * testTask.getFilter() >> testFilter
        _ * tasksContainerInternal.findByPath(TEST_TASK_NAME) >> testTask
        TaskCollection<Test> testTaskCollection = Mock()
        _ * testTaskCollection.iterator() >> [testTask].iterator()
        _ * tasksContainerInternal.withType(AbstractTestTask) >> testTaskCollection
        _ * testTask.getOutputs() >> outputsInternal

    ConventionAwareHelper conventionAware;

    TestTask testTask;

    @Rule
    public TestNameTestDirectoryProvider temporaryFolder = new TestNameTestDirectoryProvider(getClass());

    @Before public void setUp() {
        testTask = TestUtil.create(temporaryFolder).task(TestTask.class);
        conventionAware = new ConventionAwareHelper(testTask, new DefaultConvention(TestUtil.instantiatorFactory().decorateLenient()));

                test {
                    useJUnitJupiter()
                    targets.all {
                        // explicitly realize the task now to cause this configuration to run now
                        testTask.get().configure {
                            options {
                                includeTags 'fast'
                            }
                        }
                    }
                }
            }

    def instantiator = TestUtil.instantiatorFactory().decorateLenient()

    static class TestTask extends DefaultTask {
    }

    TestTask createTask(String name) {
        def task = TestUtil.create(temporaryFolder).createTask(TestTask, project, name)
        assertTrue(TestTask.isAssignableFrom(task.getClass()))
        return task
    }

    }

    def "can configure TestNG with an Action"() {
        when:
        testTask.useTestNG { TestNGOptions options ->
            options.suiteName = 'Custom Suite'
        }

        then:
        testTask.options.suiteName == 'Custom Suite'
    }

    TestNGTestFramework createFramework() {
        new TestNGTestFramework(testTask, new DefaultTestFilter(), objects)
    }

        buildFile << """
            testing {
                suites {
                    test {
                        useJUnitJupiter()
                        targets.all {
                            testTask.configure {
                                options {
                                    excludeTags "exclude"
                                }
                            }
                        }

class TaskReportContainerTest extends Specification {

    final Project project = ProjectBuilder.builder().build()
    final TestTask task = project.task("testTask", type: TestTask)

    def container = createContainer {
        dir("b")
        file("a")
    }

    static class TestTask extends DefaultTask {
        @Nested
        TaskReportContainer<Report> reports
    }