/*******************************************************************************
 * Copyright (c) 2013, 2016 Jesper S Moller and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Jesper S Moller - initial API and implementation
 *     					Bug 412151 - [1.8][compiler] Check repeating annotation's collection type
 *     					Bug 412149 - [1.8][compiler] Emit repeated annotations into the designated container
 *     					Bug 419209 - [1.8] Repeating container annotations should be rejected in the presence of annotation it contains
 *		Stephan Herrmann - Contribution for
 *						Bug 419209 - [1.8] Repeating container annotations should be rejected in the presence of annotation it contains
 *******************************************************************************/
package org.eclipse.jdt.core.tests.compiler.regression;

import java.io.File;

import junit.framework.Test;

import org.eclipse.jdt.core.util.ClassFileBytesDisassembler;
import org.eclipse.jdt.internal.compiler.ASTVisitor;
import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
import org.eclipse.jdt.internal.compiler.impl.IntConstant;
import org.eclipse.jdt.internal.compiler.lookup.CompilationUnitScope;

@SuppressWarnings({ "rawtypes" })
public class RepeatableAnnotationTest extends AbstractComparableTest {

	// Static initializer to specify tests subset using TESTS_* static variables
	// All specified tests which do not belong to the class are skipped...
	static {
//		TESTS_NAMES = new String[] { "test006" };
//		TESTS_NUMBERS = new int[] { 297 };
//		TESTS_RANGE = new int[] { 294, -1 };
	}

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

	public static Test suite() {
		return buildMinimalComplianceTestSuite(testClass(), F_1_8);
	}

	public static Class testClass() {
		return RepeatableAnnotationTest.class;
	}

	// check repeated occurrence of non-repeatable annotation
	public void test001() {
		this.runNegativeTest(
			new String[] {
				"X.java",
				"public @Foo @Foo class X {\n" +
				"}\n" +
				"\n",
				"Foo.java",
				"public @interface Foo {\n" +
				"}\n"
			},
			"----------\n" + 
			"1. ERROR in X.java (at line 1)\n" + 
			"	public @Foo @Foo class X {\n" + 
			"	       ^^^^\n" + 
			"Duplicate annotation of non-repeatable type @Foo. Only annotation types marked @Repeatable can be used multiple times at one target.\n" + 
			"----------\n" + 
			"2. ERROR in X.java (at line 1)\n" + 
			"	public @Foo @Foo class X {\n" + 
			"	            ^^^^\n" + 
			"Duplicate annotation of non-repeatable type @Foo. Only annotation types marked @Repeatable can be used multiple times at one target.\n" + 
			"----------\n");
	}

	public void test002() {
		this.runConformTest(
				new String[] {
						"X.java",
						"@Foo @Foo public class X {\n" +
								"}\n" +
								"\n",
								"Foo.java",
								"@java.lang.annotation.Repeatable(FooContainer.class) public @interface Foo {\n" +
										"}\n",
										"FooContainer.java",
										"public @interface FooContainer {\n" +
												"	Foo[] value();\n" +
												"}\n"
				},
				"");
	}

	// check repeated occurrence of annotation where annotation container is not valid for the target 
	public void test003() {
		this.runNegativeTest(
			new String[] {
				"FooContainer.java",
				"import java.lang.annotation.ElementType;\n" +
				"import java.lang.annotation.Target;\n" +
				"@Target({ElementType.METHOD, ElementType.FIELD}) public @interface FooContainer {\n" +
				
				"	Foo[] value();\n" +
				"}\n",
				"Foo.java",
				"@java.lang.annotation.Repeatable(FooContainer.class) public @interface Foo {\n" +
				"}\n",
				"X.java",
				"@Foo @Foo public class X { /* Problem */\n" +
				"  @Foo @Foo void okHere() { /* No problem */\n" +
				"    @Foo @Foo int local = 0; /* Problem! */\n" +
				"  }\n" +
				"  @Foo @Foo int alsoFoo = 0; /* No problem */\n" +
				"  @Foo class Y {} /* No problem since not repeated */\n" +
				"}\n"
			},
			"----------\n" + 
			"1. ERROR in X.java (at line 1)\n" + 
			"	@Foo @Foo public class X { /* Problem */\n" + 
			"	^^^^\n" + 
			"The annotation @Foo cannot be repeated at this location since its container annotation type @FooContainer is disallowed at this location\n" + 
			"----------\n" + 
			"2. ERROR in X.java (at line 3)\n" + 
			"	@Foo @Foo int local = 0; /* Problem! */\n" + 
			"	^^^^\n" + 
			"The annotation @Foo cannot be repeated at this location since its container annotation type @FooContainer is disallowed at this location\n" + 
			"----------\n");
	}

	// This is the same test as test003, only where the annotation info for Foo is from a class file, not from the compiler
	public void test004() {
		this.runConformTest(
			new String[] {
					"FooContainer.java",
					"import java.lang.annotation.ElementType;\n" +
					"import java.lang.annotation.Target;\n" +
					"@Target({ElementType.METHOD, ElementType.FIELD}) public @interface FooContainer {\n" +
					"	Foo[] value();\n" +
					"}\n",
					"Foo.java",
					"@java.lang.annotation.Repeatable(FooContainer.class) public @interface Foo {\n" +
					"}\n"
				}, 
				"");
		this.runNegativeTest(
			new String[] {
				"X.java",
				"@Foo @Foo public class X { /* Problem */\n" +
				"}\n"
			},
			"----------\n" + 
			"1. ERROR in X.java (at line 1)\n" + 
			"	@Foo @Foo public class X { /* Problem */\n" + 
			"	^^^^\n" + 
			"The annotation @Foo cannot be repeated at this location since its container annotation type @FooContainer is disallowed at this location\n" + 
			"----------\n",
			null, false /* don't flush*/);
	}

	// Test that a single, repeatable annotation can exist just fine an occurrence of its container annotation
	public void test005() {
		this.runConformTest(
			new String[] {
				"X.java",
				"@java.lang.annotation.Repeatable(FooContainer.class) @interface Foo {}\n" +
				"@interface FooContainer { Foo[] value(); }\n" +
				"@Foo @FooContainer({@Foo, @Foo}) public class X { /* Not a problem */ }\n"
			}, 
			"");
	}

	// Test that an repeated annotation can't occur together with its container annotation
	public void test006() {
		this.runNegativeTest(
			new String[] {
				"X.java",
				"@interface FooContainer { Foo[] value(); }\n" +
				"@java.lang.annotation.Repeatable(FooContainer.class) @interface Foo {}\n" +
				"@Foo @Foo @FooContainer({@Foo, @Foo}) public class X { /* A problem */ }\n"
			}, 
			"----------\n" + 
			"1. ERROR in X.java (at line 3)\n" + 
			"	@Foo @Foo @FooContainer({@Foo, @Foo}) public class X { /* A problem */ }\n" + 
			"	^^^^\n" + 
			"The repeatable annotation @Foo may not be repeated where its container annotation type @FooContainer is also used directly\n" + 
			"----------\n");
	}

	// Test that an repeated annotation can't occur together with its container annotation, even if it itself is repeatable.
	public void test007() {
		this.runNegativeTest(
			new String[] {
				"X.java",
				"@interface FooContainerContainer { FooContainer[] value(); }\n" +
				"@java.lang.annotation.Repeatable(FooContainerContainer.class) @interface FooContainer { Foo[] value(); }\n" +
				"@java.lang.annotation.Repeatable(FooContainer.class) @interface Foo {}\n" +
				"@Foo @Foo @FooContainer({@Foo, @Foo}) public class X { /* Still a problem */ }\n"
			}, 
			"----------\n" + 
			"1. ERROR in X.java (at line 4)\n" + 
			"	@Foo @Foo @FooContainer({@Foo, @Foo}) public class X { /* Still a problem */ }\n" + 
			"	^^^^\n" + 
			"The repeatable annotation @Foo may not be repeated where its container annotation type @FooContainer is also used directly\n" + 
			"----------\n");
	}
	
	// Test that an repeated annotation can't occur together with its container annotation, even if it itself is repeatable.
	public void test007a() {
		this.runNegativeTest(
			new String[] {
				"X.java",
				"@interface FooContainerContainer { FooContainer[] value(); }\n" +
				"@java.lang.annotation.Repeatable(FooContainerContainer.class) @interface FooContainer { Foo[] value(); }\n" +
				"@java.lang.annotation.Repeatable(FooContainer.class) @interface Foo {}\n" +
				"@interface Bar {}\n" +
				"@Foo @Foo @Bar @Bar @FooContainer({@Foo, @Foo}) public class X { /* Still a problem */ }\n"
			}, 
			"----------\n" + 
			"1. ERROR in X.java (at line 5)\n" + 
			"	@Foo @Foo @Bar @Bar @FooContainer({@Foo, @Foo}) public class X { /* Still a problem */ }\n" + 
			"	^^^^\n" + 
			"The repeatable annotation @Foo may not be repeated where its container annotation type @FooContainer is also used directly\n" + 
			"----------\n" + 
			"2. ERROR in X.java (at line 5)\n" + 
			"	@Foo @Foo @Bar @Bar @FooContainer({@Foo, @Foo}) public class X { /* Still a problem */ }\n" + 
			"	          ^^^^\n" + 
			"Duplicate annotation of non-repeatable type @Bar. Only annotation types marked @Repeatable can be used multiple times at one target.\n" + 
			"----------\n" + 
			"3. ERROR in X.java (at line 5)\n" + 
			"	@Foo @Foo @Bar @Bar @FooContainer({@Foo, @Foo}) public class X { /* Still a problem */ }\n" + 
			"	               ^^^^\n" + 
			"Duplicate annotation of non-repeatable type @Bar. Only annotation types marked @Repeatable can be used multiple times at one target.\n" + 
			"----------\n");
	}

