ConstructorSelector injectOnlyJsr330Selector = new Jsr330ConstructorSelector(injectOnlyGenerator, cacheFactory.newClassCache());
        ConstructorSelector decoratedJsr330Selector = new Jsr330ConstructorSelector(decoratedGenerator, cacheFactory.newClassCache());
        ConstructorSelector injectOnlyLenientSelector = new ParamsMatchingConstructorSelector(injectOnlyGenerator);

    def scheme = new DefaultInstantiationScheme(
        new Jsr330ConstructorSelector(classGenerator, cacheFactory.newClassCache()),
        classGenerator,
        new DefaultServiceRegistry(),
        [] as Set,
        new TestCrossBuildInMemoryCacheFactory())

    def "can specify a set of services to inject"() {

    <K, V> CrossBuildInMemoryCache<K, V> newCacheRetainingDataFromPreviousBuild(Predicate<V> retentionFilter) {
        return new TestCache<K, V>()
    }

    @Override
    <V> CrossBuildInMemoryCache<Class<?>, V> newClassCache() {
        return new TestCache<Class<?>, V>()
    }

    @Override
    <V> CrossBuildInMemoryCache<Class<?>, V> newClassMap() {
        return new TestCache<Class<?>, V>()
    }

 */
@ServiceScope(Scope.Global::class)
class BeanConstructors(
    cacheFactory: CrossBuildInMemoryCacheFactory
) {
    private
    val cache: CrossBuildInMemoryCache<Class<*>, Constructor<out Any>> = cacheFactory.newClassCache()

    fun constructorForSerialization(beanType: Class<*>): Constructor<out Any> {
        return cache.get(beanType) { -> createConstructor(beanType) }
    }

    private

        def b = new Object()
        def c = new Object()
        def function = Mock(Function)

        given:
        function.apply(String) >> a
        function.apply(Long) >> b

        def cache = factory.newClassCache()

        expect:
        cache.get(String, function) == a
        cache.get(Long, function) == b
        cache.getIfPresent(String) == a
        cache.getIfPresent(Long) == b

        cache.put(String, c)

        this(constructorSelector, classGenerator, defaultServices, injectionAnnotations, cacheFactory.newClassCache());
    }

     *
     * <p>Note: this should be used to create _only_ global scoped instances.
     */
    <V> CrossBuildInMemoryCache<Class<?>, V> newClassCache();

    /**
     * Creates a new map instance whose keys are Class instances. Keys are referenced using strong or weak references, values by strong or other references depending on their usage.

    private final CrossBuildInMemoryCache<Class<?>, TaskClassInfo> classInfos;

    public DefaultTaskClassInfoStore(CrossBuildInMemoryCacheFactory cacheFactory) {
        this.classInfos = cacheFactory.newClassCache();
    }

    @Override
    public TaskClassInfo getTaskClassInfo(Class<? extends Task> type) {
        return classInfos.get(type, aClass -> createTaskClassInfo(aClass.asSubclass(Task.class)));
    }

        listenerManager.addListener(cache);
        return cache;
    }

    @Override
    public <V> CrossBuildInMemoryCache<Class<?>, V> newClassCache() {
        // Should use some variation of DefaultClassMap below to associate values with classes, as currently we retain a strong reference to each value for one session after the ClassLoader

        this.displayName = calculateDisplayName(propertyAnnotationHandlers);
        this.propertyTypeResolver = propertyTypeResolver;
        this.cache = cacheFactory.newClassCache();
        this.missingPropertyAnnotationHandler = missingPropertyAnnotationHandler;
    }

    private static String calculateDisplayName(Collection<? extends PropertyAnnotationHandler> annotationHandlers) {