long newFreeMemory = doRequestFreeMemory(status.getName(), requestedFreeMemory, freeMemory);
        return newFreeMemory > freeMemory;
    }

    private long doRequestFreeMemory(String name, long requestedFreeMemory, long freeMemory) {
        long toReleaseMemory = requestedFreeMemory;
        if (freeMemory < requestedFreeMemory) {

import org.gradle.internal.operations.BuildOperationContext;

public class DefaultCleanupProgressMonitor implements CleanupProgressMonitor {

    private final BuildOperationContext buildOperationContext;
    private long deleted;
    private long skipped;

    public DefaultCleanupProgressMonitor(BuildOperationContext buildOperationContext) {
        this.buildOperationContext = buildOperationContext;
    }

    @Override

        @Provides
        Long createLong(Long value) {
            return value + 2
        }

        @Provides
        Long decorateLong(Long value) {
            return value + 2
        }
    }

    private static class TestDecoratingProviderWithCreate implements ServiceRegistrationProvider {
        @Provides
        Long createLong(Long value) {
            return value + 2

    private TimeFormatting() {
    }

    public static String formatDurationVerbose(long durationMillis) {
        StringBuilder result = new StringBuilder();
        if (durationMillis > MILLIS_PER_HOUR) {
            result.append(durationMillis / MILLIS_PER_HOUR).append(" hrs ");
        }
        if (durationMillis > (long) MILLIS_PER_MINUTE) {

    private final Lock lock = new ReentrantLock();

    private final Map<Long, ContendedAction> contendedActions = new HashMap<>();
    private final Map<Long, FileLockReleasedSignal> lockReleasedSignals = new HashMap<>();
    private final Map<Long, Integer> unlocksRequestedFrom = new HashMap<>();
    private final Map<Long, Integer> unlocksConfirmedFrom = new HashMap<>();

    private final ExecutorFactory executorFactory;

                      Thread.sleep(($minimumBuildTimeMillis - sinceStart) as Long)
                    }
                }
            """
        }
        return """
            def startAt = System.nanoTime()

            interface MinimumBuildTimeParams extends ${BuildServiceParameters.name} {
                Property<Long> getStartAt()
                Property<Long> getMinimumBuildTimeMillis()
            }

        private final Supplier<Long> releaseTimestampSupplier;
        private final Supplier<Long> snapshotTimestampSupplier;

        CleanupCondition(SortedSet<VersionSpecificCacheDirectory> cacheDirsWithSameBaseVersion, Supplier<Long> releaseTimestampSupplier, Supplier<Long> snapshotTimestampSupplier) {
            this.cacheDirsWithSameBaseVersion = cacheDirsWithSameBaseVersion;

    protected abstract int maybeReadBytes(byte[] buffer, int offset, int count) throws IOException;

    protected abstract long maybeSkip(long count) throws IOException;

    private class DecoderStream extends InputStream {
        byte[] buffer = new byte[1];

        @Override
        public long skip(long n) throws IOException {
            return maybeSkip(n);
        }

        @Override

        return delegate.scheduleAtFixedRate(trackedCommand(command), initialDelay, period, unit);
    }

    @Override
    public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) {
        return delegate.scheduleWithFixedDelay(trackedCommand(command), initialDelay, delay, unit);
    }

    private final long startTime;
    private final boolean interactive;

    public DefaultBuildRequestMetaData(BuildClientMetaData clientMetaData, long startTime, boolean interactive) {
        this.clientMetaData = clientMetaData;
        this.startTime = startTime;
        this.interactive = interactive;
    }

    public DefaultBuildRequestMetaData(long startTime) {
        this(startTime, false);
    }