class FinalizerThread extends Thread {
    private final static Logger LOG = LoggerFactory.getLogger(FinalizerThread.class);

    private final ReferenceQueue<CachedClassLoader> referenceQueue;
    private final AtomicBoolean stopped = new AtomicBoolean();

    // Protects the following fields
    private final Lock lock;
    private final Map<ClassPath, Cleanup> cleanups;
    private final Map<ClassPath, CacheEntry> cacheEntries;

import java.util.Collection;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.locks.ReentrantLock;

public class DefaultSlidingWindow<T> implements SlidingWindow<T> {
    final LinkedBlockingDeque<T> deque;
    final ReentrantLock lock = new ReentrantLock();

    public DefaultSlidingWindow(int capacity) {
        this.deque = new LinkedBlockingDeque<T>(capacity);
    }

    @Override

import org.custommonkey.xmlunit.XMLUnit
import org.gradle.plugins.ide.fixtures.IdeProjectFixture
import org.gradle.test.fixtures.file.TestFile

class EclipseProjectFixture extends IdeProjectFixture {
    private final Node project

    private EclipseProjectFixture(Node project) {
        this.project = project
    }

    static EclipseProjectFixture create(TestFile projectDir) {
        TestFile file = projectDir.file('.project')

    @SuppressWarnings("ThreadLocalUsage")
    private final ThreadLocal<Object> executing = new ThreadLocal<Object>();
    private final ExecutorPolicy executorPolicy;

    public AbstractManagedExecutor(S delegate, ExecutorPolicy executorPolicy) {
        super(delegate);
        this.executorPolicy = executorPolicy;
    }

    @Override
    public void execute(@Nonnull final Runnable command) {

public class DistributionInstaller {
    private static final String APP_NAME = "Gradle Tooling API";
    private static final InternalBuildProgressListener NO_OP = new NoOpListener();
    private final ProgressLoggerFactory progressLoggerFactory;
    private final InternalBuildProgressListener buildProgressListener;
    private final Clock clock;

public class ExecHandleRunner implements Runnable {
    private static final Logger LOGGER = Logging.getLogger(ExecHandleRunner.class);

    private final ProcessBuilderFactory processBuilderFactory;
    private final DefaultExecHandle execHandle;
    private final Lock lock = new ReentrantLock();
    private final ProcessLauncher processLauncher;
    private final Executor executor;

    private Process process;

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


class ReservedPortRange {
    final int startPort
    final int endPort
    private final Lock lock = new ReentrantLock()
    PortDetector portDetector = new DefaultPortDetector()
    final List<Integer> allocated = []
    int current

    public ReservedPortRange(int startPort, int endPort) {
        this.startPort = startPort

    private static final Logger LOGGER = LoggerFactory.getLogger(TestWorker.class);
    public static final String WORKER_ID_SYS_PROPERTY = "org.gradle.test.worker";
    public static final String WORKER_TMPDIR_SYS_PROPERTY = "org.gradle.internal.worker.tmpdir";
    private static final String WORK_THREAD_NAME = "Test worker";

    private final WorkerTestClassProcessorFactory factory;

 *
 * @author Anthony Zana
 */
public class UninterruptiblesTest extends TestCase {
  private static final String EXPECTED_TAKE = "expectedTake";

  /** Timeout to use when we don't expect the timeout to expire. */
  private static final long LONG_DELAY_MS = 2500;

  private static final long SLEEP_SLACK = 2;

  private final TearDownStack tearDownStack = new TearDownStack();

    private final BuildSessionActionExecutor delegate;
    private final WorkInputListeners inputsListeners;
    private final FileChangeListeners fileChangeListeners;
    private final BuildRequestMetaData requestMetaData;
    private final OperatingSystem operatingSystem;
    private final BuildCancellationToken cancellationToken;
    private final DeploymentRegistryInternal deploymentRegistry;