	// Test that repeated annotations should be contiguous (raises a warning if not) -- not yet in BETA_JAVA8
	public void _test008() {
		this.runNegativeTest(
			new String[] {
				"X.java",
				"@interface Bar {}\n" +
				"@interface Baz {}\n" +
				"@java.lang.annotation.Repeatable(FooContainer.class) @interface Foo {}\n" +
				"@interface FooContainer { Foo[] value(); }\n" +
				"@Foo @Bar @Foo /* just lexical */ @Foo public class X { /* Gives a warning */ }\n"
			}, 
			"----------\n" + 
			"1. WARNING in X.java (at line 5)\n" + 
			"	@Foo @Bar @Foo /* just lexical */ @Foo public class X { /* Gives a warning */ }\n" + 
			"	          ^^^^\n" + 
			"Repeated @Foo annotations are not grouped together\n" + 
			"----------\n");
	}
	// Test that deprecation of container annotation is reflected in the repeated annotation (disabled until specification clarification is available)
	public void _test009() {
		this.runConformTest(
			new String[] {
				"Y.java",
				"@java.lang.annotation.Repeatable(FooContainer.class) @interface Foo { int value(); }\n" +
				"@Deprecated @interface FooContainer { Foo[] value(); }\n" +
				"@Foo(0) class X { /* Gives a warning */ }\n" + 
				"@Foo(1) @Foo(2) public class Y { /* Gives a warning */ }\n"
			}, 
			new ASTVisitor() {
				public boolean visit(
						TypeDeclaration typeDeclaration,
						CompilationUnitScope scope) {
						if (new String(typeDeclaration.name).equals("X")) {
							assertFalse("Foo on X should NOT be deprecated!", typeDeclaration.annotations[0].getCompilerAnnotation().getAnnotationType().isDeprecated());
						}
						if (new String(typeDeclaration.name).equals("Y")) {
							assertEquals("Find Foo(1) on Y",  IntConstant.fromValue(1), typeDeclaration.annotations[0].getCompilerAnnotation().getElementValuePairs()[0].value);
							assertTrue("1st Foo on Y should be deprecated!", typeDeclaration.annotations[0].getCompilerAnnotation().getAnnotationType().isDeprecated());
							assertEquals("Find Foo(2) on Y",  IntConstant.fromValue(2), typeDeclaration.annotations[1].getCompilerAnnotation().getElementValuePairs()[0].value);
							assertTrue("2nd Foo on Y should be deprecated!", typeDeclaration.annotations[1].getCompilerAnnotation().getAnnotationType().isDeprecated());
						}
						return true; // do nothing by default, keep traversing
					}
			});
	}
	// Bug 412151: [1.8][compiler] Check repeating annotation's collection type
	// 412151: The collections type's (TC) declaration must have a array of Ts as its value() - with Foo and FooContainer in same compilation round
	public void test010() {
		this.runNegativeTest(
			new String[] {
			"Foo.java",
			"@interface FooContainer {\n" +
			"}\n" +
			"@java.lang.annotation.Repeatable(FooContainer.class)\n" +
			"@interface Foo {}\n"
			}, 
		"----------\n" + 
		"1. ERROR in Foo.java (at line 3)\n" + 
		"	@java.lang.annotation.Repeatable(FooContainer.class)\n" + 
		"	                                 ^^^^^^^^^^^^^^^^^^\n" + 
		"The container annotation type @FooContainer must declare a member value()\n" + 
		"----------\n");
	}
	// 412151: The collections type's (TC) declaration must have a array of Ts as its value() - with Foo and FooContainer in same compilation round
	public void test011() {
		this.runNegativeTest(
			new String[] {
			"Foo.java",
			"@interface FooContainer {\n" +
			"    int[] value();\n" +
			"}\n" +
			"@java.lang.annotation.Repeatable(FooContainer.class)\n" +
			"@interface Foo {}\n"
			}, 
		"----------\n" + 
		"1. ERROR in Foo.java (at line 4)\n" + 
		"	@java.lang.annotation.Repeatable(FooContainer.class)\n" + 
		"	                                 ^^^^^^^^^^^^^^^^^^\n" + 
		"The value method in the container annotation type @FooContainer must be of type Foo[] but is int[]\n" + 
		"----------\n");
	}
	// 412151: The collections type's (TC) declaration must have a array of Ts as its value() - with Foo and FooContainer in same compilation round
	public void test012() {
		this.runNegativeTest(
			new String[] {
				"Foo.java",
				"@interface FooContainer {\n" +
				"    Foo[][] value();\n" +
				"}\n" +
				"@java.lang.annotation.Repeatable(FooContainer.class)\n" +
				"@interface Foo {}\n"
			},
			"----------\n" + 
			"1. ERROR in Foo.java (at line 2)\n" + 
			"	Foo[][] value();\n" + 
			"	^^^^^^^\n" + 
			"Invalid type Foo[][] for the annotation attribute FooContainer.value; only primitive type, String, Class, annotation, enumeration are permitted or 1-dimensional arrays thereof\n" + 
			"----------\n" + 
			"2. ERROR in Foo.java (at line 4)\n" + 
			"	@java.lang.annotation.Repeatable(FooContainer.class)\n" + 
			"	                                 ^^^^^^^^^^^^^^^^^^\n" + 
			"The value method in the container annotation type @FooContainer must be of type Foo[] but is Foo[][]\n" + 
			"----------\n"
		);
	}
	// 412151: Any methods declared by TC other than value() have a default value (JLS 9.6.2).
	public void test013() {
		this.runNegativeTest(
			new String[] {
				"Foo.java",
				"@interface FooContainer {\n" +
				"    Foo[] value();\n" +
				"    int hasDefaultValue() default 1337;\n" +
				"    int doesntHaveDefaultValue();\n" +
				"}\n" +
				"@java.lang.annotation.Repeatable(FooContainer.class)\n" +
				"@interface Foo {}\n"
			}, 
		"----------\n" + 
		"1. ERROR in Foo.java (at line 6)\n" + 
		"	@java.lang.annotation.Repeatable(FooContainer.class)\n" + 
		"	                                 ^^^^^^^^^^^^^^^^^^\n" + 
		"The container annotation type @FooContainer must declare a default value for the annotation attribute \'doesntHaveDefaultValue\'\n" + 
		"----------\n");
	}
	// 412151: The @Retention meta-annotation of TC must at least include the retention of T ()
	public void test014() {
		this.runConformTest(
			new String[] {
				"Foo.java",
				"import java.lang.annotation.Retention;\n" + 
				"import java.lang.annotation.RetentionPolicy;\n" + 
				"@Retention(RetentionPolicy.CLASS)\n" +
				"@interface FooContainer {\n" +
				"    Foo[] value();\n" +
				"}\n" +
				"@java.lang.annotation.Repeatable(FooContainer.class)\n" +
				"@Retention(RetentionPolicy.CLASS)\n" +
				"@interface Foo {\n" +
				"}\n"
			}, 
		"");
	}

	// 
	public void test015() {
		// These are fine:
		this.runConformTest(
			new String[] {
					"FooContainer.java",
					"public @interface FooContainer {\n" +
					"	Foo[] value();\n" +
					"}\n",
					"Foo.java",
					"@java.lang.annotation.Repeatable(FooContainer.class) public @interface Foo {\n" +
					"}\n"
				}, 
				"");
		// This changes FooContainer without re-checking Foo
		this.runConformTest(
				new String[] {
						"FooContainer.java",
						"public @interface FooContainer {\n" +
						"	int[] value();\n" +
						"}\n"
					},
					"",
					null,
					false,
					null);
		this.runNegativeTest(
			new String[] {
				"X.java",
				"@Foo @Foo public class X { /* Problem since Foo now uses FooContainer which doesn't work anymore*/\n" +
				"}\n"
			},
			"----------\n" + 
			"1. ERROR in X.java (at line 1)\n" + 
			"	@Foo @Foo public class X { /* Problem since Foo now uses FooContainer which doesn\'t work anymore*/\n" + 
			"	^^^^\n" + 
			"The value method in the container annotation type @FooContainer must be of type Foo[] but is int[]\n" + 
			"----------\n",
			null, false /* don't flush*/);
	}

