delegate.add(configurationName, dependencyNotation, configureAction)

    override fun create(dependencyConstraintNotation: Any): DependencyConstraint =
        delegate.create(dependencyConstraintNotation)

    override fun create(dependencyConstraintNotation: Any, configureAction: Action<in DependencyConstraint>): DependencyConstraint =
        delegate.create(dependencyConstraintNotation, configureAction)

    internal
    abstract val delegate: ArtifactHandler

    override fun add(configurationName: String, artifactNotation: Any): PublishArtifact =
        delegate.add(configurationName, artifactNotation)

    override fun add(configurationName: String, artifactNotation: Any, configureClosure: Closure<Any>): PublishArtifact =
        delegate.add(configurationName, artifactNotation, configureClosure)

/**
 * A [ServerSocketFactory] that delegates calls. Sockets can be configured after creation by
 * overriding [.configureServerSocket].
 */
open class DelegatingServerSocketFactory(private val delegate: ServerSocketFactory) : ServerSocketFactory() {
  @Throws(IOException::class)
  override fun createServerSocket(): ServerSocket {
    val serverSocket = delegate.createServerSocket()
    return configureServerSocket(serverSocket)

 */
public class FlatteningNotationParser<N, T> implements NotationParser<N, Set<T>> {

    private final NotationParser<N, T> delegate;

    public FlatteningNotationParser(NotationParser<N, T> delegate) {
        assert delegate != null : "delegate cannot be null";
        this.delegate = delegate;
    }

    @Override

import java.util.List;

/**
 * A {@link DependencyMetadata} implementation which delegates all method calls to a provided {@code delegate}.
 */
public abstract class DelegatingDependencyMetadata implements DependencyMetadata {

    private final DependencyMetadata delegate;

    public DelegatingDependencyMetadata(DependencyMetadata delegate) {
        this.delegate = delegate;
    }

    @Override
    public ComponentSelector getSelector() {

/**
 * Simple build cache implementation that delegates to a {@link ConcurrentMap}.
 *
 * @since 3.5
 */
public class MapBasedBuildCacheService implements BuildCacheService {
    private final ConcurrentMap<String, byte[]> delegate;

    public MapBasedBuildCacheService(ConcurrentMap<String, byte[]> delegate) {
        this.delegate = delegate;
    }

    @Override

    protected final DynamicObject _delegate;
    private final Object _original_owner;
    private boolean _configuring;

    public ConfigureDelegate(Closure<?> configureClosure, Object delegate) {
        _original_owner = configureClosure.getOwner();
        _owner = DynamicObjectUtil.asDynamicObject(_original_owner);
        _delegate = DynamicObjectUtil.asDynamicObject(delegate);
    }

    @Override

/**
 * An SSLSocketFactory that delegates calls. Sockets created by the delegate are wrapped with ones
 * that will not accept the [TLS_FALLBACK_SCSV] cipher, thus bypassing server-side fallback
 * checks on platforms that support it. Unfortunately this wrapping will disable any
 * reflection-based calls to SSLSocket from Platform.
 */
class FallbackTestClientSocketFactory(
  delegate: SSLSocketFactory,

import javax.net.ssl.SSLSocketFactory

/**
 * A [SSLSocketFactory] that delegates calls. Sockets can be configured after creation by
 * overriding [.configureSocket].
 */
open class DelegatingSSLSocketFactory(private val delegate: SSLSocketFactory) : SSLSocketFactory() {
  @Throws(IOException::class)
  override fun createSocket(): SSLSocket {
    val sslSocket = delegate.createSocket() as SSLSocket
    return configureSocket(sslSocket)
  }

    def delegate = Mock(ExternalResourceLister)
    def buildOperationRunner = Mock(BuildOperationRunner)
    def context = Mock(BuildOperationContext)
    def lister = new ProgressLoggingExternalResourceLister(delegate, buildOperationRunner)
    def location = new ExternalResourceName(new URI("https://location/"))

    def "delegates list to delegate and generates build operation"() {
        setup: