import javax.annotation.Nullable;
import java.io.File;
import java.util.Map;
import java.util.function.Consumer;

@ServiceScope(Scope.Global.class)
public interface CacheFactory {
    /**
     * Opens a cache with the given options. The caller must close the cache when finished with it.
     */

    private final CacheFactory cacheFactory = Mock()
    private final PersistentCache cache = Mock()
    private final DefaultCacheBuilder builder = new DefaultCacheBuilder(cacheFactory, sharedCacheDir)

    void createsGlobalDirectoryBackedCache() {
        when:
        def result = builder.open()

        then:
        result == cache

        registration.add(GlobalCacheDir.class);
    }

    @Provides
    UnscopedCacheBuilderFactory createCacheRepository(CacheFactory cacheFactory) {
        return new DefaultUnscopedCacheBuilderFactory(cacheFactory);
    }

    @Provides
    DefaultGlobalScopedCacheBuilderFactory createGlobalScopedCache(GlobalCacheDir globalCacheDir, UnscopedCacheBuilderFactory unscopedCacheBuilderFactory) {

    private final CrossBuildInMemoryCacheFactory cacheFactory;

    public InspectionSchemeFactory(
        List<? extends TypeAnnotationHandler> allKnownTypeHandlers,
        List<? extends PropertyAnnotationHandler> allKnownPropertyHandlers,
        TypeAnnotationMetadataStore typeAnnotationMetadataStore,
        CrossBuildInMemoryCacheFactory cacheFactory
    ) {

import org.gradle.cache.MultiProcessSafeIndexedCache
import spock.lang.Specification

import java.util.function.Supplier

class InMemoryCacheDecoratorFactoryTest extends Specification {
    def cacheFactory = new DefaultInMemoryCacheDecoratorFactory(false, new TestCrossBuildInMemoryCacheFactory())
    def target = Mock(MultiProcessSafeIndexedCache)
    def asyncCacheAccess = Mock(AsyncCacheAccess)

        GradleUserHomeDirProvider gradleUserHomeDirProvider,
        BuildOperationRunner buildOperationRunner,
        CacheConfigurationsInternal cacheConfigurations,
        ListenerManager listenerManager,
        CacheFactory cacheFactory
    ) {
        UsedGradleVersions usedGradleVersions = new UsedGradleVersionsFromGradleUserHomeCaches(cacheBuilderFactory);
        registration.add(UsedGradleVersions.class, usedGradleVersions);

internal
object GradleUserHomeServices : ServiceRegistrationProvider {

    @Provides
    fun createKotlinScriptClassloadingCache(
        cacheFactory: CrossBuildInMemoryCacheFactory
    ) = KotlinScriptClassloadingCache(cacheFactory)

        return new DefaultCrossBuildInMemoryCacheFactory(listenerManager);
    }

    @Provides
    NamedObjectInstantiator createNamedObjectInstantiator(CrossBuildInMemoryCacheFactory cacheFactory) {
        return new NamedObjectInstantiator(cacheFactory);
    }

    @Provides
    TaskDependencyFactory createTaskDependencyFactory() {
        return DefaultTaskDependencyFactory.withNoAssociatedProject();
    }

            cacheFactory);
    }

    @Provides
    InspectionSchemeFactory createInspectionSchemeFactory(
        List<TypeAnnotationHandler> typeHandlers,
        List<PropertyAnnotationHandler> propertyHandlers,
        TypeAnnotationMetadataStore typeAnnotationMetadataStore,
        CrossBuildInMemoryCacheFactory cacheFactory
    ) {

import java.util.Map;
import java.util.function.Consumer;

import static org.gradle.cache.internal.filelock.DefaultLockOptions.mode;

public class DefaultCacheBuilder implements CacheBuilder {
    private final CacheFactory factory;
    private final File baseDir;
    private Map<String, ?> properties = Collections.emptyMap();
    private Consumer<? super PersistentCache> initializer;