	// 412151: The @Retention meta-annotation of TC must at least include the retention of T ()
	// Base example, both targets are specified
	public void test016() {
		this.runNegativeTest(
			new String[] {
				"Foo.java",
				"import java.lang.annotation.Retention;\n" + 
				"import java.lang.annotation.RetentionPolicy;\n" + 
				"@Retention(RetentionPolicy.SOURCE)\n" +
				"@interface FooContainer { Foo[] value(); }\n" +
				"@java.lang.annotation.Repeatable(FooContainer.class)\n" +
				"@Retention(RetentionPolicy.RUNTIME)\n" +
				"@interface Foo { }\n"
			}, 
		"----------\n" + 
		"1. ERROR in Foo.java (at line 5)\n" + 
		"	@java.lang.annotation.Repeatable(FooContainer.class)\n" + 
		"	                                 ^^^^^^^^^^^^^^^^^^\n" + 
		"Retention \'RUNTIME\' of @Foo is longer than the retention of its container annotation type @FooContainer, which is \'SOURCE\'\n" + 
		"----------\n");
	}

	// 412151: The @Retention meta-annotation of TC must at least include the retention of T ()
	// Only specified on FooContainer
	public void test017() {
		this.runNegativeTest(
			new String[] {
				"Foo.java",
				"import java.lang.annotation.Retention;\n" + 
				"import java.lang.annotation.RetentionPolicy;\n" + 
				"@Retention(RetentionPolicy.SOURCE)\n" +
				"@interface FooContainer { Foo[] value(); }\n" +
				"@java.lang.annotation.Repeatable(FooContainer.class)\n" +
				"@interface Foo { }\n"
			}, 
		"----------\n" + 
		"1. ERROR in Foo.java (at line 5)\n" + 
		"	@java.lang.annotation.Repeatable(FooContainer.class)\n" + 
		"	                                 ^^^^^^^^^^^^^^^^^^\n" + 
		"Retention \'CLASS\' of @Foo is longer than the retention of its container annotation type @FooContainer, which is \'SOURCE\'\n" + 
		"----------\n");
	}

	// 412151: The @Retention meta-annotation of TC must at least include the retention of T ()
	// Only specified on Foo
	public void test018() {
		this.runNegativeTest(
			new String[] {
				"Foo.java",
				"import java.lang.annotation.Retention;\n" + 
				"import java.lang.annotation.RetentionPolicy;\n" + 
				"@interface FooContainer { Foo[] value(); }\n" +
				"@java.lang.annotation.Repeatable(FooContainer.class)\n" +
				"@Retention(RetentionPolicy.RUNTIME)\n" +
				"@interface Foo { }\n"
			}, 
		"----------\n" + 
		"1. ERROR in Foo.java (at line 4)\n" + 
		"	@java.lang.annotation.Repeatable(FooContainer.class)\n" + 
		"	                                 ^^^^^^^^^^^^^^^^^^\n" + 
		"Retention \'RUNTIME\' of @Foo is longer than the retention of its container annotation type @FooContainer, which is \'CLASS\'\n" + 
		"----------\n");
	}

	// 412151: The @Retention meta-annotation of TC must at least include the retention of T ()
	// Only specified on Foo - but positive
	public void test019() {
		this.runConformTest(
			new String[] {
				"Foo.java",
				"import java.lang.annotation.Retention;\n" + 
				"import java.lang.annotation.RetentionPolicy;\n" + 
				"@interface FooContainer { Foo[] value(); }\n" +
				"@java.lang.annotation.Repeatable(FooContainer.class)\n" +
				"@Retention(RetentionPolicy.SOURCE)\n" +
				"@interface Foo { }\n"
			});
	}

	// 412151: The @Retention meta-annotation of TC must at least include the retention of T
	// Only specified on FooContainer, separate compilation
	public void test020() {
		this.runConformTest(
			new String[] {
					"FooContainer.java",
					"import java.lang.annotation.Retention;\n" + 
					"import java.lang.annotation.RetentionPolicy;\n" + 
					"@Retention(RetentionPolicy.SOURCE)\n" +
					"public @interface FooContainer { Foo[] value(); }\n",
					"Foo.java",
					"import java.lang.annotation.Retention;\n" + 
					"import java.lang.annotation.RetentionPolicy;\n" + 
					"@Retention(RetentionPolicy.SOURCE)\n" +
					"@java.lang.annotation.Repeatable(FooContainer.class)\n" +
					"public @interface Foo { }\n"
				});
		this.runNegativeTest(
			new String[] {
				"Foo.java",
				"@java.lang.annotation.Repeatable(FooContainer.class)\n" +
				"public @interface Foo { } // If omitted, retention is class\n"
			}, 
		"----------\n" + 
		"1. ERROR in Foo.java (at line 1)\n" + 
		"	@java.lang.annotation.Repeatable(FooContainer.class)\n" + 
		"	                                 ^^^^^^^^^^^^^^^^^^\n" + 
		"Retention \'CLASS\' of @Foo is longer than the retention of its container annotation type @FooContainer, which is \'SOURCE\'\n" + 
		"----------\n",
		null, false /* don't flush*/);
	}

	// 412151: The @Retention meta-annotation of TC must at least include the retention of T ()
	// Only specified on Foo, separate compilation
	public void test021() {
		this.runConformTest(
			new String[] {
				"FooContainer.java",
				"import java.lang.annotation.Retention;\n" + 
				"import java.lang.annotation.RetentionPolicy;\n" + 
				"public @interface FooContainer { Foo[] value(); }\n",
				"Foo.java",
				"import java.lang.annotation.Retention;\n" + 
				"import java.lang.annotation.RetentionPolicy;\n" + 
				"@java.lang.annotation.Repeatable(FooContainer.class)\n" +
				"public @interface Foo { }\n"
			});
		this.runNegativeTest(
			new String[] {
				"Foo.java",
				"import java.lang.annotation.Retention;\n" + 
				"import java.lang.annotation.RetentionPolicy;\n" + 
				"@java.lang.annotation.Repeatable(FooContainer.class)\n" +
				"@Retention(RetentionPolicy.RUNTIME)\n" +
				"@interface Foo { }\n"
			}, 
		"----------\n" + 
		"1. ERROR in Foo.java (at line 3)\n" + 
		"	@java.lang.annotation.Repeatable(FooContainer.class)\n" + 
		"	                                 ^^^^^^^^^^^^^^^^^^\n" + 
		"Retention \'RUNTIME\' of @Foo is longer than the retention of its container annotation type @FooContainer, which is \'CLASS\'\n" + 
		"----------\n",
		null, false /* don't flush*/);
	}

	// 412151: TC's @Targets, if specified, must be a subset or the same as T's @Targets
	// TC's @Targets, if specified, must be a subset or the same as T's @Targets. Simple test
	public void test022() {
		this.runNegativeTest(
			new String[] {
				"FooContainer.java",
				"import java.lang.annotation.Target;\n" + 
				"import java.lang.annotation.ElementType;\n" + 
				"public @Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD})\n" +
				"@interface FooContainer { Foo[] value(); }\n",
				"Foo.java",
				"import java.lang.annotation.Target;\n" + 
				"import java.lang.annotation.ElementType;\n" + 
				"public @java.lang.annotation.Repeatable(FooContainer.class)\n" +
				"@Target({ElementType.FIELD})\n" +
				"@interface Foo { }\n"
			},
		"----------\n" + 
		"1. ERROR in Foo.java (at line 3)\n" + 
		"	public @java.lang.annotation.Repeatable(FooContainer.class)\n" + 
		"	                                        ^^^^^^^^^^^^^^^^^^\n" + 
		"The container annotation type @FooContainer is allowed at targets where the repeatable annotation type @Foo is not: TYPE, METHOD\n" + 
		"----------\n");
	}

	// 412151: TC's @Targets, if specified, must be a subset or the same as T's @Targets
	// TC's @Targets, if specified, must be a subset or the same as T's @Targets. Test this as a separate pass, so that
	// FooContainer is loaded from binary.
	public void test023() {
		this.runConformTest(
			new String[] {
				"FooContainer.java",
				"import java.lang.annotation.Target;\n" + 
				"import java.lang.annotation.ElementType;\n" + 
				"public @Target({ElementType.METHOD})\n" +
				"@interface FooContainer { Foo[] value(); }\n",
				"Foo.java",
				"import java.lang.annotation.Target;\n" + 
				"import java.lang.annotation.ElementType;\n" + 
				"public @Target({ElementType.METHOD})\n" +
				"@interface Foo { }\n"
			});
		this.runNegativeTest(
			new String[] {
				"Foo.java",
				"import java.lang.annotation.Target;\n" + 
				"import java.lang.annotation.ElementType;\n" + 
				"public @java.lang.annotation.Repeatable(FooContainer.class)\n" +
				"@java.lang.annotation.Target({ElementType.FIELD})\n" +
				"@interface Foo { }\n"
			}, 
		"----------\n" + 
		"1. ERROR in Foo.java (at line 3)\n" + 
		"	public @java.lang.annotation.Repeatable(FooContainer.class)\n" + 
		"	                                        ^^^^^^^^^^^^^^^^^^\n" + 
		"The container annotation type @FooContainer is allowed at targets where the repeatable annotation type @Foo is not: METHOD\n" + 
		"----------\n",
		null, false /* don't flush*/);
	}

