when:
        container.named("a").configure(method)
        then:
        noExceptionThrown()

        when:
        container.named("a", method)
        then:
        noExceptionThrown()

        when:
        container.named("a", getType(), method)
        then:
        noExceptionThrown()

        when:

// error returned in IAM subsystem when user doesn't exist.
var errNoSuchUser = errors.New("Specified user does not exist")

// error returned by IAM when a use a builtin IDP command when they could mean
// to use a LDAP command.
var errNoSuchUserLDAPWarn = errors.New("Specified user does not exist. If you meant a user in LDAP please use command under `mc idp ldap`")

// error returned when service account is not found

        expect:
        broadcast.type == TestListener
    }

    def 'source object does nothing when no listeners are added'() {
        expect:
        broadcast.source.event1("param")
    }

    def 'visit listeners does nothing when no listeners are added'() {
        def visitor = Mock(Action)

        when:
        broadcast.visitListeners(visitor)

        then:
        0 * visitor._
    }

            apply plugin: 'java'
        """
    }

    def "can build when no source dir present"() {
        when:
        assert !file("src/main/java").exists()

        then:
        succeeds("build")
        skipped(":compileJava")
        executed(":build")
    }

    def "can build when source dir is removed"() {
        when:
        file("src/main/java/Thing.java") << "class Thing {}"

        then:

            }
        """
        when:
        withBuildCache().run "jacocoTestReport"
        then:
        executedAndNotSkipped ":test", ":jacocoTestReport"
        reportFile.assertIsFile()

        when:
        succeeds "clean"
        then:
        reportFile.assertDoesNotExist()

        when:
        withBuildCache().run("integrationTest", "jacocoIntegrationTestReport")

    def onOutputWritesText() {
        when:
        output.onOutput('some message')

        then:
        output.value == 'some message'
    }

    def writesNullText() {
        when:
        output.text(null)

        then:
        output.value == 'null'
    }

    def writesEndOfLine() {
        when:
        output.println()

        then:

    def "setup"() {
        settingsFile << "rootProject.name = 'projectConfigure'"
    }

    def "produces reasonable error message when Gradle.beforeProject closure fails"() {
        when:
        settingsFile << """
    gradle.beforeProject {
        throw new RuntimeException("beforeProject failure")
    }
"""
        buildFile << """
    task test
"""
        then:

        publication.addCandidate(jar)

        then:
        publication.defaultArtifactProvider.get() == set(jar)

        when:
        publication.addCandidate(ear)

        then:
        publication.defaultArtifactProvider.get() == set(ear)

        when:
        publication.addCandidate(jar)

        then:
        publication.defaultArtifactProvider.get() == set(ear)
    }

        methods: ["l7-method"]
  # L4 and L7 when
  - when:
    - key: "source.namespace"
      values: ["when-l4-l7-ns"]
    - key: "connection.sni"
      values: [ "when-l4-l7-sni"]
  # L4 only when
  - when:
    - key: "source.namespace"
      values: ["when-l4-ns"]
    - key: "source.ip"
      values: ["10.10.10.10"]
      notValues: ["20.20.20.20"]
  # L7 only when
  - when:
    - key: "connection.sni"

    }

    def "can run tasks via tooling API when configuration cache is enabled"() {
        buildFile << """
            plugins {
                id("java")
            }
            println("script log statement")
        """

        when:
        configurationCacheRun("assemble")

        then:
        outputContains("script log statement")

        when:
        configurationCacheRun("assemble")