Example #1
0
 public static IVMInstall getVMInstall(ILaunchConfiguration configuration) throws CoreException {
   String jre =
       configuration.getAttribute(
           IJavaLaunchConfigurationConstants.ATTR_JRE_CONTAINER_PATH, (String) null);
   IVMInstall vm = null;
   if (jre == null) {
     String name = configuration.getAttribute(IPDELauncherConstants.VMINSTALL, (String) null);
     if (name == null) {
       name = getDefaultVMInstallName(configuration);
     }
     vm = getVMInstall(name);
     if (vm == null) {
       throw new CoreException(
           LauncherUtils.createErrorStatus(
               NLS.bind(MDEMessages.WorkbenchLauncherConfigurationDelegate_noJRE, name)));
     }
   } else {
     IPath jrePath = Path.fromPortableString(jre);
     vm = JavaRuntime.getVMInstall(jrePath);
     if (vm == null) {
       String id = JavaRuntime.getExecutionEnvironmentId(jrePath);
       if (id == null) {
         String name = JavaRuntime.getVMInstallName(jrePath);
         throw new CoreException(
             LauncherUtils.createErrorStatus(
                 NLS.bind(MDEMessages.WorkbenchLauncherConfigurationDelegate_noJRE, name)));
       }
       throw new CoreException(
           LauncherUtils.createErrorStatus(NLS.bind(MDEMessages.VMHelper_cannotFindExecEnv, id)));
     }
   }
   return vm;
 }
Example #2
0
 private void addToolsJar(ILaunchConfiguration configuration, List rtes, String path) {
   IRuntimeClasspathEntry tools = getToolsJar(configuration);
   if (tools == null) {
     if (path != null) {
       // use the global entry
       rtes.add(JavaRuntime.newArchiveRuntimeClasspathEntry(new Path(path)));
     } else {
       // use the default vm install to try to find a tools.jar
       IVMInstall install = JavaRuntime.getDefaultVMInstall();
       if (install != null) {
         IAntClasspathEntry entry =
             AntCorePlugin.getPlugin()
                 .getPreferences()
                 .getToolsJarEntry(new Path(install.getInstallLocation().getAbsolutePath()));
         if (entry != null) {
           rtes.add(
               JavaRuntime.newArchiveRuntimeClasspathEntry(
                   new Path(entry.getEntryURL().getPath())));
         }
       }
     }
   } else {
     rtes.add(tools);
   }
 }
  @Override
  protected void addUserEntries(ClasspathModel model) throws CoreException {

    if (supportLibs != null && supportLibs.length > 0) {
      for (URL supportLib : supportLibs) {
        model.addEntry(
            ClasspathModel.USER,
            JavaRuntime.newStringVariableClasspathEntry(
                new Path(supportLib.getPath()).toOSString()));
      }
    }

    for (IPath libRoot : libRoots) {
      File[] libFiles =
          libRoot
              .toFile()
              .listFiles(
                  new FilenameFilter() {

                    public boolean accept(File dir, String name) {
                      return name.endsWith(".jar");
                    }
                  });

      if (!CoreUtil.isNullOrEmpty(libFiles)) {

        for (File libFile : libFiles) {
          model.addEntry(
              ClasspathModel.USER,
              JavaRuntime.newStringVariableClasspathEntry(libFile.getAbsolutePath()));
        }
      }
    }

    for (String portalLib : portalLibs) {
      model.addEntry(
          ClasspathModel.USER,
          JavaRuntime.newStringVariableClasspathEntry(
              portalDir.append("WEB-INF/lib").append(portalLib).toOSString()));
    }

    if (userLibs != null) {
      for (String userLib : userLibs) {
        model.addEntry(
            ClasspathModel.USER,
            JavaRuntime.newStringVariableClasspathEntry(
                portalDir.append("WEB-INF/lib").append(userLib).toOSString()));
      }
    } else {
      for (String jarFile : this.portalDir.append("WEB-INF/lib").toFile().list()) {
        if (jarFile.endsWith(".jar")) {
          model.addEntry(
              ClasspathModel.USER,
              JavaRuntime.newStringVariableClasspathEntry(
                  portalDir.append("WEB-INF/lib").append(jarFile).toOSString()));
        }
      }
    }
  }
 public void testArchiveLocationMemento() throws Exception {
   IVMInstall vm = JavaRuntime.getDefaultVMInstall();
   IJavaSourceLocation location =
       new ArchiveSourceLocation(
           JavaRuntime.getLibraryLocations(vm)[0].getSystemLibraryPath().toOSString(), null);
   String memento = location.getMemento();
   IJavaSourceLocation restored = new ArchiveSourceLocation();
   restored.initializeFrom(memento);
   assertEquals("archive locations should be equal", location, restored);
 }
