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