failure.assertThatCause(CoreMatchers.containsString("Received status code 500 from server: broken"))


        when:
        server.resetExpectations()
        then:
        executer.withArgument("--offline")
        run 'retrieve'
        and:
        file('libs/projectA-1.0-SNAPSHOT.jar').assertIsCopyOf(module.artifact.file)
    }

    @ToBeFixedForConfigurationCache

                artifacts {
                    compile file: file('thing.txt'), builtBy: { throw new RuntimeException('broken') }
                }
            }
"""

        expect:
        executer.withArgument("--dry-run")
        fails("useCompileConfiguration")
        failure.assertHasDescription("Could not determine the dependencies of task ':useCompileConfiguration'.")
        failure.assertHasCause('broken')

        executer.beforeExecute {
            def initScript = file("init.gradle")
            initScript.text = buildLogicForMinimumBuildTime(minimumBuildTimeMillis)
            withArgument("-I").withArgument(initScript.absolutePath)
        }
    }

    protected int getMinimumBuildTimeMillis() {
        2000
    }

    protected void withoutContinuousBuild() {
        withoutContinuousArg = true

            executer.withArgument("-D${projectName}OutputDir=${buildDirPath}")
        }

        void setOutputFileName(String outputFileName) {
            executer.withArgument("-D${projectName}FileName=${outputFileName}")
        }

        void setOutputDirName(String outputDirName) {
            executer.withArgument("-D${projectName}DirName=${outputDirName}")
        }

        expectEvent("block")
        def client = new DaemonClientFixture(executer.withArgument("--debug").withTasks("block").start())
        waitFor("started")
        daemons.daemon.assertBusy()
        client.kill()
        daemons.daemon.becomesCanceled()

        when:
        def build = executer.withTasks("help").withArguments("--info").start()
        ConcurrentTestUtil.poll {

                    bar
                }

                dependencies {
                    bar "test:test-jar:1.0"
                }
            }
        """
        executer.withArgument("--parallel")

        expect:

        then:
        resolve.expectGraph {
            root(":", ":test:") {
                module("org:default-dependency:1.0")
            }
        }

        when:
        executer.withArgument("-DexplicitDeps=yes")
        run "checkDeps"

        then:
        resolve.expectGraph {
            root(":", ":test:") {
                module("org:explicit-dependency:1.0")
            }
        }

        executedAndNotSkipped(":someTask")

        // Change to different value
        when:
        buildFile.replace('new CustomType("value1 ignore me")', 'new CustomType("value2")')
        executer.withArgument("-i")
        run "someTask"

        then:
        executedAndNotSkipped(":someTask")
        outputContains("Value of input property 'someValue' has changed for task ':someTask'")

        when:

                        tasks.create(name, SerialPing)
                    }
                }
            }
        """
        executer.beforeExecute {
            withArgument('--info')
        }
    }

    void withInvalidPing() {
        buildFile << """
            abstract class InvalidPing extends Ping {

            }
        }

        when:
        server.resetExpectations()
        m.pom.expectHead()
        m.moduleMetadata.expectHead()
        m.artifact.expectHead()

        executer.withArgument("--refresh-dependencies")
        run("checkDeps")

        then:
        resolve.expectGraph {
            root(":", ":test:") {
                module("test:a:1.2")
            }
        }
    }