Example #5
0
  /**
   * @return the resolved classpath for the launch configuration. All entries, not just user
   *     entries, are returned.
   * @throws CoreException
   */
  public static String[] resolveClasspath(ILaunchConfiguration config) throws CoreException {
    IRuntimeClasspathEntry[] entries =
        JavaRuntime.resolveRuntimeClasspath(
            JavaRuntime.computeUnresolvedRuntimeClasspath(config), config);

    String[] paths = new String[entries.length];
    for (int i = 0; i < entries.length; i++) {
      paths[i] = entries[i].getLocation();
    }
    return paths;
  }
Example #6
0
 private void addSWTJars(List rtes) {
   if (fgSWTEntries == null) {
     fgSWTEntries = new ArrayList();
     Bundle bundle = Platform.getBundle("org.eclipse.swt"); // $NON-NLS-1$
     BundleDescription description =
         Platform.getPlatformAdmin().getState(false).getBundle(bundle.getBundleId());
     BundleDescription[] fragments = description.getFragments();
     for (int i = 0; i < fragments.length; i++) {
       Bundle fragmentBundle = Platform.getBundle(fragments[i].getName());
       URL bundleURL;
       try {
         bundleURL = FileLocator.resolve(fragmentBundle.getEntry("/")); // $NON-NLS-1$
       } catch (IOException e) {
         AntLaunching.log(e);
         continue;
       }
       String urlFileName = bundleURL.getFile();
       if (urlFileName.startsWith("file:")) { // $NON-NLS-1$
         try {
           urlFileName = new URL(urlFileName).getFile();
           if (urlFileName.endsWith("!/")) { // $NON-NLS-1$
             urlFileName = urlFileName.substring(0, urlFileName.length() - 2);
           }
         } catch (MalformedURLException e) {
           AntLaunching.log(e);
           continue;
         }
       }
       IPath fragmentPath = new Path(urlFileName);
       if (fragmentPath.getFileExtension() != null) { // JAR file
         fgSWTEntries.add(JavaRuntime.newArchiveRuntimeClasspathEntry(fragmentPath));
       } else { // folder
         File bundleFolder = fragmentPath.toFile();
         if (!bundleFolder.isDirectory()) {
           continue;
         }
         String[] names =
             bundleFolder.list(
                 new FilenameFilter() {
                   public boolean accept(File dir, String name) {
                     return name.endsWith(".jar"); // $NON-NLS-1$
                   }
                 });
         for (int j = 0; j < names.length; j++) {
           String jarName = names[j];
           fgSWTEntries.add(
               JavaRuntime.newArchiveRuntimeClasspathEntry(fragmentPath.append(jarName)));
         }
       }
     }
   }
   rtes.addAll(fgSWTEntries);
 }
