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