jvmTargetValidationMode = org.jetbrains.kotlin.gradle.dsl.jvm.JvmTargetValidationMode.WARNING
            }
        """)

        withFile("src/main/kotlin/code.kt", """
            import org.gradle.api.*

            class MyPlugin : Plugin<Project> {
                override fun apply(project: Project): Unit = project.run {
                    ext {

                testImplementation("junit:junit:4.13")
                testImplementation("org.hamcrest:hamcrest-core:1.3")
            }

            $repositoriesBlock

            """
        )

        withFile(
            "src/main/kotlin/plugin/TestPlugin.kt",
            """

            package plugin

            import org.gradle.api.*
            import org.gradle.kotlin.dsl.*

            }
        }

        withDefaultSettingsIn("external-plugins")
        withKotlinDslPluginIn("external-plugins").appendText("""group = "test"""")
        withFile("external-plugins/src/main/kotlin/applied-output.gradle.kts", outputFrom("applied-output plugin"))
        withFile(
            "external-plugins/src/main/kotlin/applied-output-fails.gradle.kts", """
            ${outputFrom("applied-output-fails plugin")}

    }

    @Override
    public <R> R withNode(VfsRelativePath targetPath, CaseSensitivity caseSensitivity, NodeHandler<T, R> handler) {
        return entry.withNode(targetPath, caseSensitivity, handler);
    }

    @Override
    public <RESULT> ChildMap<RESULT> invalidate(VfsRelativePath targetPath, CaseSensitivity caseSensitivity, InvalidationHandler<T, RESULT> handler) {

    }

    @Override
    public <R> R withNode(VfsRelativePath targetPath, CaseSensitivity caseSensitivity, NodeHandler<T, R> handler) {
        int childIndexWithCommonPrefix = findChildIndexWithCommonPrefix(targetPath, caseSensitivity);
        if (childIndexWithCommonPrefix >= 0) {
            Entry<T> entry = entries.get(childIndexWithCommonPrefix);
            return entry.withNode(targetPath, caseSensitivity, handler);
        }

        then:
        1 * listener.onOutput({ it instanceof LogLevelChangeEvent && it.newLogLevel == LogLevel.WARN })
        1 * listener.onOutput({ it.spans[0].text == withEOL('info') })
        original.toString() == ''
        0 * listener._
    }

    private String withEOL(String value) {
        return String.format('%s%n', value)
    }

        """.stripIndent())

        and:
        withImplementationDependencyOn("project-a", dependencyA)
        withFile("project-a/src/main/kotlin/my-plugin-a.gradle.kts")

        and:
        withImplementationDependencyOn("project-b", dependencyB)
        withFile("project-b/src/main/kotlin/my-plugin-b.gradle.kts")

        expect:
        assertClassPathFor(

                            }
                        }
                    }
                }
            }
            """
        )

        withFile("src/main/kotlin/foo.gradle.kts", "plugins { base }")
        withFile(
            "src/test/kotlin/fooTest.kt",
            """
            import org.junit.Test
            class FooTest {
                @Test fun testFoo() { }
            }

        withAllWarningsAsErrors()
        val script = withFile("my-init.gradle.kts", scriptContentWithWarning)
        buildAndFail("help", "-I", script.name).apply {
            assertHasWarningLineFor(script)
            assertHasDetailedErrorOutput()
        }
    }

    @Test
    fun `fails on warning in applied script`() {
        withAllWarningsAsErrors()
        val script = withFile("my-script.gradle.kts", scriptContentWithWarning)

    fun withBuildScriptIn(baseDir: String, script: String, produceFile: (String) -> File = ::newFile): File =
        withFile("$baseDir/build.gradle.kts", script, produceFile)

    protected
    fun withFile(fileName: String, text: String = "", produceFile: (String) -> File = ::newFile) =
        writeFile(produceFile(fileName), text)

    private
    fun writeFile(file: File, text: String): File =