[junit] Move JUnit tests from java.tests to junit.java.tests module

Splits the JUnit configuration tests from Application configuration tests and inverses the dependency between `java.tests` and `junit.java.tests`.


(cherry picked from commit 062a96590e6f07f252f429e79e7d9ea46768c88e)

IJ-MR-153625

GitOrigin-RevId: 103c768ee584fb1565d94c4ce72d07ef44f18fa9

java/java-tests/intellij.java.tests.iml

@@ -90,7 +90,6 @@
     <orderEntry type="module" module-name="intellij.platform.util" scope="TEST" />
     <orderEntry type="module" module-name="intellij.platform.core" scope="TEST" />
     <orderEntry type="module" module-name="intellij.tools.ide.metrics.benchmark" scope="TEST" />
-    <orderEntry type="module" module-name="intellij.junit.java.tests" scope="TEST" />
     <orderEntry type="module" module-name="intellij.platform.util.coroutines" scope="TEST" />
     <orderEntry type="module" module-name="intellij.platform.navbar.testFramework" scope="TEST" />
     <orderEntry type="module" module-name="intellij.java.unscramble" scope="TEST" />

java/java-tests/testSrc/com/intellij/java/execution/ApplicationConfigurationFromEditorTest.java

@@ -0,0 +1,36 @@
+// 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.java.execution;
+
+import com.intellij.execution.RunnerAndConfigurationSettings;
+import com.intellij.execution.actions.ConfigurationContext;
+import com.intellij.openapi.actionSystem.ActionPlaces;
+import com.intellij.openapi.actionSystem.CommonDataKeys;
+import com.intellij.testFramework.MapDataContext;
+import com.intellij.testFramework.fixtures.LightJavaCodeInsightFixtureTestCase;
+
+public class ApplicationConfigurationFromEditorTest extends LightJavaCodeInsightFixtureTestCase {
+  public void testApplicationConfigurationForUnknownMethod() {
+    assertNull(setupConfigurationContext("""
+                                           public class Foo {
+                                             public static void x<caret>xx(String[] args) {}
+                                           }"""));
+    assertNotNull(setupConfigurationContext("""
+                                              public class Foo {
+                                                public static void m<caret>ain(String[] args) {}
+                                              }"""));
+  }
+
+  private <T> T setupConfigurationContext(final String fileText) {
+    myFixture.configureByText("MyTest.java", fileText);
+
+    MapDataContext dataContext = new MapDataContext();
+    dataContext.put(CommonDataKeys.PROJECT, myFixture.getProject());
+    dataContext.put(CommonDataKeys.EDITOR, myFixture.getEditor());
+    dataContext.put(CommonDataKeys.PSI_FILE, myFixture.getFile());
+
+    ConfigurationContext context = ConfigurationContext.getFromContext(dataContext, ActionPlaces.UNKNOWN);
+    RunnerAndConfigurationSettings settings = context.getConfiguration();
+    //noinspection unchecked
+    return settings != null ? (T)settings.getConfiguration() : null;
+  }
+}

java/java-tests/testSrc/com/intellij/java/execution/ApplicationConfigurationRefactoringsTest.java

@@ -0,0 +1,106 @@
+// 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.java.execution;
+
+import com.intellij.execution.RunManager;
+import com.intellij.execution.application.ApplicationConfiguration;
+import com.intellij.execution.configurations.RunConfiguration;
+import com.intellij.execution.configurations.RuntimeConfigurationException;
+import com.intellij.execution.impl.RunManagerImpl;
+import com.intellij.execution.impl.RunnerAndConfigurationSettingsImpl;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.psi.*;
+import com.intellij.refactoring.PackageWrapper;
+import com.intellij.refactoring.move.moveClassesOrPackages.MoveClassesOrPackagesProcessor;
+import com.intellij.refactoring.move.moveClassesOrPackages.SingleSourceRootMoveDestination;
+import com.intellij.refactoring.rename.RenameProcessor;
+import com.intellij.testFramework.MapDataContext;
+import org.jetbrains.annotations.NotNull;
+
+public class ApplicationConfigurationRefactoringsTest extends BaseConfigurationTestCase {
+  private static final String APPLICATION_CODE = "public class Application {" +
+                                                 "  public static void main(String[] args) {\n" +
+                                                 "  }" +
+                                                 "}";
+  private TestSources mySource;
+
+  public void testRenameApplication() {
+    PsiClass psiClass = mySource.createClass("Application", APPLICATION_CODE);
+    assertNotNull(psiClass);
+    ApplicationConfiguration configuration = createConfiguration(psiClass);
+    assertNotNull(configuration);
+    rename(psiClass, "NewName");
+    try {
+      configuration.checkConfiguration();
+    }
+    catch (RuntimeConfigurationException e) {
+      fail("Unexpected ConfigurationException: " + e);
+    }
+    assertEquals("NewName", configuration.getMainClassName());
+  }
+
+  public void testMoveApplication() {
+    PsiClass psiClass = mySource.createClass("Application", APPLICATION_CODE);
+    assertNotNull(psiClass);
+    ApplicationConfiguration configuration = createConfiguration(psiClass);
+    move(psiClass, "pkg");
+    try {
+      configuration.checkConfiguration();
+    }
+    catch (RuntimeConfigurationException e) {
+      fail("Unexpected ConfigurationException: " + e);
+    }
+
+    assertEquals("pkg.Application", configuration.getMainClassName());
+    rename(JavaPsiFacade.getInstance(myProject).findPackage("pkg"), "pkg2");
+    assertEquals("pkg2.Application", configuration.getMainClassName());
+  }
+
+  private void initModule() {
+    mySource.initModule();
+    mySource.copyJdkFrom(myModule);
+  }
+
+  private void move(final PsiElement psiElement, String packageName) {
+    VirtualFile pkgFile = mySource.createPackageDir(packageName);
+    final PsiDirectory toDir = PsiManager.getInstance(myProject).findDirectory(pkgFile);
+    assertNotNull(toDir);
+    PackageWrapper wrapper = PackageWrapper.create(JavaDirectoryService.getInstance().getPackage(toDir));
+    new MoveClassesOrPackagesProcessor(myProject, new PsiElement[]{psiElement},
+                                       new SingleSourceRootMoveDestination(wrapper, toDir),
+                                       false, false, null).run();
+  }
+
+  private void rename(final PsiElement psiElement, final String newName) {
+    new RenameProcessor(myProject, psiElement, newName, false, false).run();
+  }
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+
+    mySource = new TestSources(myProject, getTempDir());
+    initModule();
+  }
+
+  @Override
+  protected void tearDown() throws Exception {
+    try {
+      mySource.tearDown();
+      mySource = null;
+    }
+    catch (Throwable e) {
+      addSuppressedException(e);
+    }
+    finally {
+      super.tearDown();
+    }
+  }
+
+  @Override
+  protected <T extends RunConfiguration> T createConfiguration(@NotNull PsiElement psiClass, @NotNull MapDataContext dataContext) {
+    T configuration = super.createConfiguration(psiClass, dataContext);
+    RunManagerImpl manager = (RunManagerImpl)RunManager.getInstance(myProject);
+    manager.setTemporaryConfiguration(new RunnerAndConfigurationSettingsImpl(manager, configuration, false));
+    return configuration;
+  }
+}

java/java-tests/testSrc/com/intellij/java/execution/ApplicationConfigurationTest.java

