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

Class <org.gradle.kotlin.dsl.DependencyHandlerScope> extends/implements org.gradle.kotlin.dsl.support.delegates.DependencyHandlerDelegate that is Gradle Internal API in (DependencyHandlerScope.kt:0)

/**
 * A cookie jar that delegates to a [java.net.CookieHandler].
 *
 * This implementation delegates everything to [okhttp3.java.net.cookiejar.JavaNetCookieJar], which
 * conforms to the package-naming limitations of JPMS.
 *
 * Callers should prefer to use [okhttp3.java.net.cookiejar.JavaNetCookieJar] directly.
 */
class JavaNetCookieJar private constructor(
  delegate: okhttp3.java.net.cookiejar.JavaNetCookieJar,

----
includeBuild("some-build")                         // Delegates to Settings.includeBuild()
reportsDir = findProject("/myInternalProject")     // Delegates to Settings.findProject()
----
=====
[.multi-language-sample]
=====
[source, groovy]
----
includeBuild('some-build')                         // Delegates to Settings.includeBuild()
reportsDir = findProject('/myInternalProject')     // Delegates to Settings.findProject()
----
=====

    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:

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