	// 412151: TC's @Targets, if specified, must be a subset or the same as T's @Targets
	// TC's may target ANNOTATION_TYPE but that should match TYPE for T, since it's a superset
	public void test024() {
		this.runConformTest(
			new String[] {
				"FooContainer.java",
				"import java.lang.annotation.ElementType;\n" + 
				"@java.lang.annotation.Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})\n" +
				"@interface FooContainer { Foo[] value(); }\n",
				"Foo.java",
				"import java.lang.annotation.ElementType;\n" + 
				"@java.lang.annotation.Repeatable(FooContainer.class)\n" +
				"@java.lang.annotation.Target({ElementType.METHOD, ElementType.TYPE})\n" +
				"@interface Foo { }\n"
			});
	}

	// 412151: TC's @Targets, if specified, must be a subset or the same as T's @Targets
	// Test that all ElementTypes can be reported
	public void test025() {
		this.runNegativeTest(
			new String[] {
				"FooContainer.java",
				"import java.lang.annotation.Target;\n" + 
				"import java.lang.annotation.ElementType;\n" + 
				"public @Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.CONSTRUCTOR, ElementType.LOCAL_VARIABLE, ElementType.ANNOTATION_TYPE, ElementType.PACKAGE, ElementType.TYPE_PARAMETER, ElementType.TYPE_USE})\n" +
				"@interface FooContainer { Foo[] value(); }\n",
				"Foo.java",
				"import java.lang.annotation.Target;\n" + 
				"import java.lang.annotation.ElementType;\n" + 
				"public @java.lang.annotation.Repeatable(FooContainer.class)\n" +
				"@Target({})\n" +
				"@interface Foo { }\n"
			},
		"----------\n" + 
		"1. ERROR in Foo.java (at line 3)\n" + 
		"	public @java.lang.annotation.Repeatable(FooContainer.class)\n" + 
		"	                                        ^^^^^^^^^^^^^^^^^^\n" + 
		"The container annotation type @FooContainer is allowed at targets where the repeatable annotation type @Foo is not: TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, ANNOTATION_TYPE, PACKAGE, TYPE_PARAMETER, TYPE_USE\n" + 
		"----------\n");
	}

	// 412151: TC's @Targets, if specified, must be a subset or the same as T's @Targets
	// TC's has no @Targets (=every SE7 location), but @Foo has, then complain.
	public void test026() {
		this.runConformTest(
			new String[] {
				"FooContainer.java",
				"@interface FooContainer { Foo[] value(); }\n",
				"Foo.java",
				"@interface Foo { }\n"
			});
		this.runNegativeTest(
			new String[] {
				"Foo.java",
				"import java.lang.annotation.Target;\n" + 
				"import java.lang.annotation.ElementType;\n" + 
				"@java.lang.annotation.Repeatable(FooContainer.class)\n" +
				"@java.lang.annotation.Target({ElementType.FIELD})\n" +
				"@interface Foo { }\n"
			}, 
			"----------\n" + 
			"1. ERROR in Foo.java (at line 3)\n" + 
			"	@java.lang.annotation.Repeatable(FooContainer.class)\n" + 
			"	                                 ^^^^^^^^^^^^^^^^^^\n" + 
			"The container annotation type @FooContainer is allowed at targets where the repeatable annotation type @Foo is not: TYPE, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, ANNOTATION_TYPE, PACKAGE\n" + 
			"----------\n",
		null, false /* don't flush*/);
	}

	// 412151: If T is @Documented, then TC should also be Documented
	public void test027() {
		this.runConformTest(
			new String[] {
				"FooContainer.java",
				"@java.lang.annotation.Documented @interface FooContainer { Foo[] value(); }\n",
				"Foo.java",
				"@java.lang.annotation.Documented @interface Foo { }\n"});
	}
	
	// 412151: If T is @Documented, then TC should also be Documented, OK for TC to be documented while T is not
	public void test028() {
		this.runConformTest(
			new String[] {
				"FooContainer.java",
				"@java.lang.annotation.Documented @interface FooContainer { Foo[] value(); }\n",
				"Foo.java",
				"@interface Foo { }\n"});
	}

	// 412151: If T is @Documented, then TC should also be Documented
	public void test029() {
		this.runNegativeTest(
			new String[] {
				"FooContainer.java",
				"@interface FooContainer { Foo[] value(); }\n",
				"Foo.java",
				"@java.lang.annotation.Repeatable(FooContainer.class) @java.lang.annotation.Documented\n" +
				"@interface Foo { }\n"
			}, 
			"----------\n" + 
			"1. ERROR in Foo.java (at line 1)\n" + 
			"	@java.lang.annotation.Repeatable(FooContainer.class) @java.lang.annotation.Documented\n" + 
			"	                                 ^^^^^^^^^^^^^^^^^^\n" + 
			"The repeatable annotation type @Foo is marked @Documented, but its container annotation type @FooContainer is not\n" + 
			"----------\n");
	}

	// 412151: If T is @Documented, then TC should also be Documented - check from previous compilation
	public void test030() {
		this.runConformTest(
				new String[] {
					"FooContainer.java",
					"@java.lang.annotation.Documented @interface FooContainer { Foo[] value(); }\n",
					"Foo.java",
					"@java.lang.annotation.Documented @interface Foo { }\n"
				});
			this.runConformTest(
				new String[] {
					"Foo.java",
					"public @java.lang.annotation.Documented @java.lang.annotation.Repeatable(FooContainer.class)\n" +
					"@interface Foo { }\n"
				},
				"",
				null,
				false,
				null);
	}

	// 412151: If T is @Inherited, then TC should also be Inherited
	public void test031() {
		this.runConformTest(
			new String[] {
				"FooContainer.java",
				"@java.lang.annotation.Inherited @interface FooContainer { Foo[] value(); }\n",
				"Foo.java",
				"@java.lang.annotation.Inherited @interface Foo { }\n"});
	}

	// 412151: If T is @Inherited, then TC should also be Inherited, OK for TC to be inherited while T is not.
	public void test032() {
		this.runConformTest(
			new String[] {
				"FooContainer.java",
				"@java.lang.annotation.Inherited @interface FooContainer { Foo[] value(); }\n",
				"Foo.java",
				"@interface Foo { }\n"});
	}
	// 412151: If T is @Inherited, then TC should also be Inherited
	public void test033() {
		this.runNegativeTest(
			new String[] {
				"FooContainer.java",
				"@interface FooContainer { Foo[] value(); }\n",
				"Foo.java",
				"@java.lang.annotation.Repeatable(FooContainer.class) @java.lang.annotation.Inherited\n" +
				"@interface Foo { }\n"
			}, 
			"----------\n" + 
			"1. ERROR in Foo.java (at line 1)\n" + 
			"	@java.lang.annotation.Repeatable(FooContainer.class) @java.lang.annotation.Inherited\n" + 
			"	                                 ^^^^^^^^^^^^^^^^^^\n" + 
			"The repeatable annotation type @Foo is marked @Inherited, but its container annotation type @FooContainer is not\n" + 
			"----------\n");
	}