@@ -0,0 +1,37 @@
+// 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.java.execution;
+
+import com.intellij.execution.RunConfigurationConfigurableAdapter;
+import com.intellij.execution.application.ApplicationConfigurable;
+import com.intellij.execution.application.ApplicationConfiguration;
+import com.intellij.execution.ui.CommonJavaParametersPanel;
+import com.intellij.openapi.options.Configurable;
+import com.intellij.openapi.options.ConfigurationException;
+import com.intellij.openapi.util.Disposer;
+import com.intellij.testFramework.PlatformTestUtil;
+
+public class ApplicationConfigurationTest extends BaseConfigurationTestCase {
+  public void testCreatingApplicationConfiguration() throws ConfigurationException {
+    if (PlatformTestUtil.COVERAGE_ENABLED_BUILD) return;
+
+    ApplicationConfiguration configuration = new ApplicationConfiguration(null, myProject);
+    ApplicationConfigurable editor = new ApplicationConfigurable(myProject);
+    try {
+      editor.getComponent(); // To get all the watchers installed.
+      Configurable configurable = new RunConfigurationConfigurableAdapter(editor, configuration);
+      configurable.reset();
+      CommonJavaParametersPanel javaParameters = editor.getCommonProgramParameters();
+      javaParameters.setProgramParameters("prg");
+      javaParameters.setVMParameters("vm");
+      javaParameters.setWorkingDirectory("dir");
+      assertTrue(configurable.isModified());
+      configurable.apply();
+      assertEquals("prg", configuration.getProgramParameters());
+      assertEquals("vm", configuration.getVMParameters());
+      assertEquals("dir", configuration.getWorkingDirectory());
+    }
+    finally {
+      Disposer.dispose(editor);
+    }
+  }
+}

java/java-tests/testSrc/com/intellij/java/execution/ApplicationContextConfigurationTest.java

@@ -0,0 +1,59 @@
+// 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.java.execution;
+
+import com.intellij.execution.actions.CreateAction;
+import com.intellij.execution.application.ApplicationConfiguration;
+import com.intellij.execution.executors.DefaultRunExecutor;
+import com.intellij.execution.impl.RunManagerImpl;
+import com.intellij.execution.impl.RunnerAndConfigurationSettingsImpl;
+import com.intellij.execution.runners.ExecutionEnvironment;
+import com.intellij.execution.runners.ExecutionEnvironmentBuilder;
+import com.intellij.openapi.actionSystem.AnActionEvent;
+import com.intellij.openapi.actionSystem.ExecutionDataKeys;
+import com.intellij.openapi.application.ex.PathManagerEx;
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiMethod;
+import com.intellij.testFramework.MapDataContext;
+import com.intellij.testFramework.TestActionEvent;
+import org.jetbrains.annotations.NotNull;
+
+public class ApplicationContextConfigurationTest extends BaseConfigurationTestCase {
+  private static final String PACKAGE_NAME = "apackage";
+  private static final String SHORT_CLASS_NAME = "SampleClass";
+  private static final String CLASS_NAME = PACKAGE_NAME + "." + SHORT_CLASS_NAME;
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    addModule("commonConfiguration");
+  }
+
+  public void testApplication() {
+    PsiClass psiClass = findClass(getModule1(), CLASS_NAME);
+    PsiMethod psiMethod = psiClass.findMethodsByName("main", false)[0];
+    ApplicationConfiguration configuration = createConfiguration(psiMethod);
+    assertEquals(CLASS_NAME, configuration.getMainClassName());
+    assertEquals(configuration.suggestedName(), configuration.getName());
+    assertEquals(SHORT_CLASS_NAME, configuration.getName());
+  }
+
+  public void testApplicationFromConsoleContext() {
+    PsiClass psiClass = findClass(getModule1(), CLASS_NAME);
+    PsiMethod psiMethod = psiClass.findMethodsByName("main", false)[0];
+    ApplicationConfiguration configuration = createConfiguration(psiMethod);
+    RunnerAndConfigurationSettingsImpl settings =
+      new RunnerAndConfigurationSettingsImpl(RunManagerImpl.getInstanceImpl(myProject), configuration);
+    ExecutionEnvironment e = ExecutionEnvironmentBuilder.createOrNull(DefaultRunExecutor.getRunExecutorInstance(), settings).build();
+    MapDataContext dataContext = new MapDataContext();
+    dataContext.put(ExecutionDataKeys.EXECUTION_ENVIRONMENT, e);
+    AnActionEvent event = TestActionEvent.createTestEvent(dataContext);
+    new CreateAction().update(event);
+    assertTrue(event.getPresentation().isEnabledAndVisible());
+  }
+
+  @Override
+  @NotNull
+  protected String getTestDataPath() {
+    return PathManagerEx.getTestDataPath();
+  }
+}

java/java-tests/testSrc/com/intellij/java/execution/ApplicationModulePathTest.java

@@ -1,4 +1,4 @@
-// Copyright 2000-2024 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
+// 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.java.execution;
 
 import com.intellij.compiler.CompilerConfiguration;
