Attachment #33254 for bug #99620




		if (normalize == null)
			return false;
		// return keep.equals(normalizer.normalized(normalize));
		return equals(keep, 
				normalizer.normalized(normalize));
	}
private static boolean equals(String a, String b) {
	StringBuffer aBuffer = new StringBuffer(a), bBuffer = new StringBuffer(b);

			result);
}
// test the tester - runConformTest
public void test007(){
	this.runConformTest(
		new String[] {
			"X.java",

        + " -cp " + JRE_HOME_DIR + "/lib/jce.jar"
        + " -verbose -warn:+deprecation,syntheticAccess,uselessTypeCheck,unsafe,finalBound,unusedLocal"
        + " -proceedOnError -referenceInfo -d \"" + OUTPUT_DIR + "\"",
		"[parsing    ---OUTPUT_DIR_PLACEHOLDER---/X.java - #1/1]\n" + 
		"[reading    java/lang/Object.class]\n" + 
		"[analyzing  ---OUTPUT_DIR_PLACEHOLDER---/X.java - #1/1]\n" + 
		"[reading    java/util/List.class]\n" + 
		"[reading    java/lang/SuppressWarnings.class]\n" + 
		"[reading    java/lang/String.class]\n" + 
		"[writing    X.class - #1]\n" + 
		"[completed  ---OUTPUT_DIR_PLACEHOLDER---/X.java - #1/1]\n" + 
		"[1 unit compiled]\n" + 
		"[1 .class file generated]\n", 
        "----------\n" + 
        "1. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/X.java\n" + 
        " (at line 1)\n" + 
        "	import java.util.List;\n" + 
        "	       ^^^^^^^^^^^^^^\n" + 

        "1 problem (1 warning)", true);
}
// test the tester - runNegativeTest
public void test008(){
	this.runNegativeTest(
		new String[] {
			"X.java",

        + " -cp " + JRE_HOME_DIR + "/lib/jce.jar"
        + " -verbose -warn:+deprecation,syntheticAccess,uselessTypeCheck,unsafe,finalBound,unusedLocal"
        + " -proceedOnError -referenceInfo -d \"" + OUTPUT_DIR + "\"",
		"[parsing    ---OUTPUT_DIR_PLACEHOLDER---/X.java - #1/1]\n" + 
		"[reading    java/lang/Object.class]\n" + 
		"[analyzing  ---OUTPUT_DIR_PLACEHOLDER---/X.java - #1/1]\n" + 
		"[reading    java/util/List.class]\n" + 
		"[reading    java/lang/SuppressWarnings.class]\n" + 
		"[reading    java/lang/String.class]\n" + 
		"[writing    X.class - #1]\n" + 
		"[completed  ---OUTPUT_DIR_PLACEHOLDER---/X.java - #1/1]\n" + 
		"[1 unit compiled]\n" + 
		"[1 .class file generated]\n", 
		"----------\n" + 
		"1. ERROR in ---OUTPUT_DIR_PLACEHOLDER---/X.java\n" + 
		" (at line 11)\n" + 
		"	Zork z;\n" + 
		"	^^^^\n" + 
		"Zork cannot be resolved to a type\n" + 
		"----------\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",

        + " -1.5 -g -preserveAllLocals"
        + " -cp \"" + OUTPUT_DIR + "[+OK2" + File.pathSeparator + "~Warn" 
        	+ File.pathSeparator + "-KO]\""
        + " -warn:+deprecation,syntheticAccess,uselessTypeCheck,unsafe,finalBound,unusedLocal"
        + " -proceedOnError -referenceInfo -d \"" + OUTPUT_DIR + "\"",
        "", 
		"----------\n" + 
		"1. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/X.java\n" + 
		" (at line 5)\n" + 
		"	Warn warn;\n" + 
		"	^^^^\n" + 
		"Discouraged access: Warn\n" + 
		"----------\n" + 
		"2. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/X.java\n" + 
		" (at line 6)\n" + 
		"	KO ko;\n" + 
		"	^^\n" + 
		"Access restriction: KO\n" + 
		"----------\n" + 
		"3. ERROR in ---OUTPUT_DIR_PLACEHOLDER---/X.java\n" + 
		" (at line 7)\n" + 
		"	Zork z;\n" + 
		"	^^^^\n" + 
		"Zork cannot be resolved to a type\n" + 
		"----------\n" + 
		"3 problems (1 error, 2 warnings)",
        "----------\n" + 
        "3 problems (1 error, 2 warnings)",
        true);
}
// command line - no user classpath nor bootclasspath
public void test010(){
	this.runConformTest(
		new String[] {
			"X.java",

        },
        "\"" + OUTPUT_DIR +  File.separator + "X.java\""
        + " -1.5 -g -preserveAllLocals"
        + " -warn:+deprecation,syntheticAccess,uselessTypeCheck,unsafe,finalBound,unusedLocal"
        + " -proceedOnError -referenceInfo -d \"" + OUTPUT_DIR + "\"",
        "", 
        "----------\n" + 
        "1. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/X.java\n" + 
        " (at line 1)\n" + 
        "	import java.util.List;\n" + 
        "	       ^^^^^^^^^^^^^^\n" + 

        true);
}
// command line - help
public void test012(){
	final String expectedOutput =
        "{0}\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 {1}>\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 {1}>\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" + 
		"    -sourcepath <directories separated by {1}>\n" + 
		"                       specify location for application sources. Each directory can\n" + 
		"                       specify access rules for types between ''['' and '']'' (e.g. [-X.java]\n" + 
		"                       to deny access to type X)\n" + 
		"    -extdirs <directories separated by {1}>\n" + 
		"                       specify location for extension zip/jar files\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" + 
		"    -1.6               use 1.6 compliance level (implicit -source 1.6 -target 1.6)\n" + 
		"    -source <version>  set source level: 1.3 to 1.6 (or 6 or 6.0)\n" + 
		"    -target <version>  set classfile target level: 1.1 to 1.6 (or 6 or 6.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" + 
		"      hiding               macro for fieldHiding, localHiding, typeHiding and maskedCatchBlock\n" + 
		"      incomplete-switch    same as enumSwitch\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" + 
		"      paramAssign          assignment to a parameter\n" + 
		"      pkgDefaultMethod   + attempt to override package-default method\n" + 
		"      raw                  usage of raw type\n" + 
		"      semicolon            unnecessary semicolon, empty statement\n" + 
		"      serial             + missing serialVersionUID\n" + 
		"      specialParamHiding   constructor or setter parameter hiding another field\n" + 
		"      static-access        macro for indirectStatic and staticReceiver\n" + 
		"      staticReceiver     + non-static reference to static member\n" + 
		"      suppress           + enable @SuppressWarnings\n" + 
		"      synthetic-access     same as syntheticAccess\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" + 
		"      unchecked          + unchecked type operation\n" + 
		"      unnecessaryElse      unnecessary else clause\n" + 
		"      unqualified-field-access same as unQualifiedField\n" + 
		"      unqualifiedField     unqualified reference to field\n" + 
		"      unused               macro for unusedArgument, unusedImport, unusedLabel,\n" + 
		"                               unusedLocal, unusedPrivate and unusedThrown\n" + 
		"      unusedArgument       unread method parameter\n" + 
		"      unusedImport       + unused import declaration\n" + 
		"      unusedLabel        + unused label\n" + 
		"      unusedLocal        + unread local variable\n" + 
		"      unusedPrivate      + unused private member declaration\n" + 
		"      unusedThrown         unused declared thrown exception\n" + 
		"      uselessTypeCheck     unnecessary cast/instanceof operation\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" + 
		" Ignored options:\n" + 
		"    -J<option>         pass option to virtual machine (ignored)\n" + 
		"    -X<option>         specify non-standard option (ignored)\n" + 
		"    -X                 print non-standard options and exit (ignored)\n" + 
		"    -O                 optimize for execution time (ignored)\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. If the file extension is ''.xml'', then the log\n" + 
		"                       will be a xml 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" + 
		"\n";

	this.runConformTest(
		new String[0],
        " -help -referenceInfo",
		MessageFormat.format(expectedOutput, new String[] {
				Main.bind("misc.version", new String[] {
					Main.bind("compiler.name"),

}

	// 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",

				+ " -log \"" + logFileName + "\" -d \"" + OUTPUT_DIR + "\"",
				"", 
				"----------\n" + 
				"1. ERROR in ---OUTPUT_DIR_PLACEHOLDER---/X.java\n" + 
				" (at line 3)\n" + 
				"	Zork z;\n" + 
				"	^^^^\n" + 

		String logContents = Util.fileContent(logFileName);
		String expectedLogContents = 
			"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + 
			"<!DOCTYPE compiler PUBLIC \"-//Eclipse.org//DTD Eclipse JDT 3.2.001 Compiler//EN\" \"http://www.eclipse.org/jdt/core/compiler_32_001.dtd\">\n" + 
			"<compiler name=\"{1}\" copyright=\"{2}\" version=\"{3}\">\n" + 
			"	<command_line>\n" + 
			"		<argument value=\"---OUTPUT_DIR_PLACEHOLDER---{0}X.java\"/>\n" + 
			"		<argument value=\"-1.5\"/>\n" + 

			"		<option key=\"org.eclipse.jdt.core.compiler.problem.discouragedReference\" value=\"warning\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.emptyStatement\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.enumIdentifier\" value=\"warning\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.fatalOptionalError\" value=\"enabled\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.fieldHiding\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.finalParameterBound\" value=\"warning\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally\" value=\"warning\"/>\n" + 

			"		<option key=\"org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.indirectStaticAccess\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.invalidJavadoc\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.invalidJavadocTags\" value=\"disabled\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsDeprecatedRef\" value=\"disabled\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsNotVisibleRef\" value=\"disabled\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility\" value=\"public\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.localVariableHiding\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.methodWithConstructorName\" value=\"warning\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation\" value=\"ignore\"/>\n" + 

			"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility\" value=\"public\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingJavadocTags\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding\" value=\"disabled\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility\" value=\"public\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingSerialVersion\" value=\"warning\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.noEffectAssignment\" value=\"warning\"/>\n" + 

			"		<option key=\"org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.nullReference\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod\" value=\"warning\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.parameterAssignment\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.rawTypeReference\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.specialParameterHidingField\" value=\"disabled\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.staticAccessReceiver\" value=\"warning\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.suppressWarnings\" value=\"enabled\"/>\n" + 

			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding\" value=\"disabled\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedImport\" value=\"warning\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedLabel\" value=\"warning\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedLocal\" value=\"warning\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedParameter\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract\" value=\"disabled\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete\" value=\"disabled\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedPrivateMember\" value=\"warning\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast\" value=\"warning\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.source\" value=\"1.5\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.taskCaseSensitive\" value=\"enabled\"/>\n" + 

			"		<problem_summary problems=\"1\" errors=\"1\" warnings=\"0\" tasks=\"0\"/>\n" + 
			"	</stats>\n" + 
			"</compiler>\n";
		String normalizedExpectedLogContents =
				MessageFormat.format(
						expectedLogContents,
						new String[] {
								File.separator,
								Main.bind("compiler.name"),
								Main.bind("compiler.copyright"),
								Main.bind("compiler.version")
						});
		String normalizedLogContents =
				xmlLogsNormalizer.normalized(logContents);
		boolean compareOK = normalizedExpectedLogContents.equals(
				normalizedLogContents);
		if (!compareOK) {
			System.out.println(getClass().getName() + '#' + getName());
			System.out.println(

				  + "\n--------- (cut and paste:) ----------\n"
					+ Util.displayString(xmlLogsNormalizer.normalized(logContents))
				  + "\n------------- [END LOG] -------------\n");
			assertEquals("Unexpected log contents", 
					normalizedExpectedLogContents, normalizedLogContents);
		}
		assertTrue("unexpected log contents", compareOK);
	}

	// command line - txt log contents https://bugs.eclipse.org/bugs/show_bug.cgi?id=93904

		}
		assertTrue("unexpected log contents", compareOK);
	}
public void test016(){
		this.runConformTest(
			new String[] {
					"X.java",

	        + " -cp ." + File.pathSeparator + File.pathSeparator + File.pathSeparator + "\"" + OUTPUT_DIR + "\""
	        + " -verbose -proceedOnError -referenceInfo"
	        + " -d \"" + OUTPUT_DIR + "\"",
			"[parsing    ---OUTPUT_DIR_PLACEHOLDER---/X.java - #1/1]\n" + 
			"[reading    java/lang/Object.class]\n" + 
			"[analyzing  ---OUTPUT_DIR_PLACEHOLDER---/X.java - #1/1]\n" + 
			"[parsing    ---OUTPUT_DIR_PLACEHOLDER---/OK1.java - #2/2]\n" + 
			"[writing    X.class - #1]\n" + 
			"[completed  ---OUTPUT_DIR_PLACEHOLDER---/X.java - #1/2]\n" + 
			"[analyzing  ---OUTPUT_DIR_PLACEHOLDER---/OK1.java - #2/2]\n" + 
			"[writing    OK1.class - #2]\n" + 
			"[completed  ---OUTPUT_DIR_PLACEHOLDER---/OK1.java - #2/2]\n" + 
			"[2 units compiled]\n" + 
			"[2 .class files generated]\n",
	        "",
	        true);
	}
public void test017(){
		this.runConformTest(
			new String[] {
					"X.java",

	        "\"" + OUTPUT_DIR +  File.separator + "X.java\""
	        + " -1.5 -g -preserveAllLocals"
	        + " -cp dummmy_dir" + File.pathSeparator + "dummy.jar" + File.pathSeparator + File.pathSeparator + "\"" + OUTPUT_DIR + "\"" 
	        + " -proceedOnError -referenceInfo" 
	        + " -d \"" + OUTPUT_DIR + "\"",
	        "",
	        "incorrect classpath: dummmy_dir\n",
	        "incorrect classpath: dummy.jar\n" + 
	        "incorrect classpath: dummy.jar\n",
	        true);
	}
// we tolerate inexisting jars on the classpath
// TODO (maxime) check and document
public void _test017b(){
	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 dummy.jar" + File.pathSeparator + File.pathSeparator + "\"" + OUTPUT_DIR + "\"" 
        + " -verbose -proceedOnError -referenceInfo" 
        + " -d \"" + OUTPUT_DIR + "\"",
        "[2 .class files generated]\n",
        "incorrect classpath: dummmy.jar\n",
        true);
}
// we tolerate empty classpath entries
// TODO (maxime) check and document
public void _test017c(){
	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 " + File.pathSeparator + File.pathSeparator + "\"" + OUTPUT_DIR + "\"" 
        + " -verbose -proceedOnError -referenceInfo" 
        + " -d \"" + OUTPUT_DIR + "\"",
        "[2 .class files generated]\n",
        "incorrect classpath\n",
        true);
}
// command line - unusual classpath (empty, but using current directory, still OK provided 
//	that we execute from the appropriate directory); since there is no notion
// of current directory for this tests suite, the test is not executed
// TODO (maxime) enforce working directory
	public void _test018(){
		this.runConformTest(
			new String[] {

	        "",
	        true);
	}
public void test019(){
		this.runNegativeTest(
			new String[] {
				"X.java",

	        "\"" + OUTPUT_DIR +  File.separator + "X.java\""
	        + " -1.5 -g -preserveAllLocals" 
	        + " -cp \"" + OUTPUT_DIR + "[+OK2" + File.pathSeparator + "~Warn" + File.pathSeparator + "-KO]\""
	        + " -warn:+deprecation,syntheticAccess,uselessTypeCheck,unsafe,finalBound,unusedLocal" 
	        + " -proceedOnError -referenceInfo"
	        + " -d \"" + OUTPUT_DIR + "\"", 
	        "", 
			"----------\n" + 
			"1. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/X.java\n" + 
			" (at line 5)\n" + 
			"	Warn warn;\n" + 
			"	^^^^\n" + 
			"Discouraged access: Warn\n" + 
			"----------\n" + 
			"2. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/X.java\n" + 
			" (at line 6)\n" + 
			"	KO ko;\n" + 
			"	^^\n" + 
			"Access restriction: KO\n" + 
			"----------\n" + 
			"3. ERROR in ---OUTPUT_DIR_PLACEHOLDER---/X.java\n" + 
			" (at line 7)\n" + 
			"	Zork z;\n" + 
			"	^^^^\n" + 
			"Zork cannot be resolved to a type\n" + 
			"----------\n" + 
			"3 problems (1 error, 2 warnings)",
	        "----------\n" + 
	        "3 problems (1 error, 2 warnings)",
	        true);
	}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=88364 - skip options -O -Jxxx and -Xxxx, multiple times if needed
	public void test020(){
		this.runConformTest(
			new String[] {
					"X.java",

	        + " -1.5 -g -preserveAllLocals"
	        + " -verbose -proceedOnError -referenceInfo"
	        + " -d \"" + OUTPUT_DIR + "\" -O -Xxxx -O -Jxyz -Xtyu -Jyu",
	        "[parsing    ---OUTPUT_DIR_PLACEHOLDER---/X.java - #1/1]\n" + 
			"[reading    java/lang/Object.class]\n" + 
			"[analyzing  ---OUTPUT_DIR_PLACEHOLDER---/X.java - #1/1]\n" + 
			"[writing    X.class - #1]\n" + 
			"[completed  ---OUTPUT_DIR_PLACEHOLDER---/X.java - #1/1]\n" + 
			"[1 unit compiled]\n" + 
			"[1 .class file generated]\n",
			"",
	        true);
	}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=88364 - -sourcepath finds additional source files
	public void test021(){
		this.runConformTest(
			new String[] {
					"src1/X.java",

	        + " -1.5 -g -preserveAllLocals"
	        + " -verbose -proceedOnError -referenceInfo"
	        + " -d \"" + OUTPUT_DIR + "\" ",
			"[parsing    ---OUTPUT_DIR_PLACEHOLDER---/src2/Y.java - #1/1]\n" + 
			"[parsing    ---OUTPUT_DIR_PLACEHOLDER---/src1/X.java - #2/2]\n" + 
			"[reading    java/lang/Object.class]\n" + 
			"[analyzing  ---OUTPUT_DIR_PLACEHOLDER---/src2/Y.java - #1/2]\n" + 
			"[writing    Y.class - #1]\n" + 
			"[completed  ---OUTPUT_DIR_PLACEHOLDER---/src2/Y.java - #1/2]\n" + 
			"[analyzing  ---OUTPUT_DIR_PLACEHOLDER---/src1/X.java - #2/2]\n" + 
			"[writing    X.class - #2]\n" + 
			"[completed  ---OUTPUT_DIR_PLACEHOLDER---/src1/X.java - #2/2]\n" + 
			"[2 units compiled]\n" + 
			"[2 .class files generated]\n",
	        "",
	        true);
	}

		        true);
		}
//	 https://bugs.eclipse.org/bugs/show_bug.cgi?id=88364 - explicit empty -extdirs removes extensions
		public void test024(){
			this.runNegativeTest(
				new String[] {
						"X.java",

		        "\"" + OUTPUT_DIR +  File.separator + "X.java\""
				+ " -extdirs \"\"" 
		        + " -1.5 -g -preserveAllLocals"
		        + " -proceedOnError -referenceInfo"
		        + " -d \"" + OUTPUT_DIR + "\" ",
		        "",
		        "----------\n" + 
		        "1. ERROR in ---OUTPUT_DIR_PLACEHOLDER---/X.java\n" + 
		        " (at line 3)\n" + 
		        "	sun.net.spi.nameservice.dns.DNSNameService dummy;\n" + 
		        "	^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 

		        true);
		}
//	 https://bugs.eclipse.org/bugs/show_bug.cgi?id=88364 - cumulative -extdirs extends the classpath
		public void test025(){
			this.runConformTest(
				new String[] {
						"src1/X.java",

		        + " -1.5 -g -preserveAllLocals"
		        + " -verbose -proceedOnError -referenceInfo"
		        + " -d \"" + OUTPUT_DIR + "\" ",
		        "[parsing    ---OUTPUT_DIR_PLACEHOLDER---/src2/Y.java - #1/1]\n" + 
				"[parsing    ---OUTPUT_DIR_PLACEHOLDER---/src1/X.java - #2/2]\n" + 
				"[reading    java/lang/Object.class]\n" + 
				"[analyzing  ---OUTPUT_DIR_PLACEHOLDER---/src2/Y.java - #1/2]\n" + 
				"[writing    Y.class - #1]\n" + 
				"[completed  ---OUTPUT_DIR_PLACEHOLDER---/src2/Y.java - #1/2]\n" + 
				"[analyzing  ---OUTPUT_DIR_PLACEHOLDER---/src1/X.java - #2/2]\n" + 
				"[reading    sun/net/spi/nameservice/dns/DNSNameService.class]\n" + 
				"[writing    X.class - #2]\n" + 
				"[completed  ---OUTPUT_DIR_PLACEHOLDER---/src1/X.java - #2/2]\n" + 
				"[2 units compiled]\n" + 
				"[2 .class files generated]\n",
		        "",
		        true);
		}
//	 https://bugs.eclipse.org/bugs/show_bug.cgi?id=88364 - -extdirs extends the classpath before -classpath
		public void test026(){
			this.runConformTest(
				new String[] {
						"src1/X.java",

		        + " -1.5 -g -preserveAllLocals"
		        + " -verbose -proceedOnError -referenceInfo"
		        + " -d \"" + OUTPUT_DIR + "\" ",
				"[parsing    ---OUTPUT_DIR_PLACEHOLDER---/src2/Y.java - #1/1]\n" + 
				"[parsing    ---OUTPUT_DIR_PLACEHOLDER---/src1/X.java - #2/2]\n" + 
				"[reading    java/lang/Object.class]\n" + 
				"[analyzing  ---OUTPUT_DIR_PLACEHOLDER---/src2/Y.java - #1/2]\n" + 
				"[writing    Y.class - #1]\n" + 
				"[completed  ---OUTPUT_DIR_PLACEHOLDER---/src2/Y.java - #1/2]\n" + 
				"[analyzing  ---OUTPUT_DIR_PLACEHOLDER---/src1/X.java - #2/2]\n" + 
				"[writing    X.class - #2]\n" + 
				"[completed  ---OUTPUT_DIR_PLACEHOLDER---/src1/X.java - #2/2]\n" + 
				"[2 units compiled]\n" + 
				"[2 .class files generated]\n",
				"",
		        true);
		}

Lines 966-971 Link Here

(-)batch/org/eclipse/jdt/internal/compiler/batch/Main.java (-2 / +8 lines)
966	public String destinationPath;	966	public String destinationPath;
967	public String[] encodings;	967	public String[] encodings;
968	public Logger logger;	968	public Logger logger;
		969	PrintWriter out;
		970	// need to pass the compiler messages output to the delegate compiler
		971	// do not user directly (use logger)
		972	// TODO (maxime) this is used in one instance - check reason with olivier
969	public int exportedClassFilesCounter;	973	public int exportedClassFilesCounter;
970	public String[] filenames;	974	public String[] filenames;
971	public boolean generatePackagesStructure;	975	public boolean generatePackagesStructure;
Lines 1000-1005 Link Here
1000		1004
1001	public Main(PrintWriter outWriter, PrintWriter errWriter, boolean systemExitWhenFinished, Map customDefaultOptions) {	1005	public Main(PrintWriter outWriter, PrintWriter errWriter, boolean systemExitWhenFinished, Map customDefaultOptions) {
1002	this.logger = new Logger(outWriter, errWriter);	1006	this.logger = new Logger(outWriter, errWriter);
		1007	this.out = outWriter;
1003	this.systemExitWhenFinished = systemExitWhenFinished;	1008	this.systemExitWhenFinished = systemExitWhenFinished;
1004	this.options = new CompilerOptions().getMap();	1009	this.options = new CompilerOptions().getMap();
1005	if (customDefaultOptions != null) {	1010	if (customDefaultOptions != null) {
Lines 2749-2755 Link Here
2749	String relativeStringName = new String(relativeName);	2754	String relativeStringName = new String(relativeName);
2750	try {	2755	try {
2751	if (this.compilerOptions.verbose)	2756	if (this.compilerOptions.verbose)
2752	System.out.println(	2757	this.out.println(
2753	Messages.bind(	2758	Messages.bind(
2754	Messages.compilation_write,	2759	Messages.compilation_write,
2755	new String[] {	2760	new String[] {
Lines 2789-2795 Link Here
2789	getHandlingPolicy(),	2794	getHandlingPolicy(),
2790	this.options,	2795	this.options,
2791	getBatchRequestor(),	2796	getBatchRequestor(),
2792	getProblemFactory());	2797	getProblemFactory(),
		2798	this.out);
2793	this.compilerOptions = batchCompiler.options;	2799	this.compilerOptions = batchCompiler.options;
2794		2800
2795	// set the non-externally configurable options.	2801	// set the non-externally configurable options.




	public ICompilerRequestor requestor;
	public CompilerOptions options;
	public ProblemReporter problemReporter;
	PrintWriter out; // output for messages that are not sent to problemReporter

	// management of unit to be processed
	//public CompilationUnitResult currentCompilationUnitResult;

			new ProblemReporter(policy, this.options, problemFactory);
		this.lookupEnvironment =
			new LookupEnvironment(this, this.options, this.problemReporter, environment);
		this.out = new PrintWriter(System.out, true);
		initializeParser();
	}
	
	/**
	 * Answer a new compiler using the given name environment and compiler options.
	 * The environment and options will be in effect for the lifetime of the compiler.
	 * When the compiler is run, compilation results are sent to the given requestor.
	 *
	 *  @param environment org.eclipse.jdt.internal.compiler.api.env.INameEnvironment
	 *      Environment used by the compiler in order to resolve type and package
	 *      names. The name environment implements the actual connection of the compiler
	 *      to the outside world (e.g. in batch mode the name environment is performing
	 *      pure file accesses, reuse previous build state or connection to repositories).
	 *      Note: the name environment is responsible for implementing the actual classpath
	 *            rules.
	 *
	 *  @param policy org.eclipse.jdt.internal.compiler.api.problem.IErrorHandlingPolicy
	 *      Configurable part for problem handling, allowing the compiler client to
	 *      specify the rules for handling problems (stop on first error or accumulate
	 *      them all) and at the same time perform some actions such as opening a dialog
	 *      in UI when compiling interactively.
	 *      @see org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies
	 *      
	 *  @param requestor org.eclipse.jdt.internal.compiler.api.ICompilerRequestor
	 *      Component which will receive and persist all compilation results and is intended
	 *      to consume them as they are produced. Typically, in a batch compiler, it is 
	 *      responsible for writing out the actual .class files to the file system.
	 *      @see org.eclipse.jdt.internal.compiler.CompilationResult
	 *
	 *  @param problemFactory org.eclipse.jdt.internal.compiler.api.problem.IProblemFactory
	 *      Factory used inside the compiler to create problem descriptors. It allows the
	 *      compiler client to supply its own representation of compilation problems in
	 *      order to avoid object conversions. Note that the factory is not supposed
	 *      to accumulate the created problems, the compiler will gather them all and hand
	 *      them back as part of the compilation unit result.
	 *
	 *  @param out java.io.PrintWriter
	 *      Used by the compiler to output messages which are not related to problems,
	 *      e.g. the information issued in verbose mode. If null, defaults to System.out 
	 *      with automatic flushing. 
	 */
	public Compiler(
		INameEnvironment environment,
		IErrorHandlingPolicy policy,
		Map settings,
		final ICompilerRequestor requestor,
		IProblemFactory problemFactory,
		PrintWriter out) {

		// create a problem handler given a handling policy
		this.options = new CompilerOptions(settings);
		
		// wrap requestor in DebugRequestor if one is specified
		if(DebugRequestor == null) {
			this.requestor = requestor;
		} else {
			this.requestor = new ICompilerRequestor(){
				public void acceptResult(CompilationResult result){
					if (DebugRequestor.isActive()){
						DebugRequestor.acceptDebugResult(result);
					}
					requestor.acceptResult(result);
				}
			};
		}
		this.problemReporter =
			new ProblemReporter(policy, this.options, problemFactory);
		this.lookupEnvironment =
			new LookupEnvironment(this, this.options, this.problemReporter, environment);
		this.out = out == null ? new PrintWriter(System.out, true) : out;
		initializeParser();
	}
	

		}
		this.problemReporter = new ProblemReporter(policy, this.options, problemFactory);
		this.lookupEnvironment = new LookupEnvironment(this, this.options, problemReporter, environment);
		this.out = new PrintWriter(System.out, true);
		initializeParser();
	}

	
	/**
	 * Add an additional binary type
	 */
	public void accept(IBinaryType binaryType, PackageBinding packageBinding, AccessRestriction accessRestriction) {
		if (this.options.verbose) {
			this.out.println(
				Messages.bind(Messages.compilation_loadBinary, new String(binaryType.getName())));
//			new Exception("TRACE BINARY").printStackTrace(System.out);
//		    System.out.println();

		try {
			if (options.verbose) {
				String count = String.valueOf(totalUnits + 1);
				this.out.println(
					Messages.bind(Messages.compilation_request,
						new String[] {
							count,

				new CompilationResult(sourceUnits[i], i, maxUnits, this.options.maxProblemsPerUnit);
			try {
				if (options.verbose) {
					this.out.println(
						Messages.bind(Messages.compilation_request,
						new String[] {
							String.valueOf(i + 1),

				unit = unitsToProcess[i];
				try {
					if (options.verbose)
						this.out.println(
							Messages.bind(Messages.compilation_process,
							new String[] {
								String.valueOf(i + 1),

				unitsToProcess[i] = null; // release reference to processed unit declaration
				requestor.acceptResult(unit.compilationResult.tagAsAccepted());
				if (options.verbose)
					this.out.println(
						Messages.bind(Messages.compilation_done,
						new String[] {
							String.valueOf(i + 1),

		}
		if (options.verbose) {
			if (this.totalUnits > 1) {
				this.out.println(
					Messages.bind(Messages.compilation_units, String.valueOf(this.totalUnits))); 
			} else {
				this.out.println(
					Messages.bind(Messages.compilation_unit, String.valueOf(this.totalUnits))); 
			}
		}

Return to bug 99620

Lines 27-32 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/Compiler.java (-7 / +81 lines)
27	public ICompilerRequestor requestor;	27	public ICompilerRequestor requestor;
28	public CompilerOptions options;	28	public CompilerOptions options;
29	public ProblemReporter problemReporter;	29	public ProblemReporter problemReporter;
		30	PrintWriter out; // output for messages that are not sent to problemReporter
30		31
31	// management of unit to be processed	32	// management of unit to be processed
32	//public CompilationUnitResult currentCompilationUnitResult;	33	//public CompilationUnitResult currentCompilationUnitResult;
Lines 109-114 Link Here
109	new ProblemReporter(policy, this.options, problemFactory);	110	new ProblemReporter(policy, this.options, problemFactory);
110	this.lookupEnvironment =	111	this.lookupEnvironment =
111	new LookupEnvironment(this, this.options, this.problemReporter, environment);	112	new LookupEnvironment(this, this.options, this.problemReporter, environment);
		113	this.out = new PrintWriter(System.out, true);
		114	initializeParser();
		115	}
		116
		117	/**
		118	* Answer a new compiler using the given name environment and compiler options.
		119	* The environment and options will be in effect for the lifetime of the compiler.
		120	* When the compiler is run, compilation results are sent to the given requestor.
		121	*
		122	* @param environment org.eclipse.jdt.internal.compiler.api.env.INameEnvironment
		123	* Environment used by the compiler in order to resolve type and package
		124	* names. The name environment implements the actual connection of the compiler
		125	* to the outside world (e.g. in batch mode the name environment is performing
		126	* pure file accesses, reuse previous build state or connection to repositories).
		127	* Note: the name environment is responsible for implementing the actual classpath
		128	* rules.
		129	*
		130	* @param policy org.eclipse.jdt.internal.compiler.api.problem.IErrorHandlingPolicy
		131	* Configurable part for problem handling, allowing the compiler client to
		132	* specify the rules for handling problems (stop on first error or accumulate
		133	* them all) and at the same time perform some actions such as opening a dialog
		134	* in UI when compiling interactively.
		135	* @see org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies
		136	*
		137	* @param requestor org.eclipse.jdt.internal.compiler.api.ICompilerRequestor
		138	* Component which will receive and persist all compilation results and is intended
		139	* to consume them as they are produced. Typically, in a batch compiler, it is
		140	* responsible for writing out the actual .class files to the file system.
		141	* @see org.eclipse.jdt.internal.compiler.CompilationResult
		142	*
		143	* @param problemFactory org.eclipse.jdt.internal.compiler.api.problem.IProblemFactory
		144	* Factory used inside the compiler to create problem descriptors. It allows the
		145	* compiler client to supply its own representation of compilation problems in
		146	* order to avoid object conversions. Note that the factory is not supposed
		147	* to accumulate the created problems, the compiler will gather them all and hand
		148	* them back as part of the compilation unit result.
		149	*
		150	* @param out java.io.PrintWriter
		151	* Used by the compiler to output messages which are not related to problems,
		152	* e.g. the information issued in verbose mode. If null, defaults to System.out
		153	* with automatic flushing.
		154	*/
		155	public Compiler(
		156	INameEnvironment environment,
		157	IErrorHandlingPolicy policy,
		158	Map settings,
		159	final ICompilerRequestor requestor,
		160	IProblemFactory problemFactory,
		161	PrintWriter out) {
		162
		163	// create a problem handler given a handling policy
		164	this.options = new CompilerOptions(settings);
		165
		166	// wrap requestor in DebugRequestor if one is specified
		167	if(DebugRequestor == null) {
		168	this.requestor = requestor;
		169	} else {
		170	this.requestor = new ICompilerRequestor(){
		171	public void acceptResult(CompilationResult result){
		172	if (DebugRequestor.isActive()){
		173	DebugRequestor.acceptDebugResult(result);
		174	}
		175	requestor.acceptResult(result);
		176	}
177	};
178	}
179	this.problemReporter =
180	new ProblemReporter(policy, this.options, problemFactory);
181	this.lookupEnvironment =
182	new LookupEnvironment(this, this.options, this.problemReporter, environment);
183	this.out = out == null ? new PrintWriter(System.out, true) : out;
112	initializeParser();	184	initializeParser();
113	}	185	}
114		186
Lines 177-191 Link Here
177	}	249	}
178	this.problemReporter = new ProblemReporter(policy, this.options, problemFactory);	250	this.problemReporter = new ProblemReporter(policy, this.options, problemFactory);
179	this.lookupEnvironment = new LookupEnvironment(this, this.options, problemReporter, environment);	251	this.lookupEnvironment = new LookupEnvironment(this, this.options, problemReporter, environment);
		252	this.out = new PrintWriter(System.out, true);
180	initializeParser();	253	initializeParser();
181	}	254	}
		255
182		256
183	/**	257	/**
184	* Add an additional binary type	258	* Add an additional binary type
185	*/	259	*/
186	public void accept(IBinaryType binaryType, PackageBinding packageBinding, AccessRestriction accessRestriction) {	260	public void accept(IBinaryType binaryType, PackageBinding packageBinding, AccessRestriction accessRestriction) {
187	if (this.options.verbose) {	261	if (this.options.verbose) {
188	System.out.println(	262	this.out.println(
189	Messages.bind(Messages.compilation_loadBinary, new String(binaryType.getName())));	263	Messages.bind(Messages.compilation_loadBinary, new String(binaryType.getName())));
190	// new Exception("TRACE BINARY").printStackTrace(System.out);	264	// new Exception("TRACE BINARY").printStackTrace(System.out);
191	// System.out.println();	265	// System.out.println();
Lines 204-210 Link Here
204	try {	278	try {
205	if (options.verbose) {	279	if (options.verbose) {
206	String count = String.valueOf(totalUnits + 1);	280	String count = String.valueOf(totalUnits + 1);
207	System.out.println(	281	this.out.println(
208	Messages.bind(Messages.compilation_request,	282	Messages.bind(Messages.compilation_request,
209	new String[] {	283	new String[] {
210	count,	284	count,
Lines 277-283 Link Here
277	new CompilationResult(sourceUnits[i], i, maxUnits, this.options.maxProblemsPerUnit);	351	new CompilationResult(sourceUnits[i], i, maxUnits, this.options.maxProblemsPerUnit);
278	try {	352	try {
279	if (options.verbose) {	353	if (options.verbose) {
280	System.out.println(	354	this.out.println(
281	Messages.bind(Messages.compilation_request,	355	Messages.bind(Messages.compilation_request,
282	new String[] {	356	new String[] {
283	String.valueOf(i + 1),	357	String.valueOf(i + 1),
Lines 322-328 Link Here
322	unit = unitsToProcess[i];	396	unit = unitsToProcess[i];
323	try {	397	try {
324	if (options.verbose)	398	if (options.verbose)
325	System.out.println(	399	this.out.println(
326	Messages.bind(Messages.compilation_process,	400	Messages.bind(Messages.compilation_process,
327	new String[] {	401	new String[] {
328	String.valueOf(i + 1),	402	String.valueOf(i + 1),
Lines 337-343 Link Here
337	unitsToProcess[i] = null; // release reference to processed unit declaration	411	unitsToProcess[i] = null; // release reference to processed unit declaration
338	requestor.acceptResult(unit.compilationResult.tagAsAccepted());	412	requestor.acceptResult(unit.compilationResult.tagAsAccepted());
339	if (options.verbose)	413	if (options.verbose)
340	System.out.println(	414	this.out.println(
341	Messages.bind(Messages.compilation_done,	415	Messages.bind(Messages.compilation_done,
342	new String[] {	416	new String[] {
343	String.valueOf(i + 1),	417	String.valueOf(i + 1),
Lines 358-367 Link Here
358	}	432	}
359	if (options.verbose) {	433	if (options.verbose) {
360	if (this.totalUnits > 1) {	434	if (this.totalUnits > 1) {
361	System.out.println(	435	this.out.println(
362	Messages.bind(Messages.compilation_units, String.valueOf(this.totalUnits)));	436	Messages.bind(Messages.compilation_units, String.valueOf(this.totalUnits)));
363	} else {	437	} else {
364	System.out.println(	438	this.out.println(
365	Messages.bind(Messages.compilation_unit, String.valueOf(this.totalUnits)));	439	Messages.bind(Messages.compilation_unit, String.valueOf(this.totalUnits)));
366	}	440	}
367	}	441	}