number = 456
                add()
            }
            """.trimIndent()
        )

        resolver.resolve(schema, emptyList(), topLevelBlock)

        val document = convertBlockToDocument(topLevelBlock)
        val resolved = resolutionContainer(schema, resolver.trace, document)
        val resolutions = resolved.collectToMap(document).values
        assertEquals(

    ): EvaluationResult<AnalysisStepResult> {
        val failureReasons = mutableListOf<NotEvaluated.StageFailure>()

        val evaluationSchema = step.evaluationSchemaForStep

        val resolver = tracingCodeResolver(evaluationSchema.operationGenerationId, evaluationSchema.analysisStatementFilter)

        val languageModel = languageModelFromLightParser(scriptIdentifier, scriptSource)

import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirOfType
import org.jetbrains.kotlin.analysis.low.level.api.fir.resolver.ResolutionParameters
import org.jetbrains.kotlin.analysis.low.level.api.fir.resolver.SingleCandidateResolutionMode
import org.jetbrains.kotlin.analysis.low.level.api.fir.resolver.SingleCandidateResolver
import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.llFirSession

val string = DataTypeInternal.DefaultStringDataType.ref


val boolean = DataTypeInternal.DefaultBooleanDataType.ref


fun AnalysisSchema.resolve(
    code: String,
    resolver: Resolver = tracingCodeResolver()
): ResolutionResult {
    val parsedTree = parse(code)

    val languageBuilder = DefaultLanguageTreeBuilder()
    val tree = languageBuilder.build(parsedTree, SourceIdentifier("demo"))

        val owner = analysisSession.getClassLikeSymbol(classId) ?: return null
        val firSession = analysisSession.useSiteSession
        val resolver = FirSamResolver(firSession, analysisSession.getScopeSessionFor(firSession))
        return resolver.getSamConstructor(owner)?.let {
            analysisSession.firSymbolBuilder.functionLikeBuilder.buildSamConstructorSymbol(it.symbol)
        }
    }

import org.jetbrains.kotlin.com.intellij.psi.tree.IElementType
import org.junit.jupiter.api.Test
import kotlin.test.assertEquals
import kotlin.test.assertTrue


class ImportTest {
    private
    val resolver = defaultCodeResolver()
    private
    val errorCollector = ErrorCollectorImpl()

    private
    fun testContext(): AnalysisContext {
        return AnalysisContext(
            DefaultAnalysisSchema(

      <artifactId>maven-slf4j-wrapper</artifactId>
    </dependency>
    <dependency>
      <groupId>org.apache.maven.resolver</groupId>
      <artifactId>maven-resolver-api</artifactId>
    </dependency>
    <dependency>
      <groupId>org.apache.maven.resolver</groupId>
      <artifactId>maven-resolver-util</artifactId>
    </dependency>
    <dependency>
      <groupId>org.codehaus.plexus</groupId>

    public fun KtReference.resolveToSymbols(): Collection<KaSymbol> = withValidityAssertion {
        return analysisSession.resolver.resolveToSymbols(this)
    }

    public fun KtReference.resolveToSymbol(): KaSymbol? = withValidityAssertion {
        return analysisSession.resolver.resolveToSymbols(this).singleOrNull()
    }

    /**

import org.gradle.internal.component.model.VariantGraphResolveState;
import org.gradle.internal.model.CalculatedValueContainerFactory;
import org.gradle.internal.resolve.resolver.ArtifactResolver;
import org.gradle.internal.resolve.resolver.DefaultVariantArtifactResolver;
import org.gradle.internal.resolve.resolver.VariantArtifactResolver;

import java.util.function.LongFunction;

/**

			}
			t.Run(name+server, func(t *testing.T) {
				t.Parallel()
				r := DefaultResolver
				if !def {
					r = &Resolver{PreferGo: true}
				}
				fn(t, r, server)
			})
		}
	}
}

func TestNSLookupMX(t *testing.T) {
	testenv.MustHaveExternalNetwork(t)

	testLookup(t, func(t *testing.T, r *Resolver, server string) {
		mx, err := r.LookupMX(context.Background(), server)
		if err != nil {
			t.Fatal(err)
		}