this.projectName = projectName;
        }

        @Override
        public void execute(BuildEnvironmentReportTask task) {
            task.setDescription("Displays all buildscript dependencies declared in " + projectName + ".");
            task.setGroup(HELP_GROUP);
            task.setImpliesSubProjects(true);
        }
    }

    @SuppressWarnings("deprecation")

        expect:
        succeeds("compileGroovy")
    }

    def "cant compile against gradle base services"() {
        def gradleBaseServicesClass = Action
        buildScript """
            apply plugin: 'groovy'
            ${mavenCentralRepository()}
        """

        when:
        file("src/main/groovy/Groovy.groovy") << """

            lockFileReaderWriter.writeUniqueLockfile(allLockState);
            if (context.isScript()) {
                LOGGER.lifecycle("Persisted dependency lock state for buildscript of project '{}'", context.getProjectPath());
            } else {
                LOGGER.lifecycle("Persisted dependency lock state for project '{}'", context.getProjectPath());
            }
        }
    }

                is Program.PluginManagement -> emitStage1Sequence(program)
                is Program.Stage1Sequence -> emitStage1Sequence(program.pluginManagement, program.buildscript, program.plugins)
                else -> throw IllegalStateException("Expecting a residual program with plugins, got `$program'")
            }
        }
    }

    private

        def workActionJarName = "workAction.jar"
        withWorkActionClassInExternalJar(file(workActionJarName))

        buildFile << """
            buildscript {
                dependencies {
                    classpath files("$workActionJarName")
                }
            }

            task runInWorker(type: WorkerTask) {

    }

    // plugins do not publish signatures so we expect the checksums to be present
    def "writes checksums of plugins using buildscript block"() {
        given:
        addPlugin()
        buildFile << """
          buildscript {
             repositories {
                maven { url "${pluginRepo.uri}" }
             }
             dependencies {

                dependsOn gradle.includedBuild("buildB").task(":assemble")
            }
        """
        dependency buildB, "org.test:XXX:1.0"
        buildC.buildFile.text = """
            buildscript {
                repositories { maven { url = "${mavenRepo.uri}" } }
                dependencies { classpath "org.test:plugin:1.0" }
            }
        """ + buildC.buildFile.text

        includeBuild buildB

    static final String EMPTY_RESOLUTIONS_ENTRY = "empty=";
    static final String BUILD_SCRIPT_PREFIX = "buildscript-";
    static final String SETTINGS_SCRIPT_PREFIX = "settings-";

    private final Path lockFilesRoot;
    private final DomainObjectContext context;
    private final RegularFileProperty lockFile;

        file("build/output/file.txt").assertExists()
    }

    @Issue("https://github.com/gradle/gradle/issues/2180")
    def "fileTrees can be used as output files"() {
        given:
        buildScript """
            task myTask {
                inputs.file file('input.txt')
                outputs.files fileTree(dir: 'build', include: 'output.txt')
                def layout = project.layout

        val movedPluginJar = file("plugin.jar")
        pluginJar.renameTo(movedPluginJar)

        withDefaultSettings().appendText(
            """
            buildscript {
                dependencies {
                    classpath(files("${movedPluginJar.name}"))
                }
            }

            gradle.apply<MyInitPluginPlugin>()