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 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))); }
protected void appendForkInfo(Executor executor) throws ExecutionException { final String forkMode = getForkMode(); if (Comparing.strEqual(forkMode, "none")) { if (forkPerModule()) { if (isExecutorDisabledInForkedMode()) { final String actionName = UIUtil.removeMnemonic(executor.getStartActionText()); throw new CantRunException( "'" + actionName + "' is disabled when per-module working directory is configured.<br/>" + "Please specify single working directory, or change test scope to single module."); } } else { return; } } else if (isExecutorDisabledInForkedMode()) { final String actionName = executor.getActionName(); throw new CantRunException( actionName + " is disabled in fork mode.<br/>Please change fork mode to <none> to " + actionName.toLowerCase(Locale.ENGLISH) + "."); } 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, CharsetToolkit.UTF8); try { if (JdkUtil.useDynamicClasspath(getConfiguration().getProject())) { String classpath = PathUtil.getJarPathForClass(CommandLineWrapper.class); final String utilRtPath = PathUtil.getJarPathForClass(StringUtilRt.class); if (!classpath.equals(utilRtPath)) { classpath += File.pathSeparator + utilRtPath; } writer.println(classpath); } else { writer.println(""); } writer.println(((JavaSdkType) jdk.getSdkType()).getVMExecutablePath(jdk)); for (String vmParameter : javaParameters.getVMParametersList().getList()) { writer.println(vmParameter); } } finally { writer.close(); } passForkMode(forkMode, tempFile); } catch (Exception e) { LOG.error(e); } }
public void testJarParameter() throws CantRunException { JavaParameters javaParameters = new JavaParameters(); javaParameters.setJdk(getProjectJDK()); javaParameters.setJarPath("my-jar-file.jar"); String commandLineString = CommandLineBuilder.createFromJavaParameters(javaParameters).getCommandLineString(); assertTrue(commandLineString, commandLineString.contains("-jar my-jar-file.jar")); }
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()); } }
public static void addJavaHome(@NotNull JavaParameters params, @NotNull Module module) { final Sdk sdk = ModuleUtilCore.getSdk(module, JavaModuleExtensionImpl.class); if (sdk != null && sdk.getSdkType() instanceof JavaSdkType) { String path = StringUtil.trimEnd(sdk.getHomePath(), File.separator); if (StringUtil.isNotEmpty(path)) { Map<String, String> env = params.getEnv(); if (env == null) { env = new HashMap<String, String>(); params.setEnv(env); } env.put("JAVA_HOME", FileUtil.toSystemDependentName(path)); } } }
public static JavaParameters createJavaParametersWithSdk(@Nullable Module module) { JavaParameters params = new JavaParameters(); params.setCharset(null); if (module != null) { final Sdk sdk = ModuleRootManager.getInstance(module).getSdk(); if (sdk != null && sdk.getSdkType() instanceof JavaSdkType) { params.setJdk(sdk); } } if (params.getJdk() == null) { params.setJdk(new SimpleJavaSdkType().createJdk("tmp", SystemProperties.getJavaHome())); } return params; }
protected void createServerSocket(JavaParameters javaParameters) { try { myServerSocket = new ServerSocket(0, 0, InetAddress.getByName("127.0.0.1")); javaParameters.getProgramParametersList().add("-socket" + myServerSocket.getLocalPort()); } catch (IOException e) { LOG.error(e); } }
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); }
protected void createTempFiles(JavaParameters javaParameters) { try { myTempFile = FileUtil.createTempFile("idea_" + getFrameworkId(), ".tmp"); myTempFile.deleteOnExit(); passTempFile(javaParameters.getProgramParametersList(), myTempFile.getAbsolutePath()); } catch (IOException e) { LOG.error(e); } }
public static void addJavaHome(@NotNull JavaParameters params, @NotNull Module module) { final Sdk sdk = ModuleRootManager.getInstance(module).getSdk(); if (sdk != null && sdk.getSdkType() instanceof JavaSdkType) { String path = StringUtil.trimEnd(sdk.getHomePath(), File.separator); if (StringUtil.isNotEmpty(path)) { params.addEnv("JAVA_HOME", FileUtil.toSystemDependentName(path)); } } }
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 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; }
private static List<String> extractAllInPackageTests( JavaParameters parameters, PsiPackage psiPackage) throws IOException { String filePath = ContainerUtil.find( parameters.getProgramParametersList().getArray(), value -> StringUtil.startsWithChar(value, '@') && !StringUtil.startsWith(value, "@w@")) .substring(1); List<String> lines = readLinesFrom(new File(filePath)); assertEquals(psiPackage.getQualifiedName(), lines.get(0)); // lines.remove(0); lines.remove(0); return lines; }
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 testRunningJUnit() throws ExecutionException { PsiClass testA = findTestA(getModule1()); JUnitConfiguration configuration = createConfiguration(testA); JavaParameters parameters = checkCanRun(configuration); assertEmpty(parameters.getVMParametersList().getList()); final SegmentedOutputStream notifications = new SegmentedOutputStream(System.out); assertTrue( JUnitStarter.checkVersion( parameters.getProgramParametersList().getArray(), new PrintStream(notifications))); assertTrue(parameters.getProgramParametersList().getList().contains(testA.getQualifiedName())); assertEquals(JUnitStarter.class.getName(), parameters.getMainClass()); assertEquals(myJdk.getHomeDirectory().getPresentableUrl(), parameters.getJdkPath()); }
protected DebuggerSession createRemoteProcess( final int transport, final boolean serverMode, JavaParameters javaParameters) throws ExecutionException, InterruptedException, InvocationTargetException { boolean useSockets = transport == DebuggerSettings.SOCKET_TRANSPORT; RemoteConnection remoteConnection = new RemoteConnection(useSockets, "127.0.0.1", String.valueOf(DEFAULT_ADDRESS), serverMode); String launchCommandLine = remoteConnection.getLaunchCommandLine(); launchCommandLine = StringUtil.replace(launchCommandLine, RemoteConnection.ONTHROW, ""); launchCommandLine = StringUtil.replace(launchCommandLine, RemoteConnection.ONUNCAUGHT, ""); launchCommandLine = StringUtil.replace(launchCommandLine, "suspend=n", "suspend=y"); println(launchCommandLine, ProcessOutputTypes.SYSTEM); for (StringTokenizer tokenizer = new StringTokenizer(launchCommandLine); tokenizer.hasMoreTokens(); ) { String token = tokenizer.nextToken(); javaParameters.getVMParametersList().add(token); } GeneralCommandLine commandLine = CommandLineBuilder.createFromJavaParameters(javaParameters); DebuggerSession debuggerSession; if (serverMode) { debuggerSession = attachVM(remoteConnection, false); commandLine.createProcess(); } else { commandLine.createProcess(); debuggerSession = attachVM(remoteConnection, true); } ProcessHandler processHandler = debuggerSession.getProcess().getProcessHandler(); DebugProcessImpl process = (DebugProcessImpl) DebuggerManagerEx.getInstanceEx(myProject).getDebugProcess(processHandler); assertNotNull(process); return debuggerSession; }
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)); } } }
protected <T> void addClassesListToJavaParameters( Collection<? extends T> elements, Function<T, String> nameFunction, String packageName, boolean createTempFile, boolean junit4) { try { if (createTempFile) { myTempFile = FileUtil.createTempFile("idea_junit", ".tmp"); myTempFile.deleteOnExit(); myJavaParameters.getProgramParametersList().add("@" + myTempFile.getAbsolutePath()); } final PrintWriter writer = new PrintWriter(myTempFile, "UTF-8"); try { writer.println(packageName); final List<String> testNames = new ArrayList<String>(); for (final T element : elements) { final String name = nameFunction.fun(element); if (name == null) { LOG.error("invalid element " + element); return; } testNames.add(name); } Collections.sort(testNames); // sort tests in FQN order for (String testName : testNames) { writer.println(testName); } } finally { writer.close(); } } catch (IOException e) { LOG.error(e); } }
protected DebuggerSession createLocalSession(final JavaParameters javaParameters) throws ExecutionException, InterruptedException { createBreakpoints(javaParameters.getMainClass()); DebuggerSettings.getInstance().DEBUGGER_TRANSPORT = DebuggerSettings.SOCKET_TRANSPORT; GenericDebuggerRunnerSettings debuggerRunnerSettings = new GenericDebuggerRunnerSettings(); debuggerRunnerSettings.LOCAL = true; final RemoteConnection debugParameters = DebuggerManagerImpl.createDebugParameters(javaParameters, debuggerRunnerSettings, false); ExecutionEnvironment environment = new ExecutionEnvironmentBuilder(myProject, DefaultDebugExecutor.getDebugExecutorInstance()) .runnerSettings(debuggerRunnerSettings) .runProfile(new MockConfiguration()) .build(); final JavaCommandLineState javaCommandLineState = new JavaCommandLineState(environment) { @Override protected JavaParameters createJavaParameters() { return javaParameters; } @Override protected GeneralCommandLine createCommandLine() throws ExecutionException { return CommandLineBuilder.createFromJavaParameters(getJavaParameters()); } }; ApplicationManager.getApplication() .invokeAndWait( () -> { try { myDebuggerSession = DebuggerManagerEx.getInstanceEx(myProject) .attachVirtualMachine( new DefaultDebugEnvironment( new ExecutionEnvironmentBuilder( myProject, DefaultDebugExecutor.getDebugExecutorInstance()) .runProfile(new MockConfiguration()) .build(), javaCommandLineState, debugParameters, false)); XDebuggerManager.getInstance(myProject) .startSession( javaCommandLineState.getEnvironment(), new XDebugProcessStarter() { @Override @NotNull public XDebugProcess start(@NotNull XDebugSession session) { return JavaDebugProcess.create(session, myDebuggerSession); } }); } catch (ExecutionException e) { LOG.error(e); } }); myDebugProcess = myDebuggerSession.getProcess(); myDebugProcess.addProcessListener( new ProcessAdapter() { @Override public void onTextAvailable(ProcessEvent event, Key outputType) { print(event.getText(), outputType); } }); assertNotNull(myDebuggerSession); assertNotNull(myDebugProcess); return myDebuggerSession; }
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 DebuggerSession createLocalProcess(int transport, final JavaParameters javaParameters) throws ExecutionException, InterruptedException, InvocationTargetException { createBreakpoints(javaParameters.getMainClass()); final DebuggerSession[] debuggerSession = new DebuggerSession[] {null}; DebuggerSettings.getInstance().DEBUGGER_TRANSPORT = transport; GenericDebuggerRunnerSettings debuggerRunnerSettings = new GenericDebuggerRunnerSettings(); debuggerRunnerSettings.LOCAL = true; debuggerRunnerSettings.setDebugPort(String.valueOf(DEFAULT_ADDRESS)); ExecutionEnvironment environment = new ExecutionEnvironmentBuilder(myProject, DefaultDebugExecutor.getDebugExecutorInstance()) .runnerSettings(debuggerRunnerSettings) .runProfile(new MockConfiguration()) .build(); final JavaCommandLineState javaCommandLineState = new JavaCommandLineState(environment) { @Override protected JavaParameters createJavaParameters() { return javaParameters; } @Override protected GeneralCommandLine createCommandLine() throws ExecutionException { return CommandLineBuilder.createFromJavaParameters(getJavaParameters()); } }; final RemoteConnection debugParameters = DebuggerManagerImpl.createDebugParameters( javaCommandLineState.getJavaParameters(), debuggerRunnerSettings, true); UIUtil.invokeAndWaitIfNeeded( new Runnable() { @Override public void run() { try { debuggerSession[0] = attachVirtualMachine( javaCommandLineState, javaCommandLineState.getEnvironment(), debugParameters, false); } catch (ExecutionException e) { fail(e.getMessage()); } } }); final ProcessHandler processHandler = debuggerSession[0].getProcess().getProcessHandler(); debuggerSession[0] .getProcess() .addProcessListener( new ProcessAdapter() { @Override public void onTextAvailable(ProcessEvent event, Key outputType) { print(event.getText(), outputType); } }); DebugProcessImpl process = (DebugProcessImpl) DebuggerManagerEx.getInstanceEx(myProject).getDebugProcess(processHandler); assertNotNull(process); return debuggerSession[0]; }
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; }