Example #7
0
  /**
   * Get the default VMInstall name using the available info in the config, using the JavaProject if
   * available.
   *
   * @param configuration Launch configuration to check
   * @return name of the VMInstall
   * @throws CoreException thrown if there's a problem getting the VM name
   */
  public static String getDefaultVMInstallName(ILaunchConfiguration configuration)
      throws CoreException {
    IJavaProject javaProject = JavaRuntime.getJavaProject(configuration);
    IVMInstall vmInstall = null;
    if (javaProject != null) {
      vmInstall = JavaRuntime.getVMInstall(javaProject);
    }

    if (vmInstall != null) {
      return vmInstall.getName();
    }

    return VMUtil.getDefaultVMInstallName();
  }
Example #8
0
 @SuppressWarnings({"rawtypes", "unchecked", "resource"})
 @Override
 public Object createExecutableExtension(String propertyName) throws CoreException {
   try {
     String className = attributes.get(propertyName);
     IProject project = getProject();
     IJavaProject javaProject = JavaCore.create(project);
     String[] classPathEntries = JavaRuntime.computeDefaultRuntimeClassPath(javaProject);
     List<URL> urlList = new ArrayList<URL>();
     for (int i = 0; i < classPathEntries.length; i++) {
       String entry = classPathEntries[i];
       IPath path = new Path(entry);
       URL url = path.toFile().toURI().toURL();
       urlList.add(url);
     }
     ClassLoader parentClassLoader = javaProject.getClass().getClassLoader();
     URL[] urls = (URL[]) urlList.toArray(new URL[urlList.size()]);
     URLClassLoader classLoader = new URLClassLoader(urls, parentClassLoader);
     ClassLoader cl = classLoader.getParent();
     Class clazz = classLoader.loadClass(className);
     return clazz.getConstructor().newInstance();
   } catch (Exception ex) {
     ex.printStackTrace();
     throw new CoreException(new Status(IStatus.ERROR, Activator.PLUGIN_ID, ex.getMessage()));
   }
 }
 private void addSystemLibraries() throws JavaModelException {
   IClasspathEntry[] oldEntries = javaProject.getRawClasspath();
   IClasspathEntry[] newEntries = new IClasspathEntry[oldEntries.length + 1];
   System.arraycopy(oldEntries, 0, newEntries, 0, oldEntries.length);
   newEntries[oldEntries.length] = JavaRuntime.getDefaultJREContainerEntry();
   javaProject.setRawClasspath(newEntries, null);
 }