	// 412151: If T is @Inherited, then TC should also be Inherited - check from previous compilation
	public void test034() {
		this.runConformTest(
				new String[] {
					"FooContainer.java",
					"@java.lang.annotation.Inherited @interface FooContainer { Foo[] value(); }\n",
					"Foo.java",
					"@java.lang.annotation.Inherited @interface Foo { }\n"
				});
			this.runConformTest(
				new String[] {
					"Foo.java",
					"public @java.lang.annotation.Inherited @java.lang.annotation.Repeatable(FooContainer.class)\n" +
					"@interface Foo { }\n"
				},
				"",
				null,
				false,
				null);
	}
	// 412151: Ensure no double reporting for bad target.
	public void test035() {
		this.runNegativeTest(
			new String[] {
				"X.java",
				"import java.lang.annotation.ElementType;\n" +
				"import java.lang.annotation.Repeatable;\n" +
				"import java.lang.annotation.Target;\n" +
				"@Target(ElementType.FIELD)\n" +
				"@interface TC {\n" +
				"	T [] value();\n" +
				"}\n" +
				"@Target(ElementType.TYPE)\n" +
				"@Repeatable(TC.class)\n" +
				"@interface T {\n" +
				"}\n" +
				"@T @T // we used to double report here.\n" +
				"public class X { \n" +
				"	X f;\n" +
				"}\n"
			}, 
			"----------\n" + 
			"1. ERROR in X.java (at line 9)\n" + 
			"	@Repeatable(TC.class)\n" + 
			"	            ^^^^^^^^\n" + 
			"The container annotation type @TC is allowed at targets where the repeatable annotation type @T is not: FIELD\n" + 
			"----------\n" + 
			"2. ERROR in X.java (at line 12)\n" + 
			"	@T @T // we used to double report here.\n" + 
			"	^^\n" + 
			"The annotation @T cannot be repeated at this location since its container annotation type @TC is disallowed at this location\n" + 
			"----------\n");
	}	
	// 412149: [1.8][compiler] Emit repeated annotations into the designated container
	public void test036() {
		this.runConformTest(
			new String[] {
				"X.java",
				"import java.lang.annotation.Repeatable;\n" +
				"import java.lang.annotation.Retention;\n" +
				"import static java.lang.annotation.RetentionPolicy.*;\n" +
				"\n" +
				"@Retention(RUNTIME)\n" +
				"@interface AttrContainer {\n" +
				"  public Attr[] value();\n" +
				"}\n" +
				"@Retention(RUNTIME)\n" +
				"@Repeatable(AttrContainer.class)\n" + 
				"@interface Attr {\n" +
				"  public int value() default -1;\n" +
				"}\n" +
				"\n" +
				"@Attr(1) @Attr(2)\n" +
				"public class X {\n" +
				"  public static void main(String args[]) {\n" +
				"  	Object e[] = X.class.getAnnotationsByType(Attr.class);\n" +
				"  	for (int i=0; i<e.length;++i) System.out.print(e[i] + \" \");\n" +
				"  }\n" +
				"}"
			},
			"@Attr(value=1) @Attr(value=2)");
		
	}
	// 412149: [1.8][compiler] Emit repeated annotations into the designated container
	// Test that only repetitions go into the container 
	public void test037() {
		this.runConformTest(
			new String[] {
				"X.java",
				"import java.lang.annotation.Repeatable;\n" +
				"import java.lang.annotation.Retention;\n" +
				"import static java.lang.annotation.RetentionPolicy.*;\n" +
				"\n" +
				"@Retention(RUNTIME)\n" +
				"@interface AttrContainer {\n" +
				"  public Attr[] value();\n" +
				"}\n" +
				"@Retention(RUNTIME)\n" +
				"@Repeatable(AttrContainer.class)\n" + 
				"@interface Attr {\n" +
				"  public int value() default -1;\n" +
				"}\n" +
				"\n" +
				"public class X {\n" +
				"  @Attr(1) class Y1 {}\n" +
				"  @Attr(1) @Attr(2) class Y2 {} \n" +
				"  public static void main(String args[]) {\n" +
				"  	System.out.println(\"Y1: \" + Y1.class.getAnnotation(Attr.class));\n" +
				"  	System.out.println(\"Y2: \" + Y2.class.getAnnotation(Attr.class));\n" +
				"  	System.out.println(\"Y1: \" + Y1.class.getAnnotation(AttrContainer.class));\n" +
				"  	System.out.println(\"Y2: \" + Y2.class.getAnnotation(AttrContainer.class));\n" +
				"  }\n" +
				"}"
			},
			"Y1: @Attr(value=1)\n" + 
			"Y2: null\n" + 
			"Y1: null\n" + 
			"Y2: @AttrContainer(value=[@Attr(value=1), @Attr(value=2)])");
		
	}
	// 412149: [1.8][compiler] Emit repeated annotations into the designated container
	// Test that the retention from the containing annotation is used
	public void test038() {
		this.runConformTest(
			new String[] {
				"X.java",
				"import java.lang.annotation.Repeatable;\n" +
				"import java.lang.annotation.Retention;\n" +
				"import static java.lang.annotation.RetentionPolicy.*;\n" +
				"\n" +
				"@Retention(RUNTIME)\n" +
				"@interface AttrContainer {\n" +
				"  public Attr[] value();\n" +
				"}\n" +
				"@Retention(SOURCE)\n" +
				"@Repeatable(AttrContainer.class)\n" + 
				"@interface Attr {\n" +
				"  public int value() default -1;\n" +
				"}\n" +
				"\n" +
				"public class X {\n" +
				"  @Attr(1) class Y1 {}\n" +
				"  @Attr(1) @Attr(2) class Y2 {} \n" +
				"  public static void main(String args[]) {\n" +
				"  	System.out.println(\"Y1 has \" + Y1.class.getAnnotationsByType(Attr.class).length);\n" +
				"  	System.out.println(\"Y2 has \" + Y2.class.getAnnotationsByType(Attr.class).length);\n" +
				"  }\n" +
				"}"
			},
			"Y1 has 0\n" + 
			"Y2 has 2");
		
	}
	// 412149: [1.8][compiler] Emit repeated annotations into the designated container
	// Test that repeated annotations can appear at package targets
	public void test039() throws Exception {
		String[] testFiles = {
				"repeatable/Main.java",
				"package repeatable;\n" +
				"public class Main {\n" +
				"    public static void main (String[] argv) {\n" + 
				"    };\n" +
				"}",

			"repeatable/FooContainer.java",
			"package repeatable;\n" +
			"@java.lang.annotation.Target(java.lang.annotation.ElementType.PACKAGE)\n" +
			"@java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy.RUNTIME)\n" +
			"public @interface FooContainer {\n" +
			"	Foo[] value();\n" +
			"}\n",

			"repeatable/Foo.java",
			"package repeatable;\n" +
			"@java.lang.annotation.Repeatable(FooContainer.class)\n" + 
			"public @interface Foo {}\n",

			"repeatable/package-info.java",
			"@Foo @Foo\n" +
			"package repeatable;\n" +
			"import repeatable.Foo;",
		};
		runConformTest(testFiles, "");
		String expectedOutout = 
				"  RuntimeVisibleAnnotations: \n" + 
				"    #8 @repeatable.FooContainer(\n" + 
				"      #9 value=[\n" + 
				"        annotation value =\n" + 
				"            #10 @repeatable.Foo(\n" + 
				"            )\n" + 
				"        annotation value =\n" + 
				"            #10 @repeatable.Foo(\n" + 
				"            )\n" + 
				"        ]\n" + 
				"    )\n";
		checkDisassembledClassFile(OUTPUT_DIR + File.separator + "repeatable" + File.separator + "package-info.class", "package-info", expectedOutout, ClassFileBytesDisassembler.SYSTEM);
	}
	// 412149: [1.8][compiler] Emit repeated annotations into the designated container
	// Test that repeated annotations show up on fields, methods, and parameters
	public void test040() {
		this.runConformTest(
			new String[] {
				"X.java",
				"import java.lang.reflect.Field;\n" + 
				"import java.lang.reflect.Method;\n" + 
				"import java.lang.reflect.Parameter;\n" + 
				"import java.lang.annotation.Repeatable;\n" +
				"import java.lang.annotation.Retention;\n" +
				"import static java.lang.annotation.RetentionPolicy.*;\n" +
				"\n" +
				"@Retention(RUNTIME)\n" +
				"@interface AttrContainer {\n" +
				"  public Attr[] value();\n" +
				"}\n" +
				"@Retention(RUNTIME)\n" +
				"@Repeatable(AttrContainer.class)\n" + 
				"@interface Attr {\n" +
				"  public int value() default -1;\n" +
				"}\n" +
				"\n" +
				"public class X {\n" +
				"   @Attr(1) @Attr(2) public int field;\n" + 
				"\n" + 
				"   @Attr(3) @Attr(4)\n" + 
				"   public static void main(@Attr(5) @Attr(6) String args[]) throws Exception {\n" + 
				"    Field fieldField = X.class.getField(\"field\");\n" + 
				"    dump(fieldField.getAnnotationsByType(Attr.class));\n" + 
				"    Method mainMethod = X.class.getMethod(\"main\", (new String[0]).getClass());\n" + 
				"    dump(mainMethod.getAnnotationsByType(Attr.class));\n" + 
				"    Parameter argvParameter = mainMethod.getParameters()[0];\n" + 
				"    dump(argvParameter.getAnnotationsByType(Attr.class));\n" + 
				"   }\n" + 
				"   static void dump(Attr[] attrs) {\n" + 
				"    for (int i=0; i<attrs.length;++i) System.out.print(attrs[i] + \" \");\n" + 
				"   }\n" +
				"}"
			},
			"@Attr(value=1) @Attr(value=2) @Attr(value=3) @Attr(value=4) @Attr(value=5) @Attr(value=6)");
	}
	// Test that repeated annotations show up type parameters properly.
	public void testTypeParameters() {
		this.runConformTest(
			new String[] {
				"X.java",
				"import java.lang.annotation.Annotation;\n" +
				"import java.lang.annotation.ElementType;\n" +
				"import java.lang.annotation.Repeatable;\n" +
				"import java.lang.annotation.Retention;\n" +
				"import java.lang.annotation.Target;\n" +
				"import java.lang.reflect.AnnotatedElement;\n" +
				"import java.lang.reflect.AnnotatedType;\n" +
				"import java.lang.reflect.Field;\n" +
				"import java.lang.reflect.Method;\n" +
				"import java.lang.reflect.Type;\n" +
				"import java.lang.reflect.TypeVariable;\n" +
				"\n" +
				"import static java.lang.annotation.RetentionPolicy.*;\n" +
				"\n" +
				"@Retention(RUNTIME)\n" +
				"@Target({ElementType.TYPE_USE, ElementType.TYPE, ElementType.FIELD, ElementType.CONSTRUCTOR, ElementType.PARAMETER,})\n" +
				"@interface TC {\n" +
				"  public T[] value();\n" +
				"}\n" +
				"@Retention(RUNTIME)\n" +
				"@Repeatable(TC.class)\n" +
				"@Target({ElementType.TYPE_USE, ElementType.TYPE, ElementType.FIELD, ElementType.CONSTRUCTOR, ElementType.PARAMETER, ElementType.METHOD})\n" +
				"@interface T {\n" +
				"  public int value() default -1;\n" +
				"}\n" +
				"\n" +
				"interface I<@T(1) @T(2) K extends @T(3) @T(4) Object & java.lang.@T(5) @T(6) Comparable<?>> {\n" +
				"}\n" +
				"\n" +
				"\n" +
				"public class X {\n" +
				"  public static void main(String args[]) {\n" +
				"	Class<I> ci = I.class;  \n" +
				"  	printAnnotations(\"I.class\", ci);\n" +
				"  	TypeVariable<Class<I>>[] typeParameters = ci.getTypeParameters();\n" +
				"  	for (TypeVariable<?> t: typeParameters) {\n" +
				"  		printAnnotations(t.getName(), t);\n" +
				"  		AnnotatedType[] bounds = t.getAnnotatedBounds();\n" +
				"  		for (AnnotatedType bound : bounds) {\n" +
				"  			printAnnotations(bound.getType().getTypeName(), bound);\n" +
				"  		}\n" +
				"  	}\n" +
				"  }\n" +
				"  \n" +
				"  static void printAnnotations(String name, AnnotatedElement element) {\n" +
				"	  int [] iterations = { 0, 1 };\n" +
				"	  for (int i : iterations) {\n" +
				"		  Class<? extends Annotation> annotation = i == 0 ? T.class : TC.class;\n" +
				"		  for (int j: iterations) {\n" +
				"			  Annotation [] annotations = j == 0 ? new Annotation [] { element.getAnnotation(annotation) } : element.getAnnotationsByType(annotation);\n" +
				"			  if (annotations.length == 0 || (annotations.length == 1 && annotations[0] == null)) continue;\n" +
				"			  System.out.print(name + (j == 0 ? \".getAnnotation(\" : \".getAnnotationByType(\") + annotation.getName() + \".class): \");\n" +
				"			  for (Annotation a : annotations) {\n" +
				"				  System.out.print(a + \" \");\n" +
				"			  }\n" +
				"			  System.out.println();\n" +
				"		  }\n" +
				"	  }\n" +
				"  }\n" +
				"}\n"

			},
			"K.getAnnotationByType(T.class): @T(value=1) @T(value=2) \n" +
			"K.getAnnotation(TC.class): @TC(value=[@T(value=1), @T(value=2)]) \n" +
			"K.getAnnotationByType(TC.class): @TC(value=[@T(value=1), @T(value=2)]) \n" +
			"java.lang.Object.getAnnotationByType(T.class): @T(value=3) @T(value=4) \n" +
			"java.lang.Object.getAnnotation(TC.class): @TC(value=[@T(value=3), @T(value=4)]) \n" +
			"java.lang.Object.getAnnotationByType(TC.class): @TC(value=[@T(value=3), @T(value=4)]) \n" +
			"java.lang.Comparable<?>.getAnnotationByType(T.class): @T(value=5) @T(value=6) \n" +
			"java.lang.Comparable<?>.getAnnotation(TC.class): @TC(value=[@T(value=5), @T(value=6)]) \n" +
			"java.lang.Comparable<?>.getAnnotationByType(TC.class): @TC(value=[@T(value=5), @T(value=6)])",
			null,
			true,
			new String [] { "-Ddummy" }); // Not sure, unless we force the VM to not be reused by passing dummy vm argument, the generated program aborts midway through its execution.
	}
	// Test that repeated annotations show up at various sites, both type use and declaration.
	public void testVariousSites() {
		this.runConformTest(
			new String[] {
				"X.java",
				"import java.lang.annotation.Annotation;\n" +
				"import java.lang.annotation.ElementType;\n" +
				"import java.lang.annotation.Repeatable;\n" +
				"import java.lang.annotation.Retention;\n" +
				"import java.lang.annotation.Target;\n" +
				"import java.lang.reflect.AnnotatedArrayType;\n" +
				"import java.lang.reflect.AnnotatedElement;\n" +
				"import java.lang.reflect.AnnotatedParameterizedType;\n" +
				"import java.lang.reflect.AnnotatedType;\n" +
				"import java.lang.reflect.Constructor;\n" +
				"import java.lang.reflect.Field;\n" +
				"import java.lang.reflect.Method;\n" +
				"import java.lang.reflect.TypeVariable;\n" +
				"\n" +
				"import static java.lang.annotation.RetentionPolicy.*;\n" +
				"\n" +
				"@Retention(RUNTIME)\n" +
				"@Target({ElementType.TYPE_USE, ElementType.TYPE, ElementType.FIELD, ElementType.CONSTRUCTOR, ElementType.PARAMETER, ElementType.METHOD})\n" +
				"@interface TC {\n" +
				"  public T[] value();\n" +
				"}\n" +
				"@Retention(RUNTIME)\n" +
				"@Repeatable(TC.class)\n" +
				"@Target({ElementType.TYPE_USE, ElementType.TYPE, ElementType.FIELD, ElementType.CONSTRUCTOR, ElementType.PARAMETER, ElementType.METHOD})\n" +
				"@interface T {\n" +
				"  public int value() default -1;\n" +
				"}\n" +
				"\n" +
				"interface I {\n" +
				"}\n" +
				"\n" +
				"@T(1) @T(2)\n" +
				"public class X<@T(3) @T(4) K extends @T(5) @T(6) Object & java.lang.@T(7) @T(8) Comparable<?>, @T(9) @T(10) V> extends @T(11) @T(12) Object implements @T(13) @T(14) I {\n" +
				"  public @T(15) @T(16) X<@T(17) @T(18) String, @T(19) @T(20) Integer> field;\n" +
				"  @T(21) @T(22)\n" +
				"  public <@T(23) @T(24) Q> X @T(25) @T(26) [] method(@T(27) @T(28) X<K, V> this, \n" +
				"		                                             @T(29) @T(30) X<@T(31) @T(32) String, String> that) throws @T(33) @T(34) NullPointerException {\n" +
				"	  return null;\n" +
				"  }\n" +
				"  @T(35) @T(36)\n" +
				"  public X() {\n" +
				"	  \n" +
				"  }\n" +
				"  @T(37) @T(48)\n" +
				"  public class MemberType {\n" +
				"	  \n" +
				"  }\n" +
				"  \n" +
				"  public static void main(String args[]) {\n" +
				"	Class<X> xc = X.class;  \n" +
				"  	printAnnotations(\"Class: \" + \"X.class\", xc);\n" +
				"  	TypeVariable<Class<X>>[] typeParameters = xc.getTypeParameters();\n" +
				"  	for (TypeVariable<?> t: typeParameters) {\n" +
				"  		printAnnotations(\"Type Parameter: \" + t.getName(), t);\n" +
				"  		AnnotatedType[] bounds = t.getAnnotatedBounds();\n" +
				"  		for (AnnotatedType bound : bounds) {\n" +
				"  			printAnnotations(\"Type parameter bound: \" + bound.getType().getTypeName(), bound);\n" +
				"  		}\n" +
				"  	}\n" +
				"  	AnnotatedType annotatedSuperclass = xc.getAnnotatedSuperclass();\n" +
				"  	printAnnotations(\"Superclass: \" + annotatedSuperclass.getType().getTypeName(), annotatedSuperclass);\n" +
				"  	\n" +
				"  	AnnotatedType [] annotatedSuperInterfaces = xc.getAnnotatedInterfaces();\n" +
				"  	printAnnotations(\"Superinterface: \" + annotatedSuperInterfaces[0].getType().getTypeName(), annotatedSuperInterfaces[0]);\n" +
				"  	\n" +
				"  	for (Field field: xc.getFields()) {\n" +
				"  		printAnnotations(\"Field: \" + field.getName(), field);\n" +
				"  		AnnotatedParameterizedType fType = (AnnotatedParameterizedType) field.getAnnotatedType();\n" +
				"  		for (AnnotatedType typeArgumentType : fType.getAnnotatedActualTypeArguments())\n" +
				"  			printAnnotations(\"Field Type argument: \" + typeArgumentType.getType().getTypeName(), typeArgumentType);\n" +
				"  			\n" +
				"  	}\n" +
				"  	for (Method method: xc.getMethods()) {\n" +
				"  		switch (method.getName()) {\n" +
				"  		case \"method\"  :\n" +
				"  			printAnnotations(method.getName(), method);\n" +
				"  			AnnotatedArrayType mType = (AnnotatedArrayType) method.getAnnotatedReturnType();\n" +
				"  			printAnnotations(\"Method return type: \" + mType.getType().getTypeName(), mType);\n" +
				"  			AnnotatedType mTypeEtype = mType.getAnnotatedGenericComponentType();\n" +
				"  			printAnnotations(\"Method return type, element type: \" + mTypeEtype.getType().getTypeName(), mTypeEtype);\n" +
				"  			TypeVariable<Method>[] typeParameters2 = method.getTypeParameters();\n" +
				"  		  	for (TypeVariable<?> t: typeParameters2) {\n" +
				"  		  		printAnnotations(\"Method Type Parameter: \" + t.getName(), t);\n" +
				"  		  	}\n" +
				"  		  	AnnotatedType annotatedReceiverType = method.getAnnotatedReceiverType();\n" +
				"  		  	printAnnotations(\"Receiver: \", annotatedReceiverType);\n" +
				"  		  	AnnotatedType[] annotatedParameterTypes = method.getAnnotatedParameterTypes();\n" +
				"  		  	for (AnnotatedType annotatedParameterType : annotatedParameterTypes) {\n" +
				"  		  		printAnnotations(\"Parameter: \", annotatedParameterType);\n" +
				"  		  	}\n" +
				"  		  	AnnotatedType[] annotatedExceptionTypes = method.getAnnotatedExceptionTypes();\n" +
				"  		  	for (AnnotatedType annotatedType : annotatedExceptionTypes) {\n" +
				"				printAnnotations(\"Exception type: \", annotatedType);\n" +
				"			}\n" +
				"  			break;\n" +
				"  		}\n" +
				"  	}\n" +
				"  	for (Constructor<?> constructor : xc.getConstructors()) {\n" +
				"  		printAnnotations(\"Constructor: \", constructor);\n" +
				"  	}\n" +
				"  	// don't know how to get member classes.\n" +
				"  }\n" +
				"  \n" +
				"  static void printAnnotations(String name, AnnotatedElement element) {\n" +
				"	  int [] iterations = { 0, 1 };\n" +
				"	  for (int i : iterations) {\n" +
				"		  Class<? extends Annotation> annotation = i == 0 ? T.class : TC.class;\n" +
				"		  for (int j: iterations) {\n" +
				"			  Annotation [] annotations = j == 0 ? new Annotation [] { element.getAnnotation(annotation) } : element.getAnnotationsByType(annotation);\n" +
				"			  if (annotations.length == 0 || (annotations.length == 1 && annotations[0] == null)) continue;\n" +
				"			  System.out.print(name + (j == 0 ? \".getAnnotation(\" : \".getAnnotationByType(\") + annotation.getName() + \".class): \");\n" +
				"			  for (Annotation a : annotations) {\n" +
				"				  System.out.print(a + \" \");\n" +
				"			  }\n" +
				"			  System.out.println();\n" +
				"		  }\n" +
				"	  }\n" +
				"  }\n" +
				"}\n"

			},
			"Class: X.class.getAnnotationByType(T.class): @T(value=1) @T(value=2) \n" +
			"Class: X.class.getAnnotation(TC.class): @TC(value=[@T(value=1), @T(value=2)]) \n" +
			"Class: X.class.getAnnotationByType(TC.class): @TC(value=[@T(value=1), @T(value=2)]) \n" +
			"Type Parameter: K.getAnnotationByType(T.class): @T(value=3) @T(value=4) \n" +
			"Type Parameter: K.getAnnotation(TC.class): @TC(value=[@T(value=3), @T(value=4)]) \n" +
			"Type Parameter: K.getAnnotationByType(TC.class): @TC(value=[@T(value=3), @T(value=4)]) \n" +
			"Type parameter bound: java.lang.Object.getAnnotationByType(T.class): @T(value=5) @T(value=6) \n" +
			"Type parameter bound: java.lang.Object.getAnnotation(TC.class): @TC(value=[@T(value=5), @T(value=6)]) \n" +
			"Type parameter bound: java.lang.Object.getAnnotationByType(TC.class): @TC(value=[@T(value=5), @T(value=6)]) \n" +
			"Type parameter bound: java.lang.Comparable<?>.getAnnotationByType(T.class): @T(value=7) @T(value=8) \n" +
			"Type parameter bound: java.lang.Comparable<?>.getAnnotation(TC.class): @TC(value=[@T(value=7), @T(value=8)]) \n" +
			"Type parameter bound: java.lang.Comparable<?>.getAnnotationByType(TC.class): @TC(value=[@T(value=7), @T(value=8)]) \n" +
			"Type Parameter: V.getAnnotationByType(T.class): @T(value=9) @T(value=10) \n" +
			"Type Parameter: V.getAnnotation(TC.class): @TC(value=[@T(value=9), @T(value=10)]) \n" +
			"Type Parameter: V.getAnnotationByType(TC.class): @TC(value=[@T(value=9), @T(value=10)]) \n" +
			"Superclass: java.lang.Object.getAnnotationByType(T.class): @T(value=11) @T(value=12) \n" +
			"Superclass: java.lang.Object.getAnnotation(TC.class): @TC(value=[@T(value=11), @T(value=12)]) \n" +
			"Superclass: java.lang.Object.getAnnotationByType(TC.class): @TC(value=[@T(value=11), @T(value=12)]) \n" +
			"Superinterface: I.getAnnotationByType(T.class): @T(value=13) @T(value=14) \n" +
			"Superinterface: I.getAnnotation(TC.class): @TC(value=[@T(value=13), @T(value=14)]) \n" +
			"Superinterface: I.getAnnotationByType(TC.class): @TC(value=[@T(value=13), @T(value=14)]) \n" +
			"Field: field.getAnnotationByType(T.class): @T(value=15) @T(value=16) \n" +
			"Field: field.getAnnotation(TC.class): @TC(value=[@T(value=15), @T(value=16)]) \n" +
			"Field: field.getAnnotationByType(TC.class): @TC(value=[@T(value=15), @T(value=16)]) \n" +
			"Field Type argument: java.lang.String.getAnnotationByType(T.class): @T(value=17) @T(value=18) \n" +
			"Field Type argument: java.lang.String.getAnnotation(TC.class): @TC(value=[@T(value=17), @T(value=18)]) \n" +
			"Field Type argument: java.lang.String.getAnnotationByType(TC.class): @TC(value=[@T(value=17), @T(value=18)]) \n" +
			"Field Type argument: java.lang.Integer.getAnnotationByType(T.class): @T(value=19) @T(value=20) \n" +
			"Field Type argument: java.lang.Integer.getAnnotation(TC.class): @TC(value=[@T(value=19), @T(value=20)]) \n" +
			"Field Type argument: java.lang.Integer.getAnnotationByType(TC.class): @TC(value=[@T(value=19), @T(value=20)]) \n" +
			"method.getAnnotationByType(T.class): @T(value=21) @T(value=22) \n" +
			"method.getAnnotation(TC.class): @TC(value=[@T(value=21), @T(value=22)]) \n" +
			"method.getAnnotationByType(TC.class): @TC(value=[@T(value=21), @T(value=22)]) \n" +
			"Method return type: X[].getAnnotationByType(T.class): @T(value=25) @T(value=26) \n" +
			"Method return type: X[].getAnnotation(TC.class): @TC(value=[@T(value=25), @T(value=26)]) \n" +
			"Method return type: X[].getAnnotationByType(TC.class): @TC(value=[@T(value=25), @T(value=26)]) \n" +
			"Method return type, element type: X.getAnnotationByType(T.class): @T(value=21) @T(value=22) \n" +
			"Method return type, element type: X.getAnnotation(TC.class): @TC(value=[@T(value=21), @T(value=22)]) \n" +
			"Method return type, element type: X.getAnnotationByType(TC.class): @TC(value=[@T(value=21), @T(value=22)]) \n" +
			"Method Type Parameter: Q.getAnnotationByType(T.class): @T(value=23) @T(value=24) \n" +
			"Method Type Parameter: Q.getAnnotation(TC.class): @TC(value=[@T(value=23), @T(value=24)]) \n" +
			"Method Type Parameter: Q.getAnnotationByType(TC.class): @TC(value=[@T(value=23), @T(value=24)]) \n" +
			"Receiver: .getAnnotationByType(T.class): @T(value=27) @T(value=28) \n" +
			"Receiver: .getAnnotation(TC.class): @TC(value=[@T(value=27), @T(value=28)]) \n" +
			"Receiver: .getAnnotationByType(TC.class): @TC(value=[@T(value=27), @T(value=28)]) \n" +
			"Parameter: .getAnnotationByType(T.class): @T(value=29) @T(value=30) \n" +
			"Parameter: .getAnnotation(TC.class): @TC(value=[@T(value=29), @T(value=30)]) \n" +
			"Parameter: .getAnnotationByType(TC.class): @TC(value=[@T(value=29), @T(value=30)]) \n" +
			"Exception type: .getAnnotationByType(T.class): @T(value=33) @T(value=34) \n" +
			"Exception type: .getAnnotation(TC.class): @TC(value=[@T(value=33), @T(value=34)]) \n" +
			"Exception type: .getAnnotationByType(TC.class): @TC(value=[@T(value=33), @T(value=34)]) \n" +
			"Constructor: .getAnnotationByType(T.class): @T(value=35) @T(value=36) \n" +
			"Constructor: .getAnnotation(TC.class): @TC(value=[@T(value=35), @T(value=36)]) \n" +
			"Constructor: .getAnnotationByType(TC.class): @TC(value=[@T(value=35), @T(value=36)])",
			null,
			true,
			new String [] { "-Ddummy" }); // Not sure, unless we force the VM to not be reused by passing dummy vm argument, the generated program aborts midway through its execution.
	}

