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);

    private TestDecompressionCoordinators() {}

    public static DecompressionCoordinator decompressionCoordinator(File cacheDir) {
        final TestInMemoryCacheFactory cacheFactory = new TestInMemoryCacheFactory();
        return new DefaultDecompressionCoordinator(cacheFactory.open(cacheDir, "test compression cache"));
    }

        UNPROCESSED_PROPERTY_TYPE_ANNOTATIONS,
        { false },
        cacheFactory
    )
    def propertyTypeResolver = new DefaultPropertyTypeResolver()
    def metadataStore = new DefaultTypeMetadataStore([], services.getAll(PropertyAnnotationHandler), [Classpath, CompileClasspath], typeAnnotationMetadataStore, propertyTypeResolver, cacheFactory, MissingPropertyAnnotationHandler.DO_NOTHING)

    def setupSpec() {

    def cacheFactory = new TestCrossBuildInMemoryCacheFactory()
    def typeAnnotationMetadataStore = new DefaultTypeAnnotationMetadataStore(
        [],
        [:],
        ["java", "groovy"],
        [],
        [Object, GroovyObject],
        [ConfigurableFileCollection, Property],
        [Internal],
        { false },
        cacheFactory
    )

internal
object GradleUserHomeServices : ServiceRegistrationProvider {

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