diff options
Diffstat (limited to 'testplugins/org.eclipse.jdt.ui.tests/chkpii')
5 files changed, 728 insertions, 0 deletions
diff --git a/testplugins/org.eclipse.jdt.ui.tests/chkpii/org/eclipse/jdt/ui/tests/chkpii/ChkpiiTests.java b/testplugins/org.eclipse.jdt.ui.tests/chkpii/org/eclipse/jdt/ui/tests/chkpii/ChkpiiTests.java new file mode 100644 index 000000000..5f55182ab --- /dev/null +++ b/testplugins/org.eclipse.jdt.ui.tests/chkpii/org/eclipse/jdt/ui/tests/chkpii/ChkpiiTests.java @@ -0,0 +1,370 @@ +/******************************************************************************* + * Copyright (c) 2000, 2009 IBM Corporation and others. + * 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: + * IBM Corporation - initial API and implementation + *******************************************************************************/ +package org.eclipse.jdt.ui.tests.chkpii; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.UnsupportedEncodingException; +import java.net.URL; +import java.nio.charset.Charset; +import java.util.StringTokenizer; + +import junit.extensions.ActiveTestSuite; +import junit.framework.Test; +import junit.framework.TestCase; + +import org.eclipse.osgi.service.environment.Constants; + +import org.eclipse.core.runtime.FileLocator; +import org.eclipse.core.runtime.Platform; + +public class ChkpiiTests extends TestCase { + + private String fLogDirectoryName; + + private class FileCategory { + private final String fName; + protected FileCategory(String name) { + fName= name; + } + public String getOutputFile() { + return fLogDirectoryName + fName.toLowerCase() + ".txt"; + } + public String getFilesToTest() { + return getPluginDirectory() + getExtension(); + } + protected String getExtension() { + return "*." + fName.toLowerCase(); + } + + public String toString() { + return fName.toUpperCase(); + } + } + private static class StreamConsumer extends Thread { + StringBuffer fStrBuffer; + BufferedReader fReader; + + + public String getContents() { + return fStrBuffer.toString(); + } + + public StreamConsumer(InputStream inputStream) { + super(); + setDaemon(true); + try { + fReader = new BufferedReader(new InputStreamReader(inputStream, "LATIN1")); + } catch (UnsupportedEncodingException e) { + e.printStackTrace(); + fReader = new BufferedReader(new InputStreamReader(inputStream)); + } + fStrBuffer= new StringBuffer(); + } + + public void run() { + try { + char[] buf= new char[1024]; + int count; + while (0 < (count = fReader.read(buf))) { + fStrBuffer.append(buf, 0, count); + } + fReader.close(); + } catch (IOException ex) { + ex.printStackTrace(); + } + } + + public void terminate() { + interrupt(); + try { + fReader.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + + } + + private final FileCategory HTML= new FileCategory("HTML") { + protected String getExtension() { + return "*.htm*"; + } + }; + private final FileCategory PROPERTIES= new FileCategory("PROPERTIES"); + private final FileCategory XML= new FileCategory("XML"); + + public static Test suite() { + return new ActiveTestSuite(ChkpiiTests.class); + } + + public void testHTMLFiles() { + assertChkpii(HTML); + } + + public void testXMLFiles() { + assertChkpii(XML); + } + + public void testPropertiesFiles() { + assertChkpii(PROPERTIES); + } + + private void assertChkpii(FileCategory type) { + + boolean isExecuted= executeChkpiiProcess(type); + assertTrue("Could not run chkpii test on " + type + " files. See console for details.", isExecuted); //$NON-NLS-1$ + StringBuffer buf= new StringBuffer(); + boolean isValid= checkLogFile(type, buf); + assertTrue(buf + "See " + type.getOutputFile() + " for details.", isValid); //$NON-NLS-1$ //$NON-NLS-2$ + } + + private boolean executeChkpiiProcess(FileCategory type) { + Runtime aRuntime= Runtime.getRuntime(); + String chkpiiString= getChkpiiString(type); + + StreamConsumer err= null; + StreamConsumer out= null; + Process process= null; + try { + process= aRuntime.exec(chkpiiString); + err= new StreamConsumer(process.getErrorStream()); + out= new StreamConsumer(process.getInputStream()); + err.start(); + out.start(); + process.waitFor(); + } catch (IOException e) { + e.printStackTrace(); + return false; + } catch (InterruptedException e) { + return false; + } finally { + out.terminate(); + err.terminate(); + } + + if (err.getContents().length() > 0 || !new File(type.getOutputFile()).exists()) { + System.out.println(out.getContents()); + System.out.println(err.getContents()); + System.out.flush(); + return false; + } + int res= process.exitValue(); + System.out.println("ChkpiiTests#" + getName() + "() exit value: " + res); + return true; + } + + private String getChkpiiString(FileCategory type) { + return getExec() + " " + type.getFilesToTest() + " -E -O " + type.getOutputFile() + " -XM @" + getExcludeErrors() + " -X " + getExcludeFile () + " -S -JSQ"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ + } + + private String getPluginDirectory() { + + // Get some path inside a plug-in + String filePath= toLocation(getClass().getResource("ignoreFiles.txt")); + + StringTokenizer tokenizer= new StringTokenizer(filePath, File.separator); + + String path= ""; + if (filePath.charAt(0) != File.separatorChar) + path= tokenizer.nextToken(); + + while (tokenizer.hasMoreTokens()) { + String token= tokenizer.nextToken(); + if (token.equals("org.eclipse.jdt.ui.tests")) + break; + + path= path + File.separator + token; + } + return path + File.separator; + } + + private String toLocation(URL platformURL) { + File localFile; + try { + localFile= new File(FileLocator.toFileURL(platformURL).getFile()); + } catch (IOException e) { + e.printStackTrace(); + return platformURL.getFile(); + } + try { + return localFile.getCanonicalPath(); + } catch (IOException e) { + e.printStackTrace(); + return localFile.getPath(); + } + } + + /** + * Method getExcludeFiles. + * + * @return String + */ + private String getExcludeFile() { + return toLocation(getClass().getResource("ignoreFiles.txt")); + } + + /** + * Method getExec. + * + * @return String + */ + private String getExec() { + return new File("chkpii.exe").getPath(); //$NON-NLS-1$ + } + + private String getExcludeErrors() { + + String fileName; + + if (Platform.getOS().equals(Constants.OS_WIN32)) + fileName= "ignoreErrorsWindows.txt"; //$NON-NLS-1$ + else + fileName= "ignoreErrorsUnix.txt"; //$NON-NLS-1$ + + return toLocation(getClass().getResource(fileName)); + } + + /** + * Checks if the given log file is valid and states no errors. + * + * @param type the file category + * @param message a string buffer to append error messages to + * @return <code>true</code> if there are errors in the log file + */ + private boolean checkLogFile(FileCategory type, StringBuffer message) { + String logFilePath= type.getOutputFile(); + BufferedReader aReader= null; + int errors= -1, warnings= -1, notProcessed= -1, endOfSummary= -1; + boolean hasFailed= false; + + try { + aReader= new BufferedReader(new InputStreamReader(new FileInputStream(logFilePath), Charset.forName("ISO-8859-1"))); + String aLine= aReader.readLine(); + while (aLine != null) { + if (errors == -1) + errors= parseSummary(aLine, "Files Contain Error"); + if (XML != type && warnings == -1) + warnings= parseSummary(aLine, "Files Contain Warnings Only"); + else if (notProcessed == -1) + notProcessed= parseNotProcessedSummary(aLine); + else if (endOfSummary == -1) + endOfSummary= parseEndOfSummary(aLine); + else + break; + + aLine= aReader.readLine(); + } + + if (errors > 0) { + message.append("" + errors + " files containing errors\n"); + hasFailed= true; + } + if (XML != type && warnings > 0) { + message.append("" + errors + " files containing errors\n"); + hasFailed= true; + } + if (notProcessed > 0) { + message.append("" + notProcessed + " files not found\n"); + hasFailed= true; + } + if (endOfSummary != 0) { + message.append("Incomplete logfile\n"); + hasFailed= true; + } + + } catch (FileNotFoundException e) { + message.append("Could not open log file: " + logFilePath + "\n" + e.getLocalizedMessage() + "\n"); //$NON-NLS-1$ + hasFailed= true; + } catch (IOException e) { + message.append("Error reading log file: " + logFilePath + "\n" + e.getLocalizedMessage() + "\n"); //$NON-NLS-1$ + hasFailed= true; + } finally { + if (aReader != null) { + try { + aReader.close(); + } catch (IOException e) { + message.append("Error closing log file: " + logFilePath + "\n" + e.getLocalizedMessage() + "\n"); //$NON-NLS-1$ + hasFailed= true; + } + } + } + + return !hasFailed; + } + + private int parseSummary(String aLine, String parseString) { + int index= aLine.indexOf(parseString); + if (index == -1) + return -1; + + String aString= aLine.substring(0, index).trim(); + try { + return Integer.parseInt(aString); + } catch (NumberFormatException e) { + return -1; + } + } + + private int parseNotProcessedSummary(String aLine) { + int index= aLine.indexOf("Files Could Not Be Processed"); //$NON-NLS-1$ + if (index == -1) + return -1; + + String aString= aLine.substring(0, index).trim(); + try { + return Integer.parseInt(aString); + } catch (NumberFormatException e) { + return -1; + } + } + + private int parseEndOfSummary(String aLine) { + int index= aLine.indexOf("End of Listing"); //$NON-NLS-1$ + if (index == -1) + return -1; + return 0; + } + + /** + * Constructor for EmptyDirectoriesTest. + * + * @param name the test name + */ + public ChkpiiTests(String name) { + super(name); + fLogDirectoryName= getPluginDirectory() + "chkpiiResults" + File.separator; //$NON-NLS-1$ + new File(PROPERTIES.getOutputFile()).delete(); + new File(HTML.getOutputFile()).delete(); + new File(XML.getOutputFile()).delete(); + } + + /* + * @see TestCase#setUp() + */ + protected void setUp() throws Exception { + super.setUp(); + new File(fLogDirectoryName).mkdirs(); + } + + /* + * @see TestCase#tearDown() + */ + protected void tearDown() throws Exception { + super.tearDown(); + fLogDirectoryName= null; + } +} diff --git a/testplugins/org.eclipse.jdt.ui.tests/chkpii/org/eclipse/jdt/ui/tests/chkpii/HTMLTidyTest.java b/testplugins/org.eclipse.jdt.ui.tests/chkpii/org/eclipse/jdt/ui/tests/chkpii/HTMLTidyTest.java new file mode 100644 index 000000000..00101887f --- /dev/null +++ b/testplugins/org.eclipse.jdt.ui.tests/chkpii/org/eclipse/jdt/ui/tests/chkpii/HTMLTidyTest.java @@ -0,0 +1,223 @@ +/******************************************************************************* + * Copyright (c) 2008 IBM Corporation and others. + * 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: + * IBM Corporation - initial API and implementation + *******************************************************************************/ +package org.eclipse.jdt.ui.tests.chkpii; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.OutputStreamWriter; +import java.io.Writer; +import java.net.URL; +import java.text.SimpleDateFormat; +import java.util.ArrayList; +import java.util.Date; +import java.util.regex.Pattern; + +import junit.framework.TestCase; + +import org.eclipse.jdt.testplugin.JavaTestPlugin; + +import org.eclipse.core.runtime.FileLocator; + +import org.eclipse.jdt.internal.ui.util.StringMatcher; + +/** + * Runs the 'tidy' command (e.g. from Cygwin) on HTML files in the workspace + * and collects HTMLTidy's errors and warnings into /chkpiiResults/tidy.txt + * + * Note: Currently disabled. + */ +public class HTMLTidyTest extends TestCase { + + private static final int TIDY_TIMEOUT= 10000; + private static final Pattern EXCLUSION_PATTERN_TABLE_SUMMARY= Pattern.compile("line \\d+ column \\d+ - Warning: <table> lacks \"summary\" attribute"); + + private static final Pattern EXCLUSION_PATTERN_EMPTY_TAG= Pattern.compile("line \\d+ column \\d+ - Warning: trimming empty <\\w+>"); + private static final Pattern EXCLUSION_PATTERN_MALFORMED_URI= Pattern.compile("line \\d+ column \\d+ - Warning: <a> escaping malformed URI reference"); + private static final Pattern eXCLUSION_PATTERN_SCRIPT_TYPE= Pattern.compile("line \\d+ column \\d+ - Warning: <script> inserting \"type\" attribute"); + private static final Pattern eXCLUSION_PATTERN_IMG_LACKS_ALT= Pattern.compile("line \\d+ column \\d+ - Warning: <img> lacks \"alt\" attribute"); + + private int fworkspacePathLength; + private StringMatcher[] fIgnores; + private Writer fTidyResults; + + /** + * Main method for manual testing of a file or folder selected in the workspace. To run, create + * a Java launch configuration with program argument<br> + * <code>"${resource_loc}"</code><br> + * (including double quotes!). + * + * @param args 1 argument: Absolute path to a file or folder + * @throws Exception if checking fails + */ + public static void main(String[] args) throws Exception { + HTMLTidyTest test= new HTMLTidyTest(); + test.fIgnores= new StringMatcher[0]; + test.fTidyResults= new OutputStreamWriter(System.out); + File file= new File(args[0]); + if (file.isDirectory()) + test.checkFolder(file); + else + test.checkFile(file); + } + + public void testHTML() throws Exception { + URL testBundleRoot= JavaTestPlugin.getDefault().getBundle().getEntry("/"); + URL testBundleFile= FileLocator.toFileURL(testBundleRoot); + File hostWorkspace= new File(testBundleFile.getFile()).getParentFile(); + String workspacePath= hostWorkspace.getAbsolutePath(); + fworkspacePathLength= workspacePath.length(); + File chkpiiResults= new File(hostWorkspace, "chkpiiResults"); + File tidy= new File(chkpiiResults, "tidy.txt"); + fTidyResults= new OutputStreamWriter(new FileOutputStream(tidy), "UTF-8"); + String startTime= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()); + fTidyResults.write(getClass().getName() + " started at " + startTime + "\n"); + fIgnores= getIgnores(); + + try { + boolean ok= true; +// ok&= checkFolder(new File(hostWorkspace, "org.eclipse.jdt.doc.user"), tidyResults); +// ok&= checkFolder(new File(hostWorkspace, "org.eclipse.jdt.doc.isv"), tidyResults); +// ok&= checkFolder(new File(hostWorkspace, "org.eclipse.platform.doc.user"), tidyResults); +// ok&= checkFolder(new File(hostWorkspace, "org.eclipse.platform.doc.isv"), tidyResults); +// ok&= checkFolder(new File(hostWorkspace + "/org.eclipse.jdt.doc.isv/guide")); + + ok&= checkFolder(hostWorkspace); + + assertTrue("See " + tidy.getAbsolutePath(), ok); + } finally { + fTidyResults.flush(); + fTidyResults.close(); + fTidyResults= null; + } + } + + private StringMatcher[] getIgnores() throws IOException { + ArrayList matchers= new ArrayList(); + InputStream is= getClass().getResourceAsStream("ignoreFiles.txt"); + BufferedReader reader= new BufferedReader(new InputStreamReader(is)); + while (reader.ready()) { + String line= reader.readLine(); + if (line.length() > 0) { + char first= line.charAt(0); + if (line.endsWith("/*")) + line= line.substring(0, line.length() - 2); // stops at directory during tree traversal + if (first != '/' && first != '*') { // relative matches + // emulate CHKPII specification: + // matchers.add(new StringMatcher(fWorkspacePath + "/" + line, true, false)); + + // emulate actual CHKPII implementation: + matchers.add(new StringMatcher("*/" + line, true, false)); + } + matchers.add(new StringMatcher(line, true, false)); + } + } + return (StringMatcher[]) matchers.toArray(new StringMatcher[matchers.size()]); + } + + private boolean isIgnored(File file) { + String relativePath= file.getAbsolutePath().substring(fworkspacePathLength); + relativePath= relativePath.replace('\\', '/'); + for (int i= 0; i < fIgnores.length; i++) { + StringMatcher matcher= fIgnores[i]; + if (matcher.match(relativePath)) + return true; + } + return false; + } + + private boolean checkFolder(File folder) throws Exception { + + File[] files= folder.listFiles(); + boolean success= true; + for (int i= 0; i < files.length; i++) { + File file= files[i]; + if (isIgnored(file)) { +// System.out.println("Ignored: " + file.getAbsolutePath() + (file.isDirectory() ? "/*" : "")); + continue; + } + if (isHTMLFile(file)) { + success&= checkFile(file); + } else if (file.isDirectory()) { + success&= checkFolder(file); + } + } + return success; + } + + private boolean checkFile(File file) throws Exception { + String filePath= file.getAbsolutePath(); + String command= "tidy -eq \"" + filePath + "\""; + final Process process= Runtime.getRuntime().exec(command); + long timeout= System.currentTimeMillis() + TIDY_TIMEOUT; + + BufferedReader tidyReader= new BufferedReader(new InputStreamReader(process.getErrorStream())); + boolean available= tidyReader.ready(); + boolean first= true; + while (available || System.currentTimeMillis() < timeout) { + if (! available) { + if (! isAlive(process)) + break; + Thread.sleep(100); + } else { + while (available) { + String line= tidyReader.readLine(); + if (isRelevant(line)) { + if (first) { + first= false; + fTidyResults.write("\n--- " + filePath +'\n'); + } + fTidyResults.write(line); + fTidyResults.write('\n'); + } + available= tidyReader.ready(); + } + } + available= tidyReader.ready(); + if (! available && ! isAlive(process)) + break; + } + fTidyResults.flush(); + try { + return process.exitValue() == 0; + } catch (IllegalThreadStateException e) { + process.destroy(); + fail("'" + command + "' killed after " + TIDY_TIMEOUT +" ms"); + return false; + } + } + + private static boolean isRelevant(String line) { + return ! EXCLUSION_PATTERN_TABLE_SUMMARY.matcher(line).matches() + && ! EXCLUSION_PATTERN_EMPTY_TAG.matcher(line).matches() + && ! EXCLUSION_PATTERN_MALFORMED_URI.matcher(line).matches() + && ! eXCLUSION_PATTERN_SCRIPT_TYPE.matcher(line).matches() + && ! eXCLUSION_PATTERN_IMG_LACKS_ALT.matcher(line).matches() + ; + } + + private static boolean isAlive(Process process) { + try { + process.exitValue(); + } catch (IllegalThreadStateException e) { + return true; + } + return false; + } + + private static boolean isHTMLFile(File file) { + String name= file.getName(); + return (name.endsWith(".html") || name.endsWith(".htm")) && file.isFile(); + } +} diff --git a/testplugins/org.eclipse.jdt.ui.tests/chkpii/org/eclipse/jdt/ui/tests/chkpii/ignoreErrorsUnix.txt b/testplugins/org.eclipse.jdt.ui.tests/chkpii/org/eclipse/jdt/ui/tests/chkpii/ignoreErrorsUnix.txt new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/testplugins/org.eclipse.jdt.ui.tests/chkpii/org/eclipse/jdt/ui/tests/chkpii/ignoreErrorsUnix.txt diff --git a/testplugins/org.eclipse.jdt.ui.tests/chkpii/org/eclipse/jdt/ui/tests/chkpii/ignoreErrorsWindows.txt b/testplugins/org.eclipse.jdt.ui.tests/chkpii/org/eclipse/jdt/ui/tests/chkpii/ignoreErrorsWindows.txt new file mode 100644 index 000000000..3a8856178 --- /dev/null +++ b/testplugins/org.eclipse.jdt.ui.tests/chkpii/org/eclipse/jdt/ui/tests/chkpii/ignoreErrorsWindows.txt @@ -0,0 +1,2 @@ +127 +128 diff --git a/testplugins/org.eclipse.jdt.ui.tests/chkpii/org/eclipse/jdt/ui/tests/chkpii/ignoreFiles.txt b/testplugins/org.eclipse.jdt.ui.tests/chkpii/org/eclipse/jdt/ui/tests/chkpii/ignoreFiles.txt new file mode 100644 index 000000000..9839ed5e6 --- /dev/null +++ b/testplugins/org.eclipse.jdt.ui.tests/chkpii/org/eclipse/jdt/ui/tests/chkpii/ignoreFiles.txt @@ -0,0 +1,133 @@ +feature.properties +feature.xml +cpl-*.html +epl-*.html +ipl-*.html +license.html +about.html +notice.html +customBuildCallbacks.xml +buildnotes*.htm +buildnotes*.html +*/bin/* +*/plugin-export/* +*/.metadata/* +*/doc_zip/* +*/scripts/* +*/icons/* + +com.oti.zrh.contextids/* +com.oti.zrh.eclipse.tools/* +com.oti.zrh.eclipse.doc.tools-feature/* +com.oti.zrh.eclipse.tools-updateSite/* + +javax.servlet/* + +org.eclipse.jdt.ui.tests.refactoring/resources/* +org.eclipse.jdt.ui/core*extension\org/eclipse/jdt/internal/corext/template/default-codetemplates.xml +org.eclipse.pde.doc.isv/buildDoc.xml +org.eclipse.pde.doc.user/buildDoc.xml + +org.eclipse.platform.doc.isv/buildDoc.xml +org.eclipse.jdt.doc.isv/buildDoc.xml +org.eclipse.jdt.core/* +org.eclipse.core.resources/build-user.xml +org.eclipse.core.tests.resources/test.xml +org.eclipse.tomcat/conf/* +org.eclipse.ui/plugin.xml +org.eclipse.platform.source/* +org.apache.ant/* +org.eclipse.ant.core/* +org.eclipse.ant.ui/* +org.eclipse.help.webapp/* +org.eclipse.pde.ui/* +org.eclipse.pde.build/* +org.eclipse.releng.tools/* +org.eclipse.sdk.tests-feature/* +org.eclipse.sdk-feature/* +org.eclipse.perfmsr.core/* +org.eclipse.test.performance.ui/* +org.eclipse.pde.source/* +org.eclipse.ui.examples.recipeeditor/doc/article.html +org.eclipse.ui.examples.recipeeditor/templates/templates.xml +org.eclipse.ant.core/* +org.eclipse.core.commands/* +org.eclipse.core.contenttype/* +org.eclipse.core.filesystem/* +org.eclipse.core.filesystem.linux.x86/* +org.eclipse.core.jobs/* +org.eclipse.core.resources/* +org.eclipse.core.resources.compatibility/* +org.eclipse.core.runtime/* +org.eclipse.core.runtime.compatibility/* +org.eclipse.core.runtime.compatibility.registry/* +org.eclipse.core.variables/* +org.eclipse.core.tests.harness/* +org.eclipse.debug.core/* +org.eclipse.debug.ui/* +org.eclipse.equinox.common/* +org.eclipse.equinox.preferences/* +org.eclipse.equinox.registry/* +org.eclipse.equinox.p2.metadata.generator/* +org.eclipse.equinox.p2.engine/* +org.eclipse.equinox.p2.publisher/* +org.eclipse.help/* +org.eclipse.help.appserver/* +org.eclipse.help.base/* +org.eclipse.help.ui/* +org.eclipse.jdt.debug/* +org.eclipse.jdt.debug.ui/* +org.eclipse.jdt.launching/* +org.eclipse.jdt.launching.j9/* +org.eclipse.jface/* +org.eclipse.osgi/* +org.eclipse.pde/* +org.eclipse.pde.core/* +org.eclipse.sdk/* +org.eclipse.swt/* +org.eclipse.swt.examples/* +org.eclipse.swt.gtk.linux.x86/* +org.eclipse.swt.win32.win32.x86/* +org.eclipse.team.core/* +org.eclipse.team.ui/* +org.eclipse.ua.tests/* +org.eclipse.ui.cheatsheets/* +org.eclipse.ui.console/* +org.eclipse.ui.forms/* +org.eclipse.ui.intro/* +org.eclipse.ui.navigator/* +org.eclipse.ui.navigator.resources/* +org.eclipse.ui.tests/* +org.eclipse.ui.views/* +org.eclipse.ui.views.properties.tabbed/* +org.eclipse.ui.workbench/* +org.eclipse.ui.workbench.compatibility/* +org.eclipse.update.configurator/* +org.eclipse.update.core/* +org.eclipse.update.core.linux/* +org.eclipse.update.ui/* + +com.ibm.icu/* +javax.servlet.jsp/* +org.apache.ant/* +org.apache.commons.el/* +org.apache.jasper/* +org.apache.lucene/* +org.apache.lucene.analysis/* +org.junit4/* +org.objectweb.asm/* + +www*eclipse.org-eclipse-root/* +www*eclipse.org-development/* +www*platform-search/* +www*platform-UI/* +platform-releng-home/* +platform-search-home/* +platform-text-home/* +www*platform-text/* +platform-ui-home/* +jdt-ui-home/* +www*jdt-ui/* +Text*Team*Documents/* +Eclipse*JDT*Builds/* +T*JDT-UI*Team*Documents/* |