Attachment #150486 for bug #287648

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




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

import java.io.IOException;

public class TypeAnnotationSyntaxTest extends AbstractTypeAnnotationSyntaxTest {

	public TypeAnnotationSyntaxTest(String testName) {
		super(testName);
	}

// wild card bounds 
public void test0021() throws IOException  {
		String source = 
			"public class X {\n" +
			"	void foo(Map<? super @Typesafe Object, ? extends @NonNull String> m){\n" +
			"	}\n" +
			"}\n";
		String expectedUnitToString = 
			"public class X {\n" + 
			"  public X() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"  void foo(Map<? super @Typesafe Object, ? extends @NonNull String> m) {\n" + 
			"  }\n" + 
			"}\n"; 
		checkParse(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//wild card bounds 
	public void test0021a() throws IOException  {
		String source = 
			"public class X {\n" +
			"	void foo(Map<? super @Typesafe Object[]@Marker @Normal(Value=10) @SingleMember(0)[][]," +
			"                ? extends @NonNull HashMap<@Positive Integer, @Negative Integer>> m){\n" +
			"	}\n" +
			"}\n";
		String expectedUnitToString = 
			"public class X {\n" + 
			"  public X() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"  void foo(Map<? super @Typesafe Object[] @Marker @Normal(Value = 10) @SingleMember(0) [][], ? extends @NonNull HashMap<@Positive Integer, @Negative Integer>> m) {\n" + 
			"  }\n" + 
			"}\n";
		checkParse(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//ReferenceType : ReferenceType1, ReferenceType2, ReferenceType3 ...
	public void test0020() throws IOException  {
		String source = 	"public class X<@Marker A extends @Useless X1<@Readonly X2<@Marker X3<@ReadOnly String>>>> {\n" +
							"	A a;\n" +
							"	public static void main(String[] args) {\n" +
							"		@Useless X<@Usefull X1<@Readonly X2<@Marker X3<@NonNull String>>>> x;\n" +
							"       x = new @Useless X<@Usefull X1<@Uselss X2<@Usefull X3<@NonNull String>>>>();\n" +
							"		x.a = new @NonNull X1<@NonEmpty X2<@Marker X3<@English String>>>();\n" +
							"		x.a.a1 = new @Uselss X2<@Usefull X3<@English String>>();\n" +
							"		x.a.a1.a2 = new @Useless X3<@Hindi String>();\n" +
							"		x.a.a1.a2.a3 = \"SUCCESS\";\n" +
							"		System.out.println(x.a.a1.a2.a3);\n" +
							"	}\n" +
							"}\n" +
							"@Java5 class X1<@Useless A extends @Usefull X2<@Useless X3<@English String>>> {\n" +
							"	A a1;\n" +
							"}\n" +
							"class X2<@Java7 A extends @Java7 X3<@Java7 String>> {\n" +
							"	A a2;\n" +
							"}\n" +
							"@Java5 class X3<@Java7 A> {\n" +
							"	A a3;\n" +
							"}\n";
		String expectedUnitToString = 
			"public class X<@Marker A extends @Useless X1<@Readonly X2<@Marker X3<@ReadOnly String>>>> {\n" + 
			"  A a;\n" + 
			"  public X() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"  public static void main(String[] args) {\n" + 
			"    @Useless X<@Usefull X1<@Readonly X2<@Marker X3<@NonNull String>>>> x;\n" +
			"    x = new @Useless X<@Usefull X1<@Uselss X2<@Usefull X3<@NonNull String>>>>();\n" + 
			"    x.a = new @NonNull X1<@NonEmpty X2<@Marker X3<@English String>>>();\n" + 
			"    x.a.a1 = new @Uselss X2<@Usefull X3<@English String>>();\n" + 
			"    x.a.a1.a2 = new @Useless X3<@Hindi String>();\n" + 
			"    x.a.a1.a2.a3 = \"SUCCESS\";\n" + 
			"    System.out.println(x.a.a1.a2.a3);\n" + 
			"  }\n" + 
			"}\n" + 
			"@Java5 class X1<@Useless A extends @Usefull X2<@Useless X3<@English String>>> {\n" + 
			"  A a1;\n" + 
			"  X1() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"}\n" + 
			"class X2<@Java7 A extends @Java7 X3<@Java7 String>> {\n" + 
			"  A a2;\n" + 
			"  X2() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"}\n" + 
			"@Java5 class X3<@Java7 A> {\n" + 
			"  A a3;\n" + 
			"  X3() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"}\n";
		checkParse((CHECK_ALL & ~CHECK_INDEXING_PARSER), source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//ReferenceType : type argument
	public void test0019() throws IOException  {
		String source = 	"@Deprecated public class X<@Useless Tx1 extends @NonNull String, @Usefull Tx2 extends @NonNull Comparable>  extends @Volatile XS<@NonNegative Tx2> {\n" +
							"\n" +
							"    public static void main(String[] args) {\n" +
							"        Integer w;\n" +
							"        w = new @Transient X<@Marker @Singlemember(10) @Normal(Value=10) String, Integer>().get(new @Positive Integer(12));\n" +
							"        w = new @Transient X<String, @Positive @Marker @Singlemember(10) @Normal(Value=10) Integer>().get(new @Positive Integer(12));\n" +
							"        w = new @Transient X<String, Integer>().get(new @Positive Integer(12));\n" +
							"        System.out.println(\"SUCCESS\");\n" +
							"    }\n" +
							"}\n" +
							"class XS <@Positive Txs> {\n" +
							"    Txs get(Txs t) @Readonly {\n" +
							"        return t;\n" +
							"    }\n" +
							"}\n";
	
						
		String expectedUnitToString = 
			"public @Deprecated class X<@Useless Tx1 extends @NonNull String, @Usefull Tx2 extends @NonNull Comparable> extends @Volatile XS<@NonNegative Tx2> {\n" + 
			"  public X() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"  public static void main(String[] args) {\n" + 
			"    Integer w;\n" + 
			"    w = new @Transient X<@Marker @Singlemember(10) @Normal(Value = 10) String, Integer>().get(new @Positive Integer(12));\n" + 
			"    w = new @Transient X<String, @Positive @Marker @Singlemember(10) @Normal(Value = 10) Integer>().get(new @Positive Integer(12));\n" + 
			"    w = new @Transient X<String, Integer>().get(new @Positive Integer(12));\n" + 
			"    System.out.println(\"SUCCESS\");\n" + 
			"  }\n" + 
			"}\n" + 
			"class XS<@Positive Txs> {\n" + 
			"  XS() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"  Txs get(Txs t) @Readonly  {\n" + 
			"    return t;\n" + 
			"  }\n" + 
			"}\n";
		checkParse((CHECK_ALL & ~CHECK_INDEXING_PARSER), source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//ReferenceType : type argument
	public void test0019a() throws IOException  {
		String source = 	"@Deprecated public class X<@Useless Tx1 extends @NonNull String, @Usefull Tx2 extends @NonNull Comparable>  extends @Volatile XS<@NonNegative Tx2> {\n" +
							"\n" +
							"    public static void main(String[] args) {\n" +
							"        Integer w;\n" +
							"        w = new @Transient X<@Singlemember(10) String [] @Marker[] [], HashMap<@Readonly String, @Positive Integer>>().get(new @Positive Integer(12));\n" +
							"    }\n" +
							"}\n" +
							"class XS <@Positive Txs> {\n" +
							"    Txs get(Txs t) @Readonly {\n" +
							"        return null;\n" +
							"    }\n" +
							"}\n";
	
						
		String expectedUnitToString = 
			"public @Deprecated class X<@Useless Tx1 extends @NonNull String, @Usefull Tx2 extends @NonNull Comparable> extends @Volatile XS<@NonNegative Tx2> {\n" + 
			"  public X() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"  public static void main(String[] args) {\n" + 
			"    Integer w;\n" + 
			"    w = new @Transient X<@Singlemember(10) String[] @Marker [][], HashMap<@Readonly String, @Positive Integer>>().get(new @Positive Integer(12));\n" + 
			"  }\n" + 
			"}\n" + 
			"class XS<@Positive Txs> {\n" + 
			"  XS() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"  Txs get(Txs t) @Readonly  {\n" + 
			"    return null;\n" + 
			"  }\n" + 
			"}\n";
		checkParse(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	public void test0001a() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	public void test0002() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	public void test0002a() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	public void test0002b() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	public void test0002c() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	public void test0003() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	public void test0003a() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	public void test0003b() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	public void test0003c() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	public void test0004() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	public void test0005() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	public void test0005a() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	public void test0006() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	
	}
	public void test0007() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	// parameters
	public void test0008() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	public void test0008a() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	public void test0008b() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	public void test0008c() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	// varargs annotation
	public void test0008d() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	public void test0008e() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	public void test0008f() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	public void test0008g() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	// local variables
	public void test0009() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	// type parameter
	public void test0010() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	// Type
	public void test0011() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	// Type
	public void test0011a() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//Type
	public void test0011b() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	// Type
	public void test0011c() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//Type
	public void test0011d() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//Type
	public void test0011e() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	// Type
	public void test0011f() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//Type
	public void test0011g() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	// Type0 field declaration.
	public void test0012() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//Type0 field declaration.
	public void test0012a() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//Type0 field declaration.
	public void test0012b() 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(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//Type0 field declaration.
	public void test0012c() throws IOException  {
		String source = "public class A  {\n" +
						"    int [] f [];\n" +
						"    @Marker HashMap<@Positive Integer, @Negative Integer>.Iterator k;\n" +
						"    float [] p [];\n" +
						"}\n";
		String expectedUnitToString = 
			"public class A {\n" + 
			"  int[][] f;\n" + 
			"  @Marker HashMap<@Positive Integer, @Negative Integer>.Iterator k;\n" + 
			"  float[][] p;\n" + 
			"  public A() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"}\n";
		checkParse(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//Type0 field declaration.
	public void test0012d() throws IOException  {
		String source = "public class A  {\n" +
						"    int [] f [];\n" +
						"    @Marker int [] @NonEmpty[] [] k;\n" +
						"    float [] p [];\n" +
						"}\n";
		String expectedUnitToString = 
			"public class A {\n" + 
			"  int[][] f;\n" + 
			"  @Marker int[] @NonEmpty [][] k;\n" + 
			"  float[][] p;\n" + 
			"  public A() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"}\n";
		checkParse(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//Type0 field declaration.
	public void test0012e() throws IOException  {
		String source = "public class A  {\n" +
						"    int [] f [];\n" +
						"    @Marker String [] @NonEmpty[] []k;\n" +
						"    float [] p [];\n" +
						"}\n";
		String expectedUnitToString = 
			"public class A {\n" + 
			"  int[][] f;\n" + 
			"  @Marker String[] @NonEmpty [][] k;\n" + 
			"  float[][] p;\n" + 
			"  public A() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"}\n";
		checkParse(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//Type0 field declaration.
	public void test0012f() throws IOException  {
		String source = "public class A  {\n" +
						"    int [] f [];\n" +
						"    @Marker HashMap<@Positive Integer, @Negative Integer>[] @NonEmpty[] [] k;\n" +
						"    float [] p [];\n" +
						"}\n";
		String expectedUnitToString = 
			"public class A {\n" + 
			"  int[][] f;\n" + 
			"  @Marker HashMap<@Positive Integer, @Negative Integer>[] @NonEmpty [][] k;\n" + 
			"  float[][] p;\n" + 
			"  public A() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"}\n";
		checkParse(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//Type0 field declaration.
	public void test0012g() throws IOException  {
		String source = "public class A  {\n" +
						"    int [] f [];\n" +
						"    @Marker HashMap<@Positive Integer, @Negative Integer>.Iterator[] @NonEmpty[] [] k;\n" +
						"    float [] p [];\n" +
						"}\n";
		String expectedUnitToString = 
			"public class A {\n" + 
			"  int[][] f;\n" + 
			"  @Marker HashMap<@Positive Integer, @Negative Integer>.Iterator[] @NonEmpty [][] k;\n" + 
			"  float[][] p;\n" + 
			"  public A() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"}\n";
		checkParse(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//Type0 MethodHeaderName.
	public void test0013() throws IOException  {
		String source = "public class A  {\n" +
						"    public @Marker int foo() { return 0; }\n" +
						"    public int bar() { return 0; }\n" +
						"}\n";
		String expectedUnitToString = 
			"public class A {\n" + 
			"  public A() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"  public @Marker int foo() {\n" + 
			"    return 0;\n" + 
			"  }\n" + 
			"  public int bar() {\n" + 
			"    return 0;\n" + 
			"  }\n" + 
			"}\n";
		checkParse(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//Type0 MethodHeaderName.
	public void test0013a() throws IOException  {
		String source = "public class A  {\n" +
						"    public @Marker String foo() { return null; }\n" +
						"    public String bar() { return null; }\n" +
						"}\n";
		String expectedUnitToString = 
			"public class A {\n" + 
			"  public A() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"  public @Marker String foo() {\n" + 
			"    return null;\n" + 
			"  }\n" + 
			"  public String bar() {\n" + 
			"    return null;\n" + 
			"  }\n" + 
			"}\n";
		checkParse(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//Type0 MethodHeaderName.
	public void test0013b() throws IOException  {
		String source = "public class A  {\n" +
						"    public @Marker HashMap<@Positive Integer, @Negative Integer> foo() { return null; }\n" +
						"    public HashMap<@Positive Integer, @Negative Integer>  bar() { return null; }\n" +
						"}\n";
		String expectedUnitToString = 
			"public class A {\n" + 
			"  public A() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"  public @Marker HashMap<@Positive Integer, @Negative Integer> foo() {\n" + 
			"    return null;\n" + 
			"  }\n" + 
			"  public HashMap<@Positive Integer, @Negative Integer> bar() {\n" + 
			"    return null;\n" + 
			"  }\n" + 
			"}\n";
		checkParse(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//Type0 MethodHeaderName.
	public void test0013c() throws IOException  {
		String source = "public class A  {\n" +
						"    public @Marker HashMap<@Positive Integer, @Negative Integer>.Iterator foo() { return null; }\n" +
						"    public HashMap<@Positive Integer, @Negative Integer>.Iterator  bar() { return null; }\n" +
						"}\n";
		String expectedUnitToString = 
			"public class A {\n" + 
			"  public A() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"  public @Marker HashMap<@Positive Integer, @Negative Integer>.Iterator foo() {\n" + 
			"    return null;\n" + 
			"  }\n" + 
			"  public HashMap<@Positive Integer, @Negative Integer>.Iterator bar() {\n" + 
			"    return null;\n" + 
			"  }\n" + 
			"}\n";
		checkParse(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//Type0 MethodHeaderName.
	public void test0013d() throws IOException  {
		String source = "public class A  {\n" +
						"    public @Marker int [] foo() @NonEmpty [] [] { return 0; }\n" +
						"    public int [] @NonEmpty [] [] bar() { return 0; }\n" +
						"}\n";
		String expectedUnitToString = 
			"public class A {\n" + 
			"  public A() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"  public @Marker int[] @NonEmpty [][] foo() {\n" + 
			"    return 0;\n" + 
			"  }\n" + 
			"  public int[] @NonEmpty [][] bar() {\n" + 
			"    return 0;\n" + 
			"  }\n" + 
			"}\n";
		checkParse(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//Type0 MethodHeaderName.
	public void test0013e() throws IOException  {
		String source = "public class A  {\n" +
						"    public @Marker String []  foo() @NonEmpty [] [] { return null; }\n" +
						"    public String [] @NonEmpty [] [] bar() { return null; }\n" +
						"}\n";
		String expectedUnitToString = 
			"public class A {\n" + 
			"  public A() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"  public @Marker String[] @NonEmpty [][] foo() {\n" + 
			"    return null;\n" + 
			"  }\n" + 
			"  public String[] @NonEmpty [][] bar() {\n" + 
			"    return null;\n" + 
			"  }\n" + 
			"}\n";
		checkParse(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//Type0 MethodHeaderName.
	public void test0013f() throws IOException  {
		String source = "public class A  {\n" +
						"    public @Marker HashMap<@Positive Integer, @Negative Integer> [] foo() @NonEmpty [] [] { return null; }\n" +
						"    public HashMap<@Positive Integer, @Negative Integer>  [] @NonEmpty [] [] bar() { return null; }\n" +
						"}\n";
		String expectedUnitToString = 
			"public class A {\n" + 
			"  public A() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"  public @Marker HashMap<@Positive Integer, @Negative Integer>[] @NonEmpty [][] foo() {\n" + 
			"    return null;\n" + 
			"  }\n" + 
			"  public HashMap<@Positive Integer, @Negative Integer>[] @NonEmpty [][] bar() {\n" + 
			"    return null;\n" + 
			"  }\n" + 
			"}\n";
		checkParse(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//Type0 MethodHeaderName.
	public void test0013g() throws IOException  {
		String source = "public class A  {\n" +
						"    public @Marker HashMap<@Positive Integer, @Negative Integer>.Iterator[]  foo() @NonEmpty [] [] { return null; }\n" +
						"    public HashMap<@Positive Integer, @Negative Integer>.Iterator[] @NonEmpty [] [] bar() { return null; }\n" +
						"}\n";
		String expectedUnitToString = 
			"public class A {\n" + 
			"  public A() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"  public @Marker HashMap<@Positive Integer, @Negative Integer>.Iterator[] @NonEmpty [][] foo() {\n" + 
			"    return null;\n" + 
			"  }\n" + 
			"  public HashMap<@Positive Integer, @Negative Integer>.Iterator[] @NonEmpty [][] bar() {\n" + 
			"    return null;\n" + 
			"  }\n" + 
			"}\n";
		checkParse(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//Type0 local variable declaration
	public void test0014() throws IOException  {
		String source = "public class A  {\n" +
						"    public void foo() {\n" +
						"        @Marker int p;\n" +
						"        int q;\n" + 
						"    }\n" +
						"}\n";
		String expectedUnitToString = 
			"public class A {\n" + 
			"  public A() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"  public void foo() {\n" + 
			"    @Marker int p;\n" + 
			"    int q;\n" + 
			"  }\n" + 
			"}\n";
		checkParse(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//Type0 local variable declaration
	public void test0014a() throws IOException  {
		String source = "public class A  {\n" +
						"    public void foo() {\n" +
						"        @Marker String p;\n" +
						"        String q;\n" + 
						"    }\n" +
						"}\n";
		String expectedUnitToString = 
			"public class A {\n" + 
			"  public A() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"  public void foo() {\n" + 
			"    @Marker String p;\n" + 
			"    String q;\n" + 
			"  }\n" + 
			"}\n";
		checkParse(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//Type0 local variable declaration
	public void test0014b() throws IOException  {
		String source = "public class A  {\n" +
						"    public void foo() {\n" +
						"        @Marker HashMap<@Positive Integer, @Negative Integer> p;\n" +
						"        HashMap<@Positive Integer, @Negative Integer> q;\n" + 
						"    }\n" +
						"}\n";
		String expectedUnitToString = 
			"public class A {\n" + 
			"  public A() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"  public void foo() {\n" + 
			"    @Marker HashMap<@Positive Integer, @Negative Integer> p;\n" + 
			"    HashMap<@Positive Integer, @Negative Integer> q;\n" + 
			"  }\n" + 
			"}\n";
		checkParse(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//Type0 local variable declaration
	public void test0014c() throws IOException  {
		String source = "public class A  {\n" +
						"    public void foo() {\n" +
						"        @Marker HashMap<@Positive Integer, @Negative Integer>.Iterator p;\n" +
						"        HashMap<@Positive Integer, @Negative Integer>.Iterator q;\n" + 
						"    }\n" +
						"}\n";
		String expectedUnitToString = 
			"public class A {\n" + 
			"  public A() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"  public void foo() {\n" + 
			"    @Marker HashMap<@Positive Integer, @Negative Integer>.Iterator p;\n" + 
			"    HashMap<@Positive Integer, @Negative Integer>.Iterator q;\n" + 
			"  }\n" + 
			"}\n";
		checkParse(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//Type0 local variable declaration
	public void test0014d() throws IOException  {
		String source = "public class A  {\n" +
						"    public void foo() {\n" +
						"        @Marker int [] @NonNull[] p @NonEmpty [] [];\n" +
						"        int [] @NonNull[] q @NonEmpty [] [];\n" + 
						"    }\n" +
						"}\n";
		String expectedUnitToString = 
			"public class A {\n" + 
			"  public A() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"  public void foo() {\n" + 
			"    @Marker int[] @NonNull [] @NonEmpty [][] p;\n" + 
			"    int[] @NonNull [] @NonEmpty [][] q;\n" + 
			"  }\n" + 
			"}\n";
		checkParse(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//Type0 local variable declaration
	public void test0014e() throws IOException  {
		String source = "public class A  {\n" +
						"    public void foo() {\n" +
						"        @Marker String [] @NonNull[] p @NonEmpty [] [];\n" +
						"        String [] @NonNull[] q @NonEmpty [] [];\n" + 
						"    }\n" +
						"}\n";
		String expectedUnitToString = 
			"public class A {\n" + 
			"  public A() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"  public void foo() {\n" + 
			"    @Marker String[] @NonNull [] @NonEmpty [][] p;\n" + 
			"    String[] @NonNull [] @NonEmpty [][] q;\n" + 
			"  }\n" + 
			"}\n";
		checkParse(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//Type0 local variable declaration
	public void test0014f() throws IOException  {
		String source = "public class A  {\n" +
						"    public void foo() {\n" +
						"        @Marker HashMap<@Positive Integer, @Negative Integer> [] @NonNull[] p @NonEmpty [] [];\n" +
						"        HashMap<@Positive Integer, @Negative Integer> [] @NonNull[] q @NonEmpty [] [];\n" + 
						"    }\n" +
						"}\n";
		String expectedUnitToString = 
			"public class A {\n" + 
			"  public A() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"  public void foo() {\n" + 
			"    @Marker HashMap<@Positive Integer, @Negative Integer>[] @NonNull [] @NonEmpty [][] p;\n" + 
			"    HashMap<@Positive Integer, @Negative Integer>[] @NonNull [] @NonEmpty [][] q;\n" + 
			"  }\n" + 
			"}\n";
		checkParse(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//Type0 local variable declaration
	public void test0014g() throws IOException  {
		String source = "public class A  {\n" +
						"    public void foo() {\n" +
						"        @Marker HashMap<@Positive Integer, @Negative Integer>.Iterator [] @NonNull[] p @NonEmpty [] [];\n" +
						"        HashMap<@Positive Integer, @Negative Integer>.Iterator [] @NonNull[] @NonEmpty [] [] q;\n" + 
						"    }\n" +
						"}\n";
		String expectedUnitToString = 
			"public class A {\n" + 
			"  public A() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"  public void foo() {\n" + 
			"    @Marker HashMap<@Positive Integer, @Negative Integer>.Iterator[] @NonNull [] @NonEmpty [][] p;\n" + 
			"    HashMap<@Positive Integer, @Negative Integer>.Iterator[] @NonNull [] @NonEmpty [][] q;\n" + 
			"  }\n" + 
			"}\n";
		checkParse(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//Type0 foreach
	public void test0015() throws IOException  {
		String source = "public class A  {\n" +
						"    public void foo() {\n" +
						"        String @NonNull [] @Marker [] s @Readonly [];\n" +
						"    	 for (@Readonly String @NonNull [] si @Marker [] : s) {}\n" +
						"    	 for (String @NonNull [] sii @Marker [] : s) {}\n" +
						"    }\n" +
						"}\n";
		String expectedUnitToString = 
			"public class A {\n" + 
			"  public A() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"  public void foo() {\n" + 
			"    String @NonNull [] @Marker [] @Readonly [] s;\n" + 
			"    for (@Readonly String @NonNull [] @Marker [] si : s) \n" + 
			"      {\n" + 
			"      }\n" + 
			"    for (String @NonNull [] @Marker [] sii : s) \n" + 
			"      {\n" + 
			"      }\n" + 
			"  }\n" + 
			"}\n";
		checkParse(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//Type0 foreach
	public void test0015a() throws IOException  {
		String source = "public class A  {\n" +
						"    public void foo() {\n" +
						"        int @NonNull [] @Marker [] s @Readonly [];\n" +
						"    	 for (@Readonly int @NonNull [] si @Marker [] : s) {}\n" +
						"    	 for (int @NonNull [] sii @Marker [] : s) {}\n" +
						"    }\n" +
						"}\n";
		String expectedUnitToString = 
			"public class A {\n" + 
			"  public A() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"  public void foo() {\n" + 
			"    int @NonNull [] @Marker [] @Readonly [] s;\n" + 
			"    for (@Readonly int @NonNull [] @Marker [] si : s) \n" + 
			"      {\n" + 
			"      }\n" + 
			"    for (int @NonNull [] @Marker [] sii : s) \n" + 
			"      {\n" + 
			"      }\n" + 
			"  }\n" + 
			"}\n";
		checkParse(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	// cast expression
	public void test0016() throws IOException  {
		String source = "public class Clazz {\n" +
						"public static void main(String [] args) {\n" +
						"int x;\n" +
						"x = (Integer)\n" +
						"(@Readonly Object)\n" +
						"(@Readonly HashMap<@Positive Integer, @Negative Integer>.Iterator [] @Normal(Value=0)[] [] )\n" +
						"(@Readonly HashMap<@Positive Integer, @Negative Integer>.Iterator [] @SingleMember(0)[] [] )\n" +
						"(@Readonly HashMap<@Positive Integer, @Negative Integer>.Iterator [] @Marker[] [] )\n" +
						"(@Readonly Object)\n" +
						"(@Readonly HashMap<@Positive Integer, @Negative Integer> [] @Normal(Value=0)[] [] )\n" +
						"(@Readonly HashMap<@Positive Integer, @Negative Integer> [] @SingleMember(0)[] [] )\n" +
						"(@Readonly HashMap<@Positive Integer, @Negative Integer> [] @Marker[] [] )\n" +
						"(@Readonly Object)\n" +
						"(@Readonly String [] @Normal(Value=0)[] [] )\n" +
						"(@Readonly String [] @SingleMember(0)[] [] )\n" +
						"(@Readonly String [] @Marker[] [] )\n" +
						"(@Readonly Object)\n" +
						"(@Readonly int [] @Normal(Value=0)[] [] )\n" +
						"(@Readonly int [] @SingleMember(0)[] [] )\n" +
						"(@Readonly int [] @Marker[] [] )\n" +
						"(@Readonly Object)\n" +
						"(@Readonly HashMap<@Positive Integer, @Negative Integer>.Iterator)\n" +
						"(@Readonly Object)\n" +
						"(@Readonly HashMap<@Positive Integer, @Negative Integer>)\n" +
						"(@Readonly Object)\n" +
						"(@ReadOnly String)\n" +
						"(@Readonly Object)\n" +
						"(@Readonly int) 10;\n" +
						"}\n" +
						"}\n";
		String expectedUnitToString = 
			"public class Clazz {\n" + 
			"  public Clazz() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"  public static void main(String[] args) {\n" + 
			"    int x;\n" + 
			"    x = (Integer) (@Readonly Object) ( @Readonly HashMap<@Positive Integer, @Negative Integer>.Iterator[] @Normal(Value = 0) [][]) ( @Readonly HashMap<@Positive Integer, @Negative Integer>.Iterator[] @SingleMember(0) [][]) ( @Readonly HashMap<@Positive Integer, @Negative Integer>.Iterator[] @Marker [][]) (@Readonly Object) (@Readonly HashMap<@Positive Integer, @Negative Integer>[] @Normal(Value = 0) [][]) (@Readonly HashMap<@Positive Integer, @Negative Integer>[] @SingleMember(0) [][]) (@Readonly HashMap<@Positive Integer, @Negative Integer>[] @Marker [][]) (@Readonly Object) (@Readonly String[] @Normal(Value = 0) [][]) (@Readonly String[] @SingleMember(0) [][]) (@Readonly String[] @Marker [][]) (@Readonly Object) (@Readonly int[] @Normal(Value = 0) [][]) (@Readonly int[] @SingleMember(0) [][]) (@Readonly int[] @Marker [][]) (@Readonly Object) ( @Readonly HashMap<@Positive Integer, @Negative Integer>.Iterator) (@Readonly Object) (@Readonly HashMap<@Positive Integer, @Negative Integer>) (@Readonly Object) (@ReadOnly String) (@Readonly Object) (@Readonly int) 10;\n" + 
			"  }\n" + 
			"}\n";
		checkParse(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	//cast expression
	public void test0016a() throws IOException  {
		String source = "public class Clazz {\n" +
						"public static void main(String [] args) {\n" +
						"int x;\n" +
						"x = (Integer)\n" +
						"(Object)\n" +
						"(@Readonly HashMap<Integer, @Negative Integer>.Iterator [] @Normal(Value=0)[] [] )\n" +
						"(HashMap<@Positive Integer, Integer>.Iterator [] @SingleMember(0)[] [] )\n" +
						"(@Readonly HashMap<Integer, @Negative Integer>.Iterator [] @Marker[] [] )\n" +
						"(Object)\n" +
						"(@Readonly HashMap<@Positive Integer, Integer> [] @Normal(Value=0)[] [] )\n" +
						"(HashMap<Integer, @Negative Integer> [] @SingleMember(0)[] [] )\n" +
						"(@Readonly HashMap<@Positive Integer, Integer> [] @Marker[] [] )\n" +
						"(Object)\n" +
						"(@Readonly String [] @Normal(Value=0)[] [] )\n" +
						"(String [] @SingleMember(0)[] [] )\n" +
						"(@Readonly String [] @Marker[] [] )\n" +
						"(Object)\n" +
						"(@Readonly int [] @Normal(Value=0)[] [] )\n" +
						"(int [] @SingleMember(0)[] [] )\n" +
						"(@Readonly int [] @Marker[] [] )\n" +
						"(Object)\n" +
						"(@Readonly HashMap<Integer, @Negative Integer>.Iterator)\n" +
						"(Object)\n" +
						"(@Readonly HashMap<@Positive Integer, Integer>)\n" +
						"(Object)\n" +
						"(@ReadOnly String)\n" +
						"(Object)\n" +
						"(@Readonly int) 10;\n" +
						"}\n" +
						"}\n";
		String expectedUnitToString = 
			"public class Clazz {\n" + 
			"  public Clazz() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"  public static void main(String[] args) {\n" + 
			"    int x;\n" + 
			"    x = (Integer) (Object) ( @Readonly HashMap<Integer, @Negative Integer>.Iterator[] @Normal(Value = 0) [][]) (HashMap<@Positive Integer, Integer>.Iterator[] @SingleMember(0) [][]) ( @Readonly HashMap<Integer, @Negative Integer>.Iterator[] @Marker [][]) (Object) (@Readonly HashMap<@Positive Integer, Integer>[] @Normal(Value = 0) [][]) (HashMap<Integer, @Negative Integer>[] @SingleMember(0) [][]) (@Readonly HashMap<@Positive Integer, Integer>[] @Marker [][]) (Object) (@Readonly String[] @Normal(Value = 0) [][]) (String[] @SingleMember(0) [][]) (@Readonly String[] @Marker [][]) (Object) (@Readonly int[] @Normal(Value = 0) [][]) (int[] @SingleMember(0) [][]) (@Readonly int[] @Marker [][]) (Object) ( @Readonly HashMap<Integer, @Negative Integer>.Iterator) (Object) (@Readonly HashMap<@Positive Integer, Integer>) (Object) (@ReadOnly String) (Object) (@Readonly int) 10;\n" + 
			"  }\n" + 
			"}\n";
		checkParse(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	// instanceof checks 
	public void test0017() throws IOException  {
		String source = "public class Clazz {\n" +
						"public static void main(Object o) {\n" +
						"if (o instanceof @Readonly String) {\n" +
						"} else if (o instanceof @Readonly int [] @NonEmpty[] [] ) {\n" +
						"} else if (o instanceof @Readonly String [] @NonEmpty[] [] ) {\n" +
						"} else if (o instanceof @Readonly HashMap<?,?> [] @NonEmpty[] [] ) {\n" +
						"} else if (o instanceof @Readonly HashMap<@Positive Integer, @Negative Integer>.Iterator [] @NonEmpty[] [] ) {\n" +	
						"} else if (o instanceof @Readonly HashMap<?,?>) {\n" +
						"} else if (o instanceof @Readonly HashMap<@Positive Integer, @Negative Integer>.Iterator) {\n" +
						"}\n" +
						"}\n" +
						"}";
		String expectedUnitToString = 
			"public class Clazz {\n" + 
			"  public Clazz() {\n" + 
			"    super();\n" + 
			"  }\n" + 
			"  public static void main(Object o) {\n" + 
			"    if ((o instanceof @Readonly String))\n" + 
			"        {\n" + 
			"        }\n" + 
			"    else\n" + 
			"        if ((o instanceof @Readonly int[] @NonEmpty [][]))\n" + 
			"            {\n" + 
			"            }\n" + 
			"        else\n" + 
			"            if ((o instanceof @Readonly String[] @NonEmpty [][]))\n" + 
			"                {\n" + 
			"                }\n" + 
			"            else\n" + 
			"                if ((o instanceof @Readonly HashMap<?, ?>[] @NonEmpty [][]))\n" + 
			"                    {\n" + 
			"                    }\n" + 
			"                else\n" + 
			"                    if ((o instanceof  @Readonly HashMap<@Positive Integer, @Negative Integer>.Iterator[] @NonEmpty [][]))\n" + 
			"                        {\n" + 
			"                        }\n" + 
			"                    else\n" + 
			"                        if ((o instanceof @Readonly HashMap<?, ?>))\n" + 
			"                            {\n" + 
			"                            }\n" + 
			"                        else\n" + 
			"                            if ((o instanceof  @Readonly HashMap<@Positive Integer, @Negative Integer>.Iterator))\n" + 
			"                                {\n" + 
			"                                }\n" + 
			"  }\n" + 
			"}\n";
		checkParse(source.toCharArray(), null, "test001", expectedUnitToString);
	}
	// assorted unclassified 
	public void test0018() throws IOException  {
		String source = "import java.util.HashMap;\n" +
						"import java.util.Map; \n" +  
						"\n" +
						"public class Clazz <@A M extends @B String, @C N extends @D Comparable> extends\n" +
						"								@E Object implements @F Comparable <@G Object> {\n" +
						"	\n" +
						"  Clazz(char [] ...args) @H { \n" +   
						"   }\n" +
						"   \n" +
						"  int @I[] f @J[], g, h[], i@K[];\n" +
						"  int @L[][]@M[] f2; \n" +
						"   \n" +
						"  Clazz (int @N [] @O... a) @Q {}\n" +
						" int @R[]@S[] aa() {}\n" +
						" \n" +
						" int @T[]@U[]@V[] a () @W[]@X[]@Y[] @Z { return null; }\n" +
						"   \n" +
						"  public void main(String @A[] @B ... args) @C throws @D Exception {\n" +
						"  	\n" +
						"       HashMap<@E String, @F String> b1;\n" +
						"      \n" +
						"     int b; b = (@G int) 10;\n" +
						"      \n" +
						"     char @H[]@I[] ch; ch = (@K char @L[]@M[])(@N char @O[]@P[]) null;\n" +
						"      \n" +
						"      int [] i; i = new @Q int @R[10];\n" +
						"       \n" +
						"      \n" +
						"   Integer w; w = new X<@S String, @T Integer>().get(new @U Integer(12));\n" +
						"    throw new @V Exception(\"test\");\n" +
						"    boolean c; c  = null instanceof @W String;\n" +
						"	} \n" +
						" public <@X X, @Y Y> void foo(X x, Y @Z... y) {  \n" +
						"	\n" +
						"}\n" +
						" \n" +
						" void foo(Map<? super @A Object, ? extends @B String> m){}\n" +
						" public int compareTo(Object arg0) {\n" +
						"     return 0;\n" +
						" }\n" +
						"\n" +
						"}\n" +
						"class X<@C K, @D T extends @E Object & @F Comparable<? super @G T>> {\n" +
						"	\n" +
						"  public Integer get(Integer integer) {\n" +
						"       return null;\n" +
						"   }\n" +
						"}\n";
						
						
		String expectedUnitToString = "import java.util.HashMap;\n" + 
									  "import java.util.Map;\n" + 
									  "public class Clazz<@A M extends @B String, @C N extends @D Comparable> extends @E Object implements @F Comparable<@G Object> {\n" + 
									  "  int @I [] @J [] f;\n" + 
									  "  int @I [] g;\n" + 
									  "  int @I [][] h;\n" + 
									  "  int @I [] @K [] i;\n" + 
									  "  int @L [][] @M [] f2;\n" + 
									  "  Clazz(char[]... args) @H  {\n" + 
									  "    super();\n" + 
									  "  }\n" + 
									  "  Clazz(int @N [] @O ... a) @Q  {\n" + 
									  "    super();\n" + 
									  "  }\n" + 
									  "  int @R [] @S [] aa() {\n" + 
									  "  }\n" + 
									  "  int @T [] @U [] @V [] @W [] @X [] @Y [] a() @Z  {\n" + 
									  "    return null;\n" + 
									  "  }\n" + 
									  "  public void main(String @A [] @B ... args) @C  throws @D Exception {\n" + 
									  "    HashMap<@E String, @F String> b1;\n" + 
									  "    int b;\n" +
									  "    b = (@G int) 10;\n" + 
									  "    char @H [] @I [] ch;\n" +
									  "    ch = (@K char @L [] @M []) (@N char @O [] @P []) null;\n" + 
									  "    int[] i;\n" +
									  "    i = new @Q int @R [10];\n" + 
									  "    Integer w;\n" +
									  "    w = new X<@S String, @T Integer>().get(new @U Integer(12));\n" + 
									  "    throw new @V Exception(\"test\");\n" + 
									  "    boolean c;\n" +
									  "    c = (null instanceof @W String);\n" + 
									  "  }\n" + 
									  "  public <@X X, @Y Y>void foo(X x, Y @Z ... y) {\n" + 
									  "  }\n" + 
									  "  void foo(Map<? super @A Object, ? extends @B String> m) {\n" + 
									  "  }\n" + 
									  "  public int compareTo(Object arg0) {\n" + 
									  "    return 0;\n" + 
									  "  }\n" + 
									  "}\n" + 
									  "class X<@C K, @D T extends @E Object & @F Comparable<? super @G T>> {\n" + 
									  "  X() {\n" + 
									  "    super();\n" + 
									  "  }\n" + 
									  "  public Integer get(Integer integer) {\n" + 
									  "    return null;\n" + 
									  "  }\n" + 
									  "}\n";
	    // indexing parser avoids creating lots of nodes, so parse tree comes out incorrectly.
		// this is not bug, but intended behavior - see IndexingParser.newSingleNameReference(char[], long)
		checkParse((CHECK_ALL & ~CHECK_INDEXING_PARSER), source.toCharArray(), null, "test001", expectedUnitToString);
	}


}




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.Locale;

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.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.CompilationUnitDeclaration;
import org.eclipse.jdt.internal.compiler.ast.Expression;
import org.eclipse.jdt.internal.compiler.ast.ImportReference;
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.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 {
	
	protected static String  jsr308TestScratchArea = "c:\\Jsr308TestScratchArea";
	protected static final int CHECK_PARSER = 0x1;
	protected static final int CHECK_COMPLETION_PARSER = 0x2;
	private static final int CHECK_SELECTION_PARSER = 0x4;
	private static final int CHECK_DOCUMENT_ELEMENT_PARSER = 0x8;
	private static final int CHECK_COMMENT_RECORDER_PARSER = 0x10;
	private 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-b65-windows-i586-16_jul_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 + "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) 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());
		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(
		char[] source,
		String expectedSyntaxErrorDiagnosis,
		String testName, 
		String expectedUnitToString) throws IOException {
	checkParse(CHECK_ALL, source, expectedSyntaxErrorDiagnosis, testName, expectedUnitToString);
}
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,
		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) {
	
	
}
}

Return to bug 287648

Added Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/parser/AbstractTypeAnnotationSyntaxTest.java (+495 lines)
1	package org.eclipse.jdt.core.tests.compiler.parser;
2
3	import java.io.BufferedReader;
4	import java.io.File;
5	import java.io.FileInputStream;
6	import java.io.FileOutputStream;
7	import java.io.IOException;
8	import java.io.InputStreamReader;
9	import java.io.OutputStreamWriter;
10	import java.util.Locale;
11
12	import org.eclipse.jdt.core.compiler.CategorizedProblem;
13	import org.eclipse.jdt.core.tests.util.AbstractCompilerTest;
14	import org.eclipse.jdt.core.tests.util.CompilerTestSetup;
15	import org.eclipse.jdt.core.tests.util.Util;
16	import org.eclipse.jdt.internal.codeassist.complete.CompletionParser;
17	import org.eclipse.jdt.internal.codeassist.select.SelectionParser;
18	import org.eclipse.jdt.internal.compiler.CompilationResult;
19	import org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies;
20	import org.eclipse.jdt.internal.compiler.DocumentElementParser;
21	import org.eclipse.jdt.internal.compiler.IDocumentElementRequestor;
22	import org.eclipse.jdt.internal.compiler.ISourceElementRequestor;
23	import org.eclipse.jdt.internal.compiler.SourceElementParser;
24	import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
25	import org.eclipse.jdt.internal.compiler.ast.Expression;
26	import org.eclipse.jdt.internal.compiler.ast.ImportReference;
27	import org.eclipse.jdt.internal.compiler.batch.CompilationUnit;
28	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
29	import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;
30	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
31	import org.eclipse.jdt.internal.compiler.parser.Parser;
32	import org.eclipse.jdt.internal.compiler.problem.DefaultProblem;
33	import org.eclipse.jdt.internal.compiler.problem.DefaultProblemFactory;
34	import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
35	import org.eclipse.jdt.internal.core.search.indexing.IndexingParser;
36	import org.eclipse.jdt.internal.core.util.CommentRecorderParser;
37
38	public abstract class AbstractTypeAnnotationSyntaxTest extends AbstractCompilerTest implements IDocumentElementRequestor, ISourceElementRequestor {
39
40	protected static String jsr308TestScratchArea = "c:\\Jsr308TestScratchArea";
41	protected static final int CHECK_PARSER = 0x1;
42	protected static final int CHECK_COMPLETION_PARSER = 0x2;
43	private static final int CHECK_SELECTION_PARSER = 0x4;
44	private static final int CHECK_DOCUMENT_ELEMENT_PARSER = 0x8;
45	private static final int CHECK_COMMENT_RECORDER_PARSER = 0x10;
46	private static final int CHECK_SOURCE_ELEMENT_PARSER = 0x20;
47	protected static final int CHECK_INDEXING_PARSER = 0x40;
48	protected static final int CHECK_JAVAC_PARSER = 0x80;
49	protected static int CHECK_ALL = (CHECK_PARSER \| CHECK_COMPLETION_PARSER \| CHECK_SELECTION_PARSER \|
50	CHECK_DOCUMENT_ELEMENT_PARSER \| CHECK_COMMENT_RECORDER_PARSER \|
51	CHECK_SOURCE_ELEMENT_PARSER \| CHECK_INDEXING_PARSER);
52	public static final String compiler = "C:\\jdk-7-ea-bin-b65-windows-i586-16_jul_2009\\jdk7\\bin\\javac.exe";
53	public static boolean optimizeStringLiterals = false;
54
55
56
57	public void initialize(CompilerTestSetup setUp) {
58	super.initialize(setUp);
59	}
60	public AbstractTypeAnnotationSyntaxTest(String testName){
61	super(testName);
62	// if ((new File(compiler).exists())) {
63	// File f = new File(jsr308TestScratchArea);
64	// if (!f.exists()) {
65	// f.mkdir();
66	// }
67	// if (f.exists()) {
68	// try {
69	// OutputStreamWriter w = new OutputStreamWriter(new FileOutputStream(new File(jsr308TestScratchArea + File.separator + "Marker.java")));
70	// w.write("@interface Marker {}\n".toCharArray());
71	// w.close();
72	// w = new OutputStreamWriter(new FileOutputStream(new File(jsr308TestScratchArea + File.separator + "Normal.java")));
73	// w.write("@interface Normal {\n\tint value() default 10;\n}\n".toCharArray());
74	// w.close();
75	// w = new OutputStreamWriter(new FileOutputStream(new File(jsr308TestScratchArea + File.separator + "SingleMember.java")));
76	// w.write("@interface SingleMember {\n\tint value() default 10;\n}\n".toCharArray());
77	// w.close();
78	// w = new OutputStreamWriter(new FileOutputStream(new File(jsr308TestScratchArea + File.separator + "Positive.java")));
79	// w.write("@interface Positive {}\n".toCharArray());
80	// w.close();
81	// w = new OutputStreamWriter(new FileOutputStream(new File(jsr308TestScratchArea + File.separator + "Negative.java")));
82	// w.write("@interface Negative{}\n".toCharArray());
83	// w.close();
84	// w = new OutputStreamWriter(new FileOutputStream(new File(jsr308TestScratchArea + File.separator + "Readonly.java")));
85	// w.write("@interface Readonly {}\n".toCharArray());
86	// w.close();
87	// w = new OutputStreamWriter(new FileOutputStream(new File(jsr308TestScratchArea + File.separator + "HashMap.java")));
88	// w.write("class HashMap<X,Y> {\n class Iterator {}; \n}\n".toCharArray());
89	// w.close();
90	// CHECK_ALL \|= CHECK_JAVAC_PARSER;
91	// } catch (IOException e) {
92	// // ignore
93	// }
94	// }
95	// }
96	}
97	public void checkParse(
98	int parserToCheck,
99	char[] source,
100	String expectedSyntaxErrorDiagnosis,
101	String testName, String expectedUnitToString) throws IOException {
102
103	CompilerOptions options = new CompilerOptions(getCompilerOptions());
104	options.complianceLevel = ClassFileConstants.JDK1_7;
105	options.sourceLevel = ClassFileConstants.JDK1_7;
106	options.targetJDK = ClassFileConstants.JDK1_7;
107
108	ICompilationUnit sourceUnit = null;
109	CompilationResult compilationResult = null;
110	CompilationUnitDeclaration unit = null;
111
112	if ((parserToCheck & CHECK_JAVAC_PARSER) != 0) {
113	String javaFilePath = jsr308TestScratchArea + "\\Xyz.java";
114	File f = new File(javaFilePath);
115	FileOutputStream o = new FileOutputStream(f);
116	OutputStreamWriter w = new OutputStreamWriter(o);
117	w.write(source);
118	w.close();
119	Process p = Runtime.getRuntime().exec (new String[] { compiler, "-sourcepath", jsr308TestScratchArea, javaFilePath }, null, new File(jsr308TestScratchArea));
120	try {
121	BufferedReader stdout = new BufferedReader(new InputStreamReader(p.getInputStream()));
122	BufferedReader stderr = new BufferedReader(new InputStreamReader(p.getErrorStream()));
123	String line;
124	while ((line = stderr.readLine())!= null)
125	System.out.println(line);
126	while ((line = stdout.readLine())!= null)
127	System.out.println(line);
128	assertTrue("javac unhappy", p.waitFor() == 0);
129	} catch (InterruptedException e) {
130	System.err.println("Skipped javac behavior check due to interrupt...");
131	}
132	}
133	if ((parserToCheck & CHECK_PARSER) != 0) {
134	Parser parser1 =
135	new Parser(
136	new ProblemReporter(
137	DefaultErrorHandlingPolicies.proceedWithAllProblems(),
138	options,
139	new DefaultProblemFactory(Locale.getDefault())),
140	optimizeStringLiterals);
141	sourceUnit = new CompilationUnit(source, testName, null);
142	compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);
143	unit = parser1.parse(sourceUnit, compilationResult);
144	parser1.getMethodBodies(unit);
145	assertDianosticEquals(expectedSyntaxErrorDiagnosis, testName, compilationResult);
146	assertParseTreeEquals(expectedUnitToString, unit.toString());
147	parser1 = null;
148	}
149
150	if ((parserToCheck & CHECK_COMPLETION_PARSER) != 0) {
151	CompletionParser parser2 = new CompletionParser(
152	new ProblemReporter(
153	DefaultErrorHandlingPolicies.proceedWithAllProblems(),
154	options,
155	new DefaultProblemFactory(Locale.getDefault())),
156	false);
157	compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);
158	unit = parser2.parse(sourceUnit, compilationResult, Integer.MAX_VALUE);
159	parser2.getMethodBodies(unit);
160	assertDianosticEquals(expectedSyntaxErrorDiagnosis, testName, compilationResult);
161	assertParseTreeEquals(expectedUnitToString, unit.toString());
162	parser2 = null;
163	}
164	if ((parserToCheck & CHECK_SELECTION_PARSER) != 0) {
165	SelectionParser parser3 = new SelectionParser(
166	new ProblemReporter(
167	DefaultErrorHandlingPolicies.proceedWithAllProblems(),
168	options,
169	new DefaultProblemFactory(Locale.getDefault())));
170	compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);
171	unit = parser3.parse(sourceUnit, compilationResult, Integer.MAX_VALUE, Integer.MAX_VALUE);
172	parser3.getMethodBodies(unit);
173	assertDianosticEquals(expectedSyntaxErrorDiagnosis, testName, compilationResult);
174	assertParseTreeEquals(expectedUnitToString, unit.toString());
175	parser3 = null;
176	}
177	if ((parserToCheck & CHECK_DOCUMENT_ELEMENT_PARSER) != 0) {
178	DocumentElementParser parser4 = new DocumentElementParser(
179	this,
180	new DefaultProblemFactory(Locale.getDefault()),
181	options);
182	compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);
183	unit = parser4.parse(sourceUnit, compilationResult);
184	parser4.getMethodBodies(unit);
185	assertDianosticEquals(expectedSyntaxErrorDiagnosis, testName, compilationResult);
186	assertParseTreeEquals(expectedUnitToString, unit.toString());
187	parser4 = null;
188	}
189	if ((parserToCheck & CHECK_COMMENT_RECORDER_PARSER) != 0) {
190	CommentRecorderParser parser5 = new CommentRecorderParser(
191	new ProblemReporter(
192	DefaultErrorHandlingPolicies.proceedWithAllProblems(),
193	options,
194	new DefaultProblemFactory(Locale.getDefault())),
195	optimizeStringLiterals);
196	compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);
197	unit = parser5.parse(sourceUnit, compilationResult);
198	parser5.getMethodBodies(unit);
199	assertDianosticEquals(expectedSyntaxErrorDiagnosis, testName, compilationResult);
200	assertParseTreeEquals(expectedUnitToString, unit.toString());
201	parser5 = null;
202	}
203	if ((parserToCheck & CHECK_SOURCE_ELEMENT_PARSER) != 0) {
204	SourceElementParser parser6 = new SourceElementParser(this,
205	new DefaultProblemFactory(Locale.getDefault()),
206	options,
207	true,
208	optimizeStringLiterals);
209	compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);
210	unit = parser6.parse(sourceUnit, compilationResult);
211	parser6.getMethodBodies(unit);
212	assertDianosticEquals(expectedSyntaxErrorDiagnosis, testName, compilationResult);
213	assertParseTreeEquals(expectedUnitToString, unit.toString());
214	parser6 = null;
215	}
216	if ((parserToCheck & CHECK_INDEXING_PARSER) != 0) {
217	IndexingParser parser7 = new IndexingParser(this,
218	new DefaultProblemFactory(Locale.getDefault()),
219	options,
220	true,
221	optimizeStringLiterals, false);
222	compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);
223	unit = parser7.parse(sourceUnit, compilationResult);
224	parser7.getMethodBodies(unit);
225	assertDianosticEquals(expectedSyntaxErrorDiagnosis, testName, compilationResult);
226	assertParseTreeEquals(expectedUnitToString, unit.toString());
227	parser7 = null;
228	}
229	}
230	public void checkParse(
231	char[] source,
232	String expectedSyntaxErrorDiagnosis,
233	String testName,
234	String expectedUnitToString) throws IOException {
235	checkParse(CHECK_ALL, source, expectedSyntaxErrorDiagnosis, testName, expectedUnitToString);
236	}
237	private void assertParseTreeEquals(String expectedUnitToString, String computedUnitToString) {
238	if (expectedUnitToString == null) { // just checking that we are able to digest.
239	return;
240	}
241	if (!expectedUnitToString.equals(computedUnitToString)) {
242	System.out.println(Util.displayString(computedUnitToString));
243	}
244	assertEquals("Parse Tree is wrong",
245	Util.convertToIndependantLineDelimiter(expectedUnitToString),
246	Util.convertToIndependantLineDelimiter(computedUnitToString));
247	}
248	private void assertDianosticEquals(String expectedSyntaxErrorDiagnosis,
249	String testName, CompilationResult compilationResult) {
250	String computedSyntaxErrorDiagnosis = getCompilerMessages(compilationResult);
251	assertEquals(
252	"Invalid syntax error diagnosis" + testName,
253	Util.convertToIndependantLineDelimiter(expectedSyntaxErrorDiagnosis),
254	Util.convertToIndependantLineDelimiter(computedSyntaxErrorDiagnosis));
255	}
256	private String getCompilerMessages(CompilationResult compilationResult) {
257	StringBuffer buffer = new StringBuffer(100);
258	if (compilationResult.hasProblems() \|\| compilationResult.hasTasks()) {
259	CategorizedProblem[] problems = compilationResult.getAllProblems();
260	int count = problems.length;
261	int problemCount = 0;
262	char[] unitSource = compilationResult.compilationUnit.getContents();
263	for (int i = 0; i < count; i++) {
264	if (problems[i] != null) {
265	if (problemCount == 0)
266	buffer.append("----------\n");
267	problemCount++;
268	buffer.append(problemCount + (problems[i].isError() ? ". ERROR" : ". WARNING"));
269	buffer.append(" in " + new String(problems[i].getOriginatingFileName()).replace('/', '\\'));
270	try {
271	buffer.append(((DefaultProblem)problems[i]).errorReportSource(unitSource));
272	buffer.append("\n");
273	buffer.append(problems[i].getMessage());
274	buffer.append("\n");
275	} catch (Exception e) {
276	}
277	buffer.append("----------\n");
278	}
279	}
280	}
281	String computedSyntaxErrorDiagnosis = buffer.toString();
282	return computedSyntaxErrorDiagnosis;
283	}
284
285	void traverse (File f) throws IOException {
286	if (f.isDirectory()) {
287	File [] files = f.listFiles();
288	for (int i = 0; i < files.length; i++) {
289	traverse(files[i]);
290	}
291	} else {
292	if (f.getName().endsWith(".java")) {
293	System.out.println(f.getCanonicalPath());
294	char [] contents = new char[(int) f.length()];
295	FileInputStream fs = new FileInputStream(f);
296	InputStreamReader isr = new InputStreamReader(fs);
297	isr.read(contents);
298	checkParse(contents, null, f.getCanonicalPath(), null);
299	}
300	}
301	}
302	public void _test000() throws IOException {
303	traverse(new File("C:\\jsr308tests"));
304	}
305
306	public void acceptImport(int declarationStart, int declarationEnd,
307	int[] javaDocPositions, char[] name, int nameStartPosition,
308	boolean onDemand, int modifiers) {
309
310
311	}
312	public void acceptInitializer(int declarationStart, int declarationEnd,
313	int[] javaDocPositions, int modifiers, int modifiersStart,
314	int bodyStart, int bodyEnd) {
315
316
317	}
318	public void acceptLineSeparatorPositions(int[] positions) {
319
320
321	}
322	public void acceptPackage(int declarationStart, int declarationEnd,
323	int[] javaDocPositions, char[] name, int nameStartPosition) {
324
325
326	}
327	public void acceptProblem(CategorizedProblem problem) {
328
329
330	}
331	public void enterClass(int declarationStart, int[] javaDocPositions,
332	int modifiers, int modifiersStart, int classStart, char[] name,
333	int nameStart, int nameEnd, char[] superclass, int superclassStart,
334	int superclassEnd, char[][] superinterfaces,
335	int[] superinterfaceStarts, int[] superinterfaceEnds, int bodyStart) {
336
337
338	}
339	public void enterCompilationUnit() {
340
341
342	}
343	public void enterConstructor(int declarationStart, int[] javaDocPositions,
344	int modifiers, int modifiersStart, char[] name, int nameStart,
345	int nameEnd, char[][] parameterTypes, int[] parameterTypeStarts,
346	int[] parameterTypeEnds, char[][] parameterNames,
347	int[] parameterNameStarts, int[] parameterNameEnds, int parametersEnd,
348	char[][] exceptionTypes, int[] exceptionTypeStarts,
349	int[] exceptionTypeEnds, int bodyStart) {
350
351
352	}
353	public void enterField(int declarationStart, int[] javaDocPositions,
354	int modifiers, int modifiersStart, char[] type, int typeStart,
355	int typeEnd, int typeDimensionCount, char[] name, int nameStart,
356	int nameEnd, int extendedTypeDimensionCount,
357	int extendedTypeDimensionEnd) {
358
359
360	}
361	public void enterInterface(int declarationStart, int[] javaDocPositions,
362	int modifiers, int modifiersStart, int interfaceStart, char[] name,
363	int nameStart, int nameEnd, char[][] superinterfaces,
364	int[] superinterfaceStarts, int[] superinterfaceEnds, int bodyStart) {
365
366
367	}
368	public void enterMethod(int declarationStart, int[] javaDocPositions,
369	int modifiers, int modifiersStart, char[] returnType,
370	int returnTypeStart, int returnTypeEnd, int returnTypeDimensionCount,
371	char[] name, int nameStart, int nameEnd, char[][] parameterTypes,
372	int[] parameterTypeStarts, int[] parameterTypeEnds,
373	char[][] parameterNames, int[] parameterNameStarts,
374	int[] parameterNameEnds, int parametersEnd,
375	int extendedReturnTypeDimensionCount,
376	int extendedReturnTypeDimensionEnd, char[][] exceptionTypes,
377	int[] exceptionTypeStarts, int[] exceptionTypeEnds, int bodyStart) {
378
379
380	}
381	public void exitClass(int bodyEnd, int declarationEnd) {
382
383
384	}
385	public void exitCompilationUnit(int declarationEnd) {
386
387
388	}
389	public void exitConstructor(int bodyEnd, int declarationEnd) {
390
391
392	}
393	public void exitField(int bodyEnd, int declarationEnd) {
394
395
396	}
397	public void exitInterface(int bodyEnd, int declarationEnd) {
398
399
400	}
401	public void exitMethod(int bodyEnd, int declarationEnd) {
402
403
404	}
405	public void acceptAnnotationTypeReference(char[][] annotation, int sourceStart,
406	int sourceEnd) {
407
408
409	}
410	public void acceptAnnotationTypeReference(char[] annotation, int sourcePosition) {
411
412
413	}
414	public void acceptConstructorReference(char[] typeName, int argCount,
415	int sourcePosition) {
416
417
418	}
419	public void acceptFieldReference(char[] fieldName, int sourcePosition) {
420
421
422	}
423	public void acceptImport(int declarationStart, int declarationEnd,
424	char[][] tokens, boolean onDemand, int modifiers) {
425
426
427	}
428	public void acceptMethodReference(char[] methodName, int argCount,
429	int sourcePosition) {
430
431
432	}
433	public void acceptPackage(ImportReference importReference) {
434
435
436	}
437	public void acceptTypeReference(char[][] typeName, int sourceStart,
438	int sourceEnd) {
439
440
441	}
442	public void acceptTypeReference(char[] typeName, int sourcePosition) {
443
444
445	}
446	public void acceptUnknownReference(char[][] name, int sourceStart, int sourceEnd) {
447
448
449	}
450	public void acceptUnknownReference(char[] name, int sourcePosition) {
451
452
453	}
454	public void enterConstructor(MethodInfo methodInfo) {
455
456
457	}
458	public void enterField(FieldInfo fieldInfo) {
459
460
461	}
462	public void enterInitializer(int declarationStart, int modifiers) {
463
464
465	}
466	public void enterMethod(MethodInfo methodInfo) {
467
468
469	}
470	public void enterType(TypeInfo typeInfo) {
471
472
473	}
474	public void exitConstructor(int declarationEnd) {
475
476
477	}
478	public void exitField(int initializationStart, int declarationEnd,
479	int declarationSourceEnd) {
480
481
482	}
483	public void exitInitializer(int declarationEnd) {
484
485
486	}
487	public void exitMethod(int declarationEnd, Expression defaultValue) {
488
489
490	}
491	public void exitType(int declarationEnd) {
492
493
494	}
495	}