initial creation of tools project
diff --git a/plugins/org.eclipse.wtp.releng.tools/.classpath b/plugins/org.eclipse.wtp.releng.tools/.classpath
new file mode 100644
index 0000000..ce73933
--- /dev/null
+++ b/plugins/org.eclipse.wtp.releng.tools/.classpath
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.4"/>
+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/plugins/org.eclipse.wtp.releng.tools/.cvsignore b/plugins/org.eclipse.wtp.releng.tools/.cvsignore
new file mode 100644
index 0000000..5022c63
--- /dev/null
+++ b/plugins/org.eclipse.wtp.releng.tools/.cvsignore
@@ -0,0 +1,4 @@
+javaCompiler.wtpRelengTools.jar.args
+build.xml
+bin
+temp.folder
diff --git a/plugins/org.eclipse.wtp.releng.tools/.project b/plugins/org.eclipse.wtp.releng.tools/.project
new file mode 100644
index 0000000..99c64d2
--- /dev/null
+++ b/plugins/org.eclipse.wtp.releng.tools/.project
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.wtp.releng.tools</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ManifestBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.SchemaBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/plugins/org.eclipse.wtp.releng.tools/.settings/org.eclipse.jdt.core.prefs b/plugins/org.eclipse.wtp.releng.tools/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..88b7d71
--- /dev/null
+++ b/plugins/org.eclipse.wtp.releng.tools/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,58 @@
+#Sat Feb 24 15:04:32 EST 2007
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.4
+org.eclipse.jdt.core.compiler.compliance=1.4
+org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.autoboxing=ignore
+org.eclipse.jdt.core.compiler.problem.deprecation=ignore
+org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled
+org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=disabled
+org.eclipse.jdt.core.compiler.problem.discouragedReference=ignore
+org.eclipse.jdt.core.compiler.problem.emptyStatement=ignore
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=warning
+org.eclipse.jdt.core.compiler.problem.fallthroughCase=ignore
+org.eclipse.jdt.core.compiler.problem.fatalOptionalError=disabled
+org.eclipse.jdt.core.compiler.problem.fieldHiding=ignore
+org.eclipse.jdt.core.compiler.problem.finalParameterBound=warning
+org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=warning
+org.eclipse.jdt.core.compiler.problem.forbiddenReference=error
+org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=warning
+org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=warning
+org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=ignore
+org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=ignore
+org.eclipse.jdt.core.compiler.problem.localVariableHiding=ignore
+org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=warning
+org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=ignore
+org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation=ignore
+org.eclipse.jdt.core.compiler.problem.missingSerialVersion=warning
+org.eclipse.jdt.core.compiler.problem.noEffectAssignment=warning
+org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=warning
+org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=ignore
+org.eclipse.jdt.core.compiler.problem.nullReference=error
+org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=warning
+org.eclipse.jdt.core.compiler.problem.parameterAssignment=ignore
+org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=ignore
+org.eclipse.jdt.core.compiler.problem.rawTypeReference=ignore
+org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled
+org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=warning
+org.eclipse.jdt.core.compiler.problem.suppressWarnings=enabled
+org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=ignore
+org.eclipse.jdt.core.compiler.problem.typeParameterHiding=warning
+org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation=warning
+org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=ignore
+org.eclipse.jdt.core.compiler.problem.unhandledWarningToken=warning
+org.eclipse.jdt.core.compiler.problem.unnecessaryElse=ignore
+org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=ignore
+org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore
+org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=ignore
+org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=disabled
+org.eclipse.jdt.core.compiler.problem.unusedImport=warning
+org.eclipse.jdt.core.compiler.problem.unusedLabel=warning
+org.eclipse.jdt.core.compiler.problem.unusedLocal=warning
+org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore
+org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract=disabled
+org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete=disabled
+org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=warning
+org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
+org.eclipse.jdt.core.compiler.source=1.4
diff --git a/plugins/org.eclipse.wtp.releng.tools/META-INF/MANIFEST.MF b/plugins/org.eclipse.wtp.releng.tools/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..aaebddf
--- /dev/null
+++ b/plugins/org.eclipse.wtp.releng.tools/META-INF/MANIFEST.MF
@@ -0,0 +1,10 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: %Bundle-Name.0
+Bundle-SymbolicName: org.eclipse.wtp.releng.tools;singleton:=true
+Bundle-Version: 1.0.0.qualifier
+Require-Bundle: org.apache.ant
+Bundle-Localization: plugin
+Bundle-ClassPath: wtpRelengTools.jar
+Bundle-RequiredExecutionEnvironment: J2SE-1.4
+Export-Package: org.eclipse.wtp.releng.tools
diff --git a/plugins/org.eclipse.wtp.releng.tools/build.properties b/plugins/org.eclipse.wtp.releng.tools/build.properties
new file mode 100644
index 0000000..d863dc9
--- /dev/null
+++ b/plugins/org.eclipse.wtp.releng.tools/build.properties
@@ -0,0 +1,5 @@
+bin.includes = META-INF/,\
+               plugin.xml,\
+               plugin.properties,\
+               wtpRelengTools.jar
+source.wtpRelengTools.jar = src/
diff --git a/plugins/org.eclipse.wtp.releng.tools/plugin.properties b/plugins/org.eclipse.wtp.releng.tools/plugin.properties
new file mode 100644
index 0000000..be037b9
--- /dev/null
+++ b/plugins/org.eclipse.wtp.releng.tools/plugin.properties
@@ -0,0 +1,2 @@
+# properties file for org.eclipse.wtp.releng.tools
+Bundle-Name.0 = Tools
\ No newline at end of file
diff --git a/plugins/org.eclipse.wtp.releng.tools/plugin.xml b/plugins/org.eclipse.wtp.releng.tools/plugin.xml
new file mode 100644
index 0000000..65d7b9d
--- /dev/null
+++ b/plugins/org.eclipse.wtp.releng.tools/plugin.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.2"?>
+<plugin>
+
+  <extension
+         point="org.eclipse.ant.core.extraClasspathEntries">
+      <extraClasspathEntry
+            library="wtpRelengTools.jar">
+      </extraClasspathEntry>
+   </extension>
+	<!-- Tasks -->
+   <extension point="org.eclipse.ant.core.antTasks">
+   
+       <antTask
+            library="wtpRelengTools.jar"
+            name="summarizeResults"
+            class="org.eclipse.wtp.releng.tools.ResultsSummaryGenerator">
+      </antTask>
+       <antTask
+            library="wtpRelengTools.jar"
+            name="countBuildFiles"
+            class="org.eclipse.wtp.releng.tools.FileCounter">
+      </antTask>
+       <antTask
+            library="wtpRelengTools.jar"
+            name="customizeAccessRules"
+            class="org.eclipse.wtp.releng.tools.CustomizeAccessRules">
+      </antTask>
+ 
+    </extension>
+
+</plugin>
diff --git a/plugins/org.eclipse.wtp.releng.tools/src/org/eclipse/wtp/releng/tools/CustomizeAccessRules.java b/plugins/org.eclipse.wtp.releng.tools/src/org/eclipse/wtp/releng/tools/CustomizeAccessRules.java
new file mode 100644
index 0000000..fe0f977
--- /dev/null
+++ b/plugins/org.eclipse.wtp.releng.tools/src/org/eclipse/wtp/releng/tools/CustomizeAccessRules.java
@@ -0,0 +1,389 @@
+package org.eclipse.wtp.releng.tools;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.FilenameFilter;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+
+import org.apache.tools.ant.BuildException;
+import org.apache.tools.ant.Task;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+
+public class CustomizeAccessRules extends Task {
+
+	private static final String LINE_SEPARATOR_PROPERTY_NAME = "line.separator";
+	private static final String PATH_SEPARATOR_PROPERTY_NAME = "path.separator";
+
+	static class JavaCompilerFilter implements FilenameFilter {
+
+		private static final String JAVA_COMPILER_FILENAME_EXTENSION = "args";
+		private static final String JAVA_COMPILER_FILENAME_PREFIX = "javaCompiler";
+
+		public boolean accept(File dir, String name) {
+			if (name.startsWith(JAVA_COMPILER_FILENAME_PREFIX) && name.endsWith(JAVA_COMPILER_FILENAME_EXTENSION)) {
+				return true;
+			}
+			return false;
+		}
+
+	}
+
+	private String bundleDirectory;
+	private String defaultRules;
+
+
+	private static final String FORBID_CHARACTER = "-";
+	private static final String DISCOURAGED_CHARACTER = "~";
+	private static final String ACCESSIBLE_CHARACTER = "+";
+	private static final String NONACCESSIBLE_RULE_VALUE = "nonaccessible";
+	private static final String DISCOURAGED_RULE_VALUE = "discouraged";
+	private static final String ACCESSIBLE_RULE_VALUE = "accessible";
+	private static final String PATTERN_ATTRIBUTE_NAME = "pattern";
+	private static final String KIND_ATTRIBUTE_NAME = "kind";
+	private static final String ACCESSRULE_ELEMENT_NAME = "accessrule";
+	private static final String ORG_ECLIPSE_PDE_CORE_REQUIRED_PLUGINS = "org.eclipse.pde.core.requiredPlugins";
+	private static final String PATH_ATTRIBUTE_NAME = "path";
+	private static final String CLASSPATHENTRY_ELEMENT_NAME = "classpathentry";
+	private static final String RBRACKET = "]";
+	private static final String LBRACKET = "[";
+	private static final String BACKUP_FILE_EXTENSION = ".bak";
+	private static final String CLASSPATH_FILENAME = ".classpath";
+	private static final String COMMA = ",";
+	private static final String ADAPTER_ACCESS = "#ADAPTER#ACCESS#";
+
+
+	private static String EOL = System.getProperty(LINE_SEPARATOR_PROPERTY_NAME);
+	private static String PATH_SEPERATOR = System.getProperty(PATH_SEPARATOR_PROPERTY_NAME);
+	private static FilenameFilter javaCompilerFilter = new JavaCompilerFilter();
+
+	private static Pattern adapterAccessLinePattern = Pattern.compile(ADAPTER_ACCESS + "(.*)\\[(.*)\\]");
+
+
+	private String computeCustomizedRules(File classpathFile) {
+		// first priority is to use any from classpath file.
+		String results = extractClassPathRules(classpathFile);
+		// if none, see if default rules have been specified in task element
+		if ((results == null) || (results.length() == 0)) {
+			if ((getDefaultRules() != null) && (getDefaultRules().length() > 0)) {
+				results = convertForm(getDefaultRules());
+			}
+		}
+		return results;
+	}
+
+	private boolean contains(String mainString, String toBeFound) {
+		return (-1 < mainString.indexOf(toBeFound));
+	}
+
+	private String convertForm(String commaSeperatedList) {
+		String result = commaSeperatedList;
+		result = result.replaceAll(COMMA, PATH_SEPERATOR);
+		result = removeSpace(result);
+		return result + PATH_SEPERATOR;
+	}
+
+	private void customizeAccess(File javaCompilerFile, File classpathFile) {
+		try {
+
+			String name = javaCompilerFile.getName();
+			String bakName = name + BACKUP_FILE_EXTENSION;
+			File bakFile = new File(javaCompilerFile.getParentFile(), bakName);
+			// if backup already exists, just keep adding '.bak' until doesn't
+			while (bakFile.exists()) {
+				bakName = bakName + BACKUP_FILE_EXTENSION;
+				bakFile = new File(javaCompilerFile.getParentFile(), bakName);
+			}
+
+			/*
+			 * FYI. Seems like the javaCompiler file is recreated, from one
+			 * compile/generate step to another, so we need to re-process
+			 * (that is, the existence of the .bak file doesn't mean we are
+			 * done).
+			 */
+
+			FileReader fileReader = new FileReader(javaCompilerFile);
+			BufferedReader bufferedReader = new BufferedReader(fileReader);
+
+			File newFile = new File(javaCompilerFile.getParentFile(), "tempnew" + javaCompilerFile.getName());
+			FileWriter newFileWriter = new FileWriter(newFile);
+
+			while (bufferedReader.ready()) {
+				String line = bufferedReader.readLine();
+				Matcher matcher = adapterAccessLinePattern.matcher(line);
+				if (matcher.matches()) {
+					String cp = matcher.group(1);
+					String ar = matcher.group(2);
+
+					String customizedRules = computeCustomizedRules(classpathFile);
+
+					if (contains(ar, customizedRules)) {
+						// simply re-write what we already have
+						newFileWriter.write(ADAPTER_ACCESS + cp + LBRACKET + ar + RBRACKET + EOL);
+					}
+					else {
+						// or, add if not already there
+						System.out.println("     Info: customized access rules with pattern: " + customizedRules);
+						newFileWriter.write(ADAPTER_ACCESS + cp + LBRACKET + customizedRules + ar + RBRACKET + EOL);
+					}
+				}
+				else {
+					System.out.println("Debug: Line did not match grammar syntax expectations: " + line);
+					newFileWriter.write(line + EOL);
+				}
+
+			}
+
+			newFileWriter.close();
+			fileReader.close();
+
+			File holdFile = new File(javaCompilerFile.getParentFile(), javaCompilerFile.getName());
+			javaCompilerFile.renameTo(bakFile);
+			newFile.renameTo(holdFile);
+
+		}
+		catch (FileNotFoundException e) {
+			throw new BuildException(e);
+		}
+		catch (IOException e) {
+			System.out.println("Could not read/write javaCompilerFile");
+			e.printStackTrace();
+		}
+
+	}
+
+	public void execute() throws BuildException {
+
+		try {
+			System.out.println("bundleDirectory: " + getBundleDirectory());
+
+			if ((getBundleDirectory() != null) && (getBundleDirectory().length() > 0)) {
+				File directory = new File(getBundleDirectory());
+				if ((directory != null) && directory.exists() && directory.isDirectory()) {
+					processBundlesDirectory(directory);
+				}
+				else {
+					String msg = "the directory does not exist";
+					System.out.println(msg);
+				}
+			}
+		}
+		catch (Exception e) {
+			e.printStackTrace();
+			throw new BuildException(e);
+		}
+
+	}
+
+	private String extractClassPathRules(File classpathFile) {
+		StringBuffer patterns = new StringBuffer();
+		Document aDocument = getDOM(classpathFile);
+		Element element = getElementWithAttribute(aDocument, CLASSPATHENTRY_ELEMENT_NAME, PATH_ATTRIBUTE_NAME, ORG_ECLIPSE_PDE_CORE_REQUIRED_PLUGINS);
+		NodeList nodeList = element.getElementsByTagName(ACCESSRULE_ELEMENT_NAME);
+
+		int length = nodeList.getLength();
+		if (length > 0) {
+			ArrayList accessible = new ArrayList();
+			ArrayList discouraged = new ArrayList();
+			ArrayList forbidden = new ArrayList();
+			for (int i = 0; i < length; i++) {
+				Node node = nodeList.item(i);
+				NamedNodeMap aNamedNodeMap = node.getAttributes();
+				Node kindAttribute = aNamedNodeMap.getNamedItem(KIND_ATTRIBUTE_NAME);
+				String kindValue = kindAttribute.getNodeValue();
+				Node patternAttribute = aNamedNodeMap.getNamedItem(PATTERN_ATTRIBUTE_NAME);
+				String patternValue = patternAttribute.getNodeValue();
+
+				if (ACCESSIBLE_RULE_VALUE.equals(kindValue)) {
+					accessible.add(patternValue);
+				}
+				else if (DISCOURAGED_RULE_VALUE.equals(kindValue)) {
+					discouraged.add(patternValue);
+				}
+				else if (NONACCESSIBLE_RULE_VALUE.equals(kindValue)) {
+					forbidden.add(patternValue);
+				}
+			}
+
+			/*
+			 * we store all the node/attribute values in arrayLists first,
+			 * just to be positive we add them in order or acceessible,
+			 * discouraged, and forbidden. (I'm not positive the
+			 * getElementsByTagName gaurentees the order we want).
+			 */
+			for (int j = 0; j < accessible.size(); j++) {
+				patterns.append(ACCESSIBLE_CHARACTER + (String) accessible.get(j) + PATH_SEPERATOR);
+			}
+			for (int j = 0; j < discouraged.size(); j++) {
+				patterns.append(DISCOURAGED_CHARACTER + (String) discouraged.get(j) + PATH_SEPERATOR);
+			}
+			for (int j = 0; j < forbidden.size(); j++) {
+				patterns.append(FORBID_CHARACTER + (String) forbidden.get(j) + PATH_SEPERATOR);
+			}
+		}
+		String result = patterns.toString();
+		return result;
+	}
+
+	public String getBundleDirectory() {
+		return bundleDirectory;
+	}
+
+	public String getDefaultRules() {
+		return defaultRules;
+	}
+
+	private Document getDOM(File file) {
+
+		Document aDocument = null;
+		BufferedReader reader = null;
+		try {
+			reader = new BufferedReader(new FileReader(file));
+			InputSource inputSource = new InputSource(reader);
+			DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+			DocumentBuilder builder = factory.newDocumentBuilder();
+			aDocument = builder.parse(inputSource);
+		}
+		catch (SAXException e) {
+			e.printStackTrace();
+		}
+		catch (IOException e) {
+			e.printStackTrace();
+		}
+		catch (ParserConfigurationException e) {
+			e.printStackTrace();
+		}
+		finally {
+			if (reader != null) {
+				try {
+					reader.close();
+				}
+				catch (IOException e) {
+					// ignore this one
+				}
+			}
+		}
+
+		if (aDocument == null) {
+			String msg = "Error: could not parse xml in classpath file: " + file.getAbsolutePath();
+			throw new BuildException(msg);
+		}
+		return aDocument;
+
+	}
+
+	private Element getElementWithAttribute(Document aDocument, String elementName, String attributeName, String attributeValue) {
+		Element element = null;
+		NodeList nodeList = aDocument.getElementsByTagName(elementName);
+
+		int length = nodeList.getLength();
+		for (int i = 0; i < length; i++) {
+			Node node = nodeList.item(i);
+			NamedNodeMap aNamedNodeMap = node.getAttributes();
+			Node attribute = aNamedNodeMap.getNamedItem(attributeName);
+			if (attribute.getNodeValue().equals(attributeValue)) {
+				element = (Element) node;
+				break;
+			}
+		}
+		return element;
+	}
+
+	private boolean isSuitable(File file) {
+		return (file != null) && file.exists() && file.canRead() && file.canWrite();
+	}
+
+	private void processBundlesDirectory(File bundlesDirectory) {
+
+		if (bundlesDirectory == null) {
+			throw new BuildException("Error: bundlesDirectory can not be null");
+		}
+
+		String[] files = bundlesDirectory.list();
+		if ((files == null) || (files.length == 0)) {
+			throw new BuildException("Error: bundlesDirectory was empty");
+		}
+
+		for (int i = 0; i < files.length; i++) {
+			File file = new File(bundlesDirectory, files[i]);
+			if (file.isFile()) {
+				System.out.println("debug info: top level file ignored: " + file.getName());
+			}
+			else {
+				processDirectory(file);
+			}
+		}
+
+	}
+
+	private void processDirectory(File directory) {
+
+		String[] allFiles = directory.list();
+		if (allFiles == null) {
+			throw new BuildException("Error: bundlesDirectory was empty");
+		}
+
+		File classpathFile = new File(directory, CLASSPATH_FILENAME);
+		File[] javaCompilerFiles = directory.listFiles(javaCompilerFilter);
+
+		File javaCompilerFile = null;
+		if (javaCompilerFiles != null) {
+			for (int j = 0; j < javaCompilerFiles.length; j++) {
+				javaCompilerFile = javaCompilerFiles[j];
+				if (isSuitable(javaCompilerFile) && isSuitable(classpathFile)) {
+					System.out.println("   Info: customizing access rules in " + directory.getName());
+					customizeAccess(javaCompilerFile, classpathFile);
+				}
+			}
+		}
+	}
+
+	/**
+	 * Simply space remover (not for natural language)
+	 * 
+	 * @param s
+	 * @return String
+	 */
+	private String removeSpace(String s) {
+		String results = null;
+		StringBuffer sb = new StringBuffer();
+		for (int i = 0; i < s.length(); i++) {
+			char c = s.charAt(i);
+			if (Character.isWhitespace(c)) {
+				// do not copy to buffer
+			}
+			else {
+				// add to buffer
+				sb.append(c);
+			}
+		}
+		if (sb.length() > 0) {
+			results = sb.toString();
+		}
+		return results;
+
+	}
+
+	public void setBundleDirectory(String bundleDirectory) {
+		this.bundleDirectory = bundleDirectory;
+	}
+
+	public void setDefaultRules(String defaultRules) {
+		this.defaultRules = defaultRules;
+	}
+}
diff --git a/plugins/org.eclipse.wtp.releng.tools/src/org/eclipse/wtp/releng/tools/FileCounter.java b/plugins/org.eclipse.wtp.releng.tools/src/org/eclipse/wtp/releng/tools/FileCounter.java
new file mode 100644
index 0000000..f21de90
--- /dev/null
+++ b/plugins/org.eclipse.wtp.releng.tools/src/org/eclipse/wtp/releng/tools/FileCounter.java
@@ -0,0 +1,146 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2006 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.wtp.releng.tools;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.StringTokenizer;
+import org.apache.tools.ant.BuildException;
+import org.apache.tools.ant.Task;
+
+/**
+ * This task will count the number of fils in a given directory
+ * that match a given filter.  The number of fils will be output
+ * to a given output file.  The output file will be overwritten
+ * if it already exists.
+ * 
+ * Note: Filter comparison is NOT case sensitive.  Do not use wild cards.
+ * ie .zip counts all files with .zip anywere in the name.
+ */
+public class FileCounter extends Task {
+	
+	private String sourceDirectory = "";
+	private String filterString = ".zip";
+	private String outputFile = "";
+	
+	public static void main(String args[]) {
+		// For testing only.
+		FileCounter aFileCounter = new FileCounter();
+		aFileCounter.setSourceDirectory("c:\\RelEng\\dean");
+		aFileCounter.setOutputFile("c:\\RelEng\\dean\\files.count");
+		aFileCounter.setFilterString(".zip");
+		aFileCounter.execute();
+	}
+
+	public void execute() throws BuildException {
+		// Do the work.
+		
+		int count = 0;
+		
+		System.out.println("Source Directory: " + this.getSourceDirectory());
+		System.out.println("Output File: " + this.getOutputFile());
+		System.out.println("Filter String: " + this.getFilterString());
+		
+		File aDirectory = new File(this.getSourceDirectory());
+//		if (aDirectory == null) {
+//			throw new BuildException("Directory " + this.getSourceDirectory() + " not found.");
+//		}
+		
+		String[] names = aDirectory.list();
+		if (names == null) {
+			throw new BuildException("Directory " + this.getSourceDirectory() + " not found.");
+		}			
+		
+		System.out.println("List size: " + names.length);
+		
+		for (int i = 0; i < names.length; i++) {
+			System.out.println("Name: " + names[i]);
+			
+			int index = -1;
+			StringTokenizer types = getFileTypes();
+			
+			while (types.hasMoreTokens()){
+				index = names[i].toLowerCase().indexOf(types.nextToken().toLowerCase());
+				if (index != -1) {
+					count++;
+				}
+			}
+
+		}
+		
+		try {
+			FileOutputStream anOutputStream = new FileOutputStream(this.getOutputFile());
+			anOutputStream.write(String.valueOf(count).getBytes());
+			anOutputStream.close();
+		} catch (FileNotFoundException e) {
+			throw new BuildException("Can not create file.count file");
+		} catch (IOException e) {
+			throw new BuildException("Can not create file.count file");
+		}
+		
+	}
+
+	private StringTokenizer getFileTypes(){
+		return new StringTokenizer(getFilterString(),",");
+	}
+
+	/**
+	 * Gets the sourceDirectory.
+	 * @return Returns a String
+	 */
+	public String getSourceDirectory() {
+		return sourceDirectory;
+	}
+
+	/**
+	 * Sets the sourceDirectory.
+	 * @param sourceDirectory The sourceDirectory to set
+	 */
+	public void setSourceDirectory(String sourceDirectory) {
+		this.sourceDirectory = sourceDirectory;
+	}
+
+	/**
+	 * Gets the filterString.
+	 * @return Returns a String
+	 */
+	public String getFilterString() {
+		return filterString;
+	}
+
+	/**
+	 * Sets the filterString.
+	 * @param filterString The filterString to set
+	 */
+	public void setFilterString(String filterString) {
+		this.filterString = filterString;
+	}
+
+	/**
+	 * Gets the outputFile.
+	 * @return Returns a String
+	 */
+	public String getOutputFile() {
+		return outputFile;
+	}
+
+	/**
+	 * Sets the outputFile.
+	 * @param outputFile The outputFile to set
+	 */
+	public void setOutputFile(String outputFile) {
+		this.outputFile = outputFile;
+	}
+
+}
diff --git a/plugins/org.eclipse.wtp.releng.tools/src/org/eclipse/wtp/releng/tools/FullJarNameParser.java b/plugins/org.eclipse.wtp.releng.tools/src/org/eclipse/wtp/releng/tools/FullJarNameParser.java
new file mode 100644
index 0000000..d8e0264
--- /dev/null
+++ b/plugins/org.eclipse.wtp.releng.tools/src/org/eclipse/wtp/releng/tools/FullJarNameParser.java
@@ -0,0 +1,78 @@
+/*******************************************************************************
+ * Copyright (c) 2006 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.wtp.releng.tools;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class FullJarNameParser {
+
+	private static final boolean DEBUG = false; 
+	// simplified pattern: (ID) '_' (N '.' M '.' O '.' S) '.jar'
+	private String START_GROUP = "(";
+	private String END_GROUP = ")";
+	private String UNDERSCORE = "_";
+	private String BACKSLASH = "\\";
+	private String LITERAL_PERIOD = BACKSLASH + ".";
+	private String ANYDIGITS = BACKSLASH + "d" + "*";
+	private String ANY = ".*";
+	private Pattern pattern = Pattern.compile(START_GROUP + ANY + END_GROUP + UNDERSCORE + START_GROUP + START_GROUP + ANYDIGITS + END_GROUP + LITERAL_PERIOD + START_GROUP + ANYDIGITS + END_GROUP + LITERAL_PERIOD + START_GROUP + ANYDIGITS + END_GROUP + START_GROUP + LITERAL_PERIOD + ANY + END_GROUP + "?" + END_GROUP);
+
+	private String projectString;
+	private String versionString;
+
+
+
+	public FullJarNameParser() {
+		super();
+	}
+
+	public boolean parse(String line) {
+		boolean result = false;
+		projectString = "";
+		versionString = "";
+		Matcher matcher = pattern.matcher(line);
+
+		if (!matcher.matches()) {
+			System.out.println();
+			System.out.println("\tthe line did not match parse rule: ");
+			System.out.println("\t" + line);
+			System.out.println();
+			result = false;
+		}
+		else {
+
+			projectString = matcher.group(1);
+			versionString = matcher.group(2);
+			if (DEBUG) {
+				System.out.println(projectString);
+				System.out.println(versionString);
+				System.out.println();
+			}
+			result = true;
+		}
+		return result;
+	}
+
+
+
+	public String getProjectString() {
+		return projectString;
+	}
+
+
+
+	public String getVersionString() {
+		return versionString;
+	}
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.wtp.releng.tools/src/org/eclipse/wtp/releng/tools/ResultsSummaryGenerator.java b/plugins/org.eclipse.wtp.releng.tools/src/org/eclipse/wtp/releng/tools/ResultsSummaryGenerator.java
new file mode 100644
index 0000000..5e9566f
--- /dev/null
+++ b/plugins/org.eclipse.wtp.releng.tools/src/org/eclipse/wtp/releng/tools/ResultsSummaryGenerator.java
@@ -0,0 +1,1242 @@
+package org.eclipse.wtp.releng.tools;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.Writer;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+import java.util.Vector;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.FactoryConfigurationError;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.transform.OutputKeys;
+import javax.xml.transform.Source;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.TransformerFactoryConfigurationError;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+
+import org.apache.tools.ant.BuildException;
+import org.apache.tools.ant.Project;
+import org.apache.tools.ant.Task;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.w3c.dom.Text;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+
+/**
+ * This class was original based on TestResultsGenerator.java from the
+ * org.eclilpse.build.tools project in the basebuilder.
+ * 
+ */
+public class ResultsSummaryGenerator extends Task {
+
+	private static final String WARNING_SEVERITY = "WARNING";
+	private static final String ERROR_SEVERITY = "ERROR";
+	private static final String ForbiddenReferenceID = "ForbiddenReference";
+	private static final String DiscouragedReferenceID = "DiscouragedReference";
+
+	private static final int DEFAULT_READING_SIZE = 8192;
+	private String EOL = System.getProperty("line.separator");
+
+	private static final String elementName = "testsuite";
+	private static final String testResultsToken = "%testresults%";
+	private static final String compileLogsToken = "%compilelogs%";
+	public Vector dropTokens;
+	public Vector platformSpecs;
+	public Vector differentPlatforms;
+	public String testResultsWithProblems = EOL;
+
+	private DocumentBuilder parser = null;
+	public String testResultsTemplateString = "";
+	public String dropTemplateString = "";
+
+	public Vector platformDescription;
+	public Vector platformTemplateString;
+	public Vector platformDropFileName;
+
+	// Status of tests results (pending, successful, failed), used to specify
+	// the color
+	// of the test Results link on the build pages (standard, green, red),
+	// once failures
+	// are encountered, this is set to failed
+	// protected String testResultsStatus = "successful";
+	// assume tests ran. If no html files are found, this is set to false
+	private boolean testsRan = true;
+
+	// Parameters
+	// build runs JUnit automated tests
+	private boolean isBuildTested;
+
+	// buildType, I, N
+	public String buildType;
+
+	// Comma separated list of drop tokens
+	public String dropTokenList;
+
+	// Token in platform.php.template to be replaced by the desired platform
+	// ID
+	public String platformIdentifierToken;
+
+	// Location of the xml files
+	public String xmlDirectoryName;
+
+	// Location of the html files
+	public String htmlDirectoryName;
+
+	// Location of the resulting index.php file.
+	public String dropDirectoryName;
+
+	// Location and name of the template index.php file.
+	public String testResultsTemplateFileName;
+
+	// Platform specific template and output list (colon separated) in the
+	// following format:
+	// <descriptor, ie. OS name>,path to template file, path to output file
+	// public String platformSpecificTemplateList = "";
+
+	// Name of the generated index php file.
+	public String testResultsHtmlFileName;
+
+	// Name of the generated drop index php file;
+	public String dropHtmlFileName;
+
+	// Arbitrary path used in the index.php page to href the
+	// generated .html files.
+	public String hrefTestResultsTargetPath;
+
+	// Aritrary path used in the index.php page to reference the compileLogs
+	public String hrefCompileLogsTargetPath;
+
+	// Location of compile logs base directory
+	public String compileLogsDirectoryName;
+
+	// Location and name of test manifest file
+	public String testManifestFileName;
+
+	private FullJarNameParser nameParser = new FullJarNameParser();
+
+	private static class UnitTestResults {
+		private int errors = -99;
+		private int failures = -99;
+		private int totalTests = -99;
+
+		int getErrors() {
+			return errors;
+		}
+
+		void setErrors(int errors) {
+			this.errors = errors;
+		}
+
+		int getFailures() {
+			return failures;
+		}
+
+		void setFailures(int failures) {
+			this.failures = failures;
+		}
+
+		int getTotalTests() {
+			return totalTests;
+		}
+
+		void setTotalTests(int totalTests) {
+			this.totalTests = totalTests;
+		}
+	}
+
+	public static void main(String[] args) {
+		ResultsSummaryGenerator test = new ResultsSummaryGenerator();
+		test
+				.setDropTokenList("%sdk%,%tests%,%example%,%rcpruntime%,%rcpsdk%,%icubase%,%runtime%,%platformsdk%,%jdt%,%jdtsdk%,%pde%,%pdesdk%,%cvs%,%cvssdk%,%teamextras%,%swt%,%relengtools%");
+		test.setPlatformIdentifierToken("%platform%");
+		test.getDropTokensFromList(test.dropTokenList);
+		test.setIsBuildTested(true);
+		test.setXmlDirectoryName("C:\\junk\\testresults\\xml");
+		test.setHtmlDirectoryName("C:\\junk\\testresults");
+		test.setDropDirectoryName("C:\\junk");
+		test
+				.setTestResultsTemplateFileName("C:\\junk\\templateFiles\\testResults.php.template");
+		// test.setPlatformSpecificTemplateList("Windows,C:\\junk\\templateFiles\\platform.php.template,winPlatform.php;Linux,C:\\junk\\templateFiles\\platform.php.template,linPlatform.php;Solaris,C:\\junk\\templateFiles\\platform.php.template,solPlatform.php;AIX,C:\\junk\\templateFiles\\platform.php.template,aixPlatform.php;Macintosh,C:\\junk\\templateFiles\\platform.php.template,macPlatform.php;Source
+		// Build,C:\\junk\\templateFiles\\sourceBuilds.php.template,sourceBuilds.php");
+		test.setTestResultsHtmlFileName("testResults.php");
+		// test.setDropHtmlFileName("index.php");
+		test.setDropHtmlFileName("index.html");
+
+		test.setHrefTestResultsTargetPath("testresults");
+		test.setCompileLogsDirectoryName("C:\\junk\\compilelogs\\plugins");
+		test.setHrefCompileLogsTargetPath("compilelogs");
+		test.setTestManifestFileName("C:\\junk\\testManifest.xml");
+		test.execute();
+	}
+
+	public void execute() {
+
+		try {
+			getDropTokensFromList(dropTokenList);
+			testResultsTemplateString = readFile(testResultsTemplateFileName);
+			// dropTemplateString = readFile(dropTemplateFileName);
+
+			// Specific to the platform build-page
+			/*
+			 * if (platformSpecificTemplateList != "") { String description,
+			 * platformTemplateFile, platformDropFile; // Retrieve the different
+			 * platforms and their info
+			 * getDifferentPlatformsFromList(platformSpecificTemplateList); //
+			 * Parses the platform info and retrieves the platform name, //
+			 * template file, and drop file for (int i = 0; i <
+			 * differentPlatforms.size(); i++) {
+			 * getPlatformSpecsFromList(differentPlatforms.get(i).toString());
+			 * description = platformSpecs.get(0).toString();
+			 * platformTemplateFile = platformSpecs.get(1).toString();
+			 * platformDropFile = platformSpecs.get(2).toString();
+			 * platformDescription.add(description);
+			 * platformTemplateString.add(readFile(platformTemplateFile));
+			 * platformDropFileName.add(platformDropFile); } }
+			 */
+
+			System.out.println("Begin: Generating test results index page");
+			System.out.println("Parsing XML files");
+			parseUnitTestXml();
+			System.out.println("Parsing compile logs");
+			parseCompileLogs();
+			System.out.println("End: Generating test results index page");
+			writeTestResultsFile();
+			// For the platform build-page, write platform files, in addition
+			// to
+			// the index file
+			// if (platformSpecificTemplateList != "") {
+			// writeDropFiles();
+			// }
+			// else {
+			// }
+		} catch (Exception e) {
+			throw new BuildException(e);
+		}
+	}
+
+	private void parseCompileLogs()
+			throws TransformerFactoryConfigurationError, IOException,
+			TransformerException {
+		totalErrors = 0;
+		totalAccess = 0;
+		totalWarnings = 0;
+		rowCount = 0;
+		totaldiscouragedAccessWarningCount = 0;
+		totalforbiddenAccessWarningCount = 0;
+
+		StringBuffer replaceString = new StringBuffer();
+		processCompileLogsDirectory(compileLogsDirectoryName, replaceString);
+
+		writeFormattedTotals(replaceString);
+		writeCompileSummaryTotalsAsXML(compileLogsDirectoryName);
+
+		if (replaceString.length() == 0) {
+			replaceString.append("None");
+		}
+
+		testResultsTemplateString = replace(testResultsTemplateString,
+				compileLogsToken, String.valueOf(replaceString));
+
+	}
+
+	/**
+	 * @param mainSummaryName
+	 * @throws TransformerException
+	 * @throws IOException
+	 * @throws TransformerFactoryConfigurationError
+	 */
+	private void writeCompileSummaryTotalsAsXML(String mainSummaryName)
+			throws TransformerFactoryConfigurationError, IOException,
+			TransformerException {
+		String outputFileName = mainSummaryName + "Summary" + ".xml";
+		// debug
+		// System.out.println("dropDirectoryName: " + dropDirectoryName);
+		// System.out.println("outputFileName: " + outputFileName);
+		// File fileDir = new File(dropDirectoryName);
+		File file = new File(outputFileName);
+		file.createNewFile();
+		Node rootNode = createNewDOM("compileSummary");
+		addSummaryNodeTo(rootNode, "totalBundles", rowCount);
+		addSummaryNodeTo(rootNode, "totalErrors", totalErrors);
+		addSummaryNodeTo(rootNode, "totalWarnings", totalWarnings);
+		addSummaryNodeTo(rootNode, "totalAccess", totalAccess);
+		addSummaryNodeTo(rootNode, "totaldiscouragedAccessWarningCount",
+				totaldiscouragedAccessWarningCount);
+		addSummaryNodeTo(rootNode, "totalforbiddenAccessWarningCount",
+				totalforbiddenAccessWarningCount);
+		serialize(rootNode, file);
+
+	}
+
+	private void serialize(Node rootNode, File outputFile)
+			throws TransformerFactoryConfigurationError, IOException,
+			TransformerException {
+		// JAXP transformation
+		Document sourceDocument = rootNode.getOwnerDocument();
+		Source domSource = new DOMSource(sourceDocument);
+		Transformer serializer = TransformerFactory.newInstance()
+				.newTransformer();
+		try {
+			serializer.setOutputProperty(OutputKeys.INDENT, "yes"); //$NON-NLS-1$
+			serializer.setOutputProperty(
+					"{http://xml.apache.org/xslt}indent-amount", "4"); //$NON-NLS-1$ //$NON-NLS-2$
+		} catch (IllegalArgumentException e) {
+			// unsupported properties, so we'll just ignore
+		}
+		Writer outputWriter = null;
+		try {
+			outputWriter = new FileWriter(outputFile);
+			serializer.transform(domSource, new StreamResult(outputWriter));
+		} finally {
+			if (outputWriter != null) {
+				outputWriter.close();
+			}
+		}
+	}
+
+	/**
+	 * <summaryItem> <name>someName</name> <value>8</value> </summaryItem>
+	 * 
+	 * @param dom
+	 */
+	private void addSummaryNodeTo(Node rootNode, String itemName, int intdata) {
+		Document dom = rootNode.getOwnerDocument();
+		Element summaryElement = dom.createElement("summaryItem");
+
+		Element nameElement = dom.createElement("name");
+		Element valueElement = dom.createElement("value");
+
+		summaryElement.appendChild(nameElement);
+		summaryElement.appendChild(valueElement);
+
+		Text name = dom.createTextNode(itemName);
+		Text value = dom.createTextNode(String.valueOf(intdata));
+		nameElement.appendChild(name);
+		valueElement.appendChild(value);
+
+		rootNode.appendChild(summaryElement);
+	}
+
+	private Node createNewDOM(String rootElementName) {
+		Document document = null;
+		Node rootNode = null;
+		try {
+			document = DocumentBuilderFactory.newInstance()
+					.newDocumentBuilder().newDocument();
+		} catch (ParserConfigurationException e) {
+			log("exception creating document: " + e.getMessage()); //$NON-NLS-1$
+		} catch (FactoryConfigurationError e) {
+			log("exception creating document: " + e.getMessage()); //$NON-NLS-1$
+		}
+		if (document != null) {
+			rootNode = document.appendChild(document
+					.createElement(rootElementName));
+		}
+		return rootNode;
+	}
+
+	private void processCompileLogsDirectory(String directoryName,
+			StringBuffer buffer) {
+		if (buffer == null) {
+			throw new RuntimeException("write buffer can not be null");
+		}
+		File sourceDirectory = new File(directoryName);
+
+		if (sourceDirectory.isFile()) {
+			if (sourceDirectory.getName().endsWith(".log"))
+				readCompileLog(sourceDirectory.getAbsolutePath(), buffer);
+			if (sourceDirectory.getName().endsWith(".xml"))
+				parseCompileLog(sourceDirectory.getAbsolutePath(), buffer);
+		}
+		if (sourceDirectory.isDirectory()) {
+			File[] logFiles = sourceDirectory.listFiles();
+			Arrays.sort(logFiles);
+			for (int j = 0; j < logFiles.length; j++) {
+				processCompileLogsDirectory(logFiles[j].getAbsolutePath(),
+						buffer);
+			}
+		}
+
+	}
+
+	/**
+	 * 
+	 */
+	private void writeFormattedTotals(StringBuffer buffer) {
+
+		if (buffer == null) {
+			throw new RuntimeException("write buffer can not be null");
+		}
+
+		String rowtype = "normaltable";
+		if (totalErrors > 0) {
+			rowtype = "errortable";
+		} else if (totalWarnings > 0) {
+			rowtype = "warningtable";
+			if (totalWarnings > 200) {
+				rowtype = "extraWarningTable";
+			}
+		}
+		//
+		// System.out.println("totalErrors: " + totalErrors); // ,
+		// log("totalErrors: " + totalErrors, Project.MSG_INFO);
+
+		buffer.append("<tr CLASS=\"" + rowtype + " " + "bold" + "\">" + EOL)
+		.append("<td>" + "TOTALS  (" + rowCount + ")" + "</td>")
+		.append("<td CLASS=\"numeric\">" + totalErrors + "</td>")
+		.append("<td CLASS=\"numeric\">" + totalWarnings + "</td>")
+		.append("<td CLASS=\"numeric\">" + totalforbiddenAccessWarningCount + "</td>")
+		.append("<td CLASS=\"numeric\">" + totaldiscouragedAccessWarningCount + "</td>")
+		.append(EOL + "</tr>" + EOL);
+
+	}
+
+	private void readCompileLog(String log, StringBuffer buffer) {
+		String fileContents = readFile(log);
+
+		int errorCount = countCompileErrors(fileContents);
+		int warningCount = countCompileWarnings(fileContents);
+		int forbiddenWarningCount = countForbiddenWarnings(fileContents);
+		int discouragedWarningCount = countDiscouragedWarnings(fileContents);
+		// use wildcard in place of version number on directory names
+		String logName = log
+				.substring(getCompileLogsDirectoryName().length() + 1);
+		StringBuffer stringBuffer = new StringBuffer(logName);
+		stringBuffer.replace(logName.indexOf("_") + 1, logName.indexOf(
+				File.separator, logName.indexOf("_") + 1), "*");
+		logName = new String(stringBuffer);
+		formatCompileErrorRow(log, errorCount, warningCount,
+				forbiddenWarningCount, discouragedWarningCount, buffer);
+	}
+
+	private void parseCompileLog(String log, StringBuffer stringBuffer) {
+		int errorCount = 0;
+		int warningCount = 0;
+		int forbiddenWarningCount = 0;
+		int discouragedWarningCount = 0;
+
+		File file = new File(log);
+		Document aDocument = null;
+		BufferedReader reader = null;
+		try {
+			reader = new BufferedReader(new FileReader(file));
+			InputSource inputSource = new InputSource(reader);
+			DocumentBuilderFactory factory = DocumentBuilderFactory
+					.newInstance();
+			DocumentBuilder builder = factory.newDocumentBuilder();
+			aDocument = builder.parse(inputSource);
+		} catch (SAXException e) {
+			e.printStackTrace();
+		} catch (IOException e) {
+			e.printStackTrace();
+		} catch (ParserConfigurationException e) {
+			e.printStackTrace();
+		} finally {
+			if (reader != null) {
+				try {
+					reader.close();
+				} catch (IOException e) {
+					// ignore
+				}
+			}
+		}
+
+		if (aDocument == null) {
+			log("could not parse xml in log file: " + log, Project.MSG_ERR);
+			return;
+		}
+
+		// Get summary of problems.
+		// By API, nodeList should never be null.
+		NodeList nodeList = aDocument.getElementsByTagName("problem");
+
+		int length = nodeList.getLength();
+		for (int i = 0; i < length; i++) {
+			Node problemNode = nodeList.item(i);
+			NamedNodeMap aNamedNodeMap = problemNode.getAttributes();
+			Node severityNode = aNamedNodeMap.getNamedItem("severity");
+			Node idNode = aNamedNodeMap.getNamedItem("id");
+			if (severityNode != null) {
+				String severityNodeValue = severityNode.getNodeValue();
+				if (WARNING_SEVERITY.equals(severityNodeValue)) {
+					// this is a warning
+					// need to check the id
+					String nodeValue = idNode.getNodeValue();
+					if (ForbiddenReferenceID.equals(nodeValue)) {
+						forbiddenWarningCount++;
+					} else if (DiscouragedReferenceID.equals(nodeValue)) {
+						discouragedWarningCount++;
+					} else {
+						warningCount++;
+					}
+				} else if (ERROR_SEVERITY.equals(severityNodeValue)) {
+					// this is an error
+					errorCount++;
+				}
+			}
+		}
+
+		// use wildcard in place of version number on directory names
+		// System.out.println(log + "/n");
+		String logName = log
+				.substring(getCompileLogsDirectoryName().length() + 1);
+		StringBuffer buffer = new StringBuffer(logName);
+		buffer.replace(logName.indexOf("_") + 1, logName.indexOf(
+				File.separator, logName.indexOf("_") + 1), "*");
+		logName = new String(buffer);
+
+		formatCompileErrorRow(log.replaceAll(".xml", ".html"), errorCount,
+				warningCount, forbiddenWarningCount, discouragedWarningCount,
+				stringBuffer);
+	}
+
+	private static byte[] getFileByteContent(String fileName)
+			throws IOException {
+		InputStream stream = null;
+		try {
+			File file = new File(fileName);
+			stream = new FileInputStream(file);
+			return getInputStreamAsByteArray(stream, (int) file.length());
+		} finally {
+			if (stream != null) {
+				try {
+					stream.close();
+				} catch (IOException e) {
+					// ignore
+				}
+			}
+		}
+	}
+
+	/**
+	 * Returns the given input stream's contents as a byte array. If a length is
+	 * specified (ie. if length != -1), only length bytes are returned.
+	 * Otherwise all bytes in the stream are returned. Note this doesn't close
+	 * the stream.
+	 * 
+	 * @throws IOException
+	 *             if a problem occured reading the stream.
+	 */
+	private static byte[] getInputStreamAsByteArray(InputStream stream,
+			int length) throws IOException {
+		byte[] contents;
+		if (length == -1) {
+			contents = new byte[0];
+			int contentsLength = 0;
+			int amountRead = -1;
+			do {
+				int amountRequested = Math.max(stream.available(),
+						DEFAULT_READING_SIZE); // read
+				// at
+				// least
+				// 8K
+
+				// resize contents if needed
+				if (contentsLength + amountRequested > contents.length) {
+					System.arraycopy(contents, 0,
+							contents = new byte[contentsLength
+									+ amountRequested], 0, contentsLength);
+				}
+
+				// read as many bytes as possible
+				amountRead = stream.read(contents, contentsLength,
+						amountRequested);
+
+				if (amountRead > 0) {
+					// remember length of contents
+					contentsLength += amountRead;
+				}
+			} while (amountRead != -1);
+
+			// resize contents if necessary
+			if (contentsLength < contents.length) {
+				System.arraycopy(contents, 0,
+						contents = new byte[contentsLength], 0, contentsLength);
+			}
+		} else {
+			contents = new byte[length];
+			int len = 0;
+			int readSize = 0;
+			while ((readSize != -1) && (len != length)) {
+				// See PR 1FMS89U
+				// We record first the read size. In this case len is the
+				// actual read size.
+				len += readSize;
+				readSize = stream.read(contents, len, length - len);
+			}
+		}
+
+		return contents;
+	}
+
+	public String readFile(String fileName) {
+		byte[] aByteArray = null;
+		try {
+			aByteArray = getFileByteContent(fileName);
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		if (aByteArray == null) {
+			return "";
+		}
+		return new String(aByteArray);
+	}
+
+	private int countCompileErrors(String aString) {
+		return extractNumber(aString, "error");
+	}
+
+	private int countCompileWarnings(String aString) {
+		return extractNumber(aString, "warning");
+	}
+
+	private int countForbiddenWarnings(String aString) {
+		return extractNumber(aString, "Access restriction:");
+	}
+
+	private int countDiscouragedWarnings(String aString) {
+		return extractNumber(aString, "Discouraged access:");
+	}
+
+	private int extractNumber(String aString, String endToken) {
+		int endIndex = aString.lastIndexOf(endToken);
+		if (endIndex == -1) {
+			return 0;
+		}
+
+		int startIndex = endIndex;
+		while (startIndex >= 0 && aString.charAt(startIndex) != '('
+				&& aString.charAt(startIndex) != ',') {
+			startIndex--;
+		}
+
+		String count = aString.substring(startIndex + 1, endIndex).trim();
+		try {
+			return Integer.parseInt(count);
+		} catch (NumberFormatException e) {
+			return 0;
+		}
+
+	}
+
+	public boolean includeAll;
+	private int totalErrors;
+	private int totalAccess;
+	private int totalWarnings;
+	private int rowCount;
+	private int totaldiscouragedAccessWarningCount;
+	private int totalforbiddenAccessWarningCount;
+
+	private void parseUnitTestXml() throws IOException,
+			TransformerFactoryConfigurationError, TransformerException {
+
+		File sourceDirectory = new File(xmlDirectoryName);
+
+		if (sourceDirectory.exists()) {
+
+			int grandTotalErrors = 0;
+			int grandTotalTests = 0;
+
+			String replaceString = "";
+
+			File[] xmlFileNames = sourceDirectory.listFiles();
+			Arrays.sort(xmlFileNames);
+
+			for (int i = 0; i < xmlFileNames.length; i++) {
+				if (xmlFileNames[i].getPath().endsWith(".xml")) {
+					String fullName = xmlFileNames[i].getPath();
+					UnitTestResults unitTestResults = countErrors(fullName);
+					int errorCount = unitTestResults.getErrors()
+							+ unitTestResults.getFailures();
+					if (errorCount != 0) {
+						String testName = xmlFileNames[i].getName().substring(
+								0, xmlFileNames[i].getName().length() - 4);
+						testResultsWithProblems = testResultsWithProblems
+								.concat(EOL + testName);
+					}
+
+					String tmp = formatTestRow(xmlFileNames[i].getPath(),
+							errorCount, unitTestResults.getTotalTests());
+					replaceString = replaceString + tmp;
+
+					if (errorCount > 0) {
+						grandTotalErrors = grandTotalErrors + errorCount;
+					} else if (errorCount < 0) {
+						grandTotalErrors = grandTotalErrors + 1;
+					}
+
+					if (unitTestResults.getTotalTests() > 0) {
+						grandTotalTests = grandTotalTests
+								+ unitTestResults.getTotalTests();
+					}
+
+				}
+			}
+
+			String tmp = formatTestRow("TOTALS", grandTotalErrors,
+					grandTotalTests);
+			replaceString = replaceString + tmp;
+
+			testResultsTemplateString = replace(testResultsTemplateString,
+					testResultsToken, replaceString);
+			testsRan = true;
+
+			writeUnitTestSummary(dropDirectoryName, grandTotalErrors,
+					grandTotalTests);
+
+		} else {
+			testsRan = false;
+			System.out.println("Test results not found in "
+					+ sourceDirectory.getAbsolutePath());
+		}
+
+	}
+
+	/**
+	 * @param grandTotalErrors
+	 * @param grandTotalTests
+	 * @throws IOException
+	 * @throws TransformerException
+	 * @throws TransformerFactoryConfigurationError
+	 */
+	private void writeUnitTestSummary(String filename, int grandTotalErrors,
+			int grandTotalTests) throws IOException,
+			TransformerFactoryConfigurationError, TransformerException {
+		String outputFileName = filename + "/unitTestsSummary" + ".xml";
+		System.out.println("unitTestsSummary: " + outputFileName);
+		File file = new File(outputFileName);
+		file.createNewFile();
+		Node rootNode = createNewDOM("unitTestsSummary");
+		addSummaryNodeTo(rootNode, "grandTotalErrors", grandTotalErrors);
+		addSummaryNodeTo(rootNode, "grandTotalTests", grandTotalTests);
+		serialize(rootNode, file);
+	}
+
+	private String replace(String source, String original, String replacement) {
+
+		int replaceIndex = source.indexOf(original);
+		if (replaceIndex > -1) {
+			String resultString = source.substring(0, replaceIndex);
+			resultString = resultString + replacement;
+			resultString = resultString
+					+ source.substring(replaceIndex + original.length());
+			return resultString;
+		} else {
+			System.out.println("Could not find token: " + original);
+			return source;
+		}
+
+	}
+
+	private void writeTestResultsFile() {
+
+		String outputFileName = dropDirectoryName + File.separator
+				+ testResultsHtmlFileName;
+		writeFile(outputFileName, testResultsTemplateString);
+	}
+
+	private void writeFile(String outputFileName, String contents) {
+		FileWriter outputWriter = null;
+		try {
+			outputWriter = new FileWriter(outputFileName);
+			outputWriter.write(contents);
+		} catch (FileNotFoundException e) {
+			System.out.println("File not found exception writing: "
+					+ outputFileName);
+		} catch (IOException e) {
+			System.out.println("IOException writing: " + outputFileName);
+		} finally {
+			if (outputWriter != null) {
+				try {
+					outputWriter.close();
+				} catch (IOException e) {
+					System.out
+							.println("IOException closing: " + outputFileName);
+				}
+			}
+		}
+	}
+
+	public void setTestResultsHtmlFileName(String aString) {
+		testResultsHtmlFileName = aString;
+	}
+
+	public String getTestResultsHtmlFileName() {
+		return testResultsHtmlFileName;
+	}
+
+	public void setTestResultsTemplateFileName(String aString) {
+		testResultsTemplateFileName = aString;
+	}
+
+	public String getTestResultsTemplateFileName() {
+		return testResultsTemplateFileName;
+	}
+
+	public void setXmlDirectoryName(String aString) {
+		xmlDirectoryName = aString;
+	}
+
+	public String getXmlDirectoryName() {
+		return xmlDirectoryName;
+	}
+
+	public void setHtmlDirectoryName(String aString) {
+		htmlDirectoryName = aString;
+	}
+
+	public String getHtmlDirectoryName() {
+		return htmlDirectoryName;
+	}
+
+	public void setDropDirectoryName(String aString) {
+		dropDirectoryName = aString;
+	}
+
+	public String getDropDirectoryName() {
+		return dropDirectoryName;
+	}
+
+	private void formatCompileErrorRow(String fileName, int errorCount,
+			int warningCount, int forbiddenAccessWarningCount,
+			int discouragedAccessWarningCount, StringBuffer buffer) {
+
+		int accessRuleWarningCount = forbiddenAccessWarningCount
+				+ discouragedAccessWarningCount;
+		totalErrors = totalErrors + errorCount;
+		totalAccess = totalAccess + accessRuleWarningCount;
+		totalWarnings = totalWarnings + warningCount;
+		totalforbiddenAccessWarningCount = totalforbiddenAccessWarningCount
+				+ forbiddenAccessWarningCount;
+		totaldiscouragedAccessWarningCount = totaldiscouragedAccessWarningCount
+				+ discouragedAccessWarningCount;
+		rowCount = rowCount + 1;
+
+		if (!isIncludeAll()) {
+			if (errorCount == 0 && warningCount == 0
+					&& accessRuleWarningCount == 0) {
+				return;
+			}
+		}
+
+		int pos = fileName.indexOf(getHrefCompileLogsTargetPath());
+
+		String shortName = fileName.substring(pos
+				+ getHrefCompileLogsTargetPath().length());
+		String displayName = shortName;
+
+		String stripString = "/plugins/";
+		pos = displayName.indexOf(stripString);
+		if (pos != -1) {
+			displayName = displayName.substring(pos + stripString.length());
+		}
+
+		// we assume there's always a slash preceeding filename
+		pos = displayName.lastIndexOf('/');
+		if (pos != -1) {
+			displayName = displayName.substring(0, pos);
+		}
+
+		// if there's any remaining slashes ... it is one or more
+		// subdirectories of where jars are, so we need to
+		// save before we strip off version numbers
+		String remaining = null;
+		pos = displayName.indexOf('/');
+		if (pos != -1) {
+			remaining = displayName.substring(pos);
+			displayName = displayName.substring(0, pos);
+		}
+		displayName = stripOffVersionNumber(displayName);
+		if (remaining != null) {
+			displayName = displayName + remaining;
+		}
+
+		String rowtype = "normaltable";
+		if (errorCount > 0 || forbiddenAccessWarningCount > 0) {
+			rowtype = "errortable";
+		} else if (warningCount > 0 || discouragedAccessWarningCount > 0) {
+			rowtype = "warningtable";
+			if (warningCount > 15 || discouragedAccessWarningCount > 0) {
+				rowtype = "extraWarningTable";
+			}
+		}
+
+		buffer.append("<tr CLASS=\"" + rowtype + "\">" + EOL) 
+				.append("<td>" + EOL)
+				.append("<a href=\"").append(getHrefCompileLogsTargetPath()).append(shortName)
+				.append("\" type='text/plain' >")
+				.append(displayName)
+				.append("</a></td>")
+				.append(EOL)
+				
+				.append("<td CLASS=\"numeric\">").append("<a href=\"")
+				.append(getHrefCompileLogsTargetPath()).append(shortName)
+				.append("#ERRORS")
+				.append("\" type='text/plain' >")
+				.append(errorCount)
+				.append("</a></td>")
+				.append(EOL)
+
+				.append("<td CLASS=\"numeric\">").append("<a href=\"")
+				.append(getHrefCompileLogsTargetPath()).append(shortName).append("#OTHER_WARNINGS")
+				.append("\" type='text/plain' >")
+				.append(warningCount)
+				.append("</a></td>")
+				
+				.append("<td CLASS=\"numeric\">").append("<a href=\"")
+				.append(getHrefCompileLogsTargetPath()).append(shortName)
+				.append("#ACCESSRULES_WARNINGS")
+				.append("\" type='text/plain' >")
+				.append(forbiddenAccessWarningCount)
+				.append("</a></td>")
+				.append(EOL)
+								
+				.append("<td CLASS=\"numeric\">").append("<a href=\"")
+				.append(getHrefCompileLogsTargetPath()).append(shortName)
+				.append("#ACCESSRULES_WARNINGS")
+				.append("\" type='text/plain' >")
+				.append(discouragedAccessWarningCount)
+				.append("</a></td>")
+				.append(EOL)				
+				
+				.append( EOL + "</tr>" + EOL);
+	}
+
+	/**
+	 * @param displayName
+	 * @return
+	 */
+	private String stripOffVersionNumber(String displayName) {
+		String result = displayName;
+		nameParser.parse(result);
+		result = nameParser.getProjectString();
+
+		// debug and test
+		// System.out.println("project: " + result + " version: " +
+		// nameParser.getVersionString());
+		return result;
+	}
+
+	private String formatTestRow(String fileName, int errorCount, int totalTests) {
+
+		// replace .xml with .html
+
+		String aString = "";
+
+		if (fileName.endsWith(".xml")) {
+
+			int begin = fileName.lastIndexOf(File.separatorChar);
+			int end = fileName.lastIndexOf(".xml");
+
+			String shortName = fileName.substring(begin + 1, end);
+			String displayName = shortName;
+
+			String rowtype = "normaltable";
+			if (errorCount > 0 || errorCount < 0) {
+				rowtype = "errortable";
+			} else if (totalTests < 3) {
+				rowtype = "warningtable";
+				if (totalTests == 0) {
+					rowtype = "extraWarningTable";
+				}
+			}
+
+			aString = aString + "<tr CLASS=\"" + rowtype + "\">" + EOL;
+
+			if (errorCount < 0) {
+				aString = aString + "<td>" + displayName + "</td>" + EOL;
+				aString = aString + "<td CLASS=\"" + "numeric" + "\">" + "DNF"
+						+ "</td>" + EOL;
+				aString = aString + "<td CLASS=\"" + "numeric" + "\">" + "0"
+						+ " </td>" + EOL;
+			} else {
+				aString = aString + "<td>" + "<a href=" + "\""
+						+ hrefTestResultsTargetPath + "/" + shortName + ".html"
+						+ "\">" + displayName + "</a>" + "</td>" + EOL;
+				aString = aString + "<td CLASS=\"" + "numeric" + "\">"
+						+ String.valueOf(errorCount) + "</td>" + EOL;
+				aString = aString + "<td CLASS=\"" + "numeric" + "\">"
+						+ String.valueOf(totalTests) + "</td>" + EOL;
+
+			}
+
+			aString = aString + "</tr>" + EOL;
+		}
+
+		else {
+			// not really file name (but "TOTALS")
+			String displayName = fileName;
+			String rowtype = "bold";
+			if (errorCount > 0) {
+				rowtype = "errortable" + " " + rowtype;
+			}
+			aString = aString + "<tr CLASS=\"" + rowtype + "\">" + EOL;
+			aString = aString + "<td>" + displayName + "</td>" + EOL;
+			aString = aString + "<td CLASS=\"" + "numeric" + "\">"
+					+ String.valueOf(errorCount) + "</td>" + EOL;
+			aString = aString + "<td CLASS=\"" + "numeric" + "\">"
+					+ String.valueOf(totalTests) + "</td>" + EOL;
+
+		}
+
+		return aString;
+
+	}
+
+	private UnitTestResults countErrors(String fileName) {
+		UnitTestResults result = new UnitTestResults();
+
+		if (new File(fileName).length() == 0)
+			return result;
+
+		int errorCount = 0;
+		int failureCount = 0;
+		int totalTests = 0;
+		try {
+			DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory
+					.newInstance();
+			parser = docBuilderFactory.newDocumentBuilder();
+
+			Document document = parser.parse(fileName);
+			NodeList elements = document.getElementsByTagName(elementName);
+
+			int elementCount = elements.getLength();
+			if (elementCount == 0)
+				return result;
+			for (int i = 0; i < elementCount; i++) {
+				Element element = (Element) elements.item(i);
+				NamedNodeMap attributes = element.getAttributes();
+				Node aNode = attributes.getNamedItem("errors");
+				errorCount = errorCount
+						+ Integer.parseInt(aNode.getNodeValue());
+				aNode = attributes.getNamedItem("failures");
+				errorCount = errorCount
+						+ Integer.parseInt(aNode.getNodeValue());
+
+				aNode = attributes.getNamedItem("tests");
+				totalTests = totalTests
+						+ Integer.parseInt(aNode.getNodeValue());
+
+			}
+
+			result.setErrors(errorCount);
+			result.setFailures(failureCount);
+			result.setTotalTests(totalTests);
+
+		} catch (IOException e) {
+			System.out.println("IOException: " + fileName);
+			// e.printStackTrace();
+			return result;
+		} catch (SAXException e) {
+			System.out.println("SAXException: " + fileName);
+			// e.printStackTrace();
+			return result;
+		} catch (ParserConfigurationException e) {
+			e.printStackTrace();
+		}
+		return result;
+	}
+
+	/**
+	 * Gets the hrefTestResultsTargetPath.
+	 * 
+	 * @return Returns a String
+	 */
+	public String getHrefTestResultsTargetPath() {
+		return hrefTestResultsTargetPath;
+	}
+
+	/**
+	 * Sets the hrefTestResultsTargetPath.
+	 * 
+	 * @param hrefTestResultsTargetPath
+	 *            The hrefTestResultsTargetPath to set
+	 */
+	public void setHrefTestResultsTargetPath(String htmlTargetPath) {
+		this.hrefTestResultsTargetPath = htmlTargetPath;
+	}
+
+	/**
+	 * Gets the compileLogsDirectoryName.
+	 * 
+	 * @return Returns a String
+	 */
+	public String getCompileLogsDirectoryName() {
+		return compileLogsDirectoryName;
+	}
+
+	/**
+	 * Sets the compileLogsDirectoryName.
+	 * 
+	 * @param compileLogsDirectoryName
+	 *            The compileLogsDirectoryName to set
+	 */
+	public void setCompileLogsDirectoryName(String compileLogsDirectoryName) {
+		this.compileLogsDirectoryName = compileLogsDirectoryName;
+	}
+
+	/**
+	 * Gets the hrefCompileLogsTargetPath.
+	 * 
+	 * @return Returns a String
+	 */
+	public String getHrefCompileLogsTargetPath() {
+		return hrefCompileLogsTargetPath;
+	}
+
+	/**
+	 * Sets the hrefCompileLogsTargetPath.
+	 * 
+	 * @param hrefCompileLogsTargetPath
+	 *            The hrefCompileLogsTargetPath to set
+	 */
+	public void setHrefCompileLogsTargetPath(String hrefCompileLogsTargetPath) {
+		this.hrefCompileLogsTargetPath = hrefCompileLogsTargetPath;
+	}
+
+	/**
+	 * Gets the testManifestFileName.
+	 * 
+	 * @return Returns a String
+	 */
+	public String getTestManifestFileName() {
+		return testManifestFileName;
+	}
+
+	/**
+	 * Sets the testManifestFileName.
+	 * 
+	 * @param testManifestFileName
+	 *            The testManifestFileName to set
+	 */
+	public void setTestManifestFileName(String testManifestFileName) {
+		this.testManifestFileName = testManifestFileName;
+	}
+
+	/**
+	 * Gets the dropHtmlFileName.
+	 * 
+	 * @return Returns a String
+	 */
+	public String getDropHtmlFileName() {
+		return dropHtmlFileName;
+	}
+
+	/**
+	 * Sets the dropHtmlFileName.
+	 * 
+	 * @param dropHtmlFileName
+	 *            The dropHtmlFileName to set
+	 */
+	public void setDropHtmlFileName(String dropHtmlFileName) {
+		this.dropHtmlFileName = dropHtmlFileName;
+	}
+
+	private void getDropTokensFromList(String list) {
+		StringTokenizer tokenizer = new StringTokenizer(list, ",");
+		dropTokens = new Vector();
+
+		while (tokenizer.hasMoreTokens()) {
+			dropTokens.add(tokenizer.nextToken());
+		}
+	}
+
+	public String getDropTokenList() {
+		return dropTokenList;
+	}
+
+	public void setDropTokenList(String dropTokenList) {
+		this.dropTokenList = dropTokenList;
+	}
+
+	public boolean isBuildTested() {
+		return isBuildTested;
+	}
+
+	public void setIsBuildTested(boolean isBuildTested) {
+		this.isBuildTested = isBuildTested;
+	}
+
+	/**
+	 * @return
+	 */
+	public boolean testsRan() {
+		return testsRan;
+	}
+
+	/**
+	 * @param b
+	 */
+	public void setTestsRan(boolean b) {
+		testsRan = b;
+	}
+
+	/**
+	 * @return
+	 */
+	public Vector getDropTokens() {
+		return dropTokens;
+	}
+
+	/**
+	 * @param vector
+	 */
+	public void setDropTokens(Vector vector) {
+		dropTokens = vector;
+	}
+
+	/**
+	 * @return
+	 */
+	public String getTestResultsWithProblems() {
+		return testResultsWithProblems;
+	}
+
+	/**
+	 * @param string
+	 */
+	public void setTestResultsWithProblems(String string) {
+		testResultsWithProblems = string;
+	}
+
+	public String getBuildType() {
+		return buildType;
+	}
+
+	public void setBuildType(String buildType) {
+		this.buildType = buildType;
+	}
+
+	public void setPlatformIdentifierToken(String platformIdentifierToken) {
+		this.platformIdentifierToken = platformIdentifierToken;
+	}
+
+	public String getPlatformIdentifierToken() {
+		return platformIdentifierToken;
+	}
+
+	public boolean isIncludeAll() {
+		return includeAll;
+	}
+
+	public void setIncludeAll(boolean includeAll) {
+		this.includeAll = includeAll;
+	}
+
+}
diff --git a/plugins/org.eclipse.wtp.releng.tools/src/org/eclipse/wtp/releng/tools/handy.jpage b/plugins/org.eclipse.wtp.releng.tools/src/org/eclipse/wtp/releng/tools/handy.jpage
new file mode 100644
index 0000000..ff164c5
--- /dev/null
+++ b/plugins/org.eclipse.wtp.releng.tools/src/org/eclipse/wtp/releng/tools/handy.jpage
@@ -0,0 +1,17 @@
+System.getProperty("path.separator");
+
+System.getProperty("file.separator");
+
+System.getProperty("line.separator");
+
+void dumpAllProperties() {
+	java.util.Enumeration enumeration = System.getProperties().keys();
+	String key = null;
+	while (enumeration.hasMoreElements()) {
+		key = (String) enumeration.nextElement();
+		System.out.print(key);
+		for (int i = 0; i < (30 - key.length()); i++)
+			System.out.print(" ");
+		System.out.println("->" + System.getProperty(key));
+	}
+}