Index: src/org/eclipse/jdt/core/tests/compiler/regression/BatchCompilerTest.java
===================================================================
RCS file: /home/eclipse/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/BatchCompilerTest.java,v
retrieving revision 1.8
diff -u -r1.8 BatchCompilerTest.java
--- src/org/eclipse/jdt/core/tests/compiler/regression/BatchCompilerTest.java	23 Feb 2005 02:52:37 -0000	1.8
+++ src/org/eclipse/jdt/core/tests/compiler/regression/BatchCompilerTest.java	25 May 2005 08:40:27 -0000
@@ -10,17 +10,442 @@
  *******************************************************************************/
 package org.eclipse.jdt.core.tests.compiler.regression;
 
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.PrintWriter;
 import junit.framework.Test;
+import junit.framework.TestSuite;
 
+import org.eclipse.jdt.core.tests.util.Util;
 import org.eclipse.jdt.internal.compiler.batch.Main;
 
 public class BatchCompilerTest extends AbstractRegressionTest {
+	public static final String OUTPUT_DIR_PLACEHOLDER = "---OUTPUT_DIR_PLACEHOLDER---";
+	static final String JRE_HOME_DIR = Util.getJREDirectory();
+	
 public BatchCompilerTest(String name) {
 	super(name);
 }
 public static Test suite() {
+	if (false) {
+		TestSuite suite = new TestSuite();
+		suite.addTest(new BatchCompilerTest("test013"));
+		suite.addTest(new BatchCompilerTest("test014"));
+		suite.addTest(new BatchCompilerTest("test015"));
+		return suite;
+	}
 	return setupSuite(testClass());
+	// TODO find a way to reduce the number of command line tests to one per 
+	//      test run (aka do not add 1.3, 1.4, 1.5 supplementary level)
 }
+
+	/**
+	 * Run a compilation test that is expected to complete successfully and
+	 * compare the outputs to expected ones.
+	 * 
+	 * @param testFiles
+	 *            the source files, given as a suite of file name, file content;
+	 *            file names are relative to the output directory
+	 * @param commandLine
+	 *            the command line to pass to
+	 *            {@link Main#compile(String) Main#compile}
+	 * @param expectedSuccessOutOutputString
+	 *            the expected contents of the standard output stream; pass null
+	 *            to bypass the comparison
+	 * @param expectedSuccessErrOutputString
+	 *            the expected contents of the standard error output stream;
+	 *            pass null to bypass the comparison
+	 * @param shouldFlushOutputDirectory
+	 *            pass true to get the output directory flushed before the test
+	 *            runs
+	 */
+	protected void runConformTest(String[] testFiles, String commandLine,
+			String expectedSuccessOutOutputString,
+			String expectedSuccessErrOutputString,
+			boolean shouldFlushOutputDirectory) {
+		runTest(true, testFiles, commandLine, expectedSuccessOutOutputString,
+				expectedSuccessErrOutputString, shouldFlushOutputDirectory);
+	}
+
+	/**
+	 * Run a compilation test that is expected to fail and compare the outputs
+	 * to expected ones.
+	 * 
+	 * @param testFiles
+	 *            the source files, given as a suite of file name, file content;
+	 *            file names are relative to the output directory
+	 * @param commandLine
+	 *            the command line to pass to
+	 *            {@link Main#compile(String) Main#compile}
+	 * @param expectedFailureOutOutputString
+	 *            the expected contents of the standard output stream; pass null
+	 *            to bypass the comparison
+	 * @param expectedFailureErrOutputString
+	 *            the expected contents of the standard error output stream;
+	 *            pass null to bypass the comparison
+	 * @param shouldFlushOutputDirectory
+	 *            pass true to get the output directory flushed before the test
+	 *            runs
+	 */
+	protected void runNegativeTest(String[] testFiles, String commandLine,
+			String expectedFailureOutOutputString,
+			String expectedFailureErrOutputString,
+			boolean shouldFlushOutputDirectory) {
+		runTest(false, testFiles, commandLine, expectedFailureOutOutputString,
+				expectedFailureErrOutputString, shouldFlushOutputDirectory);
+	}
+
+	/**
+	 * Worker method for runConformTest and runNegativeTest.
+	 * 
+	 * @param shouldCompileOK
+	 *            set to true if the compiler should compile the given sources
+	 *            without errors
+	 * @param testFiles
+	 *            the source files, given as a suite of file name, file content;
+	 *            file names are relative to the output directory
+	 * @param commandLine
+	 *            the command line to pass to
+	 *            {@link Main#compile(String) Main#compile}
+	 * @param expectedOutOutputString
+	 *            the expected contents of the standard output stream; pass null
+	 *            to bypass the comparison
+	 * @param expectedErrOutputString
+	 *            the expected contents of the standard error output stream;
+	 *            pass null to bypass the comparison
+	 * @param shouldFlushOutputDirectory
+	 *            pass true to get the output directory flushed before the test
+	 *            runs
+	 */
+	private void runTest(boolean shouldCompileOK, String[] testFiles, String commandLine,
+			String expectedOutOutputString,
+			String expectedErrOutputString,
+			boolean shouldFlushOutputDirectory) {
+		File outputDirectory = new File(OUTPUT_DIR);
+		if (shouldFlushOutputDirectory)
+			Util.flushDirectoryContent(outputDirectory);
+		try {
+			if (!outputDirectory.isDirectory()) {
+				outputDirectory.mkdirs();
+			}
+			PrintWriter sourceFileWriter;
+			for (int i = 0; i < testFiles.length; i += 2) {
+				String fileName = OUTPUT_DIR + File.separator + testFiles[i];
+				File file = new File(fileName), innerOutputDirectory = file
+						.getParentFile();
+				if (!innerOutputDirectory.isDirectory()) {
+					innerOutputDirectory.mkdirs();
+				}
+				sourceFileWriter = new PrintWriter(new FileOutputStream(file));
+				sourceFileWriter.write(testFiles[i + 1]);
+				sourceFileWriter.close();
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+			throw new RuntimeException(e);
+		}
+		String printerWritersNameRoot = OUTPUT_DIR + File.separator + testName();
+		String outFileName = printerWritersNameRoot + "out.txt", 
+			   errFileName = printerWritersNameRoot + "err.txt";
+		Main batchCompiler;
+		try {
+			batchCompiler = new Main(new PrintWriter(new FileOutputStream(
+					outFileName)), new PrintWriter(new FileOutputStream(
+					errFileName)), false);
+		} catch (FileNotFoundException e) {
+			System.out.println(getClass().getName() + '#' + getName());
+			e.printStackTrace();
+			throw new RuntimeException(e);
+		}
+		boolean compileOK;
+		try {
+			compileOK = batchCompiler.compile(Main.tokenize(commandLine));
+		} catch (RuntimeException e) {
+			compileOK = false;
+			System.out.println(getClass().getName() + '#' + getName());
+			e.printStackTrace();
+			throw e;
+		}
+		String outOutputString = Util.fileContent(outFileName), 
+		       errOutputString = Util.fileContent(errFileName);
+		boolean compareOK = false;
+		if (compileOK == shouldCompileOK) {
+			compareOK = semiNormalizedComparison(expectedOutOutputString,
+					outOutputString, outputDirNormalizer)
+					&& semiNormalizedComparison(expectedErrOutputString,
+							errOutputString, outputDirNormalizer);
+		}
+		if (compileOK != shouldCompileOK || !compareOK) {
+			System.out.println(getClass().getName() + '#' + getName());
+			for (int i = 0; i < testFiles.length; i += 2) {
+				System.out.print(testFiles[i]);
+				System.out.println(" [");
+				System.out.println(testFiles[i + 1]);
+				System.out.println("]");
+			}
+		}
+		if (compileOK != shouldCompileOK)
+			System.out.println(errOutputString);
+		if (compileOK == shouldCompileOK && !compareOK) {
+			System.out.println(
+					    "------------ [START OUT] ------------\n"
+					+   "------------- Expected: -------------\n"
+					+ expectedOutOutputString
+					+ "\n------------- but was:  -------------\n"
+					+ outOutputString
+					+ "\n--------- (cut and paste:) ----------\n"
+					+ Util.displayString(outputDirNormalizer
+							.normalized(outOutputString))
+					+ "\n------------- [END OUT] -------------\n"
+					+   "------------ [START ERR] ------------\n"
+					+   "------------- Expected: -------------\n"
+					+ expectedErrOutputString
+					+ "\n------------- but was:  -------------\n"
+					+ errOutputString
+					+ "\n--------- (cut and paste:) ----------\n"
+					+ Util.displayString(outputDirNormalizer
+							.normalized(errOutputString))
+					+ "\n------------- [END ERR] -------------\n");
+		}
+		if (shouldCompileOK)
+			assertTrue("Unexpected problems: " + errOutputString, compileOK);
+		else
+			assertTrue("Unexpected success: " + errOutputString, !compileOK);
+		assertTrue("Unexpected output for invocation with arguments ["
+				+ commandLine + "]:\n--[START]--\n" + outOutputString + "\n"
+				+ errOutputString + "\n---[END]---\n", compareOK);
+	}
+	
+	/**
+	 * Abstract normalizer for output comparison. This class merely embodies a
+	 * chain of responsibility, plus the signature of the method of interest
+	 * here, that is {@link #normalized(String) normalized}.
+	 */
+	private static abstract class Normalizer {
+		private Normalizer nextInChain;
+		Normalizer(Normalizer nextInChain) {
+			this.nextInChain = nextInChain;
+		}
+		String normalized(String originalValue) {
+			if (nextInChain == null)
+				return originalValue;
+			else
+				return nextInChain.normalized(originalValue);
+		}
+	}
+
+	/**
+	 * This normalizer replaces occurrences of a given string with a given
+	 * placeholder.
+	 */
+	private static class StringNormalizer extends Normalizer {
+		private String match;
+		private int matchLength;
+		private String placeholder;
+		StringNormalizer(Normalizer nextInChain, String match, String placeholder) {
+			super(nextInChain);
+			this.match = match;
+			this.matchLength = match.length();
+			this.placeholder = placeholder;
+		}
+		String normalized(String originalValue) {
+			StringBuffer normalizedValueBuffer = new StringBuffer(originalValue);
+			int nextOccurrenceIndex;
+			while ((nextOccurrenceIndex = normalizedValueBuffer.indexOf(match)) != -1)
+				normalizedValueBuffer.replace(nextOccurrenceIndex,
+						nextOccurrenceIndex + matchLength, placeholder);
+			return super.normalized(normalizedValueBuffer.toString());
+		}
+	}
+	
+	/**
+	 * This normalizer replaces the whole classpaths section of a log file with
+	 * a normalized placeholder. 
+	 */
+	private static class XMLClasspathsSectionNormalizer extends Normalizer {
+		XMLClasspathsSectionNormalizer() {
+			super(null);
+		}
+		XMLClasspathsSectionNormalizer(Normalizer nextInChain) {
+			super(nextInChain);
+		}
+		String normalized(String originalValue) {
+			StringBuffer normalizedValueBuffer = new StringBuffer(originalValue);
+			int classpathsStartTagStart = normalizedValueBuffer
+					.indexOf("<classpaths>"), classpathsEndTagStart = normalizedValueBuffer
+					.indexOf("</classpaths>");
+			if (classpathsStartTagStart != -1 && classpathsEndTagStart != -1
+					&& classpathsStartTagStart < classpathsEndTagStart)
+				normalizedValueBuffer.replace(classpathsStartTagStart + 12,
+						classpathsEndTagStart, "NORMALIZED SECTION");
+			return super.normalized(normalizedValueBuffer.toString());
+		}
+	}
+
+	/**
+	 * This normalizer removes a selected range of lines from a log file.
+	 */
+	private static class LinesRangeNormalizer extends Normalizer {
+		private int first, number;
+
+		LinesRangeNormalizer() {
+			super(null);
+			first = number = 0;
+		}
+
+		LinesRangeNormalizer(Normalizer nextInChain) {
+			super(nextInChain);
+			first = number = 0;
+		}
+
+		/**
+		 * Make a new normalizer able to suppress a range of lines delimited by
+		 * "\r\n" sequences from a log file (or another string).
+		 * 
+		 * @param nextInChain
+		 *            the next normalizer in the chain of responsibility; pass
+		 *            null if none is needed
+		 * @param firstLineToRemove
+		 *            the index of the first line to remove, starting at 0
+		 * @param linesNumber
+		 *            the number or lines to remove; if 0, no other
+		 *            transformation occurs than those operated by nextInChain
+		 *            (if any)
+		 */
+		LinesRangeNormalizer(Normalizer nextInChain, int firstLineToRemove,
+				int linesNumber) {
+			super(nextInChain);
+			first = firstLineToRemove;
+			number = linesNumber >= 0 ? linesNumber : 0;
+		}
+
+		String normalized(String originalValue) {
+			if (number == 0 || originalValue.length() == 0)
+				return super.normalized(originalValue);
+			final int START = 0, KEEPING = 1, KEEPING_R = 2, SKIPING = 3, SKIPING_R = 4, END = 5, ERROR = 6;
+			int state = START, currentLineIndex = 0, currentCharIndex = 0, sourceLength;
+			char currentChar = '\0';
+			if (first <= 0)
+				state = SKIPING;
+			else
+				state = KEEPING;
+			StringBuffer normalizedValueBuffer = new StringBuffer(), source = new StringBuffer(
+					originalValue);
+			sourceLength = source.length();
+			while (state != END && state != ERROR) {
+				if (currentCharIndex < sourceLength) {
+					currentChar = source.charAt(currentCharIndex++);
+					switch (currentChar) {
+					case '\r':
+						switch (state) {
+						case KEEPING:
+							normalizedValueBuffer.append(currentChar);
+							state = KEEPING_R;
+							break;
+						case SKIPING:
+							state = SKIPING_R;
+							break;
+						default:
+							state = ERROR;
+						}
+						break;
+					case '\n':
+						currentLineIndex++;
+						switch (state) {
+						case KEEPING_R:
+							normalizedValueBuffer.append(currentChar);
+							if (currentLineIndex == first) {
+								state = SKIPING;
+							}
+							break;
+						case SKIPING_R:
+							// in effect, we tolerate too big first and number
+							// values
+							if (currentLineIndex >= first + number) {
+								if (currentCharIndex < sourceLength)
+									normalizedValueBuffer.append(source
+											.substring(currentCharIndex));
+								state = END;
+							}
+							break;
+						default:
+							state = ERROR;
+						}
+						break;
+					default:
+						switch (state) {
+						case KEEPING:
+							normalizedValueBuffer.append(currentChar);
+							break;
+						case SKIPING:
+							break;
+						default:
+							state = ERROR;
+						}
+
+					}
+				} 
+				else if (currentChar == '\n')
+					state = END;
+				else
+					state = ERROR;
+			}
+			if (state == ERROR)
+				normalizedValueBuffer
+						.append("UNEXPECTED ERROR in LinesRangeNormalizer");
+			return super.normalized(normalizedValueBuffer.toString());
+		}
+	}
+
+	/**
+	 * Normalizer instance that replaces occurrences of OUTPUT_DIR with 
+	 * OUTPUT_DIR_PLACEHOLDER.
+	 */
+	private static Normalizer outputDirNormalizer = new StringNormalizer(null,
+			OUTPUT_DIR, OUTPUT_DIR_PLACEHOLDER);
+
+	/**
+	 * Normalizer instance for non XML log files. 
+	 */
+	private static Normalizer textLogsNormalizer = new StringNormalizer(
+			new XMLClasspathsSectionNormalizer(new LinesRangeNormalizer(null,
+					0, 1)), OUTPUT_DIR, OUTPUT_DIR_PLACEHOLDER);
+
+	/**
+	 * Normalizer instance for XML log files.
+	 */
+	private static Normalizer xmlLogsNormalizer = new StringNormalizer(
+			new XMLClasspathsSectionNormalizer(new LinesRangeNormalizer(null,
+					1, 1)), OUTPUT_DIR, OUTPUT_DIR_PLACEHOLDER);
+	
+
+	/**
+	 * Return true if and only if the two strings passed as parameters compare
+	 * equal, modulo the transformation of the second string by a normalizer
+	 * passed in parameter. This is meant to erase the variations of subparts of
+	 * the compared strings in function of the test machine, the user account,
+	 * etc.
+	 * 
+	 * @param keep
+	 *            the first string to compare, gets compared as it is
+	 * @param normalize
+	 *            the second string to compare, passed through the normalizer
+	 *            before comparison
+	 * @param normalizer
+	 *            the transformation applied to normalize
+	 * @return true if keep and normalize compare equal after normalize has been
+	 *         normalized
+	 */
+	private boolean semiNormalizedComparison(String keep, String normalize,
+			Normalizer normalizer) {
+		if (keep == null)
+			return normalize == null;
+		if (normalize == null)
+			return false;
+		return keep.equals(normalizer.normalized(normalize));
+	}
+
 public void test01() {
 	
 		String commandLine = "-classpath \"D:/a folder\";d:/jdk1.4/jre/lib/rt.jar -1.4 -preserveAllLocals -g -verbose d:/eclipse/workspaces/development2.0/plugins/Bar/src2/ -d d:/test";
@@ -117,6 +542,686 @@
 			expected,
 			result);
 }
+// test the tester - runConformTest
+public void test007(){
+	this.runConformTest(
+		new String[] {
+			"X.java",
+			"import java.util.List;\n" + 
+			"\n" + 
+			"@SuppressWarnings(\"all\"//$NON-NLS-1$\n" + 
+			")\n" + 
+			"public class X {\n" + 
+			"	public static void main(String[] args) {\n" + 
+			"		if (false) {\n" + 
+			"			;\n" + 
+			"		} else {\n" + 
+			"		}\n" + 
+			"		// Zork z;\n" + 
+			"	}\n" + 
+			"}"
+        },
+        "\"" + OUTPUT_DIR +  File.separator + "X.java\""
+        + " -1.5 -g -preserveAllLocals"
+        + " -bootclasspath " + JRE_HOME_DIR + "/lib/rt.jar"
+        + " -cp " + JRE_HOME_DIR + "/lib/jce.jar"
+        + " -verbose -warn:+deprecation,syntheticAccess,uselessTypeCheck,unsafe,finalBound,unusedLocal"
+        + " -proceedOnError -referenceInfo -d \"" + OUTPUT_DIR + "\"",
+        "[1 .class file generated]\r\n", 
+        "----------\r\n" + 
+        "1. WARNING in ---OUTPUT_DIR_PLACEHOLDER---\\X.java\r\n" + 
+        " (at line 1)\r\n" + 
+        "	import java.util.List;\r\n" + 
+        "	       ^^^^^^^^^^^^^^\r\n" + 
+        "The import java.util.List is never used\r\n" + 
+        "----------\r\n" + 
+        "1 problem (1 warning)", true);
+}
+// test the tester - runNegativeTest; waiting decision about "errors hide warnings"
+public void test008(){
+	this.runNegativeTest(
+		new String[] {
+			"X.java",
+			"import java.util.List;\n" + 
+			"\n" + 
+			"@SuppressWarnings(\"all\"//$NON-NLS-1$\n" + 
+			")\n" + 
+			"public class X {\n" + 
+			"	public static void main(String[] args) {\n" + 
+			"		if (false) {\n" + 
+			"			;\n" + 
+			"		} else {\n" + 
+			"		}\n" + 
+			"		Zork z;\n" + 
+			"	}\n" + 
+			"}"
+        },
+        "\"" + OUTPUT_DIR +  File.separator + "X.java\""
+        + " -1.5 -g -preserveAllLocals"
+        + " -bootclasspath " + JRE_HOME_DIR + "/lib/rt.jar"
+        + " -cp " + JRE_HOME_DIR + "/lib/jce.jar"
+        + " -verbose -warn:+deprecation,syntheticAccess,uselessTypeCheck,unsafe,finalBound,unusedLocal"
+        + " -proceedOnError -referenceInfo -d \"" + OUTPUT_DIR + "\"",
+        "[1 .class file generated]\r\n", 
+        "----------\r\n" + 
+        "1. ERROR in ---OUTPUT_DIR_PLACEHOLDER---\\X.java\r\n" + 
+        " (at line 11)\r\n" + 
+        "	Zork z;\r\n" + 
+        "	^^^^\r\n" + 
+        "Zork cannot be resolved to a type\r\n" + 
+        "----------\r\n" + 
+        "1 problem (1 error)", true);
+}
+// https://bugs.eclipse.org/bugs/show_bug.cgi?id=92398 -- a case that works, another that does not
+// revisit this test case depending on https://bugs.eclipse.org/bugs/show_bug.cgi?id=95349
+public void test009(){
+	this.runNegativeTest(
+		new String[] {
+			"X.java",
+			"/** */\n" + 
+			"public class X {\n" + 
+			"	OK1 ok1;\n" + 
+			"	OK2 ok2;\n" + 
+			"	Warn warn;\n" + 
+			"	KO ko;\n" + 
+	        "	Zork z;\r\n" + 
+			"}",
+			"OK1.java",
+			"/** */\n" + 
+			"public class OK1 {\n" + 
+			"	// empty\n" + 
+			"}",
+			"OK2.java",
+			"/** */\n" + 
+			"public class OK2 {\n" + 
+			"	// empty\n" + 
+			"}",
+			"Warn.java",
+			"/** */\n" + 
+			"public class Warn {\n" + 
+			"	// empty\n" + 
+			"}",
+			"KO.java",
+			"/** */\n" + 
+			"public class KO {\n" + 
+			"	// empty\n" + 
+			"}",
+		},
+        "\"" + OUTPUT_DIR +  File.separator + "X.java\""
+        + " -1.5 -g -preserveAllLocals"
+        + " -cp \"" + OUTPUT_DIR + "[+OK2.java;~Warn.java;-KO.java]\""
+        + " -verbose -warn:+deprecation,syntheticAccess,uselessTypeCheck,unsafe,finalBound,unusedLocal"
+        + " -proceedOnError -referenceInfo -d \"" + OUTPUT_DIR + "\"",
+        "[5 .class files generated]\r\n", 
+        "----------\r\n" + 
+        "1. WARNING in ---OUTPUT_DIR_PLACEHOLDER---\\X.java\r\n" + 
+        " (at line 5)\r\n" + 
+        "	Warn warn;\r\n" + 
+        "	^^^^\r\n" + 
+        "Discouraged access: Warn\r\n" + 
+        "----------\r\n" + 
+        "----------\r\n" + 
+        "2. WARNING in ---OUTPUT_DIR_PLACEHOLDER---\\X.java\r\n" + 
+        " (at line 6)\r\n" + 
+        "	KO ko;\r\n" + 
+        "	^^\r\n" + 
+        "Access restriction: KO\r\n" + 
+        "----------\r\n" + 
+        "----------\r\n" + 
+        "3. ERROR in ---OUTPUT_DIR_PLACEHOLDER---\\X.java\r\n" + 
+        " (at line 7)\r\n" + 
+        "	Zork z;\r\n" + 
+        "	^^^^\r\n" + 
+        "Zork cannot be resolved to a type\r\n" + 
+        "----------\r\n" + 
+        "3 problems (1 error, 2 warnings)",
+        true);
+}
+// command line - no user classpath nor bootclasspath
+public void test010(){
+	this.runConformTest(
+		new String[] {
+			"X.java",
+			"import java.util.List;\n" + 
+			"\n" + 
+			"@SuppressWarnings(\"all\"//$NON-NLS-1$\n" + 
+			")\n" + 
+			"public class X {\n" + 
+			"	public static void main(String[] args) {\n" + 
+			"		if (false) {\n" + 
+			"			;\n" + 
+			"		} else {\n" + 
+			"		}\n" + 
+			"		// Zork z;\n" + 
+			"	}\n" + 
+			"}"
+        },
+        "\"" + OUTPUT_DIR +  File.separator + "X.java\""
+        + " -1.5 -g -preserveAllLocals"
+        + " -verbose -warn:+deprecation,syntheticAccess,uselessTypeCheck,unsafe,finalBound,unusedLocal"
+        + " -proceedOnError -referenceInfo -d \"" + OUTPUT_DIR + "\"",
+        "[1 .class file generated]\r\n", 
+        "----------\r\n" + 
+        "1. WARNING in ---OUTPUT_DIR_PLACEHOLDER---\\X.java\r\n" + 
+        " (at line 1)\r\n" + 
+        "	import java.util.List;\r\n" + 
+        "	       ^^^^^^^^^^^^^^\r\n" + 
+        "The import java.util.List is never used\r\n" + 
+        "----------\r\n" + 
+        "1 problem (1 warning)", true);
+}
+// command line - unusual classpath (ends with ';', still OK)
+public void test011(){
+	this.runConformTest(
+		new String[] {
+			"X.java",
+			"/** */\n" + 
+			"public class X {\n" + 
+			"}",
+		},
+        "\"" + OUTPUT_DIR +  File.separator + "X.java\""
+        + " -1.5 -g -preserveAllLocals"
+        + " -cp \"" + OUTPUT_DIR + "[+**/OK2.java;~**/Warn.java;-KO.java]"
+        + "\";"
+        + " -proceedOnError -referenceInfo -d \"" + OUTPUT_DIR + "\"",
+        "",
+        "",
+        true);
+}
+// command line - help
+public void test012(){
+	this.runConformTest(
+		new String[0],
+        " -help -showversion -referenceInfo",
+        "Eclipse Java Compiler 0.558, pre-3.1.0 release candidate-1, Copyright IBM Corp 2000, 2005. All rights reserved.\n" + 
+        " \n" + 
+        " Usage: <options> <source files | directories>\n" + 
+        " If directories are specified, then their source contents are compiled.\n" + 
+        " Possible options are listed below. Options enabled by default are prefixed with \'+\'\n" + 
+        " \n" + 
+        " Classpath options:\n" + 
+        "    -cp -classpath <directories and zip/jar files separated by ;>\n" + 
+        "                       specify location for application classes and sources. Each\n" + 
+        "                       directory or file can specify access rules for types between\n" + 
+        "                       \'[\' and \']\' (e.g. [-X.java] to deny access to type X)\n" + 
+        "    -bootclasspath <directories and zip/jar files separated by ;>\n" + 
+        "                       specify location for system classes. Each directory or file can\n" + 
+        "                       specify access rules for types between \'[\' and \']\' (e.g. [-X.java]\n" + 
+        "                       to deny access to type X)\n" + 
+        "    -d <dir>           destination directory (if omitted, no directory is created)\n" + 
+        "    -d none            generate no .class files\n" + 
+        "    -encoding <enc>    specify custom encoding for all sources. Each file/directory can override it\n" + 
+        "                       when suffixed with \'[\'<enc>\']\' (e.g. X.java[utf8])\n" + 
+        " \n" + 
+        " Compliance options:\n" + 
+        "    -1.3               use 1.3 compliance level (implicit -source 1.3 -target 1.1)\n" + 
+        "    -1.4             + use 1.4 compliance level (implicit -source 1.3 -target 1.2)\n" + 
+        "    -1.5               use 1.5 compliance level (implicit -source 1.5 -target 1.5)\n" + 
+        "    -source <version>  set source level: 1.3 to 1.5 (or 5 or 5.0)\n" + 
+        "    -target <version>  set classfile target level: 1.1 to 1.5 (or 5 or 5.0)\n" + 
+        " \n" + 
+        " Warning options:\n" + 
+        "    -deprecation     + deprecation outside deprecated code\n" + 
+        "    -nowarn            disable all warnings\n" + 
+        "    -warn:none         disable all warnings\n" + 
+        "    -warn:<warnings separated by ,>    enable exactly the listed warnings\n" + 
+        "    -warn:+<warnings separated by ,>   enable additional warnings\n" + 
+        "    -warn:-<warnings separated by ,>   disable specific warnings\n" + 
+        "      allDeprecation       deprecation including inside deprecated code\n" + 
+        "      allJavadoc           invalid or missing javadoc\n" + 
+        "      assertIdentifier   + \'assert\' used as identifier\n" + 
+        "      boxing               autoboxing conversion\n" + 
+        "      charConcat         + char[] in String concat\n" + 
+        "      conditionAssign      possible accidental boolean assignment\n" + 
+        "      constructorName    + method with constructor name\n" + 
+        "      dep-ann              missing @Deprecated annotation\n" + 
+        "      deprecation        + deprecation outside deprecated code\n" + 
+        "      emptyBlock           undocumented empty block\n" + 
+        "      enumSwitch           incomplete enum switch\n" + 
+        "      fieldHiding          field hiding another variable\n" + 
+        "      finalBound           type parameter with final bound\n" + 
+        "      finally            + finally block not completing normally\n" + 
+        "      indirectStatic       indirect reference to static member\n" + 
+        "      intfAnnotation     + annotation type used as super interface\n" + 
+        "      intfNonInherited   + interface non-inherited method compatibility\n" + 
+        "      javadoc              invalid javadoc\n" + 
+        "      localHiding          local variable hiding another variable\n" + 
+        "      maskedCatchBlock   + hidden catch block\n" + 
+        "      nls                  string literal lacking non-nls tag //$NON-NLS-<n>$\n" + 
+        "      noEffectAssign     + assignment without effect\n" + 
+        "      null                 missing or redundant null check\n" + 
+        "      over-ann             missing @Override annotation\n" + 
+        "      pkgDefaultMethod   + attempt to override package-default method\n" + 
+        "      semicolon            unnecessary semicolon, empty statement\n" + 
+        "      serial             + missing serialVersionUID\n" + 
+        "      suppress           + enable @SuppressWarnings\n" + 
+        "      unqualifiedField     unqualified reference to field\n" + 
+        "      unchecked          + unchecked type operation\n" + 
+        "      unusedArgument       unread method parameter\n" + 
+        "      unusedImport       + unused import declaration\n" + 
+        "      unusedLocal          unread local variable\n" + 
+        "      unusedPrivate        unused private member declaration\n" + 
+        "      unusedThrown         unused declared thrown exception\n" + 
+        "      unnecessaryElse      unnecessary else clause\n" + 
+        "      uselessTypeCheck     unnecessary cast/instanceof operation\n" + 
+        "      specialParamHiding   constructor or setter parameter hiding another field\n" + 
+        "      staticReceiver     + non-static reference to static member\n" + 
+        "      syntheticAccess      synthetic access for innerclass\n" + 
+        "      tasks(<tags separated by |>) tasks identified by tags inside comments\n" + 
+        "      typeHiding         + type parameter hiding another type\n" + 
+        "      varargsCast        + varargs argument need explicit cast\n" + 
+        "      warningToken       + unhandled warning token in @SuppressWarnings\n" + 
+        " \n" + 
+        " Debug options:\n" + 
+        "    -g[:lines,vars,source] custom debug info\n" + 
+        "    -g:lines,source  + both lines table and source debug info\n" + 
+        "    -g                 all debug info\n" + 
+        "    -g:none            no debug info\n" + 
+        "    -preserveAllLocals preserve unused local vars for debug purpose\n" + 
+        " \n" + 
+        " Advanced options:\n" + 
+        "    @<file>            read command line arguments from file\n" + 
+        "    -maxProblems <n>   max number of problems per compilation unit (100 by default)\n" + 
+        "    -log <file>        log to a file\n" + 
+        "    -proceedOnError    do not stop at first error, dumping class files with problem methods\n" + 
+        "    -verbose           enable verbose output\n" + 
+        "    -referenceInfo     compute reference info\n" + 
+        "    -progress          show progress (only in -log mode)\n" + 
+        "    -time              display speed information \n" + 
+        "    -noExit            do not call System.exit(n) at end of compilation (n==0 if no error)\n" + 
+        "    -repeat <n>        repeat compilation process <n> times for perf analysis\n" + 
+        "    -inlineJSR         inline JSR bytecode (implicit if target >= 1.5)\n" + 
+        "    -enableJavadoc     consider references in javadoc\n" + 
+        " \n" + 
+        "    -? -help           print this help message\n" + 
+        "    -v -version        print compiler version\n" + 
+        "    -showversion       print compiler version and continue\n" + 
+        "\r\n", 
+        "", true);
+}
+
+	// command line - xml log contents https://bugs.eclipse.org/bugs/show_bug.cgi?id=93904
+	public void test013() {
+		String logFileName = OUTPUT_DIR + File.separator + "log.xml";
+		this.runNegativeTest(new String[] { 
+				"X.java",
+				"/** */\n" + 
+				"public class X {\n" + 
+				"	Zork z;\n" + 
+				"}", },
+				"\"" + OUTPUT_DIR + File.separator + "X.java\""
+				+ " -1.5 -proceedOnError"
+				+ " -log \"" + logFileName + "\" -d \"" + OUTPUT_DIR + "\"",
+				"", 
+				"----------\r\n" + 
+				"1. ERROR in " + OUTPUT_DIR_PLACEHOLDER + "\\X.java\r\n" + 
+				" (at line 3)\r\n" + 
+				"	Zork z;\r\n" + 
+				"	^^^^\r\n" + 
+				"Zork cannot be resolved to a type\r\n" + 
+				"----------\r\n" + 
+				"1 problem (1 error)", 
+				true);
+		String logContents = Util.fileContent(logFileName);
+		String expectedLogContents = 
+			"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n" + 
+			"<!DOCTYPE compiler SYSTEM \"compiler.dtd\">\r\n" + 
+			"<compiler name=\"Eclipse Java Compiler\" copyright=\"Copyright IBM Corp 2000, 2005. All rights reserved.\" version=\"0.558, pre-3.1.0 release candidate-1\">\r\n" + 
+			"	<command_line>\r\n" + 
+			"		<argument value=\"---OUTPUT_DIR_PLACEHOLDER---\\X.java\"/>\r\n" + 
+			"		<argument value=\"-1.5\"/>\r\n" + 
+			"		<argument value=\"-proceedOnError\"/>\r\n" + 
+			"		<argument value=\"-log\"/>\r\n" + 
+			"		<argument value=\"---OUTPUT_DIR_PLACEHOLDER---\\log.xml\"/>\r\n" + 
+			"		<argument value=\"-d\"/>\r\n" + 
+			"		<argument value=\"---OUTPUT_DIR_PLACEHOLDER---\"/>\r\n" + 
+			"	</command_line>\r\n" + 
+			"	<options>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode\" value=\"disabled\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.codegen.targetPlatform\" value=\"1.5\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.codegen.unusedLocal\" value=\"optimize out\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.compliance\" value=\"1.5\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.debug.lineNumber\" value=\"generate\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.debug.localVariable\" value=\"do not generate\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.debug.sourceFile\" value=\"generate\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.doc.comment.support\" value=\"disabled\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.maxProblemPerUnit\" value=\"100\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.annotationSuperInterface\" value=\"warning\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.assertIdentifier\" value=\"warning\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.autoboxing\" value=\"ignore\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.deprecation\" value=\"warning\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode\" value=\"disabled\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod\" value=\"disabled\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.discouragedReference\" value=\"warning\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.emptyStatement\" value=\"ignore\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.enumIdentifier\" value=\"warning\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.fieldHiding\" value=\"ignore\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.finalParameterBound\" value=\"warning\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally\" value=\"warning\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.forbiddenReference\" value=\"warning\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock\" value=\"warning\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod\" value=\"warning\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch\" value=\"ignore\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.indirectStaticAccess\" value=\"ignore\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.invalidJavadoc\" value=\"ignore\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.invalidJavadocTags\" value=\"enabled\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsDeprecatedRef\" value=\"enabled\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsNotVisibleRef\" value=\"enabled\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility\" value=\"private\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.localVariableHiding\" value=\"ignore\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.methodWithConstructorName\" value=\"warning\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation\" value=\"ignore\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingJavadocComments\" value=\"ignore\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding\" value=\"disabled\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility\" value=\"public\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingJavadocTags\" value=\"ignore\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding\" value=\"disabled\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility\" value=\"private\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation\" value=\"ignore\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingSerialVersion\" value=\"warning\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.noEffectAssignment\" value=\"warning\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion\" value=\"warning\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral\" value=\"ignore\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.nullReference\" value=\"ignore\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod\" value=\"warning\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment\" value=\"ignore\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.specialParameterHidingField\" value=\"disabled\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.staticAccessReceiver\" value=\"warning\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.suppressWarnings\" value=\"enabled\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation\" value=\"ignore\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.typeParameterHiding\" value=\"warning\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation\" value=\"warning\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock\" value=\"ignore\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unhandledWarningToken\" value=\"warning\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unnecessaryElse\" value=\"ignore\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck\" value=\"ignore\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess\" value=\"ignore\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException\" value=\"ignore\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding\" value=\"disabled\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedImport\" value=\"warning\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedLocal\" value=\"ignore\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedParameter\" value=\"ignore\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract\" value=\"disabled\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete\" value=\"disabled\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedPrivateMember\" value=\"ignore\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast\" value=\"warning\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.source\" value=\"1.5\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.taskCaseSensitive\" value=\"enabled\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.taskPriorities\" value=\"\"/>\r\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.taskTags\" value=\"\"/>\r\n" + 
+			"	</options>\r\n" + 
+			"	<classpaths>NORMALIZED SECTION</classpaths>\r\n" + 
+			"	<sources>\r\n" + 
+			"		<source path=\"---OUTPUT_DIR_PLACEHOLDER---\\X.java\">\r\n" + 
+			"			<problems problems=\"1\" errors=\"1\" warnings=\"0\">\r\n" + 
+			"				<problem charEnd=\"28\" charStart=\"25\" severity=\"ERROR\" line=\"3\" id=\"UndefinedType\">\r\n" + 
+			"					<message value=\"Zork cannot be resolved to a type\"/>\r\n" + 
+			"					<source_context value=\"Zork z;\" sourceStart=\"0\" sourceEnd=\"3\"/>\r\n" + 
+			"					<arguments>\r\n" + 
+			"						<argument value=\"Zork\"/>\r\n" + 
+			"					</arguments>\r\n" + 
+			"				</problem>\r\n" + 
+			"			</problems>\r\n" + 
+			"			<classfile path=\"---OUTPUT_DIR_PLACEHOLDER---\\X.class\"/>\r\n" + 
+			"		</source>\r\n" + 
+			"	</sources>\r\n" + 
+			"	<stats>\r\n" + 
+			"		<problem_summary problems=\"1\" errors=\"1\" warnings=\"0\" tasks=\"0\"/>\r\n" + 
+			"	</stats>\r\n" + 
+			"</compiler>\r\n";
+		boolean compareOK = semiNormalizedComparison(expectedLogContents,
+				logContents, xmlLogsNormalizer);
+		if (!compareOK) {
+			System.out.println(getClass().getName() + '#' + getName());
+			System.out.println(
+					  "------------ [START LOG] ------------\n"
+					+ "------------- Expected: -------------\n"
+					+ expectedLogContents
+				  + "\n------------- but was:  -------------\n"
+					+ xmlLogsNormalizer.normalized(logContents)
+				  + "\n--------- (cut and paste:) ----------\n"
+					+ Util.displayString(xmlLogsNormalizer.normalized(logContents))
+				  + "\n------------- [END LOG] -------------\n");
+		}
+		assertTrue("unexpected log contents", compareOK);
+	}
+
+	// command line - txt log contents https://bugs.eclipse.org/bugs/show_bug.cgi?id=93904
+	public void test014() {
+		String logFileName = OUTPUT_DIR + File.separator + "log.txt";
+		this.runNegativeTest(new String[] { 
+				"X.java",
+				"/** */\n" + 
+				"public class X {\n" + 
+				"	Zork z;\n" + 
+				"}", },
+				"\"" + OUTPUT_DIR + File.separator + "X.java\"" 
+				+ " -1.5 -proceedOnError"
+				+ " -log \"" + logFileName + "\" -d \"" + OUTPUT_DIR + "\"",
+				"", 
+				"----------\r\n" + 
+				"1. ERROR in " + OUTPUT_DIR_PLACEHOLDER + "\\X.java\r\n" + 
+				" (at line 3)\r\n" + 
+				"	Zork z;\r\n" + 
+				"	^^^^\r\n" + 
+				"Zork cannot be resolved to a type\r\n" + 
+				"----------\r\n" + 
+				"1 problem (1 error)", 
+				false);
+		String logContents = Util.fileContent(logFileName);
+		String expectedLogContents = 
+			"----------\r\n" + 
+			"1. ERROR in ---OUTPUT_DIR_PLACEHOLDER---\\X.java\r\n" + 
+			" (at line 3)\r\n" + 
+			"	Zork z;\r\n" + 
+			"	^^^^\r\n" + 
+			"Zork cannot be resolved to a type\r\n" + 
+			"----------\r\n" + 
+			"1 problem (1 error)";
+		boolean compareOK = semiNormalizedComparison(expectedLogContents,
+				logContents, textLogsNormalizer);
+		if (!compareOK) {
+			System.out.println(getClass().getName() + '#' + getName());
+			System.out.println(
+							  "------------ [START LOG] ------------\n"
+							+ "------------- Expected: -------------\n"
+							+ expectedLogContents
+						  + "\n------------- but was:  -------------\n"
+							+ outputDirNormalizer.normalized(logContents)
+						  + "\n--------- (cut and paste:) ----------\n"
+							+ Util.displayString(outputDirNormalizer.normalized(logContents))
+						  + "\n------------- [END LOG] -------------\n");
+		}
+		assertTrue("unexpected log contents", compareOK);
+	}
+
+	// command line - no extension log contents https://bugs.eclipse.org/bugs/show_bug.cgi?id=93904
+	public void test015() {
+		String logFileName = OUTPUT_DIR + File.separator + "log";
+		this.runNegativeTest(new String[] { 
+				"X.java",
+				"/** */\n" + 
+				"public class X {\n" + 
+				"	Zork z;\n" + 
+				"}", },
+				"\"" + OUTPUT_DIR + File.separator + "X.java\""
+				+ " -1.5 -proceedOnError"
+				+ " -log \"" + logFileName + "\" -d \"" + OUTPUT_DIR + "\"",
+				"", 
+				"----------\r\n" + 
+				"1. ERROR in ---OUTPUT_DIR_PLACEHOLDER---\\X.java\r\n" + 
+				" (at line 3)\r\n" + 
+				"	Zork z;\r\n" + 
+				"	^^^^\r\n" + 
+				"Zork cannot be resolved to a type\r\n" + 
+				"----------\r\n" + 
+				"1 problem (1 error)", 
+				false);
+		String logContents = Util.fileContent(logFileName);
+		String expectedLogContents = 
+			"----------\r\n" + 
+			"1. ERROR in ---OUTPUT_DIR_PLACEHOLDER---\\X.java\r\n" + 
+			" (at line 3)\r\n" + 
+			"	Zork z;\r\n" + 
+			"	^^^^\r\n" + 
+			"Zork cannot be resolved to a type\r\n" + 
+			"----------\r\n" + 
+			"1 problem (1 error)";
+		boolean compareOK = semiNormalizedComparison(expectedLogContents,
+				logContents, textLogsNormalizer);
+		if (!compareOK) {
+			System.out.println(getClass().getName() + '#' + getName());
+			System.out.println(
+					  "------------ [START LOG] ------------\n"
+					+ "------------- Expected: -------------\n"
+					+ expectedLogContents
+				  + "\n------------- but was:  -------------\n"
+					+ outputDirNormalizer.normalized(logContents)
+				  + "\n--------- (cut and paste:) ----------\n"
+					+ Util.displayString(outputDirNormalizer.normalized(logContents))
+				  + "\n------------- [END LOG] -------------\n");
+		}
+		assertTrue("unexpected log contents", compareOK);
+	}
+//	 command line - unusual classpath (contains multiple empty members, still OK)
+	public void test016(){
+		this.runConformTest(
+			new String[] {
+					"X.java",
+					"/** */\n" + 
+					"public class X {\n" + 
+					"	OK1 ok1;\n" + 
+					"}",
+					"OK1.java",
+					"/** */\n" + 
+					"public class OK1 {\n" + 
+					"	// empty\n" + 
+					"}"
+			},
+	        "\"" + OUTPUT_DIR +  File.separator + "X.java\""
+	        + " -1.5 -g -preserveAllLocals"
+	        + " -cp .;;;\"" + OUTPUT_DIR + "\""
+	        + " -verbose -proceedOnError -referenceInfo"
+	        + " -d \"" + OUTPUT_DIR + "\"",
+	        "[2 .class files generated]\r\n",
+	        "",
+	        true);
+	}
+//	 command line - unusual classpath (contains erroneous members, still OK)
+	public void test017(){
+		this.runConformTest(
+			new String[] {
+					"X.java",
+					"/** */\n" + 
+					"public class X {\n" + 
+					"	OK1 ok1;\n" + 
+					"}",
+					"OK1.java",
+					"/** */\n" + 
+					"public class OK1 {\n" + 
+					"	// empty\n" + 
+					"}"
+			},
+	        "\"" + OUTPUT_DIR +  File.separator + "X.java\""
+	        + " -1.5 -g -preserveAllLocals"
+	        + " -cp dummmy_dir;dummy.jar;;\"" + OUTPUT_DIR + "\"" 
+	        + " -verbose -proceedOnError -referenceInfo" 
+	        + " -d \"" + OUTPUT_DIR + "\"", 
+	        "[2 .class files generated]\r\n",
+	        "",
+	        true);
+	}
+// command line - unusual classpath (empty, but using current directory, still OK provided 
+//	that we execute from the appropriate directory)
+	public void _test018(){
+		this.runConformTest(
+			new String[] {
+					"X.java",
+					"/** */\n" + 
+					"public class X {\n" + 
+					"	OK1 ok1;\n" + 
+					"}",
+					"OK1.java",
+					"/** */\n" + 
+					"public class OK1 {\n" + 
+					"	// empty\n" + 
+					"}"
+			},
+	        "\"" + OUTPUT_DIR +  File.separator + "X.java\""
+	        + " -1.5 -g -preserveAllLocals"
+	        + " -verbose -proceedOnError -referenceInfo"
+	        + " -d \"" + OUTPUT_DIR + "\"",
+	        "[2 .class files generated]\r\n",
+	        "",
+	        true);
+	}
+// https://bugs.eclipse.org/bugs/show_bug.cgi?id=92398 -- with wildcards 
+// a case that works, another that does not
+// revisit this test case depending on https://bugs.eclipse.org/bugs/show_bug.cgi?id=95349
+	public void test019(){
+		this.runNegativeTest(
+			new String[] {
+				"X.java",
+				"/** */\n" + 
+				"public class X {\n" + 
+				"	OK1 ok1;\n" + 
+				"	OK2 ok2;\n" + 
+				"	Warn warn;\n" + 
+				"	KO ko;\n" + 
+		        "	Zork z;\r\n" + 
+				"}",
+				"OK1.java",
+				"/** */\n" + 
+				"public class OK1 {\n" + 
+				"	// empty\n" + 
+				"}",
+				"OK2.java",
+				"/** */\n" + 
+				"public class OK2 {\n" + 
+				"	// empty\n" + 
+				"}",
+				"Warn.java",
+				"/** */\n" + 
+				"public class Warn {\n" + 
+				"	// empty\n" + 
+				"}",
+				"KO.java",
+				"/** */\n" + 
+				"public class KO {\n" + 
+				"	// empty\n" + 
+				"}",
+			},
+	        "\"" + OUTPUT_DIR +  File.separator + "X.java\""
+	        + " -1.5 -g -preserveAllLocals" 
+	        + " -cp \"" + OUTPUT_DIR + "[+OK2.*;~Warn.*;-KO.*]\""
+	        + " -verbose -warn:+deprecation,syntheticAccess,uselessTypeCheck,unsafe,finalBound,unusedLocal" 
+	        + " -proceedOnError -referenceInfo"
+	        + " -d \"" + OUTPUT_DIR + "\"", 
+	        "[5 .class files generated]\r\n", 
+	        "----------\r\n" + 
+	        "1. WARNING in ---OUTPUT_DIR_PLACEHOLDER---\\X.java\r\n" + 
+	        " (at line 5)\r\n" + 
+	        "	Warn warn;\r\n" + 
+	        "	^^^^\r\n" + 
+	        "Discouraged access: Warn\r\n" + 
+	        "----------\r\n" + 
+	        "----------\r\n" + 
+	        "2. WARNING in ---OUTPUT_DIR_PLACEHOLDER---\\X.java\r\n" + 
+	        " (at line 6)\r\n" + 
+	        "	KO ko;\r\n" + 
+	        "	^^\r\n" + 
+	        "Access restriction: KO\r\n" + 
+	        "----------\r\n" + 
+	        "----------\r\n" + 
+	        "3. ERROR in ---OUTPUT_DIR_PLACEHOLDER---\\X.java\r\n" + 
+	        " (at line 7)\r\n" + 
+	        "	Zork z;\r\n" + 
+	        "	^^^^\r\n" + 
+	        "Zork cannot be resolved to a type\r\n" + 
+	        "----------\r\n" + 
+	        "3 problems (1 error, 2 warnings)",
+	        true);
+	}
 public static Class testClass() {
 	return BatchCompilerTest.class;
 }