/*******************************************************************************

 * Copyright (c) 2012 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

 *

 * This is an implementation of an early-draft specification developed under the Java

 * Community Process (JCP) and is made available for testing and evaluation purposes

 * only. The code is not compatible with any specification of the JCP.

 * 

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.jdt.core.tests.compiler.parser;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.util.HashMap;

import java.util.Locale;

import java.util.Map;

import org.eclipse.jdt.core.compiler.CategorizedProblem;

import org.eclipse.jdt.core.tests.util.AbstractCompilerTest;

import org.eclipse.jdt.core.tests.util.CompilerTestSetup;

import org.eclipse.jdt.core.tests.util.Util;

import org.eclipse.jdt.internal.codeassist.complete.CompletionParser;

import org.eclipse.jdt.internal.codeassist.select.SelectionParser;

import org.eclipse.jdt.internal.compiler.ASTVisitor;

import org.eclipse.jdt.internal.compiler.CompilationResult;

import org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies;

import org.eclipse.jdt.internal.compiler.DocumentElementParser;

import org.eclipse.jdt.internal.compiler.IDocumentElementRequestor;

import org.eclipse.jdt.internal.compiler.ISourceElementRequestor;

import org.eclipse.jdt.internal.compiler.SourceElementParser;

import org.eclipse.jdt.internal.compiler.ast.Annotation;

import org.eclipse.jdt.internal.compiler.ast.Argument;

import org.eclipse.jdt.internal.compiler.ast.ArrayTypeReference;

import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;

import org.eclipse.jdt.internal.compiler.ast.Expression;

import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;

import org.eclipse.jdt.internal.compiler.ast.ImportReference;

import org.eclipse.jdt.internal.compiler.ast.MarkerAnnotation;

import org.eclipse.jdt.internal.compiler.ast.MethodDeclaration;

import org.eclipse.jdt.internal.compiler.ast.NormalAnnotation;

import org.eclipse.jdt.internal.compiler.ast.ParameterizedSingleTypeReference;

import org.eclipse.jdt.internal.compiler.ast.SingleMemberAnnotation;

import org.eclipse.jdt.internal.compiler.ast.SingleTypeReference;

import org.eclipse.jdt.internal.compiler.ast.TypeReference;

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.lookup.BlockScope;

import org.eclipse.jdt.internal.compiler.lookup.ClassScope;

import org.eclipse.jdt.internal.compiler.lookup.CompilationUnitScope;

import org.eclipse.jdt.internal.compiler.lookup.MethodScope;

import org.eclipse.jdt.internal.compiler.parser.Parser;

import org.eclipse.jdt.internal.compiler.problem.DefaultProblem;

import org.eclipse.jdt.internal.compiler.problem.DefaultProblemFactory;

import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;

import org.eclipse.jdt.internal.core.search.indexing.IndexingParser;

import org.eclipse.jdt.internal.core.util.CommentRecorderParser;

public abstract class AbstractTypeAnnotationSyntaxTest extends AbstractCompilerTest implements IDocumentElementRequestor, ISourceElementRequestor {

	static final class LocationPrinterVisitor extends ASTVisitor {

		Annotation[] primaryAnnotations;

		TypeReference enclosingReference;

		Map locations;

		public LocationPrinterVisitor() {

			this.locations = new HashMap();

		}

		public Map getLocations() {

			return this.locations;

		}

		public boolean visit(FieldDeclaration fieldDeclaration, MethodScope scope) {

			Annotation[] annotations = fieldDeclaration.annotations;

			this.enclosingReference = fieldDeclaration.type;

			this.primaryAnnotations = annotations;

			return true;

		}

		public boolean visit(MethodDeclaration methodDeclaration, ClassScope scope) {

			this.primaryAnnotations = methodDeclaration.annotations;

			TypeReference returnType = methodDeclaration.returnType;

			if (returnType != null) {

				this.enclosingReference = returnType;

				returnType.traverse(this, scope);

			}

			if (methodDeclaration.thrownExceptions != null) {

				int thrownExceptionsLength = methodDeclaration.thrownExceptions.length;

				for (int i = 0; i < thrownExceptionsLength; i++) {

					TypeReference typeReference = methodDeclaration.thrownExceptions[i];

					this.enclosingReference = typeReference;

					this.primaryAnnotations = null;

					typeReference.traverse(this, scope);

				}

			}

			return false;

		}

		public boolean visit(Argument argument, ClassScope scope) {

			Annotation[] annotations = argument.annotations;

			this.enclosingReference = argument.type;

			this.primaryAnnotations = annotations;

			return true;

		}

		public boolean visit(Argument argument, BlockScope scope) {

			Annotation[] annotations = argument.annotations;

			this.enclosingReference = argument.type;

			this.primaryAnnotations = annotations;

			return true;

		}

		public boolean visit(MarkerAnnotation annotation, BlockScope scope) {

			if (this.enclosingReference != null) {

				storeLocations(annotation, Annotation.getLocations(this.enclosingReference, this.primaryAnnotations, annotation, null));

			}

			return false;

		}

		public boolean visit(SingleMemberAnnotation annotation, BlockScope scope) {

			if (this.enclosingReference != null) {

				storeLocations(annotation, Annotation.getLocations(this.enclosingReference, this.primaryAnnotations, annotation, null));

			}

			return false;

		}

		public boolean visit(NormalAnnotation annotation, BlockScope scope) {

			if (this.enclosingReference != null) {

				storeLocations(annotation, Annotation.getLocations(this.enclosingReference, this.primaryAnnotations, annotation, null));

			}

			return false;

		}

		public void storeLocations(Annotation annotation, int[] tab) {

			String key = String.valueOf(annotation);

			if (this.locations.get(key) != null) {

				return;

			}

			if (tab == null) {

				this.locations.put(key, null);

				return;

			}

			StringBuffer buffer = new StringBuffer("{");

			for (int i = 0, max = tab.length; i < max; i++) {

				if (i > 0) {

					buffer.append(',');

				}

				buffer.append(tab[i]);

			}

			buffer.append('}');

			this.locations.put(key, String.valueOf(buffer));

		}

		public boolean visit(ArrayTypeReference arrayReference, BlockScope scope) {

			if (this.enclosingReference == null) return false;

			return true;

		}

		public boolean visit(ParameterizedSingleTypeReference typeReference, BlockScope scope) {

			if (this.enclosingReference == null) return false;

			return true;

		}

		public boolean visit(SingleTypeReference typeReference, BlockScope scope) {

			if (this.enclosingReference == null) return false;

			return true;

		}

	}

	protected static String  jsr308TestScratchArea = "c:\\Jsr308TestScratchArea";

	protected static final int CHECK_PARSER = 0x1;

	protected static final int CHECK_COMPLETION_PARSER = 0x2;

	protected static final int CHECK_SELECTION_PARSER = 0x4;

	protected static final int CHECK_DOCUMENT_ELEMENT_PARSER = 0x8;

	protected static final int CHECK_COMMENT_RECORDER_PARSER = 0x10;

	protected static final int CHECK_SOURCE_ELEMENT_PARSER = 0x20;

	protected static final int CHECK_INDEXING_PARSER = 0x40;

	protected static final int CHECK_JAVAC_PARSER = 0x80;

	protected static int CHECK_ALL = (CHECK_PARSER | CHECK_COMPLETION_PARSER | CHECK_SELECTION_PARSER |

											CHECK_DOCUMENT_ELEMENT_PARSER | CHECK_COMMENT_RECORDER_PARSER |

											CHECK_SOURCE_ELEMENT_PARSER | CHECK_INDEXING_PARSER);

	public static final String compiler = "C:\\jdk-7-ea-bin-b75-windows-i586-30_oct_2009\\jdk7\\bin\\javac.exe";

	public static boolean optimizeStringLiterals = false;

public void initialize(CompilerTestSetup setUp) {

	super.initialize(setUp);

}

public AbstractTypeAnnotationSyntaxTest(String testName){

	super(testName);

	if ((new File(compiler).exists())) {

		File f = new File(jsr308TestScratchArea);

		if (!f.exists()) {

			f.mkdir();

		}

		if (f.exists()) {

			try {

				OutputStreamWriter w = new OutputStreamWriter(new FileOutputStream(new File(jsr308TestScratchArea + File.separator + "Marker.java")));

				w.write("@interface Marker {}\n".toCharArray());

				w.close();

				w = new OutputStreamWriter(new FileOutputStream(new File(jsr308TestScratchArea + File.separator + "Normal.java")));

				w.write("@interface Normal {\n\tint value() default 10;\n}\n".toCharArray());

				w.close();

				w = new OutputStreamWriter(new FileOutputStream(new File(jsr308TestScratchArea + File.separator + "SingleMember.java")));

				w.write("@interface SingleMember {\n\tint value() default 10;\n}\n".toCharArray());

				w.close();

				w = new OutputStreamWriter(new FileOutputStream(new File(jsr308TestScratchArea + File.separator + "Positive.java")));

				w.write("@interface Positive {}\n".toCharArray());

				w.close();

				w = new OutputStreamWriter(new FileOutputStream(new File(jsr308TestScratchArea + File.separator + "Negative.java")));

				w.write("@interface Negative{}\n".toCharArray());

				w.close();

				w = new OutputStreamWriter(new FileOutputStream(new File(jsr308TestScratchArea + File.separator + "Readonly.java")));

				w.write("@interface Readonly {}\n".toCharArray());

				w.close();

				w = new OutputStreamWriter(new FileOutputStream(new File(jsr308TestScratchArea + File.separator + "NonNull.java")));

				w.write("@interface NonNull {}\n".toCharArray());

				w.close();

				w = new OutputStreamWriter(new FileOutputStream(new File(jsr308TestScratchArea + File.separator + "HashMap.java")));

				w.write("class HashMap<X,Y> {\n class Iterator {}; \n}\n".toCharArray());

				w.close();

				CHECK_ALL |= CHECK_JAVAC_PARSER;

			} catch (IOException e) {

				// ignore

			}

		}

	}

}

public void checkParse(

		int parserToCheck,

		char[] source,

		String expectedSyntaxErrorDiagnosis,

		String testName, String expectedUnitToString,

		ASTVisitor visitor) throws IOException {

	CompilerOptions options = new CompilerOptions(getCompilerOptions());

	options.complianceLevel = ClassFileConstants.JDK1_7;

	options.sourceLevel = ClassFileConstants.JDK1_7;

	options.targetJDK = ClassFileConstants.JDK1_7;

	ICompilationUnit sourceUnit = null;

	CompilationResult compilationResult = null;

	CompilationUnitDeclaration unit = null;

	if ((parserToCheck & CHECK_JAVAC_PARSER) != 0) {

		String javaFilePath = jsr308TestScratchArea + "\\Xyz.java";

		File f = new File(javaFilePath);

		FileOutputStream o = new FileOutputStream(f);

		OutputStreamWriter w = new OutputStreamWriter(o);

		w.write(source);

		w.close();

		Process p = Runtime.getRuntime().exec (new String[] { compiler, "-sourcepath", jsr308TestScratchArea, javaFilePath }, null, new File(jsr308TestScratchArea));

		try {

			BufferedReader stdout  = new BufferedReader(new InputStreamReader(p.getInputStream()));

			BufferedReader stderr  = new BufferedReader(new InputStreamReader(p.getErrorStream()));

			String line;

			while ((line = stderr.readLine())!= null)

				System.out.println(line);

			while ((line = stdout.readLine())!= null)

				System.out.println(line);

			assertTrue("javac unhappy", p.waitFor() == 0);

		} catch (InterruptedException e) {

			System.err.println("Skipped javac behavior check due to interrupt...");

		}

	}

	if ((parserToCheck & CHECK_PARSER) != 0) {

		Parser parser1 =

			new Parser(

					new ProblemReporter(

							DefaultErrorHandlingPolicies.proceedWithAllProblems(),

							options,

							new DefaultProblemFactory(Locale.getDefault())),

							optimizeStringLiterals);

		sourceUnit = new CompilationUnit(source, testName, null);

		compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);

		unit = parser1.parse(sourceUnit, compilationResult);

		parser1.getMethodBodies(unit);

		assertDianosticEquals(expectedSyntaxErrorDiagnosis, testName, compilationResult);

		assertParseTreeEquals(expectedUnitToString, unit.toString());

		if (visitor != null) {

			unit.traverse(visitor, (CompilationUnitScope) null);

		}

		parser1 = null;

	}

	if ((parserToCheck & CHECK_COMPLETION_PARSER) != 0) {

		CompletionParser parser2 = new CompletionParser(

				new ProblemReporter(

						DefaultErrorHandlingPolicies.proceedWithAllProblems(),

						options,

						new DefaultProblemFactory(Locale.getDefault())),

						false);

		compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);

		unit = parser2.parse(sourceUnit, compilationResult, Integer.MAX_VALUE);

		parser2.getMethodBodies(unit);

		assertDianosticEquals(expectedSyntaxErrorDiagnosis, testName, compilationResult);

		assertParseTreeEquals(expectedUnitToString, unit.toString());

		parser2 = null;

	}

	if ((parserToCheck & CHECK_SELECTION_PARSER) != 0) {

		SelectionParser parser3 = new SelectionParser(

				new ProblemReporter(

						DefaultErrorHandlingPolicies.proceedWithAllProblems(),

						options,

						new DefaultProblemFactory(Locale.getDefault())));

		compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);

		unit = parser3.parse(sourceUnit, compilationResult, Integer.MAX_VALUE, Integer.MAX_VALUE);

		parser3.getMethodBodies(unit);

		assertDianosticEquals(expectedSyntaxErrorDiagnosis, testName, compilationResult);

		assertParseTreeEquals(expectedUnitToString, unit.toString());

		parser3 = null;

	}

	if ((parserToCheck & CHECK_DOCUMENT_ELEMENT_PARSER) != 0) {

		DocumentElementParser parser4 = new DocumentElementParser(

				this,

				new DefaultProblemFactory(Locale.getDefault()),

				options);

		compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);

		unit = parser4.parse(sourceUnit, compilationResult);

		parser4.getMethodBodies(unit);

		assertDianosticEquals(expectedSyntaxErrorDiagnosis, testName, compilationResult);

		assertParseTreeEquals(expectedUnitToString, unit.toString());

		parser4 = null;

	}

	if ((parserToCheck & CHECK_COMMENT_RECORDER_PARSER) != 0) {

		CommentRecorderParser parser5 = new CommentRecorderParser(

				new ProblemReporter(

						DefaultErrorHandlingPolicies.proceedWithAllProblems(),

						options,

						new DefaultProblemFactory(Locale.getDefault())),

						optimizeStringLiterals);

		compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);

		unit = parser5.parse(sourceUnit, compilationResult);

		parser5.getMethodBodies(unit);

		assertDianosticEquals(expectedSyntaxErrorDiagnosis, testName, compilationResult);

		assertParseTreeEquals(expectedUnitToString, unit.toString());

		parser5 = null;

	}

	if ((parserToCheck & CHECK_SOURCE_ELEMENT_PARSER) != 0) {

		SourceElementParser parser6 = new SourceElementParser(this,

				new DefaultProblemFactory(Locale.getDefault()),

				options,

				true,

				optimizeStringLiterals);

		compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);

		unit = parser6.parse(sourceUnit, compilationResult);

		parser6.getMethodBodies(unit);

		assertDianosticEquals(expectedSyntaxErrorDiagnosis, testName, compilationResult);

		assertParseTreeEquals(expectedUnitToString, unit.toString());

		parser6 = null;

	}

	if ((parserToCheck & CHECK_INDEXING_PARSER) != 0) {

		IndexingParser parser7 = new IndexingParser(this,

				new DefaultProblemFactory(Locale.getDefault()),

				options,

				true,

				optimizeStringLiterals, false);

		compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);

		unit = parser7.parse(sourceUnit, compilationResult);

		parser7.getMethodBodies(unit);

		assertDianosticEquals(expectedSyntaxErrorDiagnosis, testName, compilationResult);

		assertParseTreeEquals(expectedUnitToString, unit.toString());

		parser7 = null;

	}

}

public void checkParse(

		int parserToCheck,

		char[] source,

		String expectedSyntaxErrorDiagnosis,

		String testName,

		String expectedUnitToString) throws IOException {

	checkParse(parserToCheck, source, expectedSyntaxErrorDiagnosis, testName, expectedUnitToString, null);

}

public void checkParse(

		char[] source,

		String expectedSyntaxErrorDiagnosis,

		String testName, String expectedUnitToString) throws IOException {

	checkParse(CHECK_ALL, source, expectedSyntaxErrorDiagnosis, testName, expectedUnitToString);

}

public void checkParse(

		char[] source,

		String expectedSyntaxErrorDiagnosis,

		String testName, String expectedUnitToString,

		ASTVisitor visitor) throws IOException {

	checkParse(CHECK_ALL, source, expectedSyntaxErrorDiagnosis, testName, expectedUnitToString, visitor);

}

private void assertParseTreeEquals(String expectedUnitToString, String computedUnitToString) {

		if (expectedUnitToString == null) {  // just checking that we are able to digest.

			return;

		}

		if (!expectedUnitToString.equals(computedUnitToString)) {

			System.out.println(Util.displayString(computedUnitToString));

		}

		assertEquals("Parse Tree is wrong",

				Util.convertToIndependantLineDelimiter(expectedUnitToString),

				Util.convertToIndependantLineDelimiter(computedUnitToString));

}

private void assertDianosticEquals(String expectedSyntaxErrorDiagnosis,

		String testName, CompilationResult compilationResult) {

	String computedSyntaxErrorDiagnosis = getCompilerMessages(compilationResult);

	assertEquals(

		"Invalid syntax error diagnosis" + testName,

		Util.convertToIndependantLineDelimiter(expectedSyntaxErrorDiagnosis),

		Util.convertToIndependantLineDelimiter(computedSyntaxErrorDiagnosis));

}

private String getCompilerMessages(CompilationResult compilationResult) {

	StringBuffer buffer = new StringBuffer(100);

	if (compilationResult.hasProblems() || compilationResult.hasTasks()) {

		CategorizedProblem[] problems = compilationResult.getAllProblems();

		int count = problems.length;

		int problemCount = 0;

		char[] unitSource = compilationResult.compilationUnit.getContents();

		for (int i = 0; i < count; i++) {

			if (problems[i] != null) {

				if (problemCount == 0)

					buffer.append("----------\n");

				problemCount++;

				buffer.append(problemCount + (problems[i].isError() ? ". ERROR" : ". WARNING"));

				buffer.append(" in " + new String(problems[i].getOriginatingFileName()).replace('/', '\\'));

				try {

					buffer.append(((DefaultProblem)problems[i]).errorReportSource(unitSource));

					buffer.append("\n");

					buffer.append(problems[i].getMessage());

					buffer.append("\n");

				} catch (Exception e) {

				}

				buffer.append("----------\n");

			}

		}

	}

	String computedSyntaxErrorDiagnosis = buffer.toString();

	return computedSyntaxErrorDiagnosis;

}

void traverse (File f) throws IOException {

if (f.isDirectory()) {

	File [] files = f.listFiles();

	for (int i = 0; i < files.length; i++) {

		traverse(files[i]);

	}

} else {

	if (f.getName().endsWith(".java")) {

		System.out.println(f.getCanonicalPath());

		char [] contents = new char[(int) f.length()];

		FileInputStream fs = new FileInputStream(f);

		InputStreamReader isr = new InputStreamReader(fs);

		isr.read(contents);

		checkParse(contents, null, f.getCanonicalPath(), null);

	}

}

}

public void _test000() throws IOException {

traverse(new File("C:\\jsr308tests"));

}

public void acceptImport(int declarationStart, int declarationEnd,

		int[] javaDocPositions, char[] name, int nameStartPosition,

		boolean onDemand, int modifiers) {

}

public void acceptInitializer(int declarationStart, int declarationEnd,

		int[] javaDocPositions, int modifiers, int modifiersStart,

		int bodyStart, int bodyEnd) {

}

public void acceptLineSeparatorPositions(int[] positions) {

}

public void acceptPackage(int declarationStart, int declarationEnd,

		int[] javaDocPositions, char[] name, int nameStartPosition) {

}

public void acceptProblem(CategorizedProblem problem) {

}

public void enterClass(int declarationStart, int[] javaDocPositions,

		int modifiers, int modifiersStart, int classStart, char[] name,

		int nameStart, int nameEnd, char[] superclass, int superclassStart,

		int superclassEnd, char[][] superinterfaces,

		int[] superinterfaceStarts, int[] superinterfaceEnds, int bodyStart) {

}

public void enterCompilationUnit() {

}

public void enterConstructor(int declarationStart, int[] javaDocPositions,

		int modifiers, int modifiersStart, char[] name, int nameStart,

		int nameEnd, char[][] parameterTypes, int[] parameterTypeStarts,

		int[] parameterTypeEnds, char[][] parameterNames,

		int[] parameterNameStarts, int[] parameterNameEnds, int parametersEnd,

		char[][] exceptionTypes, int[] exceptionTypeStarts,

		int[] exceptionTypeEnds, int bodyStart) {

}

public void enterField(int declarationStart, int[] javaDocPositions,

		int modifiers, int modifiersStart, char[] type, int typeStart,

		int typeEnd, int typeDimensionCount, char[] name, int nameStart,

		int nameEnd, int extendedTypeDimensionCount,

		int extendedTypeDimensionEnd) {

}

public void enterInterface(int declarationStart, int[] javaDocPositions,

		int modifiers, int modifiersStart, int interfaceStart, char[] name,

		int nameStart, int nameEnd, char[][] superinterfaces,

		int[] superinterfaceStarts, int[] superinterfaceEnds, int bodyStart) {

}

public void enterMethod(int declarationStart, int[] javaDocPositions,

		int modifiers, int modifiersStart, char[] returnType,

		int returnTypeStart, int returnTypeEnd, int returnTypeDimensionCount,

		char[] name, int nameStart, int nameEnd, char[][] parameterTypes,

		int[] parameterTypeStarts, int[] parameterTypeEnds,

		char[][] parameterNames, int[] parameterNameStarts,

		int[] parameterNameEnds, int parametersEnd,

		int extendedReturnTypeDimensionCount,

		int extendedReturnTypeDimensionEnd, char[][] exceptionTypes,

		int[] exceptionTypeStarts, int[] exceptionTypeEnds, int bodyStart) {

}

public void exitClass(int bodyEnd, int declarationEnd) {

}

public void exitCompilationUnit(int declarationEnd) {

}

public void exitConstructor(int bodyEnd, int declarationEnd) {

}

public void exitField(int bodyEnd, int declarationEnd) {

}

public void exitInterface(int bodyEnd, int declarationEnd) {

}

public void exitMethod(int bodyEnd, int declarationEnd) {

}

public void acceptAnnotationTypeReference(char[][] annotation, int sourceStart,

		int sourceEnd) {

}

public void acceptAnnotationTypeReference(char[] annotation, int sourcePosition) {

}

public void acceptConstructorReference(char[] typeName, int argCount,

		int sourcePosition) {

}

public void acceptFieldReference(char[] fieldName, int sourcePosition) {

}

public void acceptImport(int declarationStart, int declarationEnd,

		int nameStart, int nameEnd,

		char[][] tokens, boolean onDemand, int modifiers) {

}

public void acceptMethodReference(char[] methodName, int argCount,

		int sourcePosition) {

}

public void acceptPackage(ImportReference importReference) {

}

public void acceptTypeReference(char[][] typeName, int sourceStart,

		int sourceEnd) {

}

public void acceptTypeReference(char[] typeName, int sourcePosition) {

}

public void acceptUnknownReference(char[][] name, int sourceStart, int sourceEnd) {

}

public void acceptUnknownReference(char[] name, int sourcePosition) {

}

public void enterConstructor(MethodInfo methodInfo) {

}

public void enterField(FieldInfo fieldInfo) {

}

public void enterInitializer(int declarationStart, int modifiers) {

}

public void enterMethod(MethodInfo methodInfo) {

}

public void enterType(TypeInfo typeInfo) {

}

public void exitConstructor(int declarationEnd) {

}

public void exitField(int initializationStart, int declarationEnd,

		int declarationSourceEnd) {

}

public void exitInitializer(int declarationEnd) {

}

public void exitMethod(int declarationEnd, Expression defaultValue) {

}

public void exitType(int declarationEnd) {

}

}

 * This is an implementation of an early-draft specification developed under the Java

 * Community Process (JCP) and is made available for testing and evaluation purposes

 * only. The code is not compatible with any specification of the JCP.

 * 

	String expected17ProblemLog =

		"----------\n" + 

		"1. ERROR in X.java (at line 2)\n" + 

		"	public <T1 extends String T2> int foo(){\n" + 

		"	                   ^^^^^^\n" + 

		"Syntax error on token \"String\", strictfp expected\n" + 

		"----------\n";

	String expected17ProblemLog =

		"----------\n" + 

		"1. ERROR in X.java (at line 2)\n" + 

		"	Z <Y1, for Y2> var;\n" + 

		"	       ^^^\n" + 

		"Syntax error on token \"for\", final expected\n" + 

		"----------\n";

 * 

 * This is an implementation of an early-draft specification developed under the Java

 * Community Process (JCP) and is made available for testing and evaluation purposes

 * only. The code is not compatible with any specification of the JCP.

			"    public static void $missing$;\n" + 

			"    public static void $missing$;\n" + 

 * This is an implementation of an early-draft specification developed under the Java

 * Community Process (JCP) and is made available for testing and evaluation purposes

 * only. The code is not compatible with any specification of the JCP.

 * 

 * This is an implementation of an early-draft specification developed under the Java

 * Community Process (JCP) and is made available for testing and evaluation purposes

 * only. The code is not compatible with any specification of the JCP.

 * 

/*******************************************************************************

 * Copyright (c) 2009, 2012 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

 *

 * This is an implementation of an early-draft specification developed under the Java

 * Community Process (JCP) and is made available for testing and evaluation purposes

 * only. The code is not compatible with any specification of the JCP.

 * 

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.jdt.core.tests.compiler.parser;

import java.io.IOException;

import java.util.Map;

import junit.framework.Test;

import org.eclipse.jdt.core.tests.util.CompilerTestSetup;

public class TypeAnnotationSyntaxTest extends AbstractTypeAnnotationSyntaxTest {

	public static Class testClass() {

		return TypeAnnotationSyntaxTest.class;

	}

	public void initialize(CompilerTestSetup setUp) {

		super.initialize(setUp);

	}

	public static Test suite() {

		return buildMinimalComplianceTestSuite(testClass(), F_1_7);

	}

public TypeAnnotationSyntaxTest(String testName){

	super(testName);

}

static {

//	TESTS_NAMES = new String[] { "test0038", "test0039", "test0040a" };

//	TESTS_NUMBERS = new int[] { 133, 134, 135 };

}

public void test0001() throws IOException {

	String source = "@Marker class A extends String {}\n;" +

					"@Marker class B extends @Marker String {}\n" +

					"@Marker class C extends @Marker @SingleMember(0) String {}\n" +

					"@Marker class D extends @Marker @SingleMember(0) @Normal(Value = 0) String {}\n" +

					"@Marker class E extends String {}\n;";

	String expectedUnitToString = 

		"@Marker class A extends String {\n" + 

		"  A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"}\n" + 

		"@Marker class B extends @Marker String {\n" + 

		"  B() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"}\n" + 

		"@Marker class C extends @Marker @SingleMember(0) String {\n" + 

		"  C() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"}\n" + 

		"@Marker class D extends @Marker @SingleMember(0) @Normal(Value = 0) String {\n" + 

		"  D() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"}\n" + 

		"@Marker class E extends String {\n" + 

		"  E() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER , source.toCharArray(), null, "test0001", expectedUnitToString);

}

public void test0002() throws IOException {

	String source = "class A extends String {}\n;" +

					"class B extends @Marker String {}\n" +

					"class C extends @Marker @SingleMember(0) String {}\n" +

					"class D extends @Marker @SingleMember(0) @Normal(Value = 0) String {}\n" +

					"class E extends String {}\n;";

	String expectedUnitToString = 

		"class A extends String {\n" + 

		"  A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"}\n" + 

		"class B extends @Marker String {\n" + 

		"  B() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"}\n" + 

		"class C extends @Marker @SingleMember(0) String {\n" + 

		"  C() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"}\n" + 

		"class D extends @Marker @SingleMember(0) @Normal(Value = 0) String {\n" + 

		"  D() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"}\n" + 

		"class E extends String {\n" + 

		"  E() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0002", expectedUnitToString);

}

public void test0003() throws IOException {

	String source = "@Marker class A implements Comparable, " +

					"                   @Marker Serializable," +

					"                   Cloneable {\n" +

					"}\n";

	String expectedUnitToString = 

		"@Marker class A implements Comparable, @Marker Serializable, Cloneable {\n" + 

		"  A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0003", expectedUnitToString);

}

public void test0004() throws IOException {

	String source = "@Marker class A implements Comparable, " +

					"                   @Marker @SingleMember(0) Serializable," +

					"                   Cloneable {\n" +

					"}\n";

	String expectedUnitToString = 

		"@Marker class A implements Comparable, @Marker @SingleMember(0) Serializable, Cloneable {\n" + 

		"  A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0004", expectedUnitToString);

}

public void test0005() throws IOException {

	String source = "@Marker class A implements Comparable, " +

					"                   @Marker @SingleMember(0) @Normal(Value=0) Serializable," +

					"                   Cloneable {\n" +

					"}\n";

	String expectedUnitToString = 

		"@Marker class A implements Comparable, @Marker @SingleMember(0) @Normal(Value = 0) Serializable, Cloneable {\n" +

		"  A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0005", expectedUnitToString);

}

public void test0006() throws IOException {

	String source = "@Marker class A implements @Marker Comparable, " +

					"                   @Marker @SingleMember(0) @Normal(Value=0) Serializable," +

					"                   @Marker Cloneable {\n" +

					"}\n";

	String expectedUnitToString = 

		"@Marker class A implements @Marker Comparable, @Marker @SingleMember(0) @Normal(Value = 0) Serializable, @Marker Cloneable {\n" +

		"  A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0006", expectedUnitToString);

}

public void test007() throws IOException {

	String source = "@Marker class A extends Object implements Comparable, " +

					"                   @Marker @SingleMember(10) @Normal(Value=0) Serializable," +

					"                   Cloneable {\n" +

					"}\n";

	String expectedUnitToString = 

		"@Marker class A extends Object implements Comparable, @Marker @SingleMember(10) @Normal(Value = 0) Serializable, Cloneable {\n" +

		"  A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0007", expectedUnitToString);

}

public void test0008() throws IOException {

	String source = "@Marker class A extends @Marker Object implements Comparable, " +

					"                   @Marker @SingleMember(0) @Normal(Value=0) Serializable," +

					"                   Cloneable {\n" +

					"}\n";

	String expectedUnitToString = 

		"@Marker class A extends @Marker Object implements Comparable, @Marker @SingleMember(0) @Normal(Value = 0) Serializable, Cloneable {\n" +

		"  A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0008", expectedUnitToString);

}

public void test0009() throws IOException {

	String source = "@Marker class A extends @Marker @SingleMember(0) Object implements Comparable, " +

	"                   @Marker @SingleMember(0) @Normal(Value=0) Serializable," +

	"                   Cloneable {\n" +

	"}\n";

	String expectedUnitToString = 

		"@Marker class A extends @Marker @SingleMember(0) Object implements Comparable, @Marker @SingleMember(0) @Normal(Value = 0) Serializable, Cloneable {\n" +

		"  A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0009", expectedUnitToString);

}

public void test0010() throws IOException {

	String source = "@Marker class A extends @Marker @SingleMember(0) @Normal(Value=0) Object implements Comparable, " +

	"                   @Marker @SingleMember(0) @Normal(Value=0) Serializable," +

	"                   Cloneable {\n" +

	"}\n";

	String expectedUnitToString = 

		"@Marker class A extends @Marker @SingleMember(0) @Normal(Value = 0) Object implements Comparable, @Marker @SingleMember(0) @Normal(Value = 0) Serializable, Cloneable {\n" +

		"  A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0010", expectedUnitToString);

}

public void test0011() throws IOException {

	String source = "public class A {\n" +

					"    int[] f[];\n" +

					"    @Marker String[] @Marker[][] s[] @SingleMember(0)[][] @Normal(Value = 0)[][];\n" +

					"    float[] p[];\n" +

					"}\n";

	String expectedUnitToString = 

		"public class A {\n" + 

		"  int[][] f;\n" + 

		"  @Marker String[] @Marker [][][] @SingleMember(0) [][] @Normal(Value = 0) [][] s;\n" + 

		"  float[][] p;\n" + 

		"  public A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0011", expectedUnitToString);

}

public void test0012() throws IOException {

	String source = "public class A implements @Readonly Comparable, @NonNull Serializable, Cloneable {\n" +

					"    int[] f[];\n" +

					"    @English String[] @NonNull[] s[] @Nullable[][];\n" +

					"    float[] p[];\n" +

					"public static void main(String args[]) {\n" +

					"    @Readonly String @Nullable[] @NonNull[] s;\n" +

					"    s = new @Readonly String @NonNull[5] @Nullable[];\n" +

					"}\n" +

					"}\n";

	String expectedUnitToString = 

		"public class A implements @Readonly Comparable, @NonNull Serializable, Cloneable {\n" + 

		"  int[][] f;\n" + 

		"  @English String[] @NonNull [][] @Nullable [][] s;\n" + 

		"  float[][] p;\n" + 

		"  public A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"  public static void main(String[] args) {\n" + 

		"    @Readonly String @Nullable [] @NonNull [] s;\n" + 

		"    s = new @Readonly String @NonNull [5] @Nullable [];\n" + 

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0012", expectedUnitToString);

}

public void test0013() throws IOException {

	String source = "public class A implements @Readonly Comparable, @NonNull Serializable, Cloneable {\n" +

					"    int[] f[];\n" +

					"    @English String[] @NonNull[] s[] @Nullable[][];\n" +

					"    float[] p[];\n" +

					"public static void main(String args[]) {\n" +

					"    @Readonly String s;\n" +

					"	 s = new @Readonly String @NonNull[] @Nullable[] { {\"Hello\"}, {\"World\"}} [0][0];\n" +

					"}\n" +

					"}\n";

	String expectedUnitToString = 

		"public class A implements @Readonly Comparable, @NonNull Serializable, Cloneable {\n" + 

		"  int[][] f;\n" + 

		"  @English String[] @NonNull [][] @Nullable [][] s;\n" + 

		"  float[][] p;\n" + 

		"  public A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"  public static void main(String[] args) {\n" + 

		"    @Readonly String s;\n" + 

		"    s = new @Readonly String @NonNull [] @Nullable []{{\"Hello\"}, {\"World\"}}[0][0];\n" + 

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0013", expectedUnitToString);

}

public void test0014() throws IOException {

	String source = "public class A implements @Readonly Comparable, @NonNull Serializable, Cloneable {\n" +

					"    int[] f[];\n" +

					"    @English String[] @NonNull[] s[] @Nullable[][];\n" +

					"    float[] p[];\n" +

					"public static int main(String args[])[] @Marker[][] @Marker @SingleMember(0) @Normal(Value=0)[][] @Marker {\n" +

					"    @Readonly String @Nullable[] @NonNull[] s;\n" +

					"    s = new @Readonly String @NonNull[5] @Nullable[];\n" +

					"}\n" +

					"}\n";

	String expectedUnitToString = 

		"public class A implements @Readonly Comparable, @NonNull Serializable, Cloneable {\n" + 

		"  int[][] f;\n" + 

		"  @English String[] @NonNull [][] @Nullable [][] s;\n" + 

		"  float[][] p;\n" + 

		"  public A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"  public static int[] @Marker [][] @Marker @SingleMember(0) @Normal(Value = 0) [][] main(String[] args) @Marker {\n" +

		"    @Readonly String @Nullable [] @NonNull [] s;\n" + 

		"    s = new @Readonly String @NonNull [5] @Nullable [];\n" + 

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0014", expectedUnitToString);

}

public void test0015() throws IOException {

	String source = "public class A implements @Readonly Comparable, @NonNull Serializable, Cloneable {\n" +

					"    int[] f[];\n" +

					"    @English String[] @NonNull[] s[] @Nullable[][];\n" +

					"    float[] p[];\n" +

					"public static int main(String args[])[] @Marker[][] @Marker @SingleMember(0) @Normal(Value=0)[][] @Marker {\n" +

					"    @Readonly String @Nullable[] @NonNull[] s;\n" +

					"    s = new @Readonly String @NonNull[5] @Nullable[];\n" +

					"}\n" +

					"@Marker public A () @Marker @SingleMember(0) @Normal(Value=10) {}\n" +

					"}\n";

	String expectedUnitToString = 

		"public class A implements @Readonly Comparable, @NonNull Serializable, Cloneable {\n" + 

		"  int[][] f;\n" + 

		"  @English String[] @NonNull [][] @Nullable [][] s;\n" + 

		"  float[][] p;\n" + 

		"  public static int[] @Marker [][] @Marker @SingleMember(0) @Normal(Value = 0) [][] main(String[] args) @Marker {\n" + 

		"    @Readonly String @Nullable [] @NonNull [] s;\n" + 

		"    s = new @Readonly String @NonNull [5] @Nullable [];\n" + 

		"  }\n" + 

		"  public @Marker A() @Marker @SingleMember(0) @Normal(Value = 10) {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0015", expectedUnitToString);

}

// parameters

public void test0016() throws IOException {

	String source = "public class A {\n" +

					"@Marker public int[] @Marker[][] main(int[] @SingleMember(10)[][] args[] @Normal(Value = 10)[][])[] @Marker[][] @Marker {\n" +

					"}\n" +

					"}";

	String expectedUnitToString = 

		"public class A {\n" + 

		"  public A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"  public @Marker int[] @Marker [][][] @Marker [][] main(int[] @SingleMember(10) [][][] @Normal(Value = 10) [][] args) @Marker {\n" + 

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0016", expectedUnitToString);

}

public void test0017() throws IOException  {

	String source = "public class A {\n" +

					"@Marker public int[] @Marker[][] main(String[] @SingleMember(10)[][] args[] @Normal(Value = 10)[][])[] @Marker[][] @Marker {\n" +

					"}\n" +

					"}";

	String expectedUnitToString = 

		"public class A {\n" + 

		"  public A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"  public @Marker int[] @Marker [][][] @Marker [][] main(String[] @SingleMember(10) [][][] @Normal(Value = 10) [][] args) @Marker {\n" + 

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0017", expectedUnitToString);

}

public void test0018() throws IOException {

	String source = "public class A {\n" +

					"@Marker public int[] @Marker[][] main(HashMap<String, Object>[] @SingleMember(10)[][] args[] @Normal(Value = 10)[][])[] @Marker[][] @Marker {\n" +

					"}\n" +

					"}";

	String expectedUnitToString = 

		"public class A {\n" + 

		"  public A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"  public @Marker int[] @Marker [][][] @Marker [][] main(HashMap<String, Object>[] @SingleMember(10) [][][] @Normal(Value = 10) [][] args) @Marker {\n" + 

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0018", expectedUnitToString);

}

public void test0019() throws IOException {

	String source = "public class A {\n" +

					"@Marker public int[] @Marker [][] main(HashMap<String, Object>.Iterator[] @SingleMember(10) [][] args[] @Normal(Value = 10) [][])[] @Marker [][] @Marker {\n" +

					"}\n" +

					"}";

	String expectedUnitToString = 

		"public class A {\n" + 

		"  public A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"  public @Marker int[] @Marker [][][] @Marker [][] main(HashMap<String, Object>.Iterator[] @SingleMember(10) [][][] @Normal(Value = 10) [][] args) @Marker {\n" + 

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0019", expectedUnitToString);

}

// varargs annotation

public void test0020() throws IOException {

	String source = "public class A {\n" +

					"@Marker public int[] @Marker[][] main(int[] @SingleMember(10)[][] @Marker ... args )[] @Marker[][] @Marker {\n" +

					"}\n" +

					"}";

	String expectedUnitToString = 

		"public class A {\n" + 

		"  public A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"  public @Marker int[] @Marker [][][] @Marker [][] main(int[] @SingleMember(10) [][] @Marker ... args) @Marker {\n" + 

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0020", expectedUnitToString);

}

public void test0021() throws IOException {

	String source = "public class A {\n" +

					"@Marker public int[] @Marker[][] main(String[] @SingleMember(10)[][] @Marker ... args )[] @Marker[][] @Marker {\n" +

					"}\n" +

					"}";

	String expectedUnitToString = 

		"public class A {\n" + 

		"  public A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"  public @Marker int[] @Marker [][][] @Marker [][] main(String[] @SingleMember(10) [][] @Marker ... args) @Marker {\n" + 

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0021", expectedUnitToString);

}

public void test0022() throws IOException {

	String source = "public class A {\n" +

					"@Marker public int[] @Marker[][] main(HashMap<Integer,String>[] @SingleMember(10)[][] @Marker ... args )[] @Marker[][] @Marker {\n" +

					"}\n" +

					"}";

	String expectedUnitToString = 

		"public class A {\n" + 

		"  public A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"  public @Marker int[] @Marker [][][] @Marker [][] main(HashMap<Integer, String>[] @SingleMember(10) [][] @Marker ... args) @Marker {\n" + 

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0022", expectedUnitToString);

}

public void test0023() throws IOException {

	String source = "public class A {\n" +

					"@Marker public int[] @Marker[][] main(HashMap<Integer,String>.Iterator[] @SingleMember(10)[][] @Marker ... args )[] @Marker[][] @Marker {\n" +

					"}\n" +

					"}";

	String expectedUnitToString = 

		"public class A {\n" + 

		"  public A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"  public @Marker int[] @Marker [][][] @Marker [][] main(HashMap<Integer, String>.Iterator[] @SingleMember(10) [][] @Marker ... args) @Marker {\n" + 

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0023", expectedUnitToString);

}

// local variables

public void test0024() throws IOException {

	String source = "public class A implements @Readonly Comparable, @NonNull Serializable, Cloneable {\n" +

					"public static void main(String args[]) {\n" +

					"    int[] f[];\n" +

					"    @English String[] @NonNull[] s[] @Nullable[][];\n" +

					"    float[] p[];\n" +

					"}\n" +

					"}\n";

	String expectedUnitToString = 

		"public class A implements @Readonly Comparable, @NonNull Serializable, Cloneable {\n" + 

		"  public A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"  public static void main(String[] args) {\n" + 

		"    int[][] f;\n" + 

		"    @English String[] @NonNull [][] @Nullable [][] s;\n" + 

		"    float[][] p;\n" + 

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0024", expectedUnitToString);

}

// type parameter

public void test0025() throws IOException {

	String source = "class A {\n" +

					"public <Integer, @Positive Integer, @Negative Integer, Integer> void foo() {\n" +

					"}\n" +

					"}\n";

	String expectedUnitToString = 

		"class A {\n" + 

		"  A() {\n" + 

		"    super();\n" + 

		"  }\n" +

		"  public <Integer, @Positive Integer, @Negative Integer, Integer>void foo() {\n" + 

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0025", expectedUnitToString);

}

// Type

public void test0026() throws IOException {

	String source = "class A {\n" +

					"public <Integer, @Positive Integer, @Negative Integer, Integer> @Marker int foo() @Marker {\n" +

					"    return 0;\n" +

					"}\n" +

					"public <Integer, @Positive Integer, @Negative Integer, Integer> int bar() @Marker{\n" +

					"    return 0;\n" +

					"}\n" +

					"}\n";

	String expectedUnitToString = 

		"class A {\n" + 

		"  A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"  public <Integer, @Positive Integer, @Negative Integer, Integer>@Marker int foo() @Marker {\n" + 

		"    return 0;\n" +

		"  }\n" + 

		"  public <Integer, @Positive Integer, @Negative Integer, Integer>int bar() @Marker {\n" + 

		"    return 0;\n" +

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0026", expectedUnitToString);

}

// Type

public void test0027() throws IOException {

	String source = "class A {\n" +

					"public <Integer, @Positive Integer, @Negative Integer, Integer> @Marker String foo() @Marker {\n" +

					"    return null;\n" +

					"}\n" +

					"public <Integer, @Positive Integer, @Negative Integer, Integer> String bar () @Marker {\n" +

					"    return null;\n" +

					"}\n" +

					"}\n";

	String expectedUnitToString = 

		"class A {\n" + 

		"  A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"  public <Integer, @Positive Integer, @Negative Integer, Integer>@Marker String foo() @Marker {\n" + 

		"    return null;\n" +

		"  }\n" + 

		"  public <Integer, @Positive Integer, @Negative Integer, Integer>String bar() @Marker {\n" + 

		"    return null;\n" +

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0027", expectedUnitToString);

}

//Type

public void test0028() throws IOException {

	String source = "class A {\n" +

					"public <Integer, @Positive Integer, @Negative Integer, Integer> @Marker HashMap<@Readonly String, Object> foo() @Marker {\n" +

					"    return null;\n" +

					"}\n" +

					"public <Integer, @Positive Integer, @Negative Integer, Integer> HashMap<String, @NonNull Object> bar () @Marker {\n" +

					"    return null;\n" +

					"}\n" +

					"}\n";

	String expectedUnitToString = 

		"class A {\n" + 

		"  A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"  public <Integer, @Positive Integer, @Negative Integer, Integer>@Marker HashMap<@Readonly String, Object> foo() @Marker {\n" + 

		"    return null;\n" +

		"  }\n" + 

		"  public <Integer, @Positive Integer, @Negative Integer, Integer>HashMap<String, @NonNull Object> bar() @Marker {\n" + 

		"    return null;\n" +

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0028", expectedUnitToString);

}

// Type

public void test0029() throws IOException {

	String source = "class A {\n" +

					"public <Integer, @Positive Integer, @Negative Integer, Integer> @Marker HashMap<@Readonly String, Object>.Iterator foo() @Marker {\n" +

					"    return null;\n" +

					"}\n" +

					"public <Integer, @Positive Integer, @Negative Integer, Integer> HashMap<String, @NonNull Object>.Iterator bar () @Marker {\n" +

					"    return null;\n" +

					"}\n" +

					"}\n";

	String expectedUnitToString = 

		"class A {\n" + 

		"  A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"  public <Integer, @Positive Integer, @Negative Integer, Integer> @Marker HashMap<@Readonly String, Object>.Iterator foo() @Marker {\n" + 

		"    return null;\n" +

		"  }\n" + 

		"  public <Integer, @Positive Integer, @Negative Integer, Integer>HashMap<String, @NonNull Object>.Iterator bar() @Marker {\n" + 

		"    return null;\n" +

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0029", expectedUnitToString);

}

//Type

public void test0030() throws IOException {

	String source = "class A {\n" +

					"public <Integer, @Positive Integer, @Negative Integer, Integer> @Marker HashMap<@Readonly String, Object>.Iterator[] @NonEmpty[][] foo() @Marker {\n" +

					"    return null;\n" +

					"}\n" +

					"public <Integer, @Positive Integer, @Negative Integer, Integer> HashMap<String, @NonNull Object>.Iterator[] @NonEmpty[][] bar () @Marker {\n" +

					"    return null;\n" +

					"}\n" +

					"}\n";

	String expectedUnitToString = 

		"class A {\n" + 

		"  A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"  public <Integer, @Positive Integer, @Negative Integer, Integer> @Marker HashMap<@Readonly String, Object>.Iterator[] @NonEmpty [][] foo() @Marker {\n" + 

		"    return null;\n" +

		"  }\n" + 

		"  public <Integer, @Positive Integer, @Negative Integer, Integer>HashMap<String, @NonNull Object>.Iterator[] @NonEmpty [][] bar() @Marker {\n" + 

		"    return null;\n" +

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0030", expectedUnitToString);

}

//Type

public void test0031() throws IOException {

	String source = "class A {\n" +

					"public <Integer, @Positive Integer, @Negative Integer, Integer> @Marker int[] @NonEmpty[][] foo() @Marker {\n" +

					"    return 0;\n" +

					"}\n" +

					"public <Integer, @Positive Integer, @Negative Integer, Integer> int[] @NonEmpty[][] bar() @Marker{\n" +

					"    return 0;\n" +

					"}\n" +

					"}\n";

	String expectedUnitToString = 

		"class A {\n" + 

		"  A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"  public <Integer, @Positive Integer, @Negative Integer, Integer>@Marker int[] @NonEmpty [][] foo() @Marker {\n" + 

		"    return 0;\n" +

		"  }\n" + 

		"  public <Integer, @Positive Integer, @Negative Integer, Integer>int[] @NonEmpty [][] bar() @Marker {\n" + 

		"    return 0;\n" +

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0031", expectedUnitToString);

}

// Type

public void test0032() throws IOException {

	String source = "class A {\n" +

					"public <Integer, @Positive Integer, @Negative Integer, Integer> @Marker String[]@NonEmpty[][] foo() @Marker {\n" +

					"    return null;\n" +

					"}\n" +

					"public <Integer, @Positive Integer, @Negative Integer, Integer> String[]@NonEmpty[][] bar () @Marker {\n" +

					"    return null;\n" +

					"}\n" +

					"}\n";

	String expectedUnitToString = 

		"class A {\n" + 

		"  A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"  public <Integer, @Positive Integer, @Negative Integer, Integer>@Marker String[] @NonEmpty [][] foo() @Marker {\n" + 

		"    return null;\n" +

		"  }\n" + 

		"  public <Integer, @Positive Integer, @Negative Integer, Integer>String[] @NonEmpty [][] bar() @Marker {\n" + 

		"    return null;\n" +

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0032", expectedUnitToString);

}

//Type

public void test0033() throws IOException {

	String source = "class A {\n" +

					"public <Integer, @Positive Integer, @Negative Integer, Integer> @Marker HashMap<@Readonly String, Object>[] @NonEmpty[][] foo() @Marker {\n" +

					"    return null;\n" +

					"}\n" +

					"public <Integer, @Positive Integer, @Negative Integer, Integer> HashMap<String, @NonNull Object>[]@NonEmpty[][] bar () @Marker {\n" +

					"    return null;\n" +

					"}\n" +

					"}\n";

	String expectedUnitToString = 

		"class A {\n" + 

		"  A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"  public <Integer, @Positive Integer, @Negative Integer, Integer>@Marker HashMap<@Readonly String, Object>[] @NonEmpty [][] foo() @Marker {\n" + 

		"    return null;\n" +

		"  }\n" + 

		"  public <Integer, @Positive Integer, @Negative Integer, Integer>HashMap<String, @NonNull Object>[] @NonEmpty [][] bar() @Marker {\n" + 

		"    return null;\n" +

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0033", expectedUnitToString);

}

// Type0 field declaration.

public void test0034() throws IOException {

	String source = "public class A {\n" +

					"    int[] f[];\n" +

					"    @Marker int k;\n" +

					"    float[] p[];\n" +

					"}\n";

	String expectedUnitToString = 

		"public class A {\n" + 

		"  int[][] f;\n" + 

		"  @Marker int k;\n" + 

		"  float[][] p;\n" + 

		"  public A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0034", expectedUnitToString);

}

//Type0 field declaration.

public void test0035() throws IOException {

	String source = "public class A {\n" +

					"    int[] f[];\n" +

					"    @Marker String k;\n" +

					"    float[] p[];\n" +

					"}\n";

	String expectedUnitToString = 

		"public class A {\n" + 

		"  int[][] f;\n" + 

		"  @Marker String k;\n" + 

		"  float[][] p;\n" + 

		"  public A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0035", expectedUnitToString);

}

//Type0 field declaration.

public void test0036() throws IOException {

	String source = "public class A {\n" +

					"    int[] f[];\n" +

					"    @Marker HashMap<@Positive Integer, @Negative Integer> k;\n" +

					"    float[] p[];\n" +

					"}\n";

	String expectedUnitToString = 

		"public class A {\n" + 

		"  int[][] f;\n" + 

		"  @Marker HashMap<@Positive Integer, @Negative Integer> k;\n" + 

		"  float[][] p;\n" + 

		"  public A() {\n" + 

		"    super();\n" + 

		"  }\n" + 

		"}\n";

	checkParse(CHECK_ALL & ~CHECK_JAVAC_PARSER, source.toCharArray(), null, "test0036", expectedUnitToString);

}