private final DependencySuccessorsOnlyNodeSet delegate;
    private final NavigableSet<Node> orderedMustSuccessors = newSortedNodeSet();

    public ComplexDependencyNodesSet(DependencySuccessorsOnlyNodeSet delegate) {
        this.delegate = delegate;
    }

    @Override
    public NavigableSet<Node> getDependencySuccessors() {
        return delegate.getDependencySuccessors();
    }

    @Override

        when:
        buildA.buildFile << """
    task delegate {
        dependsOn gradle.includedBuild('buildB').task(':fails')
        dependsOn gradle.includedBuild('buildB').task(':succeeds')
    }
"""
        buildB.buildFile << """
    // force sequential execution
    tasks.succeeds.mustRunAfter tasks.fails
"""
        fails(buildA, ":delegate")

        then:
        failure.assertHasFailures(1)

  }

  @Throws(SocketException::class)
  override fun getKeepAlive(): Boolean {
    return delegate!!.keepAlive
  }

  override fun getLocalAddress(): InetAddress {
    return delegate!!.localAddress
  }

  override fun getLocalPort(): Int {
    return delegate!!.localPort
  }

  @Throws(IOException::class)
  override fun getOutputStream(): OutputStream {

   */
  @Override
  protected long edgeCount() {
    return delegate().edges().size();
  }

  @Override
  public boolean isDirected() {
    return delegate().isDirected();
  }

  @Override
  public boolean allowsSelfLoops() {
    return delegate().allowsSelfLoops();
  }

  @Override
  public ElementOrder<N> nodeOrder() {
    return delegate().nodeOrder();
  }

  @Override

      insertionOrder = castOrCopyToList(delegate.order(insertionOrder));
      reverse(insertionOrder);
      return insertionOrder;
    }

    TestSortedMapGenerator<K, V> delegate() {
      return (TestSortedMapGenerator<K, V>) delegate;
    }

    @Override
    public Entry<K, V> belowSamplesLesser() {
      return delegate().aboveSamplesGreater();
    }

    @Override

    private final DataSource delegate;

    public DelegatingDataSource(DataSource delegate) {
        this.delegate = delegate;
    }

    @Override
    public InputStream openInput() throws IOException {
        return delegate.openInput();
    }

    @Override
    public long getLength() throws IOException {
        return delegate.getLength();
    }

    @Override

    private static class PlannedTaskIdentity implements TaskIdentity {
        private final org.gradle.api.internal.project.taskfactory.TaskIdentity<?> delegate;

        public PlannedTaskIdentity(org.gradle.api.internal.project.taskfactory.TaskIdentity<?> delegate) {
            this.delegate = delegate;
        }

        @Override
        public NodeIdentity.NodeType getNodeType() {
            return NodeIdentity.NodeType.TASK;
        }

    implements ScheduledExecutorService {
  final ScheduledExecutorService delegate;

  protected WrappingScheduledExecutorService(ScheduledExecutorService delegate) {
    super(delegate);
    this.delegate = delegate;
  }

  @Override
  public final ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
    return delegate.schedule(wrapTask(command), delay, unit);
  }

  @Override

            @Suppress("unused")
            fun doCall() = delegate.withGroovyBuilder(builder)
        }
}


private
class GroovyBuilderScopeForGroovyObject(override val delegate: GroovyObject) : GroovyBuilderScope {

    override fun hasProperty(name: String): Boolean =
        delegate.metaClass.hasProperty(delegate, name) != null

    override fun String.invoke(vararg arguments: Any?): Any? =

   *
   * @since 9.0
   */
  public abstract static class SimpleForwardingListenableFuture<V extends @Nullable Object>
      extends ForwardingListenableFuture<V> {
    private final ListenableFuture<V> delegate;

    protected SimpleForwardingListenableFuture(ListenableFuture<V> delegate) {
      this.delegate = Preconditions.checkNotNull(delegate);
    }

    @Override