/**
     * An object that allows instants to be defined and queried.
     *
     * @see NamedInstant
     */
    final Instants instant = new Instants(logger)

    /**
     * An object that allows operations to be defined and queried.
     *
     * @see NamedOperation
     */
    final Operations operation = new Operations(instant, instant)

    /**

  //
  // If the probe is disabled, it is recommended to have delay=1s,period=2s,failureThreshold=30.
  // This ensures the startup is reasonable fast (polling every 2s). 1s delay is used since the startup is not often ready instantly.
  google.protobuf.BoolValue enabled = 1;

  // Minimum consecutive failures for the probe to be considered failed after having succeeded.
  uint32 failureThreshold = 2;
}

/**
 * A target for blocking. Exposes each named instant as a property, and accessing that property will block until the
 * instant has been reached.
 */
class BlockTarget {
    private final Instants instants

    BlockTarget(Instants instants) {
        this.instants = instants
    }

    def getProperty(String name) {
        instants.waitFor(name)
        true
    }

            synchronizer.runNow(action2)
            instant.end
        }

        then:
        instant.action2Start > instant.action1End
        instant.end > instant.action2Start
    }

    def "cannot query instant that has not been defined in test thread"() {
        when:
        instant.unknown

        then:
        IllegalStateException e = thrown()

- Fixes a bug where hard evictions due to resource pressure would let the pod have the full termination grace period, instead of shutting down instantly. This bug also affected force deleted pods. Both cases now get a termination grace period of 1 second. ([#124063](https://github.com/kubernetes/kubernetes/pull/124063), [@olyazavr](https://github.com/olyazavr)) [SIG Node]

            instant.willStop
            executor.stop()
            instant.stopped
        }

        then:
        instant.stopped > instant.completed1
        instant.stopped > instant.completed2
    }

    def factoryStopBlocksUntilAllScheduledRunningJobsAreCompleted() {
        given:
        def action1 = {
            instant.started1
            thread.blockUntil.willStop
            thread.block()

            vfs.invalidate(['/my/location/new/something'])
            instant.invalidated
        }
        then:
        instant.snapshottingStarted < instant.invalidated
        instant.invalidated < instant.snapshottingFinished
        !vfs.findSnapshot(location).present
    }

     def "only stores non-invalidated children when using store action"() {
        def location = '/my/location/new'
        when:

/**
 * Represents the current thread.
 */
class TestThread {
    private final Instants instants

    TestThread(Instants instants) {
        this.instants = instants
    }

    void block() {
        Thread.sleep(750)
    }

    BlockTarget getBlockUntil() {
        return new BlockTarget(instants)
    }

                        spec.instant.child2Started
                        spec.thread.block()
                        spec.instant.child2Finished
                    }
                })
            })
            outer.leaseFinish()
        }

        then:
        instant.child2Started > instant.child1Finished || instant.child1Started > instant.child2Finished

        cleanup:

import java.time.Duration;
import java.time.Instant;

/**
 * Represents when cache cleanup should be triggered.
 *
 * @since 8.0
 */
public interface CleanupFrequency {
    /**
     * Trigger cleanup once every 24 hours.
     */
    CleanupFrequency DAILY = new CleanupFrequency() {
        @Override
        public boolean requiresCleanup(@Nullable Instant lastCleanupTime) {
            if (lastCleanupTime == null) {