Attachment #94341 for bug #217078




/*******************************************************************************
 * Copyright (c) 2000, 2008 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

			"	       ^^^^^^^^^\n" + 
			"The import java.util is never used\n" + 
			"----------\n",
			"SUCCESS" /* expectedOuputString */,
			null /* expectedErrorString */,
			null,
			true,
			null,

			"	       ^^^^^^^^^\n" + 
			"The import java.util is never used\n" + 
			"----------\n",
			null /* expectedOutputString */,
			"java.lang.Error: Unresolved compilation problem: \n" + /* expectedErrorString */ 
			"\n",
			null,
			true,

			"Non-externalized string literal; it should be followed by //$NON-NLS-<n>$\n" + 
			"----------\n",
			"SUCCESS",
			null /* expectedErrorString */,
			null,
			true,
			null,

			"Empty block should be documented\n" + 
			"----------\n",
			"SUCCESS",
			null /* expectedErrorString */,
			null,
			true,
			null,

			"	                         ^^\n" + 
			"Empty block should be documented\n" + 
			"----------\n",
			null,
			"java.lang.Error: Unresolved compilation problem: \n" + /* expectedErrorString */ 
			"	Empty block should be documented\n" +  
			"\n",
			null,
			true,

Lines 1-5 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/FlowAnalysisTest.java (-1 / +3 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2005, 2007 IBM Corporation and others.	2	* Copyright (c) 2005, 2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 1375-1380 Link Here
1375	"The label label is never explicitly referenced\n" +	1375	"The label label is never explicitly referenced\n" +
1376	"----------\n" /* expectedCompilerLog */,	1376	"----------\n" /* expectedCompilerLog */,
1377	"" /* expectedOutputString */,	1377	"" /* expectedOutputString */,
		1378	"" /* expectedErrorString */,
1378	false /* forceExecution */,	1379	false /* forceExecution */,
1379	null /* classLib */,	1380	null /* classLib */,
1380	true /* shouldFlushOutputDirectory */,	1381	true /* shouldFlushOutputDirectory */,
Lines 1408-1413 Link Here
1408	false /* expectingCompilerErrors */,	1409	false /* expectingCompilerErrors */,
1409	"" /* expectedCompilerLog */,	1410	"" /* expectedCompilerLog */,
1410	"" /* expectedOutputString */,	1411	"" /* expectedOutputString */,
		1412	"" /* expectedErrorString */,
1411	false /* forceExecution */,	1413	false /* forceExecution */,
1412	null /* classLib */,	1414	null /* classLib */,
1413	true /* shouldFlushOutputDirectory */,	1415	true /* shouldFlushOutputDirectory */,




	protected void runNegativeTestWithExecution(
			String[] testFiles, 
			String expectedProblemLog, 
			String expectedOutputString,
			String expectedErrorString,
			String[] classLib,
			boolean shouldFlushOutputDirectory, 
			String[] vmArguments, 

		boolean passed = 
			this.verifier.verifyClassFiles(
				sourceFile, 
				className,
				expectedOutputString /* expectedOutputString */,
				expectedErrorString /* expectedErrorString */,
				this.classpaths, 
				null, 
				vmArguments);
		if (!passed) {
			String platformIndependantExpectedSuccessOutputString = Util.convertToIndependantLineDelimiter(expectedOutputString);
			String platformIndependantFailureReason = Util.convertToIndependantLineDelimiter(this.verifier.failureReason);
			if (platformIndependantFailureReason.indexOf(platformIndependantExpectedSuccessOutputString) == -1) {
				System.out.println(getClass().getName() + '#' + getName());

			boolean expectingCompilerErrors,
			String expectedCompilerLog,
			String expectedOutputString,
			String expectedErrorString,
			boolean forceExecution,
			String[] classLib,
			boolean shouldFlushOutputDirectory, 

				boolean passed = 
					this.verifier.verifyClassFiles(
						sourceFile, 
						className,
						expectedOutputString,
						expectedErrorString,
						this.classpaths, 
						null, 
						vmArguments);

Lines 88-93 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/ProgrammingProblemsTest.java (+1 lines)
88	expectingCompilerErrors,	88	expectingCompilerErrors,
89	expectedCompilerLog,	89	expectedCompilerLog,
90	expectedOutputString,	90	expectedOutputString,
		91	"" /* expectedErrorString */,
91	forceExecution,	92	forceExecution,
92	classLib,	93	classLib,
93	shouldFlushOutputDirectory,	94	shouldFlushOutputDirectory,




/*******************************************************************************
 * Copyright (c) 2005, 2008 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

		false /* expectingCompilerErrors */,
		"" /* expectedCompilerLog */,
		"" /* expectedOutputString */,
		"" /* expectedErrorString */,
		false /* forceExecution */,
		null /* classLib */,
		true /* shouldFlushOutputDirectory */, 

		"Null pointer access: The variable t can only be null at this location\n" + 
		"----------\n" /* expectedCompilerLog */,
		"" /* expectedOutputString */,
		"" /* expectedErrorString */,
		false /* forceExecution */,
		null /* classLib */,
		true /* shouldFlushOutputDirectory */, 

		"Potential null pointer access: The variable t may be null at this location\n" + 
		"----------\n" /* expectedCompilerLog */,
		"" /* expectedOutputString */,
		"" /* expectedErrorString */,
		false /* forceExecution */,
		null /* classLib */,
		true /* shouldFlushOutputDirectory */, 

		false /* expectingCompilerErrors */,
		"" /* expectedCompilerLog */,
		"" /* expectedOutputString */,
		"" /* expectedErrorString */,
		false /* forceExecution */,
		null /* classLib */,
		true /* shouldFlushOutputDirectory */, 

		"Potential null pointer access: The variable str may be null at this location\n" + 
		"----------\n" /* expectedCompilerLog */,
		"" /* expectedOutputString */,
		"" /* expectedErrorString */,
		false /* forceExecution */,
		null /* classLib */,
		true /* shouldFlushOutputDirectory */, 

		"Potential null pointer access: The variable str may be null at this location\n" + 
		"----------\n" /* expectedCompilerLog */,
		"" /* expectedOutputString */,
		"" /* expectedErrorString */,
		false /* forceExecution */,
		null /* classLib */,
		true /* shouldFlushOutputDirectory */, 

			"Null pointer access: The variable o can only be null at this location\n" + 
			"----------\n" /* expectedCompilerLog */,
			"" /* expectedOutputString */,
			"" /* expectedErrorString */,
			false /* forceExecution */,
			null /* classLib */,
			true /* shouldFlushOutputDirectory */, 




/*******************************************************************************
 * Copyright (c) 2006, 2008 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at


// memory exhaustion - try to allocate too big an instance
public void test0001_memory_exhaustion() {
	runTest(
		new String[] { /* testFiles */
			"X.java",
			"public class X {\n" + 
			"  public static void main(String args[]) {\n" + 

			"    storage = new long[itemsNb];\n" +
			"  }\n" + 
			"}\n"},
		false /* expectingCompilerErrors */,
		"" /* expectedCompilerLog */,
		"SUCCESS" /* expectedOutputString */,
		null /* expectedErrorString - skip this because some JREs emit additional info to stderr in case of exception */,
		false /* forceExecution */,
		null /* classLib */,
		true /* shouldFlushOutputDirectory */, 
		null /* vmArguments */, 
		null /* customOptions */,
		null /* clientRequestor */,
		true /* skipJavac */);
}

// synchronization - concurrent access to a resource with explicit and




/*******************************************************************************
 * Copyright (c) 2000, 2008 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

public TestVerifier(boolean reuseVM) {
	this.reuseVM = reuseVM;
}
private boolean checkBuffers(String outputString, String errorString, 
		String sourceFileName, String expectedOutputString, String expectedErrorStringStart) {
	String platformIndependantString;
	if (expectedOutputString != null) {
		platformIndependantString = Util.convertToIndependantLineDelimiter(outputString.trim());
		if (!Util.convertToIndependantLineDelimiter(expectedOutputString).equals(platformIndependantString)) {
			System.out.println(Util.displayString(platformIndependantString, 2));
			this.failureReason =
				"Unexpected output running resulting class file for "
					+ sourceFileName
					+ ":\n"
					+ "--[START]--\n"
					+ outputString
					+ "---[END]---\n";
			return false;
		}
	}	
	if (expectedErrorStringStart != null) {
		platformIndependantString = Util.convertToIndependantLineDelimiter(errorString.trim());
		if (expectedErrorStringStart.length() == 0 && platformIndependantString.length() > 0 ||
				!platformIndependantString.startsWith(Util.convertToIndependantLineDelimiter(expectedErrorStringStart))) {
			/*
			 * This is an opportunistic heuristic for error strings comparison:
			 * - null means skip test;
			 * - empty means exactly empty;
			 * - other means starts with.
			 * If this became insufficient, we could envision using specific
			 * matchers for specific needs.
			 */
			System.out.println(Util.displayString(platformIndependantString, 2));
			this.failureReason =
				"Unexpected error running resulting class file for "
					+ sourceFileName
					+ ":\n"
					+ "--[START]--\n"
					+ errorString
					+ "---[END]---\n";
			return false;
		}
	}
	
	return true;
}


 * a virtual machine.
 */
