func TestSpuriousEDEADLK(t *testing.T) {
	// 	P.1 locks file A.
	// 	Q.3 locks file B.
	// 	Q.3 blocks on file A.
	// 	P.2 blocks on file B. (Spurious EDEADLK occurs here.)
	// 	P.1 unlocks file A.
	// 	Q.3 unblocks and locks file A.
	// 	Q.3 unlocks files A and B.
	// 	P.2 unblocks and locks file B.
	// 	P.2 unlocks file B.

	testenv.MustHaveExec(t)

	dirVar := t.Name() + "DIR"

    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;

        def block1 = server.expectAndBlock("block1")
        def block2 = server.expectAndBlock("block2")

        when:
        // Block until first build has produced red things
        def build1 = executer.withTasks("redThings", "block1", "blueThings").start()
        block1.waitForAllPendingCalls()

        // Block until second build has produced blue things
        def build2 = executer.withTasks("redThings", "blueThings", "block2").start()

     * 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

task b {
    def files = configurations.b
    doLast {
        files.files
    }
}
task block1 {
    doLast {
        ${blockingServer.callFromBuild("block1")}
    }
}
block1.mustRunAfter a
b.mustRunAfter block1

task block2 {
    doLast {
        ${blockingServer.callFromBuild("block2")}
    }
}
block2.mustRunAfter b
"""
        // Ensure scripts are compiled
        run("help")

        expect:

		dst.Code = dsync.RespErr
		dst.Err = err.Error()
	}
	return dst, nil
}

const (
	// Lock maintenance interval.
	lockMaintenanceInterval = 1 * time.Minute

	// Lock validity duration
	lockValidityDuration = 1 * time.Minute
)

// lockMaintenance loops over all locks and discards locks
// that have not been refreshed for some time.
func lockMaintenance(ctx context.Context) {

    }
}

task block1 {
    dependsOn tasks.a
    onlyIf { project.hasProperty("enable-block1") }
    doLast {
        ${blockingServer.callFromBuild("block1")}
    }
}

task b {
    dependsOn tasks.block1
    doLast {
        configurations.b.files
    }
}

task block2 {
    dependsOn tasks.b
    onlyIf { project.hasProperty("enable-block2") }
    doLast {

     *
     * @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.

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])