super.configureTest(builder)
        builder.useDirectives(Directives)
    }

    override fun doTestByMainFile(mainFile: KtFile, mainModule: KtTestModule, testServices: TestServices) {
        val elementsByMarker = collectElementsToResolve(mainFile, mainModule, testServices).groupBy { it.marker }
        val actual = prettyPrint {
            printMap(
                map = elementsByMarker,

// tag::mainClass-conf[]
application {
    mainClass = "org.gradle.sample.Main"
}
// end::mainClass-conf[]

// tag::mainModule-conf[]
application {
    mainModule = "org.gradle.sample.app" // name defined in module-info.java
    mainClass = "org.gradle.sample.Main"
}
// end::mainModule-conf[]

// tag::application-defaultjvmargs[]
application {
    applicationDefaultJvmArgs = listOf("-Dgreeting.language=en")
}

        when:
        consumingModuleInfo('requires moda')
        succeeds ':compileJava'

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

    def "detects change from library to module"() {
        when:
        publishJavaLibrary('moda')
        consumingModuleInfo('requires moda')

        mainFile: KtFile,
        mainModule: KtTestModule,
        testServices: TestServices
    ): String = generateResolveOutput(context.element, testServices)

    abstract fun generateResolveOutput(mainElement: KtElement, testServices: TestServices): String

    override fun collectElementsToResolve(
        mainFile: KtFile,
        mainModule: KtTestModule,
        testServices: TestServices,

        consumingModuleClass('moda.ModaClass')

        when:
        succeeds ':compileJava'

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

    def "compiles a non-module using the classpath"() {
        given:
        publishJavaModule('moda')
        consumingModuleClass('moda.ModaClass', 'moda.internal.ModaClassInternal')

        context: ResolveTestCaseContext<KtReference?>,
        mainFile: KtFile,
        mainModule: KtTestModule,
        testServices: TestServices,
    ): String {
        val reference = context.element ?: return "no references found"

        return analyzeReferenceElement(reference.element, mainModule) {
            val symbols = reference.resolveToSymbols()
            val symbolsAgain = reference.resolveToSymbols()

        def mainModule = mavenRepo.module(group, module, version)
        mainModule.assertArtifactsPublished(getMainModuleArtifacts(module, version))
        assert mainModule.parsedPom.scopes.size() == apiDependencies.isEmpty() ? 0 : 1
        if (!apiDependencies.isEmpty()) {
            mainModule.parsedPom.scopes.compile.assertDependsOn(apiDependencies as String[])
        }

    override fun KaSession.getScope(mainFile: KtFile, testServices: TestServices): KaScope = mainFile.getFileSymbol().getFileScope()

    override fun doTestByMainFile(mainFile: KtFile, mainModule: KtTestModule, testServices: TestServices) {
        super.doTestByMainFile(mainFile, mainModule, testServices)

        analyseForTest(mainFile) {
            val fileSymbol = mainFile.getFileSymbol()

import org.jetbrains.kotlin.test.services.assertions

abstract class AbstractContainingModuleByFileTest : AbstractAnalysisApiBasedTest() {
    override fun doTestByMainFile(mainFile: KtFile, mainModule: KtTestModule, testServices: TestServices) {
        analyseForTest(mainFile) {
            val fileSymbol = mainFile.getFileSymbol()
            val module = fileSymbol.getContainingModule()

    private final Property<String> mainModule;
    private final Property<String> mainClass;

    public DefaultJavaApplication(@SuppressWarnings("deprecation") org.gradle.api.plugins.ApplicationPluginConvention convention, ObjectFactory objectFactory, ProviderFactory providerFactory) {
        this.convention = convention;
        this.mainModule = objectFactory.property(String.class);