public void testTestClassPathWhenRunningConfigurations() throws IOException, ExecutionException {
addModule("module4", false);
Module module4 = getModule4();
assignJdk(module4);
addSourcePath(module4, "testSrc", true);
addSourcePath(module4, "src", false);
String output = setCompilerOutput(module4, "classes", false);
String testOuput = setCompilerOutput(module4, "testClasses", true);
ApplicationConfiguration applicationConfiguration =
createConfiguration(findClass(module4, "Application"));
JavaParameters parameters = checkCanRun(applicationConfiguration);
String classPath = parameters.getClassPath().getPathsString();
checkDoesNotContain(classPath, testOuput);
checkContains(classPath, output);
JUnitConfiguration junitConfiguration =
createJUnitConfiguration(
findClass(module4, "TestApplication"),
TestClassConfigurationProducer.class,
new MapDataContext());
parameters = checkCanRun(junitConfiguration);
classPath = parameters.getClassPath().getPathsString();
checkContains(classPath, testOuput);
checkContains(classPath, output);
applicationConfiguration.MAIN_CLASS_NAME =
junitConfiguration.getPersistentData().getMainClassName();
classPath = checkCanRun(applicationConfiguration).getClassPath().getPathsString();
checkContains(classPath, testOuput);
checkContains(classPath, output);
}
public void testClasspath() throws CantRunException {
JavaParameters javaParameters;
String commandLineString;
javaParameters = new JavaParameters();
final Sdk internalJdk = JavaAwareProjectJdkTableImpl.getInstanceEx().getInternalJdk();
javaParameters.setJdk(internalJdk);
javaParameters.getClassPath().add("my-jar-file.jar");
javaParameters.setMainClass("Main");
commandLineString =
CommandLineBuilder.createFromJavaParameters(javaParameters).getCommandLineString();
assertTrue(containsClassPath(commandLineString));
javaParameters = new JavaParameters();
javaParameters.setJdk(internalJdk);
javaParameters.getClassPath().add("my-jar-file.jar");
javaParameters.setMainClass("Main");
javaParameters.getVMParametersList().add("-cp");
javaParameters.getVMParametersList().add("..");
commandLineString =
CommandLineBuilder.createFromJavaParameters(javaParameters).getCommandLineString();
commandLineString = removeClassPath(commandLineString, "-cp ..");
assertTrue(!containsClassPath(commandLineString));
javaParameters = new JavaParameters();
javaParameters.setJdk(internalJdk);
javaParameters.getClassPath().add("my-jar-file.jar");
javaParameters.setMainClass("Main");
javaParameters.getVMParametersList().add("-classpath");
javaParameters.getVMParametersList().add("..");
commandLineString =
CommandLineBuilder.createFromJavaParameters(javaParameters).getCommandLineString();
commandLineString = removeClassPath(commandLineString, "-classpath ..");
assertTrue(!containsClassPath(commandLineString));
}
protected void initialize() throws ExecutionException {
JavaParametersUtil.configureConfiguration(myJavaParameters, myConfiguration);
myJavaParameters.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(myProject).getProjectSdk());
}
myJavaParameters.getClassPath().add(JavaSdkUtil.getIdeaRtJarPath());
myJavaParameters.getClassPath().add(PathUtil.getJarPathForClass(JUnitStarter.class));
myJavaParameters
.getProgramParametersList()
.add(JUnitStarter.IDE_VERSION + JUnitStarter.VERSION);
for (RunConfigurationExtension ext :
Extensions.getExtensions(RunConfigurationExtension.EP_NAME)) {
ext.updateJavaParameters(myConfiguration, myJavaParameters, getRunnerSettings());
}
final Object[] listeners = Extensions.getExtensions(IDEAJUnitListener.EP_NAME);
final StringBuilder buf = new StringBuilder();
for (final Object listener : listeners) {
boolean enabled = true;
for (RunConfigurationExtension ext :
Extensions.getExtensions(RunConfigurationExtension.EP_NAME)) {
if (ext.isListenerDisabled(myConfiguration, listener, getRunnerSettings())) {
enabled = false;
break;
}
}
if (enabled) {
final Class classListener = listener.getClass();
buf.append(classListener.getName()).append("\n");
myJavaParameters.getClassPath().add(PathUtil.getJarPathForClass(classListener));
}
}
if (buf.length() > 0) {
try {
myListenersFile = FileUtil.createTempFile("junit_listeners_", "");
myListenersFile.deleteOnExit();
myJavaParameters.getProgramParametersList().add("@@" + myListenersFile.getPath());
FileUtil.writeToFile(myListenersFile, buf.toString().getBytes());
} catch (IOException e) {
LOG.error(e);
}
}
}
public void testAllInPackageForProject() throws IOException, ExecutionException {
// module1 -> module2 -> module3
// module5
addModule("module5");
addDependency(getModule1(), getModule2());
addDependency(getModule2(), getModule3());
String[][] outputs = new String[4][];
for (int i = 0; i < 4; i++) {
outputs[i] = addOutputs(getModule(i), i + 1);
}
PsiPackage defaultPackage = JavaPsiFacade.getInstance(myProject).findPackage("");
JUnitConfiguration configuration =
createJUnitConfiguration(
defaultPackage, AllInPackageConfigurationProducer.class, new MapDataContext());
configuration.getPersistentData().setScope(TestSearchScope.WHOLE_PROJECT);
JavaParameters javaParameters = checkCanRun(configuration);
String classPath = javaParameters.getClassPath().getPathsString();
assertEquals(-1, classPath.indexOf(JarFileSystem.PROTOCOL_PREFIX));
assertEquals(-1, classPath.indexOf(LocalFileSystem.PROTOCOL_PREFIX));
for (int i = 0; i < 4; i++) {
checkContains(classPath, outputs[i][0]);
checkContains(classPath, outputs[i][1]);
}
}
public void testClasspathConfiguration() throws CantRunException {
JavaParameters parameters = new JavaParameters();
RunConfigurationModule module = new JavaRunConfigurationModule(myProject, false);
Module module1 = getModule1();
Module module2 = getModule2();
addDependency(module1, module2);
Module module3 = getModule3();
addDependency(module2, module3);
addDependency(module1, module3);
addOutputs(module1, 1);
addOutputs(module2, 2);
addOutputs(module3, 3);
module.setModule(module1);
parameters.configureByModule(module.getModule(), JavaParameters.JDK_AND_CLASSES_AND_TESTS);
ArrayList<String> classPath = new ArrayList<>();
StringTokenizer tokenizer =
new StringTokenizer(parameters.getClassPath().getPathsString(), File.pathSeparator);
while (tokenizer.hasMoreTokens()) {
String token = tokenizer.nextToken();
classPath.add(token);
}
CHECK.singleOccurence(classPath, getOutput(module1, false));
CHECK.singleOccurence(classPath, getOutput(module1, false));
CHECK.singleOccurence(classPath, getOutput(module1, true));
CHECK.singleOccurence(classPath, getOutput(module2, false));
CHECK.singleOccurence(classPath, getOutput(module2, true));
CHECK.singleOccurence(classPath, getOutput(module3, false));
CHECK.singleOccurence(classPath, getOutput(module3, true));
CHECK.singleOccurence(classPath, getFSPath(findFile(MOCK_JUNIT)));
}
public void testSameTestAndCommonOutput() throws IOException, ExecutionException {
addModule("module4", false);
Module module = getModule4();
assignJdk(module);
addSourcePath(module, "src", false);
addSourcePath(module, "testSrc", false);
String output = setCompilerOutput(module, "classes", false);
assertEquals(output, setCompilerOutput(module, "classes", true));
RunConfiguration configuration = createConfiguration(findClass(module, "Application"));
JavaParameters javaParameters = checkCanRun(configuration);
checkContains(javaParameters.getClassPath().getPathsString(), output);
configuration = createConfiguration(findClass(module, "TestApplication"));
javaParameters = checkCanRun(configuration);
checkContains(javaParameters.getClassPath().getPathsString(), output);
}
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);
}
}
protected void collectListeners(
JavaParameters javaParameters, StringBuilder buf, String epName, String delimiter) {
final T configuration = getConfiguration();
final Object[] listeners = Extensions.getExtensions(epName);
for (final Object listener : listeners) {
boolean enabled = true;
for (RunConfigurationExtension ext :
Extensions.getExtensions(RunConfigurationExtension.EP_NAME)) {
if (ext.isListenerDisabled(configuration, listener, getRunnerSettings())) {
enabled = false;
break;
}
}
if (enabled) {
if (buf.length() > 0) buf.append(delimiter);
final Class classListener = listener.getClass();
buf.append(classListener.getName());
javaParameters.getClassPath().add(PathUtil.getJarPathForClass(classListener));
}
}
}
@Override
protected JavaParameters createJavaParameters() throws ExecutionException {
final JavaParameters javaParameters = new JavaParameters();
final Module module = getConfiguration().getConfigurationModule().getModule();
Project project = getConfiguration().getProject();
Sdk jdk =
module == null
? ProjectRootManager.getInstance(project).getProjectSdk()
: ModuleRootManager.getInstance(module).getSdk();
javaParameters.setJdk(jdk);
final Object[] patchers = Extensions.getExtensions(ExtensionPoints.JUNIT_PATCHER);
for (Object patcher : patchers) {
((JUnitPatcher) patcher).patchJavaParameters(module, javaParameters);
}
// Append coverage parameters if appropriate
for (RunConfigurationExtension ext :
Extensions.getExtensions(RunConfigurationExtension.EP_NAME)) {
ext.updateJavaParameters(getConfiguration(), javaParameters, getRunnerSettings());
}
final String parameters = getConfiguration().getProgramParameters();
getConfiguration().setProgramParameters(null);
try {
JavaParametersUtil.configureConfiguration(javaParameters, getConfiguration());
} finally {
getConfiguration().setProgramParameters(parameters);
}
javaParameters.getClassPath().addFirst(JavaSdkUtil.getIdeaRtJarPath());
configureClasspath(javaParameters);
if (!StringUtil.isEmptyOrSpaces(parameters)) {
javaParameters.getProgramParametersList().add("@name" + parameters);
}
return javaParameters;
}
protected JavaParameters createJavaParameters() throws ExecutionException {
log.debug("createJavaParameters");
SubstepsRunConfiguration runConfig =
(SubstepsRunConfiguration) this.getEnvironment().getRunProfile();
SubstepsRunnerConfigurationModel model = runConfig.getModel();
JavaParameters params = model.getJavaParameters();
params.setWorkingDirectory(model.getWorkingDir());
if (params.getJdk() == null) {
log.debug("params on the jdk is null");
params.setJdk(
JavaSdkImpl.getInstance().createJdk(model.getVersionString(), model.getHomePath()));
params.getClassPath().add(model.getClassPathString());
}
params.getProgramParametersList().add("prog-args-env", "prg-localhost");
ParametersList vmParametersList = params.getVMParametersList();
vmParametersList.addParametersString("-Dfile.encoding=UTF-8");
vmParametersList.addParametersString("-Dcom.sun.management.jmxremote.port=" + jmxPort);
vmParametersList.addParametersString("-Dcom.sun.management.jmxremote.authenticate=false");
vmParametersList.addParametersString("-Dcom.sun.management.jmxremote.ssl=false");
vmParametersList.addParametersString("-Djava.rmi.server.hostname=localhost");
// String rmiClasspathString = "\"file://" +
// model.getClassPathString().replaceAll(File.pathSeparator, " file://") + "\"";
// log.debug("rmi classpath: " + rmiClasspathString);
// vmParametersList.addParametersString("-Djava.rmi.server.codebase=" +
// rmiClasspathString);
vmParametersList.addParametersString("-Dsun.io.serialization.extendedDebugInfo=true");
// System.setProperty("java.rmi.server.codebase", rmiClasspathString);
// createServerSocket(params);
//
//
// if (myServerSocket != null) {
// params.getProgramParametersList().add(ForkedDebuggerHelper.DEBUG_SOCKET +
// myServerSocket.getLocalPort());
// }
//
log.debug(
"launching substeps runner with classpath: "
+ params.getClassPath().getPathsString()
+ "\njvm info: "
+ model.getHomePath()
+ " version: "
+ model.getVersionString());
return params;
}
