import org.gradle.launcher.daemon.context.DaemonContext;

import java.io.File;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

import static org.gradle.launcher.daemon.server.api.DaemonStateControl.State;
import static org.gradle.launcher.daemon.server.api.DaemonStateControl.State.Canceled;

        _ * lock.state
        1 * lock.close()
        0 * _._
    }

    def "locks requested target"() {
        final store = new DefaultPersistentDirectoryStore(cacheDir, "<display>", mode(Shared), null, lockManager, Mock(ExecutorFactory), buildOperationRunner)

        when:
        store.open()

        then:
        1 * lockManager.lock(cacheDir.file("."), mode(Shared), "<display> ($cacheDir)") >> lock

    /**
     * Possible results from a resource lock state transform.
     */
    enum Disposition { FAILED, FINISHED, RETRY }

    /**
     * Registers a resource lock to be rolled back if the transform associated with this resource lock state
     * fails.
     */
    void registerLocked(ResourceLock resourceLock);

    /**

    public void loadLocally(HashCode key, Consumer<? super File> reader) {
        // We need to lock other processes out here because garbage collection can be under way in another process
        persistentCache.withFileLock(() -> {
            // Additional locking necessary because of https://github.com/gradle/gradle/issues/3537
            lock.readLock().lock();
            try {
                loadInsideLock(key, reader);
            } finally {

	TimeLastRefresh time.Time // Timestamp for last lock refresh.
	Source          string    // Contains line, function and filename requesting the lock.
	Group           bool      // indicates if it was a group lock.
	Owner           string    // Owner represents the UUID of the owner who originally requested the lock.
	Quorum          int       // Quorum represents the quorum required for this lock to be active.

import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

@ThreadSafe
public class ClasspathInferer {
    private static final Logger LOGGER = LoggerFactory.getLogger(ClasspathInferer.class);
    private final Lock lock = new ReentrantLock();
    private final Map<Class<?>, Collection<URI>> classPathCache;

import org.gradle.launcher.daemon.context.DaemonConnectDetails;
import org.gradle.launcher.daemon.protocol.Message;

import javax.annotation.Nullable;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * A simple wrapper for the connection to a daemon.
 *
 * <p>Currently, dispatch is thread safe, and receive is not.
 */

					return ObjectLocked{}
				}

				if !ret.RetainUntilDate.Before(t) {
					return ObjectLocked{}
				}
				return nil
			}
			// https://docs.aws.amazon.com/AmazonS3/latest/dev/object-lock-overview.html#object-lock-retention-modes
			// If you try to delete objects protected by governance mode and have s3:BypassGovernanceRetention, the operation will succeed.

    private final List<TestParticipant> participants
    private final Lock lock

    CompositeTestParticipant(ConcurrentTestUtil owner, Lock lock, List<TestParticipant> participants) {
        super(owner)
        this.participants = participants
        this.lock = lock
    }

    void running() {
        lock.lock()
        try {
            participants*.running()
        } finally {

    }

    @SuppressWarnings("try")
    private <T> T withBuildLogicQueueLock(Supplier<T> buildAction) {
        lock.lock();
        try {
            final boolean firstLockHolder = lock.getHoldCount() == 1;
            if (firstLockHolder) { // lock file at the top of the callstack only
                try (FileLock ignored = lockBuildLogicQueueFile()) {
                    return buildAction.get();