obj.Generic.ClientConnection.ContentType = fmt.Sprintf("%s/%s.%s.%s", c.RandString(), c.RandString(), c.RandString(), c.RandString())
			if obj.Generic.LeaderElection.ResourceLock == "" {
				obj.Generic.LeaderElection.ResourceLock = "endpoints"
			}
			obj.Generic.Controllers = []string{fmt.Sprintf("%s", c.RandString())}
			if obj.KubeCloudShared.ClusterName == "" {
				obj.KubeCloudShared.ClusterName = "kubernetes"
			}

        then:
        lock1.lockedState
    }

    def "can nest multiple calls to withStateLock"() {
        def lock = [
            resourceLock("lock1"),
            resourceLock("lock2"),
            resourceLock("lock3"),
            resourceLock("lock4")
        ]

        given:
        def innerAction = new InternalTransformer<ResourceLockState.Disposition, ResourceLockState>() {

        waitingToStartNodes.clear();
        readyNodes.clear();
        runningNodes.clear();
        reachableCache.clear();
    }

    private void resourceUnlocked(ResourceLock resourceLock) {
        if (!(resourceLock instanceof WorkerLeaseRegistry.WorkerLease) && !readyNodes.isEmpty()) {
            maybeNodesSelectable = true;
        }
    }

    @Override
    public State executionState() {

    def workerLeaseService = workerLeaseService(1)

    def "can use withLocks to execute a runnable with resources locked"() {
        boolean executed = false
        def lock1 = resourceLock("lock1", false)
        def lock2 = resourceLock("lock1", false)

        when:
        workerLeaseService.withLocks([lock1, lock2], runnable {
            assert lock1.lockedState
            assert lock2.lockedState

 * limitations under the License.
 */

package org.gradle.internal.resources;

public interface ResourceLockContainer {
    void lockAcquired(ResourceLock lock);

    void lockReleased(ResourceLock lock);

     * fails.
     */
    void registerLocked(ResourceLock resourceLock);

    /**
     * Registers a resource lock that has been unlocked during the transform so that the coordination service can
     * notify threads waiting on a lock.
     */
    void registerUnlocked(ResourceLock resourceLock);

    /**
     * Release any locks that have been acquired during the transform.
     */

        return taskProject;
    }

    @Override
    public List<? extends ResourceLock> getResourcesToLock() {
        if (resourceLocks == null) {
            resourceLocks = task.getSharedResources();
        }
        return resourceLocks;
    }

    @Override
    public TaskInternal getTask() {
        return task;
    }

    @Override

 */

package org.gradle.internal.resources;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class SharedResourceLeaseRegistry extends AbstractResourceLockRegistry<String, ResourceLock> {
    private final Map<String, LeaseHolder> sharedResources = new ConcurrentHashMap<String, LeaseHolder>();
    private final ResourceLockCoordinationService coordinationService;

 */

package org.gradle.internal.resources;

public class ProjectLock extends ExclusiveAccessResourceLock {
    private final ResourceLock allProjectsLock;

    public ProjectLock(String displayName, ResourceLockCoordinationService coordinationService, ResourceLockContainer owner, ResourceLock allProjectsLock) {
        super(displayName, coordinationService, owner);
        this.allProjectsLock = allProjectsLock;
    }

import org.gradle.internal.UncheckedException;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;

public class LockCache<K, T extends ResourceLock> {
    private final Cache<K, T> resourceLocks = CacheBuilder.newBuilder().weakValues().build();
    private final ResourceLockCoordinationService coordinationService;
    private final ResourceLockContainer owner;