junit detection: test for constructor args
[idea/community.git] / java / java-tests / testSrc / com / intellij / java / execution / ConfigurationsTest.java
1 /*
2  * Copyright 2000-2017 JetBrains s.r.o.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package com.intellij.java.execution;
17
18 import com.intellij.application.options.ModuleDescriptionsComboBox;
19 import com.intellij.execution.CantRunException;
20 import com.intellij.execution.ExecutionException;
21 import com.intellij.execution.RunConfigurationConfigurableAdapter;
22 import com.intellij.execution.application.ApplicationConfigurable;
23 import com.intellij.execution.application.ApplicationConfiguration;
24 import com.intellij.execution.application.ApplicationConfigurationType;
25 import com.intellij.execution.configurations.*;
26 import com.intellij.execution.executors.DefaultRunExecutor;
27 import com.intellij.execution.impl.RunManagerImpl;
28 import com.intellij.execution.impl.RunnerAndConfigurationSettingsImpl;
29 import com.intellij.execution.junit.*;
30 import com.intellij.execution.junit2.configuration.JUnitConfigurable;
31 import com.intellij.execution.junit2.configuration.JUnitConfigurationModel;
32 import com.intellij.execution.runners.ExecutionEnvironmentBuilder;
33 import com.intellij.execution.testframework.SearchForTestsTask;
34 import com.intellij.execution.testframework.TestSearchScope;
35 import com.intellij.execution.ui.CommonJavaParametersPanel;
36 import com.intellij.openapi.Disposable;
37 import com.intellij.openapi.compiler.CompilerMessage;
38 import com.intellij.openapi.compiler.CompilerMessageCategory;
39 import com.intellij.openapi.module.Module;
40 import com.intellij.openapi.module.ModuleManager;
41 import com.intellij.openapi.options.Configurable;
42 import com.intellij.openapi.options.ConfigurationException;
43 import com.intellij.openapi.project.Project;
44 import com.intellij.openapi.projectRoots.Sdk;
45 import com.intellij.openapi.roots.*;
46 import com.intellij.openapi.ui.LabeledComponent;
47 import com.intellij.openapi.util.Disposer;
48 import com.intellij.openapi.util.io.FileUtil;
49 import com.intellij.openapi.util.text.StringUtil;
50 import com.intellij.openapi.vfs.JarFileSystem;
51 import com.intellij.openapi.vfs.LocalFileSystem;
52 import com.intellij.openapi.vfs.VirtualFile;
53 import com.intellij.psi.*;
54 import com.intellij.psi.search.GlobalSearchScope;
55 import com.intellij.rt.ant.execution.SegmentedOutputStream;
56 import com.intellij.rt.execution.junit.JUnitStarter;
57 import com.intellij.testFramework.CompilerTester;
58 import com.intellij.testFramework.MapDataContext;
59 import com.intellij.testFramework.PlatformTestUtil;
60 import com.intellij.testFramework.PsiTestUtil;
61 import com.intellij.ui.EditorTextFieldWithBrowseButton;
62 import com.intellij.util.Assertion;
63 import com.intellij.util.PathUtil;
64 import com.intellij.util.containers.ContainerUtil;
65 import com.intellij.util.containers.ContainerUtilRt;
66 import junit.framework.TestCase;
67 import org.jdom.Element;
68
69 import java.io.*;
70 import java.util.*;
71
72 import static org.assertj.core.api.Assertions.assertThat;
73
74 public class ConfigurationsTest extends BaseConfigurationTestCase {
75   private final Assertion CHECK = new Assertion();
76
77   private Sdk myJdk;
78   private static final String INNER_TEST_NAME = "test1.InnerTest.Inner";
79   private static final String RT_INNER_TEST_NAME = "test1.InnerTest$Inner";
80
81   @Override
82   protected void setUp() throws Exception {
83     super.setUp();
84     addModule("module1");
85     addModule("module2");
86     addModule("module3");
87     assignJdk(getModule1());
88   }
89
90   public void testCreateConfiguration() throws ExecutionException {
91     Module module1 = getModule1();
92     PsiClass psiClass = findTestA(module1);
93     JUnitConfiguration configuration = createConfiguration(psiClass);
94     assertEquals(Collections.singleton(module1), ContainerUtilRt.newHashSet(configuration.getModules()));
95     checkClassName(psiClass.getQualifiedName(), configuration);
96     assertEquals(psiClass.getName(), configuration.getName());
97     checkTestObject(JUnitConfiguration.TEST_CLASS, configuration);
98     Module module2 = getModule2();
99     Assertion.compareUnordered(new Module[]{module1, module2}, configuration.getValidModules());
100
101     PsiClass innerTest = findClass(module1, INNER_TEST_NAME);
102     configuration = createJUnitConfiguration(innerTest, TestInClassConfigurationProducer.class, new MapDataContext());
103     checkClassName(RT_INNER_TEST_NAME, configuration);
104     checkCanRun(configuration);
105
106     PsiMethod[] testMethod = innerTest.findMethodsByName("test", false);
107     assertEquals(1, testMethod.length);
108     configuration = createConfiguration(testMethod[0]);
109     checkClassName(RT_INNER_TEST_NAME, configuration);
110     checkMethodName("test", configuration);
111     checkTestObject(JUnitConfiguration.TEST_METHOD, configuration);
112     checkCanRun(configuration);
113
114     PsiMethod mainMethod = innerTest.findMethodsByName("main", false)[0];
115     ApplicationConfiguration appConfiguration = createConfiguration(mainMethod);
116     assertEquals(RT_INNER_TEST_NAME, appConfiguration.MAIN_CLASS_NAME);
117     checkCanRun(configuration);
118   }
119
120   public void testModulesSelector() throws ConfigurationException {
121     if (PlatformTestUtil.COVERAGE_ENABLED_BUILD) return;
122
123     Module module1 = getModule1();
124     Module module2 = getModule2();
125     JUnitConfigurable editor = new JUnitConfigurable(myProject);
126     try {
127       JUnitConfiguration configuration = createConfiguration(findTestA(module2));
128       editor.getComponent(); // To get all the watchers installed.
129       Configurable configurable = new RunConfigurationConfigurableAdapter(editor, configuration);
130       ModuleDescriptionsComboBox comboBox = editor.getModulesComponent();
131       configurable.reset();
132       assertFalse(configurable.isModified());
133       assertEquals(module2.getName(), comboBox.getSelectedModuleName());
134       assertEquals(ModuleManager.getInstance(myProject).getModules().length + 1, comboBox.getModel().getSize()); //no module
135       comboBox.setSelectedModule(module1);
136       assertTrue(configurable.isModified());
137       configurable.apply();
138       assertFalse(configurable.isModified());
139       assertEquals(Collections.singleton(module1), ContainerUtilRt.newHashSet(configuration.getModules()));
140     }
141     finally {
142       Disposer.dispose(editor);
143     }
144   }
145
146   public void testCantCreateConfiguration() {
147     PsiClass objectClass =
148       JavaPsiFacade.getInstance(myProject).findClass(CommonClassNames.JAVA_LANG_OBJECT, GlobalSearchScope.allScope(myProject));
149     assertNull(createConfiguration(objectClass));
150     assertNull(createConfiguration(JUnitUtil.getContainingPackage(objectClass)));
151   }
152
153   public void testRunningJUnit() throws ExecutionException {
154     PsiClass testA = findTestA(getModule1());
155     JUnitConfiguration configuration = createConfiguration(testA);
156     JavaParameters parameters = checkCanRun(configuration);
157     assertEquals("[-Didea.test.cyclic.buffer.size=1048576]", parameters.getVMParametersList().toString());
158     final SegmentedOutputStream notifications = new SegmentedOutputStream(System.out);
159     assertTrue(JUnitStarter.checkVersion(parameters.getProgramParametersList().getArray(),
160                                          new PrintStream(notifications)));
161     assertTrue(parameters.getProgramParametersList().getList().contains(testA.getQualifiedName()));
162     assertEquals(JUnitStarter.class.getName(), parameters.getMainClass());
163     assertEquals(myJdk.getHomeDirectory().getPresentableUrl(), parameters.getJdkPath());
164   }
165
166   public void testRunningAllInPackage() throws IOException, ExecutionException {
167     Module module1 = getModule1();
168     GlobalSearchScope module1AndLibraries = GlobalSearchScope.moduleWithLibrariesScope(module1);
169     PsiClass testCase = findClass(TestCase.class.getName(), module1AndLibraries);
170     PsiClass psiClass = findTestA(module1);
171     PsiClass psiClass2 = findTestA(getModule2());
172     PsiClass derivedTest = findClass(module1, "test1.DerivedTest");
173     PsiClass baseTestCase = findClass("junit.framework.ThirdPartyClass", module1AndLibraries);
174     PsiClass testB = findClass(getModule3(), "test1.TestB");
175     assertNotNull(testCase);
176     assertNotNull(derivedTest);
177     assertNotNull(psiClass);
178     assertTrue(psiClass.isInheritor(testCase, false));
179     assertEquals(baseTestCase, derivedTest.getSuperClass());
180     assertTrue(baseTestCase.isInheritor(testCase, true));
181     assertTrue(derivedTest.isInheritor(testCase, true));
182     PsiPackage psiPackage = JUnitUtil.getContainingPackage(psiClass);
183     JUnitConfiguration configuration = createConfiguration(psiPackage, module1);
184     JavaParameters parameters = checkCanRun(configuration);
185     List<String> lines = extractAllInPackageTests(parameters, psiPackage);
186     Assertion.compareUnordered(
187       //category, filters, classNames...
188       new Object[]{"", "", psiClass.getQualifiedName(), derivedTest.getQualifiedName(), RT_INNER_TEST_NAME,
189         testB.getQualifiedName()},
190       lines);
191   }
192
193   public void testRunAllInPackageWhenPackageIsEmptyInModule() throws ExecutionException {
194     assignJdk(getModule2());
195     JUnitConfiguration configuration =
196       new JUnitConfiguration("", myProject, JUnitConfigurationType.getInstance().getConfigurationFactories()[0]);
197     configuration.getPersistentData().TEST_OBJECT = JUnitConfiguration.TEST_PACKAGE;
198     configuration.getPersistentData().PACKAGE_NAME = "test2";
199     configuration.getPersistentData().setScope(TestSearchScope.WHOLE_PROJECT);
200     assertEmpty(configuration.getModules());
201     checkCanRun(configuration);
202     configuration.getPersistentData().PACKAGE_NAME = "noTests";
203 //    checkCantRun(configuration, "No tests found in the package '");
204
205     configuration.getPersistentData().PACKAGE_NAME = "com.abcent";
206     checkCantRun(configuration, "Package 'com.abcent' does not exist");
207   }
208
209   public void testAllInPackageForCommonAncestorModule() throws IOException, ExecutionException {
210     disposeModule(getModule2());
211     addModule("module5", true);
212     Module ancestor = getModule1();
213     Module child1 = getModule2();
214     Module child2 = getModule3();
215     addDependency(ancestor, child1);
216     addDependency(ancestor, child2);
217     PsiPackage psiPackage = JavaPsiFacade.getInstance(myProject).findPackage("test1");
218     JUnitConfiguration configuration = createJUnitConfiguration(psiPackage, AllInPackageConfigurationProducer.class, new MapDataContext());
219     configuration.getPersistentData().setScope(TestSearchScope.WHOLE_PROJECT);
220     assertNotNull(configuration);
221     checkPackage(psiPackage.getQualifiedName(), configuration);
222     assertEmpty(configuration.getModules());
223     JavaParameters parameters = checkCanRun(configuration);
224     List<String> tests = extractAllInPackageTests(parameters, psiPackage);
225     String childTest1 = findClass(child1, "test1.TestB").getQualifiedName();
226     String childTest2 = findClass(child2, "test1.Test5").getQualifiedName();
227     String ancestorTest = findClass(ancestor, "test1.TestA").getQualifiedName();
228     CHECK.containsAll(tests, new Object[]{ancestorTest, childTest1, childTest2});
229   }
230
231   public void testConstructors() throws IOException, ExecutionException {
232     addModule("module6", true);
233     PsiPackage psiPackage = JavaPsiFacade.getInstance(myProject).findPackage("test1");
234     JUnitConfiguration configuration = createJUnitConfiguration(psiPackage, AllInPackageConfigurationProducer.class, new MapDataContext());
235     configuration.getPersistentData().setScope(TestSearchScope.SINGLE_MODULE);
236     configuration.setModule(getModule(3));
237     assertNotNull(configuration);
238     checkPackage(psiPackage.getQualifiedName(), configuration);
239     JavaParameters parameters = checkCanRun(configuration);
240     List<String> tests = extractAllInPackageTests(parameters, psiPackage);
241     CHECK.containsAll(tests, new Object[]{"test1.TestCaseInheritor"});
242   }
243
244   public void testClasspathConfiguration() throws CantRunException {
245     JavaParameters parameters = new JavaParameters();
246     RunConfigurationModule module = new JavaRunConfigurationModule(myProject, false);
247     Module module1 = getModule1();
248     Module module2 = getModule2();
249     addDependency(module1, module2);
250     Module module3 = getModule3();
251     addDependency(module2, module3);
252     addDependency(module1, module3);
253     addOutputs(module1, 1);
254     addOutputs(module2, 2);
255     addOutputs(module3, 3);
256     module.setModule(module1);
257     parameters.configureByModule(module.getModule(), JavaParameters.JDK_AND_CLASSES_AND_TESTS);
258     ArrayList<String> classPath = new ArrayList<>();
259     StringTokenizer tokenizer = new StringTokenizer(parameters.getClassPath().getPathsString(), File.pathSeparator);
260     while (tokenizer.hasMoreTokens()) {
261       String token = tokenizer.nextToken();
262       classPath.add(token);
263     }
264     CHECK.singleOccurence(classPath, getOutput(module1, false));
265     CHECK.singleOccurence(classPath, getOutput(module1, false));
266     CHECK.singleOccurence(classPath, getOutput(module1, true));
267     CHECK.singleOccurence(classPath, getOutput(module2, false));
268     CHECK.singleOccurence(classPath, getOutput(module2, true));
269     CHECK.singleOccurence(classPath, getOutput(module3, false));
270     CHECK.singleOccurence(classPath, getOutput(module3, true));
271     CHECK.singleOccurence(classPath, getFSPath(findFile(MOCK_JUNIT)));
272   }
273
274   public void testExternalizeJUnitConfiguration() {
275     Module module = getModule1();
276     JUnitConfiguration oldRc = createConfiguration(findTestA(module));
277     oldRc.setWorkingDirectory(module.getModuleFilePath());
278
279     RunManagerImpl runManager = new RunManagerImpl(myProject);
280     Element element = new RunnerAndConfigurationSettingsImpl(runManager, oldRc, false).writeScheme();
281
282     RunnerAndConfigurationSettingsImpl settings = new RunnerAndConfigurationSettingsImpl(runManager);
283     settings.readExternal(element, false);
284     JUnitConfiguration newRc = (JUnitConfiguration)settings.getConfiguration();
285
286     checkTestObject(oldRc.getPersistentData().TEST_OBJECT, newRc);
287     assertThat(newRc.getModules()).containsOnly(module);
288     checkClassName(oldRc.getPersistentData().getMainClassName(), newRc);
289   }
290
291   public void testTestClassPathWhenRunningConfigurations() throws ExecutionException {
292     addModule("module4", false);
293     Module module4 = getModule4();
294     assignJdk(module4);
295     addSourcePath(module4, "testSrc", true);
296     addSourcePath(module4, "src", false);
297     String output = setCompilerOutput(module4, "classes", false);
298     String testOuput = setCompilerOutput(module4, "testClasses", true);
299
300     ApplicationConfiguration applicationConfiguration = createConfiguration(findClass(module4, "Application"));
301     JavaParameters parameters = checkCanRun(applicationConfiguration);
302     String classPath = parameters.getClassPath().getPathsString();
303     checkDoesNotContain(classPath, testOuput);
304     checkContains(classPath, output);
305
306     JUnitConfiguration junitConfiguration =
307       createJUnitConfiguration(findClass(module4, "TestApplication"), TestInClassConfigurationProducer.class, new MapDataContext());
308     parameters = checkCanRun(junitConfiguration);
309     classPath = parameters.getClassPath().getPathsString();
310     checkContains(classPath, testOuput);
311     checkContains(classPath, output);
312
313     applicationConfiguration.MAIN_CLASS_NAME = junitConfiguration.getPersistentData().getMainClassName();
314     classPath = checkCanRun(applicationConfiguration).getClassPath().getPathsString();
315     checkContains(classPath, testOuput);
316     checkContains(classPath, output);
317   }
318
319   public void testSameTestAndCommonOutput() throws ExecutionException {
320     addModule("module4", false);
321     Module module = getModule4();
322     assignJdk(module);
323     addSourcePath(module, "src", false);
324     addSourcePath(module, "testSrc", false);
325     String output = setCompilerOutput(module, "classes", false);
326     assertEquals(output, setCompilerOutput(module, "classes", true));
327
328     RunConfiguration configuration = createConfiguration(findClass(module, "Application"));
329     JavaParameters javaParameters = checkCanRun(configuration);
330     checkContains(javaParameters.getClassPath().getPathsString(), output);
331
332     configuration = createConfiguration(findClass(module, "TestApplication"));
333     javaParameters = checkCanRun(configuration);
334     checkContains(javaParameters.getClassPath().getPathsString(), output);
335   }
336
337   public void testCreatingApplicationConfiguration() throws ConfigurationException {
338     if (PlatformTestUtil.COVERAGE_ENABLED_BUILD) return;
339
340     ApplicationConfiguration configuration = new ApplicationConfiguration(null, myProject, ApplicationConfigurationType.getInstance());
341     ApplicationConfigurable editor = new ApplicationConfigurable(myProject);
342     try {
343       editor.getComponent(); // To get all the watchers installed.
344       Configurable configurable = new RunConfigurationConfigurableAdapter(editor, configuration);
345       configurable.reset();
346       CommonJavaParametersPanel javaParameters = editor.getCommonProgramParameters();
347       javaParameters.setProgramParameters("prg");
348       javaParameters.setVMParameters("vm");
349       javaParameters.setWorkingDirectory("dir");
350       assertTrue(configurable.isModified());
351       configurable.apply();
352       assertEquals("prg", configuration.getProgramParameters());
353       assertEquals("vm", configuration.getVMParameters());
354       assertEquals("dir", configuration.getWorkingDirectory());
355     }
356     finally {
357       Disposer.dispose(editor);
358     }
359   }
360
361   public void testCreateInnerPackageLocalApplication() throws ExecutionException {
362     PsiClass psiClass = findClass(getModule1(), "test2.NotATest.InnerApplication");
363     assertNotNull(psiClass);
364     ApplicationConfiguration configuration = createConfiguration(psiClass);
365     assertEquals("test2.NotATest$InnerApplication", configuration.MAIN_CLASS_NAME);
366     checkCanRun(configuration);
367   }
368
369   public void testEditJUnitConfiguration() throws ConfigurationException {
370     if (PlatformTestUtil.COVERAGE_ENABLED_BUILD) return;
371
372     PsiClass testA = findTestA(getModule2());
373     JUnitConfiguration configuration = createConfiguration(testA);
374     JUnitConfigurable editor = new JUnitConfigurable(myProject);
375     try {
376       Configurable configurable = new RunConfigurationConfigurableAdapter(editor, configuration);
377       configurable.reset();
378       final EditorTextFieldWithBrowseButton component =
379         ((LabeledComponent<EditorTextFieldWithBrowseButton>)editor.getTestLocation(JUnitConfigurationModel.CLASS)).getComponent();
380       assertEquals(testA.getQualifiedName(), component.getText());
381       PsiClass otherTest = findClass(getModule2(), "test2.Test2");
382       component.setText(otherTest.getQualifiedName());
383       configurable.apply();
384       assertEquals(otherTest.getName(), configuration.getName());
385       String specialName = "My name";
386       configuration.setName(specialName);
387       configuration.setNameChangedByUser(true);
388       configurable.reset();
389       component.setText(testA.getQualifiedName());
390       configurable.apply();
391       assertEquals(specialName, configuration.getName());
392     }
393     finally {
394       Disposer.dispose(editor);
395     }
396   }
397
398   public void testRunThirdPartyApplication() throws ExecutionException {
399     ApplicationConfiguration configuration =
400       new ApplicationConfiguration("Third party", myProject, ApplicationConfigurationType.getInstance());
401     configuration.setModule(getModule1());
402     configuration.MAIN_CLASS_NAME = "third.party.Main";
403     checkCanRun(configuration);
404   }
405
406   public void testAllInPackageForProject() throws ExecutionException {
407     // module1 -> module2 -> module3
408     // module5
409     addModule("module5");
410     addDependency(getModule1(), getModule2());
411     addDependency(getModule2(), getModule3());
412     String[][] outputs = new String[4][];
413     for (int i = 0; i < 4; i++) {
414       outputs[i] = addOutputs(getModule(i), i + 1);
415     }
416
417
418     PsiPackage defaultPackage = JavaPsiFacade.getInstance(myProject).findPackage("");
419     JUnitConfiguration configuration =
420       createJUnitConfiguration(defaultPackage, AllInPackageConfigurationProducer.class, new MapDataContext());
421     configuration.getPersistentData().setScope(TestSearchScope.WHOLE_PROJECT);
422     JavaParameters javaParameters = checkCanRun(configuration);
423     String classPath = javaParameters.getClassPath().getPathsString();
424     assertEquals(-1, classPath.indexOf(JarFileSystem.PROTOCOL_PREFIX));
425     assertEquals(-1, classPath.indexOf(LocalFileSystem.PROTOCOL_PREFIX));
426     for (int i = 0; i < 4; i++) {
427       checkContains(classPath, outputs[i][0]);
428       checkContains(classPath, outputs[i][1]);
429     }
430   }
431
432   public void testOriginalModule() {
433     ModuleRootModificationUtil.addDependency(getModule1(), getModule2(), DependencyScope.TEST, true);
434     ModuleRootModificationUtil.addDependency(getModule2(), getModule3(), DependencyScope.TEST, false);
435     assertTrue(ModuleBasedConfiguration.canRestoreOriginalModule(getModule1(), new Module[] {getModule2()}));
436     assertTrue(ModuleBasedConfiguration.canRestoreOriginalModule(getModule1(), new Module[] {getModule3()}));
437
438     //not exported but on the classpath
439     addModule("module4");
440     ModuleRootModificationUtil.addDependency(getModule3(), getModule4(), DependencyScope.TEST, false);
441     assertTrue(ModuleBasedConfiguration.canRestoreOriginalModule(getModule1(), new Module[] {getModule4()}));
442
443     addModule("module5");
444     assertFalse(ModuleBasedConfiguration.canRestoreOriginalModule(getModule1(), new Module[] {getModule(4)}));
445
446     assertFalse(ModuleBasedConfiguration.canRestoreOriginalModule(getModule2(), new Module[] {getModule1()}));
447   }
448
449   private void assignJdk(Module module) {
450     myJdk = ModuleRootManager.getInstance(myModule).getSdk();
451     ModuleRootModificationUtil.setModuleSdk(module, myJdk);
452   }
453
454   private static String getOutput(Module module1, boolean test) {
455     CompilerModuleExtension compilerModuleExtension = CompilerModuleExtension.getInstance(module1);
456     assertNotNull(compilerModuleExtension);
457     VirtualFile output = test ? compilerModuleExtension.getCompilerOutputPathForTests() : compilerModuleExtension.getCompilerOutputPath();
458     return getFSPath(output);
459   }
460
461   private static String getFSPath(VirtualFile output) {
462     return PathUtil.getLocalPath(output);
463   }
464
465   private String[] addOutputs(Module module, int index) {
466     String[] outputs = new String[2];
467     String prefix = "outputs" + File.separatorChar;
468     VirtualFile generalOutput = findFile(prefix + "general " + index);
469     VirtualFile testOutput = findFile(prefix + "tests" + index);
470     outputs[0] = generalOutput.getPresentableUrl();
471     outputs[1] = testOutput.getPresentableUrl();
472     PsiTestUtil.setCompilerOutputPath(module, generalOutput.getUrl(), false);
473     PsiTestUtil.setCompilerOutputPath(module, testOutput.getUrl(), true);
474     Disposer.register(getTestRootDisposable(), new Disposable() {
475       @Override
476       public void dispose() {
477         for (File file : new File(outputs[1]).listFiles()) {
478           if (file.getName().equals("keep.dir")) continue;
479           FileUtil.delete(file);
480         }
481       }
482     });
483     return outputs;
484   }
485
486   private static JavaParameters checkCanRun(RunConfiguration configuration) throws ExecutionException {
487     final RunProfileState state;
488     state = ExecutionEnvironmentBuilder.create(DefaultRunExecutor.getRunExecutorInstance(), configuration).build().getState();
489     assertNotNull(state);
490     assertTrue(state instanceof JavaCommandLine);
491     if (state instanceof TestPackage) {
492       @SuppressWarnings("UnusedDeclaration")
493       final JavaParameters parameters = ((TestPackage)state).getJavaParameters();
494       final SearchForTestsTask task = ((TestPackage)state).createSearchingForTestsTask();
495       assertNotNull(task);
496       Project project = configuration.getProject();
497       try {
498         CompilerTester tester = new CompilerTester(project, Arrays.asList(ModuleManager.getInstance(project).getModules()));
499         try {
500           List<CompilerMessage> messages = tester.make();
501           assertFalse(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 }