?: error("Unsupported type $type, consider add corresponding mapping")
    }

    fun getAllConverters(conversionForCollectionValues: HLParameterConversion): Map<KClass<*>, HLParameterConversion> {
        return buildMap {
            putAll(typeMapping)
            put(
                Map::class,
                HLMapParameterConversion(
                    "key",
                    "value",

        context: AnalysisContext,
        functionCall: FunctionCall
    ): ObjectOrigin.FunctionOrigin? = with(context) {
        val argResolutions = lazy {
            var hasErrors = false
            val result = buildMap<FunctionArgument.ValueArgument, ObjectOrigin> {
                functionCall.args.filterIsInstance<FunctionArgument.ValueArgument>().forEach {
                    val resolution = expressionResolver.doResolveExpression(context, it.expr)

    }

    private fun collectStubsFromBinaryRoot(
        binaryRoot: VirtualFile,
        binaryClassCache: ClsKotlinBinaryClassCache,
    ): Map<VirtualFile, KotlinFileStubImpl> =
        buildMap {
            VfsUtilCore.visitChildrenRecursively(binaryRoot, object : VirtualFileVisitor<Void>() {
                override fun visitFile(file: VirtualFile): Boolean {
                    if (!file.isDirectory) {

            }
        """
        includedBuilds = [empty]
        createDirs("buildA", "buildA/subproject1")
        buildA.settingsFile << """
            include('subproject1')
            $includeRootStatement
        """

        when:
        checkDependencies()

        then:
        def expectSubstitution = rootIsIncluded.contains("yes")
        checkGraph {

        def originalResult = runBuildAction(new FetchAllIdeaProjects())

        then:
        originalResult.allIdeaProjects.name == ['buildA', 'buildB', 'buildC', 'buildD']
        originalResult.rootIdeaProject.name == 'buildA'
        originalResult.rootIdeaProject.modules.name == ['buildA']

        def moduleA = originalResult.rootIdeaProject.modules[0]
        moduleA.dependencies.each {

    ExecutionResult runAndFail() {
        withEnabledBuildCache().fails("cacheable")
    }

    void assertCacheWasCleanedUpSince(long lastCleanupCheck) {
        def buildOp = operations.only("Clean up ${getBuildCacheName()} ($cacheDir)")
        buildOp.details.cacheLocation == cacheDir
        assert gcFile().lastModified() > lastCleanupCheck
    }

    void assertCacheWasNotCleanedUpSince(long lastCleanupCheck) {

27347 pts/0    S      0:00 bash

	}
	// TODO: not sure why it goes here
	filters = append(filters, authzCustomBuilder.BuildTCP()...)

	// Authn
	filters = extension.PopAppendNetwork(filters, wasm, extensions.PluginPhase_AUTHN)

	// Authz
	filters = extension.PopAppendNetwork(filters, wasm, extensions.PluginPhase_AUTHZ)
	filters = append(filters, authzBuilder.BuildTCP()...)

	// Stats

                }
            }
        """
        builder.manifestAttributes("Premain-Class": "TestAgent")
        def agentJar = file("agent.jar")
        builder.buildJar(agentJar)
        buildFile << """
        """
        settingsFile << """
        """

        when:
        def runner = GradleRunner.create()
        runner.withJvmArguments("-javaagent:${agentJar}")

// in build.ToolDir.
func ToolExeSuffix() string {
	if installedGOOS == "windows" {
		return ".exe"
	}
	return ""
}

// These are general "build flags" used by build and other commands.
var (
	BuildA             bool     // -a flag
	BuildBuildmode     string   // -buildmode flag
	BuildBuildvcs      = "auto" // -buildvcs flag: "true", "false", or "auto"
	BuildContext       = defaultContext()