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 }