dryRunTest(JvmTestSuite) {
                        ${configureTestFramework}

                        targets {
                            all {
                                testTask.configure {
                                    dryRun.set(true)
                                }
                            }
                        }
                    }
                    test {

        1 * testResult.getFailedTestCount() >> 1

        def testTask = Mock(TaskInternal)
        1 * testTask.getPath() >> ":someproject:someTestTask"
        def taskBuildOperation = BuildOperationDescriptor.displayName("task")
            .details(new ExecuteTaskBuildOperationDetails(Stub(LocalTaskNode) {
                getTask() >> testTask
            }))
            .build(new OperationIdentifier(1), null)

.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

    private final Factory<File> testTaskTemporaryDir;
    private final Provider<Boolean> dryRun;

    public JUnitTestFramework(Test testTask, DefaultTestFilter filter, boolean useImplementationDependencies) {
        this(filter, useImplementationDependencies, new JUnitOptions(), testTask.getTemporaryDirFactory(), testTask.getDryRun());
    }

        buildFile << """
            testing {
                suites {
                    test {
                        useJUnit()
                        targets.all {
                            testTask.configure {
                                options {
                                    excludeCategories "com.example.Exclude"
                                }
                            }
                        }

        buildFile << """
            testing {
                suites {
                    test {
                        targets {
                            all {
                                testTask.configure {
                                    options {
                                        configFailurePolicy "continue"
                                    }
                                }

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

        val integrationTest by registering(JvmTestSuite::class) {
            dependencies {
                implementation(project())
            }

            targets {
                all {
                    testTask.configure {
                        shouldRunAfter(test)
                    }
                }
            }
        }
    }
}

tasks.named("check") {

import org.gradle.api.tasks.testing.logging.TestExceptionFormat

plugins {
    id 'java-library'
}

repositories {
    mavenCentral()
}

testing.suites.test {
    useJUnitJupiter()
    targets.test.testTask.configure {
        testLogging {
            exceptionFormat = TestExceptionFormat.FULL
        }
    }

               suites {
                   $suiteDeclaration {
                       useJUnit()
                       targets {
                           all {
                               testTask.configure {
                                   options {
                                       includeCategories 'CategoryA'
                                   }
                               }