configurations.customRuntimeClasspath.state.toString()
    }
    doLast {
        assert customCompileClasspathState.get() == "UNRESOLVED"
        assert customRuntimeClasspathState.get() == "UNRESOLVED"
    }
}
        """

        expect:
        succeeds("verify")
    }

    def "not specifying a groovy runtime produces decent error message"() {
        given:
        buildFile << """

                doLast {
                    assert configurations.customCompileClasspath.state.toString() == "UNRESOLVED"
                    assert configurations.customRuntimeClasspath.state.toString() == "UNRESOLVED"
                }
            }
        """

        expect:
        succeeds("verify")
    }

    def "not specifying a scala runtime produces decent error message"() {
        given:

        expect:
        buildSucceeds """
assert providers.systemProperty('some-prop').get() == 'some-value'
assert java.lang.management.ManagementFactory.runtimeMXBean.inputArguments.contains('-Xmx64m')
        """
    }

    def "shows decent message when awkward java home used"() {
        def dummyJdk = file("dummyJdk").createDir()
        assert dummyJdk.isDirectory()

        when:

        given:
        file('build.gradle') << """
task foo { doLast { assert false } }
task bar { doLast { assert true } }
"""

        when:
        withConnection {
            it.newBuild().forTasks('foo').withArguments('bar').run()
        }

        then:
        noExceptionThrown()
    }

zirain <******@****.***> 1665678622 +0800

        def daemonDir = new File(baseDir, GradleVersion.current().version)
        assert daemonDir.exists()
        daemonDir.listFiles().findAll { it.name.endsWith('.log') }
    }

    String readLog(File baseDir) {
        def logs = getLogs(baseDir)

        //assert single log
        assert logs.size() == 1

        logs[0].text
    }

    void printAllLogs(File baseDir) {

        then:
        1 * mockRegistry.configure(_, _) >> { ModelActionRole role, ModelAction action ->
            assert role == ModelActionRole.Mutate
            assert action.subject == ModelReference.of(ComponentSpecFactory)
        }
        0 * _
    }

    def "decent error message for rule declaration problem - #descr"() {
        def ruleMethod = ruleDefinitionForMethod(methodName)

        when:
        apply(registration, mockRegistry)

        then:
        1 * mockRegistry.configure(_, _) >> { ModelActionRole role, ModelAction action ->
            assert role == ModelActionRole.Mutate
            assert action.subject == ModelReference.of(ComponentSpecFactory)
        }
        0 * _

        where:
        methodName                 | _
        "validTypeRule"            | _

        when:
        apply(registration, mockRegistry)

        then:
        1 * mockRegistry.configure(_, _) >> { ModelActionRole role, ModelAction action ->
            assert role == ModelActionRole.Defaults
            assert action.subject == ModelReference.of("binaries", BinaryContainer.class)
        }
        0 * _
    }

    static interface SomeBinarySpec extends BinarySpec {}

    class Rules {

        when:
        expectPublication()
        keyStore.configureServerAndClientCerts(executer)
        succeeds 'publish'

        then:
        verifyPublications()
    }

    def "decent error message when client can't authenticate server"() {
        keyStore.enableSslWithServerCert(server)
        initBuild()

        when:
        keyStore.configureIncorrectServerCert(executer)