Example #10
0
  void doDebug(IProgressMonitor monitor) throws InterruptedException {
    monitor.setTaskName(
        "Connecting debugger "
            + session.getName()
            + " to "
            + session.getHost()
            + ":"
            + session.getJdb());

    Map<String, String> parameters = new HashMap<String, String>();
    parameters.put("hostname", session.getHost());
    parameters.put("port", session.getJdb() + "");
    parameters.put("timeout", session.getTimeout() + "");
    IVMConnector connector = JavaRuntime.getDefaultVMConnector();

    while (!monitor.isCanceled()) {

      try {
        connector.connect(parameters, monitor, launch);
        break;
      } catch (Exception e) {
        Thread.sleep(500);
      }
    }
  }
 /**
  * Create a new IVMInstall of DefaultVM install type.
  *
  * @return
  */
 public static IVMInstall createVM(File location) {
   @SuppressWarnings("restriction")
   IVMInstallType vmType = JavaRuntime.getVMInstallType(ID_STANDARD_VM_TYPE);
   IVMInstall vm = vmType.createVMInstall(createVMId(vmType));
   vm.setInstallLocation(location);
   return vm;
 }
 boolean isUnmodifiable(Object element) {
   if (element instanceof IVMInstall) {
     IVMInstall vm = (IVMInstall) element;
     return JavaRuntime.isContributedVMInstall(vm.getId());
   }
   return false;
 }
 /** Performs the edit VM action when the Edit... button is pressed */
 private void editVM() {
   IStructuredSelection selection = (IStructuredSelection) fVMList.getSelection();
   VMStandin vm = (VMStandin) selection.getFirstElement();
   if (vm == null) {
     return;
   }
   if (JavaRuntime.isContributedVMInstall(vm.getId())) {
     VMDetailsDialog dialog = new VMDetailsDialog(getShell(), vm);
     dialog.open();
   } else {
     EditVMInstallWizard wizard =
         new EditVMInstallWizard(vm, fVMs.toArray(new IVMInstall[fVMs.size()]));
     WizardDialog dialog = new WizardDialog(getShell(), wizard);
     if (dialog.open() == Window.OK) {
       VMStandin result = wizard.getResult();
       if (result != null) {
         // replace with the edited VM
         int index = fVMs.indexOf(vm);
         fVMs.remove(index);
         fVMs.add(index, result);
         fVMList.setSelection(new StructuredSelection(result));
         fVMList.refresh(true);
       }
     }
   }
 }
  ISourceContainer[] getSourceContainers(String location, String id) throws CoreException {

    ISourceContainer[] containers = (ISourceContainer[]) fSourceContainerMap.get(location);
    if (containers != null) {
      return containers;
    }

    ArrayList result = new ArrayList();
    ModelEntry entry = MonitorRegistry.findEntry(id);

    boolean match = false;

    IMonitorModelBase[] models = entry.getWorkspaceModels();
    for (int i = 0; i < models.length; i++) {
      if (isPerfectMatch(models[i], new Path(location))) {
        IResource resource = models[i].getUnderlyingResource();
        // if the plug-in matches a workspace model,
        // add the project and any libraries not coming via a container
        // to the list of source containers, in that order
        if (resource != null) {
          addProjectSourceContainers(resource.getProject(), result);
        }
        match = true;
        break;
      }
    }

    if (!match) {
      File file = new File(location);
      if (file.isFile()) {
        // in case of linked plug-in projects that map to an external JARd plug-in,
        // use source container that maps to the library in the linked project.
        ISourceContainer container = getArchiveSourceContainer(location);
        if (container != null) {
          containers = new ISourceContainer[] {container};
          fSourceContainerMap.put(location, containers);
          return containers;
        }
      }

      models = entry.getExternalModels();
      for (int i = 0; i < models.length; i++) {
        if (isPerfectMatch(models[i], new Path(location))) {
          // try all source zips found in the source code locations
          IClasspathEntry[] entries = MDEClasspathContainer.getExternalEntries(models[i]);
          for (int j = 0; j < entries.length; j++) {
            IRuntimeClasspathEntry rte = convertClasspathEntry(entries[j]);
            if (rte != null) result.add(rte);
          }
          break;
        }
      }
    }

    IRuntimeClasspathEntry[] entries =
        (IRuntimeClasspathEntry[]) result.toArray(new IRuntimeClasspathEntry[result.size()]);
    containers = JavaRuntime.getSourceContainers(entries);
    fSourceContainerMap.put(location, containers);
    return containers;
  }
 /**
  * Sets the workspace default VM on the given working copy
  *
  * @param config
  * @since 3.5
  */
 @SuppressWarnings("deprecation")
 public static void setVM(ILaunchConfigurationWorkingCopy config) {
   IVMInstall vm = JavaRuntime.getDefaultVMInstall();
   String vmName = vm.getName();
   String vmTypeID = vm.getVMInstallType().getId();
   config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_VM_INSTALL_NAME, vmName);
   config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_VM_INSTALL_TYPE, vmTypeID);
 }
 private String getDefaultJVMName() {
   IVMInstall install = JavaRuntime.getDefaultVMInstall();
   if (install != null) {
     return install.getName();
   } else {
     return Messages.NewBlackBerryProjectWizardPageOne_UnknownDefaultJRE_name;
   }
 }
  public static IVMInstall ensureJavaXXdefaultVM(String version) throws CoreException {
    // Before doing anything check the current default VM
    IVMInstall vm = JavaRuntime.getDefaultVMInstall();
    if (JavaUtils.isJavaXX(vm, version)) {
      return vm; // Done!
    }

    vm = getJavaXXVM(version);
    if (vm == null) {
      vm = JavaUtils.createVM(getVMLocation(version));
    }
    if (!JavaUtils.isJavaXX(vm, version)) {
      throw new Error("vm at " + vm.getInstallLocation() + " doesn't look like a Java " + version);
    }
    JavaRuntime.setDefaultVMInstall(vm, new NullProgressMonitor());
    return vm;
  }