public boolean verifyClassFiles(String sourceFilePath, String className, String expectedSuccessOutputString, String[] classpaths) {
	return verifyClassFiles(sourceFilePath, className, expectedSuccessOutputString, "", classpaths, null, null);
}
/**
 * Verify that the class files created for the given test file can be loaded by
 * a virtual machine.
 */
public boolean verifyClassFiles(String sourceFilePath, String className, String expectedSuccessOutputString, String[] classpaths, String[] programArguments, String[] vmArguments) {
	return verifyClassFiles(sourceFilePath, className, expectedSuccessOutputString, "", classpaths, programArguments, vmArguments);
}
public boolean verifyClassFiles(String sourceFilePath, String className, String expectedOutputString, 
		String expectedErrorStringStart, String[] classpaths, String[] programArguments, String[] vmArguments) {
	this.outputBuffer = new StringBuffer();
	this.errorBuffer = new StringBuffer();
	if (this.reuseVM && programArguments == null) {

	}
	
	this.failureReason = null;
	return this.checkBuffers(this.outputBuffer.toString(), this.errorBuffer.toString(), sourceFilePath, expectedOutputString, expectedErrorStringStart);
}

/**

Return to bug 217078

Lines 1131-1137 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/AbstractRegressionTest.java (-5 / +9 lines)
1131	protected void runNegativeTestWithExecution(	1131	protected void runNegativeTestWithExecution(
1132	String[] testFiles,	1132	String[] testFiles,
1133	String expectedProblemLog,	1133	String expectedProblemLog,
1134	String expectedSuccessOutputString,	1134	String expectedOutputString,
		1135	String expectedErrorString,
1135	String[] classLib,	1136	String[] classLib,
1136	boolean shouldFlushOutputDirectory,	1137	boolean shouldFlushOutputDirectory,
1137	String[] vmArguments,	1138	String[] vmArguments,
Lines 1211-1223 Link Here
1211	boolean passed =	1212	boolean passed =
1212	this.verifier.verifyClassFiles(	1213	this.verifier.verifyClassFiles(
1213	sourceFile,	1214	sourceFile,
1214	className,	1215	className,
1215	expectedSuccessOutputString,	1216	expectedOutputString /* expectedOutputString */,
		1217	expectedErrorString /* expectedErrorString */,
1216	this.classpaths,	1218	this.classpaths,
1217	null,	1219	null,
1218	vmArguments);	1220	vmArguments);
1219	if (!passed) {	1221	if (!passed) {
1220	String platformIndependantExpectedSuccessOutputString = Util.convertToIndependantLineDelimiter(expectedSuccessOutputString);	1222	String platformIndependantExpectedSuccessOutputString = Util.convertToIndependantLineDelimiter(expectedOutputString);
1221	String platformIndependantFailureReason = Util.convertToIndependantLineDelimiter(this.verifier.failureReason);	1223	String platformIndependantFailureReason = Util.convertToIndependantLineDelimiter(this.verifier.failureReason);
1222	if (platformIndependantFailureReason.indexOf(platformIndependantExpectedSuccessOutputString) == -1) {	1224	if (platformIndependantFailureReason.indexOf(platformIndependantExpectedSuccessOutputString) == -1) {
1223	System.out.println(getClass().getName() + '#' + getName());	1225	System.out.println(getClass().getName() + '#' + getName());
Lines 1245-1250 Link Here
1245	boolean expectingCompilerErrors,	1247	boolean expectingCompilerErrors,
1246	String expectedCompilerLog,	1248	String expectedCompilerLog,
1247	String expectedOutputString,	1249	String expectedOutputString,
		1250	String expectedErrorString,
1248	boolean forceExecution,	1251	boolean forceExecution,
1249	String[] classLib,	1252	String[] classLib,
1250	boolean shouldFlushOutputDirectory,	1253	boolean shouldFlushOutputDirectory,
Lines 1330-1337 Link Here
1330	boolean passed =	1333	boolean passed =
1331	this.verifier.verifyClassFiles(	1334	this.verifier.verifyClassFiles(
1332	sourceFile,	1335	sourceFile,
1333	className,	1336	className,
1334	expectedOutputString,	1337	expectedOutputString,
		1338	expectedErrorString,
1335	this.classpaths,	1339	this.classpaths,
1336	null,	1340	null,
1337	vmArguments);	1341	vmArguments);

Lines 1-5 Link Here

(-)src/org/eclipse/jdt/core/tests/util/TestVerifier.java (-25 / +46 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2007 IBM Corporation and others.	2	* Copyright (c) 2000, 2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 30-58 Link Here
30	public TestVerifier(boolean reuseVM) {	30	public TestVerifier(boolean reuseVM) {
31	this.reuseVM = reuseVM;	31	this.reuseVM = reuseVM;
32	}	32	}
33	private boolean checkBuffers(String errorString, String outputString, String sourceFileName, String expectedSuccessOutputString) {	33	private boolean checkBuffers(String outputString, String errorString,
34		34	String sourceFileName, String expectedOutputString, String expectedErrorStringStart) {
35	if (errorString.trim().length() > 0) {	35	String platformIndependantString;
36	this.failureReason =	36	if (expectedOutputString != null) {
37	"Unexpected target error running resulting class file for "	37	platformIndependantString = Util.convertToIndependantLineDelimiter(outputString.trim());
38	+ sourceFileName	38	if (!Util.convertToIndependantLineDelimiter(expectedOutputString).equals(platformIndependantString)) {
39	+ ":\n"	39	System.out.println(Util.displayString(platformIndependantString, 2));
40	+ errorString;	40	this.failureReason =
41	return false;	41	"Unexpected output running resulting class file for "
42	}	42	+ sourceFileName
43	String platformIndependantOutputString = Util.convertToIndependantLineDelimiter(outputString.trim());	43	+ ":\n"
44	if (expectedSuccessOutputString != null && !Util.convertToIndependantLineDelimiter(expectedSuccessOutputString).equals(platformIndependantOutputString)) {	44	+ "--[START]--\n"
45	System.out.println(Util.displayString(platformIndependantOutputString, 2));	45	+ outputString
46	this.failureReason =	46	+ "---[END]---\n";
47	"Unexpected output running resulting class file for "	47	return false;
48	+ sourceFileName	48	}
49	+ ":\n"	49	}
50	+ "--[START]--\n"	50	if (expectedErrorStringStart != null) {
51	+ outputString	51	platformIndependantString = Util.convertToIndependantLineDelimiter(errorString.trim());
52	+ "---[END]---\n";	52	if (expectedErrorStringStart.length() == 0 && platformIndependantString.length() > 0 \|\|
53	return false;	53	!platformIndependantString.startsWith(Util.convertToIndependantLineDelimiter(expectedErrorStringStart))) {
		54	/*
		55	* This is an opportunistic heuristic for error strings comparison:
		56	* - null means skip test;
		57	* - empty means exactly empty;
		58	* - other means starts with.
		59	* If this became insufficient, we could envision using specific
		60	* matchers for specific needs.
		61	*/
		62	System.out.println(Util.displayString(platformIndependantString, 2));
		63	this.failureReason =
		64	"Unexpected error running resulting class file for "
		65	+ sourceFileName
		66	+ ":\n"
		67	+ "--[START]--\n"
		68	+ errorString
		69	+ "---[END]---\n";
		70	return false;
		71	}
54	}	72	}
55
56	return true;	73	return true;
57	}	74	}
58		75
Lines 557-569 Link Here
557	* a virtual machine.	574	* a virtual machine.
558	*/	575	*/
559	public boolean verifyClassFiles(String sourceFilePath, String className, String expectedSuccessOutputString, String[] classpaths) {	576	public boolean verifyClassFiles(String sourceFilePath, String className, String expectedSuccessOutputString, String[] classpaths) {
560	return verifyClassFiles(sourceFilePath, className, expectedSuccessOutputString, classpaths, null, null);	577	return verifyClassFiles(sourceFilePath, className, expectedSuccessOutputString, "", classpaths, null, null);
561	}	578	}
562	/**	579	/**
563	* Verify that the class files created for the given test file can be loaded by	580	* Verify that the class files created for the given test file can be loaded by
564	* a virtual machine.	581	* a virtual machine.
565	*/	582	*/
566	public boolean verifyClassFiles(String sourceFilePath, String className, String expectedSuccessOutputString, String[] classpaths, String[] programArguments, String[] vmArguments) {	583	public boolean verifyClassFiles(String sourceFilePath, String className, String expectedSuccessOutputString, String[] classpaths, String[] programArguments, String[] vmArguments) {
		584	return verifyClassFiles(sourceFilePath, className, expectedSuccessOutputString, "", classpaths, programArguments, vmArguments);
		585	}
		586	public boolean verifyClassFiles(String sourceFilePath, String className, String expectedOutputString,
		587	String expectedErrorStringStart, String[] classpaths, String[] programArguments, String[] vmArguments) {
567	this.outputBuffer = new StringBuffer();	588	this.outputBuffer = new StringBuffer();
568	this.errorBuffer = new StringBuffer();	589	this.errorBuffer = new StringBuffer();
569	if (this.reuseVM && programArguments == null) {	590	if (this.reuseVM && programArguments == null) {
Lines 574-580 Link Here
574	}	595	}
575		596
576	this.failureReason = null;	597	this.failureReason = null;
577	return this.checkBuffers(this.errorBuffer.toString(), this.outputBuffer.toString(), sourceFilePath, expectedSuccessOutputString);	598	return this.checkBuffers(this.outputBuffer.toString(), this.errorBuffer.toString(), sourceFilePath, expectedOutputString, expectedErrorStringStart);
578	}	599	}
579		600
580	/**	601	/**