effectively unqualified: take parenthesis around qualifier into account
[idea/community.git] / plugins / junit / src / com / intellij / execution / junit / JUnitConfiguration.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
5 package com.intellij.execution.junit;
6
7 import com.intellij.codeInsight.MetaAnnotationUtil;
8 import com.intellij.diagnostic.logging.LogConfigurationPanel;
9 import com.intellij.execution.*;
10 import com.intellij.execution.actions.RunConfigurationProducer;
11 import com.intellij.execution.configuration.EnvironmentVariablesComponent;
12 import com.intellij.execution.configurations.*;
13 import com.intellij.execution.executors.DefaultRunExecutor;
14 import com.intellij.execution.junit2.configuration.JUnitConfigurable;
15 import com.intellij.execution.junit2.info.MethodLocation;
16 import com.intellij.execution.junit2.ui.properties.JUnitConsoleProperties;
17 import com.intellij.execution.runners.ExecutionEnvironment;
18 import com.intellij.execution.runners.ExecutionEnvironmentBuilder;
19 import com.intellij.execution.testframework.TestSearchScope;
20 import com.intellij.execution.testframework.sm.runner.SMTRunnerConsoleProperties;
21 import com.intellij.openapi.module.Module;
22 import com.intellij.openapi.module.ModuleManager;
23 import com.intellij.openapi.options.SettingsEditor;
24 import com.intellij.openapi.options.SettingsEditorGroup;
25 import com.intellij.openapi.project.Project;
26 import com.intellij.openapi.util.Comparing;
27 import com.intellij.openapi.util.DefaultJDOMExternalizer;
28 import com.intellij.openapi.util.InvalidDataException;
29 import com.intellij.openapi.util.WriteExternalException;
30 import com.intellij.openapi.util.io.FileUtil;
31 import com.intellij.openapi.util.text.StringUtil;
32 import com.intellij.psi.*;
33 import com.intellij.psi.util.ClassUtil;
34 import com.intellij.refactoring.listeners.RefactoringElementListener;
35 import com.intellij.rt.execution.junit.RepeatCount;
36 import com.intellij.util.ArrayUtil;
37 import org.jdom.Element;
38 import org.jetbrains.annotations.NonNls;
39 import org.jetbrains.annotations.NotNull;
40 import org.jetbrains.annotations.Nullable;
41
42 import java.util.*;
43
44 public class JUnitConfiguration extends JavaTestConfigurationBase {
45   public static final String DEFAULT_PACKAGE_NAME = ExecutionBundle.message("default.package.presentable.name");
46
47   @NonNls public static final String TEST_CLASS = "class";
48   @NonNls public static final String TEST_PACKAGE = "package";
49   @NonNls public static final String TEST_DIRECTORY = "directory";
50   @NonNls public static final String TEST_CATEGORY = "category";
51   @NonNls public static final String TEST_METHOD = "method";
52   @NonNls public static final String TEST_UNIQUE_ID = "uniqueId";
53   @NonNls public static final String BY_SOURCE_POSITION = "source location";
54   @NonNls public static final String BY_SOURCE_CHANGES = "changes";
55
56   //fork modes
57   @NonNls public static final String FORK_NONE = "none";
58   @NonNls public static final String FORK_METHOD = "method";
59   @NonNls public static final String FORK_KLASS = "class";
60   @NonNls public static final String FORK_REPEAT = "repeat";
61   // See #26522
62   @NonNls public static final String JUNIT_START_CLASS = "com.intellij.rt.execution.junit.JUnitStarter";
63   @NonNls private static final String PATTERN_EL_NAME = "pattern";
64   @NonNls public static final String TEST_PATTERN = PATTERN_EL_NAME;
65   @NonNls private static final String TEST_CLASS_ATT_NAME = "testClass";
66   @NonNls private static final String PATTERNS_EL_NAME = "patterns";
67   private final Data myData;
68   final RefactoringListeners.Accessor<PsiPackage> myPackage = new RefactoringListeners.Accessor<PsiPackage>() {
69     @Override
70     public void setName(final String qualifiedName) {
71       final boolean generatedName = isGeneratedName();
72       myData.PACKAGE_NAME = qualifiedName;
73       if (generatedName) setGeneratedName();
74     }
75
76     @Override
77     public PsiPackage getPsiElement() {
78       final String qualifiedName = myData.getPackageName();
79       return qualifiedName != null ? JavaPsiFacade.getInstance(getProject()).findPackage(qualifiedName)
80                                    : null;
81     }
82
83     @Override
84     public void setPsiElement(final PsiPackage psiPackage) {
85       setName(psiPackage.getQualifiedName());
86     }
87   };
88   final RefactoringListeners.Accessor<PsiClass> myClass = new RefactoringListeners.Accessor<PsiClass>() {
89     @Override
90     public void setName(@NotNull final String qualifiedName) {
91       final boolean generatedName = isGeneratedName();
92       myData.MAIN_CLASS_NAME = qualifiedName;
93       if (generatedName) setGeneratedName();
94     }
95
96     @Override
97     public PsiClass getPsiElement() {
98       return getConfigurationModule().findClass(myData.getMainClassName());
99     }
100
101     @Override
102     public void setPsiElement(final PsiClass psiClass) {
103       final Module originalModule = getConfigurationModule().getModule();
104       setMainClass(psiClass);
105       restoreOriginalModule(originalModule);
106     }
107   };
108   
109   final RefactoringListeners.Accessor<PsiClass> myCategory = new RefactoringListeners.Accessor<PsiClass>() {
110     @Override
111     public void setName(@NotNull final String qualifiedName) {
112       setCategory(qualifiedName);
113     }
114
115     @Override
116     public PsiClass getPsiElement() {
117       return getConfigurationModule().findClass(myData.getCategory());
118     }
119
120     @Override
121     public void setPsiElement(final PsiClass psiClass) {
122       setCategory(JavaExecutionUtil.getRuntimeQualifiedName(psiClass));
123     }
124   };
125   public boolean ALTERNATIVE_JRE_PATH_ENABLED;
126   public String ALTERNATIVE_JRE_PATH;
127
128   public JUnitConfiguration(final String name, final Project project, ConfigurationFactory configurationFactory) {
129     this(name, project, new Data(), configurationFactory);
130   }
131
132   protected JUnitConfiguration(final String name, final Project project, final Data data, ConfigurationFactory configurationFactory) {
133     super(name, new JavaRunConfigurationModule(project, false), configurationFactory);
134     myData = data;
135   }
136
137   @Override
138   public TestObject getState(@NotNull final Executor executor, @NotNull final ExecutionEnvironment env) throws ExecutionException {
139     return TestObject.fromString(myData.TEST_OBJECT, this, env);
140   }
141
142   @Override
143   @NotNull
144   public SettingsEditor<? extends RunConfiguration> getConfigurationEditor() {
145     SettingsEditorGroup<JUnitConfiguration> group = new SettingsEditorGroup<>();
146     group.addEditor(ExecutionBundle.message("run.configuration.configuration.tab.title"), new JUnitConfigurable(getProject()));
147     JavaRunConfigurationExtensionManager.getInstance().appendEditors(this, group);
148     group.addEditor(ExecutionBundle.message("logs.tab.title"), new LogConfigurationPanel<>());
149     return group;
150   }
151
152   public Data getPersistentData() {
153     return myData;
154   }
155
156   @Override
157   public RefactoringElementListener getRefactoringElementListener(final PsiElement element) {
158     final RefactoringElementListener listener = getTestObject().getListener(element, this);
159     return RunConfigurationExtension.wrapRefactoringElementListener(element, this, listener);
160   }
161
162   @Override
163   public void checkConfiguration() throws RuntimeConfigurationException {
164     getTestObject().checkConfiguration();
165     JavaRunConfigurationExtensionManager.checkConfigurationIsValid(this);
166   }
167
168   @Override
169   public Collection<Module> getValidModules() {
170     if (TEST_PACKAGE.equals(myData.TEST_OBJECT) || TEST_PATTERN.equals(myData.TEST_OBJECT)) {
171       return Arrays.asList(ModuleManager.getInstance(getProject()).getModules());
172     }
173     try {
174       getTestObject().checkConfiguration();
175     }
176     catch (RuntimeConfigurationError e) {
177       return Arrays.asList(ModuleManager.getInstance(getProject()).getModules());
178     }
179     catch (RuntimeConfigurationException e) {
180       //ignore
181     }
182
183     return JavaRunConfigurationModule.getModulesForClass(getProject(), myData.getMainClassName());
184   }
185
186   @Override
187   public String suggestedName() {
188     String repeat;
189     switch (getRepeatMode()) {
190       case RepeatCount.UNLIMITED :
191       case RepeatCount.UNTIL_FAILURE :
192         repeat = " [*]";
193         break;
194       case RepeatCount.N:
195         repeat = " [" + getRepeatCount() + "]";
196         break;
197       default:
198         repeat = "";
199     }
200     return myData.getGeneratedName(getConfigurationModule()) + repeat;
201   }
202
203   @Override
204   public String getActionName() {
205     return getTestObject().suggestActionName();
206   }
207
208   @Override
209   public String getVMParameters() {
210     return myData.getVMParameters();
211   }
212
213   @Override
214   public void setVMParameters(@Nullable String value) {
215     myData.setVMParameters(value);
216   }
217
218   @Override
219   public String getProgramParameters() {
220     return myData.getProgramParameters();
221   }
222
223   @Override
224   public void setProgramParameters(String value) {
225     myData.setProgramParameters(value);
226   }
227
228   @Override
229   public String getWorkingDirectory() {
230     return myData.getWorkingDirectory();
231   }
232
233   @Override
234   public void setWorkingDirectory(String value) {
235     myData.setWorkingDirectory(value);
236   }
237
238   @Override
239   @NotNull
240   public Map<String, String> getEnvs() {
241     return myData.getEnvs();
242   }
243
244   @Override
245   public void setEnvs(@NotNull Map<String, String> envs) {
246     myData.setEnvs(envs);
247   }
248
249   @Override
250   public boolean isPassParentEnvs() {
251     return myData.PASS_PARENT_ENVS;
252   }
253
254   @Override
255   public void setPassParentEnvs(boolean passParentEnvs) {
256     myData.PASS_PARENT_ENVS = passParentEnvs;
257   }
258
259   @Override
260   public boolean isAlternativeJrePathEnabled() {
261     return ALTERNATIVE_JRE_PATH_ENABLED;
262   }
263
264   @Override
265   public void setAlternativeJrePathEnabled(boolean enabled) {
266     ALTERNATIVE_JRE_PATH_ENABLED = enabled;
267   }
268
269   @Override
270   public String getAlternativeJrePath() {
271     return ALTERNATIVE_JRE_PATH;
272   }
273
274   @Override
275   public void setAlternativeJrePath(String path) {
276     ALTERNATIVE_JRE_PATH = path;
277   }
278
279   @Override
280   public String getRunClass() {
281     final Data data = getPersistentData();
282     return !Comparing.strEqual(data.TEST_OBJECT, TEST_CLASS) &&
283            !Comparing.strEqual(data.TEST_OBJECT, TEST_METHOD) ? null : data.getMainClassName();
284   }
285
286   @Override
287   public String getPackage() {
288     final Data data = getPersistentData();
289     return !Comparing.strEqual(data.TEST_OBJECT, TEST_PACKAGE) ? null : data.getPackageName();
290   }
291
292   public void beClassConfiguration(final PsiClass testClass) {
293     if (FORK_KLASS.equals(getForkMode())) {
294       setForkMode(FORK_NONE);
295     }
296     setMainClass(testClass);
297     myData.TEST_OBJECT = TEST_CLASS;
298     setGeneratedName();
299   }
300
301   @Override
302   public boolean isConfiguredByElement(PsiElement element) {
303     final PsiClass testClass = JUnitUtil.getTestClass(element);
304     final PsiMethod testMethod = JUnitUtil.getTestMethod(element, false);
305     final PsiPackage testPackage;
306     if (element instanceof PsiPackage) {
307       testPackage = (PsiPackage)element;
308     } else if (element instanceof PsiDirectory){
309       testPackage = JavaDirectoryService.getInstance().getPackage(((PsiDirectory)element));
310     } else {
311       testPackage = null;
312     }
313     PsiDirectory testDir = element instanceof PsiDirectory ? (PsiDirectory)element : null;
314
315     return getTestObject().isConfiguredByElement(this, testClass, testMethod, testPackage, testDir);
316   }
317
318   @Override
319   public TestSearchScope getTestSearchScope() {
320     return getPersistentData().getScope();
321   }
322
323   public void beFromSourcePosition(PsiLocation<PsiMethod> sourceLocation) {
324     myData.setTestMethod(sourceLocation);
325     myData.TEST_OBJECT = BY_SOURCE_POSITION;
326   }
327
328   public void setMainClass(final PsiClass testClass) {
329     final boolean shouldUpdateName = isGeneratedName();
330     setModule(myData.setMainClass(testClass));
331     if (shouldUpdateName) setGeneratedName();
332   }
333
334   public void setCategory(String categoryName) {
335     final boolean shouldUpdateName = isGeneratedName();
336     myData.setCategoryName(categoryName);
337     if (shouldUpdateName) setGeneratedName();
338   }
339
340   public void beMethodConfiguration(final Location<PsiMethod> methodLocation) {
341     setForkMode(FORK_NONE);
342     setModule(myData.setTestMethod(methodLocation));
343     setGeneratedName();
344   }
345
346   @Override
347   @NotNull
348   public Module[] getModules() {
349     if (TEST_PACKAGE.equals(myData.TEST_OBJECT) &&
350         getPersistentData().getScope() == TestSearchScope.WHOLE_PROJECT) {
351       return Module.EMPTY_ARRAY;
352     }
353     return super.getModules();
354   }
355
356   public TestObject getTestObject() {
357     return myData.getTestObject(this);
358   }
359
360   @Override
361   public void readExternal(@NotNull final Element element) throws InvalidDataException {
362     super.readExternal(element);
363     JavaRunConfigurationExtensionManager.getInstance().readExternal(this, element);
364     DefaultJDOMExternalizer.readExternal(this, element);
365     DefaultJDOMExternalizer.readExternal(getPersistentData(), element);
366     EnvironmentVariablesComponent.readExternal(element, getPersistentData().getEnvs());
367     final Element patternsElement = element.getChild(PATTERNS_EL_NAME);
368     if (patternsElement != null) {
369       final LinkedHashSet<String> tests = new LinkedHashSet<>();
370       for (Element patternElement : patternsElement.getChildren(PATTERN_EL_NAME)) {
371         tests.add(patternElement.getAttributeValue(TEST_CLASS_ATT_NAME));
372       }
373       myData.setPatterns(tests);
374     }
375     final Element forkModeElement = element.getChild("fork_mode");
376     if (forkModeElement != null) {
377       final String mode = forkModeElement.getAttributeValue("value");
378       if (mode != null) {
379         setForkMode(mode);
380       }
381     }
382     final String count = element.getAttributeValue("repeat_count");
383     if (count != null) {
384       try {
385         setRepeatCount(Integer.parseInt(count));
386       }
387       catch (NumberFormatException e) {
388         setRepeatCount(1);
389       }
390     }
391     final String repeatMode = element.getAttributeValue("repeat_mode");
392     if (repeatMode != null) {
393       setRepeatMode(repeatMode);
394     }
395     final Element dirNameElement = element.getChild("dir");
396     if (dirNameElement != null) {
397       final String dirName = dirNameElement.getAttributeValue("value");
398       getPersistentData().setDirName(FileUtil.toSystemDependentName(dirName));
399     }
400
401     final Element categoryNameElement = element.getChild("category");
402     if (categoryNameElement != null) {
403       final String categoryName = categoryNameElement.getAttributeValue("value");
404       getPersistentData().setCategoryName(categoryName);
405     }
406
407     Element idsElement = element.getChild("uniqueIds");
408     if (idsElement != null) {
409       List<String> ids = new ArrayList<>();
410       idsElement.getChildren("uniqueId").forEach(uniqueIdElement -> ids.add(uniqueIdElement.getAttributeValue("value")));
411       getPersistentData().setUniqueIds(ArrayUtil.toStringArray(ids));
412     }
413   }
414
415   @Override
416   public void writeExternal(@NotNull final Element element) throws WriteExternalException {
417     super.writeExternal(element);
418     JavaRunConfigurationExtensionManager.getInstance().writeExternal(this, element);
419     DefaultJDOMExternalizer.writeExternal(this, element);
420     final Data persistentData = getPersistentData();
421     DefaultJDOMExternalizer.writeExternal(persistentData, element);
422
423     if (!persistentData.getEnvs().isEmpty()) {
424       EnvironmentVariablesComponent.writeExternal(element, persistentData.getEnvs());
425     }
426
427     final String dirName = persistentData.getDirName();
428     if (!dirName.isEmpty()) {
429       final Element dirNameElement = new Element("dir");
430       dirNameElement.setAttribute("value", FileUtil.toSystemIndependentName(dirName));
431       element.addContent(dirNameElement);
432     }
433
434     final String categoryName = persistentData.getCategory();
435     if (!categoryName.isEmpty()) {
436       final Element categoryNameElement = new Element("category");
437       categoryNameElement.setAttribute("value", categoryName);
438       element.addContent(categoryNameElement);
439     }
440
441     final Element patternsElement = new Element(PATTERNS_EL_NAME);
442     for (String o : persistentData.getPatterns()) {
443       final Element patternElement = new Element(PATTERN_EL_NAME);
444       patternElement.setAttribute(TEST_CLASS_ATT_NAME, o);
445       patternsElement.addContent(patternElement);
446     }
447     element.addContent(patternsElement);
448     final String forkMode = getForkMode();
449     if (!forkMode.equals("none")) {
450       final Element forkModeElement = new Element("fork_mode");
451       forkModeElement.setAttribute("value", forkMode);
452       element.addContent(forkModeElement);
453     }
454     if (getRepeatCount() != 1) {
455       element.setAttribute("repeat_count", String.valueOf(getRepeatCount()));
456     }
457     final String repeatMode = getRepeatMode();
458     if (!RepeatCount.ONCE.equals(repeatMode)) {
459       element.setAttribute("repeat_mode", repeatMode);
460     }
461     String[] ids = persistentData.getUniqueIds();
462     if (ids != null) {
463       Element uniqueIds = new Element("uniqueIds");
464       Arrays.stream(ids).forEach(id -> uniqueIds.addContent(new Element("uniqueId").setAttribute("value", id)));
465       element.addContent(uniqueIds);
466     }
467   }
468
469   public String getForkMode() {
470     return myData.FORK_MODE;
471   }
472
473   public void setForkMode(@NotNull String forkMode) {
474     myData.FORK_MODE = forkMode;
475   }
476
477   @Override
478   public boolean collectOutputFromProcessHandler() {
479     return false;
480   }
481
482   public void bePatternConfiguration(List<PsiClass> classes, PsiMethod method) {
483     myData.TEST_OBJECT = TEST_PATTERN;
484     final LinkedHashSet<String> patterns = new LinkedHashSet<>();
485     final String methodSufiix;
486     if (method != null) {
487       myData.METHOD_NAME = Data.getMethodPresentation(method);
488       methodSufiix = "," + myData.METHOD_NAME;
489     } else {
490       methodSufiix = "";
491     }
492     for (PsiClass pattern : classes) {
493       patterns.add(JavaExecutionUtil.getRuntimeQualifiedName(pattern) + methodSufiix);
494     }
495     myData.setPatterns(patterns);
496     final Module module = RunConfigurationProducer.getInstance(PatternConfigurationProducer.class).findModule(this, getConfigurationModule()
497       .getModule(), patterns);
498     if (module == null) {
499       myData.setScope(TestSearchScope.WHOLE_PROJECT);
500       setModule(null);
501     } else {
502       setModule(module);
503     }
504     setGeneratedName();
505   }
506
507   public int getRepeatCount() {
508     return myData.REPEAT_COUNT;
509   }
510
511   public void setRepeatCount(int repeatCount) {
512     myData.REPEAT_COUNT = repeatCount;
513   }
514
515   public String getRepeatMode() {
516     return myData.REPEAT_MODE;
517   }
518
519   public void setRepeatMode(String repeatMode) {
520     myData.REPEAT_MODE = repeatMode;
521   }
522
523   @Override
524   public SMTRunnerConsoleProperties createTestConsoleProperties(Executor executor) {
525     return new JUnitConsoleProperties(this, executor);
526   }
527
528   @NotNull
529   @Override
530   public String getFrameworkPrefix() {
531     return "j";
532   }
533
534   public static class Data implements Cloneable {
535     public String PACKAGE_NAME;
536     public String MAIN_CLASS_NAME;
537     public String METHOD_NAME;
538     private String[] UNIQUE_ID;
539     public String TEST_OBJECT = TEST_CLASS;
540     public String VM_PARAMETERS;
541     public String PARAMETERS;
542     public String WORKING_DIRECTORY;
543     public boolean PASS_PARENT_ENVS = true;
544     public TestSearchScope.Wrapper TEST_SEARCH_SCOPE = new TestSearchScope.Wrapper();
545     private String DIR_NAME;
546     private String CATEGORY_NAME;
547     private String FORK_MODE = FORK_NONE;
548     private int REPEAT_COUNT = 1;
549     private String REPEAT_MODE = RepeatCount.ONCE;
550     private LinkedHashSet<String> myPattern = new LinkedHashSet<>();
551     private Map<String, String> myEnvs = new LinkedHashMap<>();
552     private String myChangeList = "All";
553
554     public boolean equals(final Object object) {
555       if (!(object instanceof Data)) return false;
556       final Data second = (Data)object;
557       return Comparing.equal(TEST_OBJECT, second.TEST_OBJECT) &&
558              Comparing.equal(getMainClassName(), second.getMainClassName()) &&
559              Comparing.equal(getPackageName(), second.getPackageName()) &&
560              Comparing.equal(getMethodNameWithSignature(), second.getMethodNameWithSignature()) &&
561              Comparing.equal(getWorkingDirectory(), second.getWorkingDirectory()) &&
562              Comparing.equal(VM_PARAMETERS, second.VM_PARAMETERS) &&
563              Comparing.equal(PARAMETERS, second.PARAMETERS) &&
564              Comparing.equal(myPattern, second.myPattern) &&
565              Comparing.equal(FORK_MODE, second.FORK_MODE) &&
566              Comparing.equal(DIR_NAME, second.DIR_NAME) &&
567              Comparing.equal(CATEGORY_NAME, second.CATEGORY_NAME) &&
568              Comparing.equal(UNIQUE_ID, second.UNIQUE_ID) &&
569              Comparing.equal(REPEAT_MODE, second.REPEAT_MODE) &&
570              REPEAT_COUNT == second.REPEAT_COUNT;
571     }
572
573     public int hashCode() {
574       return Comparing.hashcode(TEST_OBJECT) ^
575              Comparing.hashcode(getMainClassName()) ^
576              Comparing.hashcode(getPackageName()) ^
577              Comparing.hashcode(getMethodNameWithSignature()) ^
578              Comparing.hashcode(getWorkingDirectory()) ^
579              Comparing.hashcode(VM_PARAMETERS) ^
580              Comparing.hashcode(PARAMETERS) ^
581              Comparing.hashcode(myPattern) ^
582              Comparing.hashcode(FORK_MODE) ^
583              Comparing.hashcode(DIR_NAME) ^
584              Comparing.hashcode(CATEGORY_NAME) ^
585              Comparing.hashcode(UNIQUE_ID) ^
586              Comparing.hashcode(REPEAT_MODE) ^
587              Comparing.hashcode(REPEAT_COUNT);
588     }
589
590     public TestSearchScope getScope() {
591       return TEST_SEARCH_SCOPE.getScope();
592     }
593
594     public void setScope(final TestSearchScope scope) {
595       TEST_SEARCH_SCOPE.setScope(scope);
596     }
597
598     @Override
599     public Data clone() {
600       try {
601         Data data = (Data)super.clone();
602         data.TEST_SEARCH_SCOPE = new TestSearchScope.Wrapper();
603         data.setScope(getScope());
604         data.myEnvs = new LinkedHashMap<>(myEnvs);
605         return data;
606       }
607       catch (CloneNotSupportedException e) {
608         throw new RuntimeException(e);
609       }
610     }
611
612     public String getVMParameters() {
613       return VM_PARAMETERS;
614     }
615
616     public void setVMParameters(String value) {
617       VM_PARAMETERS = value;
618     }
619
620     public String getProgramParameters() {
621       return PARAMETERS;
622     }
623
624     public void setProgramParameters(String value) {
625       PARAMETERS = value;
626     }
627
628     public String getWorkingDirectory() {
629       return ExternalizablePath.localPathValue(WORKING_DIRECTORY);
630     }
631
632     public void setWorkingDirectory(String value) {
633       WORKING_DIRECTORY = ExternalizablePath.urlValue(value);
634     }
635
636     public void setUniqueIds(String... uniqueId) {
637       UNIQUE_ID = uniqueId;
638     }
639
640     public String[] getUniqueIds() {
641       return UNIQUE_ID;
642     }
643
644     public Module setTestMethod(final Location<PsiMethod> methodLocation) {
645       final PsiMethod method = methodLocation.getPsiElement();
646       METHOD_NAME = getMethodPresentation(method);
647       TEST_OBJECT = TEST_METHOD;
648       return setMainClass(methodLocation instanceof MethodLocation ? ((MethodLocation)methodLocation).getContainingClass() : method.getContainingClass());
649     }
650
651     public static String getMethodPresentation(PsiMethod method) {
652       if (method.getParameterList().getParametersCount() > 0 && MetaAnnotationUtil.isMetaAnnotated(method, JUnitUtil.TEST5_ANNOTATIONS)) {
653         return method.getName() + "(" + ClassUtil.getVMParametersMethodSignature(method) + ")";
654       }
655       else {
656         return method.getName();
657       }
658     }
659
660     public String getGeneratedName(final JavaRunConfigurationModule configurationModule) {
661       if (TEST_PACKAGE.equals(TEST_OBJECT) || TEST_DIRECTORY.equals(TEST_OBJECT)) {
662         if (TEST_SEARCH_SCOPE.getScope() == TestSearchScope.WHOLE_PROJECT) {
663           return ExecutionBundle.message("default.junit.config.name.whole.project");
664         }
665         final String moduleName = TEST_SEARCH_SCOPE.getScope() == TestSearchScope.WHOLE_PROJECT ? "" : configurationModule.getModuleName();
666         final String packageName = TEST_PACKAGE.equals(TEST_OBJECT) ? getPackageName() : StringUtil.getShortName(getDirName(), '/');
667         if (packageName.length() == 0) {
668           if (moduleName.length() > 0) {
669             return ExecutionBundle.message("default.junit.config.name.all.in.module", moduleName);
670           }
671           return DEFAULT_PACKAGE_NAME;
672         }
673         if (moduleName.length() > 0) {
674           return ExecutionBundle.message("default.junit.config.name.all.in.package.in.module", packageName, moduleName);
675         }
676         return packageName;
677       }
678       if (TEST_PATTERN.equals(TEST_OBJECT)) {
679         final int size = myPattern.size();
680         if (size == 0) return "Temp suite";
681         String fqName = myPattern.iterator().next();
682         String firstName =
683           fqName.contains("*") ? fqName
684                                : StringUtil.getShortName(fqName.contains("(") ? StringUtil.getPackageName(fqName, '(') : fqName);
685         return firstName + (size > 1 ? " and " + (size - 1) + " more" : "");
686       }
687       if (TEST_CATEGORY.equals(TEST_OBJECT)) {
688         return "@Category(" + (StringUtil.isEmpty(CATEGORY_NAME) ? "Invalid" : CATEGORY_NAME) + ")";
689       }
690       if (TEST_UNIQUE_ID.equals(TEST_OBJECT)) {
691         return UNIQUE_ID != null ? StringUtil.join(UNIQUE_ID, " ") : "Temp suite";
692       }
693       final String className = JavaExecutionUtil.getPresentableClassName(getMainClassName());
694       if (TEST_METHOD.equals(TEST_OBJECT)) {
695         return className + '.' + getMethodName();
696       }
697
698       return className;
699     }
700
701     public String getMainClassName() {
702       return MAIN_CLASS_NAME != null ? MAIN_CLASS_NAME : "";
703     }
704
705     public String getPackageName() {
706       return PACKAGE_NAME != null ? PACKAGE_NAME : "";
707     }
708
709     public String getMethodName() {
710       String signature = getMethodNameWithSignature();
711       int paramsIdx = signature.lastIndexOf("(");
712       return paramsIdx > -1 ? signature.substring(0, paramsIdx) : signature;
713     }
714
715     public String getMethodNameWithSignature() {
716       return METHOD_NAME != null ? METHOD_NAME : "";
717     }
718
719     public String getDirName() {
720       return DIR_NAME != null ? DIR_NAME : "";
721     }
722
723     public void setDirName(String dirName) {
724       DIR_NAME = dirName;
725     }
726
727     public Set<String> getPatterns() {
728       return myPattern;
729     }
730
731     public void setPatterns(LinkedHashSet<String> pattern) {
732       myPattern = pattern;
733     }
734
735     public String getPatternPresentation() {
736       final List<String> enabledTests = new ArrayList<>();
737       for (String pattern : myPattern) {
738         enabledTests.add(pattern);
739       }
740       return StringUtil.join(enabledTests, "||");
741     }
742
743     public TestObject getTestObject(@NotNull JUnitConfiguration configuration) {
744       final ExecutionEnvironment environment = ExecutionEnvironmentBuilder.create(DefaultRunExecutor.getRunExecutorInstance(), configuration).build();
745       final TestObject testObject = TestObject.fromString(TEST_OBJECT, configuration, environment);
746       return testObject == null ? new UnknownTestTarget(configuration, environment) : testObject;
747     }
748
749     public Module setMainClass(final PsiClass testClass) {
750       MAIN_CLASS_NAME = JavaExecutionUtil.getRuntimeQualifiedName(testClass);
751       PsiPackage containingPackage = JUnitUtil.getContainingPackage(testClass);
752       PACKAGE_NAME = containingPackage != null ? containingPackage.getQualifiedName() : "";
753       return JavaExecutionUtil.findModule(testClass);
754     }
755
756     public Map<String, String> getEnvs() {
757       return myEnvs;
758     }
759
760     public void setEnvs(final Map<String, String> envs) {
761       myEnvs = envs;
762     }
763
764     public String getCategory() {
765       return CATEGORY_NAME != null ? CATEGORY_NAME : "";
766     }
767
768     public void setCategoryName(String categoryName) {
769       CATEGORY_NAME = categoryName;
770     }
771
772     public String getChangeList() {
773       return myChangeList;
774     }
775
776     public void setChangeList(String changeList) {
777       myChangeList = changeList;
778     }
779   }
780
781 }