Example #18
0
 public static IVMInstall getVMInstall(String name) {
   if (name != null) {
     IVMInstall[] installs = VMUtil.getAllVMInstances();
     for (int i = 0; i < installs.length; i++) {
       if (installs[i].getName().equals(name)) return installs[i];
     }
   }
   return JavaRuntime.getDefaultVMInstall();
 }
 /**
  * Returns the JRE container path
  *
  * @return The JRE container path
  */
 public IPath getJREContainerPath() {
   if (_useProjectRE.isSelected()) {
     int index = _RECombo.getSelectionIndex();
     if (index >= 0 && index < _installedVMs.length) { // paranoia
       return JavaRuntime.newJREContainerPath(_installedVMs[index]);
     }
   }
   return null;
 }
Example #20
0
 public static boolean isExistingVMName(String name) {
   for (IVMInstall vm :
       JavaRuntime.getVMInstallType(StandardVMType.ID_STANDARD_VM_TYPE).getVMInstalls()) {
     if (vm.getName().equals(name)) {
       return true;
     }
   }
   return false;
 }
Example #21
0
  /**
   * Returns the tools.jar to use for this launch configuration, or <code>null</code> if none.
   *
   * @param configuration configuration to resolve a tools.jar for
   * @return associated tools.jar archive, or <code>null</code>
   */
  private IRuntimeClasspathEntry getToolsJar(ILaunchConfiguration configuration) {
    try {
      IVMInstall install = JavaRuntime.computeVMInstall(configuration);
      if (install != null) {
        IAntClasspathEntry entry =
            AntCorePlugin.getPlugin()
                .getPreferences()
                .getToolsJarEntry(new Path(install.getInstallLocation().getAbsolutePath()));
        if (entry != null) {
          return JavaRuntime.newArchiveRuntimeClasspathEntry(
              new Path(entry.getEntryURL().getPath()));
        }
      }
    } catch (CoreException ce) {
      // likely dealing with a non-Java project
    }

    return null;
  }
 public static List<IVMInstall> getAllVMs() {
   List<IVMInstall> result = new ArrayList<IVMInstall>();
   IVMInstallType[] types = JavaRuntime.getVMInstallTypes();
   for (IVMInstallType type : types) {
     for (IVMInstall vm : type.getVMInstalls()) {
       result.add(vm);
     }
   }
   return result;
 }
  private static IPath[] getClasspath(ILaunchConfiguration configuration) throws CoreException {
    IRuntimeClasspathEntry[] entries = JavaRuntime.computeUnresolvedRuntimeClasspath(configuration);
    entries = JavaRuntime.resolveRuntimeClasspath(entries, configuration);

    ArrayList<IPath> userEntries = new ArrayList<IPath>(entries.length);
    for (int i = 0; i < entries.length; i++) {
      if (entries[i].getClasspathProperty() == IRuntimeClasspathEntry.USER_CLASSES) {

        String location = entries[i].getLocation();
        if (location != null) {
          IPath entry = Path.fromOSString(location);
          if (!userEntries.contains(entry)) {
            userEntries.add(entry);
          }
        }
      }
    }
    return userEntries.toArray(new IPath[userEntries.size()]);
  }
 /**
  * Get selected JVM.
  *
  * @return Selected JVM or <code>null</code> if one is not found
  */
 public IVMInstall getSelectedJVM() {
   if (_useProjectRE.isSelected()) {
     int index = _RECombo.getSelectionIndex();
     if (index >= 0 && index < _installedVMs.length) { // paranoia
       return _installedVMs[index];
     }
     return null;
   }
   // user selects workspace default JRE
   return JavaRuntime.getDefaultVMInstall();
 }
  public void testJavaSourceLocatorMemento() throws Exception {
    IJavaSourceLocation location1 = new JavaProjectSourceLocation(get14Project());
    File dir = ResourcesPlugin.getWorkspace().getRoot().getLocation().toFile();
    IJavaSourceLocation location2 = new DirectorySourceLocation(dir);
    IVMInstall vm = JavaRuntime.getDefaultVMInstall();
    IJavaSourceLocation location3 =
        new ArchiveSourceLocation(
            JavaRuntime.getLibraryLocations(vm)[0].getSystemLibraryPath().toOSString(), null);

    JavaSourceLocator locator =
        new JavaSourceLocator(new IJavaSourceLocation[] {location1, location2, location3});
    String memento = locator.getMemento();
    JavaSourceLocator restored = new JavaSourceLocator();
    restored.initializeFromMemento(memento);
    IJavaSourceLocation[] locations = restored.getSourceLocations();

    assertEquals("wrong number of source locations", 3, locations.length);
    assertEquals("1st locations not equal", location1, locations[0]);
    assertEquals("2nd locations not equal", location2, locations[1]);
    assertEquals("3rd locations not equal", location3, locations[2]);
  }
  private IRuntimeClasspathEntry convertClasspathEntry(IClasspathEntry entry) {
    if (entry == null) return null;

    IPath srcPath = entry.getSourceAttachmentPath();
    if (srcPath != null && srcPath.segmentCount() > 0) {
      IRuntimeClasspathEntry rte = JavaRuntime.newArchiveRuntimeClasspathEntry(entry.getPath());
      rte.setSourceAttachmentPath(srcPath);
      rte.setSourceAttachmentRootPath(entry.getSourceAttachmentRootPath());
      return rte;
    }
    return null;
  }
