then:
        result != null
    }

    def "class can be private and have public constructor"() {
        when:
        def result = instantiator.newInstance(PrivateWithValidConstructor, "param")

        then:
        result != null
    }

    def "wraps constructor failure"() {
        when:
        instantiator.newInstance(HasBrokenConstructor)

        then:

# build directive, in the build. Set it to 0 to ignore them.
#
# GO_EXTLINK_ENABLED: Set to 1 to invoke the host linker when building
# packages that use cgo.  Set to 0 to do all linking internally.  This
# controls the default behavior of the linker's -linkmode option.  The
# default value depends on the system.
#
# GO_LDSO: Sets the default dynamic linker/loader (ld.so) to be used
# by the internal linker.
#

        when:
        listener.onOutput(taskStartEvent)
        listener.onOutput(warningMessage)

        then:
        0 * downstreamListener._

        when:
        listener.onOutput(taskCompleteEvent)

        then:
        1 * downstreamListener.onOutput({ it.toString() == "[LIFECYCLE] [category] " })
        then:

        when:
        uncheckedClose(null)

        then:
        noExceptionThrown()

        when:
        closeQuietly(null)

        then:
        noExceptionThrown()
    }

    def "can close a valid resource"() {
        def resource = Mock(Closeable)

        when:
        uncheckedClose(resource)

        then:

        when:
        configurationCacheRun "a"

        then:
        result.assertTasksExecutedAndNotSkipped(":a")
        outputFile.assertIsFile()

        when:
        configurationCacheRun "a"

        then:
        result.assertTasksSkipped(":a")

        when:
        outputFile.delete()
        configurationCacheRun "a"

        then:

        when:
        inputs.property('a', 'value')

        then:
        inputs.hasInputs
        !inputs.hasSourceFiles
    }

    def hasInputsWhenEmptySourceFilesRegistered() {
        when:
        inputs.files([]).skipWhenEmpty()

        then:
        inputs.hasInputs
        inputs.hasSourceFiles
    }

    def hasInputsWhenSourceFilesRegistered() {
        when:

if [[ ${TARGET_ARCH} ]]; then
    # Target explicitly set
    :
elif [[ ${LOCAL_ARCH} == x86_64 ]]; then
    TARGET_ARCH=amd64
elif [[ ${LOCAL_ARCH} == armv8* ]]; then
    TARGET_ARCH=arm64
elif [[ ${LOCAL_ARCH} == arm64* ]]; then
    TARGET_ARCH=arm64
elif [[ ${LOCAL_ARCH} == aarch64* ]]; then
    TARGET_ARCH=arm64
elif [[ ${LOCAL_ARCH} == armv* ]]; then
    TARGET_ARCH=arm
elif [[ ${LOCAL_ARCH} == s390x ]]; then
    TARGET_ARCH=s390x

        then:
        def verificationFile = file("gradle/verification-metadata.xml")
        verificationFile.isFile()

        // TODO - get a false cache miss here because the content of the metadata file changes during the previous build
        when:
        configurationCacheRun("resolve1")

        then:
        configurationCache.assertStateStored()

        then:
        succeeds("build")
    }

    def "after compilation failure, fixing file retriggers build"() {
        when:
        def sourceFile = file("src/main/java/Thing.java") << "class Thing {} /* broken compile "

        then:
        fails("build")

        when:
        sourceFile << "*/"

        then:
        buildTriggeredAndSucceeded()
    }

    def "can run tests"() {
        when:

    }

    def 'fires end events when end processing fails'() {
        given:
        def failure = new RuntimeException()

        when:
        action.run()

        then:
        1 * resultProcessor.started(!null, !null)
        then:
        1 * processor.startProcessing(!null)
        then:
        1 * detector.run()
        then: