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)

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

            return empty();
        }
        return rootNode.invalidate(relativePath, caseSensitivity, diffListener)
            .<SnapshotHierarchy>map(it -> it == rootNode
                ? this
                : new DefaultSnapshotHierarchy(it, caseSensitivity))
            .orElseGet(() -> empty(caseSensitivity));
    }

    @Override
    public SnapshotHierarchy empty() {
        return empty(caseSensitivity);

    public static final StrictVersionConstraints EMPTY = new StrictVersionConstraints() {
        @Override
        public final StrictVersionConstraints union(StrictVersionConstraints other) {
            return other;
        }

        @Override
        public final StrictVersionConstraints intersect(StrictVersionConstraints other) {
            return EMPTY;
        }

        @Override

// CHECK-NEXT:        name: "main"
// CHECK-NEXT:      } ],
// CHECK-NEXT:      description: "MLIR Converted.",
// CHECK-NEXT:      buffers: [ {
// CHECK-EMPTY:
// CHECK-NEXT:      }, {
// CHECK-EMPTY:
// CHECK-NEXT:      }, {
// CHECK-EMPTY:
// CHECK-NEXT:      }, {
// CHECK-EMPTY:
// CHECK-NEXT:      }, {
// CHECK-NEXT:        data: [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
// CHECK-NEXT:      } ],

     * Even if empty string, treated as empty plainly. So "IF pmb != null" is false if empty.
     * @param hostname The parameter value of hostname. (NotNull)
     */
    public void setHostname(String hostname) {
        registerVariable("hostname", hostname);
    }

    /**
     * Set the value of clustername, used in parameter comment. <br>