daemons(gradleVersion).daemons.size() == 1

        when:
        executer.withEnvironmentVars(GRADLE_OPTS: "-Dfile.encoding=ISO-8859-1");
        executer.withArgument("-i")
        run "verify"

        then:
        output.contains("verified = ISO-8859-1")
        daemons(gradleVersion).daemons.size() == 2
    }

                dependsOn broken2
                doLast {
                    broken2.configure { $config }
                }
            }
        """

        when:
        executer.withArgument("--continue")
        fails("broken1", "broken2", "broken3")

        then:
        failure.assertHasCause("Cannot call ${description} on task ':broken1' after task has started execution.")

        this.path = projectDir.testDirectory.file(operationsTraceName).absolutePath
        executer.beforeExecute {
            this.tree = null
            executer.withArgument("-D$BuildOperationTrace.SYSPROP=$path")
        }
    }

    @Override
    List<BuildOperationRecord> getRoots() {
        getTree().roots
    }

    List<BuildOperationRecord> getDanglingChildren() {

        given:
        // Do not drop the VFS in the first build, since there is only one continuous build invocation.
        // FileSystemWatchingFixture automatically sets the argument for the first build.
        executer.withArgument(FileSystemWatchingHelper.getDropVfsArgument(false))
        executer.beforeExecute {
            withWatchFs()
        }

        def numberOfFilesInVfs = 4 // source file, class file, JAR manifest, JAR file

@Requires(IntegTestPreconditions.CanPublishToS3)
class IvyPublishS3IntegrationTest extends AbstractIvyPublishIntegTest {
    @Rule
    public S3Server server = new S3Server(temporaryFolder)

    def setup() {
        executer.withArgument("-Dorg.gradle.s3.endpoint=${server.getUri()}")
    }

    def "can publish to an S3 Ivy repository"() {
        given:
        def ivyRepo = server.remoteIvyRepo

        snapshotModule.pom.sha1.expectGet()
        snapshotModule.pom.expectGet()
        snapshotSources.expectHead()
        snapshotSources.expectGet()

        then:
        executer.withArgument(execArg)
        succeeds("verifyRefresh")

        where:
        condition | execArg
        "with --refresh-dependencies" | "--refresh-dependencies"
        "when snapshot pom changes" | "-Pnocache"
    }

        executer.beforeExecute(new Action<GradleExecuter>() {
            void execute(GradleExecuter e) {
                if (server.running) {
                    e.withArgument("-D${PLUGIN_PORTAL_OVERRIDE_URL_PROPERTY}=${uri.toString()}")
                }
            }
        })
        executer
    }


    @Override
    Statement apply(Statement base, Description description) {

    }

    def "does not execute task actions when dry run specified on composite build"() {
        when:
        def result = executer.inDirectory(file(PROJECT_B_NAME)).withArgument("--dry-run").withTasks('compileJava').run()

        then:
        def strippedGroupedTaskOutput = result.groupedOutput.strippedOutput
        strippedGroupedTaskOutput.contains(':byeWorld SKIPPED')

        new MavenSftpRepository(server, '/repo')
    }

    def setup() {
        // SFTP test fixture does not handle parallel resolution requests
        executer.beforeExecute {
            it.withArgument("--max-workers=1")
        }
    }

    def "can publish to a SFTP repository"() {
        given:
        def mavenSftpRepo = getMavenSftpRepo()

        switch (enablement) {
            case CCDebugEnablement.DEBUG_LOG_LEVEL:
                withDebugLogging()
                break
            case CCDebugEnablement.SYSTEM_PROPERTY:
                executer.withArgument "-D$ConfigurationCacheDebugOption.PROPERTY_NAME=true"
                break
            case CCDebugEnablement.GRADLE_PROPERTIES_FILE: