private final PublicKeyResultBuilder delegate;
        public boolean hasResult;

        private FirstMatchBuilder(PublicKeyResultBuilder delegate) {
            this.delegate = delegate;
        }

        @Override
        public void keyRing(PGPPublicKeyRing keyring) {
            delegate.keyRing(keyring);
            hasResult = true;
        }

        @Override

        selection.rejected
        selection.rejectionReason == "worse"
    }

    def 'delegates to metadata provider for metadata access'() {
        given:
        metadataProvider.usable >> true

        when:
        selection.getMetadata()

        then:
        1 * metadataProvider.componentMetadata
    }

    def 'delegates to metadata provider for ivy module descriptor access'() {
        given:

    def buildOperationScriptPlugin = new BuildOperationScriptPlugin(decoratedScriptPlugin, buildOperationRunner, userCodeApplicationContext)
    def target = "Test Target"

    def "delegates to decorated script plugin via build operation"() {
        when:
        buildOperationScriptPlugin.apply(target)

        then:
        2 * scriptSource.getResource() >> scriptSourceResource

        then:
        1 * delegate.execute(work, {
            it.inputProperties as Map == ["known": knownSnapshot]
            it.inputFileProperties as Map == ["known-file": knownFileFingerprint]
        }) >> delegateResult
        1 * workInputListeners.broadcastFileSystemInputsOf(work, allFileInputs)
        0 * _

        result == delegateResult
    }

    def "delegates when work has sources"() {

        }

        LifecycleMappingDelegate delegate;
        if (Arrays.binarySearch(DefaultLifecycles.STANDARD_LIFECYCLES, lifecycle.getId()) >= 0) {
            delegate = standardDelegate;
        } else {
            delegate = delegates.get(lifecycle.getId());
            if (delegate == null) {
                delegate = standardDelegate;
            }
        }

        1 * lockingState.lockedDependencies >> [DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId('org', 'foo'), '1.0')]
        1 * delegate.resolveGraph(resolveContext) >> delegateResults
        results == delegateResults
    }

    def "delegates to backing service to resolve build dependencies when there are one or more dependencies"() {
        given:
        ResolverResults delegateResults = Mock()

    }

    void "mainClassName in project delegates to mainClassName in startScripts task"() {
        when:
        plugin.apply(project);
        project.mainClassName = "Acme"

        then:
        def startScripts = project.tasks[ApplicationPlugin.TASK_START_SCRIPTS_NAME]
        startScripts.mainClassName == "Acme"
    }

    void "applicationDefaultJvmArgs in project delegates to jvmArgs in run task"() {
        when:

    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)

    }

    def "mixes in toString() implementation that delegates to delegate object when it has a displayName property"() {
        def state = Stub(ModelElementState)
        def delegate = new Object() {
            String getDisplayName() {
                return "<delegate>"
            }
        }

        expect:
        def proxyClass = generate(SomeType, delegate.class)

/**
 * 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)