access.listModuleVersions(dependency, result)

        then: 'work is delegated'
        1 * delegate.listModuleVersions(dependency, result)

        when: 'exception is thrown in resolution'
        repositoryBlacklister.getDisabledReason(REPOSITORY_ID) >> Optional.of(exception)
        effectiveRetries * delegate.listModuleVersions(dependency, result) >> { throw exception }

import java.net.Socket
import javax.net.SocketFactory

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

    def "delegates and reports each call"() {
        given:
        def location = InstallationLocation.userDefined(new File("jdkHome"), "test")
        def metadata = Mock(JvmInstallationMetadata)
        def reporter = Mock(BiConsumer)
        def delegate = Mock(JvmMetadataDetector)

        def detector = new ReportingJvmMetadataDetector(delegate, reporter)

        when:

        }
    }

    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 =

    return super.equals(obj);
  }

  /**
   * By default delegates to {@link Object#hashCode}. The dynamic proxies' {@code hashCode()} will
   * delegate to this method. Subclasses can override this method to provide custom equality.
   */
  @Override
  public int hashCode() {
    return super.hashCode();
  }

  /**
   * By default delegates to {@link Object#toString}. The dynamic proxies' {@code toString()} will

        delegate.matching(spec)

    override fun matching(spec: Closure<Any>): NamedDomainObjectSet<T> =
        delegate.matching(spec)

    override fun clear() =
        delegate.clear()

    override fun addRule(rule: Rule): Rule =
        delegate.addRule(rule)

    override fun addRule(description: String, ruleAction: Closure<Any>): Rule =
        delegate.addRule(description, ruleAction)

    private final PayloadClassLoaderRegistry delegate;

    static {
        ImmutableSet.Builder<ClassLoader> builder = ImmutableSet.builder();
        for (ClassLoader cl = PLATFORM_CLASS_LOADER; cl != null; cl = cl.getParent()) {
            builder.add(cl);
        }
        PLATFORM_CLASS_LOADERS = builder.build();
    }

    public WellKnownClassLoaderRegistry(PayloadClassLoaderRegistry delegate) {
        this.delegate = delegate;

    def version = Mock(VersionDetails)
    def delegate = Mock(InternalBuildController)
    def modelMapping = new ModelMapping()
    def controller = new BuildControllerWithoutParameterSupport(delegate, new ProtocolToModelAdapter(), modelMapping, new File("root dir"), version)

    def "delegates when no parameter is given"() {
        def model = new Object()
        def modelType = Object

    def "delegates upload to delegate uploader and logs progress"() {
        setup:
        expectPutBuildOperation(1072)

        when:
        uploader.upload(resource, location)

        then:
        1 * resource.open() >> inputStream
        1 * resource.contentLength >> 1072
        1 * delegate.upload(_, location) >> { resource, destination ->

        List<ClassRealmManagerDelegate> delegates = new ArrayList<>(this.delegates);

        if (!delegates.isEmpty()) {
            ClassRealmRequest request =
                    new DefaultClassRealmRequest(type, parent, parentImports, foreignImports, constituents);

            for (ClassRealmManagerDelegate delegate : delegates) {
                try {
                    delegate.setupRealm(classRealm, request);