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