class DefaultInstantiationSchemeTest extends Specification {
    def cacheFactory = new TestCrossBuildInMemoryCacheFactory()
    def classGenerator = AsmBackedClassGenerator.injectOnly([], Stub(PropertyRoleAnnotationHandler), [], cacheFactory, 123)
    def scheme = new DefaultInstantiationScheme(
        new Jsr330ConstructorSelector(classGenerator, cacheFactory.newClassCache()),
        classGenerator,
        new DefaultServiceRegistry(),

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

import org.gradle.cache.UnscopedCacheBuilderFactory;

import java.io.File;

public class DefaultUnscopedCacheBuilderFactory implements UnscopedCacheBuilderFactory {
    private final CacheFactory factory;

    public DefaultUnscopedCacheBuilderFactory(CacheFactory factory) {
        this.factory = factory;
    }

    @Override
    public CacheBuilder cache(File baseDir) {
        return new DefaultCacheBuilder(factory, baseDir);
    }

import org.gradle.kotlin.dsl.execution.ProgramId

import javax.inject.Inject


internal
class KotlinScriptClassloadingCache @Inject constructor(
    cacheFactory: CrossBuildInMemoryCacheFactory
) {

    private
    val cache: CrossBuildInMemoryCache<ProgramId, CompiledScript> = cacheFactory.newCache()

    fun get(key: ProgramId): CompiledScript? =
        cache.getIfPresent(key)?.also { it.onReuse() }

    private final CrossBuildInMemoryCache<ScriptCacheKey, CachedCompiledScript> cachedCompiledScripts;

    public CrossBuildInMemoryCachingScriptClassCache(CrossBuildInMemoryCacheFactory cacheFactory) {
        cachedCompiledScripts = cacheFactory.newCache();
    }

    public <T extends Script, M> CompiledScript<T, M> getOrCompile(
        Object target,
        ScriptSource source,
        ClassLoaderScope targetScope,

        [ConfigurableFileCollection, Property],
        [IgnoredThing],
        { false },
        cacheFactory
    )
    def factory = new InspectionSchemeFactory([], [handler1, handler2], typeAnnotationMetadataStore, cacheFactory)

    def "creates inspection scheme that understands given property annotations and injection annotations"() {
        def instantiationScheme = Stub(InstantiationScheme)

            cacheFactory);
    }

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

    private final FileContentCache<IncludeDirectives> cache;

    public CachingCSourceParser(FileContentCacheFactory cacheFactory) {
        final RegexBackedCSourceParser parser = new RegexBackedCSourceParser();
        cache = cacheFactory.newCache("parsedCSource", 40000, new FileContentCacheFactory.Calculator<IncludeDirectives>() {
            @Override

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;