Example #27
0
  /* (non-Javadoc)
   * @see org.eclipse.jdt.launching.IRuntimeClasspathEntry2#getRuntimeClasspathEntries(org.eclipse.debug.core.ILaunchConfiguration)
   */
  public IRuntimeClasspathEntry[] getRuntimeClasspathEntries(ILaunchConfiguration configuration)
      throws CoreException {
    boolean separateVM = AntLaunchingUtil.isSeparateJREAntBuild(configuration);
    boolean setInputHandler = configuration.getAttribute(AntLaunching.SET_INPUTHANDLER, true);
    AntCorePreferences prefs = AntCorePlugin.getPlugin().getPreferences();
    IAntClasspathEntry[] antClasspathEntries = prefs.getContributedClasspathEntries();
    IAntClasspathEntry[] userEntries = prefs.getAdditionalClasspathEntries();
    List rtes = new ArrayList(antClasspathEntries.length + userEntries.length);
    IAntClasspathEntry entry;
    for (int i = 0; i < antClasspathEntries.length; i++) {
      entry = antClasspathEntries[i];
      if (!separateVM || (separateVM && !entry.isEclipseRuntimeRequired())) {
        rtes.add(JavaRuntime.newStringVariableClasspathEntry(entry.getLabel()));
      }
    }
    boolean haveToolsEntry = false;
    String path;
    for (int i = 0; i < userEntries.length; i++) {
      entry = userEntries[i];
      path = entry.getLabel();
      IPath toolsPath = new Path(path);
      if (toolsPath.lastSegment().equals("tools.jar")) { // $NON-NLS-1$
        haveToolsEntry = true;
        // replace with dynamically resolved tools.jar based on
        // the JRE being used
        addToolsJar(configuration, rtes, path);
      } else {
        rtes.add(JavaRuntime.newStringVariableClasspathEntry(path));
      }
    }
    if (!haveToolsEntry) {
      addToolsJar(configuration, rtes, null);
    }

    if (setInputHandler && separateVM) {
      addSWTJars(rtes);
    }

    return (IRuntimeClasspathEntry[]) rtes.toArray(new IRuntimeClasspathEntry[rtes.size()]);
  }
 private static List<String> appendLaunchClasspath(
     List<String> l,
     String projectName,
     ILaunchConfiguration config,
     IClasspathEntry[] adding,
     IJavaProject jp,
     int high) {
   initJefHome();
   Set<IClasspathEntry> set = new HashSet<IClasspathEntry>();
   try {
     if (l == null) {
       l = new ArrayList<String>();
       l.add(JavaRuntime.computeJREEntry(jp).getMemento());
       l.add(
           String.format(
               "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\r\n<runtimeClasspathEntry id=\"org.eclipse.jdt.launching.classpathentry.defaultClasspath\">\r\n<memento exportedEntriesOnly=\"false\" project=\"%s\"/></runtimeClasspathEntry>\r\n",
               projectName));
     } else {
       for (String s : l) {
         Document doc = XMLUtils.loadDocumentByString(s);
         if (doc.getDocumentElement().hasAttribute("type")) {
           IRuntimeClasspathEntry rcp =
               new org.eclipse.jdt.internal.launching.RuntimeClasspathEntry(
                   doc.getDocumentElement());
           set.add(rcp.getClasspathEntry());
         }
       }
     }
     int i = 0;
     for (IClasspathEntry cp : adding) {
       if (!set.contains(cp)) {
         IRuntimeClasspathEntry rcp =
             new org.eclipse.jdt.internal.launching.RuntimeClasspathEntry(cp);
         if (i < high) {
           rcp.setClasspathProperty(2);
         } else {
           rcp.setClasspathProperty(3);
         }
         l.add(rcp.getMemento());
         set.add(cp);
         i++;
       }
     }
   } catch (CoreException e) {
     e.printStackTrace();
   } catch (IOException e) {
     e.printStackTrace();
   } catch (SAXException e) {
     e.printStackTrace();
   }
   return l;
 }
