}
    }

    @Nullable
    public static <T> T executeInClassloader(ClassLoader classLoader, Factory<T> factory) {
        ClassLoader originalClassLoader = Thread.currentThread().getContextClassLoader();
        try {
            Thread.currentThread().setContextClassLoader(classLoader);
            return factory.create();
        } finally {
            Thread.currentThread().setContextClassLoader(originalClassLoader);

            class SomeBean {
                @Internal
                final ${type} value

                @Inject
                SomeBean(ObjectFactory objects) {
                    value = ${factory}
                }
            }

            class SomeTask extends DefaultTask {
                @Internal
                final SomeBean bean = project.objects.newInstance(SomeBean)
                @Internal

public abstract class AbstractFileCollection implements FileCollectionInternal {
    protected final TaskDependencyFactory taskDependencyFactory;
    protected final Factory<PatternSet> patternSetFactory;

    protected AbstractFileCollection(TaskDependencyFactory taskDependencyFactory, Factory<PatternSet> patternSetFactory) {
        this.taskDependencyFactory = taskDependencyFactory;
        this.patternSetFactory = patternSetFactory;
    }

            @Generated
            public class InterceptorDeclaration_JvmBytecodeImpl implements JvmBytecodeCallInterceptor, $capability {

                public static class Factory implements JvmBytecodeCallInterceptor.Factory, $factoryCapability {
                }
            }
        """
        assertThat(compilation).succeededWithoutWarnings()
        assertThat(compilation)

    void configure(ServiceRegistration registration) {
        registration.add(ProjectArtifactResolver.class);
        registration.add(DefaultExternalResourceFileStore.Factory.class);
        registration.add(DefaultArtifactIdentifierFileStore.Factory.class);
        registration.add(TransformStepNodeFactory.class);
        registration.add(AttributeDesugaring.class);
        registration.add(ComponentIdGenerator.class);

    }

    Signature(Buildable source, Callable<File> toSign, Callable<String> classifier, Callable<String> name, SignatureSpec signatureSpec, Object... tasks) {
        // TODO: find a way to inject a proper task dependency factory without breaking the public API
        super(DefaultTaskDependencyFactory.withNoAssociatedProject(), tasks);
        init(toSign, classifier, name, signatureSpec);
        this.source = source;
    }

    /**

    public NamedObjectInstantiator(CrossBuildInMemoryCacheFactory cacheFactory) {
        implSuffix = ClassGeneratorSuffixRegistry.assign("$Impl");
        factorySuffix = ClassGeneratorSuffixRegistry.assign(implSuffix + "Factory");
        generatedTypes = cacheFactory.newClassMap();
    }

    @Override
    public int getId() {
        return FACTORY_ID;
    }

    @Override

            }
        }
    }

    private ITestListener adaptListener(ITestListener listener) {
        TestNGListenerAdapterFactory factory = new TestNGListenerAdapterFactory(applicationClassLoader);
        return factory.createAdapter(listener);
    }

    private static class SelectedTestsFilter implements IMethodInterceptor {

        private final TestSelectionMatcher matcher;

                SomeBean(ObjectFactory objects) {
                    value = ${factory}
                }
            }

            def configureGradleLifecycle() {
                def objects = services.get(${ObjectFactory.name})

                SomeBean bean = objects.newInstance(SomeBean)
                ${type} value = ${factory}
                value.set(${reference})
                bean.value = ${reference}

            transformStepNodeFactory = service(),
        )

    private
    inline fun <reified T : Any> service() =
        host.service<T>()

    private
    inline fun <reified T> factory() =
        host.factory(T::class.java)