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"

    }

    @ToBeFixedForConfigurationCache
    def "visual studio tasks re-execute when source files are added"() {
        app.writeSources(file("src/main"))

        when:
        run "visualStudio"

        then:
        executedAndNotSkipped ":appVisualStudioSolution"
        executedAndNotSkipped getComponentTasks("main")

        when:

    }

    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")

        noExceptionThrown()
    }

    def "throws exception when attempting to use service after it has stopped"() {
        when:
        lifecycle.stop()
        lifecycle.use { }

        then:
        IllegalStateException e = thrown()
        e.message == 'Cannot use [service] as it has been stopped.'
    }

    def "throws exception when attempting to use service after stop has been requested"() {
        when:

        then:
        thrown(IllegalStateException)
    }

    def "cannot get meta-data when has no result"() {
        when:
        descriptor.metaData

        then:
        thrown(IllegalStateException)
    }

    def "cannot get authoritative flag when has no result"() {
        when:
        descriptor.authoritative

        then:
        thrown(IllegalStateException)
    }

    def "prevents time from going backwards"() {
        when:
        setNanos 0

        then:
        clock.currentTime == START_MILLIS + 0

        when:
        setNanos 10

        then:
        clock.currentTime == START_MILLIS + 10

        when:
        setNanos 8

        then:
        clock.currentTime == START_MILLIS + 10

        when:
        setNanos 10

        then:

    def "cannot get artifacts when no result specified"() {
        when:
        result.result

        then:
        IllegalStateException e = thrown()
        e.message == 'No result has been specified.'
    }

    def "cannot get failure when no result specified"() {
        when:
        result.failure

        then:
        IllegalStateException e = thrown()

        when:
        generator.started(operation, startEvent)

        then:
        0 * _

        when:
        generator.progress(operationId, progressEvent)

        then:
        0 * _

        when:
        generator.finished(operation, finishEvent)

        then:
        0 * _
    }