	// Test that bad container specifications are handled properly.
	public void testBadContainerType() {
		this.runNegativeTest(
			new String[] {
				"X.java",
				"import java.lang.annotation.Repeatable;\n" +
				"@Repeatable(X.class)\n" +
				"@interface T {\n" +
				"  public int value() default -1;\n" +
				"}\n" +
				"public class X {\n" +
				"}\n"
			},
			"----------\n" + 
			"1. ERROR in X.java (at line 2)\n" + 
			"	@Repeatable(X.class)\n" + 
			"	            ^^^^^^^\n" + 
			"Type mismatch: cannot convert from Class<X> to Class<? extends Annotation>\n" + 
			"----------\n");
	}	
	// Test unspecified target.
	public void testUnspecifiedTarget() {
		this.runNegativeTest(
			new String[] {
				"X.java",
				"import java.lang.annotation.ElementType;\n" +
				"import java.lang.annotation.Repeatable;\n" +
				"import java.lang.annotation.Target;\n" +
				"\n" +
				"@Target(ElementType.TYPE_USE)\n" +
				"@interface TC {\n" +
				"	T [] value();\n" +
				"}\n" +
				"\n" +
				"@Repeatable(TC.class)\n" +
				"@interface T {\n" +
				"}\n" +
				"\n" +
				"@T @T\n" +
				"public class X { \n" +
				"	X f;\n" +
				"}\n"
			},
			"----------\n" + 
			"1. ERROR in X.java (at line 10)\n" + 
			"	@Repeatable(TC.class)\n" + 
			"	            ^^^^^^^^\n" + 
			"The container annotation type @TC is allowed at targets where the repeatable annotation type @T is not: TYPE_USE\n" + 
			"----------\n");
	}
	// Test unspecified target.
	public void testUnspecifiedTarget2() {
		this.runNegativeTest(
			new String[] {
				"X.java",
				"import java.lang.annotation.ElementType;\n" +
				"import java.lang.annotation.Repeatable;\n" +
				"import java.lang.annotation.Target;\n" +
				"\n" +
				"@Target(ElementType.TYPE_PARAMETER)\n" +
				"@interface TC {\n" +
				"	T [] value();\n" +
				"}\n" +
				"\n" +
				"@Repeatable(TC.class)\n" +
				"@interface T {\n" +
				"}\n" +
				"\n" +
				"@T @T\n" +
				"public class X { \n" +
				"	X f;\n" +
				"}\n"
			},
			"----------\n" + 
			"1. ERROR in X.java (at line 10)\n" + 
			"	@Repeatable(TC.class)\n" + 
			"	            ^^^^^^^^\n" + 
			"The container annotation type @TC is allowed at targets where the repeatable annotation type @T is not: TYPE_PARAMETER\n" + 
			"----------\n" + 
			"2. ERROR in X.java (at line 14)\n" + 
			"	@T @T\n" + 
			"	^^\n" + 
			"The annotation @T cannot be repeated at this location since its container annotation type @TC is disallowed at this location\n" + 
			"----------\n");
	}
	public void testDeprecation() {
		this.runNegativeTest(
			new String[] {
				"TC.java",
				"@Deprecated\n" +
				"public @interface TC {\n" +
				"  public T[] value();\n" +
				"}\n",
				"T.java",
				"@java.lang.annotation.Repeatable(TC.class)\n" +
				"@interface T {\n" +
				"  public int value() default -1;\n" +  
				"}\n" +
				"interface I<@T(1) @T(2) K> {\n" +
				"}\n"
			},
			"----------\n" + 
			"1. WARNING in T.java (at line 1)\n" + 
			"	@java.lang.annotation.Repeatable(TC.class)\n" + 
			"	                                 ^^\n" + 
			"The type TC is deprecated\n" + 
			"----------\n" + 
			"2. ERROR in T.java (at line 5)\n" + 
			"	interface I<@T(1) @T(2) K> {\n" + 
			"	            ^^\n" + 
			"Annotation types that do not specify explicit target element types cannot be applied here\n" + 
			"----------\n" + 
			"3. WARNING in T.java (at line 5)\n" + 
			"	interface I<@T(1) @T(2) K> {\n" + 
			"	            ^^\n" + 
			"The type TC is deprecated\n" + 
			"----------\n" + 
			"4. ERROR in T.java (at line 5)\n" + 
			"	interface I<@T(1) @T(2) K> {\n" + 
			"	            ^^\n" + 
			"Annotation types that do not specify explicit target element types cannot be applied here\n" + 
			"----------\n" + 
			"5. ERROR in T.java (at line 5)\n" + 
			"	interface I<@T(1) @T(2) K> {\n" + 
			"	                  ^^\n" + 
			"Annotation types that do not specify explicit target element types cannot be applied here\n" + 
			"----------\n");
	}
	public void testDeprecation2() { // verify that deprecation warning does not show up when the deprecated element is used in the same file defining it.
		this.runNegativeTest(
			new String[] {
				"T.java",
				"@Deprecated\n" +
				"@interface TC {\n" +
				"  public T[] value();\n" +
				"}\n" +
				"@java.lang.annotation.Repeatable(TC.class)\n" +
				"@interface T {\n" +
				"  public int value() default -1;\n" +  
				"}\n" +
				"interface I<@T(1) @T(2) K> {\n" +
				"}\n"
			},
			"----------\n" + 
			"1. ERROR in T.java (at line 9)\n" + 
			"	interface I<@T(1) @T(2) K> {\n" + 
			"	            ^^\n" + 
			"Annotation types that do not specify explicit target element types cannot be applied here\n" + 
			"----------\n" + 
			"2. ERROR in T.java (at line 9)\n" + 
			"	interface I<@T(1) @T(2) K> {\n" + 
			"	            ^^\n" + 
			"Annotation types that do not specify explicit target element types cannot be applied here\n" + 
			"----------\n" + 
			"3. ERROR in T.java (at line 9)\n" + 
			"	interface I<@T(1) @T(2) K> {\n" + 
			"	                  ^^\n" + 
			"Annotation types that do not specify explicit target element types cannot be applied here\n" + 
			"----------\n");
	}	
	
