settingsFile << """
            include "p1"
            include "p2"
        """

        when:
        file("p1/build.gradle") << USE
        file("p2/build.gradle") << USE

        buildScript """
            evaluationDependsOnChildren()
            task verify {
                def p1PluginClass = project(":p1").pluginClass
                def p2PluginClass = project(":p2").pluginClass
                doLast {

        )

        assert(
            build("-I", initScript.canonicalPath)
                .output.contains("*42*")
        )
    }

    @Test
    fun `Kotlin init scripts from init dir can add buildscript repositories to projects`() {

        val testRepositoryDir = file("test-repository").apply { mkdirs() }

        val guh = file("gradle-user-home").apply { mkdirs() }
        guh.withFolders {
            "init.d" {

    @Rule
    public final TestResources resources = new TestResources(testDirectoryProvider, "copyTestResources")

    def "can use filesMatching with List"() {
        given:
        buildScript """
            task (copy, type: Copy) {
                from 'src'
                into 'dest'
                filesMatching(['**/ignore/**', '**/sub/**']) {
                    name = "matched\${name}"

     * This method was originally added in order to release the resources of the {@code classpath}
     * configurations used for resolving buildscript classpaths, as they consumed a non-negligible
     * amount of memory even after the buildscript classpath was assembled.
     * <p>
     * Future work in this area should remove the need of this method by instead caching resolution

                }
            }
        }
    """
    def pluginClasspathDependency = "org.gradle:gradle-hello-world-plugin:0.2"

    def "buildscript dependencies can be resolved from gradlePluginPortal()"() {
        given:
        buildFile << """
            buildscript {
                $gradlePluginPortalRepository
                dependencies {
                    classpath("$pluginClasspathDependency")
                }

        result.testClass("LoggingTest").assertStderr(equalTo("stderr.\n"))
    }

    def "test report task can handle test tasks that did not run tests"() {
        given:
        buildScript """
            $junitSetup

            def test = tasks.named('test', Test)

            def otherTests = tasks.register('otherTests', Test) {
                binaryResultsDirectory = file("bin")

    }

    @Override
    public ScriptHandler getBuildscript() {
        return getScriptTarget().getBuildscript();
    }

    @Override
    public void buildscript(Closure configureClosure) {
        getScriptTarget().buildscript(configureClosure);
    }

    @Override
    public StandardOutputCapture getStandardOutputCapture() {
        return getScriptTarget().getStandardOutputCapture();
    }

    <para>This sample contains the following projects:</para>
    <itemizedlist>
        <listitem>
            <para>The <filename>buildscript</filename> directory contains a project that uses the old <code>buildscript</code> syntax for using plugins.</para>
        </listitem>
        <listitem>

class ConfigurationCycleIntegrationTest extends AbstractIntegrationSpec {

    def "configuration cycle error contains information useful for troubleshooting"() {
        when:
        buildScript '''
            class Rules extends RuleSource {
                @Model
                String first(@Path("second") String second) {
                    "foo"
                }

                @Model

        compileGroovy {
            groovyOptions.optimizationOptions.indy = $enableIndy
        }
        """

        buildScript("""
            apply plugin: SomePlugin
        """)
    }

    abstract TestFile file(Object... path)

    abstract TestFile buildScript(@GroovyBuildScriptLanguage String script)