import java.io.File;
import java.util.Optional;
import java.util.function.Function;

public interface RemoteBuildCacheServiceHandle extends Closeable {

    @Nullable
    @VisibleForTesting
    BuildCacheService getService();

    boolean canLoad();

    /**
     * Load the cached entry corresponding to the given cache key to the given target file.
     *

        this.service = service;
        this.pushEnabled = pushEnabled;
    }

    @Nullable
    @Override
    public LocalBuildCacheService getService() {
        return service;
    }

    @Override
    public Optional<BuildCacheLoadResult> maybeLoad(BuildCacheKey key, Function<File, BuildCacheLoadResult> unpackFunction) {

        public DefaultNodeExecutionContext(ProjectExecutionServices services) {
            this.services = services;
        }

        @Override
        public <T> T getService(Class<T> type) throws ServiceLookupException {
            return services.get(type);
        }

        @Override
        public void close() throws IOException {
            services.close();
        }
    }

import org.jetbrains.kotlin.types.checker.KotlinTypeRefiner

interface Fe10AnalysisFacade {
    companion object {
        fun getInstance(project: Project): Fe10AnalysisFacade {
            return project.getService(Fe10AnalysisFacade::class.java)
        }
    }

    fun getAnalysisContext(element: KtElement, token: KaLifetimeToken): Fe10AnalysisContext

        }
    }

    private fun registerJavaPsiFacade(project: MockProject) {
        with(project) {
            registerService(
                CoreJavaFileManager::class.java,
                this.getService(JavaFileManager::class.java) as CoreJavaFileManager
            )

            registerService(ExternalAnnotationsManager::class.java, MockExternalAnnotationsManager())

	defer cm.Unlock()
	cm.CalledFunctions = append(cm.CalledFunctions, "GetPodCgroupRoot")
	return ""
}

func (cm *FakeContainerManager) GetDevices(_, _ string) []*podresourcesapi.ContainerDevices {
	cm.Lock()
	defer cm.Unlock()
	cm.CalledFunctions = append(cm.CalledFunctions, "GetDevices")
	return nil
}

func (cm *FakeContainerManager) GetAllocatableDevices() []*podresourcesapi.ContainerDevices {
	cm.Lock()

            override val defaultIsAnalysisAllowedInWriteAction: Boolean get() = true
        }

        public fun getInstance(): KotlinAnalysisPermissionOptions =
            ApplicationManager.getApplication().getService(KotlinAnalysisPermissionOptions::class.java) ?: standaloneDefaults
    }

import static org.junit.jupiter.api.Assertions.assertTrue;

class TestApiStandalone {

    @Test
    void testStandalone() {
        Session session = ApiRunner.createSession();

        ModelBuilder builder = session.getService(ModelBuilder.class);
        ModelBuilderResult result = builder.build(ModelBuilderRequest.builder()
                .session(session)
                .source(ModelSource.fromPath(Paths.get("pom.xml").toAbsolutePath()))

     */
    Property<Integer> getMaxParallelUsages();

    /**
     * Returns a {@link Provider} that will create the service instance when its value is queried.
     */
    Provider<T> getService();

        return withRegistrations(registrations ->
            ImmutableSet.<BuildServiceRegistration<?, ?>>builder().addAll(registrations.matching(it ->
                type.isAssignableFrom(BuildServiceProvider.getProvidedType(it.getService()))
                    &&
                (StringUtils.isEmpty(name) || it.getName().equals(name))
            )).build()
        );
    }

    @Override
    @Nullable