ImmutableList<ListenableFuture<Long>> delegates =
        inCompletionOrder(ImmutableList.<ListenableFuture<Long>>of(future1, future2, future3));

    future1.set(1L);
    // Cannot cancel a complete delegate
    assertFalse(delegates.get(0).cancel(true));
    // Cancel the delegate before the input future is done
    assertTrue(delegates.get(1).cancel(true));

            return delegate.buildFile
        }

        override fun getDisplayName(): String {
            return delegate.displayName
        }

        override fun getDescription(): String? {
            onAccess("description")
            return delegate.description
        }

        override fun setDescription(description: String?) {
            onAccess("description")

        private final Map.Entry<Object, Object> delegate;

        TrackingEntry(Map.Entry<Object, Object> delegate) {
            this.delegate = delegate;
        }

        @Override
        public Object getKey() {
            return delegate.getKey();
        }

        @Override
        public Object getValue() {
            return delegate.getValue();
        }

        @Override

        private final DslOriginDependencyMetadata delegate;

        private ClientModuleDependencyMetadataWrapper(DslOriginDependencyMetadata delegate) {
            super(delegate);
            this.delegate = delegate;
        }

        @Override
        public Dependency getSource() {
            return delegate.getSource();
        }
    }

    }

    class OwnerHost(override val delegate: HostServiceProvider) : IsolateOwners() {
        override fun <T> service(type: Class<T>): T = delegate.service(type)
    }

    class OwnerFlowScope(override val delegate: Gradle) : IsolateOwners() {
        override fun <T> service(type: Class<T>): T = (delegate as GradleInternal).services.get(type)
    }

        delegate.populate(plan)
    }

    override fun execute(plan: FinalizedExecutionPlan?): ExecutionResult<Void>? =
        delegate.execute(plan)

    override fun visitScheduledNodes(visitor: BiConsumer<List<Node>, Set<Node>>) =
        delegate.visitScheduledNodes(visitor)

    override fun size(): Int = delegate.size()

    @Deprecated("Deprecated in Java")

    private final Cache<File, Map<String, Set<String>>> typeHierarchyCache;
    private final InstrumentationAnalysisSerializer delegate;

    public CachedInstrumentationAnalysisSerializer(InstrumentationAnalysisSerializer delegate) {
        this.delegate = delegate;
        dependencyAnalysisCache = CacheBuilder.newBuilder()
            .concurrencyLevel(1)
            .maximumSize(20_000)
            .build();

        private final InputStream delegate;

        public EncodedInput(java.io.InputStream delegate) {
            this.delegate = delegate;
        }

        @Override
        public int read() throws IOException {
            int byte1 = delegate.read();
            if (byte1 < 0) {
                return -1;
            }
            int byte2 = delegate.read();
            if (byte2 < 0) {

class ConfigurationCacheAwareBuildToolingModelController(
    private val delegate: BuildToolingModelController,
    private val cache: BuildTreeConfigurationCache
) : BuildToolingModelController {
    override fun getConfiguredModel(): GradleInternal = delegate.configuredModel

    override fun locateBuilderForTarget(modelName: String, param: Boolean): ToolingModelScope {
        return wrap(delegate.locateBuilderForTarget(modelName, param))
    }

        private final VersionScheme versionScheme;
        private final org.eclipse.aether.version.Version delegate;

        DefaultVersion(VersionScheme versionScheme, org.eclipse.aether.version.Version delegate) {
            this.versionScheme = versionScheme;
            this.delegate = delegate;
        }

        DefaultVersion(VersionScheme versionScheme, String delegateValue) {