return
        }
        // TODO remove debug log
        if (lastRegistryState == State.Stopped && lastLogState == State.Idle) {
            println("The daemon probably disappeared before it could've printed the stop message. Daemon log content:")
            println(logFile.text)
        }

        throw new AssertionError("""Timeout waiting for daemon with pid ${context.pid} to reach state ${state}.

     *
     * <p>Eventually, in Gradle 9.0, when {@link BuildIdentifier#isCurrentBuild()} is removed, all this logic can disappear.</p>
     */
    private LocalComponentGraphResolveState copyComponentWithForeignId(ProjectComponentIdentifier projectIdentifier) {
        ProjectState projectState = projectStateRegistry.stateFor(projectIdentifier);

            if (jobManager.isSchedulingDone()) {
                jobManager.findJobByUniqueOf(LaJobUnique.of(scheduledJob.getId())).ifPresent(job -> {
                    job.disappear();
                }).orElse(() -> logger.debug("Job {} is not scheduled.", scheduledJob.getId()));
            }
        } catch (final Exception e) {

		Funcs(
			// Ensure that InitContainers and their statuses are not generated. This
			// is because in this test we are simply doing json operations, in which
			// those disappear.
			func(s *api.PodSpec, c fuzz.Continue) {
				c.FuzzNoCustom(s)
				s.InitContainers = nil
			},
			func(s *api.PodStatus, c fuzz.Continue) {
				c.FuzzNoCustom(s)
				s.InitContainerStatuses = nil

        then:
        GradleConnectionException gce = thrown()
        gce.cause instanceof NullPointerException
    }

    @TargetGradleVersion("<3.0")
    def "retries if daemon seems to have disappeared and a daemon that did not do anything is idling (<3.0)"() {
        given:
        iteration++

        when:

                }

                if (object == null) {
                    // The daemon has potentially disappeared, so mark the connection as suspect.
                    // This makes the connection lenient if outgoing messages cannot be written while attempting to gracefully shut down the connection (in the finally {} block below)

 could encapsulate everything we need about the project in the POM including
 plugin parameters and anything else.

 We once had a document that Vincent and I agreed upon and I was about to
 implement it and then I disappeared for 8 months so it never came to pass.

 So I guess it's important to figure out what people are using properties
 files for and see if we can't incorporate it all into the POM. Or if we do

        _ * connection2.daemon >> Stub(DaemonConnectDetails)
        2 * connection2.receive() >>> [Stub(BuildStarted), new Success(resultMessage)]
        0 * connection._
    }

    def "reports daemon disappeared when result is null and cannot write further message to connection"() {
        def parameters = Stub(BuildActionParameters)
        parameters.currentDir >> new File(".")

        when:

        project.webAppDirName = 'foo'

        then:
        project.eclipse.wtp.component.resources == [new WbResource('/', 'foo')]
    }

    def "web app dir should not disappear while manually adding a wb resource"() {
        when:
        project.apply(plugin: 'war')
        project.apply(plugin: 'eclipse-wtp')
        project.webAppDirName = 'foo'

        project.eclipse.wtp {

	// loop until eviction happens. If eviction doesn't happen, this loop will get stuck forever which is fine
	for {
		time.Sleep(10 * time.Millisecond)

		_, ok := c.Get("A")
		if !ok {
			// item disappeared, we're done
			return
		}
	}
}

func testCacheFinalizer(gate *sync.WaitGroup) {
	runtime.GC() //nolint: revive
	gate.Wait()
}

func benchmarkCacheGet(c Cache, b *testing.B) {