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

   1 /*
   2  * Copyright 2000-2017 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.
   3  */
   4 package com.intellij.java.execution;
   5
   6 import com.intellij.application.options.ModuleDescriptionsComboBox;
   7 import com.intellij.execution.CantRunException;
   8 import com.intellij.execution.ExecutionException;
   9 import com.intellij.execution.RunConfigurationConfigurableAdapter;
  10 import com.intellij.execution.application.ApplicationConfigurable;
  11 import com.intellij.execution.application.ApplicationConfiguration;
  12 import com.intellij.execution.application.ApplicationConfigurationType;
  13 import com.intellij.execution.configurations.*;
  14 import com.intellij.execution.executors.DefaultRunExecutor;
  15 import com.intellij.execution.impl.RunManagerImpl;
  16 import com.intellij.execution.impl.RunnerAndConfigurationSettingsImpl;
  17 import com.intellij.execution.junit.*;
  18 import com.intellij.execution.junit2.configuration.JUnitConfigurable;
  19 import com.intellij.execution.junit2.configuration.JUnitConfigurationModel;
  20 import com.intellij.execution.runners.ExecutionEnvironmentBuilder;
  21 import com.intellij.execution.testframework.SearchForTestsTask;
  22 import com.intellij.execution.testframework.TestSearchScope;
  23 import com.intellij.execution.ui.CommonJavaParametersPanel;
  24 import com.intellij.openapi.Disposable;
  25 import com.intellij.openapi.compiler.CompilerMessage;
  26 import com.intellij.openapi.compiler.CompilerMessageCategory;
  27 import com.intellij.openapi.module.Module;
  28 import com.intellij.openapi.module.ModuleManager;
  29 import com.intellij.openapi.options.Configurable;
  30 import com.intellij.openapi.options.ConfigurationException;
  31 import com.intellij.openapi.project.Project;
  32 import com.intellij.openapi.projectRoots.Sdk;
  33 import com.intellij.openapi.roots.*;
  34 import com.intellij.openapi.ui.LabeledComponent;
  35 import com.intellij.openapi.util.Disposer;
  36 import com.intellij.openapi.util.io.FileUtil;
  37 import com.intellij.openapi.util.registry.Registry;
  38 import com.intellij.openapi.util.text.StringUtil;
  39 import com.intellij.openapi.vfs.JarFileSystem;
  40 import com.intellij.openapi.vfs.LocalFileSystem;
  41 import com.intellij.openapi.vfs.VirtualFile;
  42 import com.intellij.project.IntelliJProjectConfiguration;
  43 import com.intellij.psi.*;
  44 import com.intellij.psi.search.GlobalSearchScope;
  45 import com.intellij.rt.ant.execution.SegmentedOutputStream;
  46 import com.intellij.rt.execution.junit.JUnitStarter;
  47 import com.intellij.testFramework.CompilerTester;
  48 import com.intellij.testFramework.MapDataContext;
  49 import com.intellij.testFramework.PlatformTestUtil;
  50 import com.intellij.testFramework.PsiTestUtil;
  51 import com.intellij.ui.EditorTextFieldWithBrowseButton;
  52 import com.intellij.util.Assertion;
  53 import com.intellij.util.PathUtil;
  54 import com.intellij.util.containers.ContainerUtil;
  55 import com.intellij.util.containers.ContainerUtilRt;
  56 import junit.framework.TestCase;
  57 import org.jdom.Element;
  58
  59 import java.io.*;
  60 import java.util.*;
  61
  62 import static org.assertj.core.api.Assertions.assertThat;
  63
  64 public class ConfigurationsTest extends BaseConfigurationTestCase {
  65   private final Assertion CHECK = new Assertion();
  66
  67   private Sdk myJdk;
  68   private static final String INNER_TEST_NAME = "test1.InnerTest.Inner";
  69   private static final String RT_INNER_TEST_NAME = "test1.InnerTest$Inner";
  70
  71   @Override
  72   protected void setUp() throws Exception {
  73     super.setUp();
  74     addModule("module1");
  75     addModule("module2");
  76     addModule("module3");
  77     assignJdk(getModule1());
  78   }
  79
  80   public void testCreateConfiguration() throws ExecutionException {
  81     Module module1 = getModule1();
  82     PsiClass psiClass = findTestA(module1);
  83     JUnitConfiguration configuration = createConfiguration(psiClass);
  84     assertEquals(Collections.singleton(module1), ContainerUtilRt.newHashSet(configuration.getModules()));
  85     checkClassName(psiClass.getQualifiedName(), configuration);
  86     assertEquals(psiClass.getName(), configuration.getName());
  87     checkTestObject(JUnitConfiguration.TEST_CLASS, configuration);
  88     Module module2 = getModule2();
  89     Assertion.compareUnordered(new Module[]{module1, module2}, configuration.getValidModules());
  90
  91     PsiClass innerTest = findClass(module1, INNER_TEST_NAME);
  92     configuration = createJUnitConfiguration(innerTest, TestInClassConfigurationProducer.class, new MapDataContext());
  93     checkClassName(RT_INNER_TEST_NAME, configuration);
  94     checkCanRun(configuration);
  95
  96     PsiMethod[] testMethod = innerTest.findMethodsByName("test", false);
  97     assertEquals(1, testMethod.length);
  98     configuration = createConfiguration(testMethod[0]);
  99     checkClassName(RT_INNER_TEST_NAME, configuration);
 100     checkMethodName("test", configuration);
 101     checkTestObject(JUnitConfiguration.TEST_METHOD, configuration);
 102     checkCanRun(configuration);
 103
 104     PsiMethod mainMethod = innerTest.findMethodsByName("main", false)[0];
 105     ApplicationConfiguration appConfiguration = createConfiguration(mainMethod);
 106     assertEquals(RT_INNER_TEST_NAME, appConfiguration.getMainClassName());
 107     checkCanRun(configuration);
 108   }
 109
 110   public void testModulesSelector() throws ConfigurationException {
 111     if (PlatformTestUtil.COVERAGE_ENABLED_BUILD) return;
 112
 113     Module module1 = getModule1();
 114     Module module2 = getModule2();
 115     JUnitConfigurable editor = new JUnitConfigurable(myProject);
 116     try {
 117       JUnitConfiguration configuration = createConfiguration(findTestA(module2));
 118       editor.getComponent(); // To get all the watchers installed.
 119       Configurable configurable = new RunConfigurationConfigurableAdapter(editor, configuration);
 120       ModuleDescriptionsComboBox comboBox = editor.getModulesComponent();
 121       configurable.reset();
 122       assertFalse(configurable.isModified());
 123       assertEquals(module2.getName(), comboBox.getSelectedModuleName());
 124       assertEquals(ModuleManager.getInstance(myProject).getModules().length + 1, comboBox.getModel().getSize()); //no module
 125       comboBox.setSelectedModule(module1);
 126       assertTrue(configurable.isModified());
 127       configurable.apply();
 128       assertFalse(configurable.isModified());
 129       assertEquals(Collections.singleton(module1), ContainerUtilRt.newHashSet(configuration.getModules()));
 130     }
 131     finally {
 132       Disposer.dispose(editor);
 133     }
 134   }
 135
 136   public void testCantCreateConfiguration() {
 137     PsiClass objectClass =
 138       JavaPsiFacade.getInstance(myProject).findClass(CommonClassNames.JAVA_LANG_OBJECT, GlobalSearchScope.allScope(myProject));
 139     assertNull(createConfiguration(objectClass));
 140     assertNull(createConfiguration(JUnitUtil.getContainingPackage(objectClass)));
 141   }
 142
 143   public void testRunningJUnit() throws ExecutionException {
 144     PsiClass testA = findTestA(getModule1());
 145     JUnitConfiguration configuration = createConfiguration(testA);
 146     JavaParameters parameters = checkCanRun(configuration);
 147     assertEquals("[-Didea.test.cyclic.buffer.size=1048576]", parameters.getVMParametersList().toString());
 148     final SegmentedOutputStream notifications = new SegmentedOutputStream(System.out);
 149     assertTrue(JUnitStarter.checkVersion(parameters.getProgramParametersList().getArray(),
 150                                          new PrintStream(notifications)));
 151     assertTrue(parameters.getProgramParametersList().getList().contains(testA.getQualifiedName()));
 152     assertEquals(JUnitStarter.class.getName(), parameters.getMainClass());
 153     assertEquals(myJdk.getHomeDirectory().getPresentableUrl(), parameters.getJdkPath());
 154   }
 155
 156   public void testRunningAllInPackage() throws IOException, ExecutionException {
 157     Module module1 = getModule1();
 158     GlobalSearchScope module1AndLibraries = GlobalSearchScope.moduleWithLibrariesScope(module1);
 159     PsiClass testCase = findClass(TestCase.class.getName(), module1AndLibraries);
 160     PsiClass psiClass = findTestA(module1);
 161     PsiClass psiClass2 = findTestA(getModule2());
 162     PsiClass derivedTest = findClass(module1, "test1.DerivedTest");
 163     PsiClass baseTestCase = findClass("test1.ThirdPartyTest", module1AndLibraries);
 164     PsiClass testB = findClass(getModule3(), "test1.TestB");
 165     assertNotNull(testCase);
 166     assertNotNull(derivedTest);
 167     assertNotNull(psiClass);
 168     assertTrue(psiClass.isInheritor(testCase, false));
 169     assertEquals(baseTestCase, derivedTest.getSuperClass());
 170     assertTrue(baseTestCase.isInheritor(testCase, true));
 171     assertTrue(derivedTest.isInheritor(testCase, true));
 172     PsiPackage psiPackage = JUnitUtil.getContainingPackage(psiClass);
 173     JUnitConfiguration configuration = createConfiguration(psiPackage, module1);
 174     JavaParameters parameters = checkCanRun(configuration);
 175     List<String> lines = extractAllInPackageTests(parameters, psiPackage);
 176     Assertion.compareUnordered(
 177       //category, filters, classNames...
 178       new Object[]{"", "", psiClass.getQualifiedName(),
 179         psiClass2.getQualifiedName(),
 180         derivedTest.getQualifiedName(), RT_INNER_TEST_NAME,
 181         "test1.nested.TestA",
 182         "test1.nested.TestWithJunit4",
 183         "test1.ThirdPartyTest",
 184         testB.getQualifiedName()},
 185       lines);
 186   }
 187
 188
 189   public void testRunningAllInDirectory() throws IOException, ExecutionException {
 190     Module module1 = getModule1();
 191     PsiClass psiClass = findTestA(module1);
 192
 193     JUnitConfiguration configuration =
 194       new JUnitConfiguration("", myProject, JUnitConfigurationType.getInstance().getConfigurationFactories()[0]);
 195     configuration.getPersistentData().TEST_OBJECT = JUnitConfiguration.TEST_DIRECTORY;
 196     configuration.getPersistentData().setDirName(psiClass.getContainingFile().getContainingDirectory().getVirtualFile().getPath());
 197     configuration.setModule(module1);
 198     JavaParameters parameters = checkCanRun(configuration);
 199     String filePath = ContainerUtil.find(parameters.getProgramParametersList().getArray(),
 200                                          value -> StringUtil.startsWithChar(value, '@') && !StringUtil.startsWith(value, "@w@")).substring(1);
 201     List<String> lines = readLinesFrom(new File(filePath));
 202     lines.remove(0);
 203     Assertion.compareUnordered(
 204       //category, filters, classNames...
 205       new Object[]{"", "", psiClass.getQualifiedName(),
 206         "test1.DerivedTest", RT_INNER_TEST_NAME,
 207         "test1.nested.TestA",
 208         "test1.nested.TestWithJunit4",
 209         "test1.ThirdPartyTest"},
 210       lines);
 211   }
 212
 213   public void testRunAllInPackageWhenPackageIsEmptyInModule() throws ExecutionException {
 214     assignJdk(getModule2());
 215     JUnitConfiguration configuration =
 216       new JUnitConfiguration("", myProject, JUnitConfigurationType.getInstance().getConfigurationFactories()[0]);
 217     configuration.getPersistentData().TEST_OBJECT = JUnitConfiguration.TEST_PACKAGE;
 218     configuration.getPersistentData().PACKAGE_NAME = "test2";
 219     configuration.getPersistentData().setScope(TestSearchScope.WHOLE_PROJECT);
 220     assertEmpty(configuration.getModules());
 221     checkCanRun(configuration);
 222     configuration.getPersistentData().PACKAGE_NAME = "noTests";
 223 //    checkCantRun(configuration, "No tests found in the package '");
 224
 225     configuration.getPersistentData().PACKAGE_NAME = "com.abcent";
 226     checkCantRun(configuration, "Package 'com.abcent' does not exist");
 227   }
 228
 229   public void testAllInPackageForCommonAncestorModule() throws IOException, ExecutionException {
 230     disposeModule(getModule2());
 231     addModule("module5", true);
 232     Module ancestor = getModule1();
 233     Module child1 = getModule2();
 234     Module child2 = getModule3();
 235     addDependency(ancestor, child1);
 236     addDependency(ancestor, child2);
 237     PsiPackage psiPackage = JavaPsiFacade.getInstance(myProject).findPackage("test1");
 238     JUnitConfiguration configuration = createJUnitConfiguration(psiPackage, AllInPackageConfigurationProducer.class, new MapDataContext());
 239     configuration.getPersistentData().setScope(TestSearchScope.WHOLE_PROJECT);
 240     assertNotNull(configuration);
 241     checkPackage(psiPackage.getQualifiedName(), configuration);
 242     assertEmpty(configuration.getModules());
 243     JavaParameters parameters = checkCanRun(configuration);
 244     List<String> tests = extractAllInPackageTests(parameters, psiPackage);
 245     String childTest1 = findClass(child1, "test1.TestB").getQualifiedName();
 246     String childTest2 = findClass(child2, "test1.Test5").getQualifiedName();
 247     String ancestorTest = findClass(ancestor, "test1.TestA").getQualifiedName();
 248     CHECK.containsAll(tests, new Object[]{ancestorTest, childTest1, childTest2});
 249   }
 250
 251   public void testConstructors() throws IOException, ExecutionException {
 252     addModule("module6", true);
 253     PsiPackage psiPackage = JavaPsiFacade.getInstance(myProject).findPackage("test1");
 254     JUnitConfiguration configuration = createJUnitConfiguration(psiPackage, AllInPackageConfigurationProducer.class, new MapDataContext());
 255     configuration.getPersistentData().setScope(TestSearchScope.SINGLE_MODULE);
 256     configuration.setModule(getModule(3));
 257     assertNotNull(configuration);
 258     checkPackage(psiPackage.getQualifiedName(), configuration);
 259     JavaParameters parameters = checkCanRun(configuration);
 260     List<String> tests = extractAllInPackageTests(parameters, psiPackage);
 261     CHECK.containsAll(tests, new Object[]{"test1.TestCaseInheritor"});
 262   }
 263
 264   public void testClasspathConfiguration() throws CantRunException {
 265     JavaParameters parameters = new JavaParameters();
 266     RunConfigurationModule module = new JavaRunConfigurationModule(myProject, false);
 267     Module module1 = getModule1();
 268     Module module2 = getModule2();
 269     addDependency(module1, module2);
 270     Module module3 = getModule3();
 271     addDependency(module2, module3);
 272     addDependency(module1, module3);
 273     addOutputs(module1, 1);
 274     addOutputs(module2, 2);
 275     addOutputs(module3, 3);
 276     module.setModule(module1);
 277     parameters.configureByModule(module.getModule(), JavaParameters.JDK_AND_CLASSES_AND_TESTS);
 278     ArrayList<String> classPath = new ArrayList<>();
 279     StringTokenizer tokenizer = new StringTokenizer(parameters.getClassPath().getPathsString(), File.pathSeparator);
 280     while (tokenizer.hasMoreTokens()) {
 281       String token = tokenizer.nextToken();
 282       classPath.add(token);
 283     }
 284     CHECK.singleOccurence(classPath, getOutput(module1, false));
 285     CHECK.singleOccurence(classPath, getOutput(module1, false));
 286     CHECK.singleOccurence(classPath, getOutput(module1, true));
 287     CHECK.singleOccurence(classPath, getOutput(module2, false));
 288     CHECK.singleOccurence(classPath, getOutput(module2, true));
 289     CHECK.singleOccurence(classPath, getOutput(module3, false));
 290     CHECK.singleOccurence(classPath, getOutput(module3, true));
 291     IntelliJProjectConfiguration.LibraryRoots junit4Library = IntelliJProjectConfiguration.getProjectLibrary("JUnit4");
 292     for (File file : junit4Library.getClasses()) {
 293       CHECK.singleOccurence(classPath, file.getPath());
 294     }
 295   }
 296
 297   public void testExternalizeJUnitConfiguration() {
 298     Module module = getModule1();
 299     JUnitConfiguration oldRc = createConfiguration(findTestA(module));
 300     oldRc.setWorkingDirectory(module.getModuleFilePath());
 301
 302     RunManagerImpl runManager = new RunManagerImpl(myProject);
 303     Element element = new RunnerAndConfigurationSettingsImpl(runManager, oldRc, false).writeScheme();
 304
 305     RunnerAndConfigurationSettingsImpl settings = new RunnerAndConfigurationSettingsImpl(runManager);
 306     settings.readExternal(element, false);
 307     JUnitConfiguration newRc = (JUnitConfiguration)settings.getConfiguration();
 308
 309     checkTestObject(oldRc.getPersistentData().TEST_OBJECT, newRc);
 310     assertThat(newRc.getModules()).containsOnly(module);
 311     checkClassName(oldRc.getPersistentData().getMainClassName(), newRc);
 312   }
 313
 314   public void testTestClassPathWhenRunningConfigurations() throws ExecutionException {
 315     addModule("module4", false);
 316     Module module4 = getModule4();
 317     assignJdk(module4);
 318     addSourcePath(module4, "testSrc", true);
 319     addSourcePath(module4, "src", false);
 320     String output = setCompilerOutput(module4, "classes", false);
 321     String testOuput = setCompilerOutput(module4, "testClasses", true);
 322
 323     ApplicationConfiguration applicationConfiguration = createConfiguration(findClass(module4, "Application"));
 324     JavaParameters parameters = checkCanRun(applicationConfiguration);
 325     String classPath = parameters.getClassPath().getPathsString();
 326     checkDoesNotContain(classPath, testOuput);
 327     checkContains(classPath, output);
 328
 329     JUnitConfiguration junitConfiguration =
 330       createJUnitConfiguration(findClass(module4, "TestApplication"), TestInClassConfigurationProducer.class, new MapDataContext());
 331     parameters = checkCanRun(junitConfiguration);
 332     classPath = parameters.getClassPath().getPathsString();
 333     checkContains(classPath, testOuput);
 334     checkContains(classPath, output);
 335
 336     applicationConfiguration.setMainClassName(junitConfiguration.getPersistentData().getMainClassName());
 337     classPath = checkCanRun(applicationConfiguration).getClassPath().getPathsString();
 338     checkContains(classPath, testOuput);
 339     checkContains(classPath, output);
 340   }
 341
 342   public void testSameTestAndCommonOutput() throws ExecutionException {
 343     addModule("module4", false);
 344     Module module = getModule4();
 345     assignJdk(module);
 346     addSourcePath(module, "src", false);
 347     addSourcePath(module, "testSrc", false);
 348     String output = setCompilerOutput(module, "classes", false);
 349     assertEquals(output, setCompilerOutput(module, "classes", true));
 350
 351     RunConfiguration configuration = createConfiguration(findClass(module, "Application"));
 352     JavaParameters javaParameters = checkCanRun(configuration);
 353     checkContains(javaParameters.getClassPath().getPathsString(), output);
 354
 355     configuration = createConfiguration(findClass(module, "TestApplication"));
 356     javaParameters = checkCanRun(configuration);
 357     checkContains(javaParameters.getClassPath().getPathsString(), output);
 358   }
 359
 360   public void testCreatingApplicationConfiguration() throws ConfigurationException {
 361     if (PlatformTestUtil.COVERAGE_ENABLED_BUILD) return;
 362
 363     ApplicationConfiguration configuration = new ApplicationConfiguration(null, myProject, ApplicationConfigurationType.getInstance());
 364     ApplicationConfigurable editor = new ApplicationConfigurable(myProject);
 365     try {
 366       editor.getComponent(); // To get all the watchers installed.
 367       Configurable configurable = new RunConfigurationConfigurableAdapter(editor, configuration);
 368       configurable.reset();
 369       CommonJavaParametersPanel javaParameters = editor.getCommonProgramParameters();
 370       javaParameters.setProgramParameters("prg");
 371       javaParameters.setVMParameters("vm");
 372       javaParameters.setWorkingDirectory("dir");
 373       assertTrue(configurable.isModified());
 374       configurable.apply();
 375       assertEquals("prg", configuration.getProgramParameters());
 376       assertEquals("vm", configuration.getVMParameters());
 377       assertEquals("dir", configuration.getWorkingDirectory());
 378     }
 379     finally {
 380       Disposer.dispose(editor);
 381     }
 382   }
 383
 384   public void testCreateInnerPackageLocalApplication() throws ExecutionException {
 385     PsiClass psiClass = findClass(getModule1(), "test2.NotATest.InnerApplication");
 386     assertNotNull(psiClass);
 387     ApplicationConfiguration configuration = createConfiguration(psiClass);
 388     assertEquals("test2.NotATest$InnerApplication", configuration.getMainClassName());
 389     checkCanRun(configuration);
 390   }
 391
 392   public void testEditJUnitConfiguration() throws ConfigurationException {
 393     if (PlatformTestUtil.COVERAGE_ENABLED_BUILD) return;
 394
 395     PsiClass testA = findTestA(getModule2());
 396     JUnitConfiguration configuration = createConfiguration(testA);
 397     JUnitConfigurable editor = new JUnitConfigurable(myProject);
 398     try {
 399       Configurable configurable = new RunConfigurationConfigurableAdapter(editor, configuration);
 400       configurable.reset();
 401       final EditorTextFieldWithBrowseButton component =
 402         ((LabeledComponent<EditorTextFieldWithBrowseButton>)editor.getTestLocation(JUnitConfigurationModel.CLASS)).getComponent();
 403       assertEquals(testA.getQualifiedName(), component.getText());
 404       PsiClass otherTest = findClass(getModule2(), "test2.Test2");
 405       component.setText(otherTest.getQualifiedName());
 406       configurable.apply();
 407       assertEquals(otherTest.getName(), configuration.getName());
 408       String specialName = "My name";
 409       configuration.setName(specialName);
 410       configuration.setNameChangedByUser(true);
 411       configurable.reset();
 412       component.setText(testA.getQualifiedName());
 413       configurable.apply();
 414       assertEquals(specialName, configuration.getName());
 415     }
 416     finally {
 417       Disposer.dispose(editor);
 418     }
 419   }
 420
 421   public void testRunThirdPartyApplication() throws ExecutionException {
 422     ApplicationConfiguration configuration =
 423       new ApplicationConfiguration("Third party", myProject, ApplicationConfigurationType.getInstance());
 424     configuration.setModule(getModule1());
 425     configuration.setMainClassName("third.party.Main");
 426     checkCanRun(configuration);
 427   }
 428
 429   public void testAllInPackageForProject() throws ExecutionException {
 430     // module1 -> module2 -> module3
 431     // module5
 432     addModule("module5");
 433     addDependency(getModule1(), getModule2());
 434     addDependency(getModule2(), getModule3());
 435     String[][] outputs = new String[4][];
 436     for (int i = 0; i < 4; i++) {
 437       outputs[i] = addOutputs(getModule(i), i + 1);
 438     }
 439
 440
 441     PsiPackage defaultPackage = JavaPsiFacade.getInstance(myProject).findPackage("");
 442     JUnitConfiguration configuration =
 443       createJUnitConfiguration(defaultPackage, AllInPackageConfigurationProducer.class, new MapDataContext());
 444     configuration.getPersistentData().setScope(TestSearchScope.WHOLE_PROJECT);
 445     JavaParameters javaParameters = checkCanRun(configuration);
 446     String classPath = javaParameters.getClassPath().getPathsString();
 447     assertEquals(-1, classPath.indexOf(JarFileSystem.PROTOCOL_PREFIX));
 448     assertEquals(-1, classPath.indexOf(LocalFileSystem.PROTOCOL_PREFIX));
 449     for (int i = 0; i < 4; i++) {
 450       checkContains(classPath, outputs[i][0]);
 451       checkContains(classPath, outputs[i][1]);
 452     }
 453   }
 454
 455   public void testOriginalModule() {
 456     ModuleRootModificationUtil.addDependency(getModule1(), getModule2(), DependencyScope.TEST, true);
 457     ModuleRootModificationUtil.addDependency(getModule2(), getModule3(), DependencyScope.TEST, false);
 458     assertTrue(ModuleBasedConfiguration.canRestoreOriginalModule(getModule1(), new Module[] {getModule2()}));
 459     assertTrue(ModuleBasedConfiguration.canRestoreOriginalModule(getModule1(), new Module[] {getModule3()}));
 460
 461     //not exported but on the classpath
 462     addModule("module4");
 463     ModuleRootModificationUtil.addDependency(getModule3(), getModule4(), DependencyScope.TEST, false);
 464     assertTrue(ModuleBasedConfiguration.canRestoreOriginalModule(getModule1(), new Module[] {getModule4()}));
 465
 466     addModule("module5");
 467     assertFalse(ModuleBasedConfiguration.canRestoreOriginalModule(getModule1(), new Module[] {getModule(4)}));
 468
 469     assertFalse(ModuleBasedConfiguration.canRestoreOriginalModule(getModule2(), new Module[] {getModule1()}));
 470   }
 471
 472   private void assignJdk(Module module) {
 473     myJdk = ModuleRootManager.getInstance(myModule).getSdk();
 474     ModuleRootModificationUtil.setModuleSdk(module, myJdk);
 475   }
 476
 477   private static String getOutput(Module module1, boolean test) {
 478     CompilerModuleExtension compilerModuleExtension = CompilerModuleExtension.getInstance(module1);
 479     assertNotNull(compilerModuleExtension);
 480     VirtualFile output = test ? compilerModuleExtension.getCompilerOutputPathForTests() : compilerModuleExtension.getCompilerOutputPath();
 481     return getFSPath(output);
 482   }
 483
 484   private static String getFSPath(VirtualFile output) {
 485     return PathUtil.getLocalPath(output);
 486   }
 487
 488   private String[] addOutputs(Module module, int index) {
 489     String[] outputs = new String[2];
 490     String prefix = "outputs" + File.separatorChar;
 491     VirtualFile generalOutput = findFile(prefix + "general " + index);
 492     VirtualFile testOutput = findFile(prefix + "tests" + index);
 493     outputs[0] = generalOutput.getPresentableUrl();
 494     outputs[1] = testOutput.getPresentableUrl();
 495     PsiTestUtil.setCompilerOutputPath(module, generalOutput.getUrl(), false);
 496     PsiTestUtil.setCompilerOutputPath(module, testOutput.getUrl(), true);
 497     Disposer.register(getTestRootDisposable(), new Disposable() {
 498       @Override
 499       public void dispose() {
 500         for (File file : new File(outputs[1]).listFiles()) {
 501           if (file.getName().equals("keep.dir")) continue;
 502           FileUtil.delete(file);
 503         }
 504       }
 505     });
 506     return outputs;
 507   }
 508
 509   private static JavaParameters checkCanRun(RunConfiguration configuration) throws ExecutionException {
 510     final RunProfileState state;
 511     state = ExecutionEnvironmentBuilder.create(DefaultRunExecutor.getRunExecutorInstance(), configuration).build().getState();
 512     assertNotNull(state);
 513     assertTrue(state instanceof JavaCommandLine);
 514     if (state instanceof TestPackage) {
 515       @SuppressWarnings("UnusedDeclaration")
 516       final JavaParameters parameters = ((TestPackage)state).getJavaParameters();
 517       final SearchForTestsTask task = ((TestPackage)state).createSearchingForTestsTask();
 518       assertNotNull(task);
 519       Project project = configuration.getProject();
 520       try {
 521         if (Registry.is("junit4.search.4.tests.all.in.scope")) {
 522           task.startSearch();
 523         }
 524         else {
 525           CompilerTester tester = new CompilerTester(project, Arrays.asList(ModuleManager.getInstance(project).getModules()));
 526           try {
 527             List<CompilerMessage> messages = tester.make();
 528             assertFalse(messages.stream().filter(message -> message.getCategory() == CompilerMessageCategory.ERROR)
 529                                 .map(message -> message.getMessage())
 530                                 .findFirst().orElse("Compiles fine"),
 531                         messages.stream().anyMatch(message -> message.getCategory() == CompilerMessageCategory.ERROR));
 532             task.startSearch();
 533           }
 534           finally {
 535             tester.tearDown();
 536           }
 537         }
 538       }
 539       catch (Exception e) {
 540         fail(e.getMessage());
 541       }
 542     }
 543     try {
 544       configuration.checkConfiguration();
 545     }
 546     catch (RuntimeConfigurationError e) {
 547       fail("cannot run: " + e.getMessage());
 548     }
 549     catch (RuntimeConfigurationException e) {
 550       //ignore
 551     }
 552     return ((JavaCommandLine)state).getJavaParameters();
 553   }
 554
 555   private void checkCantRun(RunConfiguration configuration, String reasonBeginning) throws ExecutionException {
 556     //MockRunRequest request = new MockRunRequest(myProject);
 557     //CantRunException rejectReason;
 558     //try {
 559     //  configuration.runRequested(request);
 560     //  rejectReason = request.myRejectReason;
 561     //}
 562     //catch (CantRunException e) {
 563     //  rejectReason = e;
 564     //}
 565     //if (rejectReason == null) fail("Should not run");
 566     //rejectReason.getMessage().startsWith(reasonBeginning);
 567
 568     try {
 569       configuration.checkConfiguration();
 570     }
 571     catch (RuntimeConfigurationException e) {
 572       assertTrue(e.getLocalizedMessage().startsWith(reasonBeginning));
 573       return;
 574     }
 575
 576     RunProfileState state = configuration.getState(DefaultRunExecutor.getRunExecutorInstance(), new ExecutionEnvironmentBuilder(myProject, DefaultRunExecutor.getRunExecutorInstance()).runProfile(configuration).build());
 577     assertTrue(state instanceof JavaCommandLine);
 578
 579     try {
 580       ((JavaCommandLine)state).getJavaParameters();
 581     }
 582     catch (Throwable e) {
 583       assertTrue(e.getLocalizedMessage().startsWith(reasonBeginning));
 584       return;
 585     }
 586
 587     fail("Should not run");
 588   }
 589
 590   private static String setCompilerOutput(Module module, String path, boolean testOutput) {
 591     VirtualFile output = ModuleRootManager.getInstance(module).getContentEntries()[0].getFile().findChild(path);
 592     assertNotNull(output);
 593     PsiTestUtil.setCompilerOutputPath(module, output.getUrl(), testOutput);
 594     return output.getPath().replace('/', File.separatorChar);
 595   }
 596
 597   private static void addSourcePath(Module module, String path, boolean testSource) {
 598     final ContentEntry entry = ModuleRootManager.getInstance(module).getContentEntries()[0];
 599     VirtualFile child = entry.getFile().findChild(path);
 600     assertNotNull(child);
 601     PsiTestUtil.addSourceRoot(module, child, testSource);
 602   }
 603
 604   private JUnitConfiguration createConfiguration(PsiPackage psiPackage, Module module) {
 605     JUnitConfiguration configuration =
 606       new JUnitConfiguration("", myProject, JUnitConfigurationType.getInstance().getConfigurationFactories()[0]);
 607     configuration.getPersistentData().TEST_OBJECT = JUnitConfiguration.TEST_PACKAGE;
 608     configuration.getPersistentData().PACKAGE_NAME = psiPackage.getQualifiedName();
 609     configuration.getPersistentData().setScope(TestSearchScope.WHOLE_PROJECT);
 610     configuration.setModule(module);
 611     return configuration;
 612   }
 613
 614   private PsiClass findTestA(Module module) {
 615     return findClass(module, "test1.TestA");
 616   }
 617
 618   private static List<String> readLinesFrom(File file) throws IOException {
 619     if (!file.exists()) file.createNewFile();
 620     ArrayList<String> result = new ArrayList<>();
 621     BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
 622     try {
 623       String line;
 624       while ((line = reader.readLine()) != null) result.add(line);
 625       return result;
 626     }
 627     finally {
 628       reader.close();
 629     }
 630   }
 631
 632   private static List<String> extractAllInPackageTests(JavaParameters parameters, PsiPackage psiPackage)
 633     throws IOException {
 634     String filePath = ContainerUtil.find(parameters.getProgramParametersList().getArray(),
 635                                          value -> StringUtil.startsWithChar(value, '@') && !StringUtil.startsWith(value, "@w@")).substring(1);
 636     List<String> lines = readLinesFrom(new File(filePath));
 637     assertEquals(psiPackage.getQualifiedName(), lines.get(0));
 638     //lines.remove(0);
 639     lines.remove(0);
 640     return lines;
 641   }
 642
 643   private static void checkContains(String string, String fragment) {
 644     assertTrue(fragment + " in " + string, string.contains(fragment));
 645   }
 646
 647   private static void checkDoesNotContain(String string, String fragment) {
 648     assertFalse(fragment + " in " + string, string.contains(fragment));
 649   }
 650
 651   @Override
 652   protected void tearDown() throws Exception {
 653     myJdk = null;
 654     super.tearDown();
 655   }
 656 }