snapshotA.metaData.expectHead()
        snapshotA.pom.expectHead()
        snapshotA.artifact.expectHead()
        snapshotA.artifact.expectGet()

        and:
        executer.withArgument('-PskipCache')
        run 'retrieve'

        then:
        executed ':retrieve'
        file('libs').assertHasDescendants('projectA-1.1-SNAPSHOT.jar')

        // Jar artifact removal is detected

                }
            }
        """
    }

    def runWithToolchainConfigured(Jvm jvm) {
        result = executer
            .withArgument("-Porg.gradle.java.installations.paths=" + jvm.javaHome.absolutePath)
            .withTasks("check", "javadoc")
            .run()
    }

    private static String testClass(String className) {
        return """

            }
        """
        sftpServer.expectLstat("/")
        def sync = coordinator.expectAndBlock('sync')

        when:
        def gradle = executer.withTasks('reuseClient').withArgument("--info").start()
        sync.waitForAllPendingCalls()

        then:
        sftpServer.clearSessions()
        sftpServer.expectLstat("/")
        sleep(1000)

        when:
        sync.releaseAll()

    def 'task skipped by #condition reports "#reason"'() {
        buildFile("""
            tasks.register("task") {
                $condition
            }
        """)

        when:
        executer.withArgument("--info")
        succeeds(":task")

        then:
        assertTaskSkippedWithMessage(reason, ":task")

        where:

        gradleExecuterFor(arrayOf("check", "publish"), rootDir = file("plugin"))
            .withJavaHome(currentJvm.javaHome)
            .withArgument("-Porg.gradle.java.installations.paths=$installationPaths")
            .run()

        withSettingsIn("consumer", """
            pluginManagement {
                repositories {

                }

                @TaskAction
                public void doStuff() { }
            }
        """

        expect:
        executer.withArgument("-Dorg.gradle.internal.max.validation.errors=10")
        assertValidationFailsWith([

                @Nested
                public NestedBean getNestedBean() { return nested; }
            }
        """

        expect:
        executer.withArgument("-Dorg.gradle.internal.max.validation.errors=7")
        assertValidationFailsWith([

            }
        }
    }

    private static void setMavenLocalLocation(GradleExecuter gradleExecuter, File destination) {
        gradleExecuter.withArgument("-Dmaven.repo.local=${destination?:''}" )
    }

        // Change the values of the property
        when:
        buildFile.replace("[BuildSrcEnum.E1, ScriptEnum.E1, pluginValue] as $type", "[BuildSrcEnum.E2, pluginValue] as $type")

        and:
        executer.withArgument("-i")
        run "someTask"

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

        when:

.*"""
    }

    def "outcome for successful build is not logged with --quiet"() {
        given:
        buildFile << """
            task success
        """

        when:
        executer.withArgument("--quiet")
        succeeds('success')

        then:
        result.assertNotOutput("BUILD SUCCESSFUL")
        result.assertNotOutput("actionable task")
    }