@Override
  protected abstract BlockingDeque<E> delegate();

  @Override
  public int remainingCapacity() {
    return delegate().remainingCapacity();
  }

  @Override
  public void putFirst(E e) throws InterruptedException {
    delegate().putFirst(e);
  }

  @Override
  public void putLast(E e) throws InterruptedException {
    delegate().putLast(e);
  }

  @Override

    private final MapProperty<K, V> delegate;

    public MapPropertyMapView(MapProperty<K, V> delegate) {
        this.delegate = delegate;
    }

    @Override
    @Nullable
    public V get(Object key) {
        return delegate.get().get(key);
    }

    @Override
    public boolean containsKey(Object key) {
        return delegate.get().containsKey(key);
    }

    @Override

        }
    }

    internal
    abstract val delegate: Settings

    override fun getSettings(): Settings =
        delegate.settings

    override fun getBuildscript(): ScriptHandler =
        delegate.buildscript

    override fun getSettingsDir(): File =
        delegate.settingsDir

    override fun getRootDir(): File =
        delegate.rootDir

    override fun getRootProject(): ProjectDescriptor =

    final delegate = Mock(ModuleComponentRepository)
    final localAccess = Mock(ModuleComponentRepositoryAccess)
    final remoteAccess = Mock(ModuleComponentRepositoryAccess)

    def "delegates id and name methods"() {
        when:
        final repository = new BaseModuleComponentRepository(delegate, localAccess, remoteAccess)
        1 * delegate.id >> "id"
        1 * delegate.name >> "name"

    }

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

    private final AbstractArtifactsCache delegate;

    public InMemoryModuleArtifactsCache(BuildCommencedTimeProvider timeProvider) {
        super(timeProvider);
        this.delegate = null;
    }

    public InMemoryModuleArtifactsCache(BuildCommencedTimeProvider timeProvider, AbstractArtifactsCache delegate) {
        super(timeProvider);
        this.delegate = delegate;
    }

    @Override

    private final AbstractModuleVersionsCache delegate;

    public InMemoryModuleVersionsCache(BuildCommencedTimeProvider timeProvider) {
        super(timeProvider);
        this.delegate = null;
    }

    public InMemoryModuleVersionsCache(BuildCommencedTimeProvider timeProvider, AbstractModuleVersionsCache delegate) {
        super(timeProvider);
        this.delegate = delegate;
    }

    @Override

	tcs := []struct {
		name string

		delegate         RESTMapper
		resourcePatterns []schema.GroupVersionResource
		result           schema.GroupVersionResource
		err              string
	}{
		{
			name:     "error",
			delegate: fixedRESTMapper{err: errors.New("delegateError")},
			err:      "delegateError",
		},
		{
			name:     "single hit + error",

    return delegate().nodeOrder();
  }

  @Override
  public ElementOrder<E> edgeOrder() {
    return delegate().edgeOrder();
  }

  @Override
  public Set<N> adjacentNodes(N node) {
    return delegate().adjacentNodes(node);
  }

  @Override
  public Set<N> predecessors(N node) {
    return delegate().predecessors(node);
  }

  @Override
  public Set<N> successors(N node) {

  public boolean isTerminated() {
    return delegate().isTerminated();
  }

  @Override
  public void shutdown() {
    delegate().shutdown();
  }

  @Override
  @CanIgnoreReturnValue
  public List<Runnable> shutdownNow() {
    return delegate().shutdownNow();
  }

  @Override
  public void execute(Runnable command) {
    delegate().execute(command);
  }

  @Override