backingServer.expectGetBlocking('/redirected/group/projectA/1.0/ivy-1.0.xml')

        then:
        executer.beforeExecute { withArgument("-D${SOCKET_TIMEOUT_SYSTEM_PROPERTY}=1000") }
        fails('listJars')

        and:
        failureCauseContains("Could not get resource '${server.uri}/repo/group/projectA/1.0/ivy-1.0.xml'")

        textFile.text = "text file as root"

        outputs.snapshot { run language.compileTaskName }

        when:
        file("extra/B.${language.name}").text = "class B { String change; }"
        executer.withArgument "--info"
        run language.compileTaskName

        then:
        outputs.recompiledClasses("A", "B", "C")

                    new Thing();
                }
            }
        """

        when:
        executer.beforeExecute({
            withArgument("-Porg.gradle.java.installations.paths=" + jvm.getJavaHome().getAbsolutePath())
        })
        fails("build")

        then:
        failure.assertHasDescription("Execution failed for task ':compileJava'.")

        and:
        writeBuildFile()
        failedResolve.prepare()

        when:
        module.allowAll()

        and:
        executer.withArgument("-Dhttps.protocols=TLSv1.3")

        then:
        fails('checkDeps')
        failedResolve.assertFailurePresent(failure)
    }

    def writeBuildFile() {
        buildFile << """

                    new CountDownLatch(1).await();
                }
            }
        """
    }

    private void startBuild(String task, boolean buildCacheEnabled) {
        executer.withArgument('--debug').withTasks(task)
        if (buildCacheEnabled) {
            executer.withBuildCacheEnabled()
        }

        client = new DaemonClientFixture(executer.start())

    }

    def "can enable from the command line even if it's disabled in gradle.properties"() {
        setup:
        file('gradle.properties') << 'org.gradle.logging.stacktrace=internal'
        executer.withArgument('--stacktrace')

        when:
        fails()

        then:
        assertCauseWithStacktrace('show stacktrace was ALWAYS')
    }

    def "emits actionable message when wrong configuration is used"() {

    fun configureProjectAndExpectCompileAvoidanceWarnings(vararg tasks: String): BuildOperationsAssertions {
        val buildOperations = BuildOperationsFixture(executer, testDirectoryProvider)
        val output = executer.withArgument("--info").withTasks(*tasks).run().normalizedOutput
        return BuildOperationsAssertions(buildOperations, output, true)
    }

    protected

         """

        and:
        file("src/main/cpp/includingIoStream.cpp") << """
            #include <stdio.h>
            #include <iostream>
        """

        when:
        executer.withArgument("--info")
        run "assemble"

        then:
        output.contains("Found all include files for ':compileDebugCpp'")
    }

    @ToBeFixedForConfigurationCache

        """
    }

    def "restores only projects that have work scheduled"(List<String> tasks) {
        def fixture = new BuildOperationsFixture(executer, temporaryFolder)
        executer.beforeExecute {
            withArgument("-Dorg.gradle.configuration-cache.internal.load-after-store=true")
        }
        createDirs("a", "b", "c", "custom")
        settingsFile << """
            rootProject.name = 'thing'
            include 'a', 'b', 'c'

}

"""

        when:
        executer.withArgument("-Dprop=123")
        run("thing")

        then:
        executedAndNotSkipped(":thing")

        when:
        executer.withArgument("-Dprop=123")
        run("thing")

        then:
        skipped(":thing")

        when:
        executer.withArgument("-Dprop=abc")
        run("thing")

        then: