Attachment #31884 for bug #42253

Lines 1897-1902 Link Here

(-)src/org/eclipse/jdt/core/tests/model/ReconcilerTests.java (+1 lines)
1897	"import p2.*;\n" +	1897	"import p2.*;\n" +
1898	"public class X {\n" +	1898	"public class X {\n" +
1899	" public void bar(){\n" +	1899	" public void bar(){\n" +
		1900	" System.out.println();\n" +
1900	" }\n" +	1901	" }\n" +
1901	"}\n",	1902	"}\n",
1902	participant.ast	1903	participant.ast

Lines 105-111 Link Here

(-)src/org/eclipse/jdt/core/tests/dom/ASTConverterTestAST3_2.java (-1 / +1 lines)
105	}	105	}
106		106
107	static {	107	static {
108	// TESTS_NAMES = new String[] {"test0602"};	108	// TESTS_NAMES = new String[] {"test0577"};
109	// TESTS_NUMBERS = new int[] { 624 };	109	// TESTS_NUMBERS = new int[] { 624 };
110	}	110	}
111	public static Test suite() {	111	public static Test suite() {

Lines 42-48 Link Here

(-)src/org/eclipse/jdt/core/tests/dom/ASTConverterTest2.java (-1 / +1 lines)
42	}	42	}
43		43
44	static {	44	static {
45	// TESTS_NAMES = new String[] {"test0577"};	45	// TESTS_NAMES = new String[] {"test0472"};
46	// TESTS_NUMBERS = new int[] { 606 };	46	// TESTS_NUMBERS = new int[] { 606 };
47	}	47	}
48	public static Test suite() {	48	public static Test suite() {

Lines 31-37 Link Here

(-)src/org/eclipse/jdt/core/tests/dom/RunConverterTests.java (-1 / +2 lines)
31	ASTConverter15Test.class,	31	ASTConverter15Test.class,
32	ASTConverterAST3Test.class,	32	ASTConverterAST3Test.class,
33	ASTConverterTestAST3_2.class,	33	ASTConverterTestAST3_2.class,
34	ASTConverterBindingsTest.class	34	ASTConverterBindingsTest.class,
		35	ASTConverterRecoveryTest.class
35	};	36	};
36	}	37	}
37	public static Test suite() {	38	public static Test suite() {

Lines 8109-8115 Link Here

(-)src/org/eclipse/jdt/core/tests/dom/ASTConverterAST3Test.java (-1 / +1 lines)
8109	assertNotNull("No compilation unit", result); //$NON-NLS-1$	8109	assertNotNull("No compilation unit", result); //$NON-NLS-1$
8110	assertTrue("result is not a compilation unit", result instanceof CompilationUnit); //$NON-NLS-1$	8110	assertTrue("result is not a compilation unit", result instanceof CompilationUnit); //$NON-NLS-1$
8111	CompilationUnit compilationUnit = (CompilationUnit) result;	8111	CompilationUnit compilationUnit = (CompilationUnit) result;
8112	assertEquals("No errors found", 3, compilationUnit.getMessages().length); //$NON-NLS-1$	8112	assertEquals("No errors found", 4, compilationUnit.getMessages().length); //$NON-NLS-1$
8113	ASTNode node = getASTNode(compilationUnit, 0, 0);	8113	ASTNode node = getASTNode(compilationUnit, 0, 0);
8114	assertNotNull("not null", node); //$NON-NLS-1$	8114	assertNotNull("not null", node); //$NON-NLS-1$
8115	assertTrue("not a Type declaration", node instanceof TypeDeclaration); //$NON-NLS-1$	8115	assertTrue("not a Type declaration", node instanceof TypeDeclaration); //$NON-NLS-1$

Lines 8277-8283 Link Here

(-)src/org/eclipse/jdt/core/tests/dom/ASTConverterTest.java (-1 / +1 lines)
8277	assertNotNull("No compilation unit", result); //$NON-NLS-1$	8277	assertNotNull("No compilation unit", result); //$NON-NLS-1$
8278	assertTrue("result is not a compilation unit", result instanceof CompilationUnit); //$NON-NLS-1$	8278	assertTrue("result is not a compilation unit", result instanceof CompilationUnit); //$NON-NLS-1$
8279	CompilationUnit compilationUnit = (CompilationUnit) result;	8279	CompilationUnit compilationUnit = (CompilationUnit) result;
8280	assertEquals("No errors found", 3, compilationUnit.getMessages().length); //$NON-NLS-1$	8280	assertEquals("No errors found", 4, compilationUnit.getMessages().length); //$NON-NLS-1$
8281	ASTNode node = getASTNode(compilationUnit, 0, 0);	8281	ASTNode node = getASTNode(compilationUnit, 0, 0);
8282	assertNotNull("not null", node); //$NON-NLS-1$	8282	assertNotNull("not null", node); //$NON-NLS-1$
8283	assertTrue("not a Type declaration", node instanceof TypeDeclaration); //$NON-NLS-1$	8283	assertTrue("not a Type declaration", node instanceof TypeDeclaration); //$NON-NLS-1$

Lines 54-59 Link Here

(-)src/org/eclipse/jdt/core/tests/formatter/FormatterRegressionTests.java (+1 lines)
54		54
55	static {	55	static {
56	// TESTS_NUMBERS = new int[] { 609 } ;	56	// TESTS_NUMBERS = new int[] { 609 } ;
		57	// TESTS_NAMES = new String[]{ "test123"};
57	}	58	}
58	public static Test suite() {	59	public static Test suite() {
59	return buildTestSuite(FormatterRegressionTests.class);	60	return buildTestSuite(FormatterRegressionTests.class);




/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.core.tests.dom;

import java.util.List;

import junit.framework.Test;

import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.Block;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.Expression;
import org.eclipse.jdt.core.dom.ExpressionStatement;
import org.eclipse.jdt.core.dom.ITypeBinding;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.MethodInvocation;
import org.eclipse.jdt.core.dom.NumberLiteral;
import org.eclipse.jdt.core.dom.Statement;

public class ASTConverterRecoveryTest extends ConverterTestSetup {
	
	public void setUpSuite() throws Exception {
		super.setUpSuite();
		this.ast = AST.newAST(AST.JLS3);
	}

	public ASTConverterRecoveryTest(String name) {
		super(name);
	}

	static {
		TESTS_NAMES = new String[] {"test0003"};
//		TESTS_NUMBERS =  new int[] { 624 };
	}
	public static Test suite() {
		return buildTestSuite(ASTConverterRecoveryTest.class);
	}
	
	public void test0001() throws JavaModelException {
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy(
			"/Converter/src/test/X.java",
			"package test;\n"+
			"\n"+
			"public class X {\n"+
			"	void foo() {\n"+
			"	    bar(0)\n"+
			"	    baz(1);\n"+
			"	}\n"+
			"}\n");
		
		char[] source = this.workingCopies[0].getSource().toCharArray();
		ASTNode result = runConversion(AST.JLS3, this.workingCopies[0], true);
		
		assertASTNodeEquals(
			"package test;\n" + 
			"public class X {\n" + 
			"  void foo(){\n" + 
			"    bar(0);\n" + 
			"    baz(1);\n" + 
			"  }\n" + 
			"}\n",
			result);
		
		ASTNode node = getASTNode((CompilationUnit) result, 0, 0);
		assertNotNull(node);
		assertTrue("Not a method declaration", node.getNodeType() == ASTNode.METHOD_DECLARATION); //$NON-NLS-1$
		MethodDeclaration methodDeclaration = (MethodDeclaration) node;
		Block block = methodDeclaration.getBody();
		List statements = block.statements();
		assertEquals("wrong size", 2, statements.size()); //$NON-NLS-1$
		Statement statement = (Statement) statements.get(0);
		assertTrue("Not an expression statement", statement.getNodeType() == ASTNode.EXPRESSION_STATEMENT); //$NON-NLS-1$
		ExpressionStatement expressionStatement = (ExpressionStatement) statement;
		checkSourceRange(expressionStatement, "bar(0)", source); //$NON-NLS-1$
		Expression expression = expressionStatement.getExpression();
		assertTrue("Not a method invocation", expression.getNodeType() == ASTNode.METHOD_INVOCATION); //$NON-NLS-1$
		MethodInvocation methodInvocation = (MethodInvocation) expression;
		checkSourceRange(methodInvocation, "bar(0)", source); //$NON-NLS-1$
		List list = methodInvocation.arguments();
		assertTrue("Parameter list is empty", list.size() == 1); //$NON-NLS-1$
		Expression parameter = (Expression) list.get(0);
		assertTrue("Not a number", parameter instanceof NumberLiteral); //$NON-NLS-1$
		ITypeBinding typeBinding = parameter.resolveTypeBinding();
		assertNotNull("No binding", typeBinding); //$NON-NLS-1$
		assertEquals("Not int", "int", typeBinding.getName()); //$NON-NLS-1$ //$NON-NLS-2$
		checkSourceRange(parameter, "0", source); //$NON-NLS-1$
		Statement statement2 = (Statement) statements.get(1);
		assertTrue("Not an expression statement", statement2.getNodeType() == ASTNode.EXPRESSION_STATEMENT); //$NON-NLS-1$
		ExpressionStatement expressionStatement2 = (ExpressionStatement) statement2;
		checkSourceRange(expressionStatement2, "baz(1);", source); //$NON-NLS-1$
		Expression expression2 = expressionStatement2.getExpression();
		assertTrue("Not a method invocation", expression2.getNodeType() == ASTNode.METHOD_INVOCATION); //$NON-NLS-1$
		MethodInvocation methodInvocation2 = (MethodInvocation) expression2;
		checkSourceRange(methodInvocation2, "baz(1)", source); //$NON-NLS-1$
		List list2 = methodInvocation2.arguments();
		assertTrue("Parameter list is empty", list2.size() == 1); //$NON-NLS-1$
		Expression parameter2 = (Expression) list2.get(0);
		assertTrue("Not a number", parameter2 instanceof NumberLiteral); //$NON-NLS-1$
		ITypeBinding typeBinding2 = parameter2.resolveTypeBinding();
		assertNotNull("No binding", typeBinding2); //$NON-NLS-1$
		assertEquals("Not int", "int", typeBinding2.getName()); //$NON-NLS-1$ //$NON-NLS-2$
		checkSourceRange(parameter2, "1", source); //$NON-NLS-1$
	}
	
	public void test0002() throws JavaModelException {
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy(
			"/Converter/src/test/X.java",
			"package test;\n"+
			"\n"+
			"public class X {\n"+
			"	void foo() {\n"+
			"	    baz(0);\n"+
			"	    bar(1,\n"+
			"	}\n"+
			"}\n");
		
		char[] source = this.workingCopies[0].getSource().toCharArray();
		ASTNode result = runConversion(AST.JLS3, this.workingCopies[0], true);
		
		assertASTNodeEquals(
			"package test;\n" + 
			"public class X {\n" + 
			"  void foo(){\n" + 
			"    baz(0);\n" + 
			"    bar(1);\n" + 
			"  }\n" + 
			"}\n",
			result);
		
		ASTNode node = getASTNode((CompilationUnit) result, 0, 0);
		assertNotNull(node);
		assertTrue("Not a method declaration", node.getNodeType() == ASTNode.METHOD_DECLARATION); //$NON-NLS-1$
		MethodDeclaration methodDeclaration = (MethodDeclaration) node;
		Block block = methodDeclaration.getBody();
		List statements = block.statements();
		assertEquals("wrong size", 2, statements.size()); //$NON-NLS-1$
		Statement statement = (Statement) statements.get(0);
		assertTrue("Not an expression statement", statement.getNodeType() == ASTNode.EXPRESSION_STATEMENT); //$NON-NLS-1$
		ExpressionStatement expressionStatement = (ExpressionStatement) statement;
		checkSourceRange(expressionStatement, "baz(0);", source); //$NON-NLS-1$
		Expression expression = expressionStatement.getExpression();
		assertTrue("Not a method invocation", expression.getNodeType() == ASTNode.METHOD_INVOCATION); //$NON-NLS-1$
		MethodInvocation methodInvocation = (MethodInvocation) expression;
		checkSourceRange(methodInvocation, "baz(0)", source); //$NON-NLS-1$
		List list = methodInvocation.arguments();
		assertTrue("Parameter list is empty", list.size() == 1); //$NON-NLS-1$
		Expression parameter = (Expression) list.get(0);
		assertTrue("Not a number", parameter instanceof NumberLiteral); //$NON-NLS-1$
		ITypeBinding typeBinding = parameter.resolveTypeBinding();
		assertNotNull("No binding", typeBinding); //$NON-NLS-1$
		assertEquals("Not int", "int", typeBinding.getName()); //$NON-NLS-1$ //$NON-NLS-2$
		checkSourceRange(parameter, "0", source); //$NON-NLS-1$
		Statement statement2 = (Statement) statements.get(1);
		assertTrue("Not an expression statement", statement2.getNodeType() == ASTNode.EXPRESSION_STATEMENT); //$NON-NLS-1$
		ExpressionStatement expressionStatement2 = (ExpressionStatement) statement2;
		checkSourceRange(expressionStatement2, "bar(1", source); //$NON-NLS-1$
		Expression expression2 = expressionStatement2.getExpression();
		assertTrue("Not a method invocation", expression2.getNodeType() == ASTNode.METHOD_INVOCATION); //$NON-NLS-1$
		MethodInvocation methodInvocation2 = (MethodInvocation) expression2;
		checkSourceRange(methodInvocation2, "bar(1", source); //$NON-NLS-1$
		List list2 = methodInvocation2.arguments();
		assertTrue("Parameter list is empty", list2.size() == 1); //$NON-NLS-1$
		Expression parameter2 = (Expression) list2.get(0);
		assertTrue("Not a number", parameter2 instanceof NumberLiteral); //$NON-NLS-1$
		ITypeBinding typeBinding2 = parameter2.resolveTypeBinding();
		assertNotNull("No binding", typeBinding2); //$NON-NLS-1$
		assertEquals("Not int", "int", typeBinding2.getName()); //$NON-NLS-1$ //$NON-NLS-2$
		checkSourceRange(parameter2, "1", source); //$NON-NLS-1$
	}
	
	public void test0003() throws JavaModelException {
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy(
			"/Converter/src/test/X.java",
			"package test;\n"+
			"\n"+
			"public class X {\n"+
			"	void foo() {\n"+
			"	    baz(0);\n"+
			"	    bar(1,\n"+
			"	    foo(3);\n"+
			"	}\n"+
			"}\n");
		
		char[] source = this.workingCopies[0].getSource().toCharArray();
		ASTNode result = runConversion(AST.JLS3, this.workingCopies[0], true);
		
		assertASTNodeEquals(
			"package test;\n" + 
			"public class X {\n" + 
			"  void foo(){\n" + 
			"    baz(0);\n" + 
			"    bar(1,foo(3));\n" + 
			"  }\n" + 
			"}\n",
			result);
		
		ASTNode node = getASTNode((CompilationUnit) result, 0, 0);
		assertNotNull(node);
		assertTrue("Not a method declaration", node.getNodeType() == ASTNode.METHOD_DECLARATION); //$NON-NLS-1$
		MethodDeclaration methodDeclaration = (MethodDeclaration) node;
		Block block = methodDeclaration.getBody();
		List statements = block.statements();
		assertEquals("wrong size", 2, statements.size()); //$NON-NLS-1$
		Statement statement = (Statement) statements.get(0);
		assertTrue("Not an expression statement", statement.getNodeType() == ASTNode.EXPRESSION_STATEMENT); //$NON-NLS-1$
		ExpressionStatement expressionStatement = (ExpressionStatement) statement;
		checkSourceRange(expressionStatement, "baz(0);", source); //$NON-NLS-1$
		Expression expression = expressionStatement.getExpression();
		assertTrue("Not a method invocation", expression.getNodeType() == ASTNode.METHOD_INVOCATION); //$NON-NLS-1$
		MethodInvocation methodInvocation = (MethodInvocation) expression;
		checkSourceRange(methodInvocation, "baz(0)", source); //$NON-NLS-1$
		List list = methodInvocation.arguments();
		assertTrue("Parameter list is empty", list.size() == 1); //$NON-NLS-1$
		Expression parameter = (Expression) list.get(0);
		assertTrue("Not a number", parameter instanceof NumberLiteral); //$NON-NLS-1$
		ITypeBinding typeBinding = parameter.resolveTypeBinding();
		assertNotNull("No binding", typeBinding); //$NON-NLS-1$
		assertEquals("Not int", "int", typeBinding.getName()); //$NON-NLS-1$ //$NON-NLS-2$
		checkSourceRange(parameter, "0", source); //$NON-NLS-1$
		Statement statement2 = (Statement) statements.get(1);
		assertTrue("Not an expression statement", statement2.getNodeType() == ASTNode.EXPRESSION_STATEMENT); //$NON-NLS-1$
		ExpressionStatement expressionStatement2 = (ExpressionStatement) statement2;
		checkSourceRange(expressionStatement2, "bar(1,\n\t    foo(3);", source); //$NON-NLS-1$
		Expression expression2 = expressionStatement2.getExpression();
		assertTrue("Not a method invocation", expression2.getNodeType() == ASTNode.METHOD_INVOCATION); //$NON-NLS-1$
		MethodInvocation methodInvocation2 = (MethodInvocation) expression2;
		checkSourceRange(methodInvocation2, "bar(1,\n\t    foo(3)", source); //$NON-NLS-1$
		List list2 = methodInvocation2.arguments();
		assertTrue("Parameter list is empty", list2.size() == 2); //$NON-NLS-1$
		Expression parameter2 = (Expression) list2.get(0);
		assertTrue("Not a Number", parameter2 instanceof NumberLiteral); //$NON-NLS-1$
		parameter2 = (Expression) list2.get(1);
		assertTrue("Not a method invocation", parameter2 instanceof MethodInvocation); //$NON-NLS-1$
		MethodInvocation methodInvocation3 = (MethodInvocation) parameter2;
		checkSourceRange(methodInvocation3, "foo(3)", source); //$NON-NLS-1$
	}
}

Lines 901-906 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/parser/GenericDietRecoveryTest.java (+1 lines)
901	" super();\n" +	901	" super();\n" +
902	" }\n" +	902	" }\n" +
903	" void foo() {\n" +	903	" void foo() {\n" +
		904	" Object o = (Y<Z>.W<U>) e;\n" +
904	" }\n" +	905	" }\n" +
905	"}\n";	906	"}\n";
906		907

Lines 47-52 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/parser/TestAll.java (+1 lines)
47	testClasses.add(GenericDietRecoveryTest.class);	47	testClasses.add(GenericDietRecoveryTest.class);
48	testClasses.add(EnumDietRecoveryTest.class);	48	testClasses.add(EnumDietRecoveryTest.class);
49	testClasses.add(AnnotationDietRecoveryTest.class);	49	testClasses.add(AnnotationDietRecoveryTest.class);
		50	testClasses.add(StatementRecoveryTest.class);
50		51
51	/* source element parser tests */	52	/* source element parser tests */
52	testClasses.add(SourceElementParserTest.class);	53	testClasses.add(SourceElementParserTest.class);

Lines 20-30 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/parser/ComplianceDiagnoseTest.java (-6 / +31 lines)
20	}	20	}
21	// Static initializer to specify tests subset using TESTS_* static variables	21	// Static initializer to specify tests subset using TESTS_* static variables
22	// All specified tests which does not belong to the class are skipped...	22	// All specified tests which does not belong to the class are skipped...
23	// static {	23	static {
24	// TESTS_NAMES = new String[] { "test000" };	24	// TESTS_NAMES = new String[] { "test0021" };
25	// TESTS_NUMBERS = new int[] { 50 };	25	// TESTS_NUMBERS = new int[] { 50 };
26	// TESTS_RANGE = new int[] { 21, 50 };	26	// TESTS_RANGE = new int[] { 21, 50 };
27	// }	27	}
28	public static Test suite() {	28	public static Test suite() {
29	return buildTestSuite(testClass());	29	return buildTestSuite(testClass());
30	}	30	}
Lines 494-499 Link Here
494	" assert true;\n" +	494	" assert true;\n" +
495	" ^^^^^^\n" +	495	" ^^^^^^\n" +
496	"Syntax error on token \"assert\", AssignmentOperator expected after this token\n" +	496	"Syntax error on token \"assert\", AssignmentOperator expected after this token\n" +
		497	"----------\n" +
		498	"3. ERROR in X.java (at line 3)\n" +
		499	" assert true;\n" +
		500	" ^^^^^^\n" +
		501	"assert cannot be resolved\n" +
497	"----------\n";	502	"----------\n";
498	String expected14ProblemLog =	503	String expected14ProblemLog =
499	"";	504	"";
Lines 609-615 Link Here
609	" ^^^^^^^^^^^\n" +	614	" ^^^^^^^^^^^\n" +
610	"Syntax error, \'for each\' statements are only available if source level is 5.0\n" +	615	"Syntax error, \'for each\' statements are only available if source level is 5.0\n" +
611	"----------\n" +	616	"----------\n" +
612	"2. ERROR in X.java (at line 4)\n" +	617	"2. ERROR in X.java (at line 3)\n" +
		618	" for(String o: c) {\n" +
		619	" ^\n" +
		620	"c cannot be resolved\n" +
		621	"----------\n" +
		622	"3. ERROR in X.java (at line 4)\n" +
613	" #\n" +	623	" #\n" +
614	" ^\n" +	624	" ^\n" +
615	"Syntax error on token \"Invalid Character\", delete this token\n" +	625	"Syntax error on token \"Invalid Character\", delete this token\n" +
Lines 619-625 Link Here
619		629
620	String expected15ProblemLog =	630	String expected15ProblemLog =
621	"----------\n" +	631	"----------\n" +
622	"1. ERROR in X.java (at line 4)\n" +	632	"1. ERROR in X.java (at line 3)\n" +
		633	" for(String o: c) {\n" +
		634	" ^\n" +
		635	"c cannot be resolved\n" +
		636	"----------\n" +
		637	"2. ERROR in X.java (at line 4)\n" +
623	" #\n" +	638	" #\n" +
624	" ^\n" +	639	" ^\n" +
625	"Syntax error on token \"Invalid Character\", delete this token\n" +	640	"Syntax error on token \"Invalid Character\", delete this token\n" +
Lines 853-859 Link Here
853	" ^^^^^^\n" +	868	" ^^^^^^\n" +
854	"Syntax error on token \"assert\", AssignmentOperator expected after this token\n" +	869	"Syntax error on token \"assert\", AssignmentOperator expected after this token\n" +
855	"----------\n" +	870	"----------\n" +
856	"3. ERROR in X.java (at line 4)\n" +	871	"3. ERROR in X.java (at line 3)\n" +
		872	" assert true;\n" +
		873	" ^^^^^^\n" +
		874	"assert cannot be resolved\n" +
		875	"----------\n" +
		876	"4. ERROR in X.java (at line 4)\n" +
857	" #\n" +	877	" #\n" +
858	" ^\n" +	878	" ^\n" +
859	"Syntax error on token \"Invalid Character\", delete this token\n" +	879	"Syntax error on token \"Invalid Character\", delete this token\n" +
Lines 1118-1123 Link Here
1118	" for(Object o ? c){\n" +	1138	" for(Object o ? c){\n" +
1119	" ^\n" +	1139	" ^\n" +
1120	"Syntax error on token \"?\", : expected\n" +	1140	"Syntax error on token \"?\", : expected\n" +
		1141	"----------\n" +
		1142	"2. ERROR in X.java (at line 3)\n" +
		1143	" for(Object o ? c){\n" +
		1144	" ^\n" +
		1145	"c cannot be resolved\n" +
1121	"----------\n";	1146	"----------\n";
1122		1147
1123	runComplianceParserTest(	1148	runComplianceParserTest(

Lines 33-39 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/parser/DietRecoveryTest.java (-14 / +163 lines)
33	public static boolean optimizeStringLiterals = false;	33	public static boolean optimizeStringLiterals = false;
34	public static long sourceLevel = ClassFileConstants.JDK1_3; //$NON-NLS-1$	34	public static long sourceLevel = ClassFileConstants.JDK1_3; //$NON-NLS-1$
35	static {	35	static {
36	// TESTS_NUMBERS = new int[] { 113 };	36	// TESTS_NUMBERS = new int[] { 2 };
37	}	37	}
38	public static Test suite() {	38	public static Test suite() {
39	return buildTestSuite(DietRecoveryTest.class);	39	return buildTestSuite(DietRecoveryTest.class);
Lines 340-348 Link Here
340	" public int h;\n" +	340	" public int h;\n" +
341	" public int[] i = {0, 1};\n" +	341	" public int[] i = {0, 1};\n" +
342	" public X() {\n" +	342	" public X() {\n" +
343	" super();\n" +	343	" super();\n" +
344	" }\n" +	344	" }\n" +
345	" void foo() {\n" +	345	" void foo() {\n" +
		346	" System.out.println();\n" +
		347	" class L {\n" +
		348	" L() {\n" +
		349	" super();\n" +
		350	" }\n" +
		351	" void baz() {\n" +
		352	" }\n" +
		353	" }\n" +
346	" }\n" +	354	" }\n" +
347	" void bar() {\n" +	355	" void bar() {\n" +
348	" }\n" +	356	" }\n" +
Lines 599-604 Link Here
599	" super();\n" +	607	" super();\n" +
600	" }\n" +	608	" }\n" +
601	" void foo() {\n" +	609	" void foo() {\n" +
		610	" System.out.println();\n" +
		611	" new baz() {\n" +
		612	" };\n" +
602	" }\n" +	613	" }\n" +
603	" void bar() {\n" +	614	" void bar() {\n" +
604	" }\n" +	615	" }\n" +
Lines 1274-1282 Link Here
1274	String expectedDietPlusBodyUnitToString =	1285	String expectedDietPlusBodyUnitToString =
1275	"public class X extends Thread {\n" +	1286	"public class X extends Thread {\n" +
1276	" public X() {\n" +	1287	" public X() {\n" +
1277	" super();\n" +	1288	" super();\n" +
1278	" }\n" +	1289	" }\n" +
1279	" void foo() {\n" +	1290	" void foo() {\n" +
		1291	" ;\n" +
1280	" }\n" +	1292	" }\n" +
1281	" void bar() {\n" +	1293	" void bar() {\n" +
1282	" }\n" +	1294	" }\n" +
Lines 1643-1651 Link Here
1643	"public class X {\n" +	1655	"public class X {\n" +
1644	" public int h;\n" +	1656	" public int h;\n" +
1645	" public X() {\n" +	1657	" public X() {\n" +
1646	" super();\n"+	1658	" super();\n" +
1647	" }\n" +	1659	" }\n" +
1648	" void foo() {\n" +	1660	" void foo() {\n" +
		1661	" System.out.println();\n" +
		1662	" class L {\n" +
		1663	" public int l;\n" +
		1664	" L() {\n" +
		1665	" super();\n" +
		1666	" }\n" +
		1667	" void baz() {\n" +
		1668	" }\n" +
		1669	" }\n" +
1649	" }\n" +	1670	" }\n" +
1650	" void bar() {\n" +	1671	" void bar() {\n" +
1651	" }\n" +	1672	" }\n" +
Lines 1715-1723 Link Here
1715	"public class X {\n" +	1736	"public class X {\n" +
1716	" public int h;\n" +	1737	" public int h;\n" +
1717	" public X() {\n" +	1738	" public X() {\n" +
1718	" super();\n"+	1739	" super();\n" +
1719	" }\n" +	1740	" }\n" +
1720	" void foo() {\n" +	1741	" void foo() {\n" +
		1742	" System.out.println();\n" +
		1743	" class L {\n" +
		1744	" public int l;\n" +
		1745	" L() {\n" +
		1746	" super();\n" +
		1747	" }\n" +
		1748	" void baz() {\n" +
		1749	" }\n" +
		1750	" }\n" +
1721	" }\n" +	1751	" }\n" +
1722	" void bar() {\n" +	1752	" void bar() {\n" +
1723	" }\n" +	1753	" }\n" +
Lines 1855-1863 Link Here
1855	"import java.util.*;\n" +	1885	"import java.util.*;\n" +
1856	"public class X {\n" +	1886	"public class X {\n" +
1857	" public X() {\n" +	1887	" public X() {\n" +
1858	" super();\n"+	1888	" super();\n" +
1859	" }\n" +	1889	" }\n" +
1860	" void foo() {\n" +	1890	" void foo() {\n" +
		1891	" System.out.println();\n" +
		1892	" new X() {\n" +
		1893	" public int h;\n" +
		1894	" () {\n" +
		1895	" super();\n" +
		1896	" }\n" +
		1897	" void baz() {\n" +
		1898	" }\n" +
		1899	" void bar() {\n" +
		1900	" }\n" +
		1901	" void truc() {\n" +
		1902	" }\n" +
		1903	" };\n" +
1861	" }\n" +	1904	" }\n" +
1862	"}\n";	1905	"}\n";
1863		1906
Lines 1922-1930 Link Here
1922	"public class X {\n" +	1965	"public class X {\n" +
1923	" public int h;\n" +	1966	" public int h;\n" +
1924	" public X() {\n" +	1967	" public X() {\n" +
1925	" super();\n"+	1968	" super();\n" +
1926	" }\n" +	1969	" }\n" +
1927	" void foo() {\n" +	1970	" void foo() {\n" +
		1971	" System.out.println();\n" +
1928	" }\n" +	1972	" }\n" +
1929	" void bar() {\n" +	1973	" void bar() {\n" +
1930	" }\n" +	1974	" }\n" +
Lines 1992-2000 Link Here
1992	"import java.util.*;\n" +	2036	"import java.util.*;\n" +
1993	"public class X {\n" +	2037	"public class X {\n" +
1994	" public X() {\n" +	2038	" public X() {\n" +
1995	" super();\n"+	2039	" super();\n" +
1996	" }\n" +	2040	" }\n" +
1997	" void foo() {\n" +	2041	" void foo() {\n" +
		2042	" System.out.println();\n" +
		2043	" class L {\n" +
		2044	" public int l;\n" +
		2045	" L() {\n" +
		2046	" super();\n" +
		2047	" }\n" +
		2048	" void baz() {\n" +
		2049	" }\n" +
		2050	" }\n" +
		2051	" int h;\n" +
1998	" }\n" +	2052	" }\n" +
1999	" void bar() {\n" +	2053	" void bar() {\n" +
2000	" }\n" +	2054	" }\n" +
Lines 3119-3124 Link Here
3119	" super();\n" +	3173	" super();\n" +
3120	" }\n" +	3174	" }\n" +
3121	" int foo() {\n" +	3175	" int foo() {\n" +
		3176	" if (true)\n" +
		3177	" {\n" +
		3178	" int x;\n" +
		3179	" }\n" +
3122	" }\n" +	3180	" }\n" +
3123	"}\n";	3181	"}\n";
3124		3182
Lines 3162-3167 Link Here
3162	" super();\n" +	3220	" super();\n" +
3163	" }\n" +	3221	" }\n" +
3164	" int foo() {\n" +	3222	" int foo() {\n" +
		3223	" {\n" +
		3224	" int x;\n" +
		3225	" }\n" +
3165	" }\n" +	3226	" }\n" +
3166	"}\n";	3227	"}\n";
3167		3228
Lines 4247-4252 Link Here
4247	" super();\n" +	4308	" super();\n" +
4248	" }\n" +	4309	" }\n" +
4249	" int foo() {\n" +	4310	" int foo() {\n" +
		4311	" new X();\n" +
4250	" }\n" +	4312	" }\n" +
4251	"}\n";	4313	"}\n";
4252	String expectedFullUnitToString = expectedDietUnitToString;	4314	String expectedFullUnitToString = expectedDietUnitToString;
Lines 4361-4366 Link Here
4361	" return this;\n" +	4423	" return this;\n" +
4362	" }\n" +	4424	" }\n" +
4363	" int bar() {\n" +	4425	" int bar() {\n" +
		4426	" class Local {\n" +
		4427	" Local() {\n" +
		4428	" super();\n" +
		4429	" }\n" +
		4430	" int hello() {\n" +
		4431	" fo = ;\n" +
		4432	" }\n" +
		4433	" int world() {\n" +
		4434	" }\n" +
		4435	" void foo() {\n" +
		4436	" }\n" +
		4437	" }\n" +
		4438	" int hello;\n" +
4364	" }\n" +	4439	" }\n" +
4365	"}\n";	4440	"}\n";
4366		4441
Lines 4439-4444 Link Here
4439	" super();\n" +	4514	" super();\n" +
4440	" }\n" +	4515	" }\n" +
4441	" public static void main(String[] argv) {\n" +	4516	" public static void main(String[] argv) {\n" +
		4517	" new Member().f = ;\n" +
4442	" }\n" +	4518	" }\n" +
4443	"}\n";	4519	"}\n";
4444		4520
Lines 4506-4516 Link Here
4506	" private Post[] posts;\n" +	4582	" private Post[] posts;\n" +
4507	" private int numberOfDisks;\n" +	4583	" private int numberOfDisks;\n" +
4508	" IncompleteHanoi() {\n" +	4584	" IncompleteHanoi() {\n" +
4509	" super();\n" +	4585	" super();\n" +
4510	" }\n" +	4586	" }\n" +
4511	" public Hanoi(int numberOfDisks) {\n" +	4587	" public Hanoi(int numberOfDisks) {\n" +
4512	" }\n" +	4588	" }\n" +
4513	" private void solve(int depth, Post start, Post free, Post end) {\n" +	4589	" private void solve(int depth, Post start, Post free, Post end) {\n" +
		4590	" if ((depth == 1))\n" +
		4591	" moveDisk(start, end);\n" +
		4592	" else\n" +
		4593	" if ((depth > 1))\n" +
		4594	" {\n" +
		4595	" sol = ;\n" +
		4596	" }\n" +
4514	" }\n" +	4597	" }\n" +
4515	"}\n";	4598	"}\n";
4516		4599
Lines 4552-4560 Link Here
4552	String expectedDietPlusBodyUnitToString =	4635	String expectedDietPlusBodyUnitToString =
4553	"class X {\n" +	4636	"class X {\n" +
4554	" X() {\n" +	4637	" X() {\n" +
4555	" super();\n" +	4638	" super();\n" +
4556	" }\n" +	4639	" }\n" +
4557	" int foo() {\n" +	4640	" int foo() {\n" +
		4641	" Vector v = new Vector();\n" +
		4642	" s v;\n" +
		4643	" addElement();\n" +
4558	" }\n" +	4644	" }\n" +
4559	"}\n";	4645	"}\n";
4560		4646
Lines 4595-4603 Link Here
4595	String expectedDietPlusBodyUnitToString =	4681	String expectedDietPlusBodyUnitToString =
4596	"class X {\n" +	4682	"class X {\n" +
4597	" X() {\n" +	4683	" X() {\n" +
4598	" super();\n" +	4684	" super();\n" +
4599	" }\n" +	4685	" }\n" +
4600	" int foo() {\n" +	4686	" int foo() {\n" +
		4687	" Vector v = new Vector();\n" +
		4688	" public s v;\n" +
		4689	" addElement();\n" +
4601	" }\n" +	4690	" }\n" +
4602	"}\n";	4691	"}\n";
4603		4692
Lines 4640-4648 Link Here
4640	String expectedDietPlusBodyUnitToString =	4729	String expectedDietPlusBodyUnitToString =
4641	"class X {\n" +	4730	"class X {\n" +
4642	" X() {\n" +	4731	" X() {\n" +
4643	" super();\n" +	4732	" super();\n" +
4644	" }\n" +	4733	" }\n" +
4645	" int test() {\n" +	4734	" int test() {\n" +
		4735	" int[] i;\n" +
		4736	" i bar = 1;\n" +
4646	" }\n" +	4737	" }\n" +
4647	"}\n";	4738	"}\n";
4648		4739
Lines 4684-4689 Link Here
4684	" super();\n" +	4775	" super();\n" +
4685	" }\n" +	4776	" }\n" +
4686	" int foo() {\n" +	4777	" int foo() {\n" +
		4778	" X(12);\n" +
4687	" }\n" +	4779	" }\n" +
4688	"}\n";	4780	"}\n";
4689		4781
Lines 5297-5302 Link Here
5297	" super();\n" +	5389	" super();\n" +
5298	" }\n" +	5390	" }\n" +
5299	" void foo() {\n" +	5391	" void foo() {\n" +
		5392	" bar(this.array.length, 10, fred());\n" +
5300	" }\n" +	5393	" }\n" +
5301	" int fred() {\n" +	5394	" int fred() {\n" +
5302	" }\n" +	5395	" }\n" +
Lines 5583-5595 Link Here
5583	" {\n" +	5676	" {\n" +
5584	" }\n" +	5677	" }\n" +
5585	" X() {\n" +	5678	" X() {\n" +
5586	" super();\n" +	5679	" super();\n" +
5587	" }\n" +	5680	" }\n" +
5588	" public void addThreadFilter(IJavaThread thread) {\n" +	5681	" public void addThreadFilter(IJavaThread thread) {\n" +
		5682	" restricts breakpoint;\n" +
		5683	" given thread;\n" +
		5684	" any other;\n" +
		5685	" specified = ;\n" +
5589	" }\n" +	5686	" }\n" +
5590	" public void removeThreadFilter(IJavaThread thread) {\n" +	5687	" public void removeThreadFilter(IJavaThread thread) {\n" +
		5688	" removes the;\n" +
		5689	" thread restriction;\n" +
		5690	" will need = (re - create);\n" +
		5691	" request as;\n" +
		5692	" does not;\n" +
		5693	" the removal;\n" +
		5694	" thread = ;\n" +
5591	" }\n" +	5695	" }\n" +
5592	" public IJavaThread[] getThreadFilters() {\n" +	5696	" public IJavaThread[] getThreadFilters() {\n" +
		5697	" return the;\n" +
		5698	" of threads;\n" +
		5699	" breakpoint is;\n" +
		5700	" restricted to;\n" +
5593	" }\n" +	5701	" }\n" +
5594	"}\n";	5702	"}\n";
5595		5703
Lines 5647-5655 Link Here
5647	" <clinit>() {\n" +	5755	" <clinit>() {\n" +
5648	" }\n" +	5756	" }\n" +
5649	" public Bug() {\n" +	5757	" public Bug() {\n" +
5650	" super();\n" +	5758	" super();\n" +
5651	" }\n" +	5759	" }\n" +
5652	" public static void main(String[] arguments) {\n" +	5760	" public static void main(String[] arguments) {\n" +
		5761	" Shell shell = new Shell((((SWT.MENU \| SWT.RESIZE) \| SWT.TITLE) \| SWT.H_SCROLL));\n" +
		5762	" StyledText text = new StyledText(shell, SWT.WRAP);\n" +
		5763	" shell.addListener(SWT.Resize, new Listener() {\n" +
		5764	" () {\n" +
		5765	" super();\n" +
		5766	" }\n" +
		5767	" public void handleEvent(Event e) {\n" +
		5768	" text.setBounds(shell.getClientArea());\n" +
		5769	" }\n" +
		5770	"});\n" +
		5771	" shell.addListener(SWT.KeyDown, new Listener() {\n" +
		5772	" public void handleEvent(Event e) {\n" +
		5773	" bold = (! bold);\n" +
		5774	" }\n" +
		5775	"});\n" +
		5776	" text.addLineStyleListener(new LineStyleListener() {\n" +
		5777	" () {\n" +
		5778	" super();\n" +
		5779	" }\n" +
		5780	" public void lineGetStyle(LineStyleEvent event) {\n" +
		5781	" }\n" +
		5782	"});\n" +
5653	" }\n" +	5783	" }\n" +
5654	"}\n";	5784	"}\n";
5655		5785
Lines 6158-6163 Link Here
6158	" super();\n" +	6288	" super();\n" +
6159	" }\n" +	6289	" }\n" +
6160	" void bar() {\n" +	6290	" void bar() {\n" +
		6291	" class Inner {\n" +
		6292	" Inner() {\n" +
		6293	" super();\n" +
		6294	" }\n" +
		6295	" void foo() {\n" +
		6296	" try \n" +
		6297	" {\n" +
		6298	" }\n" +
		6299	" catch (Exception e) {\n" +
		6300	" }\n" +
		6301	" }\n" +
		6302	" }\n" +
6161	" }\n" +	6303	" }\n" +
6162	"}\n";	6304	"}\n";
6163		6305
Lines 6256-6261 Link Here
6256	" super();\n" +	6398	" super();\n" +
6257	" }\n" +	6399	" }\n" +
6258	" public void foo() {\n" +	6400	" public void foo() {\n" +
		6401	" try \n" +
		6402	" {\n" +
		6403	" }\n" +
		6404	" catch (Exception e) {\n" +
		6405	" bar(\"blabla\");\n" +
		6406	" throw new Exception(prefix);\n" +
		6407	" }\n" +
6259	" }\n" +	6408	" }\n" +
6260	"}\n";	6409	"}\n";
6261		6410

Lines 219-224 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/parser/ParserTest.java (-2 / +33 lines)
219	" throws e;\n" +	219	" throws e;\n" +
220	" ^^^^^^\n" +	220	" ^^^^^^\n" +
221	"Syntax error on token \"throws\", throw expected\n" +	221	"Syntax error on token \"throws\", throw expected\n" +
		222	"----------\n" +
		223	"2. ERROR in X.java (at line 3)\n" +
		224	" throws e;\n" +
		225	" ^\n" +
		226	"e cannot be resolved\n" +
222	"----------\n"	227	"----------\n"
223	);	228	);
224	}	229	}
Lines 235-240 Link Here
235	"----------\n" +	240	"----------\n" +
236	"1. ERROR in X.java (at line 2)\n" +	241	"1. ERROR in X.java (at line 2)\n" +
237	" public void foo(X, Object o, String s) {\n" +	242	" public void foo(X, Object o, String s) {\n" +
		243	" ^^^^^^^^^\n" +
		244	"X.Object cannot be resolved to a type\n" +
		245	"----------\n" +
		246	"2. ERROR in X.java (at line 2)\n" +
		247	" public void foo(X, Object o, String s) {\n" +
238	" ^\n" +	248	" ^\n" +
239	"Syntax error on token \",\", . expected\n" +	249	"Syntax error on token \",\", . expected\n" +
240	"----------\n"	250	"----------\n"
Lines 461-475 Link Here
461	"}"	471	"}"
462	},	472	},
463	"----------\n" +	473	"----------\n" +
464	"1. ERROR in X.java (at line 6)\n" +	474	"1. ERROR in X.java (at line 5)\n" +
		475	" if (sourceAttachmentPath != null) {\n" +
		476	" ^^^^^^^^^^^^^^^^^^^^\n" +
		477	"sourceAttachmentPath cannot be resolved\n" +
		478	"----------\n" +
		479	"2. ERROR in X.java (at line 6)\n" +
		480	" if (sourceAttachmentPath.isEmpty()) { && !\n" +
		481	" ^^^^^^^^^^^^^^^^^^^^\n" +
		482	"sourceAttachmentPath cannot be resolved\n" +
		483	"----------\n" +
		484	"3. ERROR in X.java (at line 6)\n" +
465	" if (sourceAttachmentPath.isEmpty()) { && !\n" +	485	" if (sourceAttachmentPath.isEmpty()) { && !\n" +
466	" ^^\n" +	486	" ^^\n" +
467	"Syntax error on token \"&&\", invalid (\n" +	487	"Syntax error on token \"&&\", invalid (\n" +
468	"----------\n" +	488	"----------\n" +
469	"2. ERROR in X.java (at line 7)\n" +	489	"4. ERROR in X.java (at line 6)\n" +
		490	" if (sourceAttachmentPath.isEmpty()) { && !\n" +
		491	"sourceAttachmentPath.isAbsolute()) {\n" +
		492	" ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
		493	"The left-hand side of an assignment must be a variable\n" +
		494	"----------\n" +
		495	"5. ERROR in X.java (at line 7)\n" +
470	" sourceAttachmentPath.isAbsolute()) {\n" +	496	" sourceAttachmentPath.isAbsolute()) {\n" +
471	" ^\n" +	497	" ^\n" +
472	"Syntax error on token \"{\", invalid AssignmentOperator\n" +	498	"Syntax error on token \"{\", invalid AssignmentOperator\n" +
		499	"----------\n" +
		500	"6. ERROR in X.java (at line 10)\n" +
		501	" return null;\n" +
		502	" ^^^^\n" +
		503	"Type mismatch: cannot convert from null to int\n" +
