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

        when:
        registry.getClassPath("name")

        then:
        IllegalArgumentException e = thrown()
        e.message == 'unknown classpath \'name\' requested.'
    }

    def "delegates to providers to find classpath"() {
        def classpath = Mock(ClassPath)

        given:
        provider1.findClassPath(_) >> null
        provider2.findClassPath("name") >> classpath

        expect:

 *
 * @author Kevin Damm
 * @author Kyle Maddison
 */
@ElementTypesAreNonnullByDefault
final class LittleEndianByteArray {

  /** The instance that actually does the work; delegates to Unsafe or a pure-Java fallback. */
  private static final LittleEndianBytes byteArray;

  /**
   * Load 8 bytes into long in a little endian manner, from the substring between position and

    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;

 *
 * @author Kevin Damm
 * @author Kyle Maddison
 */
@ElementTypesAreNonnullByDefault
final class LittleEndianByteArray {

  /** The instance that actually does the work; delegates to Unsafe or a pure-Java fallback. */
  private static final LittleEndianBytes byteArray;

  /**
   * Load 8 bytes into long in a little endian manner, from the substring between position and

        }
    }

    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 =

/**
 * The main entry point for a worker process that is using the system ClassLoader strategy. Reads worker configuration and a serialized worker action from stdin,
 * sets up the worker ClassLoader, and then delegates to {@link org.gradle.process.internal.worker.child.SystemApplicationClassLoaderWorker} to deserialize and execute the action.
 */
public class GradleWorkerMain {
    public void run() throws Exception {

import java.util.Enumeration;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * A {@code ClassLoader} which delegates to multiple parent ClassLoaders.
 *
 * Note: It's usually a good idea to add a {@link CachingClassLoader} between this ClassLoader and any

    final BuildCancellationToken cancellationToken = Mock()
    final CachingToolingImplementationLoader loader = new CachingToolingImplementationLoader(target)

    def "delegates to target loader to create implementation"() {
        def distribution = Mock(Distribution)
        def connection = Mock(ConsumerConnection)

        when:

            createDelegate(configuration, this.delegate, buildCacheControllerFactory, identityPath, instanceGenerator);
        }

        @Override
        protected BuildCacheController getDelegate() {
            return delegate.get();
        }

        @Override
        public void resetState() {
            discardDelegate(delegate);
        }