Example #29
0
  /**
   * Verifies that the classpath entry is valid and won't cause the launch to fail.
   *
   * @param entry The entry to validate.
   * @param serverProject The project that the test server will run out of.
   * @return true if it's valid
   */
  public static boolean classpathEntryIsValid(String entry, IProject serverProject) {
    try {
      ILaunchConfigurationType type =
          DebugPlugin.getDefault()
              .getLaunchManager()
              .getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
      ILaunchConfigurationWorkingCopy copy = type.newInstance(null, "ezeTemp"); // $NON-NLS-1$
      copy.setAttribute(
          IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, serverProject.getName());
      copy.setAttribute(IJavaLaunchConfigurationConstants.ATTR_DEFAULT_CLASSPATH, false);

      List<String> classpath = new ArrayList<String>(1);
      classpath.add(entry);
      copy.setAttribute(IJavaLaunchConfigurationConstants.ATTR_CLASSPATH, classpath);

      JavaRuntime.resolveRuntimeClasspath(
          JavaRuntime.computeUnresolvedRuntimeClasspath(copy), copy);
      return true;
    } catch (CoreException ce) {
      return false;
    }
  }
  private void addJreClasspath() {
    try {
      IRuntimeClasspathEntry computeJREEntry = JavaRuntime.computeJREEntry(javaProject);
      if (computeJREEntry == null) {
        return;
      }

      IRuntimeClasspathEntry[] jreEntries =
          JavaRuntime.resolveRuntimeClasspathEntry(computeJREEntry, javaProject);

      if (jreEntries.length != 0) {
        for (IRuntimeClasspathEntry jreEntry : jreEntries) {
          addToClasspath(jreEntry.getClasspathEntry().getPath().toFile());
        }

        return;
      }
    } catch (JavaModelException e) {
      KotlinLogger.logAndThrow(e);
    } catch (CoreException e) {
      KotlinLogger.logAndThrow(e);
    }
  }