1 * client.execute(spec) >> new DefaultWorkResult(true, null)

        then:
        1 * clientsManager.release(client)
    }

    def "idle client is reused when daemon is executed"() {
        when:
        factory.getWorker(requirement).execute(spec)

        then:
        1 * clientsManager.reserveIdleClient(options) >> client

        then:

    }

    def "reuses dependency instances"() {
        when:
        def out = parse(GRADLE_API)

        then:
        out instanceof DefaultFileCollectionDependency

        when: // same instance is reused
        def out2 = parse(GRADLE_API)

        then:
        out2.is out
    }

    def "assigns component identifier to dependency"() {
        expect:
        def dep = parse(notation)

                cacheAction == LOAD && !hasProblems -> log("Configuration cache entry reused.")
                cacheAction == LOAD -> log("Configuration cache entry reused with {}.", problemCountString)
                hasTooManyProblems -> log("Too many configuration cache problems found ({}).", problemCountString)

// type, but not pointer-identical types. See issue 65783.

func spillSlotReuse() {
	// The return values of getp1 and getp2 need to be
	// spilled around the calls to nopInt. Make sure that
	// spill slot gets reused.

	//arm64:`.*autotmp_2-8\(SP\)`
	getp1()[nopInt()] = 0
	//arm64:`.*autotmp_2-8\(SP\)`
	getp2()[nopInt()] = 0
}

//go:noinline
func nopInt() int {
	return 0
}

//go:noinline

            case Kind.ADD_RESOURCE:
                writeResource "42"
                break
        }
    }

    String getExpectedCacheInvalidationMessage() {
        "configuration cache cannot be reused because an input to task ':${projectDir.name}:$invalidatedTaskName' has changed."
    }

    String getInvalidatedTaskName() {
        switch (kind) {
            case Kind.CHANGE_RESOURCE:

However, it is likely that many of those tasks will have been run with exactly the same inputs in a prior CI build, populating the build cache; the outputs from those prior runs can safely be reused, resulting in dramatic build performance improvements.

=== Reusing CI builds for local development

     * http://cwiki.apache.org/confluence/display/MAVEN/ConnectException
     * </p>
     */
    @Test
    void testJdk7ipv6() {
        ConnectException connEx = new ConnectException("Connection refused: connect");
        IOException ioEx = new IOException("Unable to establish loopback connection", connEx);
        MojoExecutionException mojoEx =

// did). It turns out this is actually fine if all the threads
// in the trace have unique IDs, since the P just stays associated
// with an eternally dead thread, and it's stolen by some other
// thread later. But if thread IDs are reused, then the tracer
// gets confused when trying to advance events on the new thread.
// The now-dead thread which exited on a GoDestroySyscall still has
// its P associated and this transfers to the newly-live thread

        synchronized(lock) {
            if (scopeSpecs.containsKey(childId)) {
                // scope is being reused
                return
            }

            val parentIsRoot = parentId.parent == null
            val parent = if (parentIsRoot) {
                null
            } else {

        result.afterExecutionOutputState.get().originMetadata.buildCacheKey == buildCacheKey
        result.afterExecutionOutputState.get().originMetadata.executionTime >= result.duration
        !result.afterExecutionOutputState.get().reused
        assertOperation()

        1 * delegate.execute(work, _) >> delegateResult

        then:
        1 * outputSnapshotter.snapshotOutputs(work, _) >> outputSnapshots