expect:
        executer.withBuildJvmOpts("-Dfoo.bar=baz").withTasks("verify").run()
    }


    def "forks new daemon when file encoding set to different value via commandline"() {
        setup:
        buildScript """
            task verify {
                doFirst {
                    println "verified = " + java.nio.charset.Charset.defaultCharset().name()
                }
            }
        """

        when:

        then:
        project.buildScript.sourceFile == buildFile

        when:
        def custom = file('gradle/my-project.gradle') << '//empty'
        file('settings.gradle') << "rootProject.buildFileName = 'gradle/my-project.gradle'"
        project = withConnection { it.getModel(GradleProject.class) }

        then:
        project.buildScript.sourceFile == custom
    }

    def "copy task uses platform charset to filter text files by default"() {
        given:
        file('files').createDir()
        file('files/accents.c').write('éàüî $one', 'ISO-8859-1')
        buildScript """
            task (copy, type: Copy) {
                from 'files'
                into 'dest'
                expand(one: 1)
            }
        """.stripIndent()

        task = TestUtil.createTask(BuildEnvironmentReportTask.class, project)
    }

    def "renders only classpath build script configuration"() {
        given:
        project.buildscript.configurations.create("conf1")
        project.buildscript.configurations.create("conf2")

        when:
        task.setRenderer(renderer)
        task.generate()

        then:

@UnsupportedWithConfigurationCache(because = "software model")
class ManagedTypeWithUnmanagedPropertiesIntegrationTest extends AbstractIntegrationSpec {

    def "can have unmanaged property of unsupported types"() {
        when:
        buildScript '''
            class UnmanagedThing {
              String value
            }
            class MyFile extends File {
              MyFile(String s) { super(s) }
            }

            @Managed

        plugin.assertAutoApplied(output, false)
    }

    def "is not auto-applied when added to classpath via buildscript block"() {
        given:
        def coordinates = "${groupId}:${artifactId}:${plugin.runtimeVersion}"
        settingsFile << """
            buildscript {
                repositories {
                    maven { url '${mavenRepo.uri}' }
                }
                dependencies {

    @Requires(IntegTestPreconditions.NotConfigCached)
    def "generates build lifecycle operations for included build used as buildscript and production dependency"() {
        given:
        buildA.buildFile.prepend("""
            buildscript {
                dependencies {
                    classpath 'org.test:b1:1.0'
                }
            }
        """)

                    ?.singleSectionOf(TopLevelBlockId.plugins)
                    ?.let { sourceWithoutComments.fragment(it) }

            val buildscript =
                buildscriptFragment?.takeIf { it.isNotBlank() }?.let(Program::Buildscript)

            val pluginManagement =
                pluginManagementFragment?.takeIf { it.isNotBlank() }?.let(Program::PluginManagement)

            val plugins =

    }

    def "tasks added via task container and not explicitly required but executed are self closed"() {
        given:
        buildScript """
            ${ruleBasedTasks()}

            class Rules extends RuleSource {
                @Mutate
                void configureDependencyTask(@Path("tasks.dependency") EchoTask task) {

        def buildScript = """
            tasks.register('executionCredentials') {
                def providers = project.providers
                doLast {
                    providers.credentials($credentialsType, 'test').get()
                }
            }
        """
        file('submodule1/build.gradle') << buildScript
        file('submodule2/build.gradle') << buildScript