def setup() {
        // Start with a new registry on each test.
        _ * compatibilitySpec.isSatisfiedBy(_) >> { DaemonContext context -> context in compatibleWithCurrent }
    }

    def "expires compatible daemons"() {
        given:
        DaemonInfo d1 = registerDaemon(Idle)
        DaemonInfo d2 = registerDaemon(Idle)

        when:
        compatible = [ d1, d2 ]

        then:

import java.util.List;

import static org.gradle.launcher.daemon.server.expiry.DaemonExpirationStatus.DO_NOT_EXPIRE;
import static org.gradle.launcher.daemon.server.expiry.DaemonExpirationStatus.highestPriorityOf;

/**
 * Expires the daemon only if all children would expire the daemon.
 */
public class AllDaemonExpirationStrategy implements DaemonExpirationStrategy {
    private Iterable<DaemonExpirationStrategy> expirationStrategies;

                    return true;
                }

                final Date expires = DocumentUtil.getValue(document, fessConfig.getIndexFieldExpires(), Date.class);
                if (expires != null && expires.getTime() < systemHelper.getCurrentTimeAsLong()) {
                    final Object idValue = document.get(fessConfig.getIndexFieldId());

	q.queue.Forget(key)
	return true
}

// WaitForClose blocks until the Instance has stopped processing tasks or the timeout expires.
// If the timeout is zero, it will wait until the queue is done processing.
// WaitForClose an error if the timeout expires.
func (q Queue) WaitForClose(timeout time.Duration) error {
	closed := q.Closed()
	if timeout == 0 {
		<-closed
		return nil
	}

		iptablesTrace.Warnf("log failed: %v", e)
		return 0
	})
	if err != nil {
		log.Errorf("failed to register nflog callback: %v", err)
		return
	}

	// Block util the context expires
	<-ctx.Done()

//     in its Cancel function
//   - if the test has a deadline, adds a Context timeout and WaitDelay
//     for an arbitrary grace period before the test's deadline expires,
//   - fails the test if the command does not complete before the test's deadline, and
//   - sets a Cleanup function that verifies that the test did not leak a subprocess.

    private DaemonExpirationStrategy c1;
    private DaemonExpirationStrategy c2;

    def setup() {
        c1 = Mock(DaemonExpirationStrategy)
        c2 = Mock(DaemonExpirationStrategy)
    }

    def "expires when all child strategies expire"() {
        given:
        AllDaemonExpirationStrategy agg = new AllDaemonExpirationStrategy([c1, c2])

        when:

  @get:JvmName("name") val name: String,
  /** Returns a possibly-empty string with this cookie's value. */
  @get:JvmName("value") val value: String,
  /**
   * Returns the time that this cookie expires, in the same format as [System.currentTimeMillis].
   * This is December 31, 9999 if the cookie is not [persistent], in which case it will expire at the
   * end of the current session.
   *

        //uses different repo that does not contain this dependency
        failure.assertResolutionFailure(":impl:conf").assertHasCause("Could not find org:lib:1.0")
    }

    def "cache expires at the end of build"() {
        given:
        ivyRepo.module("org", "dependency").publish()
        ivyRepo.module("org", "lib").publish()

        file("build.gradle") << """
            configurations { conf }

	AmzFwdHeaderDeleteMarker       = "x-amz-fwd-header-x-amz-delete-marker"
	AmzFwdHeaderETag               = "x-amz-fwd-header-ETag"
	AmzFwdHeaderExpires            = "x-amz-fwd-header-Expires"
	AmzFwdHeaderExpiration         = "x-amz-fwd-header-x-amz-expiration"
	AmzFwdHeaderLastModified       = "x-amz-fwd-header-Last-Modified"

	AmzFwdHeaderObjectLockMode        = "x-amz-fwd-header-x-amz-object-lock-mode"