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

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

    }

    def "fails if custom executable is a directory"() {
        def testTask = project.tasks.create("test", Test)
        def executableDir = temporaryFolder.createDir("javac")

        when:
        testTask.executable = executableDir.absolutePath
        testTask.javaVersion

        then:
        def e = thrown(AbstractProperty.PropertyQueryException)

    public static class TestTask extends DefaultTask {
        final Runnable action;

        @Inject
        public TestTask(Runnable action) {
            this.action = action;
        }

        @TaskAction
        public void doStuff() {
            action.run();
        }
    }

    public static class TaskWithInheritedMethod extends TestTask {
        @Inject

.Define dependencies between code coverage reports and test execution
====
include::sample[dir="snippets/testing/jacoco-quickstart/kotlin",files="build.gradle.kts[tags=testtask-dependency]"]
include::sample[dir="snippets/testing/jacoco-quickstart/groovy",files="build.gradle[tags=testtask-dependency]"]
====

[[sec:configuring_the_jacoco_plugin]]
== Configuring the JaCoCo Plugin

                "task rootTask",
                "task testTask",
                "class ConventionBean { def getConventionProperty() { 'convention' } }"
        )
        file("child/build.gradle").writelns(
                "ext.childProperty = 'child'",
                "ext.sharedProperty = 'shared'",
                "task testTask {",
                "  doLast { new Reporter().checkProperties(project) }",

                testResults.from([
                    testing.suites.test.targets.test.testTask,
                    testing.suites.superTest.targets.superTest.testTask,
                    testing.suites.subTest.targets.subTest.testTask
                ])
            }

            tasks.named('build').configure { it.dependsOn testReport }
        """.stripIndent()

                subprojects {
                    tasks.withType(com.android.build.gradle.tasks.factory.AndroidUnitTest) { testTask ->
                        testTask.finalizedBy(finalizerTask)
                        finalizerTask.configure {
                            dependsOn testTask
                        }
                    }
                }
            """.stripIndent()
        }
    }

            task(asMethod)\n{ description = 'value' }
            task asStatement(type: TestTask) { property = 'value' }
            task "dynamic"(type: TestTask) { property = 'value' }
            ext.v = task(asExpression, type: TestTask) { property = 'value' }
            task(postConfigure, type: TestTask).configure { property = 'value' }
            [asStatement, dynamic, asExpression, postConfigure].each {

            defaultTestSuite.getTargets().configureEach(target -> {
                TaskProvider<Test> testTask = target.getTestTask();
                addDefaultReportTask(extension, testTask);
                addDefaultCoverageVerificationTask(testTask);
            });
        });
    }