ideaProject.modules.find { it.name == 'child3' }.jdkName == null
    }

    @TargetGradleVersion(">=3.0 <3.4")
    def "jdkName property from idea module model is not available in the tooling before 3.4"() {
        when:
        def ideaProject = withConnection { connection -> connection.getModel(IdeaProject) }
        ideaProject.modules.find { it.name == 'root' }.jdkName

        then:

        buildFile.text = """
apply plugin: 'java'
apply plugin: 'idea'

idea.project {
  languageLevel = '1.5'
  jdkName = '1.6'
}
"""

        when:
        IdeaProject project = loadToolingModel(IdeaProject)

        then:
        project.languageLevel.level == "JDK_1_5"
        project.jdkName == '1.6'
    }

    def "provides all modules"() {

        file('build.gradle').text = '''
subprojects {

        checkModel(actual, expected, [
            { it.parent },
            { it.name },
            { it.description },
            { it.jdkName },
            { it.languageLevel.level },
            [{ it.children }, { a, e -> checkIdeaModule(a, e) }],
        ])
    }

            }
        )
        compilerConfig.get(JVMConfigurationKeys.JDK_HOME)?.let { jdkHome ->
            addRegularDependency(
                buildKtSdkModule {
                    this.platform = platform
                    addBinaryRootsFromJdkHome(jdkHome.toPath(), isJre = false)
                    sdkName = "JDK for $moduleName"
                }
            )
        }
    }

    private TestFile createJdkInstallation(String version) {
        def jdkHome = temporaryFolder.createDir("jdk-$version")
        def binDir = jdkHome.createDir("bin")
        binDir.createFile(OperatingSystem.current().getExecutableName("java"))
        return jdkHome
    }

    private TestFile createJreInstallation(String version) {
        def jdkHome = temporaryFolder.createDir("jdk-$version")

                        locations.add(resolvedValue.toString());
                    }
                }
                return locations.stream()
                    .map(jdkHome -> InstallationLocation.autoDetected(new File(jdkHome), getSourceName()))
                    .collect(Collectors.toSet());
            } catch (IOException | ParserConfigurationException | SAXException | XPathExpressionException e) {

            languageVersionSettings,
            jdkHome,
        )
    }

    private fun initialiseVirtualFileFinderServices(
        environment: KotlinCoreProjectEnvironment,
        modules: List<KtModule>,
        sourceFiles: List<PsiFileSystemItem>,
        languageVersionSettings: LanguageVersionSettings,
        jdkHome: Path?,
    ) {
        val project = environment.project

    override val contentScope: GlobalSearchScope,
    override val platform: TargetPlatform,
    override val project: Project,
    private val binaryRoots: Collection<Path>,
    override val sdkName: String,
) : KtSdkModule, KtModuleWithPlatform {
    override val transitiveDependsOnDependencies: List<KtModule> by lazy {
        computeTransitiveDependsOnDependencies(directDependsOnDependencies)
    }

                        addBinaryRootsFromJdkHome(Paths.get(System.getProperty("java.home")), isJre = false)
                        platform = JvmPlatforms.defaultJvmPlatform
                        sdkName = "JDK"
                    }
                )
                sourceModule = addModule(
                    buildKtSourceModule {
                        addSourceRoot(testDataPath("jdkClassUsage"))

                    systemPath = systemPath.replace('/', File.separatorChar).replace('\\', File.separatorChar);
                    String jdkHome = request.getSystemProperties().get("java.home") + File.separator + "..";
                    if (systemPath.startsWith(jdkHome)) {
                        msg += ". Please verify that you run Maven using a JDK and not just a JRE.";
                    }
                    addViolation(