473	"----------\n"	504	"----------\n"
474	);	505	);
475	}	506	}

Lines 454-463 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/LookupTest.java (-1 / +11 lines)
454	"----------\n" +	454	"----------\n" +
455	"2. ERROR in p1\\A.java (at line 11)\n" +	455	"2. ERROR in p1\\A.java (at line 11)\n" +
456	" public void anotherMethod(int A) {}; \n" +	456	" public void anotherMethod(int A) {}; \n" +
		457	" ^^^^^^^^^^^^^\n" +
		458	"void is an invalid type for the variable anotherMethod\n" +
		459	"----------\n" +
		460	"3. ERROR in p1\\A.java (at line 11)\n" +
		461	" public void anotherMethod(int A) {}; \n" +
457	" ^\n" +	462	" ^\n" +
458	"Syntax error on token \"(\", ; expected\n" +	463	"Syntax error on token \"(\", ; expected\n" +
459	"----------\n" +	464	"----------\n" +
460	"3. ERROR in p1\\A.java (at line 11)\n" +	465	"4. ERROR in p1\\A.java (at line 11)\n" +
		466	" public void anotherMethod(int A) {}; \n" +
		467	" ^\n" +
		468	"Duplicate local variable A\n" +
		469	"----------\n" +
		470	"5. ERROR in p1\\A.java (at line 11)\n" +
461	" public void anotherMethod(int A) {}; \n" +	471	" public void anotherMethod(int A) {}; \n" +
462	" ^\n" +	472	" ^\n" +
463	"Syntax error on token \")\", ; expected\n" +	473	"Syntax error on token \")\", ; expected\n" +

Lines 617-632 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTest_1_5.java (-10 / +10 lines)
617	" public class X<T, U, V extend Exception> {}"	617	" public class X<T, U, V extend Exception> {}"
618	},	618	},
619	"----------\n" +	619	"----------\n" +
620	"1. ERROR in X.java (at line 7)\n" +	620	"1. ERROR in X.java (at line 7)\n" +
621	" public class X<T, U, V extend Exception> {}\n" +	621	" public class X<T, U, V extend Exception> {}\n" +
622	" ^^^^^^\n" +	622	" ^^^^^^\n" +
623	"Syntax error on token \"extend\", extends expected\n" +	623	"Syntax error on token \"extend\", extends expected\n" +
624	"----------\n" +	624	"----------\n" +
625	"2. ERROR in X.java (at line 7)\n" +	625	"2. ERROR in X.java (at line 7)\n" +
626	" public class X<T, U, V extend Exception> {}\n" +	626	" public class X<T, U, V extend Exception> {}\n" +
627	" ^^^^^^\n" +	627	" ^^^^^^\n" +
628	"extend cannot be resolved to a type\n" +	628	"extend cannot be resolved to a type\n" +
629	"----------\n"	629	"----------\n"
630	);	630	);
631	}	631	}
632		632

Lines 2958-2963 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/Compliance_1_5.java (+5 lines)
2958	"----------\n" +	2958	"----------\n" +
2959	"1. ERROR in X.java (at line 3)\n" +	2959	"1. ERROR in X.java (at line 3)\n" +
2960	" Object enum = null;\n" +	2960	" Object enum = null;\n" +
		2961	" ^^^^^^\n" +
		2962	"Object cannot be resolved\n" +
		2963	"----------\n" +
		2964	"2. ERROR in X.java (at line 3)\n" +
		2965	" Object enum = null;\n" +
2961	" ^^^^\n" +	2966	" ^^^^\n" +
2962	"Syntax error on token \"enum\", delete this token\n" +	2967	"Syntax error on token \"enum\", delete this token\n" +
2963	"----------\n");	2968	"----------\n");




/*******************************************************************************
 * Copyright (c) 2000, 2004 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.core.tests.compiler.parser;

import java.util.Locale;

import junit.framework.Test;

import org.eclipse.jdt.core.tests.util.AbstractCompilerTest;
import org.eclipse.jdt.core.tests.util.Util;
import org.eclipse.jdt.internal.compiler.CompilationResult;
import org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies;
import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
import org.eclipse.jdt.internal.compiler.batch.CompilationUnit;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.parser.Parser;
import org.eclipse.jdt.internal.compiler.problem.DefaultProblemFactory;
import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;

public class StatementRecoveryTest extends AbstractCompilerTest {
	public static final boolean ONLY_DIET_PLUS_BODY_WITH_STATEMENT_RECOVERY = true;
	
	public static boolean optimizeStringLiterals = false;
	public static long sourceLevel = ClassFileConstants.JDK1_3; //$NON-NLS-1$
	
static {
//	TESTS_NAMES = new String[] { "test0037"};
//	TESTS_RANGE = new int[] {10, 20};
}
public static Test suite() {
	return buildTestSuite(StatementRecoveryTest.class);
}
public StatementRecoveryTest(String testName){
	super(testName);
}

public void checkParse(
	char[] source, 
	String expectedDietUnitToString,
	String expectedDietWithStatementRecoveryUnitToString,
	String expectedDietPlusBodyUnitToString,	
	String expectedDietPlusBodyWithStatementRecoveryUnitToString,	
	String expectedFullUnitToString,
	String expectedFullWithStatementRecoveryUnitToString,
	String testName) {

	/* using regular parser in DIET mode */
	if(!ONLY_DIET_PLUS_BODY_WITH_STATEMENT_RECOVERY){
		Parser parser = 
			new Parser(
				new ProblemReporter(
					DefaultErrorHandlingPolicies.proceedWithAllProblems(), 
					new CompilerOptions(getCompilerOptions()), 
					new DefaultProblemFactory(Locale.getDefault())),
				optimizeStringLiterals);
		parser.statementRecoveryEnabled = false;
		
		ICompilationUnit sourceUnit = new CompilationUnit(source, testName, null);
		CompilationResult compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);	
		
		CompilationUnitDeclaration computedUnit = parser.dietParse(sourceUnit, compilationResult);
		String computedUnitToString = computedUnit.toString();
		if (!expectedDietUnitToString.equals(computedUnitToString)){
			System.out.println(Util.displayString(computedUnitToString));
		}
		assertEquals(
			"Invalid unit diet structure" + testName,
			expectedDietUnitToString,
			computedUnitToString);
	}
	/* using regular parser in DIET mode and statementRecoveryEnabled */
	if(!ONLY_DIET_PLUS_BODY_WITH_STATEMENT_RECOVERY){
		Parser parser = 
			new Parser(
				new ProblemReporter(
					DefaultErrorHandlingPolicies.proceedWithAllProblems(), 
					new CompilerOptions(getCompilerOptions()), 
					new DefaultProblemFactory(Locale.getDefault())),
				optimizeStringLiterals);

		ICompilationUnit sourceUnit = new CompilationUnit(source, testName, null);
		CompilationResult compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);	
		
		CompilationUnitDeclaration computedUnit = parser.dietParse(sourceUnit, compilationResult);
		String computedUnitToString = computedUnit.toString();
		if (!expectedDietWithStatementRecoveryUnitToString.equals(computedUnitToString)){
			System.out.println(Util.displayString(computedUnitToString));
		}
		assertEquals(
			"Invalid unit diet structure with statement recovery enabled" + testName,
			expectedDietWithStatementRecoveryUnitToString,
			computedUnitToString);
	}
	/* using regular parser in DIET mode + getMethodBodies */
	if(!ONLY_DIET_PLUS_BODY_WITH_STATEMENT_RECOVERY){
		Parser parser = 
			new Parser(
				new ProblemReporter(
					DefaultErrorHandlingPolicies.proceedWithAllProblems(), 
					new CompilerOptions(getCompilerOptions()), 
					new DefaultProblemFactory(Locale.getDefault())),
				optimizeStringLiterals);
		parser.statementRecoveryEnabled = false;

		ICompilationUnit sourceUnit = new CompilationUnit(source, testName, null);
		CompilationResult compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);	
		
		CompilationUnitDeclaration computedUnit = parser.dietParse(sourceUnit, compilationResult);
		String computedUnitToString = computedUnit.toString();
		if (!expectedDietUnitToString.equals(computedUnitToString)){
			System.out.println(Util.displayString(computedUnitToString));
		}
		assertEquals(
			"Invalid unit diet structure" + testName,
			expectedDietUnitToString,
			computedUnitToString);
		if (computedUnit.types != null) {
			for (int i = computedUnit.types.length; --i >= 0;){
				computedUnit.types[i].parseMethod(parser, computedUnit);
			}
		}
		computedUnitToString = computedUnit.toString();
		if (!expectedDietPlusBodyUnitToString.equals(computedUnitToString)){
			System.out.println(Util.displayString(computedUnitToString));
		}
		
		assertEquals(
			"Invalid unit diet+body structure" + testName,
			expectedDietPlusBodyUnitToString,
			computedUnitToString);
	}
	/* using regular parser in DIET mode + getMethodBodies and statementRecoveryEnabled */
	{
		Parser parser = 
			new Parser(
				new ProblemReporter(
					DefaultErrorHandlingPolicies.proceedWithAllProblems(), 
					new CompilerOptions(getCompilerOptions()), 
					new DefaultProblemFactory(Locale.getDefault())),
				optimizeStringLiterals);

		ICompilationUnit sourceUnit = new CompilationUnit(source, testName, null);
		CompilationResult compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);	
		
		CompilationUnitDeclaration computedUnit = parser.dietParse(sourceUnit, compilationResult);
		String computedUnitToString = computedUnit.toString();
		if (!expectedDietWithStatementRecoveryUnitToString.equals(computedUnitToString)){
			System.out.println(Util.displayString(computedUnitToString));
		}
		assertEquals(
			"Invalid unit diet structure" + testName,
			expectedDietWithStatementRecoveryUnitToString,
			computedUnitToString);
		if (computedUnit.types != null) {
			for (int i = computedUnit.types.length; --i >= 0;){
				computedUnit.types[i].parseMethod(parser, computedUnit);
			}
		}
		computedUnitToString = computedUnit.toString();
		if (!expectedDietPlusBodyWithStatementRecoveryUnitToString.equals(computedUnitToString)){
			System.out.println(Util.displayString(computedUnitToString));
		}
		
		assertEquals(
			"Invalid unit diet+body structure with statement recovery enabled" + testName,
			expectedDietPlusBodyWithStatementRecoveryUnitToString,
			computedUnitToString);
	}
	/* using regular parser in FULL mode */
	if(!ONLY_DIET_PLUS_BODY_WITH_STATEMENT_RECOVERY){
		Parser parser = 
			new Parser(
				new ProblemReporter(
					DefaultErrorHandlingPolicies.proceedWithAllProblems(), 
					new CompilerOptions(getCompilerOptions()), 
					new DefaultProblemFactory(Locale.getDefault())),
				optimizeStringLiterals);
		parser.statementRecoveryEnabled = false;

		ICompilationUnit sourceUnit = new CompilationUnit(source, testName, null);
		CompilationResult compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);	
		
		CompilationUnitDeclaration computedUnit = parser.parse(sourceUnit, compilationResult);
		String computedUnitToString = computedUnit.toString();
		if (!expectedFullUnitToString.equals(computedUnitToString)){
			System.out.println(Util.displayString(computedUnitToString));
		}
		assertEquals(
			"Invalid unit full structure" + testName,
			expectedFullUnitToString,
			computedUnitToString);

	}
	/* using regular parser in FULL mode and statementRecoveryEnabled */
	if(!ONLY_DIET_PLUS_BODY_WITH_STATEMENT_RECOVERY){
		Parser parser = 
			new Parser(
				new ProblemReporter(
					DefaultErrorHandlingPolicies.proceedWithAllProblems(), 
					new CompilerOptions(getCompilerOptions()), 
					new DefaultProblemFactory(Locale.getDefault())),
				optimizeStringLiterals);

		ICompilationUnit sourceUnit = new CompilationUnit(source, testName, null);
		CompilationResult compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);	
		
		CompilationUnitDeclaration computedUnit = parser.parse(sourceUnit, compilationResult);
		String computedUnitToString = computedUnit.toString();
		if (!expectedFullWithStatementRecoveryUnitToString.equals(computedUnitToString)){
			System.out.println(Util.displayString(computedUnitToString));
		}
		assertEquals(
			"Invalid unit full structure with statement recovery enabled" + testName,
			expectedFullWithStatementRecoveryUnitToString,
			computedUnitToString);

	}
}

