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

	}
	for expectedRef, expectedFrom := range configFromFile.Status.UnwantedReferences {
		actualFrom, ok := config.Status.UnwantedReferences[expectedRef]
		if !ok {
			// disappeared entirely
			log.Printf("Good news! Unwanted dependency %q is no longer referenced. Remove status.unwantedReferences[%q] in %s to ensure it doesn't get reintroduced.", expectedRef, expectedRef, dependenciesJSONPath)

// deprecated. `explanation` should contain the reason for the deprecation and
// what to use instead.
//
// This function is only an indicator that the operation may disappear in a
// version of TensorFlow after `version`. It does not affect op registration.
TF_CAPI_EXPORT extern void TF_OpDefinitionBuilderDeprecated(
    TF_OpDefinitionBuilder* builder, int version, const char* explanation);