[tests] cleanup (formatting)

GitOrigin-RevId: 636c004316bbe830cabdaeedce29f3c8b509b15e

jps/model-impl/testSrc/org/jetbrains/jps/model/JpsDependenciesEnumeratorTest.java

@@ -4,17 +4,14 @@ package org.jetbrains.jps.model;
 import com.intellij.openapi.application.ex.PathManagerEx;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.project.IntelliJProjectConfiguration;
-import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jps.model.java.*;
 import org.jetbrains.jps.model.library.JpsLibrary;
 import org.jetbrains.jps.model.library.JpsOrderRootType;
 import org.jetbrains.jps.model.library.JpsTypedLibrary;
 import org.jetbrains.jps.model.library.sdk.JpsSdk;
-import org.jetbrains.jps.model.module.JpsLibraryDependency;
 import org.jetbrains.jps.model.module.JpsModule;
 import org.jetbrains.jps.util.JpsPathUtil;
 
-import java.io.File;
 import java.io.IOException;
 import java.util.Collections;
 
@@ -26,16 +23,15 @@ public class JpsDependenciesEnumeratorTest extends JpsJavaModelTestCase {
   @Override
   public void setUp() throws Exception {
     super.setUp();
-    JpsTypedLibrary<JpsSdk<JpsDummyElement>> jdk = addJdk("1.7");
+    var jdk = addJdk("1.7");
     myModule = addModule();
     JpsModuleRootModificationUtil.setModuleSdk(myModule, jdk.getProperties());
   }
 
-  @NotNull
-  private JpsTypedLibrary<JpsSdk<JpsDummyElement>> addJdk(final String mockJdkVersion) {
-    final String mockJdkDir = "mockJDK-" + mockJdkVersion;
-    File home = PathManagerEx.findFileUnderCommunityHome("java/" + mockJdkDir);
-    JpsTypedLibrary<JpsSdk<JpsDummyElement>> jdk = myModel.getGlobal().addSdk(mockJdkVersion, home.getAbsolutePath(), mockJdkVersion, JpsJavaSdkType.INSTANCE);
+  private JpsTypedLibrary<JpsSdk<JpsDummyElement>> addJdk(String mockJdkVersion) {
+    var mockJdkDir = "mockJDK-" + mockJdkVersion;
+    var home = PathManagerEx.findFileUnderCommunityHome("java/" + mockJdkDir);
+    var jdk = myModel.getGlobal().addSdk(mockJdkVersion, home.getAbsolutePath(), mockJdkVersion, JpsJavaSdkType.INSTANCE);
     jdk.addRoot(getRtJar(mockJdkDir), JpsOrderRootType.COMPILED);
     return jdk;
   }
@@ -51,7 +47,7 @@ public class JpsDependenciesEnumeratorTest extends JpsJavaModelTestCase {
   }
 
   private static String getFastUtilSources() {
-    return IntelliJProjectConfiguration.getProjectLibrary("fastutil-min").getSourcesUrls().get(0);
+    return IntelliJProjectConfiguration.getProjectLibrary("fastutil-min").getSourcesUrls().getFirst();
   }
 
   private static String getFastUtilJar() {
@@ -62,7 +58,7 @@ public class JpsDependenciesEnumeratorTest extends JpsJavaModelTestCase {
     return getJarUrlFromProjectLib("byte-buddy");
   }
 
-  private static String getJarUrlFromProjectLib(final String libraryName) {
+  private static String getJarUrlFromProjectLib(String libraryName) {
     return assertOneElement(IntelliJProjectConfiguration.getProjectLibraryClassesRootUrls(libraryName));
   }
 
@@ -74,12 +70,12 @@ public class JpsDependenciesEnumeratorTest extends JpsJavaModelTestCase {
     return getRtJar("mockJDK-1.8");
   }
 
-  private static String getRtJar(final String mockJdkDir) {
+  private static String getRtJar(String mockJdkDir) {
     return JpsPathUtil.getLibraryRootUrl(PathManagerEx.findFileUnderCommunityHome("java/" + mockJdkDir + "/jre/lib/rt.jar"));
   }
 
   private JpsLibrary createJDomLibrary() {
-    JpsLibrary library = addLibrary("jdom");
+    var library = addLibrary("jdom");
     library.addRoot(getFastUtilJar(), JpsOrderRootType.COMPILED);
     library.addRoot(getFastUtilSources(), JpsOrderRootType.SOURCES);
     return library;
@@ -92,10 +88,10 @@ public class JpsDependenciesEnumeratorTest extends JpsJavaModelTestCase {
   }
 
   public void testModuleSources() {
-    final String srcRoot = addSourceRoot(myModule, false);
-    final String testRoot = addSourceRoot(myModule, true);
-    final String output = setModuleOutput(myModule, false);
-    final String testOutput = setModuleOutput(myModule, true);
+    var srcRoot = addSourceRoot(myModule, false);
+    var testRoot = addSourceRoot(myModule, true);
+    var output = setModuleOutput(myModule, false);
+    var testOutput = setModuleOutput(myModule, true);
 
     assertClassRoots(dependencies(myModule).withoutSdk(), testOutput, output);
     assertClassRoots(dependencies(myModule).withoutSdk().productionOnly(), output);
@@ -107,7 +103,7 @@ public class JpsDependenciesEnumeratorTest extends JpsJavaModelTestCase {
   }
 
   public void testLibraryScope() {
-    JpsLibraryDependency dependency = myModule.getDependenciesList().addLibraryDependency(createJDomLibrary());
+    var dependency = myModule.getDependenciesList().addLibraryDependency(createJDomLibrary());
     getJavaService().getOrCreateDependencyExtension(dependency).setScope(JpsJavaDependencyScope.RUNTIME);
     JpsModuleRootModificationUtil.addDependency(myModule, createJDomLibrary(), JpsJavaDependencyScope.RUNTIME, false);
 
@@ -117,18 +113,18 @@ public class JpsDependenciesEnumeratorTest extends JpsJavaModelTestCase {
   }
 
   public void testModuleDependency() {
-    final JpsModule dep = addModule("dep");
-    final String depSrcRoot = addSourceRoot(dep, false);
-    final String depTestRoot = addSourceRoot(dep, true);
-    final String depOutput = setModuleOutput(dep, false);
-    final String depTestOutput = setModuleOutput(dep, true);
+    var dep = addModule("dep");
+    var depSrcRoot = addSourceRoot(dep, false);
+    var depTestRoot = addSourceRoot(dep, true);
+    var depOutput = setModuleOutput(dep, false);
+    var depTestOutput = setModuleOutput(dep, true);
     JpsModuleRootModificationUtil.addDependency(dep, createJDomLibrary(), JpsJavaDependencyScope.COMPILE, true);
     JpsModuleRootModificationUtil.addDependency(myModule, dep, JpsJavaDependencyScope.COMPILE, true);
 
-    final String srcRoot = addSourceRoot(myModule, false);
-    final String testRoot = addSourceRoot(myModule, true);
-    final String output = setModuleOutput(myModule, false);
-    final String testOutput = setModuleOutput(myModule, true);
+    var srcRoot = addSourceRoot(myModule, false);
+    var testRoot = addSourceRoot(myModule, true);
+    var output = setModuleOutput(myModule, false);
+    var testOutput = setModuleOutput(myModule, true);
 
     assertClassRoots(dependencies(myModule).withoutSdk(), testOutput, output, depTestOutput, depOutput);
     assertClassRoots(dependencies(myModule).withoutSdk().recursively(), testOutput, output, depTestOutput, depOutput, getFastUtilJar());
@@ -140,21 +136,26 @@ public class JpsDependenciesEnumeratorTest extends JpsJavaModelTestCase {
     assertEnumeratorRoots(dependencies(myModule).withoutSdk().withoutModuleSourceEntries().recursively().classes(), getFastUtilJar());
     assertEnumeratorRoots(dependencies(myModule).withoutSdk().withoutModuleSourceEntries().recursively().sources(), getFastUtilSources());
 
-    assertEnumeratorRoots(dependencies(myModule).withoutSdk().recursively().classes().withoutSelfModuleOutput(),
-                          output, depTestOutput, depOutput, getFastUtilJar());
-    assertEnumeratorRoots(dependencies(myModule).productionOnly().withoutSdk().recursively().classes().withoutSelfModuleOutput(),
-                          depOutput, getFastUtilJar());
+    assertEnumeratorRoots(
+      dependencies(myModule).withoutSdk().recursively().classes().withoutSelfModuleOutput(),
+      output, depTestOutput, depOutput, getFastUtilJar()
+    );
+    assertEnumeratorRoots(
+      dependencies(myModule).productionOnly().withoutSdk().recursively().classes().withoutSelfModuleOutput(),
+      depOutput, getFastUtilJar()
+    );
 
     assertClassRoots(dependencies(myModule).withoutSdk().withoutDepModules().withoutModuleSourceEntries().recursively(), getFastUtilJar());
     assertEnumeratorRoots(
       dependencies(myModule).productionOnly().withoutSdk().withoutDepModules().withoutModuleSourceEntries().recursively().classes(),
-      getFastUtilJar());
+      getFastUtilJar()
+    );
     assertClassRoots(dependencies(myModule).withoutSdk().withoutDepModules().withoutModuleSourceEntries());
     assertEnumeratorRoots(dependencies(myModule).productionOnly().withoutModuleSourceEntries().withoutSdk().withoutDepModules().classes());
   }
 
   public void testModuleJpsJavaDependencyScope() {
-    final JpsModule dep = addModule("dep");
+    var dep = addModule("dep");
     JpsModuleRootModificationUtil.addDependency(dep, createJDomLibrary(), JpsJavaDependencyScope.COMPILE, true);
     JpsModuleRootModificationUtil.addDependency(myModule, dep, JpsJavaDependencyScope.TEST, true);
 
@@ -168,7 +169,7 @@ public class JpsDependenciesEnumeratorTest extends JpsJavaModelTestCase {
   }
 
   public void testNotExportedLibrary() {
-    final JpsModule dep = addModule("dep");
+    var dep = addModule("dep");
     JpsModuleRootModificationUtil.addDependency(dep, createJDomLibrary(), JpsJavaDependencyScope.COMPILE, false);
     JpsModuleRootModificationUtil.addDependency(myModule, createSampleLibrary(), JpsJavaDependencyScope.COMPILE, false);
     JpsModuleRootModificationUtil.addDependency(myModule, dep, JpsJavaDependencyScope.COMPILE, false);
@@ -180,13 +181,13 @@ public class JpsDependenciesEnumeratorTest extends JpsJavaModelTestCase {
   }
 
   public void testAnnotations() {
-    JpsLibrary library = addLibrary();
-    String libraryUrl = "temp:///library";
+    var library = addLibrary();
+    var libraryUrl = "temp:///library";
     library.addRoot(libraryUrl, JpsAnnotationRootType.INSTANCE);
     JpsModuleRootModificationUtil.addDependency(myModule, library);
     assertEnumeratorRoots(dependencies(myModule).annotations(), libraryUrl);
 
-    String moduleUrl = "temp://module";
+    var moduleUrl = "temp://module";
     JpsJavaExtensionService.getInstance().getOrCreateModuleExtension(myModule).getAnnotationRoots().addUrl(moduleUrl);
     assertEnumeratorRoots(dependencies(myModule).annotations(), moduleUrl, libraryUrl);
   }
@@ -196,8 +197,8 @@ public class JpsDependenciesEnumeratorTest extends JpsJavaModelTestCase {
   }
 
   public void testDoNotAddJdkRootsFromModuleDependency() {
-    JpsModule dep = addModule("dep");
-    JpsTypedLibrary<JpsSdk<JpsDummyElement>> jdk8 = addJdk("1.8");
+    var dep = addModule("dep");
+    var jdk8 = addJdk("1.8");
     JpsModuleRootModificationUtil.addDependency(myModule, dep);
     JpsModuleRootModificationUtil.setModuleSdk(dep, jdk8.getProperties());
     assertClassRoots(dependencies(myModule).recursively(), getRtJarJdk17());
@@ -207,10 +208,10 @@ public class JpsDependenciesEnumeratorTest extends JpsJavaModelTestCase {
   public void testProject() {
     JpsModuleRootModificationUtil.addDependency(myModule, createJDomLibrary());
 
-    final String srcRoot = addSourceRoot(myModule, false);
-    final String testRoot = addSourceRoot(myModule, true);
-    final String output = setModuleOutput(myModule, false);
-    final String testOutput = setModuleOutput(myModule, true);
+    var srcRoot = addSourceRoot(myModule, false);
+    var testRoot = addSourceRoot(myModule, true);
+    var output = setModuleOutput(myModule, false);
+    var testOutput = setModuleOutput(myModule, true);
 
     assertClassRoots(dependencies(myProject).withoutSdk(), testOutput, output, getFastUtilJar());
     assertSourceRoots(dependencies(myProject).withoutSdk(), srcRoot, testRoot, getFastUtilSources());
@@ -219,15 +220,19 @@ public class JpsDependenciesEnumeratorTest extends JpsJavaModelTestCase {
   public void testModules() {
     JpsModuleRootModificationUtil.addDependency(myModule, createJDomLibrary());
 
-    final String srcRoot = addSourceRoot(myModule, false);
-    final String testRoot = addSourceRoot(myModule, true);
-    final String output = setModuleOutput(myModule, false);
-    final String testOutput = setModuleOutput(myModule, true);
+    var srcRoot = addSourceRoot(myModule, false);
+    var testRoot = addSourceRoot(myModule, true);
+    var output = setModuleOutput(myModule, false);
+    var testOutput = setModuleOutput(myModule, true);
 
-    assertClassRoots(getJavaService().enumerateDependencies(Collections.singletonList(myModule)).withoutSdk(),
-                     testOutput, output, getFastUtilJar());
-    assertSourceRoots(getJavaService().enumerateDependencies(Collections.singletonList(myModule)).withoutSdk(),
-                      srcRoot, testRoot, getFastUtilSources());
+    assertClassRoots(
+      getJavaService().enumerateDependencies(Collections.singletonList(myModule)).withoutSdk(),
+      testOutput, output, getFastUtilJar()
+    );
+    assertSourceRoots(
+      getJavaService().enumerateDependencies(Collections.singletonList(myModule)).withoutSdk(),
+      srcRoot, testRoot, getFastUtilSources()
+    );
   }
 
   public void testIncludeTestsFromDependentModules() throws IOException {
@@ -247,20 +252,16 @@ public class JpsDependenciesEnumeratorTest extends JpsJavaModelTestCase {
 
     try (var ignored = TestJpsDependenciesEnumerationHandler.Companion.addModule(myModule, false)) {
       // modified with a handler: do NOT add test roots from dependent modules
-      assertSourceRoots(
-        getJavaService().enumerateDependencies(Collections.singletonList(myModule)).withoutSdk()
-      );
-      assertSourceRoots(
-        getJavaService().enumerateDependencies(Collections.singletonList(myModule)).recursively().withoutSdk()
-      );
+      assertSourceRoots(getJavaService().enumerateDependencies(Collections.singletonList(myModule)).withoutSdk());
+      assertSourceRoots(getJavaService().enumerateDependencies(Collections.singletonList(myModule)).recursively().withoutSdk());
     }
   }
 
   private String setModuleOutput(JpsModule module, boolean tests) {
     try {
-      File file = FileUtil.createTempDirectory(module.getName(), tests ? "testSrc" : "src");
-      JpsJavaModuleExtension extension = getJavaService().getOrCreateModuleExtension(module);
-      String url = JpsPathUtil.getLibraryRootUrl(file);
+      var file = FileUtil.createTempDirectory(module.getName(), tests ? "testSrc" : "src");
+      var extension = getJavaService().getOrCreateModuleExtension(module);
+      var url = JpsPathUtil.getLibraryRootUrl(file);
       if (tests) {
         extension.setTestOutputUrl(url);
       }
@@ -276,7 +277,7 @@ public class JpsDependenciesEnumeratorTest extends JpsJavaModelTestCase {
 
   private static String addSourceRoot(JpsModule module, boolean tests) {
     try {
-      File file = FileUtil.createTempDirectory(module.getName(), tests ? "testSrc" : "src");
+      var file = FileUtil.createTempDirectory(module.getName(), tests ? "testSrc" : "src");
       return module.addSourceRoot(JpsPathUtil.getLibraryRootUrl(file), tests ? JavaSourceRootType.TEST_SOURCE : JavaSourceRootType.SOURCE).getUrl();
     }
     catch (IOException e) {
@@ -284,11 +285,11 @@ public class JpsDependenciesEnumeratorTest extends JpsJavaModelTestCase {
     }
   }
 
-  private static void assertClassRoots(final JpsJavaDependenciesEnumerator enumerator, String... urls) {
+  private static void assertClassRoots(JpsJavaDependenciesEnumerator enumerator, String... urls) {
     assertEnumeratorRoots(enumerator.classes(), urls);
   }
 
-  private static void assertSourceRoots(final JpsJavaDependenciesEnumerator enumerator, String... urls) {
+  private static void assertSourceRoots(JpsJavaDependenciesEnumerator enumerator, String... urls) {
     assertEnumeratorRoots(enumerator.sources(), urls);
   }
 

platform/testFramework/src/com/intellij/project/IntelliJProjectConfiguration.kt

@@ -1,7 +1,6 @@
 // Copyright 2000-2025 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
 package com.intellij.project
 
-import com.intellij.application.options.PathMacrosImpl
 import com.intellij.openapi.application.PathManager
 import com.intellij.openapi.util.NlsSafe
 import com.intellij.openapi.util.io.FileUtil
@@ -17,7 +16,6 @@ import org.jetbrains.jps.model.library.JpsOrderRootType
 import org.jetbrains.jps.model.serialization.JpsMavenSettings.getMavenRepositoryPath
 import org.jetbrains.jps.model.serialization.JpsSerializationManager
 import org.jetbrains.jps.util.JpsPathUtil
-import java.io.File
 import java.nio.file.Path
 import kotlin.io.path.invariantSeparatorsPathString
 import kotlin.io.path.isDirectory
@@ -27,28 +25,24 @@ import kotlin.io.path.isDirectory
  * without hard-coding paths to their JARs.
  */
 class IntelliJProjectConfiguration {
-  private val projectHome = PathManager.getHomePath()
+  private val projectHome = PathManager.getHomeDir().toString()
   private val projectLibraries: Map<String, LibraryRoots>
   private val moduleLibraries: Map<String, Map<String, LibraryRoots>>
-
   private val remoteRepositoryDescriptions: List<JpsRemoteRepositoryDescription>
 
   init {
     val project = loadIntelliJProject(projectHome)
-    fun extractLibrariesRoots(collection: JpsLibraryCollection): Map<@NlsSafe String, LibraryRoots> {
-      return collection.libraries.associateBy(keySelector = { it.name }, valueTransform = {
+    fun extractLibrariesRoots(collection: JpsLibraryCollection): Map<@NlsSafe String, LibraryRoots> =
+      collection.libraries.associateBy(keySelector = { it.name }, valueTransform = {
         LibraryRoots(
           classes = java.util.List.copyOf(it.getFiles(JpsOrderRootType.COMPILED)),
           sources = java.util.List.copyOf(it.getFiles(JpsOrderRootType.SOURCES)),
         )
       })
-    }
     projectLibraries = extractLibrariesRoots(project.libraryCollection)
-    moduleLibraries = project.modules.associateBy({it.name}, {
-      val libraries = extractLibrariesRoots(it.libraryCollection)
-      libraries.ifEmpty { emptyMap() }
+    moduleLibraries = project.modules.associateBy(keySelector = {it.name}, valueTransform = {
+      extractLibrariesRoots(it.libraryCollection).ifEmpty { emptyMap() }
     })
-
     remoteRepositoryDescriptions = JpsRemoteRepositoryService.getInstance().getRemoteRepositoriesConfiguration(project)!!.repositories
   }
 
@@ -56,55 +50,42 @@ class IntelliJProjectConfiguration {
     private val instance by lazy { IntelliJProjectConfiguration() }
 
     @JvmStatic
-    fun getRemoteRepositoryDescriptions() : List<JpsRemoteRepositoryDescription> {
-      return instance.remoteRepositoryDescriptions
-    }
+    fun getRemoteRepositoryDescriptions() : List<JpsRemoteRepositoryDescription> = instance.remoteRepositoryDescriptions
 
     @JvmStatic
-    fun getProjectLibraryClassesRootPaths(libraryName: String): List<String> {
-      return getProjectLibrary(libraryName).classesPaths
-    }
+    fun getProjectLibraryClassesRootPaths(libraryName: String): List<String> = getProjectLibrary(libraryName).classesPaths
 
     @JvmStatic
-    fun getProjectLibraryClassesRootUrls(libraryName: String): List<String> {
-      return getProjectLibrary(libraryName).classesUrls
-    }
+    fun getProjectLibraryClassesRootUrls(libraryName: String): List<String> = getProjectLibrary(libraryName).classesUrls
 
     @JvmStatic
-    fun getProjectLibrary(libraryName: String): LibraryRoots {
-      return instance.projectLibraries[libraryName]
-             ?: throw IllegalArgumentException("Cannot find project library '$libraryName' in ${instance.projectHome}")
-    }
+    fun getProjectLibrary(libraryName: String): LibraryRoots =
+      instance.projectLibraries[libraryName]
+      ?: throw IllegalArgumentException("Cannot find project library '$libraryName' in ${instance.projectHome}")
 
     @JvmStatic
-    fun getModuleLibrary(moduleName: String, libraryName: String): LibraryRoots {
-      val moduleLibraries = instance.moduleLibraries[moduleName]
-                            ?: throw IllegalArgumentException("Cannot find module '$moduleName' in ${instance.projectHome}")
-      return moduleLibraries[libraryName]
-             ?: throw IllegalArgumentException("Cannot find module library '$libraryName' in $moduleName")
-    }
+    fun getModuleLibrary(moduleName: String, libraryName: String): LibraryRoots =
+      (instance.moduleLibraries[moduleName] ?: throw IllegalArgumentException("Cannot find module '$moduleName' in ${instance.projectHome}")).let {
+        it[libraryName] ?: throw IllegalArgumentException("Cannot find module library '$libraryName' in $moduleName")
+      }
 
     @JvmStatic
-    fun getJarFromSingleJarProjectLibrary(projectLibraryName: String): VirtualFile {
-      return getVirtualFile(getProjectLibrary(projectLibraryName))
-    }
+    fun getJarFromSingleJarProjectLibrary(projectLibraryName: String): VirtualFile = getVirtualFile(getProjectLibrary(projectLibraryName))
 
     @JvmStatic
-    fun getVirtualFile(lib: LibraryRoots): VirtualFile {
-      val url = lib.classesUrls.single()
-      return VirtualFileManager.getInstance().refreshAndFindFileByUrl(url)
-             ?: throw IllegalStateException("Cannot find virtual file by $url (nio file exists: ${lib.classes.single().exists()})")
-    }
+    fun getVirtualFile(lib: LibraryRoots): VirtualFile =
+      lib.classesUrls.single().let { url ->
+        VirtualFileManager.getInstance().refreshAndFindFileByUrl(url)
+        ?: throw IllegalStateException("Cannot find virtual file by $url (nio file exists: ${lib.classes.single().exists()})")
+      }
 
     @JvmStatic
-    fun getJarPathFromSingleJarProjectLibrary(libName: String): Path {
-      return getProjectLibrary(libName).classes.single().toPath()
-    }
+    fun getJarPathFromSingleJarProjectLibrary(libName: String): Path = getProjectLibrary(libName).classes.single().toPath()
 
     @JvmStatic
     fun loadIntelliJProject(projectHome: String): JpsProject {
       val m2Repo = getLocalMavenRepo().invariantSeparatorsPathString
-      val project = JpsSerializationManager.getInstance().loadProject(projectHome, mapOf(PathMacrosImpl.MAVEN_REPOSITORY to m2Repo), true)
+      val project = JpsSerializationManager.getInstance().loadProject(projectHome, mapOf("MAVEN_REPOSITORY" to m2Repo), true)
       val pathUtilJarPath = Path.of(PathUtil.getJarPathForClass(PathUtil::class.java))
       val outPath: Path?
       val jpsJavaProjectExtension = JpsJavaExtensionService.getInstance().getOrCreateProjectExtension(project)
@@ -122,7 +103,7 @@ class IntelliJProjectConfiguration {
     fun getLocalMavenRepo(): Path = Path.of(getMavenRepositoryPath())
   }
 
-  class LibraryRoots(val classes: List<File>, val sources: List<File>) {
+  class LibraryRoots(val classes: List<java.io.File>, val sources: List<java.io.File>) {
     val classesPaths: List<String>
       get() = classes.map { FileUtil.toSystemIndependentName(it.absolutePath) }