when:
        configurationCacheRun 'build', '-I', initScript1.absolutePath, '-I', initScript2.absolutePath

        then:
        output.indexOf('initscript1!') < output.indexOf('initscript2!')
        configurationCache.assertStateStored()

        when:
        configurationCacheRun 'build', '-I', initScript2.absolutePath, '-I', initScript1.absolutePath

        then:

        assert rootProject.projectDir == testDirectory.absolutePath
        assert rootProject.buildFile == buildFile.absolutePath
        assert rootProject.children.size() == 3 // All projects are created when storing
        with(rootProject.children.first() as Map<String, Object>) {
            assert name == 'a'
            assert path == ':a'
            assert projectDir == file('a').absolutePath

        }

        private static String removeTrailingSeparator(String absolutePath) {
            if (absolutePath.equals("/")) {
                absolutePath = "";
            } else if (absolutePath.endsWith(File.separator)) {
                absolutePath = absolutePath.substring(0, absolutePath.length() - 1);
            }
            return absolutePath;
        }

        @Override

        when:
        run "run", "-PinputFile=${inputFile.absolutePath}", "-PoutputFile=${outputFile.absolutePath}"
        then:
        executedAndNotSkipped ":run"

        when:
        def secondInputFile = file("second-input.txt")
        secondInputFile.text = inputFile.text
        run "run", "-PinputFile=${secondInputFile.absolutePath}", "-PoutputFile=${outputFile.absolutePath}"
        then:
        outputFile.text == "first"

        then:
        executedAndNotSkipped(":compileJava")
        outputContains("Compiling with toolchain '${jdk.javaHome.absolutePath}'")
        outputContains("Compiling with Java command line compiler '${jdk.javaExecutable.absolutePath}'")
        classJavaVersion(javaClassFile("Foo.class")) == jdk.javaVersion

        // Test up-to-date checks
        when:
        withInstallations(jdk, otherJdk).run(":compileJava")
        then:

            locations.size() == 1
            with(oneLocation(LineInFileLocation)) {
                length == -1
                column == -1
                line == 11
                path == "build file '$buildFile.absolutePath'"
            }
        }
    }

    def "can emit a problem with minimal configuration"() {
        given:
        withReportProblemTask """
            problems.forNamespace('org.example.plugin').reporting {

        javaCompile.options.forkOptions.executable = executableDir.absolutePath
        javaCompile.createSpec()

        then:
        def e = thrown(AbstractProperty.PropertyQueryException)
        def cause = TestUtil.getRootCause(e) as InvalidUserDataException
        cause.message.contains("The configured executable is a directory")
        cause.message.contains(executableDir.absolutePath)
    }

                    (BinaryCompatibilityRepositorySetupRule.Params.sourceCompilationClasspath): newClasspath.collect { it.absolutePath } as Set
                ])
                addSetupRule(UpgradePropertiesRuleSetup, [
                    currentUpgradedProperties: currentUpgradedPropertiesFile.absolutePath,

        def gradleUserHome = testDirectory.file('some-custom-user-home')

        when:
        def executer = wrapperExecuter.withGradleUserHomeDir(null)
        executer.withArguments("-Dgradle.user.home=$gradleUserHome.absolutePath")
        executer.run()

        then:
        installationIn gradleUserHome
    }

    @Issue('https://issues.gradle.org/browse/GRADLE-2802')
    void 'uses gradle user home set by -g'() {
        given:

    def "problems are received when a multi-file compilation failure happens"() {
        given:
        possibleFileLocations.put(writeJavaCausingTwoCompilationErrors("Foo").absolutePath, 2)
        possibleFileLocations.put(writeJavaCausingTwoCompilationErrors("Bar").absolutePath, 2)

        when:
        fails("compileJava")

        then:
        verifyAll(receivedProblem(0)) {
            assertProblem(it, "ERROR", true)