}

    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)

        override fun toString(): String = "CrossProjectModelAccessProjectEvaluationListener($delegate)"
    }

    // region delegated members
    override fun getPlugins(): PluginContainer =
        delegate.plugins

    override fun apply(closure: Closure<*>) =
        delegate.apply(closure)

    final delegate = Mock(ModuleComponentRepository)
    final localAccess = Mock(ModuleComponentRepositoryAccess)
    final remoteAccess = Mock(ModuleComponentRepositoryAccess)

    def "delegates id and name methods"() {
        when:
        final repository = new BaseModuleComponentRepository(delegate, localAccess, remoteAccess)
        1 * delegate.id >> "id"
        1 * delegate.name >> "name"

    tasks.succeeds.mustRunAfter tasks.fails
"""
        fails(buildA, ":delegate")

        then:
        failure.assertHasFailures(1)
        assertTaskExecuted(":buildB", ":fails")
        assertTaskNotExecuted(":buildB", ":succeeds")
        assertTaskNotExecuted(":", ":delegate")
    }

    def "attempts all dependencies when run with --continue when one delegated task dependency fails"() {
        when:
        buildA.buildFile << """

        return new BeanDynamicObject(delegate, publicType);
    }

    private void updateDelegates() {
        DynamicObject[] delegates = new DynamicObject[6];
        delegates[0] = dynamicDelegate;
        delegates[1] = extraPropertiesDynamicObject;
        int idx = 2;
        if (beforeConvention != null) {
            delegates[idx++] = beforeConvention;
        }
        if (convention != null) {

        then:
        1 * factory.create() >> delegate
        1 * delegate.startProcessing(resultProcessor)
        then:
        1 * delegate.processTestClass(test1)
        then:
        1 * delegate.processTestClass(test2)
        then:
        1 * delegate.stop()
        0 * _._
    }

    def 'creates new delegate processor on (n + 1)th test'() {
        given:

Mike Morris <******@****.***> 1702326113 -0500

import java.io.File;
import java.io.IOException;

/**
 * A {@link FileContentCacheFactory} that delegates to the global cache for files that are known to be immutable and shared between different builds.
 * All other requests are delegated to the build-local cache. Closing this factory will only close the local delegate, not the global one.
 */
public class SplitFileContentCacheFactory implements FileContentCacheFactory, Closeable {

    // this is a live injected collection
    protected final List<ArtifactFilterManagerDelegate> delegates;

    protected Set<String> excludedArtifacts;

    private final Set<String> coreArtifacts;

    @Inject
    public DefaultArtifactFilterManager(List<ArtifactFilterManagerDelegate> delegates, CoreExports coreExports) {
        this.delegates = delegates;
        this.coreArtifacts = coreExports.getExportedArtifacts();
    }

	tcs := []struct {
		name string

		delegate     RESTMapper
		kindPatterns []schema.GroupVersionKind
		result       schema.GroupVersionKind
		err          string
	}{
		{
			name:     "error",
			delegate: fixedRESTMapper{err: errors.New("delegateErr")},
			err:      "delegateErr",
		},
		{
			name:     "single hit + error",