private void updateText() { StringBuilder sb = new StringBuilder(); if (myShowSettingsBeforeRunCheckBox.isSelected()) { sb.append(ExecutionBundle.message("configuration.edit.before.run")).append(", "); } List<BeforeRunTask> tasks = myModel.getItems(); if (!tasks.isEmpty()) { LinkedHashMap<BeforeRunTaskProvider, Integer> counter = new LinkedHashMap<BeforeRunTaskProvider, Integer>(); for (BeforeRunTask task : tasks) { BeforeRunTaskProvider<BeforeRunTask> provider = BeforeRunTaskProvider.getProvider( myRunConfiguration.getProject(), task.getProviderId()); if (provider != null) { Integer count = counter.get(provider); if (count == null) { count = task.getItemsCount(); } else { count += task.getItemsCount(); } counter.put(provider, count); } } for (Iterator<Map.Entry<BeforeRunTaskProvider, Integer>> iterator = counter.entrySet().iterator(); iterator.hasNext(); ) { Map.Entry<BeforeRunTaskProvider, Integer> entry = iterator.next(); BeforeRunTaskProvider provider = entry.getKey(); String name = provider.getName(); if (name.startsWith("Run ")) { name = name.substring(4); } sb.append(name); if (entry.getValue() > 1) { sb.append(" (").append(entry.getValue().intValue()).append(")"); } if (iterator.hasNext()) sb.append(", "); } } if (sb.length() > 0) { sb.insert(0, ": "); } sb.insert(0, ExecutionBundle.message("before.launch.panel.title")); myListener.titleChanged(sb.toString()); }
public String getGeneratedName(final JavaRunConfigurationModule configurationModule) { if (TEST_PACKAGE.equals(TEST_OBJECT) || TEST_DIRECTORY.equals(TEST_OBJECT)) { final String moduleName = TEST_SEARCH_SCOPE.getScope() == TestSearchScope.WHOLE_PROJECT ? "" : configurationModule.getModuleName(); final String packageName = getPackageName(); if (packageName.length() == 0) { if (moduleName.length() > 0) { return ExecutionBundle.message("default.junit.config.name.all.in.module", moduleName); } return DEFAULT_PACKAGE_NAME; } if (moduleName.length() > 0) { return ExecutionBundle.message( "default.junit.config.name.all.in.package.in.module", packageName, moduleName); } return packageName; } if (TEST_PATTERN.equals(TEST_OBJECT)) { final int size = myPattern.size(); if (size == 0) return "Temp suite"; return StringUtil.getShortName(myPattern.iterator().next()) + (size > 1 ? " and " + (size - 1) + " more" : ""); } final String className = JavaExecutionUtil.getPresentableClassName(getMainClassName(), configurationModule); if (TEST_METHOD.equals(TEST_OBJECT)) { return className + '.' + getMethodName(); } return className; }
@Override public String getDescription(RunConfigurableBeforeRunTask task) { if (task.getSettings() == null) { return ExecutionBundle.message("before.launch.run.another.configuration"); } else { return ExecutionBundle.message( "before.launch.run.certain.configuration", task.getSettings().getName()); } }
public SettingsEditor<? extends RunConfiguration> getConfigurationEditor() { SettingsEditorGroup<JUnitConfiguration> group = new SettingsEditorGroup<JUnitConfiguration>(); group.addEditor( ExecutionBundle.message("run.configuration.configuration.tab.title"), new JUnitConfigurable(getProject())); JavaRunConfigurationExtensionManager.getInstance().appendEditors(this, group); group.addEditor( ExecutionBundle.message("logs.tab.title"), new LogConfigurationPanel<JUnitConfiguration>()); return group; }
public String suggestActionName() { final String configurationName = myConfiguration.getName(); if (!myConfiguration.isGeneratedName()) { return "'" + configurationName + "'"; } final JUnitConfiguration.Data data = myConfiguration.getPersistentData(); if (data.getPackageName().trim().length() > 0) { return ExecutionBundle.message("test.in.scope.presentable.text", data.getPackageName()); } return ExecutionBundle.message("all.tests.scope.presentable.text"); }
private String generateName(final String actionText) { switch (myType) { case CREATE: return ExecutionBundle.message( "create.run.configuration.for.item.action.name", actionText); case SELECT: return ExecutionBundle.message( "select.run.configuration.for.item.action.name", actionText); default: return ExecutionBundle.message("save.run.configuration.for.item.action.name", actionText); } }
public static void addLabel(final TestFrameworkRunningModel model) { String label; int color; if (model.getRoot().isDefect()) { color = RED.getRGB(); label = ExecutionBundle.message("junit.runing.info.tests.failed.label"); } else { color = GREEN.getRGB(); label = ExecutionBundle.message("junit.runing.info.tests.passed.label"); } final TestConsoleProperties consoleProperties = model.getProperties(); String name = label + " " + consoleProperties.getConfiguration().getName(); LocalHistory.getInstance().putSystemLabel(consoleProperties.getProject(), name, color); }
public void restart() { final Project project = PlatformDataKeys.PROJECT.getData( DataManager.getInstance().getDataContext(myDescriptor.getComponent())); if (ExecutorRegistry.getInstance() .isStarting(project, myExecutor.getId(), myRunner.getRunnerId())) { return; } try { final ExecutionEnvironment old = myEnvironment; myRunner.execute( myExecutor, new ExecutionEnvironment( old.getRunProfile(), old.getExecutionTarget(), project, old.getRunnerSettings(), old.getConfigurationSettings(), myDescriptor, old.getRunnerAndConfigurationSettings())); } catch (RunCanceledByUserException ignore) { } catch (ExecutionException e1) { Messages.showErrorDialog( project, e1.getMessage(), ExecutionBundle.message("restart.error.message.title")); } }
void doAddAction(AnActionButton button) { if (isUnknown()) { return; } final JBPopupFactory popupFactory = JBPopupFactory.getInstance(); final BeforeRunTaskProvider<BeforeRunTask>[] providers = Extensions.getExtensions( BeforeRunTaskProvider.EXTENSION_POINT_NAME, myRunConfiguration.getProject()); Set<Key> activeProviderKeys = getActiveProviderKeys(); DefaultActionGroup actionGroup = new DefaultActionGroup(null, false); for (final BeforeRunTaskProvider<BeforeRunTask> provider : providers) { if (provider.createTask(myRunConfiguration) == null) continue; if (activeProviderKeys.contains(provider.getId()) && provider.isSingleton()) continue; AnAction providerAction = new AnAction(provider.getName(), null, provider.getIcon()) { @Override public void actionPerformed(AnActionEvent e) { BeforeRunTask task = provider.createTask(myRunConfiguration); if (task != null) { provider.configureTask(myRunConfiguration, task); if (!provider.canExecuteTask(myRunConfiguration, task)) return; } else { return; } task.setEnabled(true); Set<RunConfiguration> configurationSet = new HashSet<RunConfiguration>(); getAllRunBeforeRuns(task, configurationSet); if (configurationSet.contains(myRunConfiguration)) { JOptionPane.showMessageDialog( BeforeRunStepsPanel.this, ExecutionBundle.message( "before.launch.panel.cyclic_dependency_warning", myRunConfiguration.getName(), provider.getDescription(task)), ExecutionBundle.message("warning.common.title"), JOptionPane.WARNING_MESSAGE); return; } addTask(task); myListener.fireStepsBeforeRunChanged(); } }; actionGroup.add(providerAction); } final ListPopup popup = popupFactory.createActionGroupPopup( ExecutionBundle.message("add.new.run.configuration.acrtion.name"), actionGroup, SimpleDataContext.getProjectContext(myRunConfiguration.getProject()), false, false, false, null, -1, Condition.TRUE); popup.show(button.getPreferredPopupPoint()); }
public static void handleExecutionError( @NotNull final Project project, @NotNull final String toolWindowId, @NotNull String taskName, @NotNull ExecutionException e) { if (e instanceof RunCanceledByUserException) return; LOG.debug(e); String description = e.getMessage(); HyperlinkListener listener = null; if ((description.contains("87") || description.contains("111") || description.contains("206")) && e instanceof ProcessNotCreatedException && !PropertiesComponent.getInstance(project).isTrueValue("dynamic.classpath")) { final String commandLineString = ((ProcessNotCreatedException) e).getCommandLine().getCommandLineString(); if (commandLineString.length() > 1024 * 32) { description = "Command line is too long. In order to reduce its length classpath file can be used.<br>" + "Would you like to enable classpath file mode for all run configurations of your project?<br>" + "<a href=\"\">Enable</a>"; listener = new HyperlinkListener() { @Override public void hyperlinkUpdate(HyperlinkEvent event) { PropertiesComponent.getInstance(project).setValue("dynamic.classpath", "true"); } }; } } final String title = ExecutionBundle.message("error.running.configuration.message", taskName); final String fullMessage = title + ":<br>" + description; if (ApplicationManager.getApplication().isUnitTestMode()) { LOG.error(fullMessage); } if (listener == null && e instanceof HyperlinkListener) { listener = (HyperlinkListener) e; } final HyperlinkListener finalListener = listener; final String finalDescription = description; UIUtil.invokeLaterIfNeeded( new Runnable() { @Override public void run() { ToolWindowManager.getInstance(project) .notifyByBalloon(toolWindowId, MessageType.ERROR, fullMessage, null, finalListener); NotificationListener notificationListener = ObjectUtils.tryCast(finalListener, NotificationListener.class); ourNotificationGroup .createNotification( title, finalDescription, NotificationType.ERROR, notificationListener) .notify(project); } }); }
private ValidationResult getValidationResult() { if (!myValidationResultValid) { myLastValidationResult = null; try { RunnerAndConfigurationSettings snapshot = getSnapshot(); if (snapshot != null) { snapshot.setName(getNameText()); snapshot.checkSettings(); for (ProgramRunner runner : RunnerRegistry.getInstance().getRegisteredRunners()) { for (Executor executor : ExecutorRegistry.getInstance().getRegisteredExecutors()) { if (runner.canRun(executor.getId(), snapshot.getConfiguration())) { checkConfiguration(runner, snapshot); break; } } } } } catch (RuntimeConfigurationException exception) { myLastValidationResult = exception != null ? new ValidationResult( exception.getLocalizedMessage(), exception.getTitle(), exception.getQuickFix()) : null; } catch (ConfigurationException e) { myLastValidationResult = new ValidationResult( e.getLocalizedMessage(), ExecutionBundle.message("invalid.data.dialog.title"), null); } myValidationResultValid = true; } return myLastValidationResult; }
private SelectionDialog( RunnerAndConfigurationSettings selectedSettings, @NotNull List<RunnerAndConfigurationSettings> settings) { super(myProject); setTitle(ExecutionBundle.message("before.launch.run.another.configuration.choose")); mySelectedSettings = selectedSettings; mySettings = settings; init(); myJBList.setSelectedValue(mySelectedSettings, true); myJBList.addMouseListener( new MouseAdapter() { @Override public void mouseClicked(MouseEvent e) { if (SwingUtilities.isLeftMouseButton(e) && e.getClickCount() == 2) { doOKAction(); } } }); FontMetrics fontMetrics = myJBList.getFontMetrics(myJBList.getFont()); int maxWidth = fontMetrics.stringWidth("m") * 30; for (RunnerAndConfigurationSettings setting : settings) { maxWidth = Math.max(fontMetrics.stringWidth(setting.getConfiguration().getName()), maxWidth); } maxWidth += 24; // icon and gap myJBList.setMinimumSize(new Dimension(maxWidth, myJBList.getPreferredSize().height)); }
private void waitForProcess(final RunContentDescriptor descriptor) { ProgressManager.getInstance() .runProcessWithProgressSynchronously( new Runnable() { public void run() { final Semaphore semaphore = new Semaphore(); semaphore.down(); ApplicationManager.getApplication() .executeOnPooledThread( new Runnable() { public void run() { final ProcessHandler processHandler = descriptor.getProcessHandler(); try { if (processHandler != null) { processHandler.waitFor(); } } finally { semaphore.up(); } } }); final ProgressIndicator progressIndicator = ProgressManager.getInstance().getProgressIndicator(); if (progressIndicator != null) { progressIndicator.setText( ExecutionBundle.message("waiting.for.vm.detach.progress.text")); ApplicationManager.getApplication() .executeOnPooledThread( new Runnable() { public void run() { while (true) { if (progressIndicator.isCanceled() || !progressIndicator.isRunning()) { semaphore.up(); break; } try { synchronized (this) { wait(2000L); } } catch (InterruptedException ignore) { } } } }); } semaphore.waitFor(); } }, ExecutionBundle.message( "terminating.process.progress.title", descriptor.getDisplayName()), true, myProject); }
private static boolean userApprovesStopForSameTypeConfigurations( Project project, String configName, int instancesCount) { RunManagerImpl runManager = RunManagerImpl.getInstanceImpl(project); final RunManagerConfig config = runManager.getConfig(); if (!config.isRestartRequiresConfirmation()) return true; DialogWrapper.DoNotAskOption option = new DialogWrapper.DoNotAskOption() { @Override public boolean isToBeShown() { return config.isRestartRequiresConfirmation(); } @Override public void setToBeShown(boolean value, int exitCode) { config.setRestartRequiresConfirmation(value); } @Override public boolean canBeHidden() { return true; } @Override public boolean shouldSaveOptionsOnCancel() { return false; } @NotNull @Override public String getDoNotShowMessage() { return CommonBundle.message("dialog.options.do.not.show"); } }; return Messages.showOkCancelDialog( project, ExecutionBundle.message( "rerun.singleton.confirmation.message", configName, instancesCount), ExecutionBundle.message("process.is.running.dialog.title", configName), ExecutionBundle.message("rerun.confirmation.button.text"), CommonBundle.message("button.cancel"), Messages.getQuestionIcon(), option) == Messages.OK; }
public void testJdk() { try { CommandLineBuilder.createFromJavaParameters(new JavaParameters()); fail("CantRunException (main class is not specified) expected"); } catch (CantRunException e) { Assert.assertEquals( ExecutionBundle.message("run.configuration.error.no.jdk.specified"), e.getMessage()); } }
public void testMainClass() { try { JavaParameters javaParameters = new JavaParameters(); javaParameters.setJdk(getProjectJDK()); CommandLineBuilder.createFromJavaParameters(javaParameters); fail("CantRunException (main class is not specified) expected"); } catch (CantRunException e) { assertEquals( ExecutionBundle.message("main.class.is.not.specified.error.message"), e.getMessage()); } }
@Override public void update(final AnActionEvent event) { final Presentation presentation = event.getPresentation(); String name = myEnvironment.getRunProfile().getName(); ProcessHandler processHandler = myDescriptor.getProcessHandler(); final boolean isRunning = processHandler != null && !processHandler.isProcessTerminated(); presentation.setText(ExecutionBundle.message("rerun.configuration.action.name", name)); presentation.setIcon(isRunning ? AllIcons.Actions.Restart : myExecutor.getIcon()); presentation.setEnabled(isEnabled()); }
public MySearchForTestsTask( TestClassFilter classFilter, boolean[] junit4, THashSet<PsiClass> classes, FindCallback callback) { super( classFilter.getProject(), ExecutionBundle.message("seaching.test.progress.title"), true); myClassFilter = classFilter; myJunit4 = junit4; myClasses = classes; myCallback = callback; }
public void checkConfiguration() throws RuntimeConfigurationException { super.checkConfiguration(); final String packageName = myConfiguration.getPersistentData().getPackageName(); final PsiPackage aPackage = JavaPsiFacade.getInstance(myConfiguration.getProject()).findPackage(packageName); if (aPackage == null) { throw new RuntimeConfigurationWarning( ExecutionBundle.message("package.does.not.exist.error.message", packageName)); } if (getSourceScope() == null) { myConfiguration.getConfigurationModule().checkForWarning(); } }
public void perform(final ConfigurationContext context) { final RunnerAndConfigurationSettingsImpl configuration = context.getConfiguration(); if (RunDialog.editConfiguration( context.getProject(), configuration, ExecutionBundle.message( "create.run.configuration.for.item.dialog.title", configuration.getName()))) { final RunManagerImpl runManager = (RunManagerImpl) context.getRunManager(); runManager.addConfiguration( configuration, runManager.isConfigurationShared(configuration), runManager.getBeforeRunTasks(configuration.getConfiguration())); runManager.setActiveConfiguration(configuration); } }
@Override public void checkConfiguration() throws RuntimeConfigurationException { JavaParametersUtil.checkAlternativeJRE(this); final String className = MAIN_CLASS_NAME; if (className == null || className.length() == 0) { throw new RuntimeConfigurationError( ExecutionBundle.message("no.main.class.specified.error.text")); } if (SCRATCH_FILE_ID <= 0) { throw new RuntimeConfigurationError("No scratch file associated with configuration"); } if (getScratchVirtualFile() == null) { throw new RuntimeConfigurationError("Associated scratch file not found"); } ProgramParametersUtil.checkWorkingDirectoryExist( this, getProject(), getConfigurationModule().getModule()); JavaRunConfigurationExtensionManager.checkConfigurationIsValid(this); }
private void appendForkInfo(Executor executor) throws ExecutionException { final String forkMode = myConfiguration.getForkMode(); if (Comparing.strEqual(forkMode, "none")) { return; } if (getRunnerSettings().getData() != null) { final String actionName = executor.getActionName(); throw new CantRunException( actionName + " is disabled in fork mode.<br/>Please change fork mode to <none> to " + actionName.toLowerCase() + "."); } final JavaParameters javaParameters = getJavaParameters(); final Sdk jdk = javaParameters.getJdk(); if (jdk == null) { throw new ExecutionException( ExecutionBundle.message("run.configuration.error.no.jdk.specified")); } try { final File tempFile = FileUtil.createTempFile("command.line", "", true); final PrintWriter writer = new PrintWriter(tempFile, "UTF-8"); try { writer.println(((JavaSdkType) jdk.getSdkType()).getVMExecutablePath(jdk)); for (String vmParameter : javaParameters.getVMParametersList().getList()) { writer.println(vmParameter); } writer.println("-classpath"); writer.println(javaParameters.getClassPath().getPathsString()); } finally { writer.close(); } myJavaParameters .getProgramParametersList() .add("@@@" + forkMode + ',' + tempFile.getAbsolutePath()); } catch (Exception e) { LOG.error(e); } }
@Override public void update(final AnActionEvent e) { final Presentation presentation = e.getPresentation(); final Project project = e.getData(CommonDataKeys.PROJECT); if (project == null) { disable(presentation); return; } RunnerAndConfigurationSettings settings = chooseTempSettings(project); if (settings == null) { disable(presentation); } else { presentation.setText( ExecutionBundle.message( "save.temporary.run.configuration.action.name", settings.getName())); presentation.setDescription(presentation.getText()); presentation.setVisible(true); presentation.setEnabled(true); } }
@Override public void update(AnActionEvent e) { Presentation presentation = e.getPresentation(); Project project = e.getData(CommonDataKeys.PROJECT); if (ActionPlaces.isMainMenuOrActionSearch(e.getPlace())) { presentation.setDescription( ExecutionBundle.message("choose.run.configuration.action.description")); } try { if (project == null || project.isDisposed() || !project.isInitialized()) { updatePresentation(null, null, null, presentation); presentation.setEnabled(false); } else { updatePresentation( ExecutionTargetManager.getActiveTarget(project), RunManagerEx.getInstanceEx(project).getSelectedConfiguration(), project, presentation); presentation.setEnabled(true); } } catch (IndexNotReadyException e1) { presentation.setEnabled(false); } }
public class TestNGConfiguration extends JavaTestConfigurationBase { @NonNls private static final String PATTERNS_EL_NAME = "patterns"; @NonNls private static final String PATTERN_EL_NAME = "pattern"; @NonNls private static final String TEST_CLASS_ATT_NAME = "testClass"; // private TestNGResultsContainer resultsContainer; protected TestData data; protected transient Project project; public boolean ALTERNATIVE_JRE_PATH_ENABLED; public String ALTERNATIVE_JRE_PATH; public static final String DEFAULT_PACKAGE_NAME = ExecutionBundle.message("default.package.presentable.name"); public static final String DEFAULT_PACKAGE_CONFIGURATION_NAME = ExecutionBundle.message("default.package.configuration.name"); private final RefactoringListeners.Accessor<PsiPackage> myPackage = new RefactoringListeners.Accessor<PsiPackage>() { public void setName(final String qualifiedName) { final boolean generatedName = isGeneratedName(); data.PACKAGE_NAME = qualifiedName; if (generatedName) setGeneratedName(); } @Nullable public PsiPackage getPsiElement() { final String qualifiedName = data.getPackageName(); return qualifiedName != null ? JavaPsiFacade.getInstance(getProject()).findPackage(qualifiedName) : null; } public void setPsiElement(final PsiPackage psiPackage) { setName(psiPackage.getQualifiedName()); } }; private final RefactoringListeners.Accessor<PsiClass> myClass = new RefactoringListeners.Accessor<PsiClass>() { public void setName(final String qualifiedName) { final boolean generatedName = isGeneratedName(); data.MAIN_CLASS_NAME = qualifiedName; if (generatedName) setGeneratedName(); } @Nullable public PsiClass getPsiElement() { final String qualifiedName = data.getMainClassName(); return qualifiedName != null ? JavaPsiFacade.getInstance(getProject()) .findClass(qualifiedName, GlobalSearchScope.allScope(project)) : null; } public void setPsiElement(final PsiClass psiClass) { setName(psiClass.getQualifiedName()); } }; public TestNGConfiguration(String s, Project project, ConfigurationFactory factory) { this(s, project, new TestData(), factory); } private TestNGConfiguration( String s, Project project, TestData data, ConfigurationFactory factory) { super(s, new JavaRunConfigurationModule(project, false), factory); this.data = data; this.project = project; } public RunProfileState getState( @NotNull final Executor executor, @NotNull final ExecutionEnvironment env) throws ExecutionException { return new TestNGRunnableState(env, this); } public TestData getPersistantData() { return data; } @Override protected ModuleBasedConfiguration createInstance() { try { return new TestNGConfiguration( getName(), getProject(), (TestData) data.clone(), TestNGConfigurationType.getInstance().getConfigurationFactories()[0]); } catch (CloneNotSupportedException e) { // can't happen right? e.printStackTrace(); } return null; } @Override public Collection<Module> getValidModules() { // TODO add handling for package return JavaRunConfigurationModule.getModulesForClass(getProject(), data.getMainClassName()); } @Override public String suggestedName() { final TestNGTestObject testObject = TestNGTestObject.fromConfig(this); return testObject != null ? testObject.getGeneratedName() : null; } @Override public String getActionName() { final TestNGTestObject testObject = TestNGTestObject.fromConfig(this); return testObject != null ? testObject.getActionName() : null; } public void setVMParameters(String value) { data.setVMParameters(value); } public String getVMParameters() { return data.getVMParameters(); } public void setProgramParameters(String value) { data.setProgramParameters(value); } public String getProgramParameters() { return data.getProgramParameters(); } public void setWorkingDirectory(String value) { data.setWorkingDirectory(value); } public String getWorkingDirectory() { return data.getWorkingDirectory(project); } public void setEnvs(@NotNull Map<String, String> envs) { data.setEnvs(envs); } @NotNull public Map<String, String> getEnvs() { return data.getEnvs(); } public void setPassParentEnvs(boolean passParentEnvs) { data.PASS_PARENT_ENVS = passParentEnvs; } public boolean isPassParentEnvs() { return data.PASS_PARENT_ENVS; } public boolean isAlternativeJrePathEnabled() { return ALTERNATIVE_JRE_PATH_ENABLED; } public void setAlternativeJrePathEnabled(boolean enabled) { this.ALTERNATIVE_JRE_PATH_ENABLED = enabled; } @Nullable public String getAlternativeJrePath() { return ALTERNATIVE_JRE_PATH; } public void setAlternativeJrePath(String path) { this.ALTERNATIVE_JRE_PATH = path; } public String getRunClass() { return !data.TEST_OBJECT.equals(TestType.CLASS.getType()) && !data.TEST_OBJECT.equals(TestType.METHOD.getType()) ? null : data.getMainClassName(); } public String getPackage() { return !data.TEST_OBJECT.equals(TestType.PACKAGE.getType()) ? null : data.getPackageName(); } public void setClassConfiguration(PsiClass psiclass) { setModule(data.setMainClass(psiclass)); data.TEST_OBJECT = TestType.CLASS.getType(); setGeneratedName(); } public void setPackageConfiguration(Module module, PsiPackage pkg) { data.setPackage(pkg); setModule(module); data.TEST_OBJECT = TestType.PACKAGE.getType(); setGeneratedName(); } public void setMethodConfiguration(Location<PsiMethod> location) { setModule(data.setTestMethod(location)); setGeneratedName(); } public void bePatternConfiguration(List<PsiClass> classes, PsiMethod method) { data.TEST_OBJECT = TestType.PATTERN.getType(); final String suffix; if (method != null) { data.METHOD_NAME = method.getName(); suffix = "," + data.METHOD_NAME; } else { suffix = ""; } LinkedHashSet<String> patterns = new LinkedHashSet<String>(); for (PsiClass pattern : classes) { patterns.add(JavaExecutionUtil.getRuntimeQualifiedName(pattern) + suffix); } data.setPatterns(patterns); final Module module = RunConfigurationProducer.getInstance(TestNGPatternConfigurationProducer.class) .findModule(this, getConfigurationModule().getModule(), patterns); if (module == null) { data.setScope(TestSearchScope.WHOLE_PROJECT); setModule(null); } else { setModule(module); } setGeneratedName(); } @NotNull public SettingsEditor<? extends RunConfiguration> getConfigurationEditor() { SettingsEditorGroup<TestNGConfiguration> group = new SettingsEditorGroup<TestNGConfiguration>(); group.addEditor( ExecutionBundle.message("run.configuration.configuration.tab.title"), new TestNGConfigurationEditor(getProject())); JavaRunConfigurationExtensionManager.getInstance().appendEditors(this, group); group.addEditor( ExecutionBundle.message("logs.tab.title"), new LogConfigurationPanel<TestNGConfiguration>()); return group; } @Override public void checkConfiguration() throws RuntimeConfigurationException { final TestNGTestObject testObject = TestNGTestObject.fromConfig(this); if (testObject != null) { testObject.checkConfiguration(); } JavaRunConfigurationExtensionManager.checkConfigurationIsValid(this); ProgramParametersUtil.checkWorkingDirectoryExist( this, getProject(), getConfigurationModule().getModule()); JavaParametersUtil.checkAlternativeJRE(this); // TODO add various checks here } @Override public void readExternal(Element element) throws InvalidDataException { PathMacroManager.getInstance(getProject()).expandPaths(element); super.readExternal(element); JavaRunConfigurationExtensionManager.getInstance().readExternal(this, element); readModule(element); DefaultJDOMExternalizer.readExternal(this, element); DefaultJDOMExternalizer.readExternal(getPersistantData(), element); EnvironmentVariablesComponent.readExternal(element, getPersistantData().getEnvs()); Map<String, String> properties = getPersistantData().TEST_PROPERTIES; properties.clear(); Element propertiesElement = element.getChild("properties"); if (propertiesElement != null) { List<Element> children = propertiesElement.getChildren("property"); for (Element property : children) { properties.put(property.getAttributeValue("name"), property.getAttributeValue("value")); } } List<String> listeners = getPersistantData().TEST_LISTENERS; listeners.clear(); Element listenersElement = element.getChild("listeners"); if (listenersElement != null) { List<Element> children = listenersElement.getChildren("listener"); for (Element listenerClassName : children) { listeners.add(listenerClassName.getAttributeValue("class")); } } final Element patternsElement = element.getChild(PATTERNS_EL_NAME); if (patternsElement != null) { final LinkedHashSet<String> tests = new LinkedHashSet<String>(); for (Object o : patternsElement.getChildren(PATTERN_EL_NAME)) { Element patternElement = (Element) o; tests.add(patternElement.getAttributeValue(TEST_CLASS_ATT_NAME)); } getPersistantData().setPatterns(tests); } } @Override public void writeExternal(Element element) throws WriteExternalException { super.writeExternal(element); JavaRunConfigurationExtensionManager.getInstance().writeExternal(this, element); writeModule(element); DefaultJDOMExternalizer.writeExternal(this, element); DefaultJDOMExternalizer.writeExternal(getPersistantData(), element); EnvironmentVariablesComponent.writeExternal(element, getPersistantData().getEnvs()); Element propertiesElement = element.getChild("properties"); if (propertiesElement == null) { propertiesElement = new Element("properties"); element.addContent(propertiesElement); } Map<String, String> properties = getPersistantData().TEST_PROPERTIES; for (Map.Entry<String, String> entry : properties.entrySet()) { Element property = new Element("property"); property.setAttribute("name", entry.getKey()); property.setAttribute("value", entry.getValue()); propertiesElement.addContent(property); } Element listenersElement = element.getChild("listeners"); if (listenersElement == null) { listenersElement = new Element("listeners"); element.addContent(listenersElement); } List<String> listeners = getPersistantData().TEST_LISTENERS; for (String listener : listeners) { Element listenerElement = new Element("listener"); listenerElement.setAttribute("class", listener); listenersElement.addContent(listenerElement); } final Set<String> patterns = getPersistantData().getPatterns(); if (!patterns.isEmpty()) { final Element patternsElement = new Element(PATTERNS_EL_NAME); for (String o : patterns) { final Element patternElement = new Element(PATTERN_EL_NAME); patternElement.setAttribute(TEST_CLASS_ATT_NAME, o); patternsElement.addContent(patternElement); } element.addContent(patternsElement); } } @Nullable public RefactoringElementListener getRefactoringElementListener(final PsiElement element) { if (data.TEST_OBJECT.equals(TestType.PACKAGE.getType())) { if (!(element instanceof PsiPackage)) return null; final RefactoringElementListener listener = RefactoringListeners.getListener((PsiPackage) element, myPackage); return RunConfigurationExtension.wrapRefactoringElementListener(element, this, listener); } else if (data.TEST_OBJECT.equals(TestType.CLASS.getType())) { if (!(element instanceof PsiClass) && !(element instanceof PsiPackage)) return null; final RefactoringElementListener listener = RefactoringListeners.getClassOrPackageListener(element, myClass); return RunConfigurationExtension.wrapRefactoringElementListener(element, this, listener); } else if (data.TEST_OBJECT.equals(TestType.METHOD.getType())) { if (!(element instanceof PsiMethod)) { final RefactoringElementListener listener = RefactoringListeners.getClassOrPackageListener(element, myClass); return RunConfigurationExtension.wrapRefactoringElementListener(element, this, listener); } final PsiMethod method = (PsiMethod) element; if (!method.getName().equals(data.getMethodName())) return null; if (!method.getContainingClass().equals(myClass.getPsiElement())) return null; class Listener extends RefactoringElementAdapter implements UndoRefactoringElementListener { public void elementRenamedOrMoved(@NotNull final PsiElement newElement) { data.setTestMethod(PsiLocation.fromPsiElement((PsiMethod) newElement)); } @Override public void undoElementMovedOrRenamed( @NotNull PsiElement newElement, @NotNull String oldQualifiedName) { final int methodIdx = oldQualifiedName.indexOf("#") + 1; if (methodIdx <= 0 || methodIdx >= oldQualifiedName.length()) return; data.METHOD_NAME = oldQualifiedName.substring(methodIdx); } } return RunConfigurationExtension.wrapRefactoringElementListener( element, this, new Listener()); } return null; } @Override public boolean collectOutputFromProcessHandler() { return false; } @Override public SMTRunnerConsoleProperties createTestConsoleProperties(Executor executor) { return new TestNGConsoleProperties(this, executor); } @NotNull @Override public String getFrameworkPrefix() { return "g"; } }
public class JUnitConfiguration extends ModuleBasedConfiguration<JavaRunConfigurationModule> implements CommonJavaRunConfigurationParameters, RefactoringListenerProvider { private static final Logger LOG = Logger.getInstance("#com.intellij.execution.junit.JUnitConfiguration"); public static final String DEFAULT_PACKAGE_NAME = ExecutionBundle.message("default.package.presentable.name"); @NonNls public static final String TEST_CLASS = "class"; @NonNls public static final String TEST_PACKAGE = "package"; @NonNls public static final String TEST_DIRECTORY = "directory"; @NonNls public static final String TEST_METHOD = "method"; @NonNls private static final String PATTERN_EL_NAME = "pattern"; @NonNls public static final String TEST_PATTERN = PATTERN_EL_NAME; @NonNls private static final String TEST_CLASS_ATT_NAME = "testClass"; @NonNls private static final String PATTERNS_EL_NAME = "patterns"; private final Data myData; // See #26522 @NonNls public static final String JUNIT_START_CLASS = "com.intellij.rt.execution.junit.JUnitStarter"; public boolean ALTERNATIVE_JRE_PATH_ENABLED; public String ALTERNATIVE_JRE_PATH; public JUnitConfiguration( final String name, final Project project, ConfigurationFactory configurationFactory) { this(name, project, new Data(), configurationFactory); } private JUnitConfiguration( final String name, final Project project, final Data data, ConfigurationFactory configurationFactory) { super(name, new JavaRunConfigurationModule(project, false), configurationFactory); myData = data; } public RunProfileState getState( @NotNull final Executor executor, @NotNull final ExecutionEnvironment env) throws ExecutionException { return TestObject.fromString( myData.TEST_OBJECT, getProject(), this, env.getRunnerSettings(), env.getConfigurationSettings()); } public SettingsEditor<? extends RunConfiguration> getConfigurationEditor() { SettingsEditorGroup<JUnitConfiguration> group = new SettingsEditorGroup<JUnitConfiguration>(); group.addEditor( ExecutionBundle.message("run.configuration.configuration.tab.title"), new JUnitConfigurable(getProject())); JavaRunConfigurationExtensionManager.getInstance().appendEditors(this, group); group.addEditor( ExecutionBundle.message("logs.tab.title"), new LogConfigurationPanel<JUnitConfiguration>()); return group; } public Data getPersistentData() { return myData; } public RefactoringElementListener getRefactoringElementListener(final PsiElement element) { final RefactoringElementListener listener = myData.getTestObject(getProject(), this).getListener(element, this); return RunConfigurationExtension.wrapRefactoringElementListener(element, this, listener); } public String getGeneratedName() { return myData.getGeneratedName(getConfigurationModule()); } public void checkConfiguration() throws RuntimeConfigurationException { myData.getTestObject(getProject(), this).checkConfiguration(); JavaRunConfigurationExtensionManager.checkConfigurationIsValid(this); } public Collection<Module> getValidModules() { if (TEST_PACKAGE.equals(myData.TEST_OBJECT) || TEST_PATTERN.equals(myData.TEST_OBJECT)) { return Arrays.asList(ModuleManager.getInstance(getProject()).getModules()); } try { myData.getTestObject(getProject(), this).checkConfiguration(); } catch (RuntimeConfigurationError e) { return Arrays.asList(ModuleManager.getInstance(getProject()).getModules()); } catch (RuntimeConfigurationException e) { // ignore } return JavaRunConfigurationModule.getModulesForClass(getProject(), myData.getMainClassName()); } protected ModuleBasedConfiguration createInstance() { return new JUnitConfiguration( getName(), getProject(), myData.clone(), JUnitConfigurationType.getInstance() .getConfigurationFactories()[0]); // throw new RuntimeException("Should not call"); } public boolean isGeneratedName() { final String name = getName(); return myData.isGeneratedName(name, getConfigurationModule()); } public String suggestedName() { return getTestObject().suggestActionName(); } public void setVMParameters(String value) { myData.setVMParameters(value); } public String getVMParameters() { return myData.getVMParameters(); } public void setProgramParameters(String value) { myData.setProgramParameters(value); } public String getProgramParameters() { return myData.getProgramParameters(); } public void setWorkingDirectory(String value) { myData.setWorkingDirectory(value); } public String getWorkingDirectory() { return myData.getWorkingDirectory(); } public void setEnvs(@NotNull Map<String, String> envs) { myData.setEnvs(envs); } @NotNull public Map<String, String> getEnvs() { return myData.getEnvs(); } public void setPassParentEnvs(boolean passParentEnvs) { myData.PASS_PARENT_ENVS = passParentEnvs; } public boolean isPassParentEnvs() { return myData.PASS_PARENT_ENVS; } public boolean isAlternativeJrePathEnabled() { return ALTERNATIVE_JRE_PATH_ENABLED; } public void setAlternativeJrePathEnabled(boolean enabled) { this.ALTERNATIVE_JRE_PATH_ENABLED = enabled; } public String getAlternativeJrePath() { return ALTERNATIVE_JRE_PATH; } public void setAlternativeJrePath(String path) { this.ALTERNATIVE_JRE_PATH = path; } public String getRunClass() { final Data data = getPersistentData(); return data.TEST_OBJECT != TEST_CLASS && data.TEST_OBJECT != TEST_METHOD ? null : data.getMainClassName(); } public String getPackage() { final Data data = getPersistentData(); return !Comparing.strEqual(data.TEST_OBJECT, TEST_PACKAGE) ? null : data.getPackageName(); } public void beClassConfiguration(final PsiClass testClass) { setMainClass(testClass); myData.TEST_OBJECT = TEST_CLASS; setGeneratedName(); } public void setMainClass(final PsiClass testClass) { final boolean shouldUpdateName = isGeneratedName(); setModule(myData.setMainClass(testClass)); if (shouldUpdateName) setGeneratedName(); } public void setGeneratedName() { setName(getGeneratedName()); } public void beMethodConfiguration(final Location<PsiMethod> methodLocation) { setModule(myData.setTestMethod(methodLocation)); setGeneratedName(); } @NotNull public Module[] getModules() { if (TEST_PACKAGE.equals(myData.TEST_OBJECT) && getPersistentData().getScope() == TestSearchScope.WHOLE_PROJECT) { return Module.EMPTY_ARRAY; } return super.getModules(); } final RefactoringListeners.Accessor<PsiPackage> myPackage = new RefactoringListeners.Accessor<PsiPackage>() { public void setName(final String qualifiedName) { final boolean generatedName = isGeneratedName(); myData.PACKAGE_NAME = qualifiedName; if (generatedName) setGeneratedName(); } public PsiPackage getPsiElement() { final String qualifiedName = myData.getPackageName(); return qualifiedName != null ? JavaPsiFacade.getInstance(getProject()).findPackage(qualifiedName) : null; } public void setPsiElement(final PsiPackage psiPackage) { setName(psiPackage.getQualifiedName()); } }; final RefactoringListeners.Accessor<PsiClass> myClass = new RefactoringListeners.Accessor<PsiClass>() { public void setName(@NotNull final String qualifiedName) { final boolean generatedName = isGeneratedName(); myData.MAIN_CLASS_NAME = qualifiedName; if (generatedName) setGeneratedName(); } public PsiClass getPsiElement() { return getConfigurationModule().findClass(myData.getMainClassName()); } public void setPsiElement(final PsiClass psiClass) { final Module originalModule = getConfigurationModule().getModule(); setMainClass(psiClass); restoreOriginalModule(originalModule); } }; public TestObject getTestObject() { return myData.getTestObject(getProject(), this); } public void readExternal(final Element element) throws InvalidDataException { PathMacroManager.getInstance(getProject()).expandPaths(element); super.readExternal(element); JavaRunConfigurationExtensionManager.getInstance().readExternal(this, element); readModule(element); DefaultJDOMExternalizer.readExternal(this, element); DefaultJDOMExternalizer.readExternal(getPersistentData(), element); EnvironmentVariablesComponent.readExternal(element, getPersistentData().getEnvs()); final Element patternsElement = element.getChild(PATTERNS_EL_NAME); if (patternsElement != null) { final Set<String> tests = new LinkedHashSet<String>(); for (Object o : patternsElement.getChildren(PATTERN_EL_NAME)) { Element patternElement = (Element) o; tests.add(patternElement.getAttributeValue(TEST_CLASS_ATT_NAME)); } myData.setPatterns(tests); } final Element forkModeElement = element.getChild("fork_mode"); if (forkModeElement != null) { final String mode = forkModeElement.getAttributeValue("value"); if (mode != null) { setForkMode(mode); } } final Element dirNameElement = element.getChild("dir"); if (dirNameElement != null) { final String dirName = dirNameElement.getAttributeValue("value"); getPersistentData().setDirName(FileUtil.toSystemDependentName(dirName)); } } public void writeExternal(final Element element) throws WriteExternalException { super.writeExternal(element); JavaRunConfigurationExtensionManager.getInstance().writeExternal(this, element); writeModule(element); DefaultJDOMExternalizer.writeExternal(this, element); final Data persistentData = getPersistentData(); DefaultJDOMExternalizer.writeExternal(persistentData, element); EnvironmentVariablesComponent.writeExternal(element, persistentData.getEnvs()); final String dirName = persistentData.getDirName(); if (!dirName.isEmpty()) { final Element dirNameElement = new Element("dir"); dirNameElement.setAttribute("value", FileUtil.toSystemIndependentName(dirName)); element.addContent(dirNameElement); } final Element patternsElement = new Element(PATTERNS_EL_NAME); for (String o : persistentData.getPatterns()) { final Element patternElement = new Element(PATTERN_EL_NAME); patternElement.setAttribute(TEST_CLASS_ATT_NAME, o); patternsElement.addContent(patternElement); } final String forkMode = getForkMode(); if (!forkMode.equals("none")) { final Element forkModeElement = new Element("fork_mode"); forkModeElement.setAttribute("value", forkMode); element.addContent(forkModeElement); } element.addContent(patternsElement); PathMacroManager.getInstance(getProject()).collapsePathsRecursively(element); } public void configureClasspath(final JavaParameters javaParameters) throws CantRunException { RunConfigurationModule module = getConfigurationModule(); final String jreHome = isAlternativeJrePathEnabled() ? getAlternativeJrePath() : null; final int pathType = JavaParameters.JDK_AND_CLASSES_AND_TESTS; if (myData.getScope() == TestSearchScope.WHOLE_PROJECT) { JavaParametersUtil.configureProject(module.getProject(), javaParameters, pathType, jreHome); } else { JavaParametersUtil.configureModule(module, javaParameters, pathType, jreHome); } } public void setForkMode(@NotNull String forkMode) { myData.FORK_MODE = forkMode; } public String getForkMode() { return myData.FORK_MODE; } public static class Data implements Cloneable { public String PACKAGE_NAME; private String DIR_NAME; public String MAIN_CLASS_NAME; public String METHOD_NAME; public String TEST_OBJECT = TEST_CLASS; public String VM_PARAMETERS; public String PARAMETERS; public String WORKING_DIRECTORY; private String FORK_MODE = "none"; private Set<String> myPattern = new LinkedHashSet<String>(); // iws/ipr compatibility public String ENV_VARIABLES; private Map<String, String> myEnvs = new LinkedHashMap<String, String>(); public boolean PASS_PARENT_ENVS = true; public TestSearchScope.Wrapper TEST_SEARCH_SCOPE = new TestSearchScope.Wrapper(); public boolean equals(final Object object) { if (!(object instanceof Data)) return false; final Data second = (Data) object; return Comparing.equal(TEST_OBJECT, second.TEST_OBJECT) && Comparing.equal(getMainClassName(), second.getMainClassName()) && Comparing.equal(getPackageName(), second.getPackageName()) && Comparing.equal(getMethodName(), second.getMethodName()) && Comparing.equal(getWorkingDirectory(), second.getWorkingDirectory()) && Comparing.equal(VM_PARAMETERS, second.VM_PARAMETERS) && Comparing.equal(PARAMETERS, second.PARAMETERS) && Comparing.equal(myPattern, second.myPattern) && Comparing.equal(FORK_MODE, second.FORK_MODE) && Comparing.equal(DIR_NAME, second.DIR_NAME); } public int hashCode() { return Comparing.hashcode(TEST_OBJECT) ^ Comparing.hashcode(getMainClassName()) ^ Comparing.hashcode(getPackageName()) ^ Comparing.hashcode(getMethodName()) ^ Comparing.hashcode(getWorkingDirectory()) ^ Comparing.hashcode(VM_PARAMETERS) ^ Comparing.hashcode(PARAMETERS) ^ Comparing.hashcode(myPattern) ^ Comparing.hashcode(FORK_MODE) ^ Comparing.hashcode(DIR_NAME); } public TestSearchScope getScope() { return TEST_SEARCH_SCOPE.getScope(); } public Data clone() { try { Data data = (Data) super.clone(); data.TEST_SEARCH_SCOPE = new TestSearchScope.Wrapper(); data.setScope(getScope()); data.myEnvs = new LinkedHashMap<String, String>(myEnvs); return data; } catch (CloneNotSupportedException e) { throw new RuntimeException(e); } } public void setVMParameters(String value) { VM_PARAMETERS = value; } public String getVMParameters() { return VM_PARAMETERS; } public void setProgramParameters(String value) { PARAMETERS = value; } public String getProgramParameters() { return PARAMETERS; } public void setWorkingDirectory(String value) { WORKING_DIRECTORY = ExternalizablePath.urlValue(value); } public String getWorkingDirectory() { return ExternalizablePath.localPathValue(WORKING_DIRECTORY); } public Module setTestMethod(final Location<PsiMethod> methodLocation) { final PsiMethod method = methodLocation.getPsiElement(); METHOD_NAME = method.getName(); TEST_OBJECT = TEST_METHOD; return setMainClass( methodLocation instanceof MethodLocation ? ((MethodLocation) methodLocation).getContainingClass() : method.getContainingClass()); } public boolean isGeneratedName( final String name, final JavaRunConfigurationModule configurationModule) { if (TEST_OBJECT == null) return true; if ((TEST_CLASS.equals(TEST_OBJECT) || TEST_METHOD.equals(TEST_OBJECT)) && getMainClassName().length() == 0) { return JavaExecutionUtil.isNewName(name); } if (TEST_METHOD.equals(TEST_OBJECT) && getMethodName().length() == 0) { return JavaExecutionUtil.isNewName(name); } return Comparing.equal(name, getGeneratedName(configurationModule)); } public String getGeneratedName(final JavaRunConfigurationModule configurationModule) { if (TEST_PACKAGE.equals(TEST_OBJECT) || TEST_DIRECTORY.equals(TEST_OBJECT)) { final String moduleName = TEST_SEARCH_SCOPE.getScope() == TestSearchScope.WHOLE_PROJECT ? "" : configurationModule.getModuleName(); final String packageName = getPackageName(); if (packageName.length() == 0) { if (moduleName.length() > 0) { return ExecutionBundle.message("default.junit.config.name.all.in.module", moduleName); } return DEFAULT_PACKAGE_NAME; } if (moduleName.length() > 0) { return ExecutionBundle.message( "default.junit.config.name.all.in.package.in.module", packageName, moduleName); } return packageName; } if (TEST_PATTERN.equals(TEST_OBJECT)) { final int size = myPattern.size(); if (size == 0) return "Temp suite"; return StringUtil.getShortName(myPattern.iterator().next()) + (size > 1 ? " and " + (size - 1) + " more" : ""); } final String className = JavaExecutionUtil.getPresentableClassName(getMainClassName(), configurationModule); if (TEST_METHOD.equals(TEST_OBJECT)) { return className + '.' + getMethodName(); } return className; } public String getMainClassName() { return MAIN_CLASS_NAME != null ? MAIN_CLASS_NAME : ""; } public String getPackageName() { return PACKAGE_NAME != null ? PACKAGE_NAME : ""; } public String getMethodName() { return METHOD_NAME != null ? METHOD_NAME : ""; } public String getDirName() { return DIR_NAME != null ? DIR_NAME : ""; } public Set<String> getPatterns() { return myPattern; } public String getPatternPresentation() { final List<String> enabledTests = new ArrayList<String>(); for (String pattern : myPattern) { enabledTests.add(pattern); } return StringUtil.join(enabledTests, "||"); } public void setPatterns(Set<String> pattern) { myPattern = pattern; } public TestObject getTestObject(final Project project, final JUnitConfiguration configuration) { // TODO[dyoma]! return TestObject.fromString(TEST_OBJECT, project, configuration, null, null); } public Module setMainClass(final PsiClass testClass) { MAIN_CLASS_NAME = JavaExecutionUtil.getRuntimeQualifiedName(testClass); PsiPackage containingPackage = JUnitUtil.getContainingPackage(testClass); PACKAGE_NAME = containingPackage != null ? containingPackage.getQualifiedName() : ""; return JavaExecutionUtil.findModule(testClass); } public void setScope(final TestSearchScope scope) { TEST_SEARCH_SCOPE.setScope(scope); } public Map<String, String> getEnvs() { return myEnvs; } public void setEnvs(final Map<String, String> envs) { myEnvs = envs; } public void setDirName(String dirName) { DIR_NAME = dirName; } } }
BeforeRunStepsPanel(StepsBeforeRunListener listener) { myListener = listener; myModel = new CollectionListModel<BeforeRunTask>(); myList = new JBList(myModel); myList.getEmptyText().setText(ExecutionBundle.message("before.launch.panel.empty")); myList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); myList.setCellRenderer(new MyListCellRenderer()); myModel.addListDataListener( new ListDataListener() { @Override public void intervalAdded(ListDataEvent e) { adjustVisibleRowCount(); updateText(); } @Override public void intervalRemoved(ListDataEvent e) { adjustVisibleRowCount(); updateText(); } @Override public void contentsChanged(ListDataEvent e) {} private void adjustVisibleRowCount() { myList.setVisibleRowCount(Math.max(4, Math.min(8, myModel.getSize()))); } }); ToolbarDecorator myDecorator = ToolbarDecorator.createDecorator(myList); if (!SystemInfo.isMac) { myDecorator.setAsUsualTopToolbar(); } myDecorator.setEditAction( new AnActionButtonRunnable() { @Override public void run(AnActionButton button) { int index = myList.getSelectedIndex(); if (index == -1) return; Pair<BeforeRunTask, BeforeRunTaskProvider<BeforeRunTask>> selection = getSelection(); if (selection == null) return; BeforeRunTask task = selection.getFirst(); BeforeRunTaskProvider<BeforeRunTask> provider = selection.getSecond(); if (provider.configureTask(myRunConfiguration, task)) { myModel.setElementAt(task, index); } } }); myDecorator.setEditActionUpdater( new AnActionButtonUpdater() { @Override public boolean isEnabled(AnActionEvent e) { Pair<BeforeRunTask, BeforeRunTaskProvider<BeforeRunTask>> selection = getSelection(); return selection != null && selection.getSecond().isConfigurable(); } }); myDecorator.setAddAction( new AnActionButtonRunnable() { @Override public void run(AnActionButton button) { doAddAction(button); } }); myDecorator.setAddActionUpdater( new AnActionButtonUpdater() { @Override public boolean isEnabled(AnActionEvent e) { return checkBeforeRunTasksAbility(true); } }); myShowSettingsBeforeRunCheckBox = new JCheckBox(ExecutionBundle.message("configuration.edit.before.run")); myShowSettingsBeforeRunCheckBox.addActionListener( new ActionListener() { @Override public void actionPerformed(ActionEvent e) { updateText(); } }); myPanel = myDecorator.createPanel(); setLayout(new BorderLayout()); add(myPanel, BorderLayout.CENTER); add(myShowSettingsBeforeRunCheckBox, BorderLayout.SOUTH); }
public SearchForTestsTask(@Nullable final Project project, final ServerSocket socket) { super(project, ExecutionBundle.message("searching.test.progress.title"), true); myServerSocket = socket; }
public SwitchDuplexConsoleViewAction() { super( ExecutionBundle.message("run.configuration.show.command.line.action.name"), null, AllIcons.Debugger.ToolConsole); }
private static boolean userApprovesStopForIncompatibleConfigurations( Project project, String configName, List<RunContentDescriptor> runningIncompatibleDescriptors) { RunManagerImpl runManager = RunManagerImpl.getInstanceImpl(project); final RunManagerConfig config = runManager.getConfig(); if (!config.isStopIncompatibleRequiresConfirmation()) return true; DialogWrapper.DoNotAskOption option = new DialogWrapper.DoNotAskOption() { @Override public boolean isToBeShown() { return config.isStopIncompatibleRequiresConfirmation(); } @Override public void setToBeShown(boolean value, int exitCode) { config.setStopIncompatibleRequiresConfirmation(value); } @Override public boolean canBeHidden() { return true; } @Override public boolean shouldSaveOptionsOnCancel() { return false; } @NotNull @Override public String getDoNotShowMessage() { return CommonBundle.message("dialog.options.do.not.show"); } }; final StringBuilder names = new StringBuilder(); for (final RunContentDescriptor descriptor : runningIncompatibleDescriptors) { String name = descriptor.getDisplayName(); if (names.length() > 0) { names.append(", "); } names.append( StringUtil.isEmpty(name) ? ExecutionBundle.message("run.configuration.no.name") : String.format("'%s'", name)); } //noinspection DialogTitleCapitalization return Messages.showOkCancelDialog( project, ExecutionBundle.message( "stop.incompatible.confirmation.message", configName, names.toString(), runningIncompatibleDescriptors.size()), ExecutionBundle.message( "incompatible.configuration.is.running.dialog.title", runningIncompatibleDescriptors.size()), ExecutionBundle.message("stop.incompatible.confirmation.button.text"), CommonBundle.message("button.cancel"), Messages.getQuestionIcon(), option) == Messages.OK; }