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