* Runs a given {@link Factory} while the specified locks are being held, releasing
     * the locks upon completion.  Blocks until the specified locks can be obtained.
     */
    <T> T withLocks(Collection<? extends ResourceLock> locks, Factory<T> factory);

    /**
     * Runs a given {@link Runnable} while the specified locks are being held, releasing
     * the locks upon completion.  Blocks until the specified locks can be obtained.
     */

// LockArgs is minimal required values for any dsync compatible lock operation.
type LockArgs struct {
	// Unique ID of lock/unlock request.
	UID string

	// Resources contains single or multiple entries to be locked/unlocked.
	Resources []string

	// Source contains the line number, function and file name of the code
	// on the client node that requested the lock.
	Source string

    private final Lock lock;
    private final Duration timeout;
    private final Condition condition;
    private final WaitPrecondition precondition;
    private boolean requestStarted;
    private boolean released;
    private final Clock clock = Time.clock();
    private long mostRecentEvent;
    private AssertionError failure;

     * This method is reentrant so that a thread can call this method from the given action.
     *
     * This method blocks until a worker lease is available.
     */
    <T> T runAsWorkerThread(Factory<T> action);

    /**
     * Runs the given action as a worker. While the action is running, the thread can acquire resource locks.
     * A worker lease is also granted to the thread. The thread can release this if it needs to, but should reacquire

     *
     * @param operation - The build operation whose asynchronous work should be completed
     * @param lockRetention - How project locks should be treated while waiting on work
     */
    void waitForCompletion(BuildOperationRef operation, ProjectLockRetention lockRetention);

    /**
     * Blocks waiting for the completion of the specified items of asynchronous work.

	} else {
		checks = append(checks, ContainerRuntimeCheck{runtime: containerRuntime})
	}

	// non-windows checks
	checks = addSwapCheck(checks)
	checks = addExecChecks(checks, execer)
	checks = append(checks,
		SystemVerificationCheck{},
		HostnameCheck{nodeName: nodeReg.Name},

package org.gradle.test.fixtures.concurrent

import java.util.concurrent.Executor
import java.util.concurrent.locks.Condition
import java.util.concurrent.locks.Lock
import java.util.concurrent.locks.ReentrantLock

class TestExecutor implements Executor {
    private final Lock lock = new ReentrantLock()
    private final Condition condition = lock.newCondition()
    private final Set<Thread> threads = new HashSet<Thread>()

//	https://csrc.nist.gov/csrc/media/publications/fips/197/final/documents/fips-197.pdf
//	https://csrc.nist.gov/archive/aes/rijndael/Rijndael-ammended.pdf

package aes

import "internal/byteorder"

// Encrypt one block from src into dst, using the expanded key xk.
func encryptBlockGo(xk []uint32, dst, src []byte) {
	_ = src[15] // early bounds check
	s0 := byteorder.BeUint32(src[0:4])
	s1 := byteorder.BeUint32(src[4:8])

    private final Clock clock = Time.clock();
    private final Lock lock;
    private WaitPrecondition last;
    private boolean completed;
    private final Condition condition;
    private int requestsStarted;

    ChainingHttpHandler(Lock lock, int timeoutMs, AtomicInteger counter, WaitPrecondition first) {
        this.lock = lock;
        this.condition = lock.newCondition();
        this.timeoutMs = timeoutMs;

        }
        handler.addHandler(previous -> new ExpectInAnyOrder(lock, previous, expectations));
    }

    /**
     * Expects the given requests to be made. Blocks until the given number of concurrent requests have been received, then releases one of the requests and blocks again.
     * Repeats until all of the requests have been received.
     */