search for tests in directory restored for down-up approach
[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.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 }