testSuites.withType(JvmTestSuite.class).configureEach(suite -> {
                suite.getTargets().configureEach(target -> {
                    createCoverageDataVariant((ProjectInternal) project, suite, target);
                });
            });
        });
    }

    private void createCoverageDataVariant(ProjectInternal project, JvmTestSuite suite, JvmTestSuiteTarget target) {

            url = uri(layout.buildDirectory.dir("repo"))
        }
    }
}

tasks.publish {
    dependsOn("check")
}
// end::publish[]


testing {
    suites {
        val test by getting(JvmTestSuite::class) {
            useJUnit()
        }
    }
}

// tag::repositories-and-dependencies[]
repositories {
    gradlePluginPortal() // so that external plugins can be resolved in dependencies section
}

plugins {
    java
    jacoco
}

version = "1.0.2"
group = "org.gradle.sample"

repositories {
    mavenCentral()
}

testing {
    suites {
        val test by getting(JvmTestSuite::class) {
            useJUnitJupiter()
        }
    }
}

// Do not generate reports for individual projects
tasks.jacocoTestReport {
    enabled = false

        }

        ${mavenCentralRepository()}

        testing {
            suites {
                test {
                    useJUnit()
                }
                integTest(JvmTestSuite) // implicitly uses JUnit Jupiter
            }
        }

        tasks.named('check') {
            dependsOn testing.suites.integTest
        }
        """

        given:
        buildKotlinFile """
            plugins {
                id("java-library")
            }
            testing {
                suites {
                    named<JvmTestSuite>("test") {
                        useJUnitJupiter()
                    }
                }
            }
            tasks.test {
                onOutput(

    ) {
        TestingExtension testing = extensions.findByType(TestingExtension.class);
        final NamedDomainObjectProvider<JvmTestSuite> testSuite = testing.getSuites().register(JvmTestSuitePlugin.DEFAULT_TEST_SUITE_NAME, JvmTestSuite.class, suite -> {
            final SourceSet testSourceSet = suite.getSources();

import org.gradle.api.internal.project.ProjectInternal;
import org.gradle.api.model.ObjectFactory;
import org.gradle.api.plugins.internal.JavaPluginHelper;
import org.gradle.api.plugins.jvm.JvmTestSuite;
import org.gradle.api.plugins.jvm.internal.JvmFeatureInternal;
import org.gradle.api.tasks.TaskProvider;
import org.gradle.api.tasks.bundling.War;
import org.gradle.internal.deprecation.DeprecationLogger;

                id 'jvm-test-suite'
            }
            ${buildFile.text}
        """
        buildFile << """
            testing {
                suites {
                    integration(JvmTestSuite) {
                        dependencies {
                             implementation 'org:lib:1.0'
                        }
                    }
                }
            }
        """

        when:

            ExtensiblePolymorphicDomainObjectContainer<TestSuite> suites = testing.getSuites();
            suites.withType(JvmTestSuite.class).configureEach(jvmTestSuite -> {
                // jvm test suite source sets are marked as test on the Eclipse classpath
                testSourceSetsConvention.add(jvmTestSuite.getSources());

                // resolved dependencies from jvm test suites are marked as test on the Eclipse classpath

    }

    def "options for test framework are respected for TestNG for custom test suite"() {
        buildFile << """
            testing {
                suites {
                    integrationTest(JvmTestSuite) {
                        useTestNG()
                        targets.all {
                            testTask.configure {
                                options {