and:
        executer.beforeExecute {
            if (!GradleContextualExecuter.embedded) {
                executer.withArgument("-D$REUSE_USER_HOME_SERVICES=true")
            }
        }
        executer.withTasks('help').start().waitForFinish()

        then:
        resource.assertDoesNotExist()

        succeeds("showMissing")

        when:
        moduleInRepo1.publish()
        server.resetExpectations()
        then:
        succeeds("showMissing")

        when:
        executer.withArgument("--refresh-dependencies")
        moduleInRepo1.ivy.expectHead()
        moduleInRepo1.ivy.sha1.expectGet()
        moduleInRepo1.jar.expectHead()
        moduleInRepo1.jar.sha1.expectGet()

        then:

    def setup() {
        server.start()

        setupBuild(new BuildTestFile(testDirectory, "root"))

        executer.beforeExecute {
            withArgument("--max-workers=10")
        }
    }

    private void setupBuild(BuildTestFile buildTestFile) {
        buildTestFile.with {
            settingsFile << """
                rootProject.name = '${rootProjectName}'

                    username = "correct-username"
                    password = "correct-password"
                }
            }
        """

        when:
        executer.withArgument("--info")
        withBuildCache().run "assemble"
        then:
        outputDoesNotContain("correct-username")
        outputDoesNotContain("correct-password")
    }

        dependencies = parseIml("two/two.iml").dependencies
        assert dependencies.libraries*.jarName as Set == [someLib2Jar.name] as Set

        executer.withArgument("-PstrictDeps=true").withTasks("idea").run()

        //then
        dependencies = parseIml("one/one.iml").dependencies
        assert dependencies.modules.size() == 1

        outputs.snapshot { run "mainExecutable" }

        when:
        directoryHeader.deleteDir()
        directoryHeader << '#pragma message("NEW directory named header")'
        and:
        executer.withArgument("--info")
        run "mainExecutable"
        then:
        executedAndNotSkipped compileTask
        and:
        outputs.recompiledFile sourceFile
        outputContains("NEW directory named header")

        given:
        buildFile << publicationBuildWithoutCredentials(version, group, mavenRemoteRepo.uri)

        if (!extraChecksums) {
            executer.withArgument("-Dorg.gradle.internal.publish.checksums.insecure=true")
            module.withoutExtraChecksums()
        }
        expectModulePublish(module, extraChecksums)

        when:
        succeeds 'publish'

        // In a nutshell, this tests that we don't even try to load classes that are there, but that we shouldn't see.

        when:
        executer
            .withArgument("-Porg.gradle.java.installations.paths=${AvailableJavaHomes.getAvailableJvms().collect { it.javaHome.absolutePath }.join(",")}")
            .withToolchainDetectionEnabled()
        buildFile << """
            plugins {

        given:
        buildFile << publicationBuildWithoutCredentials(version, group, ivyHttpRepo.uri)

        if (!extraChecksums) {
            executer.withArgument("-Dorg.gradle.internal.publish.checksums.insecure=true")
            module.withoutExtraChecksums()
        }

        and:
        module.jar.expectPut()
        module.jar.sha1.expectPut()

        setupProjectInDir(projectDir2)
        executer.requireIsolatedDaemons()
        executer.beforeExecute {
            if (!GradleContextualExecuter.embedded) {
                executer.withArgument("-D$REUSE_USER_HOME_SERVICES=true")
            }
        }

        when:
        executer.inDirectory(projectDir1)
        succeeds ":util:resolve", ":app:resolve"

        then: