def "creates an empty set that does nothing"() {
        expect:
        def set = ImmutableActionSet.empty()
        set.execute("value")
        set.empty
    }

    def "can add no-op action to empty set"() {
        expect:
        def set = ImmutableActionSet.empty().add(Actions.doNothing())
        set.is(ImmutableActionSet.empty())
    }

    def "can add empty set to empty set"() {

    def context = [:] as DaemonContext

    def address(value) {
        [key: value] as Address
    }

    def "initially empty"() {
        expect:
        all.empty
        idle.empty
        notIdle.empty
    }

    def "lifecycle"() {
        given:
        store(new DaemonInfo(address(10), context, "password".bytes, Idle))

        !stream2.forCurrentCaller().stack.empty
        !stream2.forCurrentCaller().stack.empty
        stream2.forCurrentCaller().stack.empty

        stream1.forCurrentCaller().stack.empty
    }

    def "keeps stack trace after limit has been reached when diagnostics constructed from exception"() {
        given:
        def stream = factory.newStream()
        stream.forCurrentCaller()

go version -m internal.exe
stdout -buildmode=pie
stdout '^\tpath\trsc.io/fortune'
stdout '^\tmod\trsc.io/fortune\tv1.0.0'

-- go.mod --
module m

-- empty.go --
package main
func main(){}

-- empty.txt --
-- empty.exe --
-- empty.so --

    def "factory method returns empty when no non-empty sets provided"() {
        expect:
        CompositeResolvedArtifactSet.of([]) == ResolvedArtifactSet.EMPTY
        CompositeResolvedArtifactSet.of([ResolvedArtifactSet.EMPTY, ResolvedArtifactSet.EMPTY]) == ResolvedArtifactSet.EMPTY
    }

    def "factory method returns single set when single non-empty sets provided"() {
        def set = Mock(ResolvedArtifactSet)

import org.junit.Test


class PartialEvaluatorTest {

    @Test
    fun `Project target - top-level - empty`() {

        assertThat(
            "reduces to static program that applies default plugin requests and base plugins",
            partialEvaluationOf(
                Program.Empty,
                ProgramKind.TopLevel,
                ProgramTarget.Project
            ),
            isResidualProgram(

                        '/foo/empty': new DefaultFileSystemLocationFingerprint('/foo/empty', FileType.Directory, TestHashCodes.hashCodeFrom(123)),
                        '/foo/empty/empty': new DefaultFileSystemLocationFingerprint('/foo/empty/empty', FileType.Directory, TestHashCodes.hashCodeFrom(123)),

// CHECK-NEXT:       builtin_options_type: AddOptions,
// CHECK-NEXT:       builtin_options: {
// CHECK-EMPTY:
// CHECK-NEXT:       }
// CHECK-NEXT:     } ]
// CHECK-NEXT:    name: "main"
// CHECK-NEXT:   } ],
// CHECK-NEXT:   description: "MLIR Converted.",
// CHECK-NEXT:   buffers: [ {
// CHECK-EMPTY:
// CHECK-NEXT:   }, {
// CHECK-EMPTY:
// CHECK-NEXT:   }, {

        then:
        result.tasks.collect { it.path } == [':cacheable']
        result.taskPaths(SUCCESS) == [':cacheable']
        result.taskPaths(SKIPPED).empty
        result.taskPaths(UP_TO_DATE).empty
        result.taskPaths(FAILED).empty
        result.taskPaths(FROM_CACHE).empty

        when:
        file("build").deleteDir()
        result = runner('cacheable').build()
        then:
        file("build/output").text == "done"

        expect:
        initialRoot.invalidate(searchedPath, CASE_SENSITIVE, diffListener).get() is initialRoot
        removedNodes.empty
        addedNodes.empty

        where:
        vfsSpec << (NO_COMMON_PREFIX + COMMON_PREFIX).findAll { allowEmptyChildren || !it.childPaths.empty }
    }

    def "store #fileType child with common prefix adds a new child with the shared prefix of type Directory (#vfsSpec)"() {