public void test0001() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    System.out.println();					\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		expectedDietPlusBodyUnitToString;
	
	String expectedFullUnitToString =
		expectedDietPlusBodyUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedFullUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0002() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    #                    					\n"
			+ "    System.out.println();					\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0003() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    System.out.println();					\n"
			+ "    #                    					\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0004() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    #                    					\n"
			+ "    System.out.println();					\n"
			+ "    System.out.println();					\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0005() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    System.out.println();					\n"
			+ "    System.out.println();					\n"
			+ "    #                    					\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0006() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    System.out.println();					\n"
			+ "    System.out.println();					\n"
			+ "    #                    					\n"
			+ "    System.out.println();					\n"
			+ "    System.out.println();					\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"    System.out.println();\n" + 
		"    System.out.println();\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0007() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    #                    					\n"
			+ "    System.out.println();					\n"
			+ "    if(true) {								\n"
			+ "      System.out.println();					\n"
			+ "    }										\n"
			+ "    System.out.println();					\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"    if (true)\n" + 
		"        {\n" + 
		"          System.out.println();\n" + 
		"        }\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0008() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    System.out.println();					\n"
			+ "    if(true) {								\n"
			+ "      System.out.println();					\n"
			+ "    }										\n"
			+ "    System.out.println();					\n"
			+ "    #                    					\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"    if (true)\n" + 
		"        {\n" + 
		"          System.out.println();\n" + 
		"        }\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0009() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    System.out.println();					\n"
			+ "    if(true) {								\n"
			+ "      System.out.println();					\n"
			+ "    }										\n"
			+ "    System.out.println();					\n"
			+ "    #                    					\n"
			+ "    System.out.println();					\n"
			+ "    if(true) {								\n"
			+ "      System.out.println();					\n"
			+ "    }										\n"
			+ "    System.out.println();					\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"    if (true)\n" + 
		"        {\n" + 
		"          System.out.println();\n" + 
		"        }\n" + 
		"    System.out.println();\n" + 
		"    System.out.println();\n" + 
		"    if (true)\n" + 
		"        {\n" + 
		"          System.out.println();\n" + 
		"        }\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0010() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    System.out.println();					\n"
			+ "    class Z {								\n"
			+ "      void foo() {}							\n"
			+ "    }										\n"
			+ "    System.out.println();					\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"    class Z {\n" + 
		"      Z() {\n" + 
		"        super();\n" + 
		"      }\n" + 
		"      void foo() {\n" + 
		"      }\n" + 
		"    }\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"    class Z {\n" + 
		"      Z() {\n" + 
		"        super();\n" + 
		"      }\n" + 
		"      void foo() {\n" + 
		"      }\n" + 
		"    }\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietPlusBodyUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietPlusBodyUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0011() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    System.out.println();					\n"
			+ "    class Z {								\n"
			+ "      void foo() {}							\n"
			+ "    }										\n"
			+ "    System.out.println();					\n"
			+ "    #										\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"    class Z {\n" + 
		"      Z() {\n" + 
		"        super();\n" + 
		"      }\n" + 
		"      void foo() {\n" + 
		"      }\n" + 
		"    }\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0012() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    #										\n"
			+ "    System.out.println();					\n"
			+ "    class Z {								\n"
			+ "      void foo() {}							\n"
			+ "    }										\n"
			+ "    System.out.println();					\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"    class Z {\n" + 
		"      Z() {\n" + 
		"        super();\n" + 
		"      }\n" + 
		"      void foo() {\n" + 
		"      }\n" + 
		"    }\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0013() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    System.out.println();					\n"
			+ "    class Z {								\n"
			+ "      void foo() {}							\n"
			+ "    }										\n"
			+ "    System.out.println();					\n"
			+ "    #										\n"
			+ "    System.out.println();					\n"
			+ "    class Y {								\n"
			+ "      void foo() {}							\n"
			+ "    }										\n"
			+ "    System.out.println();					\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"    class Z {\n" + 
		"      Z() {\n" + 
		"        super();\n" + 
		"      }\n" + 
		"      void foo() {\n" + 
		"      }\n" + 
		"    }\n" + 
		"    System.out.println();\n" + 
		"    System.out.println();\n" + 
		"    class Y {\n" + 
		"      Y() {\n" + 
		"        super();\n" + 
		"      }\n" + 
		"      void foo() {\n" + 
		"      }\n" + 
		"    }\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0014() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    System.out.println();					\n"
			+ "    class Z {								\n"
			+ "      void foo() {							\n"
			+ "        System.out.println();				\n"
			+ "      }										\n"
			+ "    }										\n"
			+ "    System.out.println();					\n"
			+ "    #										\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"    class Z {\n" + 
		"      Z() {\n" + 
		"        super();\n" + 
		"      }\n" + 
		"      void foo() {\n" + 
		"        System.out.println();\n" + 
		"      }\n" + 
		"    }\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0015() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    #										\n"
			+ "    System.out.println();					\n"
			+ "    class Z {								\n"
			+ "      void foo() {							\n"
			+ "        System.out.println();				\n"
			+ "      }										\n"
			+ "    }										\n"
			+ "    System.out.println();					\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"    class Z {\n" + 
		"      Z() {\n" + 
		"        super();\n" + 
		"      }\n" + 
		"      void foo() {\n" + 
		"        System.out.println();\n" + 
		"      }\n" + 
		"    }\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0016() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    System.out.println();					\n"
			+ "    class Z {								\n"
			+ "      void foo() {							\n"
			+ "        System.out.println();				\n"
			+ "      }										\n"
			+ "    }										\n"
			+ "    System.out.println();					\n"
			+ "    #										\n"
			+ "    System.out.println();					\n"
			+ "    class Z {								\n"
			+ "      void foo() {							\n"
			+ "        System.out.println();				\n"
			+ "      }										\n"
			+ "    }										\n"
			+ "    System.out.println();					\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"    class Z {\n" + 
		"      Z() {\n" + 
		"        super();\n" + 
		"      }\n" + 
		"      void foo() {\n" + 
		"        System.out.println();\n" + 
		"      }\n" + 
		"    }\n" + 
		"    System.out.println();\n" + 
		"    System.out.println();\n" + 
		"    class Z {\n" + 
		"      Z() {\n" + 
		"        super();\n" + 
		"      }\n" + 
		"      void foo() {\n" + 
		"        System.out.println();\n" + 
		"      }\n" + 
		"    }\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0017() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    System.out.println();					\n"
			+ "    class Z {								\n"
			+ "      void foo() {							\n"
			+ "        System.out.println();				\n"
			+ "        if(true) {							\n"
			+ "          System.out.println();				\n"
			+ "        }									\n"
			+ "        System.out.println();				\n"
			+ "        #									\n"
			+ "      }										\n"
			+ "    }										\n"
			+ "    System.out.println();					\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"    class Z {\n" + 
		"      Z() {\n" + 
		"        super();\n" + 
		"      }\n" + 
		"      void foo() {\n" + 
		"        System.out.println();\n" + 
		"        if (true)\n" + 
		"            {\n" + 
		"              System.out.println();\n" + 
		"            }\n" + 
		"        System.out.println();\n" + 
		"      }\n" + 
		"    }\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0018() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    System.out.println();					\n"
			+ "    class Z {								\n"
			+ "      void foo() {							\n"
			+ "        #									\n"
			+ "        System.out.println();				\n"
			+ "        if(true) {							\n"
			+ "          System.out.println();				\n"
			+ "        }									\n"
			+ "        System.out.println();				\n"
			+ "      }										\n"
			+ "    }										\n"
			+ "    System.out.println();					\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"    class Z {\n" + 
		"      Z() {\n" + 
		"        super();\n" + 
		"      }\n" + 
		"      void foo() {\n" + 
		"        System.out.println();\n" + 
		"        if (true)\n" + 
		"            {\n" + 
		"              System.out.println();\n" + 
		"            }\n" + 
		"        System.out.println();\n" + 
		"      }\n" + 
		"    }\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0019() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    System.out.println();					\n"
			+ "    class Z {								\n"
			+ "      void foo() {							\n"
			+ "        System.out.println();				\n"
			+ "        if(true) {							\n"
			+ "          System.out.println();				\n"
			+ "        }									\n"
			+ "        System.out.println();				\n"
			+ "        #									\n"
			+ "        System.out.println();				\n"
			+ "        if(true) {							\n"
			+ "          System.out.println();				\n"
			+ "        }									\n"
			+ "        System.out.println();				\n"
			+ "      }										\n"
			+ "    }										\n"
			+ "    System.out.println();					\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"    class Z {\n" + 
		"      Z() {\n" + 
		"        super();\n" + 
		"      }\n" + 
		"      void foo() {\n" + 
		"        System.out.println();\n" + 
		"        if (true)\n" + 
		"            {\n" + 
		"              System.out.println();\n" + 
		"            }\n" + 
		"        System.out.println();\n" + 
		"        System.out.println();\n" + 
		"        if (true)\n" + 
		"            {\n" + 
		"              System.out.println();\n" + 
		"            }\n" + 
		"        System.out.println();\n" + 
		"      }\n" + 
		"    }\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0020() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    #										\n"
			+ "    System.out.println();					\n"
			+ "    class Z {								\n"
			+ "      void foo() {							\n"
			+ "        System.out.println();				\n"
			+ "        if(true) {							\n"
			+ "          System.out.println();				\n"
			+ "        }									\n"
			+ "        System.out.println();				\n"
			+ "        #									\n"
			+ "        System.out.println();				\n"
			+ "        if(true) {							\n"
			+ "          System.out.println();				\n"
			+ "        }									\n"
			+ "        System.out.println();				\n"
			+ "      }										\n"
			+ "    }										\n"
			+ "    System.out.println();					\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"    class Z {\n" + 
		"      Z() {\n" + 
		"        super();\n" + 
		"      }\n" + 
		"      void foo() {\n" + 
		"        System.out.println();\n" + 
		"        if (true)\n" + 
		"            {\n" + 
		"              System.out.println();\n" + 
		"            }\n" + 
		"        System.out.println();\n" + 
		"        System.out.println();\n" + 
		"        if (true)\n" + 
		"            {\n" + 
		"              System.out.println();\n" + 
		"            }\n" + 
		"        System.out.println();\n" + 
		"      }\n" + 
		"    }\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0021() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    System.out.println();					\n"
			+ "    new Object() {							\n"
			+ "      void foo() {}							\n"
			+ "    };										\n"
			+ "    System.out.println();					\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"    new Object() {\n" + 
		"      void foo() {\n" + 
		"      }\n" + 
		"    };\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"    new Object() {\n" + 
		"      void foo() {\n" + 
		"      }\n" + 
		"    };\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietPlusBodyUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietPlusBodyUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0022() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    System.out.println();					\n"
			+ "    new Object() {							\n"
			+ "      void foo() {}							\n"
			+ "    };										\n"
			+ "    System.out.println();					\n"
			+ "    #										\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"    new Object() {\n" + 
		"      () {\n" + 
		"        super();\n" + 
		"      }\n" + 
		"      void foo() {\n" + 
		"      }\n" + 
		"    };\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0023() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    #										\n"
			+ "    System.out.println();					\n"
			+ "    new Object() {							\n"
			+ "      void bar() {}							\n"
			+ "    };										\n"
			+ "    System.out.println();					\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"    new Object() {\n" + 
		"      () {\n" + 
		"        super();\n" + 
		"      }\n" + 
		"      void bar() {\n" + 
		"      }\n" + 
		"    };\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0024() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    System.out.println();					\n"
			+ "    new Object() {							\n"
			+ "      void bar() {}							\n"
			+ "    };										\n"
			+ "    System.out.println();					\n"
			+ "    #										\n"
			+ "    System.out.println();					\n"
			+ "    new Object() {							\n"
			+ "      void bar() {}							\n"
			+ "    };										\n"
			+ "    System.out.println();					\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"    new Object() {\n" + 
		"      () {\n" + 
		"        super();\n" + 
		"      }\n" + 
		"      void bar() {\n" + 
		"      }\n" + 
		"    };\n" + 
		"    System.out.println();\n" + 
		"    System.out.println();\n" + 
		"    new Object() {\n" + 
		"      () {\n" + 
		"        super();\n" + 
		"      }\n" + 
		"      void bar() {\n" + 
		"      }\n" + 
		"    };\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0025() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    System.out.println();					\n"
			+ "    new Object() {							\n"
			+ "      void foo() {							\n"
			+ "        System.out.println();				\n"
			+ "      }										\n"
			+ "    };										\n"
			+ "    System.out.println();					\n"
			+ "    #										\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"    new Object() {\n" + 
		"      () {\n" + 
		"        super();\n" + 
		"      }\n" + 
		"      void foo() {\n" + 
		"        System.out.println();\n" + 
		"      }\n" + 
		"    };\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0026() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    #										\n"
			+ "    System.out.println();					\n"
			+ "    new Object() {							\n"
			+ "      void foo() {							\n"
			+ "        System.out.println();				\n"
			+ "      }										\n"
			+ "    };										\n"
			+ "    System.out.println();					\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"    new Object() {\n" + 
		"      () {\n" + 
		"        super();\n" + 
		"      }\n" + 
		"      void foo() {\n" + 
		"        System.out.println();\n" + 
		"      }\n" + 
		"    };\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0027() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    System.out.println();					\n"
			+ "    new Object() {							\n"
			+ "      void foo() {							\n"
			+ "        System.out.println();				\n"
			+ "      }										\n"
			+ "    };										\n"
			+ "    System.out.println();					\n"
			+ "    #										\n"
			+ "    System.out.println();					\n"
			+ "    new Object() {							\n"
			+ "      void foo() {							\n"
			+ "        System.out.println();				\n"
			+ "      }										\n"
			+ "    };										\n"
			+ "    System.out.println();					\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"    new Object() {\n" + 
		"      () {\n" + 
		"        super();\n" + 
		"      }\n" + 
		"      void foo() {\n" + 
		"        System.out.println();\n" + 
		"      }\n" + 
		"    };\n" + 
		"    System.out.println();\n" + 
		"    System.out.println();\n" + 
		"    new Object() {\n" + 
		"      () {\n" + 
		"        super();\n" + 
		"      }\n" + 
		"      void foo() {\n" + 
		"        System.out.println();\n" + 
		"      }\n" + 
		"    };\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0028() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    System.out.println();					\n"
			+ "    new Object() {							\n"
			+ "      void foo() {							\n"
			+ "        System.out.println();				\n"
			+ "        if(true) {							\n"
			+ "          System.out.println();				\n"
			+ "        }									\n"
			+ "        System.out.println();				\n"
			+ "        #									\n"
			+ "      }										\n"
			+ "    };										\n"
			+ "    System.out.println();					\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"    new Object() {\n" + 
		"      () {\n" + 
		"        super();\n" + 
		"      }\n" + 
		"      void foo() {\n" + 
		"        System.out.println();\n" + 
		"        if (true)\n" + 
		"            {\n" + 
		"              System.out.println();\n" + 
		"            }\n" + 
		"        System.out.println();\n" + 
		"      }\n" + 
		"    };\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0029() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    System.out.println();					\n"
			+ "    new Object() {							\n"
			+ "      void foo() {							\n"
			+ "        #									\n"
			+ "        System.out.println();				\n"
			+ "        if(true) {							\n"
			+ "          System.out.println();				\n"
			+ "        }									\n"
			+ "        System.out.println();				\n"
			+ "      }										\n"
			+ "    };										\n"
			+ "    System.out.println();					\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"    new Object() {\n" + 
		"      () {\n" + 
		"        super();\n" + 
		"      }\n" + 
		"      void foo() {\n" + 
		"        System.out.println();\n" + 
		"        if (true)\n" + 
		"            {\n" + 
		"              System.out.println();\n" + 
		"            }\n" + 
		"        System.out.println();\n" + 
		"      }\n" + 
		"    };\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0030() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    System.out.println();					\n"
			+ "    new Object() {							\n"
			+ "      void foo() {							\n"
			+ "        System.out.println();				\n"
			+ "        if(true) {							\n"
			+ "          System.out.println();				\n"
			+ "        }									\n"
			+ "        System.out.println();				\n"
			+ "        #									\n"
			+ "        System.out.println();				\n"
			+ "        if(true) {							\n"
			+ "          System.out.println();				\n"
			+ "        }									\n"
			+ "        System.out.println();				\n"
			+ "      }										\n"
			+ "    };										\n"
			+ "    System.out.println();					\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"    new Object() {\n" + 
		"      () {\n" + 
		"        super();\n" + 
		"      }\n" + 
		"      void foo() {\n" + 
		"        System.out.println();\n" + 
		"        if (true)\n" + 
		"            {\n" + 
		"              System.out.println();\n" + 
		"            }\n" + 
		"        System.out.println();\n" + 
		"        System.out.println();\n" + 
		"        if (true)\n" + 
		"            {\n" + 
		"              System.out.println();\n" + 
		"            }\n" + 
		"        System.out.println();\n" + 
		"      }\n" + 
		"    };\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0031() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    #										\n"
			+ "    System.out.println();					\n"
			+ "    new Object() {							\n"
			+ "      void foo() {							\n"
			+ "        System.out.println();				\n"
			+ "        if(true) {							\n"
			+ "          System.out.println();				\n"
			+ "        }									\n"
			+ "        System.out.println();				\n"
			+ "        #									\n"
			+ "        System.out.println();				\n"
			+ "        if(true) {							\n"
			+ "          System.out.println();				\n"
			+ "        }									\n"
			+ "        System.out.println();				\n"
			+ "      }										\n"
			+ "    };										\n"
			+ "    System.out.println();					\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"    new Object() {\n" + 
		"      () {\n" + 
		"        super();\n" + 
		"      }\n" + 
		"      void foo() {\n" + 
		"        System.out.println();\n" + 
		"        if (true)\n" + 
		"            {\n" + 
		"              System.out.println();\n" + 
		"            }\n" + 
		"        System.out.println();\n" + 
		"        System.out.println();\n" + 
		"        if (true)\n" + 
		"            {\n" + 
		"              System.out.println();\n" + 
		"            }\n" + 
		"        System.out.println();\n" + 
		"      }\n" + 
		"    };\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0032() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    #										\n"
			+ "    System.out.println();					\n"
			+ "    bar(new Object() {						\n"
			+ "      void foo() {							\n"
			+ "        System.out.println();				\n"
			+ "        if(true) {							\n"
			+ "          System.out.println();				\n"
			+ "        }									\n"
			+ "        System.out.println();				\n"
			+ "        #									\n"
			+ "        System.out.println();				\n"
			+ "        if(true) {							\n"
			+ "          System.out.println();				\n"
			+ "        }									\n"
			+ "        System.out.println();				\n"
			+ "      }										\n"
			+ "    });										\n"
			+ "    System.out.println();					\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"    bar(new Object() {\n" + 
		"  () {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    System.out.println();\n" + 
		"    if (true)\n" + 
		"        {\n" + 
		"          System.out.println();\n" + 
		"        }\n" + 
		"    System.out.println();\n" + 
		"    System.out.println();\n" + 
		"    if (true)\n" + 
		"        {\n" + 
		"          System.out.println();\n" + 
		"        }\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"});\n" + 
		"    System.out.println();\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0033() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    #										\n"
			+ "    class Z {								\n"
			+ "      void foo() {							\n"
			+ "        System.out.println();				\n"
			+ "      }										\n"
			+ "    }										\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    class Z {\n" + 
		"      Z() {\n" + 
		"        super();\n" + 
		"      }\n" + 
		"      void foo() {\n" + 
		"        System.out.println();\n" + 
		"      }\n" + 
		"    }\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0034() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    #										\n"
			+ "    new Object() {							\n"
			+ "      void foo() {							\n"
			+ "        System.out.println();				\n"
			+ "      }										\n"
			+ "    };										\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    new Object() {\n" + 
		"      () {\n" + 
		"        super();\n" + 
		"      }\n" + 
		"      void foo() {\n" + 
		"        System.out.println();\n" + 
		"      }\n" + 
		"    };\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0035() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    bar(\\u0029								\n"
			+ "  }											\n"
			+ "}											\n"; 	

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    bar();\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0036() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    if(true) {								\n"
			+ "      foo();									\n"
			+ "    }										\n"
			+ "    for(;									\n"
			+ "    if(true) {								\n"
			+ "      foo();									\n"
			+ "    }										\n"
			+ "  }											\n"
			+ "}											\n";

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    if (true)\n" + 
		"        {\n" + 
		"          foo();\n" + 
		"        }\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0037() {

	String s = 
		"package a;											\n"
			+ "public class X {								\n"
			+ "  void foo() {								\n"
			+ "    if() {									\n"
			+ "      foo();									\n"
			+ "    }										\n"
			+ "  }											\n"
			+ "}											\n";

	String expectedDietUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"    if ()\n" + 
		"        {\n" + 
		"          foo();\n" + 
		"        }\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
public void test0038() {
	String s = 
		"package p1;										\n"+
			"public class A {									\n"+
			"	public interface B {							\n"+
			"		public abstract void aMethod (int A);		\n"+
			"		public interface C {						\n"+
			"			public abstract void anotherMethod(int A);\n"+
			"		}											\n"+
			"	}												\n"+
			"	public class aClass implements B, B.C {			\n"+
			"		public void aMethod (int A) {				\n"+
			"			public void anotherMethod(int A) {};	\n"+
			"		}											\n"+
			"	}												\n"+
			"   	public static void main (String argv[]) {	\n"+
			"		System.out.println(\"SUCCESS\");			\n"+
			"	}												\n"+
			"}";

	String expectedDietUnitToString = 
		"package p1;\n" + 
		"public class A {\n" + 
		"  public interface B {\n" + 
		"    public interface C {\n" + 
		"      public abstract void anotherMethod(int A);\n" + 
		"    }\n" + 
		"    public abstract void aMethod(int A);\n" + 
		"  }\n" + 
		"  public class aClass implements B, B.C {\n" + 
		"    public aClass() {\n" + 
		"    }\n" + 
		"    public void aMethod(int A) {\n" + 
		"    }\n" + 
		"  }\n" + 
		"  public A() {\n" + 
		"  }\n" + 
		"  public static void main(String[] argv) {\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedDietWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String expectedDietPlusBodyUnitToString = 
		"package a;\n" + 
		"public class X {\n" + 
		"  public X() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  void foo() {\n" + 
		"  }\n" + 
		"}\n";

	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
		"package p1;\n" + 
		"public class A {\n" + 
		"  public interface B {\n" + 
		"    public interface C {\n" + 
		"      public abstract void anotherMethod(int A);\n" + 
		"    }\n" + 
		"    public abstract void aMethod(int A);\n" + 
		"  }\n" + 
		"  public class aClass implements B, B.C {\n" + 
		"    public aClass() {\n" + 
		"      super();\n" + 
		"    }\n" + 
		"    public void aMethod(int A) {\n" + 
		"      public void anotherMethod;\n" + 
		"      int A;\n" + 
		"      ;\n" + 
		"    }\n" + 
		"  }\n" + 
		"  public A() {\n" + 
		"    super();\n" + 
		"  }\n" + 
		"  public static void main(String[] argv) {\n" + 
		"    System.out.println(\"SUCCESS\");\n" + 
		"  }\n" + 
		"}\n";
	
	String expectedFullUnitToString =
		expectedDietUnitToString;
	
	String expectedFullWithStatementRecoveryUnitToString =
		expectedDietUnitToString;
	
	String testName = "<test>";
	checkParse(
		s.toCharArray(),
		expectedDietUnitToString,
		expectedDietWithStatementRecoveryUnitToString,
		expectedDietPlusBodyUnitToString,
		expectedDietPlusBodyWithStatementRecoveryUnitToString,
		expectedFullUnitToString,
		expectedFullWithStatementRecoveryUnitToString,
		testName);
}
//// incorrect statement
//public void test0002() {
//
//	String s = 
//		"package a;											\n"
//			+ "public class X {								\n"
//			+ "  void foo() {								\n"
//			+ "    System.out.println();					\n"
//			+ "    foo(										\n"
//			+ "    System.out.println();					\n"
//			+ "  }											\n"
//			+ "}											\n"; 	
//
//	String expectedDietUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedDietWithStatementRecoveryUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedDietPlusBodyUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"    System.out.println();\n" + 
//		"    System.out.println();\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedFullUnitToString = expectedDietUnitToString;
//	
//	String expectedFullWithStatementRecoveryUnitToString =
//		expectedFullUnitToString;
//	
//	String testName = "<test>";
//	checkParse(
//		s.toCharArray(),
//		expectedDietUnitToString,
//		expectedDietWithStatementRecoveryUnitToString,
//		expectedDietPlusBodyUnitToString,
//		expectedDietPlusBodyWithStatementRecoveryUnitToString,
//		expectedFullUnitToString,
//		expectedFullWithStatementRecoveryUnitToString,
//		testName);
//}
//// try statement with incorrect statements
//public void test0003() {
//
//	String s = 
//		"package a;											\n"
//			+ "public class X {								\n"
//			+ "  void foo() {								\n"
//			+ "    System.out.println();					\n"
//			+ "    foo(										\n"
//			+ "    System.out.println();					\n"
//			+ "    try {									\n"
//			+ "      System.out.println();					\n"
//			+ "      foo(									\n"
//			+ "      System.out.println();					\n"
//			+ "    } catch(Exception e) {					\n"
//			+ "      System.out.println();					\n"
//			+ "      foo(									\n"
//			+ "      System.out.println();					\n"
//			+ "    }										\n"
//			+ "  }											\n"
//			+ "}											\n"; 	
//
//	String expectedDietUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedDietWithStatementRecoveryUnitToString =
//		expectedDietUnitToString;
//	
//	
//	String expectedDietPlusBodyUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//
//	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"    System.out.println();\n" + 
//		"    System.out.println();\n" + 
//		"    try \n" + 
//		"      {\n" + 
//		"        System.out.println();\n" + 
//		"        System.out.println();\n" + 
//		"      }\n" + 
//		"    catch (Exception e)\n" + 
//		"      {\n" + 
//		"        System.out.println();\n" + 
//		"        System.out.println();\n" + 
//		"      }\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedFullUnitToString = expectedDietUnitToString;
//	
//	String expectedFullWithStatementRecoveryUnitToString =
//		expectedFullUnitToString;
//	
//	String testName = "<test>";
//	checkParse(
//		s.toCharArray(),
//		expectedDietUnitToString,
//		expectedDietWithStatementRecoveryUnitToString,
//		expectedDietPlusBodyUnitToString,
//		expectedDietPlusBodyWithStatementRecoveryUnitToString,
//		expectedFullUnitToString,
//		expectedFullWithStatementRecoveryUnitToString,
//		testName);
//}
//// try statement with incorrect statements
//public void test0004() {
//
//	String s = 
//		"package a;											\n"
//			+ "public class X {								\n"
//			+ "  void foo() {								\n"
//			+ "    System.out.println();					\n"
//			+ "    foo(										\n"
//			+ "    System.out.println();					\n"
//			+ "    try {									\n"
//			+ "      System.out.println();					\n"
//			+ "      foo(									\n"
//			+ "      System.out.println();					\n"
//			+ "    } finally {								\n"
//			+ "      System.out.println();					\n"
//			+ "      foo(									\n"
//			+ "      System.out.println();					\n"
//			+ "    }										\n"
//			+ "  }											\n"
//			+ "}											\n"; 	
//
//	String expectedDietUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedDietWithStatementRecoveryUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedDietPlusBodyUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//
//	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"    System.out.println();\n" + 
//		"    System.out.println();\n" + 
//		"    try \n" + 
//		"      {\n" + 
//		"        System.out.println();\n" + 
//		"        System.out.println();\n" + 
//		"      }\n" + 
//		"    finally\n" + 
//		"      {\n" + 
//		"        System.out.println();\n" + 
//		"        System.out.println();\n" + 
//		"      }\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedFullUnitToString = expectedDietUnitToString;
//	
//	String expectedFullWithStatementRecoveryUnitToString =
//		expectedFullUnitToString;
//	
//	String testName = "<test>";
//	checkParse(
//		s.toCharArray(),
//		expectedDietUnitToString,
//		expectedDietWithStatementRecoveryUnitToString,
//		expectedDietPlusBodyUnitToString,
//		expectedDietPlusBodyWithStatementRecoveryUnitToString,
//		expectedFullUnitToString,
//		expectedFullWithStatementRecoveryUnitToString,
//		testName);
//}
//// incorrect try statement with incorrect statements
//public void test0005() {
//
//	String s = 
//		"package a;											\n"
//			+ "public class X {								\n"
//			+ "  void foo() {								\n"
//			+ "    System.out.println();					\n"
//			+ "    foo(										\n"
//			+ "    System.out.println();					\n"
//			+ "    try {									\n"
//			+ "      System.out.println();					\n"
//			+ "      foo(									\n"
//			+ "      System.out.println();					\n"
//			+ "    } finally								\n"
//			+ "  }											\n"
//			+ "}											\n"; 	
//
//	String expectedDietUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedDietWithStatementRecoveryUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedDietPlusBodyUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//
//	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"    System.out.println();\n" + 
//		"    System.out.println();\n" + 
//		"    try \n" + 
//		"      {\n" + 
//		"        System.out.println();\n" + 
//		"        System.out.println();\n" + 
//		"      }\n" + 
//		"    finally\n" + 
//		"      {\n" + 
//		"      }\n" + 
//		"  }\n" + 
//		"}\n";;
//	
//	String expectedFullUnitToString = expectedDietUnitToString;
//	
//	String expectedFullWithStatementRecoveryUnitToString =
//		expectedFullUnitToString;
//	
//	String testName = "<test>";
//	checkParse(
//		s.toCharArray(),
//		expectedDietUnitToString,
//		expectedDietWithStatementRecoveryUnitToString,
//		expectedDietPlusBodyUnitToString,
//		expectedDietPlusBodyWithStatementRecoveryUnitToString,
//		expectedFullUnitToString,
//		expectedFullWithStatementRecoveryUnitToString,
//		testName);
//}
//// incorrect try statement with incorrect statements
//public void test0006() {
//
//	String s = 
//		"package a;											\n"
//			+ "public class X {								\n"
//			+ "  void foo() {								\n"
//			+ "    System.out.println();					\n"
//			+ "    foo(										\n"
//			+ "    System.out.println();					\n"
//			+ "    try {									\n"
//			+ "      System.out.println();					\n"
//			+ "      foo(									\n"
//			+ "      System.out.println();					\n"
//			+ "    } catch (Exception e)					\n"
//			+ "  }											\n"
//			+ "}											\n"; 	
//
//	String expectedDietUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedDietWithStatementRecoveryUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedDietPlusBodyUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//
//	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"    System.out.println();\n" + 
//		"    System.out.println();\n" + 
//		"    try \n" + 
//		"      {\n" + 
//		"        System.out.println();\n" + 
//		"        System.out.println();\n" + 
//		"      }\n" + 
//		"    finally\n" + 
//		"      {\n" + 
//		"      }\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedFullUnitToString = expectedDietUnitToString;
//	
//	String expectedFullWithStatementRecoveryUnitToString =
//		expectedFullUnitToString;
//	
//	String testName = "<test>";
//	checkParse(
//		s.toCharArray(),
//		expectedDietUnitToString,
//		expectedDietWithStatementRecoveryUnitToString,
//		expectedDietPlusBodyUnitToString,
//		expectedDietPlusBodyWithStatementRecoveryUnitToString,
//		expectedFullUnitToString,
//		expectedFullWithStatementRecoveryUnitToString,
//		testName);
//}
//// incorrect try statement with incorrect statements
//public void test0007() {
//
//	String s = 
//		"package a;											\n"
//			+ "public class X {								\n"
//			+ "  void foo() {								\n"
//			+ "    System.out.println();					\n"
//			+ "    foo(										\n"
//			+ "    System.out.println();					\n"
//			+ "    try {									\n"
//			+ "      System.out.println();					\n"
//			+ "      foo(									\n"
//			+ "      System.out.println();					\n"
//			+ "    }										\n"
//			+ "    #										\n"
//			+ "    catch (Exception e) {					\n"
//			+ "      System.out.println();					\n"
//			+ "      foo(									\n"
//			+ "      System.out.println();					\n"
//			+ "    }										\n"
//			+ "  }											\n"
//			+ "}											\n"; 	
//
//	String expectedDietUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedDietWithStatementRecoveryUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedDietPlusBodyUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//
//	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"    System.out.println();\n" + 
//		"    System.out.println();\n" + 
//		"    try \n" + 
//		"      {\n" + 
//		"        System.out.println();\n" + 
//		"        System.out.println();\n" + 
//		"      }\n" + 
//		"    finally\n" + 
//		"      {\n" + 
//		"      }\n" + 
//		"    {\n" + 
//		"      System.out.println();\n" + 
//		"      System.out.println();\n" + 
//		"    }\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedFullUnitToString = expectedDietUnitToString;
//	
//	String expectedFullWithStatementRecoveryUnitToString =
//		expectedFullUnitToString;
//	
//	String testName = "<test>";
//	checkParse(
//		s.toCharArray(),
//		expectedDietUnitToString,
//		expectedDietWithStatementRecoveryUnitToString,
//		expectedDietPlusBodyUnitToString,
//		expectedDietPlusBodyWithStatementRecoveryUnitToString,
//		expectedFullUnitToString,
//		expectedFullWithStatementRecoveryUnitToString,
//		testName);
//}
//// anonymous type statement with incorrect statements
//public void test0008() {
//
//	String s = 
//		"package a;											\n"
//			+ "public class X {								\n"
//			+ "  void foo() {								\n"
//			+ "    System.out.println();					\n"
//			+ "    foo(										\n"
//			+ "    System.out.println();					\n"
//			+ "    new Object(){};							\n"
//			+ "  }											\n"
//			+ "}											\n"; 	
//
//	String expectedDietUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedDietWithStatementRecoveryUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedDietPlusBodyUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//
//	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"    System.out.println();\n" + 
//		"    System.out.println();\n" + 
//		"    new Object() {\n" + 
//		"      () {\n" + 
//		"        super();\n" + 
//		"      }\n" + 
//		"    };\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedFullUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedFullWithStatementRecoveryUnitToString =
//		expectedFullUnitToString;
//	
//	String testName = "<test>";
//	checkParse(
//		s.toCharArray(),
//		expectedDietUnitToString,
//		expectedDietWithStatementRecoveryUnitToString,
//		expectedDietPlusBodyUnitToString,
//		expectedDietPlusBodyWithStatementRecoveryUnitToString,
//		expectedFullUnitToString,
//		expectedFullWithStatementRecoveryUnitToString,
//		testName);
//}
//// anonymous type statement with incorrect statements
//public void test0009() {
//
//	String s = 
//		"package a;											\n"
//			+ "public class X {								\n"
//			+ "  void foo() {								\n"
//			+ "    System.out.println();					\n"
//			+ "    foo(										\n"
//			+ "    System.out.println();					\n"
//			+ "    new Object(){							\n"
//			+ "      void foo() {}							\n"
//			+ "    };										\n"
//			+ "  }											\n"
//			+ "}											\n"; 	
//
//	String expectedDietUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedDietWithStatementRecoveryUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedDietPlusBodyUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";;
//
//	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"    System.out.println();\n" + 
//		"    System.out.println();\n" + 
//		"    new Object() {\n" + 
//		"      () {\n" + 
//		"        super();\n" + 
//		"      }\n" + 
//		"      void foo() {\n" + 
//		"      }\n" + 
//		"    };\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedFullUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedFullWithStatementRecoveryUnitToString =
//		expectedFullUnitToString;
//	
//	String testName = "<test>";
//	checkParse(
//		s.toCharArray(),
//		expectedDietUnitToString,
//		expectedDietWithStatementRecoveryUnitToString,
//		expectedDietPlusBodyUnitToString,
//		expectedDietPlusBodyWithStatementRecoveryUnitToString,
//		expectedFullUnitToString,
//		expectedFullWithStatementRecoveryUnitToString,
//		testName);
//}
//// incorrect anonymous type statement with incorrect statements
//public void test0010() {
//
//	String s = 
//		"package a;											\n"
//			+ "public class X {								\n"
//			+ "  void foo() {								\n"
//			+ "    System.out.println();					\n"
//			+ "    foo(										\n"
//			+ "    System.out.println();					\n"
//			+ "    new Object(){							\n"
//			+ "      void foo() {}							\n"
//			+ "    }										\n"
//			+ "  }											\n"
//			+ "}											\n"; 	
//
//	String expectedDietUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedDietWithStatementRecoveryUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedDietPlusBodyUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";;
//
//	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"    System.out.println();\n" + 
//		"    System.out.println();\n" + 
//		"    new Object() {\n" + 
//		"      () {\n" + 
//		"        super();\n" + 
//		"      }\n" + 
//		"      void foo() {\n" + 
//		"      }\n" + 
//		"    };\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedFullUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedFullWithStatementRecoveryUnitToString =
//		expectedFullUnitToString;
//	
//	String testName = "<test>";
//	checkParse(
//		s.toCharArray(),
//		expectedDietUnitToString,
//		expectedDietWithStatementRecoveryUnitToString,
//		expectedDietPlusBodyUnitToString,
//		expectedDietPlusBodyWithStatementRecoveryUnitToString,
//		expectedFullUnitToString,
//		expectedFullWithStatementRecoveryUnitToString,
//		testName);
//}
//// anonymous type statement with incorrect statements
//public void test0011() {
//
//	String s = 
//		"package a;											\n"
//			+ "public class X {								\n"
//			+ "  void foo() {								\n"
//			+ "    System.out.println();					\n"
//			+ "    foo(										\n"
//			+ "    System.out.println();					\n"
//			+ "    new Object(){							\n"
//			+ "      #										\n"
//			+ "      void foo() {}							\n"
//			+ "    };										\n"
//			+ "  }											\n"
//			+ "}											\n"; 	
//
//	String expectedDietUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedDietWithStatementRecoveryUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedDietPlusBodyUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";;
//
//	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"    System.out.println();\n" + 
//		"    System.out.println();\n" + 
//		"    new Object() {\n" + 
//		"      () {\n" + 
//		"        super();\n" + 
//		"      }\n" + 
//		"      void foo() {\n" + 
//		"      }\n" + 
//		"    };\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedFullUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedFullWithStatementRecoveryUnitToString =
//		expectedFullUnitToString;
//	
//	String testName = "<test>";
//	checkParse(
//		s.toCharArray(),
//		expectedDietUnitToString,
//		expectedDietWithStatementRecoveryUnitToString,
//		expectedDietPlusBodyUnitToString,
//		expectedDietPlusBodyWithStatementRecoveryUnitToString,
//		expectedFullUnitToString,
//		expectedFullWithStatementRecoveryUnitToString,
//		testName);
//}
//// method with incorrect statements
//public void test0012() {
//
//	String s = 
//		"package a;											\n"
//			+ "public class X {								\n"
//			+ "  void foo() {								\n"
//			+ "    System.out.println();					\n"
//			+ "    foo(										\n"
//			+ "    System.out.println();					\n"
//			+ "    new Object(){							\n"
//			+ "      #										\n"
//			+ "      void foo() {							\n"
//			+ "        System.out.println();				\n"
//			+ "        foo(									\n"
//			+ "        System.out.println();				\n"
//			+ "      }										\n"
//			+ "    };										\n"
//			+ "  }											\n"
//			+ "}											\n"; 	
//
//	String expectedDietUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedDietWithStatementRecoveryUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedDietPlusBodyUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";;
//
//	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"    System.out.println();\n" + 
//		"    System.out.println();\n" + 
//		"    new Object() {\n" + 
//		"      () {\n" + 
//		"        super();\n" + 
//		"      }\n" + 
//		"      void foo() {\n" + 
//		"        System.out.println();\n" + 
//		"        System.out.println();\n" + 
//		"      }\n" + 
//		"    };\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedFullUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedFullWithStatementRecoveryUnitToString =
//		expectedFullUnitToString;
//	
//	String testName = "<test>";
//	checkParse(
//		s.toCharArray(),
//		expectedDietUnitToString,
//		expectedDietWithStatementRecoveryUnitToString,
//		expectedDietPlusBodyUnitToString,
//		expectedDietPlusBodyWithStatementRecoveryUnitToString,
//		expectedFullUnitToString,
//		expectedFullWithStatementRecoveryUnitToString,
//		testName);
//}
//// method with incorrect statements
//public void test0013() {
//
//	String s = 
//		"package a;											\n"
//			+ "public class X {								\n"
//			+ "  void foo() {								\n"
//			+ "    System.out.println();					\n"
//			+ "    foo(										\n"
//			+ "    System.out.println();					\n"
//			+ "    new Object(){							\n"
//			+ "      #										\n"
//			+ "      void foo() {							\n"
//			+ "        #									\n"
//			+ "        System.out.println();				\n"
//			+ "        foo(									\n"
//			+ "        System.out.println();				\n"
//			+ "      }										\n"
//			+ "    };										\n"
//			+ "  }											\n"
//			+ "}											\n"; 	
//
//	String expectedDietUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedDietWithStatementRecoveryUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedDietPlusBodyUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";;
//
//	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"    System.out.println();\n" + 
//		"    System.out.println();\n" + 
//		"    new Object() {\n" + 
//		"      () {\n" + 
//		"        super();\n" + 
//		"      }\n" + 
//		"      void foo() {\n" + 
//		"        System.out.println();\n" + 
//		"        System.out.println();\n" + 
//		"      }\n" + 
//		"    };\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedFullUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedFullWithStatementRecoveryUnitToString =
//		expectedFullUnitToString;
//	
//	String testName = "<test>";
//	checkParse(
//		s.toCharArray(),
//		expectedDietUnitToString,
//		expectedDietWithStatementRecoveryUnitToString,
//		expectedDietPlusBodyUnitToString,
//		expectedDietPlusBodyWithStatementRecoveryUnitToString,
//		expectedFullUnitToString,
//		expectedFullWithStatementRecoveryUnitToString,
//		testName);
//}
//// incorrect statement at first position
//public void test0014() {
//
//	String s = 
//		"package a;											\n"
//			+ "public class X {								\n"
//			+ "  void foo() {								\n"
//			+ "    foo(										\n"
//			+ "    System.out.println();					\n"
//			+ "  }											\n"
//			+ "}											\n"; 	
//
//	String expectedDietUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedDietWithStatementRecoveryUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedDietPlusBodyUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";;
//
//	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"    System.out.println();\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedFullUnitToString =
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedFullWithStatementRecoveryUnitToString =
//		expectedFullUnitToString;
//	
//	String testName = "<test>";
//	checkParse(
//		s.toCharArray(),
//		expectedDietUnitToString,
//		expectedDietWithStatementRecoveryUnitToString,
//		expectedDietPlusBodyUnitToString,
//		expectedDietPlusBodyWithStatementRecoveryUnitToString,
//		expectedFullUnitToString,
//		expectedFullWithStatementRecoveryUnitToString,
//		testName);
//}
//// incorrect method with incorrect statements
//public void test0015() {
//
//	String s = 
//		"package a;											\n"
//			+ "public class X {								\n"
//			+ "  void foo() {								\n"
//			+ "    System.out.println();					\n"
//			+ "    foo(										\n"
//			+ "    System.out.println();					\n"
//			+ "    new Object(){							\n"
//			+ "      #										\n"
//			+ "      void foo( {							\n"
//			+ "        #									\n"
//			+ "        System.out.println();				\n"
//			+ "        foo(									\n"
//			+ "        System.out.println();				\n"
//			+ "      }										\n"
//			+ "    };										\n"
//			+ "  }											\n"
//			+ "}											\n"; 	
//
//	String expectedDietUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedDietWithStatementRecoveryUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedDietPlusBodyUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";;
//
//	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"    System.out.println();\n" + 
//		"    System.out.println();\n" + 
//		"    new Object() {\n" + 
//		"      () {\n" + 
//		"        super();\n" + 
//		"      }\n" + 
//		"      void foo() {\n" + 
//		"        System.out.println();\n" + 
//		"        System.out.println();\n" + 
//		"      }\n" + 
//		"    };\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedFullUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedFullWithStatementRecoveryUnitToString =
//		expectedFullUnitToString;
//	
//	String testName = "<test>";
//	checkParse(
//		s.toCharArray(),
//		expectedDietUnitToString,
//		expectedDietWithStatementRecoveryUnitToString,
//		expectedDietPlusBodyUnitToString,
//		expectedDietPlusBodyWithStatementRecoveryUnitToString,
//		expectedFullUnitToString,
//		expectedFullWithStatementRecoveryUnitToString,
//		testName);
//}
//// incorrect method with incorrect statements
//public void test0016() {
//
//	String s = 
//		"package a;											\n"
//			+ "public class X {								\n"
//			+ "  void foo() {								\n"
//			+ "    System.out.println();					\n"
//			+ "    foo(										\n"
//			+ "    System.out.println();					\n"
//			+ "    new Object(){							\n"
//			+ "      #										\n"
//			+ "      void foo( {							\n"
//			+ "        #									\n"
//			+ "        System.out.println();				\n"
//			+ "        foo(									\n"
//			+ "        System.out.println();				\n"
//			+ "      }										\n"
//			+ "    }										\n"
//			+ "  }											\n"
//			+ "}											\n"; 	
//
//	String expectedDietUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedDietWithStatementRecoveryUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedDietPlusBodyUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//
//	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"    System.out.println();\n" + 
//		"    System.out.println();\n" + 
//		"    new Object() {\n" + 
//		"      () {\n" + 
//		"        super();\n" + 
//		"      }\n" + 
//		"      void foo() {\n" + 
//		"        System.out.println();\n" + 
//		"        System.out.println();\n" + 
//		"      }\n" + 
//		"    };\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedFullUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedFullWithStatementRecoveryUnitToString =
//		expectedFullUnitToString;
//	
//	String testName = "<test>";
//	checkParse(
//		s.toCharArray(),
//		expectedDietUnitToString,
//		expectedDietWithStatementRecoveryUnitToString,
//		expectedDietPlusBodyUnitToString,
//		expectedDietPlusBodyWithStatementRecoveryUnitToString,
//		expectedFullUnitToString,
//		expectedFullWithStatementRecoveryUnitToString,
//		testName);
//}
//// incorrect method with incorrect statements
//public void test0017() {
//
//	String s = 
//		"package a;											\n"
//			+ "public class X {								\n"
//			+ "  void foo() {								\n"
//			+ "    System.out.println();					\n"
//			+ "    foo(										\n"
//			+ "    System.out.println();					\n"
//			+ "    new Object(){							\n"
//			+ "      #										\n"
//			+ "      void foo() {							\n"
//			+ "        #									\n"
//			+ "        System.out.println();				\n"
//			+ "        foo(									\n"
//			+ "        System.out.println();				\n"
//			+ "      }										\n"
//			+ "    }										\n"
//			+ "    System.out.println();					\n"
//			+ "    foo(										\n"
//			+ "    System.out.println();					\n"
//			+ "  }											\n"
//			+ "}											\n"; 	
//
//	String expectedDietUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedDietWithStatementRecoveryUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedDietPlusBodyUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";;
//
//	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"    System.out.println();\n" + 
//		"    System.out.println();\n" + 
//		"    new Object() {\n" + 
//		"      () {\n" + 
//		"        super();\n" + 
//		"      }\n" + 
//		"      void foo() {\n" + 
//		"        System.out.println();\n" + 
//		"        System.out.println();\n" + 
//		"      }\n" + 
//		"    };\n" + 
//		"    System.out.println();\n" + 
//		"    System.out.println();\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedFullUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedFullWithStatementRecoveryUnitToString =
//		expectedFullUnitToString;
//	
//	String testName = "<test>";
//	checkParse(
//		s.toCharArray(),
//		expectedDietUnitToString,
//		expectedDietWithStatementRecoveryUnitToString,
//		expectedDietPlusBodyUnitToString,
//		expectedDietPlusBodyWithStatementRecoveryUnitToString,
//		expectedFullUnitToString,
//		expectedFullWithStatementRecoveryUnitToString,
//		testName);
//}
//// method without right brace and with incorrect statements
//public void test0018() {
//
//	String s = 
//		"package a;											\n"
//			+ "public class X {								\n"
//			+ "  void foo() {								\n"
//			+ "    System.out.println();					\n"
//			+ "    new Object(){							\n"
//			+ "      void foo() {							\n"
//			+ "        System.out.println();				\n"
//			+ "        foo(									\n"
//			+ "        System.out.println();				\n"
//			+ "      void bar() {							\n"
//			+ "        System.out.println();				\n"
//			+ "        foo(									\n"
//			+ "        System.out.println();				\n"
//			+ "      }										\n"
//			+ "    }										\n"
//			+ "    System.out.println();					\n"
//			+ "  }											\n"
//			+ "}											\n"; 	
//
//	String expectedDietUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedDietWithStatementRecoveryUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedDietPlusBodyUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//
//	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"    System.out.println();\n" + 
//		"    new Object() {\n" + 
//		"      () {\n" + 
//		"        super();\n" + 
//		"      }\n" + 
//		"      void foo() {\n" + 
//		"        System.out.println();\n" + 
//		"        System.out.println();\n" + 
//		"      }\n" + 
//		"      void bar() {\n" + 
//		"        System.out.println();\n" + 
//		"        System.out.println();\n" + 
//		"      }\n" + 
//		"    };\n" + 
//		"    System.out.println();\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedFullUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedFullWithStatementRecoveryUnitToString =
//		expectedFullUnitToString;
//	
//	String testName = "<test>";
//	checkParse(
//		s.toCharArray(),
//		expectedDietUnitToString,
//		expectedDietWithStatementRecoveryUnitToString,
//		expectedDietPlusBodyUnitToString,
//		expectedDietPlusBodyWithStatementRecoveryUnitToString,
//		expectedFullUnitToString,
//		expectedFullWithStatementRecoveryUnitToString,
//		testName);
//}
//// local type inside block statements
//public void test0019() {
//
//	String s = 
//		"package a;											\n"
//			+ "public class X {								\n"
//			+ "  void foo() {								\n"
//			+ "    System.out.println();					\n"
//			+ "    {										\n"
//			+ "      class Y {		 						\n"
//			+ "      } 										\n"
//			+ "    }	               						\n"
//			+ "    System.out.println();					\n"
//			+ "  }											\n"
//			+ "}											\n"; 	
//
//	String expectedDietUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedDietWithStatementRecoveryUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedDietPlusBodyUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"    System.out.println();\n" + 
//		"    {\n" + 
//		"      class Y {\n" + 
//		"        Y() {\n" + 
//		"          super();\n" + 
//		"        }\n" + 
//		"      }\n" + 
//		"    }\n" + 
//		"    System.out.println();\n" + 
//		"  }\n" + 
//		"}\n";
//
//	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
//		expectedDietPlusBodyUnitToString;
//	
//	String expectedFullUnitToString =
//		expectedDietPlusBodyUnitToString;
//	
//	String expectedFullWithStatementRecoveryUnitToString =
//		expectedFullUnitToString;
//	
//	String testName = "<test>";
//	checkParse(
//		s.toCharArray(),
//		expectedDietUnitToString,
//		expectedDietWithStatementRecoveryUnitToString,
//		expectedDietPlusBodyUnitToString,
//		expectedDietPlusBodyWithStatementRecoveryUnitToString,
//		expectedFullUnitToString,
//		expectedFullWithStatementRecoveryUnitToString,
//		testName);
//}
//// local type inside block statements
//public void test0020() {
//
//	String s = 
//		"package a;											\n"
//			+ "public class X {								\n"
//			+ "  void foo() {								\n"
//			+ "    #   										\n"
//			+ "    System.out.println();					\n"
//			+ "    {										\n"
//			+ "      class Y {		 						\n"
//			+ "      } 										\n"
//			+ "    }	               						\n"
//			+ "    System.out.println();					\n"
//			+ "  }											\n"
//			+ "}											\n"; 	
//
//	String expectedDietUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedDietWithStatementRecoveryUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedDietPlusBodyUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";;
//
//	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"    System.out.println();\n" + 
//		"    {\n" + 
//		"      class Y {\n" + 
//		"        Y() {\n" + 
//		"          super();\n" + 
//		"        }\n" + 
//		"      }\n" + 
//		"    }\n" + 
//		"    System.out.println();\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedFullUnitToString =
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedFullWithStatementRecoveryUnitToString =
//		expectedFullUnitToString;
//	
//	String testName = "<test>";
//	checkParse(
//		s.toCharArray(),
//		expectedDietUnitToString,
//		expectedDietWithStatementRecoveryUnitToString,
//		expectedDietPlusBodyUnitToString,
//		expectedDietPlusBodyWithStatementRecoveryUnitToString,
//		expectedFullUnitToString,
//		expectedFullWithStatementRecoveryUnitToString,
//		testName);
//}
//// local type inside block statements
//public void test0021() {
//
//	String s = 
//		"package a;											\n"
//			+ "public class X {								\n"
//			+ "  void foo() {								\n"
//			+ "    #   										\n"
//			+ "    System.out.println();					\n"
//			+ "    {										\n"
//			+ "      System.out.println();					\n"
//			+ "      class Y {		 						\n"
//			+ "      } 										\n"
//			+ "      System.out.println();					\n"
//			+ "    }	               						\n"
//			+ "    System.out.println();					\n"
//			+ "  }											\n"
//			+ "}											\n"; 	
//
//	String expectedDietUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedDietWithStatementRecoveryUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedDietPlusBodyUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";;
//
//	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"    System.out.println();\n" + 
//		"    {\n" + 
//		"      System.out.println();\n" + 
//		"      class Y {\n" + 
//		"        Y() {\n" + 
//		"          super();\n" + 
//		"        }\n" + 
//		"      }\n" + 
//		"      System.out.println();\n" + 
//		"    }\n" + 
//		"    System.out.println();\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedFullUnitToString =
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedFullWithStatementRecoveryUnitToString =
//		expectedFullUnitToString;
//	
//	String testName = "<test>";
//	checkParse(
//		s.toCharArray(),
//		expectedDietUnitToString,
//		expectedDietWithStatementRecoveryUnitToString,
//		expectedDietPlusBodyUnitToString,
//		expectedDietPlusBodyWithStatementRecoveryUnitToString,
//		expectedFullUnitToString,
//		expectedFullWithStatementRecoveryUnitToString,
//		testName);
//}
//// anonymous types inside message send
//public void test0022() {
//
//	String s = 
//		"package a;											\n"
//			+ "public class X {								\n"
//			+ "  void foo() {								\n"
//			+ "    System.out.println();					\n"
//			+ "    bar(										\n"
//			+ "      new Object(){}, 						\n"
//			+ "      var,									\n"
//			+ "      new Object(){} 						\n"
//			+ "    );                						\n"
//			+ "    System.out.println();					\n"
//			+ "  }											\n"
//			+ "}											\n"; 	
//
//	String expectedDietUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedDietWithStatementRecoveryUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedDietPlusBodyUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"    System.out.println();\n" + 
//		"    bar(new Object() {\n" + 
//		"}, var, new Object() {\n" + 
//		"});\n" + 
//		"    System.out.println();\n" + 
//		"  }\n" + 
//		"}\n";
//
//	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
//		expectedDietPlusBodyUnitToString;
//	
//	String expectedFullUnitToString =
//		expectedDietPlusBodyUnitToString;
//	
//	String expectedFullWithStatementRecoveryUnitToString =
//		expectedFullUnitToString;
//	
//	String testName = "<test>";
//	checkParse(
//		s.toCharArray(),
//		expectedDietUnitToString,
//		expectedDietWithStatementRecoveryUnitToString,
//		expectedDietPlusBodyUnitToString,
//		expectedDietPlusBodyWithStatementRecoveryUnitToString,
//		expectedFullUnitToString,
//		expectedFullWithStatementRecoveryUnitToString,
//		testName);
//}
//// anonymous types inside message send
//public void test0023() {
//
//	String s = 
//		"package a;											\n"
//			+ "public class X {								\n"
//			+ "  void foo() {								\n"
//			+ "    #										\n"
//			+ "    System.out.println();					\n"
//			+ "    bar(										\n"
//			+ "      new Object(){}, 						\n"
//			+ "      var,									\n"
//			+ "      new Object(){} 						\n"
//			+ "    );                						\n"
//			+ "    System.out.println();					\n"
//			+ "  }											\n"
//			+ "}											\n"; 	
//
//	String expectedDietUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedDietWithStatementRecoveryUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedDietPlusBodyUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";;
//
//	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"    System.out.println();\n" + 
//		"    bar(new Object() {\n" + 
//		"  () {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"}, var, new Object() {\n" + 
//		"  () {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"});\n" + 
//		"    System.out.println();\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedFullUnitToString =
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedFullWithStatementRecoveryUnitToString =
//		expectedFullUnitToString;
//	
//	String testName = "<test>";
//	checkParse(
//		s.toCharArray(),
//		expectedDietUnitToString,
//		expectedDietWithStatementRecoveryUnitToString,
//		expectedDietPlusBodyUnitToString,
//		expectedDietPlusBodyWithStatementRecoveryUnitToString,
//		expectedFullUnitToString,
//		expectedFullWithStatementRecoveryUnitToString,
//		testName);
//}
//// anonymous types inside message send
//public void test0024() {
//
//	String s = 
//		"package a;											\n"
//			+ "public class X {								\n"
//			+ "  void foo() {								\n"
//			+ "    #										\n"
//			+ "    System.out.println();					\n"
//			+ "    bar(										\n"
//			+ "      new Object(){}, 						\n"
//			+ "      var,									\n"
//			+ "      new Object(){} 						\n"
//			+ "    )                						\n"
//			+ "    System.out.println();					\n"
//			+ "  }											\n"
//			+ "}											\n"; 	
//
//	String expectedDietUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedDietWithStatementRecoveryUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedDietPlusBodyUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";;
//
//	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"    System.out.println();\n" + 
//		"    new Object() {\n" + 
//		"      () {\n" + 
//		"        super();\n" + 
//		"      }\n" + 
//		"    };\n" + 
//		"    new Object() {\n" + 
//		"      () {\n" + 
//		"        super();\n" + 
//		"      }\n" + 
//		"    };\n" + 
//		"    System.out.println();\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedFullUnitToString =
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//			
//	String expectedFullWithStatementRecoveryUnitToString =
//		expectedFullUnitToString;
//	
//	String testName = "<test>";
//	checkParse(
//		s.toCharArray(),
//		expectedDietUnitToString,
//		expectedDietWithStatementRecoveryUnitToString,
//		expectedDietPlusBodyUnitToString,
//		expectedDietPlusBodyWithStatementRecoveryUnitToString,
//		expectedFullUnitToString,
//		expectedFullWithStatementRecoveryUnitToString,
//		testName);
//}
//public void test0025() {
//
//	String s = 
//		"package a;											\n"
//			+ "public class X {								\n"
//			+ "  void foo() {								\n"
//			+ "    System.out.println();					\n"
//			+ "    bar(new Object1(){						\n"
//			+ "      new Object2(){}, 						\n"
//			+ "      var,									\n"
//			+ "      new Object3(){} 						\n"
//			+ "    );                						\n"
//			+ "    System.out.println();					\n"
//			+ "  }											\n"
//			+ "}											\n"; 	
//
//	String expectedDietUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedDietWithStatementRecoveryUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedDietPlusBodyUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//
//	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"    System.out.println();\n" + 
//		"    bar(new Object1() {\n" + 
//		"  () {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"}, var, new Object3() {\n" + 
//		"  () {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"});\n" + 
//		"    System.out.println();\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedFullUnitToString =
//		"package a;\n" + 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedFullWithStatementRecoveryUnitToString =
//		expectedFullUnitToString;
//	
//	String testName = "<test>";
//	checkParse(
//		s.toCharArray(),
//		expectedDietUnitToString,
//		expectedDietWithStatementRecoveryUnitToString,
//		expectedDietPlusBodyUnitToString,
//		expectedDietPlusBodyWithStatementRecoveryUnitToString,
//		expectedFullUnitToString,
//		expectedFullWithStatementRecoveryUnitToString,
//		testName);
//}
//public void test0026() {
//
//	String s = 
//		"package a;											\n"
//			+ "import java.lang.*;							\n"
//			+ "import java.util.*;							\n"
//			+ "												\n"
//			+ "public class X {								\n"
//			+ "	void foo() {								\n"
//			+ "		System.out.println();					\n"
//			+ "												\n"
//			+ "		class L {								\n"
//			+ "			void baz(){}						\n"
//			+ "		}										\n"
//			+ "												\n"
//			+ "	public int h;								\n"
//			+ "	public int[] i = { 0, 1 };					\n"
//			+ "												\n"
//			+ "	void bar(){									\n"
//			+ "	void truc(){								\n"
//			+ "}											\n"; 
//
//	String expectedDietUnitToString = 
//		"package a;\n" + 
//		"import java.lang.*;\n" + 
//		"import java.util.*;\n" + 
//		"public class X {\n" + 
//		"  public int h;\n" + 
//		"  public int[] i = {0, 1};\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"  void bar() {\n" + 
//		"  }\n" + 
//		"  void truc() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedDietWithStatementRecoveryUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedDietPlusBodyUnitToString = 
//		"package a;\n" + 
//		"import java.lang.*;\n" + 
//		"import java.util.*;\n" + 
//		"public class X {\n" + 
//		"  public int h;\n" + 
//		"  public int[] i = {0, 1};\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"  void bar() {\n" + 
//		"  }\n" + 
//		"  void truc() {\n" + 
//		"  }\n" + 
//		"}\n";
//
//	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
//		"package a;\n" + 
//		"import java.lang.*;\n" + 
//		"import java.util.*;\n" + 
//		"public class X {\n" + 
//		"  public int h;\n" + 
//		"  public int[] i = {0, 1};\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"    System.out.println();\n" + 
//		"    class L {\n" + 
//		"      L() {\n" + 
//		"        super();\n" + 
//		"      }\n" + 
//		"      void baz() {\n" + 
//		"      }\n" + 
//		"    }\n" + 
//		"  }\n" + 
//		"  void bar() {\n" + 
//		"  }\n" + 
//		"  void truc() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedFullUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedFullWithStatementRecoveryUnitToString =
//		expectedFullUnitToString;
//	
//	String testName = "<test>";
//	checkParse(
//		s.toCharArray(),
//		expectedDietUnitToString,
//		expectedDietWithStatementRecoveryUnitToString,
//		expectedDietPlusBodyUnitToString,
//		expectedDietPlusBodyWithStatementRecoveryUnitToString,
//		expectedFullUnitToString,
//		expectedFullWithStatementRecoveryUnitToString,
//		testName);
//}
//public void test0027() {
//
//	String s =
//		"public class X {							\n"+
//		"   int foo(){								\n"+
//		"	  if(true){								\n"+
//		"     	int x;								\n"+
//		"	 										\n";
//
//	String expectedDietUnitToString = 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  int foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedDietWithStatementRecoveryUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedDietPlusBodyUnitToString = 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  int foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//
//	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  int foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedFullUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedFullWithStatementRecoveryUnitToString =
//		expectedFullUnitToString;
//	
//	String testName = "<test>";
//	checkParse(
//		s.toCharArray(),
//		expectedDietUnitToString,
//		expectedDietWithStatementRecoveryUnitToString,
//		expectedDietPlusBodyUnitToString,
//		expectedDietPlusBodyWithStatementRecoveryUnitToString,
//		expectedFullUnitToString,
//		expectedFullWithStatementRecoveryUnitToString,
//		testName);
//}
//public void test0028() {
//
//	String s = 
//		"import ;\n"+
//		"class X {\n"+
//		"}\n"+
//		"- public void addThreadFilter(IJavaThread thread) - restricts breakpoint to \n"+
//		"given thread and any other previously specified threads\n"+
//		"- public void removeThreadFilter(IJavaThread thread)- removes the given thread \n"+
//		"restriction (will need to re-create breakpoint request as JDI does not support \n"+
//		"the removal of thread filters)\n"+
//		"- public IJavaThread[] getThreadFilters() - return the set of threads this \n"+
//		"breakpoint is currently restricted to\n";
//
//	String expectedDietUnitToString = 
//		"class X {\n" + 
//		"  {\n" + 
//		"  }\n" + 
//		"  X() {\n" + 
//		"  }\n" + 
//		"  public void addThreadFilter(IJavaThread thread) {\n" + 
//		"  }\n" + 
//		"  public void removeThreadFilter(IJavaThread thread) {\n" + 
//		"  }\n" + 
//		"  public IJavaThread[] getThreadFilters() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedDietWithStatementRecoveryUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedDietPlusBodyUnitToString = 
//		"class X {\n" + 
//		"  {\n" + 
//		"  }\n" + 
//		"  X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  public void addThreadFilter(IJavaThread thread) {\n" + 
//		"  }\n" + 
//		"  public void removeThreadFilter(IJavaThread thread) {\n" + 
//		"  }\n" + 
//		"  public IJavaThread[] getThreadFilters() {\n" + 
//		"  }\n" + 
//		"}\n";
//
//	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
//		"class X {\n" + 
//		"  {\n" + 
//		"  }\n" + 
//		"  X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  public void addThreadFilter(IJavaThread thread) {\n" + 
//		"  }\n" + 
//		"  public void removeThreadFilter(IJavaThread thread) {\n" + 
//		"  }\n" + 
//		"  public IJavaThread[] getThreadFilters() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedFullUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedFullWithStatementRecoveryUnitToString =
//		expectedFullUnitToString;
//	
//	String testName = "<test>";
//	checkParse(
//		s.toCharArray(),
//		expectedDietUnitToString,
//		expectedDietWithStatementRecoveryUnitToString,
//		expectedDietPlusBodyUnitToString,
//		expectedDietPlusBodyWithStatementRecoveryUnitToString,
//		expectedFullUnitToString,
//		expectedFullWithStatementRecoveryUnitToString,
//		testName);
//}
//public void test0029() {
//
//	String s = 
//		"public class X {\n" +
//		"	void bar(){\n" +
//		"		#\n" +
//		"		class Inner {\n" +
//		"			void foo() {\n" +
//		"				try {\n" +
//		"				} catch(Exception e) {\n" +
//		"					e.\n" +
//		"				}\n" +
//		"			}\n" +
//		"		}\n" +
//		"	}\n" +
//		"}";
//
//	String expectedDietUnitToString = 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"  }\n" + 
//		"  void bar() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedDietWithStatementRecoveryUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedDietPlusBodyUnitToString = 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void bar() {\n" + 
//		"  }\n" + 
//		"}\n";
//
//	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void bar() {\n" + 
//		"    class Inner {\n" + 
//		"      Inner() {\n" + 
//		"        super();\n" + 
//		"      }\n" + 
//		"      void foo() {\n" + 
//		"        try \n" + 
//		"          {\n" + 
//		"          }\n" + 
//		"        catch (Exception e)\n" + 
//		"          {\n" + 
//		"          }\n" + 
//		"      }\n" + 
//		"    }\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedFullUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedFullWithStatementRecoveryUnitToString =
//		expectedFullUnitToString;
//	
//	String testName = "<test>";
//	checkParse(
//		s.toCharArray(),
//		expectedDietUnitToString,
//		expectedDietWithStatementRecoveryUnitToString,
//		expectedDietPlusBodyUnitToString,
//		expectedDietPlusBodyWithStatementRecoveryUnitToString,
//		expectedFullUnitToString,
//		expectedFullWithStatementRecoveryUnitToString,
//		testName);
//}
//public void test0030() {
//
//	String s = 
//		"package p;										\n" + 
//		"/**											\n" + 
//		" * 1FLHNKX										\n" + 
//		" */											\n" + 
//		"public class ATB {								\n" + 
//		"  void foo() {									\n" + 
//		"    if(true)									\n" + 
//		"      System.out.println(\"true\");			\n" + 
//		"    else										\n" + 
//		"      (System.out.println(\"true\"));			\n" + 
//		"  }											\n" + 
//		"}												";
//
//	String expectedDietUnitToString = 
//		"package p;\n" + 
//		"public class ATB {\n" + 
//		"  public ATB() {\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedDietWithStatementRecoveryUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedDietPlusBodyUnitToString = 
//		"package p;\n" + 
//		"public class ATB {\n" + 
//		"  public ATB() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void foo() {\n" + 
//		"  }\n" + 
//		"}\n";
//
//	String expectedDietPlusBodyWithStatementRecoveryUnitToString = 
//		"public class X {\n" + 
//		"  public X() {\n" + 
//		"    super();\n" + 
//		"  }\n" + 
//		"  void bar() {\n" + 
//		"    class Inner {\n" + 
//		"      Inner() {\n" + 
//		"        super();\n" + 
//		"      }\n" + 
//		"      void foo() {\n" + 
//		"        try \n" + 
//		"          {\n" + 
//		"          }\n" + 
//		"        catch (Exception e)\n" + 
//		"          {\n" + 
//		"          }\n" + 
//		"      }\n" + 
//		"    }\n" + 
//		"  }\n" + 
//		"}\n";
//	
//	String expectedFullUnitToString =
//		expectedDietUnitToString;
//	
//	String expectedFullWithStatementRecoveryUnitToString =
//		expectedFullUnitToString;
//	
//	String testName = "<test>";
//	checkParse(
//		s.toCharArray(),
//		expectedDietUnitToString,
//		expectedDietWithStatementRecoveryUnitToString,
//		expectedDietPlusBodyUnitToString,
//		expectedDietPlusBodyWithStatementRecoveryUnitToString,
//		expectedFullUnitToString,
//		expectedFullWithStatementRecoveryUnitToString,
//		testName);
//}
}

Lines 240-245 Link Here

(-)Eclipse Java Tests Compiler/org/eclipse/jdt/tests/compiler/regression/FromJikesPRs.java (+5 lines)
240	"----------\n" +	240	"----------\n" +
241	"1. ERROR in Test.java (at line 4)\n" +	241	"1. ERROR in Test.java (at line 4)\n" +
242	" 3+4; \n" +	242	" 3+4; \n" +
		243	" ^\n" +
		244	"The left-hand side of an assignment must be a variable\n" +
		245	"----------\n" +
		246	"2. ERROR in Test.java (at line 4)\n" +
		247	" 3+4; \n" +
243	" ^\n" +	248	" ^\n" +
244	"Syntax error on token \"+\", invalid AssignmentOperator\n" +	249	"Syntax error on token \"+\", invalid AssignmentOperator\n" +
245	"----------\n");	250	"----------\n");




}
// Use this static initializer to specify subset for tests
// All specified tests which does not belong to the class are skipped...
static {
//	TESTS_NUMBERS = new int[] { 437 };
//	TESTS_NAMES = new String[]{ "test123" };
}
public static Test suite() {
	return buildTestSuite(testClass());
}

		"	--a %= 4;  \n" + 
		"	^^\n" + 
		"Syntax error on token \"--\", delete this token\n" + 
		"----------\n" + 
		"8. ERROR in p\\X.java (at line 28)\n" + 
		"	a-- %= 4;    \n" + 
		"	^^^\n" + 
		"The left-hand side of an assignment must be a variable\n" + 
		"----------\n" + 
		"9. ERROR in p\\X.java (at line 31)\n" + 
		"	return 0;\n" + 
		"	^^^^^^^^\n" + 
		"Void methods cannot return a value\n" + 
		"----------\n"
	);
}

		"----------\n" + 
		"1. ERROR in p\\X.java (at line 4)\n" + 
		"	if (args.length == 0) (System.out.println(\"if is true\"));\n" + 
		"	                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"The left-hand side of an assignment must be a variable\n" + 
		"----------\n" + 
		"2. ERROR in p\\X.java (at line 4)\n" + 
		"	if (args.length == 0) (System.out.println(\"if is true\"));\n" + 
		"	                                                       ^\n" + 
		"Syntax error, insert \"AssignmentOperator ArrayInitializer\" to complete Expression\n" + 
		"----------\n" + 
		"3. ERROR in p\\X.java (at line 5)\n" + 
		"	else (System.out.println(\"if is false\"));\n" + 
		"	     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"The left-hand side of an assignment must be a variable\n" + 
		"----------\n" + 
		"4. ERROR in p\\X.java (at line 5)\n" + 
		"	else (System.out.println(\"if is false\"));\n" + 
		"	                                       ^\n" + 
		"Syntax error, insert \"AssignmentOperator ArrayInitializer\" to complete Expression\n" + 

		"3. ERROR in p\\Test.java (at line 8)\n" + 
		"	void bar() { 1; }\n" + 
		"	             ^\n" + 
		"The left-hand side of an assignment must be a variable\n" + 
		"----------\n" + 
		"4. ERROR in p\\Test.java (at line 8)\n" + 
		"	void bar() { 1; }\n" + 
		"	             ^\n" + 
		"Syntax error, insert \"AssignmentOperator ArrayInitializer\" to complete Expression\n" + 
		"----------\n" + 
		"5. ERROR in p\\Test.java (at line 13)\n" + 
		"	int foo();\n" + 
		"	    ^^^^^\n" + 
		"This method requires a body instead of a semicolon\n" + 
		"----------\n" + 
		"6. ERROR in p\\Test.java (at line 16)\n" + 
		"	void foo();\n" + 
		"	     ^^^^^\n" + 
		"This method requires a body instead of a semicolon\n" + 
		"----------\n" + 
		"7. ERROR in p\\Test.java (at line 18)\n" + 
		"	return new Object(){ public void run() { 1; };};}\n" + 
		"	                                         ^\n" + 
		"The left-hand side of an assignment must be a variable\n" + 
		"----------\n" + 
		"8. ERROR in p\\Test.java (at line 18)\n" + 
		"	return new Object(){ public void run() { 1; };};}\n" + 
		"	                                         ^\n" + 
		"Syntax error, insert \"AssignmentOperator ArrayInitializer\" to complete Expression\n" + 

		"----------\n" + 
		"1. ERROR in p\\Example3.java (at line 10)\n" + 
		"	int myVal = condition ? x = 7 : x = 3;\n" + 
		"	            ^^^^^^^^^\n" + 
		"condition cannot be resolved\n" + 
		"----------\n" + 
		"2. ERROR in p\\Example3.java (at line 10)\n" + 
		"	int myVal = condition ? x = 7 : x = 3;\n" + 
		"	                                  ^\n" + 
		"Syntax error on token \"=\", != expected\n" + 
		"----------\n"

		"----------\n" + 
		"1. ERROR in p\\NA.java (at line 7)\n" + 
		"	(new Class1).run();\n" + 
		"	^^^^^^^^^^^^\n" + 
		"Class1 cannot be resolved\n" + 
		"----------\n" + 
		"2. ERROR in p\\NA.java (at line 7)\n" + 
		"	(new Class1).run();\n" + 
		"	 ^^^\n" + 
		"Syntax error on token \"new\", delete this token\n" + 
		"----------\n" + 
		"3. ERROR in p\\NA.java (at line 8)\n" + 
		"	(new Class2).run();\n" + 
		"	^^^^^^^^^^^^\n" + 
		"Class2 cannot be resolved\n" + 
		"----------\n" + 
		"4. ERROR in p\\NA.java (at line 8)\n" + 
		"	(new Class2).run();\n" + 
		"	 ^^^\n" + 
		"Syntax error on token \"new\", delete this token\n" + 
		"----------\n" + 
		"5. ERROR in p\\NA.java (at line 9)\n" + 
		"	(new Class3).run();\n" + 
		"	^^^^^^^^^^^^\n" + 
		"Class3 cannot be resolved\n" + 
		"----------\n" + 
		"6. ERROR in p\\NA.java (at line 9)\n" + 
		"	(new Class3).run();\n" + 
		"	 ^^^\n" + 
		"Syntax error on token \"new\", delete this token\n" + 

			"}",
		}, 
		"----------\n" + 
		"1. ERROR in p\\AJA.java (at line 7)\n" + 
		"	Object item = new String() {\n" + 
		"	                  ^^^^^^\n" + 
		"An anonymous class cannot subclass the final class String\n" + 
		"----------\n" + 
		"2. ERROR in p\\AJA.java (at line 11)\n" + 
		"	}.;\n" + 
		"	  ^\n" + 
		"Syntax error on token \";\", delete this token\n" + 
		"----------\n" + 
		"3. ERROR in p\\AJA.java (at line 12)\n" + 
		"	item.\n" + 
		"	^^^^\n" + 
		"item cannot be resolved or is not a field\n" + 
		"----------\n" + 
		"4. ERROR in p\\AJA.java (at line 12)\n" + 
		"	item.\n" + 
		"	    ^\n" + 
		"Syntax error on token \".\", ; expected\n" + 

		"----------\n" + 
		"1. ERROR in p\\AEA.java (at line 37)\n" + 
		"	a TopLevelLocal.;\n" + 
		"	^\n" + 
		"a cannot be resolved to a type\n" + 
		"----------\n" + 
		"2. ERROR in p\\AEA.java (at line 37)\n" + 
		"	a TopLevelLocal.;\n" + 
		"	               ^\n" + 
		"Syntax error on token \".\", delete this token\n" + 
		"----------\n"

		"----------\n" + 
		"1. ERROR in p\\ATB.java (at line 10)\n" + 
		"	(System.out.println(\"true\"));\n" + 
		"	^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"The left-hand side of an assignment must be a variable\n" + 
		"----------\n" + 
		"2. ERROR in p\\ATB.java (at line 10)\n" + 
		"	(System.out.println(\"true\"));\n" + 
		"	                           ^\n" + 
		"Syntax error, insert \"AssignmentOperator ArrayInitializer\" to complete Expression\n" + 
		"----------\n"

		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	Object o2 = ((Object)) new X();	\n" + 
		"	            ^^^^^^^^^^\n" + 
		"Object cannot be resolved\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 4)\n" + 
		"	Object o2 = ((Object)) new X();	\n" + 
		"	                     ^\n" + 
		"Syntax error, insert \";\" to complete LocalVariableDeclarationStatement\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 5)\n" + 
		"	Object o3 = (((Object))) new X();	\n" + 
		"	            ^^^^^^^^^^^^\n" + 
		"Object cannot be resolved\n" + 
		"----------\n" + 
		"4. ERROR in X.java (at line 5)\n" + 
		"	Object o3 = (((Object))) new X();	\n" + 
		"	                       ^\n" + 
		"Syntax error, insert \";\" to complete LocalVariableDeclarationStatement\n" + 

Return to bug 42253

Added Link Here

(-)src/org/eclipse/jdt/core/tests/dom/ASTConverterRecoveryTest.java (+251 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2005 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jdt.core.tests.dom;
12
13	import java.util.List;
14
15	import junit.framework.Test;
16
17	import org.eclipse.jdt.core.ICompilationUnit;
18	import org.eclipse.jdt.core.JavaModelException;
19	import org.eclipse.jdt.core.dom.AST;
20	import org.eclipse.jdt.core.dom.ASTNode;
21	import org.eclipse.jdt.core.dom.Block;
22	import org.eclipse.jdt.core.dom.CompilationUnit;
23	import org.eclipse.jdt.core.dom.Expression;
24	import org.eclipse.jdt.core.dom.ExpressionStatement;
25	import org.eclipse.jdt.core.dom.ITypeBinding;
26	import org.eclipse.jdt.core.dom.MethodDeclaration;
27	import org.eclipse.jdt.core.dom.MethodInvocation;
28	import org.eclipse.jdt.core.dom.NumberLiteral;
29	import org.eclipse.jdt.core.dom.Statement;
30
31	public class ASTConverterRecoveryTest extends ConverterTestSetup {
32
33	public void setUpSuite() throws Exception {
34	super.setUpSuite();
35	this.ast = AST.newAST(AST.JLS3);
36	}
37
38	public ASTConverterRecoveryTest(String name) {
39	super(name);
40	}
41
42	static {
43	TESTS_NAMES = new String[] {"test0003"};
44	// TESTS_NUMBERS = new int[] { 624 };
45	}
46	public static Test suite() {
47	return buildTestSuite(ASTConverterRecoveryTest.class);
48	}
49
50	public void test0001() throws JavaModelException {
51	this.workingCopies = new ICompilationUnit[1];
52	this.workingCopies[0] = getWorkingCopy(
53	"/Converter/src/test/X.java",
54	"package test;\n"+
55	"\n"+
56	"public class X {\n"+
57	" void foo() {\n"+
58	" bar(0)\n"+
59	" baz(1);\n"+
60	" }\n"+
61	"}\n");
62
63	char[] source = this.workingCopies[0].getSource().toCharArray();
64	ASTNode result = runConversion(AST.JLS3, this.workingCopies[0], true);
65
66	assertASTNodeEquals(
67	"package test;\n" +
68	"public class X {\n" +
69	" void foo(){\n" +
70	" bar(0);\n" +
71	" baz(1);\n" +
72	" }\n" +
73	"}\n",
74	result);
75
76	ASTNode node = getASTNode((CompilationUnit) result, 0, 0);
77	assertNotNull(node);
78	assertTrue("Not a method declaration", node.getNodeType() == ASTNode.METHOD_DECLARATION); //$NON-NLS-1$
79	MethodDeclaration methodDeclaration = (MethodDeclaration) node;
80	Block block = methodDeclaration.getBody();
81	List statements = block.statements();
82	assertEquals("wrong size", 2, statements.size()); //$NON-NLS-1$
83	Statement statement = (Statement) statements.get(0);
84	assertTrue("Not an expression statement", statement.getNodeType() == ASTNode.EXPRESSION_STATEMENT); //$NON-NLS-1$
85	ExpressionStatement expressionStatement = (ExpressionStatement) statement;
86	checkSourceRange(expressionStatement, "bar(0)", source); //$NON-NLS-1$
87	Expression expression = expressionStatement.getExpression();
88	assertTrue("Not a method invocation", expression.getNodeType() == ASTNode.METHOD_INVOCATION); //$NON-NLS-1$
89	MethodInvocation methodInvocation = (MethodInvocation) expression;
90	checkSourceRange(methodInvocation, "bar(0)", source); //$NON-NLS-1$
91	List list = methodInvocation.arguments();
92	assertTrue("Parameter list is empty", list.size() == 1); //$NON-NLS-1$
93	Expression parameter = (Expression) list.get(0);
94	assertTrue("Not a number", parameter instanceof NumberLiteral); //$NON-NLS-1$
95	ITypeBinding typeBinding = parameter.resolveTypeBinding();
96	assertNotNull("No binding", typeBinding); //$NON-NLS-1$
97	assertEquals("Not int", "int", typeBinding.getName()); //$NON-NLS-1$ //$NON-NLS-2$
98	checkSourceRange(parameter, "0", source); //$NON-NLS-1$
99	Statement statement2 = (Statement) statements.get(1);
100	assertTrue("Not an expression statement", statement2.getNodeType() == ASTNode.EXPRESSION_STATEMENT); //$NON-NLS-1$
101	ExpressionStatement expressionStatement2 = (ExpressionStatement) statement2;
102	checkSourceRange(expressionStatement2, "baz(1);", source); //$NON-NLS-1$
103	Expression expression2 = expressionStatement2.getExpression();
104	assertTrue("Not a method invocation", expression2.getNodeType() == ASTNode.METHOD_INVOCATION); //$NON-NLS-1$
105	MethodInvocation methodInvocation2 = (MethodInvocation) expression2;
106	checkSourceRange(methodInvocation2, "baz(1)", source); //$NON-NLS-1$
107	List list2 = methodInvocation2.arguments();
108	assertTrue("Parameter list is empty", list2.size() == 1); //$NON-NLS-1$
109	Expression parameter2 = (Expression) list2.get(0);
110	assertTrue("Not a number", parameter2 instanceof NumberLiteral); //$NON-NLS-1$
111	ITypeBinding typeBinding2 = parameter2.resolveTypeBinding();
112	assertNotNull("No binding", typeBinding2); //$NON-NLS-1$
113	assertEquals("Not int", "int", typeBinding2.getName()); //$NON-NLS-1$ //$NON-NLS-2$
114	checkSourceRange(parameter2, "1", source); //$NON-NLS-1$
115	}
116
117	public void test0002() throws JavaModelException {
118	this.workingCopies = new ICompilationUnit[1];
119	this.workingCopies[0] = getWorkingCopy(
120	"/Converter/src/test/X.java",
121	"package test;\n"+
122	"\n"+
123	"public class X {\n"+
124	" void foo() {\n"+
125	" baz(0);\n"+
126	" bar(1,\n"+
127	" }\n"+
128	"}\n");
129
130	char[] source = this.workingCopies[0].getSource().toCharArray();
131	ASTNode result = runConversion(AST.JLS3, this.workingCopies[0], true);
132
133	assertASTNodeEquals(
134	"package test;\n" +
135	"public class X {\n" +
136	" void foo(){\n" +
137	" baz(0);\n" +
138	" bar(1);\n" +
139	" }\n" +
140	"}\n",
141	result);
142
143	ASTNode node = getASTNode((CompilationUnit) result, 0, 0);
144	assertNotNull(node);
145	assertTrue("Not a method declaration", node.getNodeType() == ASTNode.METHOD_DECLARATION); //$NON-NLS-1$
146	MethodDeclaration methodDeclaration = (MethodDeclaration) node;
147	Block block = methodDeclaration.getBody();
148	List statements = block.statements();
149	assertEquals("wrong size", 2, statements.size()); //$NON-NLS-1$
150	Statement statement = (Statement) statements.get(0);
151	assertTrue("Not an expression statement", statement.getNodeType() == ASTNode.EXPRESSION_STATEMENT); //$NON-NLS-1$
152	ExpressionStatement expressionStatement = (ExpressionStatement) statement;
153	checkSourceRange(expressionStatement, "baz(0);", source); //$NON-NLS-1$
154	Expression expression = expressionStatement.getExpression();
155	assertTrue("Not a method invocation", expression.getNodeType() == ASTNode.METHOD_INVOCATION); //$NON-NLS-1$
156	MethodInvocation methodInvocation = (MethodInvocation) expression;
157	checkSourceRange(methodInvocation, "baz(0)", source); //$NON-NLS-1$
158	List list = methodInvocation.arguments();
159	assertTrue("Parameter list is empty", list.size() == 1); //$NON-NLS-1$
160	Expression parameter = (Expression) list.get(0);
161	assertTrue("Not a number", parameter instanceof NumberLiteral); //$NON-NLS-1$
162	ITypeBinding typeBinding = parameter.resolveTypeBinding();
163	assertNotNull("No binding", typeBinding); //$NON-NLS-1$
164	assertEquals("Not int", "int", typeBinding.getName()); //$NON-NLS-1$ //$NON-NLS-2$
165	checkSourceRange(parameter, "0", source); //$NON-NLS-1$
166	Statement statement2 = (Statement) statements.get(1);
167	assertTrue("Not an expression statement", statement2.getNodeType() == ASTNode.EXPRESSION_STATEMENT); //$NON-NLS-1$
168	ExpressionStatement expressionStatement2 = (ExpressionStatement) statement2;
169	checkSourceRange(expressionStatement2, "bar(1", source); //$NON-NLS-1$
170	Expression expression2 = expressionStatement2.getExpression();
171	assertTrue("Not a method invocation", expression2.getNodeType() == ASTNode.METHOD_INVOCATION); //$NON-NLS-1$
172	MethodInvocation methodInvocation2 = (MethodInvocation) expression2;
173	checkSourceRange(methodInvocation2, "bar(1", source); //$NON-NLS-1$
174	List list2 = methodInvocation2.arguments();
175	assertTrue("Parameter list is empty", list2.size() == 1); //$NON-NLS-1$
176	Expression parameter2 = (Expression) list2.get(0);
177	assertTrue("Not a number", parameter2 instanceof NumberLiteral); //$NON-NLS-1$
178	ITypeBinding typeBinding2 = parameter2.resolveTypeBinding();
179	assertNotNull("No binding", typeBinding2); //$NON-NLS-1$
180	assertEquals("Not int", "int", typeBinding2.getName()); //$NON-NLS-1$ //$NON-NLS-2$
181	checkSourceRange(parameter2, "1", source); //$NON-NLS-1$
182	}
183
184	public void test0003() throws JavaModelException {
185	this.workingCopies = new ICompilationUnit[1];
186	this.workingCopies[0] = getWorkingCopy(
187	"/Converter/src/test/X.java",
188	"package test;\n"+
189	"\n"+
190	"public class X {\n"+
191	" void foo() {\n"+
192	" baz(0);\n"+
193	" bar(1,\n"+
194	" foo(3);\n"+
195	" }\n"+
196	"}\n");
197
198	char[] source = this.workingCopies[0].getSource().toCharArray();
199	ASTNode result = runConversion(AST.JLS3, this.workingCopies[0], true);
200
201	assertASTNodeEquals(
202	"package test;\n" +
203	"public class X {\n" +
204	" void foo(){\n" +
205	" baz(0);\n" +
206	" bar(1,foo(3));\n" +
207	" }\n" +
208	"}\n",
209	result);
210
211	ASTNode node = getASTNode((CompilationUnit) result, 0, 0);
212	assertNotNull(node);
213	assertTrue("Not a method declaration", node.getNodeType() == ASTNode.METHOD_DECLARATION); //$NON-NLS-1$
214	MethodDeclaration methodDeclaration = (MethodDeclaration) node;
215	Block block = methodDeclaration.getBody();
216	List statements = block.statements();
217	assertEquals("wrong size", 2, statements.size()); //$NON-NLS-1$
218	Statement statement = (Statement) statements.get(0);
219	assertTrue("Not an expression statement", statement.getNodeType() == ASTNode.EXPRESSION_STATEMENT); //$NON-NLS-1$
220	ExpressionStatement expressionStatement = (ExpressionStatement) statement;
221	checkSourceRange(expressionStatement, "baz(0);", source); //$NON-NLS-1$
222	Expression expression = expressionStatement.getExpression();
223	assertTrue("Not a method invocation", expression.getNodeType() == ASTNode.METHOD_INVOCATION); //$NON-NLS-1$
224	MethodInvocation methodInvocation = (MethodInvocation) expression;
225	checkSourceRange(methodInvocation, "baz(0)", source); //$NON-NLS-1$
226	List list = methodInvocation.arguments();
227	assertTrue("Parameter list is empty", list.size() == 1); //$NON-NLS-1$
228	Expression parameter = (Expression) list.get(0);
229	assertTrue("Not a number", parameter instanceof NumberLiteral); //$NON-NLS-1$
230	ITypeBinding typeBinding = parameter.resolveTypeBinding();
231	assertNotNull("No binding", typeBinding); //$NON-NLS-1$
232	assertEquals("Not int", "int", typeBinding.getName()); //$NON-NLS-1$ //$NON-NLS-2$
233	checkSourceRange(parameter, "0", source); //$NON-NLS-1$
234	Statement statement2 = (Statement) statements.get(1);
235	assertTrue("Not an expression statement", statement2.getNodeType() == ASTNode.EXPRESSION_STATEMENT); //$NON-NLS-1$
236	ExpressionStatement expressionStatement2 = (ExpressionStatement) statement2;
237	checkSourceRange(expressionStatement2, "bar(1,\n\t foo(3);", source); //$NON-NLS-1$
238	Expression expression2 = expressionStatement2.getExpression();
239	assertTrue("Not a method invocation", expression2.getNodeType() == ASTNode.METHOD_INVOCATION); //$NON-NLS-1$
240	MethodInvocation methodInvocation2 = (MethodInvocation) expression2;
241	checkSourceRange(methodInvocation2, "bar(1,\n\t foo(3)", source); //$NON-NLS-1$
242	List list2 = methodInvocation2.arguments();
243	assertTrue("Parameter list is empty", list2.size() == 2); //$NON-NLS-1$
244	Expression parameter2 = (Expression) list2.get(0);
245	assertTrue("Not a Number", parameter2 instanceof NumberLiteral); //$NON-NLS-1$
246	parameter2 = (Expression) list2.get(1);
247	assertTrue("Not a method invocation", parameter2 instanceof MethodInvocation); //$NON-NLS-1$
248	MethodInvocation methodInvocation3 = (MethodInvocation) parameter2;
249	checkSourceRange(methodInvocation3, "foo(3)", source); //$NON-NLS-1$
250	}
251	}

Lines 1035-1043 Link Here

(-)Eclipse Java Tests Compiler/org/eclipse/jdt/tests/compiler/regression/NegativeTest.java (-10 / +96 lines)
1035	}	1035	}
1036	// Use this static initializer to specify subset for tests	1036	// Use this static initializer to specify subset for tests
1037	// All specified tests which does not belong to the class are skipped...	1037	// All specified tests which does not belong to the class are skipped...
1038	//static {	1038	static {
1039	// TESTS_NUMBERS = new int[] { 437 };	1039	// TESTS_NUMBERS = new int[] { 437 };
1040	//}	1040	// TESTS_NAMES = new String[]{ "test123" };
		1041	}
1041	public static Test suite() {	1042	public static Test suite() {
1042	return buildTestSuite(testClass());	1043	return buildTestSuite(testClass());
1043	}	1044	}
Lines 1646-1651 Link Here
1646	" --a %= 4; \n" +	1647	" --a %= 4; \n" +
1647	" ^^\n" +	1648	" ^^\n" +
1648	"Syntax error on token \"--\", delete this token\n" +	1649	"Syntax error on token \"--\", delete this token\n" +
		1650	"----------\n" +
		1651	"8. ERROR in p\\X.java (at line 28)\n" +
		1652	" a-- %= 4; \n" +
		1653	" ^^^\n" +
		1654	"The left-hand side of an assignment must be a variable\n" +
		1655	"----------\n" +
		1656	"9. ERROR in p\\X.java (at line 31)\n" +
		1657	" return 0;\n" +
		1658	" ^^^^^^^^\n" +
		1659	"Void methods cannot return a value\n" +
1649	"----------\n"	1660	"----------\n"
1650	);	1661	);
1651	}	1662	}
Lines 2576-2585 Link Here
2576	"----------\n" +	2587	"----------\n" +
2577	"1. ERROR in p\\X.java (at line 4)\n" +	2588	"1. ERROR in p\\X.java (at line 4)\n" +
2578	" if (args.length == 0) (System.out.println(\"if is true\"));\n" +	2589	" if (args.length == 0) (System.out.println(\"if is true\"));\n" +
		2590	" ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
		2591	"The left-hand side of an assignment must be a variable\n" +
		2592	"----------\n" +
		2593	"2. ERROR in p\\X.java (at line 4)\n" +
		2594	" if (args.length == 0) (System.out.println(\"if is true\"));\n" +
2579	" ^\n" +	2595	" ^\n" +
2580	"Syntax error, insert \"AssignmentOperator ArrayInitializer\" to complete Expression\n" +	2596	"Syntax error, insert \"AssignmentOperator ArrayInitializer\" to complete Expression\n" +
2581	"----------\n" +	2597	"----------\n" +
2582	"2. ERROR in p\\X.java (at line 5)\n" +	2598	"3. ERROR in p\\X.java (at line 5)\n" +
		2599	" else (System.out.println(\"if is false\"));\n" +
		2600	" ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
		2601	"The left-hand side of an assignment must be a variable\n" +
		2602	"----------\n" +
		2603	"4. ERROR in p\\X.java (at line 5)\n" +
2583	" else (System.out.println(\"if is false\"));\n" +	2604	" else (System.out.println(\"if is false\"));\n" +
2584	" ^\n" +	2605	" ^\n" +
2585	"Syntax error, insert \"AssignmentOperator ArrayInitializer\" to complete Expression\n" +	2606	"Syntax error, insert \"AssignmentOperator ArrayInitializer\" to complete Expression\n" +
Lines 3708-3721 Link Here
3708	"3. ERROR in p\\Test.java (at line 8)\n" +	3729	"3. ERROR in p\\Test.java (at line 8)\n" +
3709	" void bar() { 1; }\n" +	3730	" void bar() { 1; }\n" +
3710	" ^\n" +	3731	" ^\n" +
		3732	"The left-hand side of an assignment must be a variable\n" +
		3733	"----------\n" +
		3734	"4. ERROR in p\\Test.java (at line 8)\n" +
		3735	" void bar() { 1; }\n" +
		3736	" ^\n" +
3711	"Syntax error, insert \"AssignmentOperator ArrayInitializer\" to complete Expression\n" +	3737	"Syntax error, insert \"AssignmentOperator ArrayInitializer\" to complete Expression\n" +
3712	"----------\n" +	3738	"----------\n" +
3713	"4. ERROR in p\\Test.java (at line 13)\n" +	3739	"5. ERROR in p\\Test.java (at line 13)\n" +
3714	" int foo();\n" +	3740	" int foo();\n" +
3715	" ^^^^^\n" +	3741	" ^^^^^\n" +
3716	"This method requires a body instead of a semicolon\n" +	3742	"This method requires a body instead of a semicolon\n" +
3717	"----------\n" +	3743	"----------\n" +
3718	"5. ERROR in p\\Test.java (at line 18)\n" +	3744	"6. ERROR in p\\Test.java (at line 16)\n" +
		3745	" void foo();\n" +
		3746	" ^^^^^\n" +
		3747	"This method requires a body instead of a semicolon\n" +
		3748	"----------\n" +
		3749	"7. ERROR in p\\Test.java (at line 18)\n" +
		3750	" return new Object(){ public void run() { 1; };};}\n" +
		3751	" ^\n" +
		3752	"The left-hand side of an assignment must be a variable\n" +
		3753	"----------\n" +
		3754	"8. ERROR in p\\Test.java (at line 18)\n" +
3719	" return new Object(){ public void run() { 1; };};}\n" +	3755	" return new Object(){ public void run() { 1; };};}\n" +
3720	" ^\n" +	3756	" ^\n" +
3721	"Syntax error, insert \"AssignmentOperator ArrayInitializer\" to complete Expression\n" +	3757	"Syntax error, insert \"AssignmentOperator ArrayInitializer\" to complete Expression\n" +
Lines 4599-4604 Link Here
4599	"----------\n" +	4635	"----------\n" +
4600	"1. ERROR in p\\Example3.java (at line 10)\n" +	4636	"1. ERROR in p\\Example3.java (at line 10)\n" +
4601	" int myVal = condition ? x = 7 : x = 3;\n" +	4637	" int myVal = condition ? x = 7 : x = 3;\n" +
		4638	" ^^^^^^^^^\n" +
		4639	"condition cannot be resolved\n" +
		4640	"----------\n" +
		4641	"2. ERROR in p\\Example3.java (at line 10)\n" +
		4642	" int myVal = condition ? x = 7 : x = 3;\n" +
4602	" ^\n" +	4643	" ^\n" +
4603	"Syntax error on token \"=\", != expected\n" +	4644	"Syntax error on token \"=\", != expected\n" +
4604	"----------\n"	4645	"----------\n"
Lines 4731-4745 Link Here
4731	"----------\n" +	4772	"----------\n" +
4732	"1. ERROR in p\\NA.java (at line 7)\n" +	4773	"1. ERROR in p\\NA.java (at line 7)\n" +
4733	" (new Class1).run();\n" +	4774	" (new Class1).run();\n" +
		4775	" ^^^^^^^^^^^^\n" +
		4776	"Class1 cannot be resolved\n" +
		4777	"----------\n" +
		4778	"2. ERROR in p\\NA.java (at line 7)\n" +
		4779	" (new Class1).run();\n" +
4734	" ^^^\n" +	4780	" ^^^\n" +
4735	"Syntax error on token \"new\", delete this token\n" +	4781	"Syntax error on token \"new\", delete this token\n" +
4736	"----------\n" +	4782	"----------\n" +
4737	"2. ERROR in p\\NA.java (at line 8)\n" +	4783	"3. ERROR in p\\NA.java (at line 8)\n" +
		4784	" (new Class2).run();\n" +
		4785	" ^^^^^^^^^^^^\n" +
		4786	"Class2 cannot be resolved\n" +
		4787	"----------\n" +
		4788	"4. ERROR in p\\NA.java (at line 8)\n" +
4738	" (new Class2).run();\n" +	4789	" (new Class2).run();\n" +
4739	" ^^^\n" +	4790	" ^^^\n" +
4740	"Syntax error on token \"new\", delete this token\n" +	4791	"Syntax error on token \"new\", delete this token\n" +
4741	"----------\n" +	4792	"----------\n" +
4742	"3. ERROR in p\\NA.java (at line 9)\n" +	4793	"5. ERROR in p\\NA.java (at line 9)\n" +
		4794	" (new Class3).run();\n" +
		4795	" ^^^^^^^^^^^^\n" +
		4796	"Class3 cannot be resolved\n" +
		4797	"----------\n" +
		4798	"6. ERROR in p\\NA.java (at line 9)\n" +
4743	" (new Class3).run();\n" +	4799	" (new Class3).run();\n" +
4744	" ^^^\n" +	4800	" ^^^\n" +
4745	"Syntax error on token \"new\", delete this token\n" +	4801	"Syntax error on token \"new\", delete this token\n" +
Lines 4932-4943 Link Here
4932	"}",	4988	"}",
4933	},	4989	},
4934	"----------\n" +	4990	"----------\n" +
4935	"1. ERROR in p\\AJA.java (at line 11)\n" +	4991	"1. ERROR in p\\AJA.java (at line 7)\n" +
		4992	" Object item = new String() {\n" +
		4993	" ^^^^^^\n" +
		4994	"An anonymous class cannot subclass the final class String\n" +
		4995	"----------\n" +
		4996	"2. ERROR in p\\AJA.java (at line 11)\n" +
4936	" }.;\n" +	4997	" }.;\n" +
4937	" ^\n" +	4998	" ^\n" +
4938	"Syntax error on token \";\", delete this token\n" +	4999	"Syntax error on token \";\", delete this token\n" +
4939	"----------\n" +	5000	"----------\n" +
4940	"2. ERROR in p\\AJA.java (at line 12)\n" +	5001	"3. ERROR in p\\AJA.java (at line 12)\n" +
		5002	" item.\n" +
		5003	" ^^^^\n" +
		5004	"item cannot be resolved or is not a field\n" +
		5005	"----------\n" +
		5006	"4. ERROR in p\\AJA.java (at line 12)\n" +
4941	" item.\n" +	5007	" item.\n" +
4942	" ^\n" +	5008	" ^\n" +
4943	"Syntax error on token \".\", ; expected\n" +	5009	"Syntax error on token \".\", ; expected\n" +
Lines 5114-5119 Link Here
5114	"----------\n" +	5180	"----------\n" +
5115	"1. ERROR in p\\AEA.java (at line 37)\n" +	5181	"1. ERROR in p\\AEA.java (at line 37)\n" +
5116	" a TopLevelLocal.;\n" +	5182	" a TopLevelLocal.;\n" +
		5183	" ^\n" +
		5184	"a cannot be resolved to a type\n" +
		5185	"----------\n" +
		5186	"2. ERROR in p\\AEA.java (at line 37)\n" +
		5187	" a TopLevelLocal.;\n" +
5117	" ^\n" +	5188	" ^\n" +
5118	"Syntax error on token \".\", delete this token\n" +	5189	"Syntax error on token \".\", delete this token\n" +
5119	"----------\n"	5190	"----------\n"
Lines 6514-6519 Link Here
6514	"----------\n" +	6585	"----------\n" +
6515	"1. ERROR in p\\ATB.java (at line 10)\n" +	6586	"1. ERROR in p\\ATB.java (at line 10)\n" +
6516	" (System.out.println(\"true\"));\n" +	6587	" (System.out.println(\"true\"));\n" +
		6588	" ^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
		6589	"The left-hand side of an assignment must be a variable\n" +
		6590	"----------\n" +
		6591	"2. ERROR in p\\ATB.java (at line 10)\n" +
		6592	" (System.out.println(\"true\"));\n" +
6517	" ^\n" +	6593	" ^\n" +
6518	"Syntax error, insert \"AssignmentOperator ArrayInitializer\" to complete Expression\n" +	6594	"Syntax error, insert \"AssignmentOperator ArrayInitializer\" to complete Expression\n" +
6519	"----------\n"	6595	"----------\n"
Lines 12937-12946 Link Here
12937	"----------\n" +	13013	"----------\n" +
12938	"1. ERROR in X.java (at line 4)\n" +	13014	"1. ERROR in X.java (at line 4)\n" +
12939	" Object o2 = ((Object)) new X(); \n" +	13015	" Object o2 = ((Object)) new X(); \n" +
		13016	" ^^^^^^^^^^\n" +
		13017	"Object cannot be resolved\n" +
		13018	"----------\n" +
		13019	"2. ERROR in X.java (at line 4)\n" +
		13020	" Object o2 = ((Object)) new X(); \n" +
12940	" ^\n" +	13021	" ^\n" +
12941	"Syntax error, insert \";\" to complete LocalVariableDeclarationStatement\n" +	13022	"Syntax error, insert \";\" to complete LocalVariableDeclarationStatement\n" +
12942	"----------\n" +	13023	"----------\n" +
12943	"2. ERROR in X.java (at line 5)\n" +	13024	"3. ERROR in X.java (at line 5)\n" +
		13025	" Object o3 = (((Object))) new X(); \n" +
		13026	" ^^^^^^^^^^^^\n" +
		13027	"Object cannot be resolved\n" +
		13028	"----------\n" +
		13029	"4. ERROR in X.java (at line 5)\n" +
12944	" Object o3 = (((Object))) new X(); \n" +	13030	" Object o3 = (((Object))) new X(); \n" +
12945	" ^\n" +	13031	" ^\n" +
12946	"Syntax error, insert \";\" to complete LocalVariableDeclarationStatement\n" +	13032	"Syntax error, insert \";\" to complete LocalVariableDeclarationStatement\n" +