@@ -30,8 +30,6 @@ import com.intellij.util.PathsList;
 import java.io.File;
 
 public class ApplicationModulePathTest extends BaseConfigurationTestCase {
-
-
   public void testAdditionalModules() throws Exception {
     ApplicationConfiguration configuration = setupConfiguration(getTestName(true), myModule);
     configuration.setVMParameters("--add-modules java.se,java.xml.bind");

java/java-tests/testSrc/com/intellij/java/execution/BaseConfigurationTestCase.java

@@ -1,4 +1,4 @@
-// Copyright 2000-2021 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
+// 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.java.execution;
 
 import com.intellij.execution.Location;
@@ -8,14 +8,12 @@ import com.intellij.execution.actions.ConfigurationContext;
 import com.intellij.execution.actions.ConfigurationFromContext;
 import com.intellij.execution.actions.RunConfigurationProducer;
 import com.intellij.execution.configurations.RunConfiguration;
-import com.intellij.execution.junit.JUnitConfiguration;
 import com.intellij.execution.junit.JUnitUtil;
 import com.intellij.execution.testframework.AbstractJavaTestConfigurationProducer;
 import com.intellij.openapi.actionSystem.ActionPlaces;
 import com.intellij.openapi.actionSystem.CommonDataKeys;
 import com.intellij.openapi.actionSystem.PlatformCoreDataKeys;
 import com.intellij.openapi.application.WriteAction;
-import com.intellij.openapi.application.ex.PathManagerEx;
 import com.intellij.openapi.module.Module;
 import com.intellij.openapi.module.ModuleManager;
 import com.intellij.openapi.module.ModuleUtilCore;
@@ -114,9 +112,12 @@ public abstract class BaseConfigurationTestCase extends JavaProjectTestCase {
     return result;
   }
 
-  protected static VirtualFile findFile(String path) {
-    String filePath = PathManagerEx.getTestDataPath() + File.separator + "junit" + File.separator + "configurations" +
-                      File.separator + path;
+  protected @NotNull String getTestDataPath() {
+    return "";
+  };
+
+  protected VirtualFile findFile(String path) {
+    String filePath = getTestDataPath() + File.separatorChar + "configuration" + File.separatorChar + path;
     return LocalFileSystem.getInstance().findFileByPath(filePath.replace(File.separatorChar, '/'));
   }
 
@@ -153,16 +154,6 @@ public abstract class BaseConfigurationTestCase extends JavaProjectTestCase {
     return JavaPsiFacade.getInstance(myProject).findClass(qualifiedName, scope);
   }
 
-  protected JUnitConfiguration createJUnitConfiguration(@NotNull PsiElement psiElement,
-                                                        @NotNull Class<? extends AbstractJavaTestConfigurationProducer<?>> producerClass,
-                                                        @NotNull MapDataContext dataContext) {
-    ConfigurationContext context = createContext(psiElement, dataContext);
-    RunConfigurationProducer<?> producer = RunConfigurationProducer.getInstance(producerClass);
-    ConfigurationFromContext fromContext = producer.createConfigurationFromContext(context);
-    assertNotNull(fromContext);
-    return (JUnitConfiguration)fromContext.getConfiguration();
-  }
-
   protected TestNGConfiguration createTestNGConfiguration(@NotNull PsiElement psiElement,
                                                           @NotNull Class<? extends AbstractJavaTestConfigurationProducer<?>> producerClass,
                                                           @NotNull MapDataContext dataContext) {
@@ -201,20 +192,4 @@ public abstract class BaseConfigurationTestCase extends JavaProjectTestCase {
   protected void addDependency(Module module, Module dependency) {
     ModuleRootModificationUtil.addDependency(module, dependency);
   }
-
-  protected void checkPackage(String packageName, JUnitConfiguration configuration) {
-    assertEquals(packageName, configuration.getPersistentData().getPackageName());
-  }
-
-  protected void checkClassName(String className, JUnitConfiguration configuration) {
-    assertEquals(className, configuration.getPersistentData().getMainClassName());
-  }
-
-  protected void checkMethodName(String methodName, JUnitConfiguration configuration) {
-    assertEquals(methodName, configuration.getPersistentData().getMethodName());
-  }
-
-  protected void checkTestObject(String testObjectKey, JUnitConfiguration configuration) {
-    assertEquals(testObjectKey, configuration.getPersistentData().TEST_OBJECT);
-  }
 }

java/java-tests/testSrc/com/intellij/java/execution/ModuleBasedConfigurationTest.java

@@ -0,0 +1,42 @@
+// 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.java.execution;
+
+import com.intellij.execution.configurations.ModuleBasedConfiguration;
+import com.intellij.openapi.application.ex.PathManagerEx;
+import com.intellij.openapi.module.Module;
+import com.intellij.openapi.roots.DependencyScope;
+import com.intellij.openapi.roots.ModuleRootModificationUtil;
+import org.jetbrains.annotations.NotNull;
+
+public class ModuleBasedConfigurationTest extends BaseConfigurationTestCase {
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    addModule("module1");
+    addModule("module2");
+    addModule("module3");
+  }
+
+  public void testOriginalModule() {
+    ModuleRootModificationUtil.addDependency(getModule1(), getModule2(), DependencyScope.TEST, true);
+    ModuleRootModificationUtil.addDependency(getModule2(), getModule3(), DependencyScope.TEST, false);
+    assertTrue(ModuleBasedConfiguration.canRestoreOriginalModule(getModule1(), new com.intellij.openapi.module.Module[] {getModule2()}));
+    assertTrue(ModuleBasedConfiguration.canRestoreOriginalModule(getModule1(), new com.intellij.openapi.module.Module[] {getModule3()}));
+
+    //not exported but on the classpath
+    addModule("module4");
+    ModuleRootModificationUtil.addDependency(getModule3(), getModule4(), DependencyScope.TEST, false);
+    assertTrue(ModuleBasedConfiguration.canRestoreOriginalModule(getModule1(), new com.intellij.openapi.module.Module[] {getModule4()}));
+
+    addModule("module5");
+    assertFalse(ModuleBasedConfiguration.canRestoreOriginalModule(getModule1(), new com.intellij.openapi.module.Module[] {getModule(4)}));
+
+    assertFalse(ModuleBasedConfiguration.canRestoreOriginalModule(getModule2(), new Module[] {getModule1()}));
+  }
+
+  @Override
+  @NotNull
+  protected String getTestDataPath() {
+    return PathManagerEx.getTestDataPath();
+  }
+}

java/java-tests/testSrc/com/intellij/java/execution/TestSources.java

@@ -1,4 +1,4 @@
-// Copyright 2000-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
+// 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.java.execution;
 
 import com.intellij.openapi.module.Module;
@@ -18,13 +18,13 @@ import com.intellij.testFramework.VfsTestUtil;
 import org.intellij.lang.annotations.Language;
 import org.jetbrains.annotations.NotNull;
 
-final class TestSources {
+public final class TestSources {
   private final Project myProject;
   private final TemporaryDirectory tempDir;
   private VirtualFile mySrc;
   private Module myModule;
 
-  TestSources(@NotNull Project project, @NotNull TemporaryDirectory temporaryDirectory) {
+  public TestSources(@NotNull Project project, @NotNull TemporaryDirectory temporaryDirectory) {
     myProject = project;
     tempDir = temporaryDirectory;
   }

plugins/junit/java-tests/intellij.junit.java.tests.iml

@@ -19,5 +19,11 @@
     <orderEntry type="module" module-name="intellij.platform.ide.util.io" scope="TEST" />
     <orderEntry type="module" module-name="intellij.java.execution.impl" scope="TEST" />
     <orderEntry type="module" module-name="intellij.java" scope="TEST" />
+    <orderEntry type="module" module-name="intellij.java.tests" scope="TEST" />
+    <orderEntry type="module" module-name="intellij.platform.externalSystem.impl" scope="TEST" />
+    <orderEntry type="module" module-name="intellij.platform.testExtensions" scope="TEST" />
+    <orderEntry type="library" scope="TEST" name="assertJ" level="project" />
+    <orderEntry type="module" module-name="intellij.java.compiler" scope="TEST" />
+    <orderEntry type="module" module-name="intellij.java.impl.refactorings" scope="TEST" />
   </component>
 </module>

plugins/junit/java-tests/test/com/intellij/execution/junit/JUnitConfigurationTest.java

@@ -1,21 +0,0 @@
-// Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
-package com.intellij.execution.junit;
-
-import com.intellij.execution.testframework.TestSearchScope;
-import com.intellij.openapi.util.JDOMUtil;
-import com.intellij.testFramework.LightPlatformTestCase;
-import org.jdom.Element;
-
-public class JUnitConfigurationTest extends LightPlatformTestCase {
-  public void testSearchScope() throws Exception {
-    JUnitConfiguration foo = new JUnitConfiguration("foo", getProject());
-    Element element = JDOMUtil.load("""
-                                      <configuration default="false" name="DjangoTests (1.6)" type="JUnit" factoryName="JUnit">
-                                          <option name="TEST_SEARCH_SCOPE">
-                                            <value defaultName="moduleWithDependencies" />
-                                          </option>
-                                        </configuration>""");
-    foo.readExternal(element);
-    assertEquals(TestSearchScope.MODULE_WITH_DEPENDENCIES, foo.getPersistentData().getScope());
-  }
-}

plugins/junit/java-tests/test/com/intellij/execution/junit/JUnitNestedClassLineMarkerTest.java

@@ -1,11 +1,10 @@
-// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
-package com.intellij.java.codeInsight.navigation;
+// 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.execution.junit;
 
 import com.intellij.codeInsight.daemon.GutterMark;
 import com.intellij.execution.RunManager;
 import com.intellij.execution.RunnerAndConfigurationSettings;
 import com.intellij.execution.configurations.RunConfiguration;
-import com.intellij.execution.junit.JUnitConfiguration;
 import com.intellij.execution.junit.codeInsight.JUnit5TestFrameworkSetupUtil;
 import com.intellij.openapi.actionSystem.*;
 import com.intellij.openapi.actionSystem.impl.PresentationFactory;
@@ -20,7 +19,7 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
-public class NestedClassLineMarkerTest extends LightJavaCodeInsightFixtureTestCase {
+public class JUnitNestedClassLineMarkerTest extends LightJavaCodeInsightFixtureTestCase {
   private final Set<RunnerAndConfigurationSettings> myTempSettings = new HashSet<>();
   @Override
   protected void tearDown() throws Exception {

plugins/junit/java-tests/test/com/intellij/execution/junit/JUnitTestRunLineMarkerTest.java

@@ -1,5 +1,5 @@
-// Copyright 2000-2024 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
-package com.intellij.java.codeInsight.navigation;
+// 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.execution.junit;
 
 import com.intellij.codeInsight.daemon.GutterMark;
 import com.intellij.execution.ExecutionBundle;
@@ -10,11 +10,12 @@ import com.intellij.execution.application.ApplicationConfiguration;
 import com.intellij.execution.configurations.RunConfiguration;
 import com.intellij.execution.impl.RunManagerImpl;
 import com.intellij.execution.impl.RunnerAndConfigurationSettingsImpl;
-import com.intellij.execution.junit.JUnitConfiguration;
 import com.intellij.execution.junit.codeInsight.JUnit5TestFrameworkSetupUtil;
 import com.intellij.execution.lineMarker.RunLineMarkerContributor;
 import com.intellij.execution.testframework.sm.runner.states.TestStateInfo;
 import com.intellij.icons.AllIcons;
+import com.intellij.java.codeInsight.navigation.LineMarkerTestCase;
+import com.intellij.java.codeInsight.navigation.MockGradleRunConfiguration;
 import com.intellij.openapi.actionSystem.*;
 import com.intellij.openapi.actionSystem.impl.PresentationFactory;
 import com.intellij.openapi.actionSystem.impl.Utils;
@@ -33,7 +34,7 @@ import javax.swing.*;
 import java.util.Date;
 import java.util.List;
 
-public class TestRunLineMarkerTest extends LineMarkerTestCase {
+public class JUnitTestRunLineMarkerTest extends LineMarkerTestCase {
   public void testAbstractTestClassMethods() {
     myFixture.addClass("package junit.framework; public class TestCase {}");
     myFixture.configureByText("MyTest.java", """

plugins/junit/java-tests/test/com/intellij/execution/junit/configuration/JUnitConfigurationFromEditorTest.java

@@ -1,19 +1,5 @@
-/*
- * Copyright 2000-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.intellij.java.execution.actions;
+// 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.execution.junit.configuration;
 
 import com.intellij.execution.RunnerAndConfigurationSettings;
 import com.intellij.execution.actions.ConfigurationContext;
@@ -26,7 +12,7 @@ import com.intellij.testFramework.fixtures.LightJavaCodeInsightFixtureTestCase;
 
 import java.util.Set;
 
-public class ConfigurationFromEditorTest extends LightJavaCodeInsightFixtureTestCase {
+public class JUnitConfigurationFromEditorTest extends LightJavaCodeInsightFixtureTestCase {
   @Override
   public void setUp() throws Exception {
     super.setUp();
@@ -50,17 +36,6 @@ public class ConfigurationFromEditorTest extends LightJavaCodeInsightFixtureTest
     return settings != null ? (T)settings.getConfiguration() : null;
   }
 
-  public void testApplicationConfigurationForUnknownMethod() {
-    assertNull(setupConfigurationContext("""
-                                           public class Foo {
-                                             public static void x<caret>xx(String[] args) {}
-                                           }"""));
-    assertNotNull(setupConfigurationContext("""
-                                              public class Foo {
-                                                public static void m<caret>ain(String[] args) {}
-                                              }"""));
-  }
-
   public void testPatternConfigurationFromSelection() {
     JUnitConfiguration configuration = setupConfigurationContext("""
                                                                    import org.junit.Test; public class MyTest {

plugins/junit/java-tests/test/com/intellij/execution/junit/configuration/JUnitConfigurationRefactoringsTest.java

@@ -1,8 +1,7 @@
-// Copyright 2000-2021 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
-package com.intellij.java.execution;
+// 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.execution.junit.configuration;
 
 import com.intellij.execution.RunManager;
-import com.intellij.execution.application.ApplicationConfiguration;
 import com.intellij.execution.configurations.RunConfiguration;
 import com.intellij.execution.configurations.RuntimeConfigurationException;
 import com.intellij.execution.impl.RunManagerImpl;
@@ -10,6 +9,7 @@ import com.intellij.execution.impl.RunnerAndConfigurationSettingsImpl;
 import com.intellij.execution.junit.AllInPackageConfigurationProducer;
 import com.intellij.execution.junit.JUnitConfiguration;
 import com.intellij.execution.testframework.AbstractJavaTestConfigurationProducer;
+import com.intellij.java.execution.TestSources;
 import com.intellij.openapi.vfs.JarFileSystem;
 import com.intellij.openapi.vfs.LocalFileSystem;
 import com.intellij.openapi.vfs.VirtualFile;
@@ -27,7 +27,7 @@ import org.jetbrains.annotations.NotNull;
 import java.io.File;
 import java.util.HashSet;
 
-public class ConfigurationRefactoringsTest extends BaseConfigurationTestCase {
+public class JUnitConfigurationRefactoringsTest extends JUnitConfigurationTestCase {
   private static final String APPLICATION_CODE = "public class Application {" +
                                                  "  public static void main(String[] args) {\n" +
                                                  "  }" +
@@ -41,37 +41,6 @@ public class ConfigurationRefactoringsTest extends BaseConfigurationTestCase {
   private static final String NOT_A_TEST = "public class NotATest {" +
                                            "public void test() {}" +
                                            "}";
-  public void testRenameApplication() {
-    PsiClass psiClass = mySource.createClass("Application", APPLICATION_CODE);
-    assertNotNull(psiClass);
-    ApplicationConfiguration configuration = createConfiguration(psiClass);
-    assertNotNull(configuration);
-    rename(psiClass, "NewName");
-    try {
-      configuration.checkConfiguration();
-    }
-    catch (RuntimeConfigurationException e) {
-      fail("Unexpected ConfigurationException: " + e);
-    }
-    assertEquals("NewName", configuration.getMainClassName());
-  }
-
-  public void testMoveApplication() {
-    PsiClass psiClass = mySource.createClass("Application", APPLICATION_CODE);
-    assertNotNull(psiClass);
-    ApplicationConfiguration configuration = createConfiguration(psiClass);
-    move(psiClass, "pkg");
-    try {
-      configuration.checkConfiguration();
-    }
-    catch (RuntimeConfigurationException e) {
-      fail("Unexpected ConfigurationException: " + e);
-    }
-
-    assertEquals("pkg.Application", configuration.getMainClassName());
-    rename(JavaPsiFacade.getInstance(myProject).findPackage("pkg"), "pkg2");
-    assertEquals("pkg2.Application", configuration.getMainClassName());
-  }
 
   public void testRenameJUnitPackage() {
     PsiPackage psiPackage = mySource.createPackage("pkg");

plugins/junit/java-tests/test/com/intellij/execution/junit/configuration/JUnitConfigurationTest.java

@@ -1,12 +1,11 @@
-// Copyright 2000-2021 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
-package com.intellij.java.execution;
+// 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.execution.junit.configuration;
 
 import com.intellij.application.options.ModuleDescriptionsComboBox;
 import com.intellij.execution.CantRunException;
 import com.intellij.execution.ExecutionException;
 import com.intellij.execution.RunConfigurationConfigurableAdapter;
 import com.intellij.execution.actions.ConfigurationContext;
-import com.intellij.execution.application.ApplicationConfigurable;
 import com.intellij.execution.application.ApplicationConfiguration;
 import com.intellij.execution.configurations.*;
 import com.intellij.execution.executors.DefaultRunExecutor;
@@ -21,11 +20,11 @@ import com.intellij.execution.target.local.LocalTargetEnvironment;
 import com.intellij.execution.target.local.LocalTargetEnvironmentRequest;
 import com.intellij.execution.testframework.SearchForTestsTask;
 import com.intellij.execution.testframework.TestSearchScope;
-import com.intellij.execution.ui.CommonJavaParametersPanel;
 import com.intellij.openapi.Disposable;
 import com.intellij.openapi.actionSystem.ActionPlaces;
 import com.intellij.openapi.actionSystem.CommonDataKeys;
 import com.intellij.openapi.actionSystem.PlatformCoreDataKeys;
+import com.intellij.openapi.application.PathManager;
 import com.intellij.openapi.application.impl.NonBlockingReadActionImpl;
 import com.intellij.openapi.compiler.CompilerMessage;
 import com.intellij.openapi.compiler.CompilerMessageCategory;
@@ -35,9 +34,13 @@ import com.intellij.openapi.options.Configurable;
 import com.intellij.openapi.options.ConfigurationException;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.projectRoots.Sdk;
-import com.intellij.openapi.roots.*;
+import com.intellij.openapi.roots.CompilerModuleExtension;
+import com.intellij.openapi.roots.ContentEntry;
+import com.intellij.openapi.roots.ModuleRootManager;
+import com.intellij.openapi.roots.ModuleRootModificationUtil;
 import com.intellij.openapi.ui.LabeledComponent;
 import com.intellij.openapi.util.Disposer;
+import com.intellij.openapi.util.JDOMUtil;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.io.FileUtilRt;
 import com.intellij.openapi.util.registry.Registry;
@@ -59,6 +62,7 @@ import com.intellij.util.PathUtil;
 import com.intellij.util.containers.ContainerUtil;
 import junit.framework.TestCase;
 import org.jdom.Element;
+import org.jetbrains.annotations.NotNull;
 
 import java.io.File;
 import java.io.IOException;
@@ -67,7 +71,7 @@ import java.util.*;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
-public class ConfigurationsTest extends BaseConfigurationTestCase {
+public class JUnitConfigurationTest extends JUnitConfigurationTestCase {
   private Sdk myJdk;
   private static final String INNER_TEST_NAME = "test1.InnerTest.Inner";
   private static final String RT_INNER_TEST_NAME = "test1.InnerTest$Inner";
@@ -81,6 +85,18 @@ public class ConfigurationsTest extends BaseConfigurationTestCase {
     assignJdk(getModule1());
   }
 
+  public void testSearchScope() throws Exception {
+    JUnitConfiguration foo = new JUnitConfiguration("foo", getProject());
+    Element element = JDOMUtil.load("""
+                                      <configuration default="false" name="DjangoTests (1.6)" type="JUnit" factoryName="JUnit">
+                                          <option name="TEST_SEARCH_SCOPE">
+                                            <value defaultName="moduleWithDependencies" />
+                                          </option>
+                                        </configuration>""");
+    foo.readExternal(element);
+    assertEquals(TestSearchScope.MODULE_WITH_DEPENDENCIES, foo.getPersistentData().getScope());
+  }
+
   public void testCreateConfiguration() throws ExecutionException {
     Module module1 = getModule1();
     PsiClass psiClass = findTestA(module1);
@@ -423,30 +439,6 @@ public class ConfigurationsTest extends BaseConfigurationTestCase {
     assertThat(javaParameters.getClassPath().getPathsString()).contains(output);
   }
 
-  public void testCreatingApplicationConfiguration() throws ConfigurationException {
-    if (PlatformTestUtil.COVERAGE_ENABLED_BUILD) return;
-
-    ApplicationConfiguration configuration = new ApplicationConfiguration(null, myProject);
-    ApplicationConfigurable editor = new ApplicationConfigurable(myProject);
-    try {
-      editor.getComponent(); // To get all the watchers installed.
-      Configurable configurable = new RunConfigurationConfigurableAdapter(editor, configuration);
-      configurable.reset();
-      CommonJavaParametersPanel javaParameters = editor.getCommonProgramParameters();
-      javaParameters.setProgramParameters("prg");
-      javaParameters.setVMParameters("vm");
-      javaParameters.setWorkingDirectory("dir");
-      assertTrue(configurable.isModified());
-      configurable.apply();
-      assertEquals("prg", configuration.getProgramParameters());
-      assertEquals("vm", configuration.getVMParameters());
-      assertEquals("dir", configuration.getWorkingDirectory());
-    }
-    finally {
-      Disposer.dispose(editor);
-    }
-  }
-
   public void testCreateInnerPackageLocalApplication() throws ExecutionException {
     PsiClass psiClass = findClass(getModule1(), "test2.NotATest.InnerApplication");
     assertNotNull(psiClass);
@@ -521,23 +513,6 @@ public class ConfigurationsTest extends BaseConfigurationTestCase {
     }
   }
 
-  public void testOriginalModule() {
-    ModuleRootModificationUtil.addDependency(getModule1(), getModule2(), DependencyScope.TEST, true);
-    ModuleRootModificationUtil.addDependency(getModule2(), getModule3(), DependencyScope.TEST, false);
-    assertTrue(ModuleBasedConfiguration.canRestoreOriginalModule(getModule1(), new Module[] {getModule2()}));
-    assertTrue(ModuleBasedConfiguration.canRestoreOriginalModule(getModule1(), new Module[] {getModule3()}));
-
-    //not exported but on the classpath
-    addModule("module4");
-    ModuleRootModificationUtil.addDependency(getModule3(), getModule4(), DependencyScope.TEST, false);
-    assertTrue(ModuleBasedConfiguration.canRestoreOriginalModule(getModule1(), new Module[] {getModule4()}));
-
-    addModule("module5");
-    assertFalse(ModuleBasedConfiguration.canRestoreOriginalModule(getModule1(), new Module[] {getModule(4)}));
-
-    assertFalse(ModuleBasedConfiguration.canRestoreOriginalModule(getModule2(), new Module[] {getModule1()}));
-  }
-
   private void assignJdk(Module module) {
     myJdk = ModuleRootManager.getInstance(myModule).getSdk();
     ModuleRootModificationUtil.setModuleSdk(module, myJdk);
@@ -703,4 +678,9 @@ public class ConfigurationsTest extends BaseConfigurationTestCase {
     myJdk = null;
     super.tearDown();
   }
+
+  @Override
+  protected @NotNull String getTestDataPath() {
+    return PathManager.getCommunityHomePath() + "/plugins/junit/java-tests/testData";
+  }
 }

plugins/junit/java-tests/test/com/intellij/execution/junit/configuration/JUnitConfigurationTestCase.kt

@@ -0,0 +1,39 @@
+// 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.execution.junit.configuration
+
+import com.intellij.execution.actions.RunConfigurationProducer
+import com.intellij.execution.junit.JUnitConfiguration
+import com.intellij.execution.testframework.AbstractJavaTestConfigurationProducer
+import com.intellij.java.execution.BaseConfigurationTestCase
+import com.intellij.psi.PsiElement
+import com.intellij.testFramework.MapDataContext
+
+abstract class JUnitConfigurationTestCase : BaseConfigurationTestCase() {
+  protected open fun createJUnitConfiguration(
+    psiElement: PsiElement,
+    producerClass: Class<out AbstractJavaTestConfigurationProducer<*>>,
+    dataContext: MapDataContext,
+  ): JUnitConfiguration? {
+    val context = createContext(psiElement, dataContext)
+    val producer: RunConfigurationProducer<*> = RunConfigurationProducer.getInstance(producerClass)
+    val fromContext = producer.createConfigurationFromContext(context)
+    assertNotNull(fromContext)
+    return fromContext!!.configuration as JUnitConfiguration
+  }
+
+  protected fun checkPackage(packageName: String?, configuration: JUnitConfiguration) {
+    assertEquals(packageName, configuration.persistentData.packageName)
+  }
+
+  protected fun checkClassName(className: String?, configuration: JUnitConfiguration) {
+    assertEquals(className, configuration.persistentData.mainClassName)
+  }
+
+  protected fun checkMethodName(methodName: String?, configuration: JUnitConfiguration) {
+    assertEquals(methodName, configuration.persistentData.getMethodName())
+  }
+
+  protected fun checkTestObject(testObjectKey: String?, configuration: JUnitConfiguration) {
+    assertEquals(testObjectKey, configuration.persistentData.TEST_OBJECT)
+  }
+}

plugins/junit/java-tests/test/com/intellij/execution/junit/configuration/JUnitContextConfigurationTest.java

@@ -1,27 +1,22 @@
-// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
-package com.intellij.java.execution.actions;
+// 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.execution.junit.configuration;
 
 import com.intellij.execution.Location;
 import com.intellij.execution.RunManager;
 import com.intellij.execution.RunnerAndConfigurationSettings;
 import com.intellij.execution.actions.ConfigurationContext;
-import com.intellij.execution.actions.CreateAction;
-import com.intellij.execution.application.ApplicationConfiguration;
 import com.intellij.execution.configurations.RunConfiguration;
-import com.intellij.execution.executors.DefaultRunExecutor;
-import com.intellij.execution.impl.RunManagerImpl;
-import com.intellij.execution.impl.RunnerAndConfigurationSettingsImpl;
 import com.intellij.execution.junit.AllInPackageConfigurationProducer;
 import com.intellij.execution.junit.JUnitConfiguration;
 import com.intellij.execution.junit.JUnitUtil;
 import com.intellij.execution.junit.TestInClassConfigurationProducer;
 import com.intellij.execution.junit2.PsiMemberParameterizedLocation;
 import com.intellij.execution.junit2.info.MethodLocation;
-import com.intellij.execution.runners.ExecutionEnvironment;
-import com.intellij.execution.runners.ExecutionEnvironmentBuilder;
 import com.intellij.execution.testframework.TestSearchScope;
-import com.intellij.java.execution.BaseConfigurationTestCase;
-import com.intellij.openapi.actionSystem.*;
+import com.intellij.openapi.actionSystem.ActionPlaces;
+import com.intellij.openapi.actionSystem.CommonDataKeys;
+import com.intellij.openapi.actionSystem.PlatformCoreDataKeys;
+import com.intellij.openapi.application.PathManager;
 import com.intellij.openapi.module.Module;
 import com.intellij.openapi.module.ModuleUtilCore;
 import com.intellij.openapi.util.text.StringUtil;
@@ -29,13 +24,13 @@ import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiMethod;
 import com.intellij.psi.PsiPackage;
 import com.intellij.testFramework.MapDataContext;
-import com.intellij.testFramework.TestActionEvent;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashSet;
 
-public class ContextConfigurationTest extends BaseConfigurationTestCase {
+public class JUnitContextConfigurationTest extends JUnitConfigurationTestCase {
   private static final String PACKAGE_NAME = "apackage";
   private static final String SHORT_CLASS_NAME = "SampleClass";
   private static final String CLASS_NAME = PACKAGE_NAME + "." + SHORT_CLASS_NAME;
@@ -172,29 +167,6 @@ public class ContextConfigurationTest extends BaseConfigurationTestCase {
     checkGeneretedName(configuration, "All in " + module.getName());
   }
 
-  public void testApplication() {
-    PsiClass psiClass = findClass(getModule1(), CLASS_NAME);
-    PsiMethod psiMethod = psiClass.findMethodsByName("main", false)[0];
-    ApplicationConfiguration configuration = createConfiguration(psiMethod);
-    assertEquals(CLASS_NAME, configuration.getMainClassName());
-    assertEquals(configuration.suggestedName(), configuration.getName());
-    assertEquals(SHORT_CLASS_NAME, configuration.getName());
-  }
-
-  public void testApplicationFromConsoleContext() {
-    PsiClass psiClass = findClass(getModule1(), CLASS_NAME);
-    PsiMethod psiMethod = psiClass.findMethodsByName("main", false)[0];
-    ApplicationConfiguration configuration = createConfiguration(psiMethod);
-    RunnerAndConfigurationSettingsImpl settings =
-      new RunnerAndConfigurationSettingsImpl(RunManagerImpl.getInstanceImpl(myProject), configuration);
-    ExecutionEnvironment e = ExecutionEnvironmentBuilder.createOrNull(DefaultRunExecutor.getRunExecutorInstance(), settings).build();
-    MapDataContext dataContext = new MapDataContext();
-    dataContext.put(ExecutionDataKeys.EXECUTION_ENVIRONMENT, e);
-    AnActionEvent event = TestActionEvent.createTestEvent(dataContext);
-    new CreateAction().update(event);
-    assertTrue(event.getPresentation().isEnabledAndVisible());
-  }
-
   public void testReusingConfiguration() {
     RunManager runManager = RunManager.getInstance(myProject);
     PsiClass psiClass = findClass(getModule1(), CLASS_NAME);
@@ -252,4 +224,9 @@ public class ContextConfigurationTest extends BaseConfigurationTestCase {
     assertEquals(configuration.suggestedName(), configuration.getName());
     assertEquals(name, configuration.getName());
   }
+
+  @Override
+  protected @NotNull String getTestDataPath() {
+    return PathManager.getCommunityHomePath() + "/plugins/junit/java-tests/testData";
+  }
 }

plugins/junit/java-tests/test/com/intellij/execution/junit/configuration/JUnitModulePathTest.java

@@ -1,5 +1,5 @@
-// Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
-package com.intellij.java.execution;
+// 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.execution.junit.configuration;
 
 import com.intellij.codeInsight.TestFrameworks;
 import com.intellij.execution.JavaTestFrameworkRunnableState;
@@ -7,8 +7,10 @@ import com.intellij.execution.configurations.JavaParameters;
 import com.intellij.execution.configurations.ParamsGroup;
 import com.intellij.execution.junit.JUnitConfiguration;
 import com.intellij.execution.junit.TestObject;
+import com.intellij.java.execution.AbstractTestFrameworkIntegrationTest;
+import com.intellij.java.execution.BaseConfigurationTestCase;
+import com.intellij.openapi.application.PathManager;
 import com.intellij.openapi.application.WriteAction;
-import com.intellij.openapi.application.ex.PathManagerEx;
 import com.intellij.openapi.module.Module;
 import com.intellij.openapi.projectRoots.ProjectJdkTable;
 import com.intellij.openapi.projectRoots.Sdk;
@@ -17,17 +19,16 @@ import com.intellij.openapi.roots.ContentEntry;
 import com.intellij.openapi.roots.ModuleRootModificationUtil;
 import com.intellij.openapi.roots.OrderEnumerator;
 import com.intellij.openapi.vfs.JarFileSystem;
-import com.intellij.openapi.vfs.LocalFileSystem;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.PsiClass;
 import com.intellij.rt.junit.JUnitStarter;
 import com.intellij.testFramework.IdeaTestUtil;
 import com.intellij.util.PathUtil;
 import com.intellij.util.PathsList;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jps.model.java.JavaSourceRootType;
 import org.jetbrains.jps.model.library.JpsMavenRepositoryLibraryDescriptor;
 
-import java.io.File;
 import java.util.Arrays;
 import java.util.List;
 
@@ -37,21 +38,21 @@ public class JUnitModulePathTest extends BaseConfigurationTestCase {
     Module module = createEmptyModule();
     JpsMavenRepositoryLibraryDescriptor nonModularizedJupiterDescription =
       new JpsMavenRepositoryLibraryDescriptor("org.junit.jupiter", "junit-jupiter-api", "5.3.0");
-    JUnitConfiguration configuration = setupConfiguration(nonModularizedJupiterDescription, "prod1", module);
+    JUnitConfiguration configuration = setupConfiguration(nonModularizedJupiterDescription, "modulePath/prod1", module);
     JavaParameters params4Tests = configuration.getTestObject().createJavaParameters4Tests();
     ParamsGroup moduleOptions = JavaTestFrameworkRunnableState.getJigsawOptions(params4Tests);
     assertNotNull(moduleOptions);
     assertEquals("--patch-module m1=" + CompilerModuleExtension.getInstance(module).getCompilerOutputPathForTests().getPath() +
-                 " --add-reads m1=ALL-UNNAMED" +
-                 " --add-opens m1/p=ALL-UNNAMED" +
-                 " --add-modules m1", moduleOptions.getParametersList().getParametersString());
+                          " --add-reads m1=ALL-UNNAMED" +
+                          " --add-opens m1/p=ALL-UNNAMED" +
+                          " --add-modules m1", moduleOptions.getParametersList().getParametersString());
 
     checkLibrariesOnPathList(module, params4Tests.getClassPath());
 
     //production module output is on the module path
     PathsList modulePath = params4Tests.getModulePath();
     assertTrue("module path: " + modulePath.getPathsString(),
-               modulePath.getPathList().contains(getCompilerOutputPath(module)));
+                        modulePath.getPathList().contains(getCompilerOutputPath(module)));
   }
 
   public void testModuleInfoInProductionModularizedJUnit() throws Exception {
@@ -67,25 +68,25 @@ public class JUnitModulePathTest extends BaseConfigurationTestCase {
   private void doTestModuleInfoInProductionModularizedJUnit(JpsMavenRepositoryLibraryDescriptor modularizedJupiterDescription)
     throws Exception {
     Module module = createEmptyModule();
-    JUnitConfiguration configuration = setupConfiguration(modularizedJupiterDescription, "prod1", module);
+    JUnitConfiguration configuration = setupConfiguration(modularizedJupiterDescription, "modulePath/prod1", module);
     JavaParameters params4Tests = configuration.getTestObject().createJavaParameters4Tests();
     ParamsGroup moduleOptions = JavaTestFrameworkRunnableState.getJigsawOptions(params4Tests);
     assertNotNull(moduleOptions);
     assertEquals("--patch-module m1=" + CompilerModuleExtension.getInstance(module).getCompilerOutputPathForTests().getPath() +
-                 " --add-reads m1=ALL-UNNAMED" +
-                 " --add-opens m1/p=ALL-UNNAMED" +
-                 " --add-modules m1", moduleOptions.getParametersList().getParametersString());
+                          " --add-reads m1=ALL-UNNAMED" +
+                          " --add-opens m1/p=ALL-UNNAMED" +
+                          " --add-modules m1", moduleOptions.getParametersList().getParametersString());
 
     checkLibrariesOnPathList(module, params4Tests.getClassPath());
 
     //production module output is on the module path
     PathsList modulePath = params4Tests.getModulePath();
     assertTrue("module path: " + modulePath.getPathsString(),
-               modulePath.getPathList().contains(getCompilerOutputPath(module)));
+                        modulePath.getPathList().contains(getCompilerOutputPath(module)));
 
     //test output on the classpath
     assertFalse("module path: " + modulePath.getPathsString(),
-               modulePath.getPathList().contains(getCompilerOutputPath(module, true)));
+                         modulePath.getPathList().contains(getCompilerOutputPath(module, true)));
   }
 
   private static void checkLibrariesOnPathList(Module module, PathsList classPath) {
@@ -96,13 +97,13 @@ public class JUnitModulePathTest extends BaseConfigurationTestCase {
         .recursively().exportedOnly().classes().usingCache().getRoots())
       .map(f -> PathUtil.getLocalPath(JarFileSystem.getInstance().getVirtualFileForJar(f)))
       .forEach(path -> assertTrue("path " + path + " is located on the classpath: " + classPath.getPathsString(),
-                                  classPath.getPathList().contains(path)));
+                                           classPath.getPathList().contains(path)));
   }
 
   public void testNonModularizedProject() throws Exception {
     Module module = createEmptyModule();
     JUnitConfiguration configuration = setupConfiguration(new JpsMavenRepositoryLibraryDescriptor("org.junit.jupiter", "junit-jupiter-api", "5.5.2"),
-                                                          "prod1", module);
+                                                          "modulePath/prod1", module);
     ModuleRootModificationUtil.updateModel(module, model -> {
       ContentEntry entry = model.getContentEntries()[0];
       entry.removeSourceFolder(entry.getSourceFolders(JavaSourceRootType.SOURCE).get(0));
@@ -116,7 +117,7 @@ public class JUnitModulePathTest extends BaseConfigurationTestCase {
     Module module = createEmptyModule();
     JpsMavenRepositoryLibraryDescriptor nonModularizedJupiterDescription =
       new JpsMavenRepositoryLibraryDescriptor("org.junit.jupiter", "junit-jupiter-api", "5.3.0");
-    JUnitConfiguration configuration = setupConfiguration(nonModularizedJupiterDescription, "test1", module);
+    JUnitConfiguration configuration = setupConfiguration(nonModularizedJupiterDescription, "modulePath/test1", module);
     JavaParameters params4Tests = configuration.getTestObject().createJavaParameters4Tests();
     ParamsGroup moduleOptions = JavaTestFrameworkRunnableState.getJigsawOptions(params4Tests);
     assertNotNull(moduleOptions);
@@ -125,13 +126,13 @@ public class JUnitModulePathTest extends BaseConfigurationTestCase {
     PathsList modulePath = params4Tests.getModulePath();
 
     assertTrue("module path: " + modulePath.getPathsString(),
-               modulePath.getPathList().stream().anyMatch(filePath -> filePath.contains("junit-jupiter-api")));
+                        modulePath.getPathList().stream().anyMatch(filePath -> filePath.contains("junit-jupiter-api")));
     //production module output is not on the module path
     assertFalse("module path: " + modulePath.getPathsString(),
-               modulePath.getPathList().contains(getCompilerOutputPath(module)));
+                         modulePath.getPathList().contains(getCompilerOutputPath(module)));
     //test module output is on the module path
     assertTrue("module path: " + modulePath.getPathsString(),
-               modulePath.getPathList().contains(getCompilerOutputPath(module, true)));
+                        modulePath.getPathList().contains(getCompilerOutputPath(module, true)));
     assertSize(2, modulePath.getPathList());
 
     //launcher should be put on the classpath
@@ -142,12 +143,12 @@ public class JUnitModulePathTest extends BaseConfigurationTestCase {
     Module module = createEmptyModule();
     JpsMavenRepositoryLibraryDescriptor nonModularizedJupiterDescription =
       new JpsMavenRepositoryLibraryDescriptor("org.junit.jupiter", "junit-jupiter-api", "5.5.2");
-    JUnitConfiguration configuration = setupConfiguration(nonModularizedJupiterDescription, "test1", module);
+    JUnitConfiguration configuration = setupConfiguration(nonModularizedJupiterDescription, "modulePath/test1", module);
     JavaParameters params4Tests = configuration.getTestObject().createJavaParameters4Tests();
     ParamsGroup moduleOptions = JavaTestFrameworkRunnableState.getJigsawOptions(params4Tests);
     assertNotNull(moduleOptions);
     assertEquals("--add-modules m1" +
-                 " --add-modules org.junit.platform.launcher", moduleOptions.getParametersList().getParametersString());
+                          " --add-modules org.junit.platform.launcher", moduleOptions.getParametersList().getParametersString());
 
     PathsList classPath = params4Tests.getClassPath();
     assertContainsElements(classPath.getPathList(), PathUtil.getJarPathForClass(JUnitStarter.class));
@@ -158,28 +159,28 @@ public class JUnitModulePathTest extends BaseConfigurationTestCase {
     //production module output is not on the module path
     List<String> modulePathList = modulePath.getPathList();
     assertFalse("module path: " + modulePath.getPathsString(),
-               modulePathList.contains(getCompilerOutputPath(module)));
+                         modulePathList.contains(getCompilerOutputPath(module)));
     //test module output is on the module path
     assertTrue("module path: " + modulePath.getPathsString(),
-               modulePathList.contains(getCompilerOutputPath(module, true)));
+                        modulePathList.contains(getCompilerOutputPath(module, true)));
     assertTrue(modulePathList.stream().anyMatch(filePath -> filePath.contains("launcher")));
   }
   
   public void testModuleInfoInTestModularizedJunitDependencyOnAnotherModule() throws Exception {
     Module module1 = createEmptyModule();
-    setupModule("prod1", module1);
+    setupModule("modulePath/prod1", module1);
     Module module = createEmptyModule();
     ModuleRootModificationUtil.updateModel(module, model -> {
       model.addModuleOrderEntry(module1);
     });
     JpsMavenRepositoryLibraryDescriptor nonModularizedJupiterDescription =
       new JpsMavenRepositoryLibraryDescriptor("org.junit.jupiter", "junit-jupiter-api", "5.5.2");
-    JUnitConfiguration configuration = setupConfiguration(nonModularizedJupiterDescription, "test2", module);
+    JUnitConfiguration configuration = setupConfiguration(nonModularizedJupiterDescription, "modulePath/test2", module);
     JavaParameters params4Tests = configuration.getTestObject().createJavaParameters4Tests();
     ParamsGroup moduleOptions = JavaTestFrameworkRunnableState.getJigsawOptions(params4Tests);
     assertNotNull(moduleOptions);
     assertEquals("--add-modules m2" +
-                 " --add-modules org.junit.platform.launcher", moduleOptions.getParametersList().getParametersString());
+                          " --add-modules org.junit.platform.launcher", moduleOptions.getParametersList().getParametersString());
 
     PathsList classPath = params4Tests.getClassPath();
     assertContainsElements(classPath.getPathList(), PathUtil.getJarPathForClass(JUnitStarter.class));
@@ -189,12 +190,12 @@ public class JUnitModulePathTest extends BaseConfigurationTestCase {
     checkLibrariesOnPathList(module, modulePath);
     List<String> modulePathList = modulePath.getPathList();
     assertFalse("module path: " + modulePath.getPathsString(),
-               modulePathList.contains(getCompilerOutputPath(module)));
+                         modulePathList.contains(getCompilerOutputPath(module)));
     assertTrue("module path: " + modulePath.getPathsString(),
-               modulePathList.contains(getCompilerOutputPath(module1)));
+                        modulePathList.contains(getCompilerOutputPath(module1)));
     //test module output is on the module path
     assertTrue("module path: " + modulePath.getPathsString(),
-               modulePathList.contains(getCompilerOutputPath(module, true)));
+                        modulePathList.contains(getCompilerOutputPath(module, true)));
     assertTrue(modulePathList.stream().anyMatch(filePath -> filePath.contains("launcher")));
   }
 
@@ -213,8 +214,8 @@ public class JUnitModulePathTest extends BaseConfigurationTestCase {
     return createConfiguration(aClass);
   }
 
-  private static void setupModule(String sources, Module module) {
-    VirtualFile contentRoot = getContentRoot(sources);
+  private void setupModule(String sources, Module module) {
+    VirtualFile contentRoot = findFile(sources);
     ModuleRootModificationUtil.updateModel(module, model -> {
       ContentEntry contentEntry = model.addContentEntry(contentRoot);
       contentEntry.addSourceFolder(contentRoot.getUrl() + "/src", false);
@@ -227,12 +228,6 @@ public class JUnitModulePathTest extends BaseConfigurationTestCase {
     });
   }
 
-  protected static VirtualFile getContentRoot(String path) {
-    String filePath = PathManagerEx.getTestDataPath() + File.separator + "junit" + File.separator + "modulePath" +
-                      File.separator + path;
-    return LocalFileSystem.getInstance().findFileByPath(filePath.replace(File.separatorChar, '/'));
-  }
-
   private static String getCompilerOutputPath(Module module) {
     return getCompilerOutputPath(module, false);
   }
@@ -242,4 +237,9 @@ public class JUnitModulePathTest extends BaseConfigurationTestCase {
     return PathUtil.getLocalPath(forTests ? moduleExtension.getCompilerOutputPathForTests()
                                           : moduleExtension.getCompilerOutputPath());
   }
+
+  @Override
+  protected @NotNull String getTestDataPath() {
+    return PathManager.getCommunityHomePath() + "/plugins/junit/java-tests/testData";
+  }
 }

plugins/junit/java-tests/test/com/intellij/execution/junit/configuration/JUnitPackageConfigurationProducerTest.kt

@@ -1,7 +1,9 @@
 // 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.execution.junit
+package com.intellij.execution.junit.configuration
 
 import com.intellij.execution.actions.ConfigurationContext
+import com.intellij.execution.junit.AllInPackageConfigurationProducer
+import com.intellij.execution.junit.JUnitConfiguration
 import com.intellij.openapi.application.runWriteAction
 import com.intellij.openapi.module.JavaModuleType
 import com.intellij.openapi.util.Ref
@@ -15,7 +17,7 @@ import com.intellij.testFramework.PsiTestUtil
 import com.intellij.testFramework.fixtures.JavaCodeInsightFixtureTestCase
 import com.intellij.testFramework.utils.vfs.createDirectory
 
-class JUnitConfigurationProducerTest : JavaCodeInsightFixtureTestCase() {
+class JUnitPackageConfigurationProducerTest : JavaCodeInsightFixtureTestCase() {
   override fun setUp() {
     super.setUp()
     runWriteAction {

plugins/junit/java-tests/testData/configuration/commonConfiguration/apackage/SampleClass.java

@@ -0,0 +1,9 @@
+package apackage;
+
+import junit.framework.TestCase;
+
+public class SampleClass extends TestCase {
+  public void test1() {}
+
+  public static void main(String[] args){ }
+}

plugins/junit/src/com/intellij/execution/junit/AbstractAllInPackageConfigurationProducer.java

@@ -30,7 +30,7 @@ public abstract class AbstractAllInPackageConfigurationProducer extends JUnitCon
   }
 
   @Override
-  protected boolean setupConfigurationFromContext(@NotNull JUnitConfiguration configuration,
+  public boolean setupConfigurationFromContext(@NotNull JUnitConfiguration configuration,
                                                   @NotNull ConfigurationContext context,
                                                   @NotNull Ref<PsiElement> sourceElement) {
     Location<PsiElement> loc = context.getLocation();