diff --git a/java/execution/impl/execution-impl.iml b/java/execution/impl/execution-impl.iml index 602b82583a84..d98f98ac7bfe 100644 --- a/java/execution/impl/execution-impl.iml +++ b/java/execution/impl/execution-impl.iml @@ -16,11 +16,11 @@ + - - + \ No newline at end of file diff --git a/java/execution/impl/src/com/intellij/execution/JavaTestFrameworkRunnableState.java b/java/execution/impl/src/com/intellij/execution/JavaTestFrameworkRunnableState.java new file mode 100644 index 000000000000..cb92598c7570 --- /dev/null +++ b/java/execution/impl/src/com/intellij/execution/JavaTestFrameworkRunnableState.java @@ -0,0 +1,78 @@ +/* + * Copyright 2000-2015 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.intellij.execution; + +import com.intellij.execution.*; +import com.intellij.execution.configurations.JavaCommandLineState; +import com.intellij.execution.configurations.RunConfigurationBase; +import com.intellij.execution.configurations.RunnerSettings; +import com.intellij.execution.process.OSProcessHandler; +import com.intellij.execution.runners.ExecutionEnvironment; +import com.intellij.execution.testframework.TestConsoleProperties; +import com.intellij.execution.testframework.TestFrameworkRunningModel; +import com.intellij.execution.testframework.actions.AbstractRerunFailedTestsAction; +import com.intellij.execution.testframework.sm.SMTestRunnerConnectionUtil; +import com.intellij.execution.testframework.sm.runner.SMTRunnerConsoleProperties; +import com.intellij.execution.testframework.sm.runner.ui.SMTRunnerConsoleView; +import com.intellij.execution.ui.ConsoleView; +import com.intellij.openapi.util.Disposer; +import com.intellij.openapi.util.Getter; +import com.intellij.util.PathUtil; +import jetbrains.buildServer.messages.serviceMessages.ServiceMessageTypes; +import org.jetbrains.annotations.NotNull; + +public abstract class JavaTestFrameworkRunnableState extends JavaCommandLineState { + public JavaTestFrameworkRunnableState(ExecutionEnvironment environment) { + super(environment); + } + + @NotNull protected abstract String getFrameworkName(); + + @NotNull protected abstract String getVMParameter(); + + @NotNull protected abstract AbstractRerunFailedTestsAction createRerunFailedTestsAction(TestConsoleProperties testConsoleProperties, ConsoleView consoleView); + + protected ExecutionResult startSMRunner(Executor executor, + OSProcessHandler handler, + RunConfigurationBase configuration, + ExecutionEnvironment environment) throws ExecutionException { + getJavaParameters().getVMParametersList().add(getVMParameter()); + getJavaParameters().getClassPath().add(PathUtil.getJarPathForClass(ServiceMessageTypes.class)); + + final RunnerSettings runnerSettings = getRunnerSettings(); + + TestConsoleProperties testConsoleProperties = new SMTRunnerConsoleProperties(configuration, getFrameworkName(), executor); + testConsoleProperties.setIfUndefined(TestConsoleProperties.HIDE_PASSED_TESTS, false); + + final ConsoleView consoleView = SMTestRunnerConnectionUtil.createConsoleWithCustomLocator(getFrameworkName(), testConsoleProperties, environment, null); + Disposer.register(configuration.getProject(), consoleView); + consoleView.attachToProcess(handler); + + AbstractRerunFailedTestsAction rerunFailedTestsAction = createRerunFailedTestsAction(testConsoleProperties, consoleView); + rerunFailedTestsAction.setModelProvider(new Getter() { + @Override + public TestFrameworkRunningModel get() { + return ((SMTRunnerConsoleView)consoleView).getResultsViewer(); + } + }); + + final DefaultExecutionResult result = new DefaultExecutionResult(consoleView, handler); + result.setRestartActions(rerunFailedTestsAction); + + JavaRunConfigurationExtensionManager.getInstance().attachExtensionsToProcess(configuration, handler, runnerSettings); + return result; + } +} diff --git a/java/execution/impl/src/com/intellij/execution/testframework/SearchForTestsTask.java b/java/execution/impl/src/com/intellij/execution/testframework/SearchForTestsTask.java index 80bb3c4785e8..166dd7830d5c 100644 --- a/java/execution/impl/src/com/intellij/execution/testframework/SearchForTestsTask.java +++ b/java/execution/impl/src/com/intellij/execution/testframework/SearchForTestsTask.java @@ -17,6 +17,7 @@ package com.intellij.execution.testframework; import com.intellij.execution.CantRunException; import com.intellij.execution.ExecutionBundle; +import com.intellij.execution.ExecutionException; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.progress.ProcessCanceledException; @@ -48,7 +49,7 @@ public abstract class SearchForTestsTask extends Task.Backgroundable { } - protected abstract void search() throws CantRunException; + protected abstract void search() throws ExecutionException; protected abstract void onFound(); public void ensureFinished() { @@ -77,14 +78,14 @@ public abstract class SearchForTestsTask extends Task.Backgroundable { public void run(@NotNull ProgressIndicator indicator) { try { mySocket = myServerSocket.accept(); - final CantRunException[] ex = new CantRunException[1]; + final ExecutionException[] ex = new ExecutionException[1]; DumbService.getInstance(getProject()).repeatUntilPassesInSmartMode(new Runnable() { @Override public void run() { try { search(); } - catch (CantRunException e) { + catch (ExecutionException e) { ex[0] = e; } } @@ -104,7 +105,7 @@ public abstract class SearchForTestsTask extends Task.Backgroundable { } } - protected void logCantRunException(CantRunException e) throws CantRunException { + protected void logCantRunException(ExecutionException e) throws ExecutionException { throw e; } diff --git a/java/execution/openapi/src/com/intellij/execution/configurations/JavaCommandLineState.java b/java/execution/openapi/src/com/intellij/execution/configurations/JavaCommandLineState.java index f6163fed0066..7e477ba92818 100644 --- a/java/execution/openapi/src/com/intellij/execution/configurations/JavaCommandLineState.java +++ b/java/execution/openapi/src/com/intellij/execution/configurations/JavaCommandLineState.java @@ -51,7 +51,7 @@ public abstract class JavaCommandLineState extends CommandLineState implements J protected abstract JavaParameters createJavaParameters() throws ExecutionException; protected GeneralCommandLine createCommandLine() throws ExecutionException { - @SuppressWarnings("deprecation") Project project = CommonDataKeys.PROJECT.getData(DataManager.getInstance().getDataContext()); + final Project project = getEnvironment().getProject(); return CommandLineBuilder.createFromJavaParameters(getJavaParameters(), project, true); } diff --git a/plugins/junit/src/com/intellij/execution/junit/TestClass.java b/plugins/junit/src/com/intellij/execution/junit/TestClass.java index e3ab54aa6adc..a6de55eaad68 100644 --- a/plugins/junit/src/com/intellij/execution/junit/TestClass.java +++ b/plugins/junit/src/com/intellij/execution/junit/TestClass.java @@ -19,10 +19,7 @@ package com.intellij.execution.junit; import com.intellij.execution.ExecutionBundle; import com.intellij.execution.ExecutionException; import com.intellij.execution.JavaExecutionUtil; -import com.intellij.execution.configurations.JavaRunConfigurationModule; -import com.intellij.execution.configurations.RunConfigurationModule; -import com.intellij.execution.configurations.RuntimeConfigurationException; -import com.intellij.execution.configurations.RuntimeConfigurationWarning; +import com.intellij.execution.configurations.*; import com.intellij.execution.runners.ExecutionEnvironment; import com.intellij.openapi.util.Comparing; import com.intellij.psi.*; @@ -34,12 +31,12 @@ class TestClass extends TestObject { } @Override - protected void initialize() throws ExecutionException { - super.initialize(); + protected void initialize(JavaParameters javaParameters) throws ExecutionException { + super.initialize(javaParameters); final JUnitConfiguration.Data data = myConfiguration.getPersistentData(); RunConfigurationModule module = myConfiguration.getConfigurationModule(); - configureModule(myJavaParameters, module, data.getMainClassName()); - myJavaParameters.getProgramParametersList().add(data.getMainClassName()); + configureModule(javaParameters, module, data.getMainClassName()); + javaParameters.getProgramParametersList().add(data.getMainClassName()); } @Override diff --git a/plugins/junit/src/com/intellij/execution/junit/TestMethod.java b/plugins/junit/src/com/intellij/execution/junit/TestMethod.java index 21817210e4d8..ab467fe3e80c 100644 --- a/plugins/junit/src/com/intellij/execution/junit/TestMethod.java +++ b/plugins/junit/src/com/intellij/execution/junit/TestMethod.java @@ -36,20 +36,20 @@ class TestMethod extends TestObject { } @Override - protected void initialize() throws ExecutionException { - defaultInitialize(); + protected void initialize(JavaParameters javaParameters) throws ExecutionException { + defaultInitialize(javaParameters); final JUnitConfiguration.Data data = myConfiguration.getPersistentData(); RunConfigurationModule module = myConfiguration.getConfigurationModule(); - configureModule(getJavaParameters(), module, data.getMainClassName()); - addJUnit3Parameter(data, module.getProject()); - getJavaParameters().getProgramParametersList().add(data.getMainClassName() + "," + data.getMethodName()); + configureModule(javaParameters, module, data.getMainClassName()); + addJUnit3Parameter(javaParameters, data, module.getProject()); + javaParameters.getProgramParametersList().add(data.getMainClassName() + "," + data.getMethodName()); } - protected void defaultInitialize() throws ExecutionException { - super.initialize(); + protected void defaultInitialize(JavaParameters javaParameters) throws ExecutionException { + super.initialize(javaParameters); } - protected void addJUnit3Parameter(final JUnitConfiguration.Data data, Project project) { + protected void addJUnit3Parameter(JavaParameters javaParameters, final JUnitConfiguration.Data data, Project project) throws ExecutionException { final PsiClass psiClass = JavaExecutionUtil.findMainClass(project, data.getMainClassName(), GlobalSearchScope.allScope(project)); LOG.assertTrue(psiClass != null); if (JUnitUtil.isJUnit4TestClass(psiClass)) { @@ -62,7 +62,7 @@ class TestMethod extends TestObject { return; } } - myJavaParameters.getProgramParametersList().add(JUnitStarter.JUNIT3_PARAMETER); + javaParameters.getProgramParametersList().add(JUnitStarter.JUNIT3_PARAMETER); } @Override diff --git a/plugins/junit/src/com/intellij/execution/junit/TestMethods.java b/plugins/junit/src/com/intellij/execution/junit/TestMethods.java index d814cb7c1a18..25a5827c52d5 100644 --- a/plugins/junit/src/com/intellij/execution/junit/TestMethods.java +++ b/plugins/junit/src/com/intellij/execution/junit/TestMethods.java @@ -16,10 +16,10 @@ package com.intellij.execution.junit; -import com.intellij.execution.CantRunException; import com.intellij.execution.ExecutionException; import com.intellij.execution.JavaExecutionUtil; import com.intellij.execution.Location; +import com.intellij.execution.configurations.JavaParameters; import com.intellij.execution.configurations.RunConfigurationModule; import com.intellij.execution.junit2.PsiMemberParameterizedLocation; import com.intellij.execution.junit2.TestProxy; @@ -54,8 +54,8 @@ public class TestMethods extends TestMethod { } @Override - protected void initialize() throws ExecutionException { - defaultInitialize(); + protected void initialize(final JavaParameters javaParameters) throws ExecutionException { + defaultInitialize(javaParameters); final JUnitConfiguration.Data data = myConfiguration.getPersistentData(); RunConfigurationModule module = myConfiguration.getConfigurationModule(); final Project project = module.getProject(); @@ -64,9 +64,9 @@ public class TestMethods extends TestMethod { @Override public void run() { try { - myConfiguration.configureClasspath(myJavaParameters); + myConfiguration.configureClasspath(javaParameters); } - catch (CantRunException e) { + catch (ExecutionException e) { exception[0] = e; } } @@ -98,7 +98,7 @@ public class TestMethods extends TestMethod { } return null; } - }, data.getPackageName(), true); + }, data.getPackageName(), true, javaParameters); } diff --git a/plugins/junit/src/com/intellij/execution/junit/TestObject.java b/plugins/junit/src/com/intellij/execution/junit/TestObject.java index 6ee5e893b4ad..82007fa04637 100644 --- a/plugins/junit/src/com/intellij/execution/junit/TestObject.java +++ b/plugins/junit/src/com/intellij/execution/junit/TestObject.java @@ -36,9 +36,7 @@ import com.intellij.execution.process.ProcessEvent; import com.intellij.execution.runners.ExecutionEnvironment; import com.intellij.execution.runners.ProgramRunner; import com.intellij.execution.testframework.*; -import com.intellij.execution.testframework.sm.SMTestRunnerConnectionUtil; -import com.intellij.execution.testframework.sm.runner.SMTRunnerConsoleProperties; -import com.intellij.execution.testframework.sm.runner.ui.SMTRunnerConsoleView; +import com.intellij.execution.testframework.actions.AbstractRerunFailedTestsAction; import com.intellij.execution.ui.ConsoleView; import com.intellij.execution.ui.ConsoleViewContentType; import com.intellij.execution.util.JavaParametersUtil; @@ -75,7 +73,6 @@ import com.intellij.rt.execution.junit.RepeatCount; import com.intellij.util.Function; import com.intellij.util.PathUtil; import com.intellij.util.ui.UIUtil; -import jetbrains.buildServer.messages.serviceMessages.ServiceMessageTypes; import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; import org.jetbrains.jps.model.serialization.PathMacroUtil; @@ -85,13 +82,12 @@ import java.io.IOException; import java.io.PrintWriter; import java.util.*; -public abstract class TestObject implements JavaCommandLine { +public abstract class TestObject extends JavaTestFrameworkRunnableState { protected static final Logger LOG = Logger.getInstance(TestObject.class); private static final String MESSAGE = ExecutionBundle.message("configuration.not.speficied.message"); @NonNls private static final String JUNIT_TEST_FRAMEWORK_NAME = "JUnit"; - protected JavaParameters myJavaParameters; protected final JUnitConfiguration myConfiguration; protected final ExecutionEnvironment myEnvironment; protected File myTempFile = null; @@ -119,7 +115,8 @@ public abstract class TestObject implements JavaCommandLine { if (JUnitConfiguration.TEST_PATTERN.equals(id)) { return new TestsPattern(configuration, environment); } - return NOT_CONFIGURED; + assert false : MESSAGE + id; + return null; } public Module[] getModulesToCompile() { @@ -128,6 +125,7 @@ public abstract class TestObject implements JavaCommandLine { } protected TestObject(JUnitConfiguration configuration, ExecutionEnvironment environment) { + super(environment); myConfiguration = configuration; myEnvironment = environment; } @@ -153,42 +151,6 @@ public abstract class TestObject implements JavaCommandLine { myConfiguration.isAlternativeJrePathEnabled() ? myConfiguration.getAlternativeJrePath() : null); } - private static final TestObject NOT_CONFIGURED = new TestObject(null, null) { - @Override - public RefactoringElementListener getListener(final PsiElement element, final JUnitConfiguration configuration) { - return null; - } - - @Override - public String suggestActionName() { - throw new RuntimeException(String.valueOf(myConfiguration)); - } - - @Override - public boolean isConfiguredByElement(final JUnitConfiguration configuration, - PsiClass testClass, - PsiMethod testMethod, - PsiPackage testPackage, - PsiDirectory testDir) { - return false; - } - - @Override - public void checkConfiguration() throws RuntimeConfigurationException { - throw new RuntimeConfigurationError(MESSAGE); - } - - @Override - public JavaParameters getJavaParameters() throws ExecutionException { - throw new ExecutionException(MESSAGE); - } - - @Override - protected void initialize() throws ExecutionException { - throw new ExecutionException(MESSAGE); - } - }; - public void checkConfiguration() throws RuntimeConfigurationException{ JavaParametersUtil.checkAlternativeJRE(myConfiguration); ProgramParametersUtil.checkWorkingDirectoryExist(myConfiguration, myConfiguration.getProject(), myConfiguration.getConfigurationModule().getModule()); @@ -198,30 +160,30 @@ public abstract class TestObject implements JavaCommandLine { return SourceScope.modulesWithDependencies(myConfiguration.getModules()); } - protected void initialize() throws ExecutionException { + protected void initialize(JavaParameters javaParameters) throws ExecutionException { String parameters = myConfiguration.getProgramParameters(); myConfiguration.getPersistentData().setProgramParameters(null); try { - JavaParametersUtil.configureConfiguration(myJavaParameters, myConfiguration); + JavaParametersUtil.configureConfiguration(javaParameters, myConfiguration); } finally { myConfiguration.getPersistentData().setProgramParameters(parameters); } - myJavaParameters.setMainClass(JUnitConfiguration.JUNIT_START_CLASS); + javaParameters.setMainClass(JUnitConfiguration.JUNIT_START_CLASS); final Module module = myConfiguration.getConfigurationModule().getModule(); - if (myJavaParameters.getJdk() == null){ - myJavaParameters.setJdk(module != null - ? ModuleRootManager.getInstance(module).getSdk() - : ProjectRootManager.getInstance(myEnvironment.getProject()).getProjectSdk()); + if (javaParameters.getJdk() == null){ + javaParameters.setJdk(module != null + ? ModuleRootManager.getInstance(module).getSdk() + : ProjectRootManager.getInstance(myEnvironment.getProject()).getProjectSdk()); } - configureAdditionalClasspath(myJavaParameters); - myJavaParameters.getProgramParametersList().add(JUnitStarter.IDE_VERSION + JUnitStarter.VERSION); + configureAdditionalClasspath(javaParameters); + javaParameters.getProgramParametersList().add(JUnitStarter.IDE_VERSION + JUnitStarter.VERSION); if (!StringUtil.isEmptyOrSpaces(parameters)) { - myJavaParameters.getProgramParametersList().add("@name" + parameters); + javaParameters.getProgramParametersList().add("@name" + parameters); } for (RunConfigurationExtension ext : Extensions.getExtensions(RunConfigurationExtension.EP_NAME)) { - ext.updateJavaParameters(myConfiguration, myJavaParameters, getRunnerSettings()); + ext.updateJavaParameters(myConfiguration, javaParameters, getRunnerSettings()); } final Object[] listeners = Extensions.getExtensions(IDEAJUnitListener.EP_NAME); @@ -237,14 +199,14 @@ public abstract class TestObject implements JavaCommandLine { if (enabled) { final Class classListener = listener.getClass(); buf.append(classListener.getName()).append("\n"); - myJavaParameters.getClassPath().add(PathUtil.getJarPathForClass(classListener)); + javaParameters.getClassPath().add(PathUtil.getJarPathForClass(classListener)); } } if (buf.length() > 0) { try { myListenersFile = FileUtil.createTempFile("junit_listeners_", ""); myListenersFile.deleteOnExit(); - myJavaParameters.getProgramParametersList().add("@@" + myListenersFile.getPath()); + javaParameters.getProgramParametersList().add("@@" + myListenersFile.getPath()); FileUtil.writeToFile(myListenersFile, buf.toString().getBytes(CharsetToolkit.UTF8_CHARSET)); } catch (IOException e) { @@ -253,40 +215,33 @@ public abstract class TestObject implements JavaCommandLine { } } - private void configureAdditionalClasspath(JavaParameters javaParameters) { + private static void configureAdditionalClasspath(JavaParameters javaParameters) { javaParameters.getClassPath().add(JavaSdkUtil.getIdeaRtJarPath()); javaParameters.getClassPath().add(PathUtil.getJarPathForClass(JUnitStarter.class)); - if (Registry.is("junit_sm_runner")) { - javaParameters.getClassPath().add(PathUtil.getJarPathForClass(ServiceMessageTypes.class)); - } } @Override - public JavaParameters getJavaParameters() throws ExecutionException { - if (myJavaParameters == null) { - myJavaParameters = new JavaParameters(); - initialize(); - final Module module = myConfiguration.getConfigurationModule().getModule(); - final Object[] patchers = Extensions.getExtensions(ExtensionPoints.JUNIT_PATCHER); - for (Object patcher : patchers) { - ((JUnitPatcher)patcher).patchJavaParameters(module, myJavaParameters); - } + protected JavaParameters createJavaParameters() throws ExecutionException { + JavaParameters javaParameters = new JavaParameters(); + initialize(javaParameters); + final Module module = myConfiguration.getConfigurationModule().getModule(); + final Object[] patchers = Extensions.getExtensions(ExtensionPoints.JUNIT_PATCHER); + for (Object patcher : patchers) { + ((JUnitPatcher)patcher).patchJavaParameters(module, javaParameters); } - return myJavaParameters; + return javaParameters; } + @NotNull @Override - public ExecutionResult execute(final Executor executor, @NotNull final ProgramRunner runner) throws ExecutionException { + public ExecutionResult execute(@NotNull final Executor executor, @NotNull final ProgramRunner runner) throws ExecutionException { final boolean smRunner = Registry.is("junit_sm_runner"); if (smRunner) { - myJavaParameters.getVMParametersList().add("-Didea.junit.sm_runner"); + return startSMRunner(executor, createHandler(executor), myConfiguration, getEnvironment()); } final JUnitProcessHandler handler = createHandler(executor); final RunnerSettings runnerSettings = getRunnerSettings(); JavaRunConfigurationExtensionManager.getInstance().attachExtensionsToProcess(myConfiguration, handler, runnerSettings); - if (smRunner) { - return useSmRunner(executor, handler); - } final TestProxy unboundOutputRoot = new TestProxy(new RootTestInfo()); final JUnitConsoleProperties consoleProperties = new JUnitConsoleProperties(myConfiguration, executor); final JUnitTreeConsoleView consoleView = new JUnitTreeConsoleView(consoleProperties, myEnvironment, unboundOutputRoot); @@ -325,6 +280,7 @@ public abstract class TestObject implements JavaCommandLine { handler.addProcessListener(new ProcessAdapter() { private boolean myStarted = false; + @Override public void startNotified(ProcessEvent event) { myStarted = true; @@ -386,30 +342,6 @@ public abstract class TestObject implements JavaCommandLine { return result; } - private ExecutionResult useSmRunner(Executor executor, JUnitProcessHandler handler) { - TestConsoleProperties testConsoleProperties = new SMTRunnerConsoleProperties(myConfiguration, JUNIT_TEST_FRAMEWORK_NAME, executor); - testConsoleProperties.setIfUndefined(TestConsoleProperties.HIDE_PASSED_TESTS, false); - - final ConsoleView consoleView = SMTestRunnerConnectionUtil.createConsoleWithCustomLocator( - JUNIT_TEST_FRAMEWORK_NAME, - testConsoleProperties, - myEnvironment, null); - Disposer.register(myConfiguration.getProject(), consoleView); - consoleView.attachToProcess(handler); - - RerunFailedTestsAction rerunFailedTestsAction = new RerunFailedTestsAction(consoleView, testConsoleProperties); - rerunFailedTestsAction.setModelProvider(new Getter() { - @Override - public TestFrameworkRunningModel get() { - return ((SMTRunnerConsoleView)consoleView).getResultsViewer(); - } - }); - - final DefaultExecutionResult result = new DefaultExecutionResult(consoleView, handler); - result.setRestartActions(rerunFailedTestsAction); - return result; - } - protected void notifyByBalloon(JUnitRunningModel model, boolean started, JUnitConsoleProperties consoleProperties) { String comment; if (model != null) { @@ -430,9 +362,9 @@ public abstract class TestObject implements JavaCommandLine { final String countString = RepeatCount.N.equals(repeatMode) && repeatCount > 0 ? RepeatCount.getCountString(repeatCount) : repeatMode; - myJavaParameters.getProgramParametersList().add(countString); + getJavaParameters().getProgramParametersList().add(countString); } - return JUnitProcessHandler.runCommandLine(CommandLineBuilder.createFromJavaParameters(myJavaParameters, myEnvironment.getProject(), true)); + return JUnitProcessHandler.runCommandLine(createCommandLine()); } private boolean forkPerModule() { @@ -512,7 +444,7 @@ public abstract class TestObject implements JavaCommandLine { writer.close(); } - myJavaParameters.getProgramParametersList().add("@@@" + forkMode + ',' + tempFile.getAbsolutePath()); + getJavaParameters().getProgramParametersList().add("@@@" + forkMode + ',' + tempFile.getAbsolutePath()); } catch (Exception e) { LOG.error(e); @@ -520,10 +452,10 @@ public abstract class TestObject implements JavaCommandLine { } protected void addClassesListToJavaParameters(Collection elements, Function nameFunction, String packageName, - boolean createTempFile) throws CantRunException { + boolean createTempFile, JavaParameters javaParameters) throws CantRunException { try { if (createTempFile) { - createTempFiles(); + createTempFiles(javaParameters); } final Map> perModule = forkPerModule() ? new TreeMap>(new Comparator() { @@ -573,7 +505,7 @@ public abstract class TestObject implements JavaCommandLine { if (perModule != null && perModule.size() > 1) { final String classpath = myConfiguration.getPersistentData().getScope() == TestSearchScope.WHOLE_PROJECT - ? null : myJavaParameters.getClassPath().getPathsString(); + ? null : javaParameters.getClassPath().getPathsString(); final PrintWriter wWriter = new PrintWriter(myWorkingDirsFile, CharsetToolkit.UTF8); try { @@ -608,16 +540,31 @@ public abstract class TestObject implements JavaCommandLine { } } - protected void createTempFiles() throws IOException { + protected void createTempFiles(JavaParameters javaParameters) throws IOException { myTempFile = FileUtil.createTempFile("idea_junit", ".tmp"); myTempFile.deleteOnExit(); - myJavaParameters.getProgramParametersList().add("@" + myTempFile.getAbsolutePath()); + javaParameters.getProgramParametersList().add("@" + myTempFile.getAbsolutePath()); myWorkingDirsFile = FileUtil.createTempFile("idea_working_dirs_junit", ".tmp"); myWorkingDirsFile.deleteOnExit(); - myJavaParameters.getProgramParametersList().add("@w@" + myWorkingDirsFile.getAbsolutePath()); + javaParameters.getProgramParametersList().add("@w@" + myWorkingDirsFile.getAbsolutePath()); } public void clear() { - myJavaParameters = null; + } + + @NotNull + protected String getFrameworkName() { + return JUNIT_TEST_FRAMEWORK_NAME; + } + + @NotNull + protected String getVMParameter() { + return "-Didea.junit.sm_runner"; + } + + @NotNull + protected AbstractRerunFailedTestsAction createRerunFailedTestsAction(TestConsoleProperties testConsoleProperties, + ConsoleView consoleView) { + return new RerunFailedTestsAction(consoleView, testConsoleProperties); } } diff --git a/plugins/junit/src/com/intellij/execution/junit/TestPackage.java b/plugins/junit/src/com/intellij/execution/junit/TestPackage.java index 53bda2b9fb75..604b9f85a45d 100644 --- a/plugins/junit/src/com/intellij/execution/junit/TestPackage.java +++ b/plugins/junit/src/com/intellij/execution/junit/TestPackage.java @@ -17,6 +17,7 @@ package com.intellij.execution.junit; import com.intellij.execution.*; +import com.intellij.execution.configurations.JavaParameters; import com.intellij.execution.configurations.RuntimeConfigurationException; import com.intellij.execution.configurations.RuntimeConfigurationWarning; import com.intellij.execution.junit2.ui.model.JUnitRunningModel; @@ -33,7 +34,6 @@ import com.intellij.psi.*; import com.intellij.psi.search.GlobalSearchScope; import com.intellij.psi.search.PackageScope; import com.intellij.refactoring.listeners.RefactoringElementListener; -import com.intellij.util.Consumer; import com.intellij.util.Function; import gnu.trove.THashSet; import org.jetbrains.annotations.Nullable; @@ -41,7 +41,6 @@ import org.jetbrains.annotations.Nullable; import java.io.IOException; import java.net.InetAddress; import java.net.ServerSocket; -import java.util.Collection; public class TestPackage extends TestObject { protected ServerSocket myServerSocket; @@ -111,9 +110,9 @@ public class TestPackage extends TestObject { return null; } } - }, getPackageName(data), false); + }, getPackageName(data), false, getJavaParameters()); } - catch (CantRunException ignored) {} + catch (ExecutionException ignored) {} } }; } @@ -123,14 +122,14 @@ public class TestPackage extends TestObject { } @Override - protected void initialize() throws ExecutionException { - super.initialize(); + protected void initialize(JavaParameters javaParameters) throws ExecutionException { + super.initialize(javaParameters); final JUnitConfiguration.Data data = myConfiguration.getPersistentData(); getClassFilter(data);//check if junit found - configureClasspath(); + configureClasspath(javaParameters); try { - createTempFiles(); + createTempFiles(javaParameters); } catch (IOException e) { LOG.error(e); @@ -138,20 +137,20 @@ public class TestPackage extends TestObject { try { myServerSocket = new ServerSocket(0, 0, InetAddress.getByName("127.0.0.1")); - myJavaParameters.getProgramParametersList().add("-socket" + myServerSocket.getLocalPort()); + javaParameters.getProgramParametersList().add("-socket" + myServerSocket.getLocalPort()); } catch (IOException e) { LOG.error(e); } } - protected void configureClasspath() throws ExecutionException { + protected void configureClasspath(final JavaParameters javaParameters) throws ExecutionException { final ExecutionException[] exception = new ExecutionException[1]; ApplicationManager.getApplication().runReadAction(new Runnable() { @Override public void run() { try { - myConfiguration.configureClasspath(myJavaParameters); + myConfiguration.configureClasspath(javaParameters); } catch (CantRunException e) { exception[0] = e; diff --git a/plugins/junit/src/com/intellij/execution/junit/TestsPattern.java b/plugins/junit/src/com/intellij/execution/junit/TestsPattern.java index 6494bc498133..c24d7d82e8be 100644 --- a/plugins/junit/src/com/intellij/execution/junit/TestsPattern.java +++ b/plugins/junit/src/com/intellij/execution/junit/TestsPattern.java @@ -21,6 +21,7 @@ package com.intellij.execution.junit; import com.intellij.execution.CantRunException; +import com.intellij.execution.ExecutionException; import com.intellij.execution.JavaExecutionUtil; import com.intellij.execution.configurations.JavaParameters; import com.intellij.execution.configurations.RuntimeConfigurationException; @@ -72,7 +73,7 @@ public class TestsPattern extends TestPackage { if (classNames.size() == data.getPatterns().size()) { return new SearchForTestsTask(project, myServerSocket) { @Override - protected void search() throws CantRunException { + protected void search() throws ExecutionException { final Function nameFunction = StringUtil.isEmpty(data.METHOD_NAME) ? FunctionUtil.id() : new Function() { @@ -81,7 +82,7 @@ public class TestsPattern extends TestPackage { return className; } }; - addClassesListToJavaParameters(classNames, nameFunction, "", false); + addClassesListToJavaParameters(classNames, nameFunction, "", false, getJavaParameters()); } @Override @@ -99,17 +100,17 @@ public class TestsPattern extends TestPackage { : className).trim(), GlobalSearchScope.allScope(project)); } - protected void configureClasspath() throws CantRunException { + protected void configureClasspath(JavaParameters javaParameters) throws CantRunException { final String jreHome = myConfiguration.isAlternativeJrePathEnabled() ? myConfiguration.getAlternativeJrePath() : null; final Module module = myConfiguration.getConfigurationModule().getModule(); if (module != null) { - JavaParametersUtil.configureModule(module, myJavaParameters, JavaParameters.JDK_AND_CLASSES_AND_TESTS, jreHome); + JavaParametersUtil.configureModule(module, javaParameters, JavaParameters.JDK_AND_CLASSES_AND_TESTS, jreHome); } else { JavaParametersUtil - .configureProject(myConfiguration.getProject(), myJavaParameters, JavaParameters.JDK_AND_CLASSES_AND_TESTS, jreHome); + .configureProject(myConfiguration.getProject(), javaParameters, JavaParameters.JDK_AND_CLASSES_AND_TESTS, jreHome); } } diff --git a/plugins/testng/src/com/theoryinpractice/testng/configuration/SearchingForTestsTask.java b/plugins/testng/src/com/theoryinpractice/testng/configuration/SearchingForTestsTask.java index 3b3d1b5b95d0..edf561ea8d25 100644 --- a/plugins/testng/src/com/theoryinpractice/testng/configuration/SearchingForTestsTask.java +++ b/plugins/testng/src/com/theoryinpractice/testng/configuration/SearchingForTestsTask.java @@ -22,6 +22,7 @@ package com.theoryinpractice.testng.configuration; import com.intellij.codeInsight.AnnotationUtil; import com.intellij.execution.CantRunException; +import com.intellij.execution.ExecutionException; import com.intellij.execution.testframework.SearchForTestsTask; import com.intellij.execution.testframework.TestSearchScope; import com.intellij.openapi.application.ApplicationManager; @@ -114,7 +115,7 @@ public class SearchingForTestsTask extends SearchForTestsTask { if (!Registry.is("testng_sm_runner")) myClient.startListening(myConfig); } - protected void logCantRunException(CantRunException e) { + protected void logCantRunException(ExecutionException e) { try { final String message = "CantRunException" + e.getMessage() + "\n"; FileUtil.writeToFile(myTempFile, message.getBytes()); diff --git a/plugins/testng/src/com/theoryinpractice/testng/configuration/TestNGRunnableState.java b/plugins/testng/src/com/theoryinpractice/testng/configuration/TestNGRunnableState.java index 510c8e3f90fe..47bd0c3f2271 100644 --- a/plugins/testng/src/com/theoryinpractice/testng/configuration/TestNGRunnableState.java +++ b/plugins/testng/src/com/theoryinpractice/testng/configuration/TestNGRunnableState.java @@ -26,10 +26,12 @@ import com.intellij.execution.process.ProcessEvent; import com.intellij.execution.runners.ExecutionEnvironment; import com.intellij.execution.runners.ProgramRunner; import com.intellij.execution.testframework.*; +import com.intellij.execution.testframework.actions.AbstractRerunFailedTestsAction; import com.intellij.execution.testframework.sm.SMTestRunnerConnectionUtil; import com.intellij.execution.testframework.sm.runner.SMTRunnerConsoleProperties; import com.intellij.execution.testframework.sm.runner.ui.SMTRunnerConsoleView; import com.intellij.execution.testframework.ui.BaseTestsOutputConsoleView; +import com.intellij.execution.ui.ConsoleView; import com.intellij.execution.ui.ConsoleViewContentType; import com.intellij.execution.util.JavaParametersUtil; import com.intellij.openapi.diagnostic.Logger; @@ -75,7 +77,7 @@ import java.net.InetAddress; import java.net.ServerSocket; import java.net.UnknownHostException; -public class TestNGRunnableState extends JavaCommandLineState { +public class TestNGRunnableState extends JavaTestFrameworkRunnableState { private static final Logger LOG = Logger.getInstance("TestNG Runner"); private static final String TESTNG_TEST_FRAMEWORK_NAME = "TestNG"; private final TestNGConfiguration config; @@ -110,12 +112,32 @@ public class TestNGRunnableState extends JavaCommandLineState { } } + @NotNull + @Override + protected OSProcessHandler startProcess() throws ExecutionException { + final OSProcessHandler handler = super.startProcess(); + final SearchingForTestsTask task = createSearchingForTestsTask(myServerSocket, config, myTempFile); + handler.addProcessListener(new ProcessAdapter() { + @Override + public void processTerminated(final ProcessEvent event) { + task.ensureFinished(); + } + + @Override + public void startNotified(final ProcessEvent event) { + task.startSearch(); + } + }); + + return handler; + } + @NotNull @Override public ExecutionResult execute(@NotNull final Executor executor, @NotNull final ProgramRunner runner) throws ExecutionException { final boolean smRunner = Registry.is("testng_sm_runner"); if (smRunner) { - return startSMRunner(executor); + return startSMRunner(executor, startProcess(), config, getEnvironment()); } OSProcessHandler processHandler = startProcess(); final TreeRootNode unboundOutputRoot = new TreeRootNode(); @@ -124,7 +146,6 @@ public class TestNGRunnableState extends JavaCommandLineState { unboundOutputRoot.setPrinter(console.getPrinter()); Disposer.register(console, unboundOutputRoot); JavaRunConfigurationExtensionManager.getInstance().attachExtensionsToProcess(config, processHandler, runnerSettings); - final SearchingForTestsTask task = createSearchingForTestsTask(myServerSocket, config, myTempFile); processHandler.addProcessListener(new ProcessAdapter() { private boolean myStarted = false; @@ -132,7 +153,6 @@ public class TestNGRunnableState extends JavaCommandLineState { public void processTerminated(final ProcessEvent event) { unboundOutputRoot.flush(); - task.ensureFinished(); } @Override @@ -143,7 +163,6 @@ public class TestNGRunnableState extends JavaCommandLineState { } client.prepareListening(listener, config.getProject(), port); myStarted = true; - task.startSearch(); } @Override @@ -190,49 +209,23 @@ public class TestNGRunnableState extends JavaCommandLineState { return result; } - private ExecutionResult startSMRunner(Executor executor) throws ExecutionException { - getJavaParameters().getVMParametersList().add("-Didea.testng.sm_runner"); - getJavaParameters().getClassPath().add(PathUtil.getJarPathForClass(ServiceMessageTypes.class)); + @NotNull + @Override + protected String getVMParameter() { + return "-Didea.testng.sm_runner"; + } - OSProcessHandler handler = startProcess(); - TestConsoleProperties testConsoleProperties = new SMTRunnerConsoleProperties(config, TESTNG_TEST_FRAMEWORK_NAME, executor); + @NotNull + @Override + protected String getFrameworkName() { + return TESTNG_TEST_FRAMEWORK_NAME; + } - testConsoleProperties.setIfUndefined(TestConsoleProperties.HIDE_PASSED_TESTS, false); - - final BaseTestsOutputConsoleView smtConsoleView = SMTestRunnerConnectionUtil.createConsoleWithCustomLocator( - TESTNG_TEST_FRAMEWORK_NAME, - testConsoleProperties, - getEnvironment(), null); - - - Disposer.register(getEnvironment().getProject(), smtConsoleView); - smtConsoleView.attachToProcess(handler); - final RerunFailedTestsAction rerunFailedTestsAction = new RerunFailedTestsAction(smtConsoleView, testConsoleProperties); - rerunFailedTestsAction.setModelProvider(new Getter() { - @Override - public TestFrameworkRunningModel get() { - return ((SMTRunnerConsoleView)smtConsoleView).getResultsViewer(); - } - }); - - final DefaultExecutionResult result = new DefaultExecutionResult(smtConsoleView, handler); - result.setRestartActions(rerunFailedTestsAction); - - JavaRunConfigurationExtensionManager.getInstance().attachExtensionsToProcess(config, handler, runnerSettings); - final SearchingForTestsTask task = createSearchingForTestsTask(myServerSocket, config, myTempFile); - handler.addProcessListener(new ProcessAdapter() { - @Override - public void processTerminated(final ProcessEvent event) { - task.ensureFinished(); - } - - @Override - public void startNotified(final ProcessEvent event) { - task.startSearch(); - } - }); - - return result; + @NotNull + @Override + protected AbstractRerunFailedTestsAction createRerunFailedTestsAction(TestConsoleProperties testConsoleProperties, + ConsoleView consoleView) { + return new RerunFailedTestsAction(consoleView, testConsoleProperties); } @Override