/** * Create a command line for launching. * * @param actualRun if true it'll make the variable substitution and start the listen connector in * the case of a debug session. * @return command line ready to be exec'd * @throws CoreException * @throws JDTNotAvailableException */ public String[] getCommandLine(boolean actualRun) throws CoreException, JDTNotAvailableException { List<String> cmdArgs = new ArrayList<String>(); if (isJython()) { // "java.exe" -classpath "C:\bin\jython21\jython.jar" org.python.util.jython script %ARGS% String javaLoc = JavaVmLocationFinder.findDefaultJavaExecutable().getAbsolutePath(); if (!InterpreterInfo.isJythonExecutable(interpreter.toOSString())) { throw new RuntimeException( "The jython jar must be specified as the interpreter to run. Found: " + interpreter); } cmdArgs.add(javaLoc); // some nice things on the classpath config: http://mindprod.com/jgloss/classpath.html cmdArgs.add("-classpath"); String cpath; // TODO: add some option in the project so that the user can choose to use the // classpath specified in the java project instead of the pythonpath itself // if (project.getNature(Constants.JAVA_NATURE) != null){ // cpath = getClasspath(JavaCore.create(project)); // } else { cpath = interpreter + SimpleRunner.getPythonPathSeparator() + pythonpathUsed; // } cmdArgs.add(cpath); cmdArgs.add( "-Dpython.path=" + pythonpathUsed); // will be added to the env variables in the run (check if this // works on all platforms...) addVmArgs(cmdArgs); if (isDebug) { // This was removed because it cannot be used. See: // http://bugs.jython.org/issue1438 // cmdArgs.add("-Dpython.security.respectJavaAccessibility=false"); cmdArgs.add("org.python.util.jython"); addDebugArgs(cmdArgs, "jython", actualRun); } else { cmdArgs.add("org.python.util.jython"); } } else { // python or iron python cmdArgs.add(interpreter.toOSString()); // Next option is for unbuffered stdout, otherwise Eclipse will not see any output until done cmdArgs.add("-u"); addVmArgs(cmdArgs); if (isDebug && isIronpython()) { addIronPythonDebugVmArgs(cmdArgs); } addDebugArgs(cmdArgs, "python", actualRun); } // Check if we should do code-coverage... boolean coverageRun = PyCoveragePreferences.getAllRunsDoCoverage(); if (coverageRun && isDebug) { if (actualRun) { RunInUiThread.async( new Runnable() { public void run() { PyDialogHelpers.openWarning( "Conflicting options: coverage with debug.", "Making a debug run with coverage enabled will not yield the expected results.\n\n" + "They'll conflict because both use the python tracing facility (i.e.: sys.settrace()).\n" + "\n" + "To debug a coverage run, do a regular run and use the remote debugger " + "(but note that the coverage will stop when it's enabled).\n" + "\n" + "Note: the run will be continued anyways."); } }); } } if (isUnittest()) { cmdArgs.add(getRunFilesScript()); } else { if (coverageRun) { // Separate support (unittest has the coverage support builtin). cmdArgs.add(getCoverageScript()); cmdArgs.add(PyCoverage.getCoverageFileLocation().getAbsolutePath()); cmdArgs.add("run"); cmdArgs.add("--source"); cmdArgs.add(PyCodeCoverageView.getChosenDir().getLocation().toOSString()); } } for (IPath p : resource) { cmdArgs.add(p.toOSString()); } if (!isUnittest()) { // The program arguments are not used when running a unittest (excluded from the tab group in // favor // of a way to overriding the default unittest arguments). String runArguments[] = null; if (actualRun && arguments != null) { String expanded = getStringSubstitution(PythonNature.getPythonNature(project)) .performStringSubstitution(arguments); runArguments = parseStringIntoList(expanded); } for (int i = 0; runArguments != null && i < runArguments.length; i++) { cmdArgs.add(runArguments[i]); } } else { // Last thing (first the files and last the special parameters the user passed -- i.e.: nose // parameters) addUnittestArgs(cmdArgs, actualRun, coverageRun); } String[] retVal = new String[cmdArgs.size()]; cmdArgs.toArray(retVal); if (actualRun) { CreatedCommandLineParams createdCommandLineParams = new CreatedCommandLineParams(retVal, coverageRun); // Provide a way for clients to alter the command line. List<Object> participants = ExtensionHelper.getParticipants(ExtensionHelper.PYDEV_COMMAND_LINE_PARTICIPANT); for (Object object : participants) { try { IPyCommandLineParticipant c = (IPyCommandLineParticipant) object; createdCommandLineParams = c.updateCommandLine(createdCommandLineParams); } catch (Exception e) { Log.log(e); } } retVal = createdCommandLineParams.cmdLine; PythonRunnerCallbacks.onCreatedCommandLine.call(createdCommandLineParams); } return retVal; }
public void testInterpreterInfoBuilder() throws Exception { Collection<String> pythonpath = new ArrayList<String>(); pythonpath.add(libDir.toString()); final InterpreterInfo info = new InterpreterInfo("2.6", TestDependent.PYTHON_EXE, pythonpath); IPreferenceStore preferences = new PreferenceStore(); final PythonInterpreterManager manager = new PythonInterpreterManager(preferences); PydevPlugin.setPythonInterpreterManager(manager); manager.setInfos(new IInterpreterInfo[] {info}, new HashSet<String>(), null); final AdditionalSystemInterpreterInfo additionalInfo = new AdditionalSystemInterpreterInfo(manager, info.getExecutableOrJar()); AdditionalSystemInterpreterInfo.setAdditionalSystemInfo( manager, info.getExecutableOrJar(), additionalInfo); // Don't load it (otherwise it'll get the 'proper' info). // AdditionalSystemInterpreterInfo.loadAdditionalSystemInfo(manager, info.getExecutableOrJar()); final ISystemModulesManager modulesManager = info.getModulesManager(); assertEquals(0, modulesManager.getSize(false)); assertEquals(0, additionalInfo.getAllTokens().size()); InterpreterInfoBuilder builder = new InterpreterInfoBuilder(); builder.setInfo(info, 0); waitUntilCondition( new ICallback<String, Object>() { public String call(Object arg) { int size = modulesManager.getSize(false); if (size == 3) { return null; } return "Expected size = 3, found: " + size; } }); waitUntilCondition( new ICallback<String, Object>() { public String call(Object arg) { try { AbstractAdditionalDependencyInfo additionalSystemInfo = AdditionalSystemInterpreterInfo.getAdditionalSystemInfo( manager, manager.getInterpreterInfos()[0].getExecutableOrJar()); if (additionalInfo != additionalSystemInfo) { throw new RuntimeException("Expecting it to be the same instance."); } } catch (MisconfigurationException e) { throw new RuntimeException(e); } Collection<IInfo> allTokens = additionalInfo.getAllTokens(); int size = allTokens.size(); if (size == 3) { return null; } FastStringBuffer buf = new FastStringBuffer(); for (IInfo i : allTokens) { buf.append(i.toString()); } return "Expected size = 3, found: " + size + "\nTokens: " + buf; } }); }