notForAccessorGeneration {
    dependencies {
        sharedArchTestClasses(project(":internal-architecture-testing"))
    }
}

testing {
    suites {
        create("archTest", JvmTestSuite::class) {
            useJUnitJupiter()
            dependencies {
                implementation(project.dependencies.create(project))
                notForAccessorGeneration {

        file("consumer/build.gradle") << """
            plugins {
                id 'java-library'
            }
            ${mavenCentralRepository()}
            testing.suites.test {
                useJUnitJupiter()
                dependencies {
                    implementation testFixtures(project(':'))
                }
            }
        """

        file("consumer/src/test/java/ExampleTest.java") << """

group = "org.gradle.sample"

repositories {
    mavenCentral()
}

// tag::multi-configure[]
testing {
    suites {
        val applyMockito = { suite: JvmTestSuite -> // <1>
            suite.useJUnitJupiter()
            suite.dependencies {
                implementation("org.mockito:mockito-junit-jupiter:4.6.1")
            }
        }

        /* This is the equivalent of:

    def 'test retry plugin with test suites'() {
        given:
        buildFile << """
            testing {
                suites {
                    test {
                        useJUnitJupiter('5.7.1')
                        targets {
                            all {
                                testTask.configure {
                                    def markerFile = file("marker.file")

            }
            repositories {
                mavenCentral()
            }
            testing {
                suites {
                    test {
                        useJUnitJupiter()
                    }
                }
            }
            tasks.named('test') {
                testLogging {
                    showStandardStreams = true
                }

        """
        buildFile << """
            ${mavenCentralRepository()}

            testing {
                suites {
                    integration(JvmTestSuite) {
                        useJUnitJupiter()
                    }
                }
            }
        """

        when:
        run 'eclipse'

        then:
        assertJarDependencyHasTestAttribute('junit-platform-engine')

            }

            dependencies {
                implementation 'org.springframework.boot:spring-boot-starter'
            }

            testing.suites.test {
                useJUnitJupiter()
                dependencies {
                    implementation 'org.springframework.boot:spring-boot-starter-test'
                }
            }
        """.stripIndent()

            plugins {
              id 'java'
            }

            ${mavenCentralRepository()}

            testing {
                suites {
                    test {
                        useJUnitJupiter()
                    }
                }
            }
        """
    }

    def 'task does not execute when it has a test task output dependency and VM exits unexpectedly'() {
        given:

        then:
        succeeds ':test'
    }

    def "runs JUnit5 blackbox test as module using the module path"() {
        given:
        buildFile << """
            testing.suites.test.useJUnitJupiter()
        """

        when:
        consumingModuleInfo('exports consumer')
        consumingModuleClass()
        testModuleInfo('requires consumer', 'requires org.junit.jupiter.api')

                implementation("org.gradle.experimental:gradle-public-api:${apiJarVersion}")
            }

            testing {
                suites {
                    test {
                        useJUnitJupiter()
                    }
                }
            }

            repositories {
                maven {
                    url = uri("${apiJarRepoLocation.toURI()}")
                }