/*******************************************************************************
* Copyright (c) 2012 Google, Inc.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Google, Inc. - initial API and implementation
*******************************************************************************/
package com.windowtester.codegen.util;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Dictionary;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.StringTokenizer;
import java.util.Vector;
import java.util.jar.Attributes;
import java.util.jar.Manifest;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.jdt.core.IClasspathContainer;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.internal.core.ClasspathEntry;
import org.eclipse.osgi.util.ManifestElement;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleException;
import org.osgi.framework.Constants;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import com.windowtester.codegen.CodeGenPlugin;
import com.windowtester.internal.debug.Logger;
/**
* Build path utilities
*/
@SuppressWarnings("restriction")
public class BuildPathUtil {
/** The name of the test case superclass, needed to discover commonRuntime.jar */
private static final String COMMON_UI_TEST_CASE_NAME = "com.windowtester.runtime.common.UITestCaseCommon"; //$NON-NLS-1$
/** The name of the test case superclass, needed to discover swingRuntime.jar */
private static final String SWING_UI_TEST_CASE_NAME = "com.windowtester.runtime.swing.UITestCaseSwing"; //$NON-NLS-1$
/** The name of the test case superclass, needed to discover wt-runtime.jar */
private static final String SWT_UI_TEST_CASE_NAME = "com.windowtester.runtime.sw.UITestCaseSWT"; //$NON-NLS-1$
/** The name of the class to test JFace dependency */
private static final String JFACE_CLASS = "org.eclipse.jface.util.IPropertyChangeListener"; //$NON-NLS-1$
/** The name of the class to discover debug plugin */
private static final String LOGGER_CLASS = "com.windowtester.internal.debug.Logger"; //$NON-NLS-1$
/** The name of the class to discover junit entry in classpath */
private static final String JUNIT_CLASS = "junit.framework.TestCase";
/** The name of the class from common core */
private static final String ECLIPSE_PLUGIN_UTILS_CLASS = "com.windowtester.runtime.util.PluginUtilities";
/** The name of the class from common util package */
private static final String COMMON_CORE_PRODUCTS_CLASS = "com.windowtester.internal.product.Products";
/** The name of the class from core runtime */
private static final String OSGI_RUNTIME_PATH_CLASS = "org.eclipse.core.runtime.Path";
/** The name of the class from core runtime */
private static final String CORE_RUNTIME_PLATFORM_CLASS = "org.eclipse.core.runtime.Platform";
/** The name of the class from osgi */
private static final String OSGI_NLS_CLASS = "org.eclipse.osgi.util.NLS";
private static int MAXLINE = 511;
private static final String LINE_SEPARATOR = System.getProperty("line.separator"); //$NON-NLS-1$
private static final String LIST_SEPARATOR = "," + LINE_SEPARATOR+" "; //$NON-NLS-1$
private static final String RUNTIME_DEP_RUNTIME_COMMON = "com.windowtester.runtime";
private static final String RUNTIME_DEP_RUNTIME_SWT = "com.windowtester.swt.runtime";
private static final String RUNTIME_DEP_RUNTIME_SWING = "com.windowtester.swing.runtime";
private static final String JFACE_BUNDLE = "org.eclipse.jface";
private static final String OSGI_RUNTIME_BUNDLE = "org.eclipse.equinox.common";
private static final String CORE_RUNTIME_BUNDLE = "org.eclipse.core.runtime";
private static final String OSGI_BUNDLE = "org.eclipse.osgi";
private static final String WINTEST_JAVADOC_PLUGIN_ID = "com.windowtester.eclipse.help";
private static final String WINTEST_JAVADOC_RELATIVE_PATH = "html/reference/javadoc";
private static final String JUNIT_BUNDLE = "org.junit";
private static final String JUNIT_VAR_NAME = "JUNIT_HOME";
public static final String CLASSPATH_CONTAINER_ID = "com.windowtester.eclipse.ui.runtimeClasspathContainer";
public static final String JUNIT_CONTAINER_ID= "org.eclipse.jdt.junit.JUNIT_CONTAINER"; //$NON-NLS-1$
public final static String JUNIT3= "3.8.1"; //$NON-NLS-1$
public final static String JUNIT4= "4"; //$NON-NLS-1$
public final static IPath JUNIT3_PATH= new Path(JUNIT_CONTAINER_ID).append(JUNIT3);
public static IBuildPathUpdater getUpdater(final IJavaProject targetProject) {
return new IBuildPathUpdater() {
public void addPluginDependency(String pluginId) throws CoreException {
BuildPathUtil.addPluginDependency(targetProject, pluginId);
}
};
}
/**
* Appends target project build path with source project build path.
*
* @param targetProject the target project
* @param sourceProject the source project
* @throws CoreException
*/
public static void appendProjectBuildPath(IJavaProject targetProject, IJavaProject sourceProject) throws CoreException {
try {
// copy required entries to target
IClasspathEntry[] srcEntries= sourceProject.getRawClasspath();
for (int i = 0; i < srcEntries.length; i++) {
IClasspathEntry entry = srcEntries[i];
if(entry.isExported() || entry.getEntryKind()==IClasspathEntry.CPE_SOURCE)
continue;
addToClasspath(targetProject, entry);
}
// add the source project as a project entry
IClasspathEntry srcPrjEntry = JavaCore.newProjectEntry(sourceProject.getPath());
addToClasspath(targetProject, srcPrjEntry);
} catch (JavaModelException e) {
// we interested only in core exceptions
if (e.getCause() instanceof CoreException) {
throw (CoreException)e.getCause();
}
}
}
/**
* Adds JAR archive defined in Classpath variable to the buildpath of Java
* project. In the case when the workspace exists with provided name, this
* project will added to the project build path. Othervise, it will use the
* variable name to set the concrete specified JAR.
*
* @param project the java project that the entry will be append to.
* @param workspaceProject name of the project to look in the workspace
* @param variable classpath variable to use
* @param jarName the name of the archive, if null it wont be used
* @throws CoreException
*/
public static void addRuntimeJarToBuildPath(IJavaProject project, String workspaceProject, String variable, String jarName) throws CoreException {
IClasspathEntry entry = getEntry(workspaceProject, variable, jarName);
addToClasspath(project, entry);
}
public static IClasspathEntry getEntry(String workspaceProject, String variable, String jarName){
IProject wsJavaProject= ResourcesPlugin.getWorkspace().getRoot().getProject(workspaceProject);
IClasspathEntry entry;
if (wsJavaProject.exists()) {
entry= JavaCore.newProjectEntry(wsJavaProject.getFullPath());
} else {
IPath variablePath= new Path(variable);
if(jarName!=null)
variablePath = variablePath.append(jarName);
entry= JavaCore.newVariableEntry(variablePath, null, null);
}
return entry;
}
public static IClasspathEntry getEntry(String bundleName, String jarName, boolean hasJavadoc) {
// check if bundle is a workspace project and if it is then use the project entry
// from workspace or otherwise resolve path from the bundle location
IProject wsJavaProject = ResourcesPlugin.getWorkspace().getRoot().getProject(bundleName);
if (wsJavaProject.exists())
return JavaCore.newProjectEntry(wsJavaProject.getFullPath());
// get the bundle
Bundle bundle = Platform.getBundle(bundleName);
if (bundle == null)
return null;
String path;
try {
// get the bundle location
URL location = bundle.getEntry(jarName);
// there is no jar in bundle location
URL jarLocation = null;
if (location == null) {
// assume bundle location is jared archive
location = bundle.getEntry("/");
jarLocation = Platform.resolve(location);
// test if bundle is jared
if (!jarLocation.getFile().endsWith(".jar!/")) {
// return null if it is not jar
return null;
}
else {
// remove jar: protocol from URL at this step
jarLocation = new URL(jarLocation.getPath());
}
}
else {
jarLocation = Platform.resolve(location);
}
// normalize path
path = jarLocation.getFile();
if (path.endsWith(".jar!/")) {
path = path.substring(0, path.length() - 2);
}
}
catch (IOException e) {
Logger.log(e);
return null;
}
/* $codepro.preprocessor.if version < 3.1 $
return JavaCore.newLibraryEntry(new Path(path), null, null);
$codepro.preprocessor.elseif version >= 3.1 $ */
org.eclipse.jdt.core.IClasspathAttribute[] attributes = ClasspathEntry.NO_EXTRA_ATTRIBUTES;
if (hasJavadoc) {
Bundle docBundle = Platform.getBundle(WINTEST_JAVADOC_PLUGIN_ID);
if (docBundle != null) {
URL location = bundle.getEntry(WINTEST_JAVADOC_RELATIVE_PATH);
if (location != null) {
attributes = new org.eclipse.jdt.core.IClasspathAttribute[]{
JavaCore.newClasspathAttribute(
org.eclipse.jdt.core.IClasspathAttribute.JAVADOC_LOCATION_ATTRIBUTE_NAME, location
.toExternalForm())
};
}
}
}
return JavaCore.newLibraryEntry(new Path(path), null, null, ClasspathEntry.NO_ACCESS_RULES, attributes, false);
/* $codepro.preprocessor.endif $ */
}
public static void addPluginJarToBuildPath(IJavaProject project, String pluginId) throws CoreException{
Bundle bundle = Platform.getBundle(pluginId);
if(bundle==null){
Logger.log("Cannot find Bundle "+pluginId);
return;
}
IPath path = new Path(getFullPath(bundle.getEntry("/")));
IClasspathEntry entry = JavaCore.newLibraryEntry(path, null, null);
addToClasspath(project, entry);
}
public static List getClasspathPaths(String pluginID) throws CoreException {
List result = new ArrayList();
try {
Bundle bundle = Platform.getBundle(pluginID);
String requires = (String) bundle.getHeaders().get(Constants.BUNDLE_CLASSPATH);
if (requires == null) {
requires = ".";
}
ManifestElement[] elements = ManifestElement.parseHeader(Constants.BUNDLE_CLASSPATH, requires);
if (elements != null) {
for (int i = 0; i < elements.length; ++i) {
ManifestElement element = elements[i];
String value = element.getValue();
if (".".equals(value)) {
value = "/";
}
URL url = bundle.getEntry(value);
if (url != null) {
result.add(getFullPath(url));
}
}
}
} catch (BundleException e) {
throw new CoreException(Logger.createLogStatus(e.getMessage(), e, null));
}
return result;
}
public static String getFullPath(URL url) throws CoreException{
try {
URL resolvedURL = Platform.resolve(url);
String resolvedURLString = resolvedURL.toString();
if (resolvedURLString.endsWith("!/")) {
resolvedURLString = resolvedURL.getFile();
resolvedURLString = resolvedURLString.substring(0, resolvedURLString.length()- "!/".length());
}
if (resolvedURLString.startsWith("file:")) {
return resolvedURLString.substring("file:".length());
} else {
return Platform.asLocalURL(url).getFile();
}
} catch (IOException e) {
throw new CoreException(Logger.createLogStatus(e.getMessage(), e, null));
}
}
public static void addToClasspath(final IJavaProject project, IClasspathEntry entry) throws CoreException {
IClasspathEntry[] oldEntries= project.getRawClasspath();
for (int i= 0; i < oldEntries.length; i++) {
if (oldEntries[i].equals(entry)) {
return;
}
}
int nEntries= oldEntries.length;
final IClasspathEntry[] newEntries= new IClasspathEntry[nEntries + 1];
System.arraycopy(oldEntries, 0, newEntries, 0, nEntries);
newEntries[nEntries]= entry;
try {
try {
project.setRawClasspath(newEntries, null);
} catch (JavaModelException e) {
throw new InvocationTargetException(e);
}
} catch (InvocationTargetException e) {
Throwable t = e.getTargetException();
if (t instanceof CoreException) {
throw (CoreException)t;
}
}
}
public static void addPluginDependency(IJavaProject targetProject, String pluginId) throws CoreException{
IFile manifest = targetProject.getProject().getFile("META-INF/MANIFEST.MF");
if(manifest.exists()){
updateManifestDependency(manifest.getLocation().toFile(), pluginId);
manifest.refreshLocal(1, null);
}else{
IFile plugin = targetProject.getProject().getFile("plugin.xml");
if(!plugin.exists())
throw new CoreException(Logger.createLogStatus("No plugin or manifest file found in target project", null, null));
updatePluginDependnecy(plugin.getLocation().toFile(), pluginId);
plugin.refreshLocal(1, null);
}
}
public static void updatePluginDependnecy(File plugin, String pluginId) throws CoreException {
try {
Document doc = parseXmlFile(plugin, false);
NodeList list = doc.getElementsByTagName("requires");
for (int i=0; i<list.getLength(); i++) {
Element element = (Element)list.item(i);
Element importElement = doc.createElement("import");
importElement.setAttribute("plugin", pluginId);
element.appendChild(importElement);
}
writeXmlFile(doc, plugin);
} catch (Exception e) {
throw new CoreException(Logger.createLogStatus(e.getMessage(), e, null));
}
}
public static Document parseXmlFile(File file, boolean validating) throws Exception {
// Create a builder factory
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(validating);
// Create the builder and parse the file
Document doc = factory.newDocumentBuilder().parse(file);
return doc;
}
public static void writeXmlFile(Document doc, File file) throws Exception{
// Prepare the DOM document for writing
Source source = new DOMSource(doc);
// Prepare the output file
Result result = new StreamResult(file);
// Write the DOM document to the file
Transformer xformer = TransformerFactory.newInstance().newTransformer();
xformer.transform(source, result);
}
public static void updateManifestDependency(File file, String pluginId) throws CoreException {
InputStream manifestStream = null;
try {
manifestStream = new FileInputStream(file);
Manifest manifest = new Manifest(manifestStream);
Properties prop = manifestToProperties(manifest.getMainAttributes());
String require = prop.getProperty(Constants.REQUIRE_BUNDLE);
if(require == null || require.trim().equals("")){
prop.put(Constants.REQUIRE_BUNDLE, pluginId);
}else{
boolean exists = false;
ManifestElement[] elements = ManifestElement.parseHeader(Constants.REQUIRE_BUNDLE, require);
StringBuffer buffer = new StringBuffer();
for (int i = 0; i < elements.length; i++) {
if(elements[i].getValue().equals(pluginId))
exists = true;
appendValue(buffer, elements[i].getValue());
}
// add required bundle at the end
if(!exists)
appendValue(buffer, pluginId);
prop.put(Constants.REQUIRE_BUNDLE, buffer.toString());
}
writeManifest(file, prop);
} catch (FileNotFoundException e) {
throw new CoreException(Logger.createLogStatus(e.getMessage(), e, null));
} catch (IOException e) {
throw new CoreException(Logger.createLogStatus(e.getMessage(), e, null));
} catch (BundleException e) {
throw new CoreException(Logger.createLogStatus(e.getMessage(), e, null));
} finally {
try {
if (manifestStream != null)
manifestStream.close();
} catch (IOException e) {
}
}
}
public static void writeManifest(File generationLocation, Dictionary manifestToWrite) throws CoreException {
Writer out = null;
try {
File parentFile = new File(generationLocation.getParent());
parentFile.mkdirs();
generationLocation.createNewFile();
if (!generationLocation.isFile()) {
throw new CoreException(Logger.createLogStatus("Location must be a file.", null, null));
}
// replaces any eventual existing file
manifestToWrite = new Hashtable((Map) manifestToWrite);
// MANIFEST.MF files must be written using UTF-8
out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(generationLocation), "UTF-8"));
Enumeration keys = manifestToWrite.keys();
while (keys.hasMoreElements()) {
String key = (String) keys.nextElement();
writeEntry(out, key, (String) manifestToWrite.get(key));
}
out.flush();
} catch (IOException e) {
throw new CoreException(Logger.createLogStatus("Error when building bundle manifets", null, null));
} finally {
if (out != null)
try {
out.close();
} catch (IOException e) {
// only report problems writing to/flushing the file
}
}
}
public static void writeBuildProperties(File generationLocation, Dictionary propertiesToWrite) throws CoreException {
Writer out = null;
try {
File parentFile = new File(generationLocation.getParent());
parentFile.mkdirs();
generationLocation.createNewFile();
if (!generationLocation.isFile()) {
throw new CoreException(Logger.createLogStatus("Location must be a file.", null, null));
}
// replaces any eventual existing file
propertiesToWrite = new Hashtable((Map) propertiesToWrite);
out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(generationLocation), "UTF-8"));
Enumeration keys = propertiesToWrite.keys();
while (keys.hasMoreElements()) {
String key = (String) keys.nextElement();
writePropertyEntry(out, key, (String) propertiesToWrite.get(key));
}
out.flush();
} catch (IOException e) {
throw new CoreException(Logger.createLogStatus("Error when writing properties file", null, null));
} finally {
if (out != null)
try {
out.close();
} catch (IOException e) {
// only report problems writing to/flushing the file
}
}
}
private static void writePropertyEntry(Writer out, String key, String value) throws IOException {
if (value != null && value.length() > 0) {
out.write(splitOnComma(key + "= " + value)); //$NON-NLS-1$
out.write(LINE_SEPARATOR);
}
}
private static void writeEntry(Writer out, String key, String value) throws IOException {
if (value != null && value.length() > 0) {
out.write(splitOnComma(key + ": " + value)); //$NON-NLS-1$
out.write(LINE_SEPARATOR);
}
}
private static String splitOnComma(String value) {
if (value.length() < MAXLINE || value.indexOf(LINE_SEPARATOR) >= 0)
return value; // assume the line is already split
String[] values = getArrayFromList(value);
if (values == null || values.length == 0)
return value;
StringBuffer sb = new StringBuffer(value.length() + ((values.length - 1) * LIST_SEPARATOR.length()));
for (int i = 0; i < values.length - 1; i++)
sb.append(values[i]).append(LIST_SEPARATOR);
sb.append(values[values.length -1]);
return sb.toString();
}
public static String[] getArrayFromList(String stringList) {
if (stringList == null || stringList.trim().equals("")) //$NON-NLS-1$
return null;
Vector list = new Vector();
StringTokenizer tokens = new StringTokenizer(stringList, ","); //$NON-NLS-1$
while (tokens.hasMoreTokens()) {
String token = tokens.nextToken().trim();
if (!token.equals("")) //$NON-NLS-1$
list.addElement(token);
}
return list.isEmpty() ? new String[0] : (String[]) list.toArray(new String[list.size()]);
}
private static void appendValue(StringBuffer buffer, String value){
if (buffer.length() > 0) {
buffer.append(LIST_SEPARATOR);
}
buffer.append(value);
}
private static Properties manifestToProperties(Attributes d) {
Iterator iter = d.keySet().iterator();
Properties result = new Properties();
while (iter.hasNext()) {
Attributes.Name key = (Attributes.Name) iter.next();
result.put(key.toString(), d.get(key));
}
return result;
}
/**
* Validate if the project has required libraries in build path. I the case if not it will add them to it.
*
* @return the status of the validation
*/
public static IStatus validateDependencies(IJavaProject targetProject, boolean addDefault, boolean isRcpApplication) {
Status status= new Status(IStatus.OK, CodeGenPlugin.getPluginId(), IStatus.OK, "Project has all libraires", null);
boolean addJUnitJar = checkToAddEntry(targetProject, JUNIT_CLASS);
boolean addCommonRuntimeJar = checkToAddEntry(targetProject, COMMON_UI_TEST_CASE_NAME);
boolean addSwtRuntimeJar = checkToAddEntry(targetProject, SWT_UI_TEST_CASE_NAME);
boolean addSwingRuntimeJar = checkToAddEntry(targetProject, SWING_UI_TEST_CASE_NAME);
boolean addJFaceJar = checkToAddEntry(targetProject, JFACE_CLASS);
// boolean addCommonDebug = checkToAddEntry(targetProject, LOGGER_CLASS);
// boolean addCommonCore = checkToAddEntry(targetProject, COMMON_CORE_PRODUCTS_CLASS);
boolean addCoreRuntime = checkToAddEntry(targetProject, CORE_RUNTIME_PLATFORM_CLASS);
// boolean addCommonUtil = checkToAddEntry(targetProject, ECLIPSE_PLUGIN_UTILS_CLASS);
boolean addOsgiRuntime = checkToAddEntry(targetProject, OSGI_RUNTIME_PATH_CLASS);
boolean addOsgi = checkToAddEntry(targetProject, OSGI_NLS_CLASS);
// test if there is a need to move forward
if(!addJUnitJar &&
!addCommonRuntimeJar &&
!addSwtRuntimeJar &&
!addSwingRuntimeJar &&
!addJFaceJar &&
!addCoreRuntime &&
!addOsgiRuntime &&
!addOsgi)
{
return status;
}
if (addDefault) {
try {
if(isRcpApplication){
if(addJUnitJar)
BuildPathUtil.addPluginDependency(targetProject, JUNIT_BUNDLE);
if(addCommonRuntimeJar)
BuildPathUtil.addPluginDependency(targetProject, RUNTIME_DEP_RUNTIME_COMMON);
if(addSwtRuntimeJar)
BuildPathUtil.addPluginDependency(targetProject, RUNTIME_DEP_RUNTIME_SWT);
if(addSwingRuntimeJar)
BuildPathUtil.addPluginDependency(targetProject, RUNTIME_DEP_RUNTIME_SWING);
if(addJFaceJar)
BuildPathUtil.addPluginDependency(targetProject, JFACE_BUNDLE);
if(addCoreRuntime)
BuildPathUtil.addPluginDependency(targetProject, CORE_RUNTIME_BUNDLE);
} else{
// add the WindowTester classpath container
addToClasspath(targetProject, JavaCore.newContainerEntry(new Path(CLASSPATH_CONTAINER_ID), false));
// add the appropriate JUnit container/library depending upon platform
/* $codepro.preprocessor.if version >= 3.2 $ */
addToClasspath(targetProject, JavaCore.newContainerEntry(JUNIT3_PATH, false));
/* $codepro.preprocessor.elseif version < 3.2 $
addRuntimeJarToBuildPath(targetProject, JUNIT_BUNDLE, JUNIT_VAR_NAME, "junit.jar");
$codepro.preprocessor.endif $ */
}
return status;
} catch(CoreException e) {
return e.getStatus();
}
}
return new Status(IStatus.WARNING, CodeGenPlugin.getPluginId(), IStatus.WARNING, "Some required libraries are missing.", null);
}
public static IClasspathEntry getRuntimeContainerEntry(IJavaProject targetProject) throws JavaModelException{
// add WindowTester Runtime Classpath container and give it to handle all dependencies
IClasspathEntry entry = JavaCore.newContainerEntry(
new Path(CLASSPATH_CONTAINER_ID),
false);
IClasspathEntry[] entries = BuildPathUtil.getRuntimeClasspathEntries(targetProject);
JavaCore.setClasspathContainer(
entry.getPath(),
new IJavaProject[]{ targetProject },
new IClasspathContainer[] {new RuntimeClasspathContainer(entries, entry.getPath())},
null);
return entry;
}
public static IStatus validateDependencies(IJavaProject targetProject, String mainAppProjectName, boolean addDefault, boolean isRcpApplication) throws CoreException {
IProject mainAppProject = ResourcesPlugin.getWorkspace().getRoot().getProject(mainAppProjectName);
if(!targetProject.getProject().getName().equals(mainAppProjectName) && addDefault){
BuildPathUtil.appendProjectBuildPath(targetProject, JavaCore.create(mainAppProject));
}
if(!targetProject.getProject().getName().equals(mainAppProjectName) && !addDefault)
return new Status(IStatus.WARNING, CodeGenPlugin.getPluginId(), IStatus.WARNING, "Some required libraries are missing.", null);
return validateDependencies(targetProject, addDefault, isRcpApplication);
}
/**
* Get required runtime Classpath entries for standalone SWT application. If the
* provided project already have some dependency in the classpath, it will
* not appear in the output.
* @param project the project to which the entries has to be computed
* @return array of required dependencies
*/
public static IClasspathEntry[] getRuntimeClasspathEntries(IJavaProject targetProject) {
// output array of entries
ArrayList entries = new ArrayList();
checkAndAddEntry(targetProject, entries, COMMON_UI_TEST_CASE_NAME, RUNTIME_DEP_RUNTIME_COMMON, "commonRuntime.jar", true);
checkAndAddEntry(targetProject, entries, SWING_UI_TEST_CASE_NAME, RUNTIME_DEP_RUNTIME_SWING, "swingRuntime.jar", true);
checkAndAddEntry(targetProject, entries, SWT_UI_TEST_CASE_NAME, RUNTIME_DEP_RUNTIME_SWT, "wt-runtime.jar", true);
checkAndAddEntry(targetProject, entries, JFACE_CLASS, JFACE_BUNDLE, "jface.jar", false);
checkAndAddEntry(targetProject, entries, CORE_RUNTIME_PLATFORM_CLASS, CORE_RUNTIME_BUNDLE, "runtime.jar", false);
checkAndAddEntry(targetProject, entries, OSGI_RUNTIME_PATH_CLASS, OSGI_RUNTIME_BUNDLE, "runtime.jar", false);
checkAndAddEntry(targetProject, entries, OSGI_NLS_CLASS, OSGI_BUNDLE, "osgi.jar", false);
return (IClasspathEntry[])entries.toArray(new IClasspathEntry[] {});
}
private static void checkAndAddEntry(IJavaProject targetProject, ArrayList entries, String classToCheck, String bundle, String jarName, boolean hasJavadoc){
if(checkToAddEntry(targetProject, classToCheck)){
IClasspathEntry entry = getEntry(bundle, jarName, hasJavadoc);
if(entry!=null)
entries.add(entry);
}
}
private static boolean checkToAddEntry(IJavaProject targetProject, String classToCheck){
/*
*
* Classpath Container in periodically coming up empty. I suspect that the java project is not initialized
* when this method called resulting in invalid response from or exception when calling findType(...).
* Added tracing and logging rather than throwing away the exception.
*
* I commented out the entire findType(...) functionality because I suspect that Eclipse
* cannot handle this type of call from here under certain circumstances causing Eclipse
* to lock up without a graceful exit.
*/
boolean required = true;
// try {
// if (targetProject.findType(classToCheck) != null) {
// Logger.log("Failed to find " + classToCheck + " in " + targetProject.getProject().getName());
// required = false;
// }
// }
// catch (JavaModelException e) {
// Logger.log("Exception when finding " + classToCheck + " in " + targetProject.getProject().getName(), e);
// }
return required;
}
}