def "emits operation for task execution"() {
        when:
        buildScript """
            task t {}
        """
        succeeds "t"

        then:
        assertResolveTaskMutationsBuildOperationEmitted(":t")
    }

    def "emits operation for failed task execution"() {
        when:
        buildScript """
            task t {
                doLast {

            LocaleUtils.toLocale("ja_JP"),
            LocaleUtils.toLocale("hr_HR")
    ].findAll {
        it != Locale.default
    }

    def "custom locale is applied to daemon"() {

        buildScript """
            task printLocale {
                doFirst {
                    println "defaultLocale: " + Locale.default
                }
            }
        """

        when:

        buildFile << """
            buildscript {
                repositories {
                    maven { url "${mavenRepo.uri}" }
                }
                dependencies {
                    classpath 'org:toplevel1:1.0'
                }
            }

            project(":impl") {
                buildscript {
                    repositories {

    }

    def "error loading plugin"() {
        pluginBuilder.addUnloadablePlugin(PLUGIN_ID)
        pluginBuilder.publishAs(GROUP, ARTIFACT, VERSION, pluginRepo, executer).allowAll()

        buildScript applyPlugin()

        expect:
        fails("verify")
        failure.assertThatDescription(startsWith("An exception occurred applying plugin request [id: 'org.my.myplugin', version: '1.0']"))

public abstract class FirstPassPrecompiledScript extends PluginsAwareScript {

    @SuppressWarnings("rawtypes")
    @Override
    public void buildscript(Closure configureClosure) {
        throw new IllegalStateException("The `buildscript` block is not supported in Groovy script plugins. Use the `plugins` block or project level dependencies instead.");
    }

        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