Collection<Class<? extends Annotation>> allowedPropertyModifiers,
        TypeAnnotationMetadataStore typeAnnotationMetadataStore,
        PropertyTypeResolver propertyTypeResolver,
        CrossBuildInMemoryCacheFactory cacheFactory,
        MissingPropertyAnnotationHandler missingPropertyAnnotationHandler
    ) {
        this.typeAnnotationHandlers = ImmutableSet.copyOf(typeAnnotationHandlers);

            .provider(LoggingServiceRegistry.NO_OP)
            .provider(new GlobalScopeServices(false, AgentStatus.disabled()))
            .build()

    def factory = services.get(CacheFactory.class)
    def currentGradleVersion = GradleVersion.current()
    def scopeMapping = new DefaultCacheScopeMapping(tmpDir.testDirectory, currentGradleVersion)

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.Consumer;
import java.util.function.Supplier;

public class DefaultCacheFactory implements CacheFactory, Closeable {
    private final Map<File, DirCacheReference> dirCaches = new HashMap<>();
    private final FileLockManager lockManager;
    private final ExecutorFactory executorFactory;

  private Iterable<LoadingCache<Object, Object>> caches() {
    // lots of different ways to configure a LoadingCache
    CacheBuilderFactory factory = cacheFactory();
    return Iterables.transform(
        factory.buildAllPermutations(),
        new Function<CacheBuilder<Object, Object>, LoadingCache<Object, Object>>() {
          @Override

        IGNORED_METHOD_ANNOTATIONS,
        { false },
        cacheFactory
    )
    def propertyHandlers = services.getAll(PropertyAnnotationHandler)
    def typeMetadataStore = new DefaultTypeMetadataStore([], propertyHandlers, [Optional, SkipWhenEmpty], typeAnnotationMetadataStore, TestPropertyTypeResolver.INSTANCE, cacheFactory, MissingPropertyAnnotationHandler.DO_NOTHING)

    }
    def fileAccessTimeJournal = Mock(FileAccessTimeJournal)
    def usedGradleVersions = Stub(UsedGradleVersions)
    def cacheConfigurations = Stub(CacheConfigurationsInternal)
    def cacheFactory = new DefaultClasspathTransformerCacheFactory(usedGradleVersions, cacheConfigurations)
    def classpathWalker = new ClasspathWalker(TestFiles.fileSystem())

        PropertyRoleAnnotationHandler roleHandler,
        Collection<Class<? extends Annotation>> enabledInjectAnnotations,
        CrossBuildInMemoryCacheFactory cacheFactory,
        int factoryId
    ) {
        String suffix;
        CrossBuildInMemoryCache<Class<?>, GeneratedClassImpl> generatedClasses;
        if (enabledInjectAnnotations.isEmpty()) {

LogConfigurationExce; public static void release(ClassLoader); public static void releaseAll(); protected static ClassLoader getContextClassLoade() throws LogConfigurationExce; private static LogFactory getCachedFactory(ClassLoader); private static void cacheFactory(ClassLoader, LogFactory); protected static LogFactory newFactory(String, ClassLoader) throws LogConfigurationExce; private static java.io.InputStream getResourceAsStream(ClassLoader, String); static void <clinit>(); } org/apache/commons/loggin...

LogConfigurationExce; public static void release(ClassLoader); public static void releaseAll(); protected static ClassLoader getContextClassLoade() throws LogConfigurationExce; private static LogFactory getCachedFactory(ClassLoader); private static void cacheFactory(ClassLoader, LogFactory); protected static LogFactory newFactory(String, ClassLoader) throws LogConfigurationExce; private static java.io.InputStream getResourceAsStream(ClassLoader, String); static void <clinit>(); } org/apache/commons/loggin...

    def "factory gets cached"() {
        given:
        Factory factory = Mock()
        Factory cachedFactory = Factories.softReferenceCache(factory)

        when:
        def value = cachedFactory.create()

        then:
        1 * factory.create() >> 123
        value == 123

        when:
        value = cachedFactory.create()

        then:
        0 * _._
        value == 123
    }