if (mainModule.testModule.directives.contains(Directives.COPY_RESOLUTION_MODE)) {
            fakeKtFile.originalFile = mainFile
        }

        return collectElementsToResolve(caretPositions, fakeKtFile)
    }

    override fun <R> analyzeReferenceElement(element: KtElement, mainModule: KtTestModule, action: KaSession.() -> R): R {

        }
    }

    override fun doTestByMainFile(mainFile: KtFile, mainModule: KtTestModule, testServices: TestServices) {
        val position = testServices.expressionMarkerProvider.getCaretPosition(mainFile)
        val reference = mainFile.findReferenceAt(position)
        assertNotNull(reference)
        val expectedAlias = mainModule.testModule.directives.singleValue(Directives.TYPE_ALIAS)

            allArgs.add(CollectionUtils.join(File.pathSeparator, rtModulePath));
        }
        allArgs.add("--module");
        if (!mainClass.isPresent()) {
            allArgs.add(mainModule.get());
        } else {
            allArgs.add(mainModule.get() + "/" + mainClass.get());
        }
    }

    @Override
    public void setAllJvmArgs(List<String> arguments) {
        throw new UnsupportedOperationException();

        consumingModuleInfo('exports consumer')
        consumingModuleClass()
        testModuleInfo('requires consumer', 'requires junit')
        testModuleClass('org.junit.Assert.assertEquals("consumer", consumer.MainModule.class.getModule().getName())')

        then:
        succeeds ':test'
    }

        builder.useDirectives(Directives)
    }

    override fun doTestByMainFile(mainFile: KtFile, mainModule: KtTestModule, testServices: TestServices) {
        val ktDeclaration = testServices.expressionMarkerProvider.getElementOfTypeAtCaret<KtDeclaration>(mainFile)
        val classIdString = mainModule.testModule.directives.singleValue(Directives.CLASS_ID)

        val actual = analyseForTest(ktDeclaration) {

        consumingModuleClass('producer.ProducerClass')

        when:
        succeeds ':compileJava'

        then:
        javaClassFile('module-info.class').exists()
        javaClassFile('consumer/MainModule.class').exists()
    }

    def "compiles a non-module using the classpath"() {
        given:
        producingModuleInfo()
        producingModuleClass()
        consumingModuleClass('producer.ProducerClass')

plugins {
    id 'myproject.java-conventions'
    id 'application'
}

dependencies {
    implementation project(':utilities')
}

application {
    mainModule = 'org.gradle.sample.app'
    mainClass = 'org.gradle.sample.app.Main'

            FirErrors.DSL_SCOPE_VIOLATION,
        ).map { it.name }
    }

    override fun doTestByMainFile(mainFile: KtFile, mainModule: KtTestModule, testServices: TestServices) {
        val testFile = mainModule.testModule.files.single { it.name == mainFile.name }

        val annotationToCheckCalls = mainModule.testModule.directives[Directives.CHECK_CALLS_WITH_ANNOTATION].singleOrNull()

abstract class AbstractTypeTest : AbstractAnalysisApiBasedTest() {
    override fun doTestByMainFile(mainFile: KtFile, mainModule: KtTestModule, testServices: TestServices) {
        val actual = analyseForTest(mainFile) {
            val type = getType(analysisSession, mainFile, mainModule, testServices)

            buildString {

plugins {
    id("myproject.java-conventions")
    application
}

dependencies {
    implementation(project(":utilities"))
}

application {
    mainModule = "org.gradle.sample.app"
    mainClass = "org.gradle.sample.app.Main"