	// 419209: [1.8] Repeating container annotations should be rejected in the presence of annotation it contains
	public void testRepeatableWithContaining1() {
		this.runNegativeTest(
			false /* skipJavac */,
			JavacTestOptions.Excuse.EclipseHasSomeMoreWarnings,
			new String[] {
				"A.java",
				"@interface FooContainerContainer {\n" +
				"  public FooContainer[] value();\n" +
				"}\n" +
				"@java.lang.annotation.Repeatable(FooContainerContainer.class)\n" +
				"@interface FooContainer {\n" +
				"  public Foo[] value();\n" +
				"}\n" +
				"@java.lang.annotation.Repeatable(FooContainer.class)\n" +
				"@interface Foo {\n" +
				"  public int value() default -1;\n" +  
				"}\n" +
				"@FooContainer({@Foo(1)}) @FooContainer({@Foo(2)}) @Foo(3) class A {}\n"
			},
			"----------\n" + 
			"1. WARNING in A.java (at line 12)\n" + 
			"	@FooContainer({@Foo(1)}) @FooContainer({@Foo(2)}) @Foo(3) class A {}\n" + 
			"	                                                  ^^^^\n" + 
			"The repeatable annotation @Foo may not be present where its container annotation type @FooContainer is repeated\n" + 
			"----------\n");
	}
	// 419209: [1.8] Repeating container annotations should be rejected in the presence of annotation it contains
	public void testRepeatableWithContaining2() {
		this.runNegativeTest(
			false /* skipJavac */,
			JavacTestOptions.Excuse.EclipseHasSomeMoreWarnings,
			new String[] {
				"A.java",
				"@interface FooContainerContainer {\n" +
				"  public FooContainer[] value();\n" +
				"}\n" +
				"@java.lang.annotation.Repeatable(FooContainerContainer.class)\n" +
				"@interface FooContainer {\n" +
				"  public Foo[] value();\n" +
				"}\n" +
				"@java.lang.annotation.Repeatable(FooContainer.class)\n" +
				"@interface Foo {\n" +
				"  public int value() default -1;\n" +  
				"}\n" +
				"@Foo(1) @FooContainer({@Foo(2)}) @FooContainer({@Foo(3)}) class A {}\n"
			},
			"----------\n" + 
			"1. WARNING in A.java (at line 12)\n" + 
			"	@Foo(1) @FooContainer({@Foo(2)}) @FooContainer({@Foo(3)}) class A {}\n" + 
			"	^^^^\n" + 
			"The repeatable annotation @Foo may not be present where its container annotation type @FooContainer is repeated\n" + 
			"----------\n");
	}
	// 419209: [1.8] Repeating container annotations should be rejected in the presence of annotation it contains
	public void testRepeatableWithContaining3() {
		this.runNegativeTest(
			false /* skipJavac */,
			JavacTestOptions.Excuse.EclipseHasSomeMoreWarnings,
			new String[] {
				"A.java",
				"@interface FooContainerContainer {\n" +
				"  public FooContainer[] value();\n" +
				"}\n" +
				"@java.lang.annotation.Repeatable(FooContainerContainer.class)\n" +
				"@interface FooContainer {\n" +
				"  public Foo[] value();\n" +
				"}\n" +
				"@java.lang.annotation.Repeatable(FooContainer.class)\n" +
				"@interface Foo {\n" +
				"  public int value() default -1;\n" +  
				"}\n" +
				"@FooContainer({@Foo(2)}) @Foo(1) @FooContainer({@Foo(3)}) class A {}\n"
			},
			"----------\n" + 
			"1. WARNING in A.java (at line 12)\n" + 
			"	@FooContainer({@Foo(2)}) @Foo(1) @FooContainer({@Foo(3)}) class A {}\n" + 
			"	                         ^^^^\n" + 
			"The repeatable annotation @Foo may not be present where its container annotation type @FooContainer is repeated\n" + 
			"----------\n");
	}	
}