}

    private void registerInstrumentationOnlyPipeline(long contextId, DependencyHandler dependencyHandler) {
        registerInstrumentingTransform(contextId, dependencyHandler, ProjectDependencyInstrumentingArtifactTransform.class, Providers.notDefined(), NOT_INSTRUMENTED, INSTRUMENTED_ONLY);
    }

    private void registerInstrumentingTransform(
        long contextId,
        DependencyHandler dependencyHandler,

        return input.read(buffer, offset, count);
    }

    @Override
    protected long maybeSkip(long count) throws IOException {
        // Work around some bugs in Input.skip()
        int remaining = input.limit() - input.position();
        if (remaining == 0) {
            long skipped = inputStream.skip(count);
            if (skipped > 0) {
                extraSkipped += skipped;
            }

    }

    private long initializeHome() {
        executer.requireIsolatedDaemons() // needs to stop daemon
        requireOwnGradleUserHomeDir() // needs its own journal
        run() // Make sure cache directory is initialized
        run '--stop' // ensure daemon does not cache file access times in memory
        return gcFile().makeOlder().lastModified()
    }

    long markCacheLastCleaned(long timeMillis) {

    private final Date timestamp;
    @Nullable
    private final Long pid;
    @Nullable
    private final DaemonExpirationStatus status;
    @Nullable
    private final String reason;

    public DaemonStopEvent(Date timestamp, @Nullable Long pid, @Nullable DaemonExpirationStatus status, @Nullable String reason) {
        this.timestamp = timestamp;
        this.status = status;

    }

    @Nullable
    public String getArtifactHash(long contextId, File file) {
        return getResolutionData(contextId).getArtifactHash(file);
    }

    public FileCollection getTypeHierarchyAnalysis(long contextId) {
        return getResolutionData(contextId).getTypeHierarchyAnalysisResult();
    }

    private ResolutionData getResolutionData(long contextId) {

        new SingleDepthFilesFinder(1), fileAccessTimeJournal, TimestampSuppliers.daysAgo(1))

    def "finds files to delete when files are old"() {
        given:
        long now = System.currentTimeMillis()
        long fiveDaysAgo = now - TimeUnit.DAYS.toMillis(5)
        def cacheEntries = [
            createCacheEntry(now),
            createCacheEntry(now),
            createCacheEntry(now),

            }

            @Provides
            Factory<Integer> createInteger(Long value) {
                return { 12 } as Factory
            }

            @Provides
            Long createLong() {
                return 2L
            }

            @Provides
            BigDecimal createBigDecimal() {
                return 123
            }
        })

     */
    InputStream getInputStream();

    /**
     * Reads a signed 64 bit long value. Can read any value that was written using {@link Encoder#writeLong(long)}.
     *
     * @throws EOFException when the end of the byte stream is reached before the long value can be fully read.
     */
    long readLong() throws EOFException, IOException;

    /**

    }

    private static class Started implements BuildOperationStartedNotification {

        private final long timestamp;

        private final OperationIdentifier id;
        private final OperationIdentifier parentId;
        private final Object details;

        private Started(long timestamp, OperationIdentifier id, OperationIdentifier parentId, Object details) {
            this.timestamp = timestamp;

   */
  private val maxIdleConnections: Int,
  keepAliveDuration: Long,
  timeUnit: TimeUnit,
  internal val connectionListener: ConnectionListener,
  private val exchangeFinderFactory: (RealConnectionPool, Address, ConnectionUser) -> ExchangeFinder,
) {
  internal val keepAliveDurationNs: Long = timeUnit.toNanos(keepAliveDuration)

  @Volatile