*
 * Should be inner class of TestFile, but can't because Groovy has issues with inner classes as delegates.
 */
class TestWorkspaceBuilder {
    def TestFile baseDir

    def TestWorkspaceBuilder(TestFile baseDir) {
        this.baseDir = baseDir
    }

    def apply(Closure cl) {
        cl.delegate = this
        cl.resolveStrategy = Closure.DELEGATE_FIRST
        cl()
    }

    }

    internal
    abstract val delegate: ScriptHandler

    override fun getSourceFile(): File? =
        delegate.sourceFile

    override fun getSourceURI(): URI? =
        delegate.sourceURI

    override fun getRepositories(): RepositoryHandler =
        delegate.repositories

    override fun repositories(configureClosure: Closure<Any>) =
        delegate.repositories(configureClosure)

    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:

        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)

import org.gradle.internal.serialize.graph.withCodec


/**
 * A codec that delegates to some more general codec, but only for a specific type
 */
class DelegatingCodec<T>(
    private val userTypesCodec: Codec<Any?>,
) : Codec<T> {

    override suspend fun WriteContext.encode(value: T) {
        // Delegate to the other codec
        withCodec(userTypesCodec) {
            write(value)
        }
    }

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

func NewContext(goTest *testing.T, labels ...label.Instance) TestContext {
	return newRootContext(nil, goTest, labels...)
}

// newRootContext creates a new TestContext that has no parent. Delegates to the global runtime.
func newRootContext(test *testImpl, goTest *testing.T, labels ...label.Instance) *testContext {
	rtMu.Lock()
	defer rtMu.Unlock()

	if rt == nil {

@GradleDsl
@Deprecated("Will be removed in Gradle 9.0")
abstract class KotlinBuildScript(
    private val host: KotlinScriptHost<Project>
) : @Suppress("DEPRECATION") org.gradle.kotlin.dsl.support.delegates.ProjectDelegate() {

    override val delegate: Project
        get() = host.target

    /**
     * The [ScriptHandler] for this script.
     */
    override fun getBuildscript(): ScriptHandler =
        host.scriptHandler

    def "ignores notation when it is not an instance of the target type"() {
        when:
        converter.convert(12L, result)

        then:
        0 * _._
    }

    def "delegates to target when notation is an instance of the target type"() {
        when:
        converter.convert(12.0, result)

        then:
        1 * target.convert(12.0, result)
    }

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