changeset 2988:02681b7c4232 jdk9-b74

Merge
author lana
date Thu, 16 Jul 2015 19:31:01 -0700
parents 3d40e9830cac ad2597bdd2f5
children 4b7f5ea468d1 70c852df047c
files
diffstat 55 files changed, 2885 insertions(+), 200 deletions(-) [+]
line wrap: on
line diff
--- a/src/jdk.compiler/share/classes/com/sun/tools/doclint/DocLint.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/doclint/DocLint.java	Thu Jul 16 19:31:01 2015 -0700
@@ -344,6 +344,10 @@
         checker.scan(dc, p);
     }
 
+    public boolean shouldCheck(CompilationUnitTree unit) {
+        return env.shouldCheck(unit);
+    }
+
     public void reportStats(PrintWriter out) {
         env.messages.reportStats(out);
     }
@@ -406,26 +410,8 @@
 
         @Override @DefinedBy(Api.COMPILER_TREE)
         public Void visitCompilationUnit(CompilationUnitTree node, Void p) {
-            if (env.includePackages != null) {
-                String packageName =   node.getPackageName() != null
-                                     ? node.getPackageName().toString()
-                                     : "";
-                if (!env.includePackages.isEmpty()) {
-                    boolean included = false;
-                    for (Pattern pack : env.includePackages) {
-                        if (pack.matcher(packageName).matches()) {
-                            included = true;
-                            break;
-                        }
-                    }
-                    if (!included)
-                        return null;
-                }
-                for (Pattern pack : env.excludePackages) {
-                    if (pack.matcher(packageName).matches()) {
-                        return null;
-                    }
-                }
+            if (!env.shouldCheck(node)) {
+                return null;
             }
             return super.visitCompilationUnit(node, p);
         }
--- a/src/jdk.compiler/share/classes/com/sun/tools/doclint/Env.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/doclint/Env.java	Thu Jul 16 19:31:01 2015 -0700
@@ -43,6 +43,7 @@
 import javax.tools.Diagnostic.Kind;
 
 import com.sun.source.doctree.DocCommentTree;
+import com.sun.source.tree.CompilationUnitTree;
 import com.sun.source.util.DocTrees;
 import com.sun.source.util.JavacTask;
 import com.sun.source.util.SourcePositions;
@@ -229,6 +230,35 @@
         return sp.getStartPosition(p.getCompilationUnit(), p.getLeaf());
     }
 
+    boolean shouldCheck(CompilationUnitTree unit) {
+        if (includePackages == null)
+            return true;
+
+        String packageName =   unit.getPackageName() != null
+                             ? unit.getPackageName().toString()
+                             : "";
+
+        if (!includePackages.isEmpty()) {
+            boolean included = false;
+            for (Pattern pack : includePackages) {
+                if (pack.matcher(packageName).matches()) {
+                    included = true;
+                    break;
+                }
+            }
+            if (!included)
+                return false;
+        }
+
+        for (Pattern pack : excludePackages) {
+            if (pack.matcher(packageName).matches()) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
     private <T extends Comparable<T>> T min(T item1, T item2) {
         return (item1 == null) ? item2
                 : (item2 == null) ? item1
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/api/JavacTrees.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/api/JavacTrees.java	Thu Jul 16 19:31:01 2015 -0700
@@ -874,8 +874,8 @@
     /**
      * Returns the original type from the ErrorType object.
      * @param errorType The errorType for which we want to get the original type.
-     * @returns TypeMirror corresponding to the original type, replaced by the ErrorType.
-     *          noType (type.tag == NONE) is returned if there is no original type.
+     * @return TypeMirror corresponding to the original type, replaced by the ErrorType.
+     *         noType (type.tag == NONE) is returned if there is no original type.
      */
     @DefinedBy(Api.COMPILER_TREE)
     public TypeMirror getOriginalType(javax.lang.model.type.ErrorType errorType) {
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Attribute.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Attribute.java	Thu Jul 16 19:31:01 2015 -0700
@@ -230,9 +230,11 @@
         /**
          * Returns a string representation of this annotation.
          * String is of one of the forms:
-         *     @com.example.foo(name1=val1, name2=val2)
-         *     @com.example.foo(val)
-         *     @com.example.foo
+         * <pre>
+         *     {@code @com.example.foo(name1=val1, name2=val2)}
+         *     {@code @com.example.foo(val)}
+         *     {@code @com.example.foo}
+         * </pre>
          * Omit parens for marker annotations, and omit "value=" when allowed.
          */
         @DefinedBy(Api.LANGUAGE_MODEL)
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/code/TypeAnnotationPosition.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/code/TypeAnnotationPosition.java	Thu Jul 16 19:31:01 2015 -0700
@@ -461,7 +461,7 @@
      *
      * @param location The type path.
      * @param onLambda The lambda for this parameter.
-     * @param index The index of the parameter.
+     * @param parameter_index The index of the parameter.
      * @param pos The position from the associated tree node.
      */
     public static TypeAnnotationPosition
@@ -479,7 +479,7 @@
      * Create a {@code TypeAnnotationPosition} for a method formal parameter.
      *
      * @param onLambda The lambda for this parameter.
-     * @param index The index of the parameter.
+     * @param parameter_index The index of the parameter.
      * @param pos The position from the associated tree node.
      */
     public static TypeAnnotationPosition
@@ -493,7 +493,7 @@
     /**
      * Create a {@code TypeAnnotationPosition} for a method formal parameter.
      *
-     * @param index The index of the parameter.
+     * @param parameter_index The index of the parameter.
      * @param pos The position from the associated tree node.
      */
     public static TypeAnnotationPosition
@@ -506,7 +506,7 @@
      * Create a {@code TypeAnnotationPosition} for a method formal parameter.
      *
      * @param location The type path.
-     * @param index The index of the parameter.
+     * @param parameter_index The index of the parameter.
      */
     public static TypeAnnotationPosition
         methodParameter(final List<TypePathEntry> location,
@@ -535,8 +535,6 @@
      * Create a {@code TypeAnnotationPosition} for a method reference.
      *
      * @param location The type path.
-     * @param onLambda The lambda for this method reference.
-     * @param pos The position from the associated tree node.
      */
     public static TypeAnnotationPosition
         methodRef(final List<TypePathEntry> location) {
@@ -564,8 +562,6 @@
      * Create a {@code TypeAnnotationPosition} for a constructor reference.
      *
      * @param location The type path.
-     * @param onLambda The lambda for this constructor reference.
-     * @param pos The position from the associated tree node.
      */
     public static TypeAnnotationPosition
         constructorRef(final List<TypePathEntry> location) {
@@ -720,8 +716,6 @@
      * Create a {@code TypeAnnotationPosition} for a resource variable.
      *
      * @param location The type path.
-     * @param onLambda The lambda for this variable.
-     * @param pos The position from the associated tree node.
      */
     public static TypeAnnotationPosition
         resourceVariable(final List<TypePathEntry> location) {
@@ -748,8 +742,6 @@
     /**
      * Create a {@code TypeAnnotationPosition} for a new.
      *
-     * @param location The type path.
-     * @param onLambda The lambda for this variable.
      * @param pos The position from the associated tree node.
      */
     public static TypeAnnotationPosition newObj(final int pos) {
@@ -760,8 +752,6 @@
      * Create a {@code TypeAnnotationPosition} for a new.
      *
      * @param location The type path.
-     * @param onLambda The lambda for this variable.
-     * @param pos The position from the associated tree node.
      */
     public static TypeAnnotationPosition
         newObj(final List<TypePathEntry> location) {
@@ -792,7 +782,6 @@
      *
      * @param location The type path.
      * @param onLambda The lambda for this variable.
-     * @param type_index The index of the interface.
      * @param pos The position from the associated tree node.
      */
     public static TypeAnnotationPosition
@@ -854,8 +843,6 @@
      * Create a {@code TypeAnnotationPosition} for an instanceof.
      *
      * @param location The type path.
-     * @param onLambda The lambda for this variable.
-     * @param pos The position from the associated tree node.
      */
     public static TypeAnnotationPosition
         instanceOf(final List<TypePathEntry> location) {
@@ -885,9 +872,7 @@
      * Create a {@code TypeAnnotationPosition} for a type cast.
      *
      * @param location The type path.
-     * @param onLambda The lambda for this variable.
      * @param type_index The index into an intersection type.
-     * @param pos The position from the associated tree node.
      */
     public static TypeAnnotationPosition
         typeCast(final List<TypePathEntry> location,
@@ -984,9 +969,7 @@
      * Create a {@code TypeAnnotationPosition} for a type parameter.
      *
      * @param location The type path.
-     * @param onLambda The lambda for this variable.
      * @param parameter_index The index of the type parameter.
-     * @param pos The position from the associated tree node.
      */
     public static TypeAnnotationPosition
         typeParameter(final List<TypePathEntry> location,
@@ -1062,7 +1045,7 @@
      *
      * @param location The type path.
      * @param onLambda The lambda for this variable.
-     * @param parameter_index The index of the type argument.
+     * @param type_index The index of the type argument.
      * @param pos The position from the associated tree node.
      */
     public static TypeAnnotationPosition
@@ -1081,9 +1064,7 @@
      * type argument.
      *
      * @param location The type path.
-     * @param onLambda The lambda for this variable.
-     * @param parameter_index The index of the type argument.
-     * @param pos The position from the associated tree node.
+     * @param type_index The index of the type argument.
      */
     public static TypeAnnotationPosition
         methodRefTypeArg(final List<TypePathEntry> location,
@@ -1097,7 +1078,7 @@
      *
      * @param location The type path.
      * @param onLambda The lambda for this variable.
-     * @param parameter_index The index of the type argument.
+     * @param type_index The index of the type argument.
      * @param pos The position from the associated tree node.
      */
     public static TypeAnnotationPosition
@@ -1116,7 +1097,7 @@
      * type argument.
      *
      * @param location The type path.
-     * @param parameter_index The index of the type argument.
+     * @param type_index The index of the type argument.
      */
     public static TypeAnnotationPosition
         constructorRefTypeArg(final List<TypePathEntry> location,
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java	Thu Jul 16 19:31:01 2015 -0700
@@ -279,7 +279,7 @@
 
     /** Check that variable can be assigned to.
      *  @param pos    The current source code position.
-     *  @param v      The assigned varaible
+     *  @param v      The assigned variable
      *  @param base   If the variable is referred to in a Select, the part
      *                to the left of the `.', null otherwise.
      *  @param env    The current environment.
@@ -759,7 +759,7 @@
     /**
      * Attribute a "lazy constant value".
      *  @param env         The env for the const value
-     *  @param initializer The initializer for the const value
+     *  @param variable    The initializer for the const value
      *  @param type        The expected type, or null
      *  @see VarSymbol#setLazyConstValue
      */
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/file/JRTIndex.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/file/JRTIndex.java	Thu Jul 16 19:31:01 2015 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2015, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -35,7 +35,6 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.ProviderNotFoundException;
-import java.nio.file.spi.FileSystemProvider;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.LinkedHashMap;
@@ -95,11 +94,6 @@
     private final FileSystem jrtfs;
 
     /**
-     * The set of module directories within the jrt: file system.
-     */
-    private final Set<Path> jrtModules;
-
-    /**
      * A lazily evaluated set of entries about the contents of the jrt: file system.
      */
     private final Map<RelativeDirectory, SoftReference<Entry>> entries;
@@ -183,14 +177,6 @@
      */
     private JRTIndex() throws IOException {
         jrtfs = FileSystems.getFileSystem(URI.create("jrt:/"));
-        jrtModules = new LinkedHashSet<>();
-        Path root = jrtfs.getPath("/");
-        try (DirectoryStream<Path> stream = Files.newDirectoryStream(root)) {
-            for (Path entry: stream) {
-                if (Files.isDirectory(entry))
-                    jrtModules.add(entry);
-            }
-        }
         entries = new HashMap<>();
     }
 
@@ -204,18 +190,29 @@
         if (e == null) {
             Map<String, Path> files = new LinkedHashMap<>();
             Set<RelativeDirectory> subdirs = new LinkedHashSet<>();
-            for (Path module: jrtModules) {
-                Path p = rd.getFile(module);
-                if (!Files.exists(p))
-                    continue;
-                try (DirectoryStream<Path> stream = Files.newDirectoryStream(p)) {
-                    for (Path entry: stream) {
-                        String name = entry.getFileName().toString();
-                        if (Files.isRegularFile(entry)) {
-                            // TODO: consider issue of files with same name in different modules
-                            files.put(name, entry);
-                        } else if (Files.isDirectory(entry)) {
-                            subdirs.add(new RelativeDirectory(rd, name));
+            Path dir;
+            if (rd.path.isEmpty()) {
+                dir = jrtfs.getPath("/modules");
+            } else {
+                Path pkgs = jrtfs.getPath("/packages");
+                dir = pkgs.resolve(rd.getPath().replaceAll("/$", "").replace("/", "."));
+            }
+            if (Files.exists(dir)) {
+                try (DirectoryStream<Path> modules = Files.newDirectoryStream(dir)) {
+                    for (Path module: modules) {
+                        Path p = rd.getFile(module);
+                        if (!Files.exists(p))
+                            continue;
+                        try (DirectoryStream<Path> stream = Files.newDirectoryStream(p)) {
+                            for (Path entry: stream) {
+                                String name = entry.getFileName().toString();
+                                if (Files.isRegularFile(entry)) {
+                                    // TODO: consider issue of files with same name in different modules
+                                    files.put(name, entry);
+                                } else if (Files.isDirectory(entry)) {
+                                    subdirs.add(new RelativeDirectory(rd, name));
+                                }
+                            }
                         }
                     }
                 }
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/file/PathFileObject.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/file/PathFileObject.java	Thu Jul 16 19:31:01 2015 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2009, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2009, 2015, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -104,8 +104,8 @@
         return new PathFileObject(fileManager, path) {
             @Override
             public String inferBinaryName(Iterable<? extends Path> paths) {
-                // use subpath to ignore the leading component containing the module name
-                return toBinaryName(path.subpath(1, path.getNameCount()));
+                // use subpath to ignore the leading /modules/MODULE-NAME
+                return toBinaryName(path.subpath(2, path.getNameCount()));
             }
         };
     }
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/main/JavaCompiler.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/main/JavaCompiler.java	Thu Jul 16 19:31:01 2015 -0700
@@ -1047,7 +1047,6 @@
     /**
      * Process any annotations found in the specified compilation units.
      * @param roots a list of compilation units
-     * @return an instance of the compiler in which to complete the compilation
      */
     // Implementation note: when this method is called, log.deferredDiagnostics
     // will have been set true by initProcessAnnotations, meaning that any diagnostics
@@ -1194,7 +1193,7 @@
      * Note that attributing classes may cause additional files to be
      * parsed and entered via the SourceCompleter.
      * Attribution of the entries in the list does not stop if any errors occur.
-     * @returns a list of environments for attributd classes.
+     * @return a list of environments for attribute classes.
      */
     public Queue<Env<AttrContext>> attribute(Queue<Env<AttrContext>> envs) {
         ListBuffer<Env<AttrContext>> results = new ListBuffer<>();
@@ -1205,7 +1204,7 @@
 
     /**
      * Attribute a parse tree.
-     * @returns the attributed parse tree
+     * @return the attributed parse tree
      */
     public Env<AttrContext> attribute(Env<AttrContext> env) {
         if (compileStates.isDone(env, CompileState.ATTR))
@@ -1245,7 +1244,7 @@
      * Perform dataflow checks on attributed parse trees.
      * These include checks for definite assignment and unreachable statements.
      * If any errors occur, an empty list will be returned.
-     * @returns the list of attributed parse trees
+     * @return the list of attributed parse trees
      */
     public Queue<Env<AttrContext>> flow(Queue<Env<AttrContext>> envs) {
         ListBuffer<Env<AttrContext>> results = new ListBuffer<>();
@@ -1315,7 +1314,7 @@
      * Prepare attributed parse trees, in conjunction with their attribution contexts,
      * for source or code generation.
      * If any errors occur, an empty list will be returned.
-     * @returns a list containing the classes to be generated
+     * @return a list containing the classes to be generated
      */
     public Queue<Pair<Env<AttrContext>, JCClassDecl>> desugar(Queue<Env<AttrContext>> envs) {
         ListBuffer<Pair<Env<AttrContext>, JCClassDecl>> results = new ListBuffer<>();
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/DocCommentParser.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/DocCommentParser.java	Thu Jul 16 19:31:01 2015 -0700
@@ -409,7 +409,7 @@
 
     /**
      * Read Java class name, possibly followed by member
-     * Matching pairs of < > are skipped. The text is terminated by the first
+     * Matching pairs of {@literal < >} are skipped. The text is terminated by the first
      * unmatched }. It is an error if the beginning of the next tag is detected.
      */
     // TODO: boolean allowMember should be enum FORBID, ALLOW, REQUIRE
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/processing/JavacProcessingEnvironment.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/processing/JavacProcessingEnvironment.java	Thu Jul 16 19:31:01 2015 -0700
@@ -1411,7 +1411,7 @@
     }
 
     /**
-     * {@inheritdoc}
+     * {@inheritDoc}
      *
      * Command line options suitable for presenting to annotation
      * processors.
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/processing/JavacRoundEnvironment.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/processing/JavacRoundEnvironment.java	Thu Jul 16 19:31:01 2015 -0700
@@ -168,7 +168,7 @@
     }
 
     /**
-     * {@inheritdoc}
+     * {@inheritDoc}
      */
     @DefinedBy(Api.ANNOTATION_PROCESSING)
     public Set<? extends Element> getElementsAnnotatedWith(Class<? extends Annotation> a) {
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/tree/JCTree.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/tree/JCTree.java	Thu Jul 16 19:31:01 2015 -0700
@@ -2368,7 +2368,7 @@
     }
 
     /**
-     * An intersection type, T1 & T2 & ... Tn (used in cast expressions)
+     * An intersection type, {@code T1 & T2 & ... Tn} (used in cast expressions)
      */
     public static class JCTypeIntersection extends JCExpression implements IntersectionTypeTree {
 
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/util/AbstractDiagnosticFormatter.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/util/AbstractDiagnosticFormatter.java	Thu Jul 16 19:31:01 2015 -0700
@@ -61,7 +61,7 @@
  *  Those implementations are specifically targeting JCDiagnostic objects.
  *  <li> Provides basic support for i18n and a method for executing all locale-dependent conversions
  *  <li> Provides the formatting logic for rendering the arguments of a JCDiagnostic object.
- * <ul>
+ * </ul>
  *
  * <p><b>This is NOT part of any supported API.
  * If you write code that depends on this, you do so at your own risk.
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/util/Context.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/util/Context.java	Thu Jul 16 19:31:01 2015 -0700
@@ -44,7 +44,7 @@
  * instance method that is overridden in extended components.  A base
  * phase supporting extension would look something like this:
  *
- * <p><pre>{@code
+ * <pre>{@code
  * public class Phase {
  *     protected static final Context.Key<Phase> phaseKey =
  *         new Context.Key<Phase>();
@@ -70,7 +70,7 @@
  * and this must be done before any reference to the phase is accessed
  * using Phase.instance().  An extended phase might be declared thus:
  *
- * <p><pre>{@code
+ * <pre>{@code
  * public class NewPhase extends Phase {
  *     protected NewPhase(Context context) {
  *         super(context);
@@ -87,7 +87,7 @@
  *
  * <p>And is registered early in the extended compiler like this
  *
- * <p><pre>
+ * <pre>
  *     NewPhase.preRegister(context);
  * </pre>
  *
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/util/IntHashTable.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/util/IntHashTable.java	Thu Jul 16 19:31:01 2015 -0700
@@ -28,7 +28,7 @@
 /**
  * A hash table that maps Object to int.
  *
- * This is a custom hash table optimised for the Object -> int
+ * This is a custom hash table optimised for the Object {@literal ->} int
  * maps. This is done to avoid unnecessary object allocation in the image set.
  *
  * @author Charles Turner
@@ -43,7 +43,7 @@
     private final static Object DELETED = new Object();
 
     /**
-     * Construct an Object -> int hash table.
+     * Construct an Object {@literal ->} int hash table.
      *
      * The default size of the hash table is 64 mappings.
      */
@@ -54,7 +54,7 @@
     }
 
     /**
-     * Construct an Object -> int hash table with a specified amount of mappings.
+     * Construct an Object {@literal ->} int hash table with a specified amount of mappings.
      * @param capacity The number of default mappings in this hash table.
      */
     public IntHashTable(int capacity) {
--- a/src/jdk.compiler/share/classes/com/sun/tools/sjavac/BuildState.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/sjavac/BuildState.java	Thu Jul 16 19:31:01 2015 -0700
@@ -187,7 +187,7 @@
 
     /**
      * Verify that the setModules method above did the right thing when
-     * running through the module->package->source structure.
+     * running through the {@literal module->package->source} structure.
      */
     public void checkInternalState(String msg, boolean linkedOnly, Map<String,Source> srcs) {
         boolean baad = false;
--- a/src/jdk.compiler/share/classes/com/sun/tools/sjavac/Util.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/sjavac/Util.java	Thu Jul 16 19:31:01 2015 -0700
@@ -131,7 +131,7 @@
      * do settings = cleanOptions("--server:",Util.set("-portfile"),settings);
      *    now settings equals "--server:portfile=bar"
      *
-     * @param allowsSubOptions A set of the allowed sub options, id portfile etc.
+     * @param allowedSubOptions A set of the allowed sub options, id portfile etc.
      * @param s The option settings string.
      */
     public static String cleanSubOptions(Set<String> allowedSubOptions, String s) {
--- a/src/jdk.compiler/share/classes/com/sun/tools/sjavac/client/SjavacClient.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/sjavac/client/SjavacClient.java	Thu Jul 16 19:31:01 2015 -0700
@@ -128,12 +128,6 @@
 
     /**
      * Make a request to the server only to get the maximum possible heap size to use for compilations.
-     *
-     * @param port_file The port file used to synchronize creation of this server.
-     * @param id The identify of the compilation.
-     * @param out Standard out information.
-     * @param err Standard err information.
-     * @return The maximum heap size in bytes.
      */
     @Override
     public SysInfo getSysInfo() {
--- a/src/jdk.compiler/share/classes/com/sun/tools/sjavac/options/Options.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/sjavac/options/Options.java	Thu Jul 16 19:31:01 2015 -0700
@@ -161,7 +161,7 @@
 
     /**
      * Get a map which maps suffixes to transformers (for example
-     * ".java" -> CompileJavaPackages)
+     * ".java" {@literal ->} CompileJavaPackages)
      */
     public Map<String, Transformer> getTranslationRules() {
         return trRules;
--- a/src/jdk.compiler/share/classes/com/sun/tools/sjavac/server/PortFile.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/sjavac/server/PortFile.java	Thu Jul 16 19:31:01 2015 -0700
@@ -78,7 +78,7 @@
 
     /**
      * Create a new portfile.
-     * @param filename is the path to the file.
+     * @param fn is the path to the file.
      */
     public PortFile(String fn) throws FileNotFoundException {
         filename = fn;
--- a/src/jdk.javadoc/share/classes/com/sun/tools/doclets/formats/html/AbstractExecutableMemberWriter.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.javadoc/share/classes/com/sun/tools/doclets/formats/html/AbstractExecutableMemberWriter.java	Thu Jul 16 19:31:01 2015 -0700
@@ -58,7 +58,6 @@
      *
      * @param member the member to write type parameters for.
      * @param htmltree the content tree to which the parameters will be added.
-     * @return the display length required to write this information.
      */
     protected void addTypeParameters(ExecutableMemberDoc member, Content htmltree) {
         Content typeParameters = getTypeParameters(member);
--- a/src/jdk.javadoc/share/classes/com/sun/tools/doclets/formats/html/ConfigurationImpl.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.javadoc/share/classes/com/sun/tools/doclets/formats/html/ConfigurationImpl.java	Thu Jul 16 19:31:01 2015 -0700
@@ -289,9 +289,11 @@
             } else if (opt.equals("-html5")) {
                 htmlVersion = HtmlVersion.HTML5;
             } else if (opt.equals("-xdoclint")) {
-                doclintOpts.add(null);
+                doclintOpts.add(DocLint.XMSGS_OPTION);
             } else if (opt.startsWith("-xdoclint:")) {
-                doclintOpts.add(opt.substring(opt.indexOf(":") + 1));
+                doclintOpts.add(DocLint.XMSGS_CUSTOM_PREFIX + opt.substring(opt.indexOf(":") + 1));
+            } else if (opt.startsWith("-xdoclint/package:")) {
+                doclintOpts.add(DocLint.XCHECK_PACKAGE + opt.substring(opt.indexOf(":") + 1));
             }
         }
         if (root.specifiedClasses().length > 0) {
@@ -325,7 +327,6 @@
      * The options arrive as case-sensitive strings. For options that
      * are not case-sensitive, use toLowerCase() on the option string
      * before comparing it.
-     * </blockquote>
      *
      * @return number of arguments + 1 for a option. Zero return means
      * option not known.  Negative value means error occurred.
@@ -349,7 +350,8 @@
             option.equals("-html4") ||
             option.equals("-html5") ||
             option.equals("-xdoclint") ||
-            option.startsWith("-xdoclint:")) {
+            option.startsWith("-xdoclint:") ||
+            option.startsWith("-xdoclint/package:")) {
             return 1;
         } else if (option.equals("-help")) {
             // Uugh: first, this should not be hidden inside optionLength,
@@ -477,6 +479,12 @@
                     reporter.printError(getText("doclet.Option_doclint_invalid_arg"));
                     return false;
                 }
+            } else if (opt.startsWith("-xdoclint/package:")) {
+                if (!DocLint.isValidOption(
+                        opt.replace("-xdoclint/package:", DocLint.XCHECK_PACKAGE))) {
+                    reporter.printError(getText("doclet.Option_doclint_package_invalid_arg"));
+                    return false;
+                }
             }
         }
         return true;
--- a/src/jdk.javadoc/share/classes/com/sun/tools/doclets/formats/html/LinkInfoImpl.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.javadoc/share/classes/com/sun/tools/doclets/formats/html/LinkInfoImpl.java	Thu Jul 16 19:31:01 2015 -0700
@@ -247,7 +247,7 @@
     }
 
     /**
-     * {@inherotDoc}
+     * {@inheritDoc}
      */
     protected Content newContent() {
         return new ContentBuilder();
--- a/src/jdk.javadoc/share/classes/com/sun/tools/doclets/formats/html/PackageIndexWriter.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.javadoc/share/classes/com/sun/tools/doclets/formats/html/PackageIndexWriter.java	Thu Jul 16 19:31:01 2015 -0700
@@ -267,7 +267,7 @@
      * navigation bar, and then the title (from the"-title"
      * option), at the top of page.
      *
-     * @body the documentation tree to which the navigation bar header will be added
+     * @param body the documentation tree to which the navigation bar header will be added
      */
     protected void addNavigationBarHeader(Content body) {
         Content htmlTree = (configuration.allowTag(HtmlTag.HEADER))
--- a/src/jdk.javadoc/share/classes/com/sun/tools/doclets/formats/html/resources/standard.properties	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.javadoc/share/classes/com/sun/tools/doclets/formats/html/resources/standard.properties	Thu Jul 16 19:31:01 2015 -0700
@@ -231,4 +231,10 @@
 \  -Xdoclint                        Enable recommended checks for problems in javadoc comments\n\
 \  -Xdoclint:(all|none|[-]<group>) \n\
 \        Enable or disable specific checks for problems in javadoc comments,\n\
-\        where <group> is one of accessibility, html, missing, reference, or syntax.\n
+\        where <group> is one of accessibility, html, missing, reference, or syntax.\n\
+\  -Xdoclint/package:([-]<packages>)\n\
+\        Enable or disable checks in specific packages. <packages> is a comma separated\n\
+\        list of package specifiers. Package specifier is either a qualified name of a package\n\
+\        or a package name prefix followed by .*, which expands to all sub-packages of\n\
+\        the given package. Prefix the package specifier with - to disable checks for\n\
+\        the specified packages.\n
--- a/src/jdk.javadoc/share/classes/com/sun/tools/doclets/internal/toolkit/resources/doclets.properties	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.javadoc/share/classes/com/sun/tools/doclets/internal/toolkit/resources/doclets.properties	Thu Jul 16 19:31:01 2015 -0700
@@ -13,6 +13,7 @@
 doclet.Option_reuse=Option reused: {0}
 doclet.Option_doclint_no_qualifiers=Access qualifiers not permitted for -Xdoclint arguments
 doclet.Option_doclint_invalid_arg=Invalid argument for -Xdoclint option
+doclet.Option_doclint_package_invalid_arg=Invalid argument for -Xdoclint/package option
 doclet.exception_encountered= {0} encountered \n\
 \twhile attempting to create file: {1}
 doclet.perform_copy_exception_encountered= {0} encountered while \n\
--- a/src/jdk.javadoc/share/classes/com/sun/tools/doclets/internal/toolkit/taglets/TagletWriter.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.javadoc/share/classes/com/sun/tools/doclets/internal/toolkit/taglets/TagletWriter.java	Thu Jul 16 19:31:01 2015 -0700
@@ -58,7 +58,7 @@
     public abstract Content getOutputInstance();
 
     /**
-     * Return the output for a {@code...} tag.
+     * Return the output for a {@code {@code ...}} tag.
      *
      * @param tag the tag.
      * @return the output of the taglet.
@@ -80,7 +80,7 @@
     protected abstract Content deprecatedTagOutput(Doc doc);
 
     /**
-     * Return the output for a {@literal...} tag.
+     * Return the output for a {@code {@literal ...}} tag.
      *
      * @param tag the tag.
      * @return the output of the taglet.
--- a/src/jdk.javadoc/share/classes/com/sun/tools/javadoc/AnnotationDescImpl.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.javadoc/share/classes/com/sun/tools/javadoc/AnnotationDescImpl.java	Thu Jul 16 19:31:01 2015 -0700
@@ -100,9 +100,11 @@
     /**
      * Returns a string representation of this annotation.
      * String is of one of the forms:
-     *     @com.example.foo(name1=val1, name2=val2)
-     *     @com.example.foo(val)
-     *     @com.example.foo
+     * <pre>
+     *     {@code @com.example.foo(name1=val1, name2=val2)}
+     *     {@code @com.example.foo(val)}
+     *     {@code @com.example.foo}
+     * </pre>
      * Omit parens for marker annotations, and omit "value=" when allowed.
      */
     @Override
--- a/src/jdk.javadoc/share/classes/com/sun/tools/javadoc/ClassDocImpl.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.javadoc/share/classes/com/sun/tools/javadoc/ClassDocImpl.java	Thu Jul 16 19:31:01 2015 -0700
@@ -1278,8 +1278,8 @@
      * each Serializable field defined by an <code>ObjectStreamField</code>
      * array component of <code>serialPersistentField</code>.
      *
-     * @returns an array of <code>FieldDoc</code> for the Serializable fields
-     * of this class.
+     * @return an array of {@code FieldDoc} for the Serializable fields
+     *         of this class.
      *
      * @see #definesSerializableFields()
      * @see SerialFieldTagImpl
--- a/src/jdk.javadoc/share/classes/com/sun/tools/javadoc/DocEnv.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.javadoc/share/classes/com/sun/tools/javadoc/DocEnv.java	Thu Jul 16 19:31:01 2015 -0700
@@ -31,6 +31,7 @@
 import javax.tools.JavaFileManager;
 
 import com.sun.javadoc.*;
+import com.sun.source.tree.CompilationUnitTree;
 import com.sun.source.util.JavacTask;
 import com.sun.source.util.TreePath;
 import com.sun.tools.doclint.DocLint;
@@ -816,16 +817,19 @@
 
     void initDoclint(Collection<String> opts, Collection<String> customTagNames, String htmlVersion) {
         ArrayList<String> doclintOpts = new ArrayList<>();
+        boolean msgOptionSeen = false;
 
-        for (String opt: opts) {
-            doclintOpts.add(opt == null ? DocLint.XMSGS_OPTION : DocLint.XMSGS_CUSTOM_PREFIX + opt);
+        for (String opt : opts) {
+            if (opt.startsWith(DocLint.XMSGS_OPTION)) {
+                if (opt.equals(DocLint.XMSGS_CUSTOM_PREFIX + "none"))
+                    return;
+                msgOptionSeen = true;
+            }
+            doclintOpts.add(opt);
         }
 
-        if (doclintOpts.isEmpty()) {
+        if (!msgOptionSeen) {
             doclintOpts.add(DocLint.XMSGS_OPTION);
-        } else if (doclintOpts.size() == 1
-                && doclintOpts.get(0).equals(DocLint.XMSGS_CUSTOM_PREFIX + "none")) {
-            return;
         }
 
         String sep = "";
@@ -848,4 +852,10 @@
     boolean showTagMessages() {
         return (doclint == null);
     }
+
+    Map<CompilationUnitTree, Boolean> shouldCheck = new HashMap<>();
+
+    boolean shouldCheck(CompilationUnitTree unit) {
+        return shouldCheck.computeIfAbsent(unit, doclint :: shouldCheck);
+    }
 }
--- a/src/jdk.javadoc/share/classes/com/sun/tools/javadoc/DocImpl.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.javadoc/share/classes/com/sun/tools/javadoc/DocImpl.java	Thu Jul 16 19:31:01 2015 -0700
@@ -129,6 +129,7 @@
             String d = documentation();
             if (env.doclint != null
                     && treePath != null
+                    && env.shouldCheck(treePath.getCompilationUnit())
                     && d.equals(getCommentText(treePath))) {
                 env.doclint.scan(treePath);
             }
--- a/src/jdk.jdeps/share/classes/com/sun/tools/classfile/ReferenceFinder.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.jdeps/share/classes/com/sun/tools/classfile/ReferenceFinder.java	Thu Jul 16 19:31:01 2015 -0700
@@ -36,7 +36,7 @@
 /**
  * A utility class to find where in a ClassFile references
  * a {@link CONSTANT_Methodref_info method},
- * a {@link CONSTANT_InterfaceMethodref_info interface method,
+ * a {@link CONSTANT_InterfaceMethodref_info interface method},
  * or a {@link CONSTANT_Fieldref_info field}.
  */
 public final class ReferenceFinder {
--- a/src/jdk.jdeps/share/classes/com/sun/tools/jdeps/PlatformClassPath.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/src/jdk.jdeps/share/classes/com/sun/tools/jdeps/PlatformClassPath.java	Thu Jul 16 19:31:01 2015 -0700
@@ -97,23 +97,32 @@
     }
 
     static class ImageHelper {
+        private static boolean isJrtAvailable() {
+            try {
+                FileSystems.getFileSystem(URI.create("jrt:/"));
+                return true;
+            } catch (ProviderNotFoundException | FileSystemNotFoundException e) {
+                return false;
+            }
+        }
+
         static ImageHelper getInstance(Path mpath) throws IOException {
             if (mpath != null) {
                 return new ImageHelper(mpath);
             }
-            Path home = Paths.get(System.getProperty("java.home"));
-            Path mlib = home.resolve("lib").resolve("modules");
-            if (Files.isDirectory(mlib)) {
-                // jimage
+
+            if (isJrtAvailable()) {
+                // jrt file system
                 FileSystem fs = FileSystems.getFileSystem(URI.create("jrt:/"));
-                return new ImageHelper(fs, fs.getPath("/"));
+                return new ImageHelper(fs, fs.getPath("/modules"));
             } else {
                 // exploded modules
-                mlib = home.resolve("modules");
-                if (!Files.isDirectory(mlib)) {
-                    throw new InternalError(home + " not a modular image");
+                String home = System.getProperty("java.home");
+                Path exploded = Paths.get(home, "modules");
+                if (!Files.isDirectory(exploded)) {
+                     throw new InternalError(home + " not a modular image");
                 }
-                return new ImageHelper(mlib);
+                return new ImageHelper(exploded);
             }
         }
 
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/classfiles/attributes/annotations/AnnotationsTestBase.java	Thu Jul 16 19:31:01 2015 -0700
@@ -0,0 +1,258 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+import com.sun.tools.classfile.Attribute;
+import com.sun.tools.classfile.ConstantPoolException;
+import com.sun.tools.classfile.Descriptor;
+
+import javax.tools.JavaFileObject;
+import java.io.IOException;
+import java.lang.annotation.RetentionPolicy;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+public abstract class AnnotationsTestBase extends TestResult {
+
+    /**
+     * Element values which are used in generation of annotations.
+     */
+    private static final TestAnnotationInfo.Pair[] elementValues = {
+            new TestAnnotationInfo.Pair("booleanValue", new TestAnnotationInfo.TestBooleanElementValue(true)),
+            new TestAnnotationInfo.Pair("byteValue", new TestAnnotationInfo.TestIntegerElementValue('B', 83)),
+            new TestAnnotationInfo.Pair("charValue", new TestAnnotationInfo.TestCharElementValue('H')),
+            new TestAnnotationInfo.Pair("shortValue", new TestAnnotationInfo.TestIntegerElementValue('S', 14)),
+            new TestAnnotationInfo.Pair("intValue", new TestAnnotationInfo.TestIntegerElementValue('I', 18)),
+            new TestAnnotationInfo.Pair("longValue", new TestAnnotationInfo.TestLongElementValue(14)),
+            new TestAnnotationInfo.Pair("floatValue", new TestAnnotationInfo.TestFloatElementValue(-1)),
+            new TestAnnotationInfo.Pair("doubleValue", new TestAnnotationInfo.TestDoubleElementValue(-83)),
+            new TestAnnotationInfo.Pair("stringValue", new TestAnnotationInfo.TestStringElementValue("///")),
+            new TestAnnotationInfo.Pair("arrayValue1", new TestAnnotationInfo.TestArrayElementValue(
+                    new TestAnnotationInfo.TestIntegerElementValue('I', 1),
+                    new TestAnnotationInfo.TestIntegerElementValue('I', 4),
+                    new TestAnnotationInfo.TestIntegerElementValue('I', 8),
+                    new TestAnnotationInfo.TestIntegerElementValue('I', 3))),
+            new TestAnnotationInfo.Pair("arrayValue2", new TestAnnotationInfo.TestArrayElementValue(
+                    new TestAnnotationInfo.TestStringElementValue("AAA"),
+                    new TestAnnotationInfo.TestStringElementValue("BBB"))),
+            new TestAnnotationInfo.Pair("enumValue", new TestAnnotationInfo.TestEnumElementValue("EnumValue", "VALUE2")),
+            new TestAnnotationInfo.Pair("classValue1", new TestAnnotationInfo.TestClassElementValue("void.class")),
+            new TestAnnotationInfo.Pair("classValue2", new TestAnnotationInfo.TestClassElementValue("Character.class")),
+            new TestAnnotationInfo.Pair("annoValue", new TestAnnotationInfo.TestAnnotationElementValue("AnnotationValue",
+                    new TestAnnotationInfo("AnnotationValue", RetentionPolicy.CLASS,
+                            new TestAnnotationInfo.Pair("stringValue",
+                                    new TestAnnotationInfo.TestStringElementValue("StringValue1"))))),
+            new TestAnnotationInfo.Pair("annoArrayValue", new TestAnnotationInfo.TestArrayElementValue(
+                    new TestAnnotationInfo.TestAnnotationElementValue("AnnotationValue",
+                            new TestAnnotationInfo("AnnotationValue", RetentionPolicy.CLASS,
+                                new TestAnnotationInfo.Pair("stringValue",
+                                        new TestAnnotationInfo.TestStringElementValue("StringValue1")))),
+                    new TestAnnotationInfo.TestAnnotationElementValue("AnnotationValue",
+                            new TestAnnotationInfo("AnnotationValue", RetentionPolicy.CLASS,
+                                    new TestAnnotationInfo.Pair("stringValue",
+                                            new TestAnnotationInfo.TestStringElementValue("StringValue1"))))))
+    };
+
+    /**
+     * Masks which are used in generation of annotations.
+     * E.g. mask 0 corresponds to an annotation without element values.
+     */
+    private static final int[] elementValuesCombinations;
+
+    static {
+        List<Integer> combinations = new ArrayList<>();
+        combinations.add(0);
+        for (int i = 0; i < elementValues.length; ++i) {
+            combinations.add(1 << i);
+        }
+        // pairs int value and another value
+        for (int i = 0; i < elementValues.length; ++i) {
+            combinations.add((1 << 5) | (1 << i));
+        }
+        combinations.add((1 << elementValues.length) - 1);
+        elementValuesCombinations = combinations.stream().mapToInt(Integer::intValue).toArray();
+    }
+
+    /**
+     * Method generates a list of test cases.
+     * Method is called in the method {@code call()}.
+     *
+     * @return a list of test cases
+     */
+    public abstract List<TestCase> generateTestCases();
+
+    public abstract void test(TestCase testCase, Map<String, ? extends JavaFileObject> classes)
+            throws IOException, ConstantPoolException, Descriptor.InvalidDescriptor;
+
+    /**
+     * The method is used to create a repeatable annotation.
+     */
+    private TestAnnotationInfo createSomeAnnotation(String annotationName) {
+        return new TestAnnotationInfo(annotationName, getRetentionPolicy(annotationName),
+                new TestAnnotationInfo.Pair("booleanValue",
+                        new TestAnnotationInfo.TestBooleanElementValue(true)),
+                new TestAnnotationInfo.Pair("intValue",
+                        new TestAnnotationInfo.TestIntegerElementValue('I', 1)),
+                new TestAnnotationInfo.Pair("enumValue",
+                        new TestAnnotationInfo.TestEnumElementValue("EnumValue", "VALUE1")));
+    }
+
+    private TestAnnotationInfo getAnnotationByMask(String annotationName, int mask) {
+        List<TestAnnotationInfo.Pair> pairs = new ArrayList<>();
+        for (int i = 0; i < elementValues.length; ++i) {
+            if ((mask & (1 << i)) != 0) {
+                pairs.add(elementValues[i]);
+            }
+        }
+        return new TestAnnotationInfo(
+                annotationName,
+                getRetentionPolicy(annotationName),
+                pairs.toArray(new TestAnnotationInfo.Pair[pairs.size()]));
+    }
+
+    /**
+     * Class represents annotations which will be applied to one method.
+     */
+    public static class TestAnnotationInfos {
+        public final List<TestAnnotationInfo> annotations;
+
+        public TestAnnotationInfos(List<TestAnnotationInfo> a) {
+            this.annotations = a;
+        }
+
+        public void annotate(TestCase.TestMemberInfo memberInfo) {
+            annotations.forEach(memberInfo::addAnnotation);
+        }
+    }
+
+    /**
+     * Convenience method to group test cases.
+     * Increases speed of tests.
+     */
+    public List<List<TestAnnotationInfos>> groupAnnotations(List<TestAnnotationInfos> annotations) {
+        List<List<TestAnnotationInfos>> groupedAnnotations = new ArrayList<>();
+        int size = 32;
+        List<TestAnnotationInfos> current = null;
+        for (TestAnnotationInfos infos : annotations) {
+            if (current == null || current.size() == size) {
+                current = new ArrayList<>();
+                groupedAnnotations.add(current);
+            }
+            current.add(infos);
+        }
+        return groupedAnnotations;
+    }
+
+    public List<TestAnnotationInfos> getAllCombinationsOfAnnotations() {
+        List<TestAnnotationInfos> combinations = new ArrayList<>();
+        for (Annotations annotationName1 : Annotations.values()) {
+            List<TestAnnotationInfo> list = IntStream.of(elementValuesCombinations)
+                    .mapToObj(e -> getAnnotationByMask(annotationName1.getAnnotationName(), e))
+                    .collect(Collectors.toList());
+            // add cases with a single annotation
+            combinations.addAll(list.stream()
+                    .map(Collections::singletonList)
+                    .map(TestAnnotationInfos::new)
+                    .collect(Collectors.toList()));
+
+            // add cases with a repeatable annotation
+            for (Annotations annotationName2 : Annotations.values()) {
+                if (annotationName1 == annotationName2 && !annotationName1.isRepeatable()) {
+                    continue;
+                }
+                TestAnnotationInfo annotation2 = createSomeAnnotation(annotationName2.getAnnotationName());
+                for (TestAnnotationInfo annotation1 : list) {
+                    List<TestAnnotationInfo> list1 = new ArrayList<>();
+                    Collections.addAll(list1, annotation1, annotation2);
+                    combinations.add(new TestAnnotationInfos(list1));
+                }
+            }
+        }
+        return combinations;
+    }
+
+    protected RetentionPolicy getRetentionPolicy(String name) {
+        if (name.contains("Visible")) {
+            return RetentionPolicy.RUNTIME;
+        } else if (name.contains("Invisible")) {
+            return RetentionPolicy.CLASS;
+        }
+        throw new IllegalArgumentException(name);
+    }
+
+    protected long countNumberOfAttributes(Attribute[] attrs,
+                                               Class<? extends Attribute> clazz) {
+        return Stream.of(attrs)
+                .filter(clazz::isInstance)
+                .count();
+    }
+
+    public void test() throws TestFailedException {
+        try {
+            List<TestCase> testCases = generateTestCases();
+            for (int i = 0; i < testCases.size(); ++i) {
+                TestCase testCase = testCases.get(i);
+                String source = testCase.generateSource();
+                Path sourceFile = Paths.get(getClass().getSimpleName() + i + ".java");
+                addTestCase(sourceFile.toAbsolutePath().toString());
+                writeToFile(sourceFile, source);
+                echo("Testing: " + sourceFile.toString());
+                try {
+                    test(testCase, compile(source).getClasses());
+                } catch (Exception e) {
+                    addFailure(e);
+                }
+            }
+        } catch (RuntimeException | IOException e) {
+            addFailure(e);
+        } finally {
+            checkStatus();
+        }
+    }
+
+    public enum Annotations {
+        RUNTIME_INVISIBLE_REPEATABLE("RuntimeInvisibleRepeatable", true),
+        RUNTIME_INVISIBLE_NOT_REPEATABLE("RuntimeInvisibleNotRepeatable", false),
+        RUNTIME_VISIBLE_REPEATABLE("RuntimeVisibleRepeatable", true),
+        RUNTIME_VISIBLE_NOT_REPEATABLE("RuntimeVisibleNotRepeatable", false);
+
+        private final String annotationName;
+        private final boolean isRepeatable;
+
+        Annotations(String annotationName, boolean isRepeatable) {
+            this.annotationName = annotationName;
+            this.isRepeatable = isRepeatable;
+        }
+
+        public String getAnnotationName() {
+            return annotationName;
+        }
+
+        public boolean isRepeatable() {
+            return isRepeatable;
+        }
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/classfiles/attributes/annotations/ClassType.java	Thu Jul 16 19:31:01 2015 -0700
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+import java.util.Collection;
+import java.util.stream.Collectors;
+
+public enum  ClassType {
+    CLASS("class"),
+    INTERFACE("interface") {
+        @Override
+        public String methodToString(TestCase.TestMethodInfo method) {
+            String modifiers = method.mods.stream()
+                    .collect(Collectors.joining(" "));
+            boolean hasBody = modifiers.contains("static") || modifiers.contains("default");
+            String parameters = method.parameters.stream()
+                    .map(TestCase.TestMemberInfo::generateSource)
+                    .collect(Collectors.joining(", "));
+            return String.format("%s %s %s(%s) %s",
+                    method.indention() + modifiers,
+                    "int",
+                    method.getName(),
+                    parameters,
+                    hasBody ? "{return 0;}" : ";");
+        }
+    },
+    ANNOTATION("@interface") {
+        @Override
+        public String methodToString(TestCase.TestMethodInfo method) {
+            String modifiers = method.mods.stream()
+                    .collect(Collectors.joining(" "));
+            return String.format("%s %s %s() %s",
+                    method.indention() + modifiers,
+                    "int",
+                    method.getName(),
+                    ";");
+        }
+    },
+    ENUM("enum") {
+        @Override
+        public String fieldToString(TestCase.TestFieldInfo field) {
+            return field.indention() + field.name;
+        }
+
+        @Override
+        public String collectFields(Collection<TestCase.TestFieldInfo> fields) {
+            return fields.stream()
+                    .map(TestCase.TestMemberInfo::generateSource)
+                    .collect(Collectors.joining(",\n")) + ";\n";
+        }
+    };
+
+    private final String classType;
+
+    ClassType(String classType) {
+        this.classType = classType;
+    }
+
+    private String collectSrc(Collection<? extends TestCase.TestMemberInfo> members) {
+        String src = members.stream()
+                .map(TestCase.TestMemberInfo::generateSource)
+                .collect(Collectors.joining("\n"));
+        return src.trim().isEmpty() ? "" : src + "\n\n";
+    }
+
+    public String collectInnerClasses(Collection<TestCase.TestClassInfo> innerClasses) {
+        return collectSrc(innerClasses);
+    }
+
+    public String collectFields(Collection<TestCase.TestFieldInfo> fields) {
+        return collectSrc(fields);
+    }
+
+    public String collectMethods(Collection<TestCase.TestMethodInfo> methods) {
+        return collectSrc(methods);
+    }
+
+    public String methodToString(TestCase.TestMethodInfo method) {
+        String modifiers = method.mods.stream()
+                .collect(Collectors.joining(" "));
+        String parameters = method.parameters.stream()
+                .map(TestCase.TestMemberInfo::generateSource)
+                .collect(Collectors.joining(", "));
+        String localClasses = collectInnerClasses(method.localClasses.values());
+        String methodBody = modifiers.contains("abstract") ? ";" :
+                String.format("{%n%s%s%n%s}",
+                        localClasses,
+                        method.isConstructor
+                                ? ""
+                                : method.indention() + "return false;",
+                        method.indention());
+        return String.format("%s %s %s(%s) %s",
+                method.indention() + modifiers,
+                method.isConstructor ? "" : "boolean",
+                method.getName(),
+                parameters,
+                methodBody);
+    }
+
+    public String fieldToString(TestCase.TestFieldInfo field) {
+        String modifiers = field.mods.stream()
+                .collect(Collectors.joining(" "));
+        return String.format("%s int %s = 0;",
+                field.indention() + modifiers,
+                field.name);
+    }
+
+    public String getDescription() {
+        return classType;
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/classfiles/attributes/annotations/README.txt	Thu Jul 16 19:31:01 2015 -0700
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+== Description of tests for RuntimeVisibleAnnotations, RuntimeInVisibleAnnotations
+RuntimeVisibleParameterAnnotations and RuntimeInvisibleParameterAnnotations attributes ==
+
+* AnnotationsTestBase class is a base class for the Annotations attribute tests.
+It contains some convenience methods which might be used in derived classes.
+
+* ClassType is a enum which is used for convenience code generation (see TestCase).
+
+* TestCase is a class which represent a test case. TestCase contains TestClassInfo,
+which represents a class, TestMethodInfo, which represents a method, TestFieldInfo,
+which represents a field, and TestParameterInfo, which represents a method's parameter.
+The class is used as test case builder. For example, the following code creates
+the top-level class Test with method classMethod() and local class Local.
+Each program member is annotated by some annotation which is an instance of
+TestAnnotationInfo (see TestAnnotationInfo):
+
+    TestCase test = new TestCase(ClassType.CLASS, "Test", "public");
+    test.clazz.addAnnotation(annotations);
+    TestCase.TestMethodInfo classMethod = test.clazz.addMethod("classMethod()");
+    classMethod.addAnnotation(annotation);
+    TestCase.TestClassInfo localClassInClassMethod = classMethod.addLocalClass("Local");
+    localClassInClassMethod.addAnnotation(annotations);
+
+Let "annotations" be a list of annotations A, B(i = 2). Thus, a test will generate the
+following code:
+
+    @A
+    @B(i = 2)
+    public class Test {
+        @A
+        @B(i = 2)
+        void classMethod() {
+            @A
+            @B(i = 2)
+            class Local {
+            }
+        }
+    }
+
+Thus, TestCase contains information about structure of classes and golden data
+about annotations. Thereafter, sources can be generated from this class representation
+by calling method generateSource(). Enum ClassType is used to handle "class type specific"
+code generation. For example, not-abstract method in a class always has body,
+while not-static and not-default method in an interface does not.
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/classfiles/attributes/annotations/RuntimeAnnotationsForGenericMethodTest.java	Thu Jul 16 19:31:01 2015 -0700
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 8044411
+ * @summary Tests the RuntimeVisibleAnnotations/RuntimeInvisibleAnnotations attribute.
+ *          Checks that the attribute is generated for bridge method.
+ * @library /tools/lib /tools/javac/lib ../lib
+ * @build WorkAnnotations TestBase TestResult InMemoryFileManager ToolBox
+ * @build TestCase ClassType TestAnnotationInfo
+ * @build RuntimeAnnotationsForGenericMethodTest AnnotationsTestBase RuntimeAnnotationsTestBase
+ * @run main RuntimeAnnotationsForGenericMethodTest
+ */
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * RuntimeAnnotationsGenericMethodTest is a test which check that
+ * RuntimeVisibleAnnotationsAttribute and RuntimeInvisibleAnnotationsAttribute
+ * are generated for both generic and appropriate bridge methods.
+ * All possible combinations of retention policies are tested.
+ *
+ * The test generates class which looks as follows:
+ *
+ * public class Test extends java.util.ArrayList&lt;Integer&gt; {
+ *     here some annotations
+ *     public boolean add(java.lang.Integer) {
+ *         return false;
+ *     }
+ * }
+ *
+ * Thereafter, various of combinations of annotations are applied
+ * to the add, the source is compiled and the generated byte code is checked.
+ *
+ * See README.txt for more information.
+ */
+public class RuntimeAnnotationsForGenericMethodTest extends RuntimeAnnotationsTestBase {
+
+    @Override
+    public List<TestCase> generateTestCases() {
+        List<TestCase> testCases = new ArrayList<>();
+        for (List<TestAnnotationInfos> groupedAnnotations : groupAnnotations(getAllCombinationsOfAnnotations())) {
+            TestCase testCase = new TestCase();
+            for (int i = 0; i < groupedAnnotations.size(); ++i) {
+                TestAnnotationInfos annotations = groupedAnnotations.get(i);
+                // generate: public class Test extends java.util.ArrayList<Integer>
+                TestCase.TestClassInfo clazz = testCase.addClassInfo("java.util.ArrayList<Integer>", ClassType.CLASS, "Test" + i);
+                TestCase.TestMethodInfo method = clazz.addMethodInfo("add(java.lang.Integer)", "public");
+                method.addParameter("Integer", "i");
+                annotations.annotate(method);
+                TestCase.TestMethodInfo synMethod = clazz.addMethodInfo("add(java.lang.Object)", true, "public");
+                annotations.annotate(synMethod);
+            }
+            testCases.add(testCase);
+        }
+        return testCases;
+    }
+
+    public static void main(String[] args) throws TestFailedException {
+        new RuntimeAnnotationsForGenericMethodTest().test();
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/classfiles/attributes/annotations/RuntimeAnnotationsForInnerAnnotationTest.java	Thu Jul 16 19:31:01 2015 -0700
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 8044411
+ * @summary Tests the RuntimeVisibleAnnotations/RuntimeInvisibleAnnotations attribute.
+ * @library /tools/lib /tools/javac/lib ../lib
+ * @build WorkAnnotations TestBase TestResult InMemoryFileManager ToolBox
+ * @build TestCase ClassType TestAnnotationInfo
+ * @build RuntimeAnnotationsForInnerAnnotationTest AnnotationsTestBase RuntimeAnnotationsTestBase
+ * @run main RuntimeAnnotationsForInnerAnnotationTest
+ */
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * The test checks that RuntimeVisibleAnnotationsAttribute and RuntimeInvisibleAnnotationsAttribute
+ * are generated properly for inner classes annotations, for methods, for fields
+ *
+ * The test checks both single and repeatable annotations. In addition, all possible combinations
+ * of retention policies are tested. The test generates source code, compiles it and checks the byte code.
+ *
+ * See README.txt for more information.
+ */
+public class RuntimeAnnotationsForInnerAnnotationTest extends RuntimeAnnotationsTestBase {
+    @Override
+    public List<TestCase> generateTestCases() {
+        List<TestCase> testCases = new ArrayList<>();
+        for (List<TestAnnotationInfos> groupedAnnotations : groupAnnotations(getAllCombinationsOfAnnotations())) {
+            for (ClassType outerClassType : ClassType.values()) {
+                TestCase test = new TestCase();
+                TestCase.TestClassInfo clazz = test.addClassInfo(outerClassType, "Test");
+                for (int i = 0; i < groupedAnnotations.size(); ++i) {
+                    TestCase.TestClassInfo anno = clazz.addInnerClassInfo(ClassType.ANNOTATION, "InnerAnnotation" + i);
+                    TestAnnotationInfos annotations = groupedAnnotations.get(i);
+                    annotations.annotate(anno);
+
+                    TestCase.TestMethodInfo annoMethod = anno.addMethodInfo("interMethod" + i + "()");
+                    annotations.annotate(annoMethod);
+
+                    TestCase.TestFieldInfo annoField = anno.addFieldInfo("annoField" + i);
+                    annotations.annotate(annoField);
+                }
+                testCases.add(test);
+            }
+        }
+        return testCases;
+    }
+
+    public static void main(String[] args) throws TestFailedException {
+        new RuntimeAnnotationsForInnerAnnotationTest().test();
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/classfiles/attributes/annotations/RuntimeAnnotationsForInnerClassTest.java	Thu Jul 16 19:31:01 2015 -0700
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 8044411
+ * @summary Tests the RuntimeVisibleAnnotations/RuntimeInvisibleAnnotations attribute.
+ * @library /tools/lib /tools/javac/lib ../lib
+ * @build WorkAnnotations TestBase TestResult InMemoryFileManager ToolBox
+ * @build TestCase ClassType TestAnnotationInfo
+ * @build RuntimeAnnotationsForInnerClassTest AnnotationsTestBase RuntimeAnnotationsTestBase
+ * @run main RuntimeAnnotationsForInnerClassTest
+ */
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * The test checks that RuntimeVisibleAnnotationsAttribute and RuntimeInvisibleAnnotationsAttribute
+ * are generated properly for inner classes, for constructors, for methods, for fields.
+ * The test checks both single and repeatable annotations. In addition, all possible combinations
+ * of retention policies are tested.
+ *
+ * The test generates source code, compiles it and checks the byte code.
+ *
+ * See README.txt for more information.
+ */
+public class RuntimeAnnotationsForInnerClassTest extends RuntimeAnnotationsTestBase {
+    @Override
+    public List<TestCase> generateTestCases() {
+        List<TestCase> testCases = new ArrayList<>();
+        for (List<TestAnnotationInfos> groupedAnnotations : groupAnnotations(getAllCombinationsOfAnnotations())) {
+            for (ClassType outerClassType : ClassType.values()) {
+                TestCase test = new TestCase();
+                TestCase.TestClassInfo outerClazz = test.addClassInfo(outerClassType, "Test");
+                for (int i = 0; i < groupedAnnotations.size(); ++i) {
+                    TestAnnotationInfos annotations = groupedAnnotations.get(i);
+                    TestCase.TestClassInfo clazz = outerClazz.addInnerClassInfo(ClassType.CLASS, "InnerClass" + i, "static");
+                    annotations.annotate(clazz);
+
+                    TestCase.TestMethodInfo constructor = clazz.addMethodInfo("<init>()");
+                    annotations.annotate(constructor);
+
+                    TestCase.TestClassInfo localClassInConstructor = constructor.addLocalClassInfo("Local1" + i);
+                    annotations.annotate(localClassInConstructor);
+
+                    TestCase.TestMethodInfo innerClazzMethod = clazz.addMethodInfo("innerClassMethod" + i + "()");
+                    annotations.annotate(innerClazzMethod);
+
+                    TestCase.TestClassInfo localClassInClassMethod = innerClazzMethod.addLocalClassInfo("Local2" + i);
+                    annotations.annotate(localClassInClassMethod);
+
+                    TestCase.TestMethodInfo innerStaticClazzMethod = clazz.addMethodInfo("innerStaticClassMethod" + i + "()", "static");
+                    annotations.annotate(innerStaticClazzMethod);
+
+                    TestCase.TestClassInfo localClassInStaticMethod = innerStaticClazzMethod.addLocalClassInfo("Local3" + i);
+                    annotations.annotate(localClassInStaticMethod);
+                }
+                testCases.add(test);
+            }
+        }
+        return testCases;
+    }
+
+    public static void main(String[] args) throws TestFailedException {
+        new RuntimeAnnotationsForInnerClassTest().test();
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/classfiles/attributes/annotations/RuntimeAnnotationsForInnerEnumTest.java	Thu Jul 16 19:31:01 2015 -0700
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 8044411
+ * @summary Tests the RuntimeVisibleAnnotations/RuntimeInvisibleAnnotations attribute.
+ * @library /tools/lib /tools/javac/lib ../lib
+ * @build WorkAnnotations TestBase TestResult InMemoryFileManager ToolBox
+ * @build TestCase ClassType TestAnnotationInfo
+ * @build RuntimeAnnotationsForInnerEnumTest AnnotationsTestBase RuntimeAnnotationsTestBase
+ * @run main RuntimeAnnotationsForInnerEnumTest
+ */
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * The test checks that RuntimeVisibleAnnotationsAttribute and RuntimeInvisibleAnnotationsAttribute
+ * are generated properly for inner classes enums, for constructors, for methods,
+ * for fields (enum, class, annotation, interface). The test checks both
+ * single and repeatable annotations. In addition, all possible combinations
+ * of retention policies are tested.
+ *
+ * The test generates source code, compiles it and checks the byte code.
+ *
+ * See README.txt for more information.
+ */
+public class RuntimeAnnotationsForInnerEnumTest extends RuntimeAnnotationsTestBase {
+    @Override
+    public List<TestCase> generateTestCases() {
+        List<TestCase> testCases = new ArrayList<>();
+        for (List<TestAnnotationInfos> groupedAnnotations : groupAnnotations(getAllCombinationsOfAnnotations())) {
+            for (ClassType outerClassType : ClassType.values()) {
+                TestCase test = new TestCase();
+                TestCase.TestClassInfo outerClassInfo = test.addClassInfo(outerClassType, "Test");
+                for (int i = 0; i < groupedAnnotations.size(); i++) {
+                    TestAnnotationInfos annotations = groupedAnnotations.get(i);
+                    TestCase.TestClassInfo clazz = outerClassInfo.addInnerClassInfo(ClassType.ENUM, "Enum" + i);
+                    annotations.annotate(clazz);
+
+                    TestCase.TestMethodInfo innerClazzMethod = clazz.addMethodInfo("innerClassMethod" + i + "()");
+                    annotations.annotate(innerClazzMethod);
+
+                    TestCase.TestClassInfo localClassInClassMethod = innerClazzMethod.addLocalClassInfo("Local1" + i);
+                    annotations.annotate(localClassInClassMethod);
+
+                    TestCase.TestMethodInfo innerStaticClazzMethod = clazz.addMethodInfo("innerStaticClassMethod" + i + "()", "static");
+                    annotations.annotate(innerStaticClazzMethod);
+
+                    TestCase.TestClassInfo localClassInStaticMethod = innerStaticClazzMethod.addLocalClassInfo("Local2" + i);
+                    annotations.annotate(localClassInStaticMethod);
+
+                    TestCase.TestFieldInfo valueA = clazz.addFieldInfo("A" + i);
+                    annotations.annotate(valueA);
+
+                    TestCase.TestFieldInfo valueB = clazz.addFieldInfo("B" + i);
+                    annotations.annotate(valueB);
+                }
+                testCases.add(test);
+            }
+        }
+        return testCases;
+    }
+
+    public static void main(String[] args) throws TestFailedException {
+        new RuntimeAnnotationsForInnerEnumTest().test();
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/classfiles/attributes/annotations/RuntimeAnnotationsForInnerInterfaceTest.java	Thu Jul 16 19:31:01 2015 -0700
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 8044411
+ * @summary Tests the RuntimeVisibleAnnotations/RuntimeInvisibleAnnotations attribute.
+ * @library /tools/lib /tools/javac/lib ../lib
+ * @build WorkAnnotations TestBase TestResult InMemoryFileManager ToolBox
+ * @build TestCase ClassType TestAnnotationInfo
+ * @build RuntimeAnnotationsForInnerInterfaceTest AnnotationsTestBase RuntimeAnnotationsTestBase
+ * @run main RuntimeAnnotationsForInnerInterfaceTest
+ */
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * The test checks that RuntimeVisibleAnnotationsAttribute and RuntimeInvisibleAnnotationsAttribute
+ * are generated properly for inner interfaces, for methods, for fields. The test checks both
+ * single and repeatable annotations. In addition, all possible combinations
+ * of retention policies are tested.
+ *
+ * The test generates source code, compiles it and checks the byte code.
+ *
+ * See README.txt for more information.
+ */
+public class RuntimeAnnotationsForInnerInterfaceTest extends RuntimeAnnotationsTestBase {
+    @Override
+    public List<TestCase> generateTestCases() {
+        List<TestCase> testCases = new ArrayList<>();
+        for (List<TestAnnotationInfos> groupedAnnotations : groupAnnotations(getAllCombinationsOfAnnotations())) {
+            for (ClassType outerClassType : ClassType.values()) {
+                TestCase test = new TestCase();
+                TestCase.TestClassInfo outerClass = test.addClassInfo(outerClassType, "Test");
+                for (int i = 0; i < groupedAnnotations.size(); ++i) {
+                    TestAnnotationInfos annotations = groupedAnnotations.get(i);
+                    TestCase.TestClassInfo inter = outerClass.addInnerClassInfo(ClassType.INTERFACE, "InnerInterface" + i);
+                    annotations.annotate(inter);
+
+                    TestCase.TestFieldInfo interField = inter.addFieldInfo("interField" + i);
+                    annotations.annotate(interField);
+
+                    TestCase.TestMethodInfo interMethod = inter.addMethodInfo("interMethod" + i + "()");
+                    annotations.annotate(interMethod);
+
+                    TestCase.TestMethodInfo interStaticMethod = inter.addMethodInfo("interStaticMethod" + i + "()", "static");
+                    annotations.annotate(interStaticMethod);
+
+                    TestCase.TestClassInfo localClassInStaticMethod = interStaticMethod.addLocalClassInfo("Local1" + i);
+                    annotations.annotate(localClassInStaticMethod);
+
+                    TestCase.TestMethodInfo interDefaultMethod = inter.addMethodInfo("interDefaultMethod" + i + "()", "default");
+                    annotations.annotate(interDefaultMethod);
+
+                    TestCase.TestClassInfo localClassInDefaultMethod = interDefaultMethod.addLocalClassInfo("Local2" + i);
+                    annotations.annotate(localClassInDefaultMethod);
+                }
+                testCases.add(test);
+            }
+        }
+        return testCases;
+    }
+
+    public static void main(String[] args) throws TestFailedException {
+        new RuntimeAnnotationsForInnerInterfaceTest().test();
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/classfiles/attributes/annotations/RuntimeAnnotationsForTopLevelClassTest.java	Thu Jul 16 19:31:01 2015 -0700
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 8044411
+ * @summary Tests the RuntimeVisibleAnnotations/RuntimeInvisibleAnnotations attribute.
+ * @library /tools/lib /tools/javac/lib ../lib
+ * @build WorkAnnotations TestBase TestResult InMemoryFileManager ToolBox
+ * @build TestCase ClassType TestAnnotationInfo
+ * @build RuntimeAnnotationsForTopLevelClassTest AnnotationsTestBase RuntimeAnnotationsTestBase
+ * @run main RuntimeAnnotationsForTopLevelClassTest
+ */
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * The test checks that RuntimeVisibleAnnotationsAttribute and RuntimeInvisibleAnnotationsAttribute
+ * are generated properly for top-level class (class, enum, annotation, interface),
+ * for constructors (in enum and in class), for methods (abstract methods, static and default methods in interface),
+ * for fields. The test checks both single and repeatable annotations.
+ * In addition, all possible combinations of retention policies are tested.
+ *
+ * The test generates source code, compiles it and checks the byte code.
+ *
+ * See README.txt for more information.
+ */
+public class RuntimeAnnotationsForTopLevelClassTest extends RuntimeAnnotationsTestBase {
+
+    @Override
+    public List<TestCase> generateTestCases() {
+        List<TestCase> testCases = new ArrayList<>();
+        for (List<TestAnnotationInfos> groupedAnnotations : groupAnnotations(getAllCombinationsOfAnnotations())) {
+            for (ClassType classType : ClassType.values()) {
+                TestCase test = new TestCase();
+                for (int i = 0; i < groupedAnnotations.size(); ++i) {
+                    TestAnnotationInfos annotations = groupedAnnotations.get(i);
+                    TestCase.TestClassInfo clazz = test.addClassInfo(classType, "Test" + i);
+                    annotations.annotate(clazz);
+
+                    if (classType != ClassType.ENUM) {
+                        TestCase.TestMethodInfo constructor = clazz.addMethodInfo("<init>()");
+                        annotations.annotate(constructor);
+
+                        TestCase.TestClassInfo localClass = constructor.addLocalClassInfo("Local1" + i);
+                        annotations.annotate(localClass);
+                    }
+                    if (classType != ClassType.ANNOTATION) {
+                        TestCase.TestMethodInfo staticClassMethod = clazz.addMethodInfo("staticClassMethod" + i + "()", "static");
+                        annotations.annotate(staticClassMethod);
+
+                        TestCase.TestClassInfo localClassInStaticMethod = staticClassMethod.addLocalClassInfo("Local2" + i);
+                        annotations.annotate(localClassInStaticMethod);
+                    }
+                    TestCase.TestMethodInfo classMethod = clazz.addMethodInfo("classMethod" + i + "()");
+                    annotations.annotate(classMethod);
+
+                    TestCase.TestClassInfo localClassInClassMethod = classMethod.addLocalClassInfo("Local3" + i);
+                    annotations.annotate(localClassInClassMethod);
+
+                    TestCase.TestFieldInfo field = clazz.addFieldInfo("field" + i);
+                    annotations.annotate(field);
+
+                    TestCase.TestFieldInfo staticField = clazz.addFieldInfo("staticField" + i, "static");
+                    annotations.annotate(staticField);
+                }
+                testCases.add(test);
+            }
+        }
+        return testCases;
+    }
+
+    public static void main(String[] args) throws TestFailedException {
+        new RuntimeAnnotationsForTopLevelClassTest().test();
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/classfiles/attributes/annotations/RuntimeAnnotationsTestBase.java	Thu Jul 16 19:31:01 2015 -0700
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+import com.sun.tools.classfile.*;
+
+import java.io.IOException;
+import java.lang.annotation.RetentionPolicy;
+import java.util.*;
+import java.util.function.Supplier;
+
+import javax.tools.JavaFileObject;
+
+public abstract class RuntimeAnnotationsTestBase extends AnnotationsTestBase {
+
+    @Override
+    public void test(TestCase testCase, Map<String, ? extends JavaFileObject> classes)
+            throws IOException, ConstantPoolException, Descriptor.InvalidDescriptor {
+        for (Map.Entry<String, ? extends JavaFileObject> entry : classes.entrySet()) {
+            String className = entry.getKey();
+            TestCase.TestClassInfo clazz = testCase.getTestClassInfo(className);
+            echo("Testing class : " + className);
+            ClassFile classFile = readClassFile(entry.getValue());
+
+            testAttributes(clazz, classFile, () -> classFile.attributes);
+
+            testMethods(clazz, classFile);
+
+            testFields(clazz, classFile);
+        }
+    }
+
+    private void testMethods(TestCase.TestClassInfo clazz, ClassFile classFile)
+            throws ConstantPoolException, Descriptor.InvalidDescriptor {
+        String className = clazz.getName();
+        Set<String> foundMethods = new HashSet<>();
+        for (Method method : classFile.methods) {
+            String methodName = method.getName(classFile.constant_pool) +
+                    method.descriptor.getParameterTypes(classFile.constant_pool);
+            if (methodName.startsWith("<init>")) {
+                String constructorName = className.replaceAll(".*\\$", "");
+                methodName = methodName.replace("<init>", constructorName);
+            }
+            echo("Testing method : " + methodName);
+
+            TestCase.TestMethodInfo testMethod = clazz.getTestMethodInfo(methodName);
+            foundMethods.add(methodName);
+            if (testMethod == null) {
+                continue;
+            }
+            testAttributes(testMethod, classFile, () -> method.attributes);
+        }
+        checkContains(foundMethods, clazz.methods.keySet(), "Methods in class : " + className);
+    }
+
+    private void testFields(TestCase.TestClassInfo clazz, ClassFile classFile)
+            throws ConstantPoolException {
+        Set<String> foundFields = new HashSet<>();
+        for (Field field : classFile.fields) {
+            String fieldName = field.getName(classFile.constant_pool);
+            echo("Testing field : " + fieldName);
+
+            TestCase.TestFieldInfo testField = clazz.getTestFieldInfo(fieldName);
+            foundFields.add(fieldName);
+            if (testField == null) {
+                continue;
+            }
+            testAttributes(testField, classFile, () -> field.attributes);
+        }
+        checkContains(foundFields, clazz.fields.keySet(), "Fields in class : " + clazz.getName());
+    }
+
+    private void testAttributes(
+            TestCase.TestMemberInfo member,
+            ClassFile classFile,
+            Supplier<Attributes> attributes)
+            throws ConstantPoolException {
+        Map<String, Annotation> actualInvisible = collectAnnotations(
+                classFile,
+                member,
+                attributes.get(),
+                Attribute.RuntimeInvisibleAnnotations);
+        Map<String, Annotation> actualVisible = collectAnnotations(
+                classFile,
+                member,
+                attributes.get(),
+                Attribute.RuntimeVisibleAnnotations);
+
+        checkEquals(actualInvisible.keySet(),
+                member.getRuntimeInvisibleAnnotations(), "RuntimeInvisibleAnnotations");
+        checkEquals(actualVisible.keySet(),
+                member.getRuntimeVisibleAnnotations(), "RuntimeVisibleAnnotations");
+
+        for (TestAnnotationInfo expectedAnnotation : member.annotations.values()) {
+            RetentionPolicy policy = getRetentionPolicy(expectedAnnotation.annotationName);
+            if (policy == RetentionPolicy.SOURCE) {
+                continue;
+            }
+            printf("Testing: isVisible: %s %s%n", policy.toString(), expectedAnnotation.annotationName);
+            Annotation actualAnnotation =
+                    (policy == RetentionPolicy.RUNTIME ? actualVisible : actualInvisible)
+                            .get(expectedAnnotation.annotationName);
+            if (checkNotNull(actualAnnotation, "Annotation is found : "
+                    + expectedAnnotation.annotationName)) {
+                expectedAnnotation.testAnnotation(this, classFile, actualAnnotation);
+            }
+        }
+    }
+
+    private Map<String, Annotation> collectAnnotations(
+            ClassFile classFile,
+            TestCase.TestMemberInfo member,
+            Attributes attributes,
+            String attribute) throws ConstantPoolException {
+
+        RuntimeAnnotations_attribute attr = (RuntimeAnnotations_attribute) attributes.get(attribute);
+        Map<String, Annotation> actualAnnotations = new HashMap<>();
+        RetentionPolicy policy = getRetentionPolicy(attribute);
+        if (member.isAnnotated(policy)) {
+            if (!checkNotNull(attr, String.format("%s should be not null value", attribute))) {
+                // test case failed, stop checking
+                return actualAnnotations;
+            }
+            for (Annotation ann : attr.annotations) {
+                String name = classFile.constant_pool.getUTF8Value(ann.type_index);
+                actualAnnotations.put(name.substring(1, name.length() - 1), ann);
+            }
+            checkEquals(countNumberOfAttributes(attributes.attrs,
+                    getRetentionPolicy(attribute) == RetentionPolicy.RUNTIME
+                            ? RuntimeVisibleAnnotations_attribute.class
+                            : RuntimeInvisibleAnnotations_attribute.class),
+                    1l,
+                    String.format("Number of %s", attribute));
+        } else {
+            checkNull(attr, String.format("%s should be null", attribute));
+        }
+        return actualAnnotations;
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/classfiles/attributes/annotations/RuntimeParameterAnnotationsForGenericMethodTest.java	Thu Jul 16 19:31:01 2015 -0700
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 8044411
+ * @summary Tests the RuntimeParameterVisibleAnnotations/RuntimeParameterInvisibleAnnotations attribute.
+ *          Checks that the attribute is generated for bridge method.
+ * @library /tools/lib /tools/javac/lib ../lib
+ * @build WorkAnnotations TestBase TestResult InMemoryFileManager ToolBox
+ * @build TestCase ClassType TestAnnotationInfo
+ * @build RuntimeParameterAnnotationsForGenericMethodTest AnnotationsTestBase RuntimeParameterAnnotationsTestBase
+ * @run main RuntimeParameterAnnotationsForGenericMethodTest
+ */
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * RuntimeParameterAnnotationsGenericMethodTest is a test which check that
+ * RuntimeVisibleParameterAnnotationsAttribute and
+ * RuntimeInvisibleParameterAnnotationsAttribute are generated for both
+ * generic and appropriate bridge methods.
+ * All possible combinations of retention policies are tested.
+ *
+ * The test generates class which looks as follows:
+ *
+ * public class Test extends java.util.ArrayList&lt;Integer&gt; {
+ *
+ *     public boolean add(here some annotations java.lang.Integer) {
+ *         return false;
+ *     }
+ * }
+ *
+ * Thereafter, various of combinations of annotations are applied
+ * to the add, the source is compiled and the generated byte code is checked.
+ *
+ * See README.txt for more information.
+ */
+public class RuntimeParameterAnnotationsForGenericMethodTest extends RuntimeParameterAnnotationsTestBase {
+    @Override
+    public List<TestCase> generateTestCases() {
+        List<TestCase> testCases = new ArrayList<>();
+        for (TestAnnotationInfos annotations : getAllCombinationsOfAnnotations()) {
+            // generate: public class Test extends java.util.ArrayList<Integer>
+            TestCase testCase = new TestCase();
+            TestCase.TestClassInfo clazz = testCase.addClassInfo("java.util.ArrayList<Integer>", ClassType.CLASS, "Test");
+            TestCase.TestParameterInfo parameter = clazz.addMethodInfo("add(java.lang.Integer)", "public").addParameter("Integer", "i");
+            annotations.annotate(parameter);
+            TestCase.TestParameterInfo synParameter = clazz.addMethodInfo("add(java.lang.Object)", true, "public").addParameter("Object", "i");
+            annotations.annotate(synParameter);
+            testCases.add(testCase);
+        }
+        return testCases;
+    }
+
+    public static void main(String[] args) throws TestFailedException {
+        new RuntimeParameterAnnotationsForGenericMethodTest().test();
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/classfiles/attributes/annotations/RuntimeParameterAnnotationsForLambdaTest.java	Thu Jul 16 19:31:01 2015 -0700
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 8044411 8079060
+ * @summary Tests the RuntimeParameterVisibleAnnotations/RuntimeParameterInvisibleAnnotations attribute.
+ * @library /tools/lib /tools/javac/lib ../lib
+ * @ignore 8079060 javac does not generate RuntimeParameterAnnotation attributes for lambda expressions
+ * @build WorkAnnotations TestBase TestResult InMemoryFileManager ToolBox
+ * @build TestCase ClassType TestAnnotationInfo
+ * @build RuntimeParameterAnnotationsForLambdaTest AnnotationsTestBase RuntimeParameterAnnotationsTestBase
+ * @run main RuntimeParameterAnnotationsForLambdaTest
+ */
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+import com.sun.tools.classfile.ClassFile;
+import com.sun.tools.classfile.Method;
+
+/**
+ * RuntimeParameterAnnotationsForLambdaTest is a test which checks that RuntimeVisibleParameterAnnotationsAttribute
+ * and RuntimeInvisibleParameterAnnotationsAttribute are generated properly for lambda expressions.
+ * The test checks both single and repeatable annotations.
+ * All possible combinations of retention policies are tested.
+ *
+ * The test generates source code, compiles it and checks the byte code.
+ *
+ * See README.txt for more information.
+ */
+public class RuntimeParameterAnnotationsForLambdaTest extends RuntimeParameterAnnotationsTestBase {
+
+    private static final String CLASS_NAME = "Test";
+    private static final String SOURCE_TEMPLATE =
+            "public class " + CLASS_NAME + " {\n" +
+            "   interface I { void method(int a, double b, String c); }\n" +
+            "   %SOURCE%\n" +
+            "}";
+
+    public static void main(String[] args) throws TestFailedException {
+        new RuntimeParameterAnnotationsForLambdaTest().test();
+    }
+
+    @Override
+    public void test() throws TestFailedException {
+        try {
+            for (TestAnnotationInfos annotations : getAllCombinationsOfAnnotations()) {
+                try {
+                    TestCase.TestMethodInfo testMethodInfo = new TestCase.TestMethodInfo(0, null, "lambda", false, false);
+                    TestCase.TestParameterInfo p1 = testMethodInfo.addParameter("int", "a");
+                    annotations.annotate(p1);
+                    testMethodInfo.addParameter("double", "b");
+                    TestCase.TestParameterInfo p3 = testMethodInfo.addParameter("String", "c");
+                    annotations.annotate(p3);
+                    String source = SOURCE_TEMPLATE.replace("%SOURCE%", generateLambdaSource(testMethodInfo));
+                    echo("Testing:\n" + source);
+                    addTestCase(source);
+                    ClassFile classFile = readClassFile(compile(source).getClasses().get(CLASS_NAME));
+                    boolean isFoundLambda = false;
+                    for (Method method : classFile.methods) {
+                        if (method.getName(classFile.constant_pool).startsWith("lambda$")) {
+                            isFoundLambda = true;
+                            testAttributes(testMethodInfo, classFile, method);
+                        }
+                    }
+                    checkTrue(isFoundLambda, "The tested lambda method was not found.");
+                } catch (Exception e) {
+                    addFailure(e);
+                }
+            }
+        } finally {
+            checkStatus();
+        }
+    }
+
+    public String generateLambdaSource(TestCase.TestMethodInfo method) {
+        return method.parameters.stream()
+                .map(TestCase.TestParameterInfo::generateSource)
+                .collect(Collectors.joining(", ", "I i = (", ") -> {};"));
+    }
+
+    @Override
+    public List<TestCase> generateTestCases() {
+        throw new UnsupportedOperationException();
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/classfiles/attributes/annotations/RuntimeParameterAnnotationsTest.java	Thu Jul 16 19:31:01 2015 -0700
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 8044411
+ * @summary Tests the RuntimeParameterVisibleAnnotations/RuntimeParameterInvisibleAnnotations attribute.
+ * @library /tools/lib /tools/javac/lib ../lib
+ * @build WorkAnnotations TestBase TestResult InMemoryFileManager ToolBox
+ * @build TestCase ClassType TestAnnotationInfo
+ * @build RuntimeParameterAnnotationsTest AnnotationsTestBase RuntimeParameterAnnotationsTestBase
+ * @run main RuntimeParameterAnnotationsTest
+ */
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * RuntimeParameterAnnotationsTest is a test which checks that RuntimeVisibleParameterAnnotationsAttribute
+ * and RuntimeInvisibleParameterAnnotationsAttribute are generated properly for constructors,
+ * for static and abstract methods of class, for abstract, default and static methods of interface.
+ * The test checks both single and repeatable annotations.
+ * All possible combinations of retention policies are tested.
+ *
+ * The test generates source code, compiles it and checks the byte code.
+ *
+ * See README.txt for more information.
+ */
+public class RuntimeParameterAnnotationsTest extends RuntimeParameterAnnotationsTestBase {
+
+    @Override
+    public List<TestCase> generateTestCases() {
+        List<TestCase> testCases = new ArrayList<>();
+        for (List<TestAnnotationInfos> groupedAnnotations : groupAnnotations(getAllCombinationsOfAnnotations())) {
+            for (ClassType classType : new ClassType[]{ClassType.CLASS, ClassType.INTERFACE}) {
+                TestCase test = new TestCase();
+                for (int i = 0; i < groupedAnnotations.size(); i++) {
+                    TestAnnotationInfos annotations = groupedAnnotations.get(i);
+                    TestCase.TestClassInfo clazz = test.addClassInfo(classType, "Test" + i, "abstract");
+
+                    initMethod(annotations, clazz, "<init>");
+
+                    initMethod(annotations, clazz, "method1");
+
+                    initMethod(annotations, clazz, "method2",
+                            classType == ClassType.CLASS ? "abstract" : "default");
+
+                    initMethod(annotations, clazz, "staticMethod", "static");
+                }
+                testCases.add(test);
+            }
+        }
+        return testCases;
+    }
+
+    /**
+     * Adds a method to the {@code testCase} with {@code methodName}.
+     *
+     * @param annotations a list of annotations
+     * @param clazz a test class
+     * @param methodName a method name
+     * @param mods an array of modifiers
+     */
+    private void initMethod(TestAnnotationInfos annotations, TestCase.TestClassInfo clazz, String methodName, String...mods) {
+        String methodDescriptor = methodName + "(int, double, java.lang.String)";
+        TestCase.TestMethodInfo method = clazz.addMethodInfo(methodDescriptor, mods);
+        TestCase.TestParameterInfo p1 = method.addParameter("int", "a");
+        annotations.annotate(p1);
+        method.addParameter("double", "b");
+        TestCase.TestParameterInfo p3 = method.addParameter("String", "c");
+        annotations.annotate(p3);
+    }
+
+    public static void main(String[] args) throws TestFailedException {
+        new RuntimeParameterAnnotationsTest().test();
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/classfiles/attributes/annotations/RuntimeParameterAnnotationsTestBase.java	Thu Jul 16 19:31:01 2015 -0700
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+import com.sun.tools.classfile.*;
+
+import javax.tools.JavaFileObject;
+import java.io.IOException;
+import java.lang.annotation.RetentionPolicy;
+import java.util.*;
+
+public abstract class RuntimeParameterAnnotationsTestBase extends AnnotationsTestBase {
+
+    @Override
+    public void test(TestCase testCase, Map<String, ? extends JavaFileObject> classes)
+            throws IOException, ConstantPoolException, Descriptor.InvalidDescriptor {
+        for (Map.Entry<String, ? extends JavaFileObject> entry : classes.entrySet()) {
+            ClassFile classFile = readClassFile(classes.get(entry.getKey()));
+            Set<String> foundMethods = new HashSet<>();
+            String className = classFile.getName();
+            TestCase.TestClassInfo testClassInfo = testCase.classes.get(className);
+            for (Method method : classFile.methods) {
+                String methodName = method.getName(classFile.constant_pool) +
+                        method.descriptor.getParameterTypes(classFile.constant_pool);
+                if (methodName.startsWith("<init>")) {
+                    methodName = methodName.replace("<init>", className);
+                }
+                foundMethods.add(methodName);
+                echo("Testing method : " + methodName);
+
+                TestCase.TestMethodInfo testMethod = testClassInfo.getTestMethodInfo(methodName);
+                if (testMethod == null) {
+                    continue;
+                }
+                testAttributes(testMethod, classFile, method);
+            }
+            checkContains(foundMethods, testClassInfo.methods.keySet(), "Methods in " + className);
+        }
+    }
+
+    protected void testAttributes(
+            TestCase.TestMethodInfo testMethod,
+            ClassFile classFile,
+            Method method) throws ConstantPoolException {
+        List<Map<String, Annotation>> actualInvisible = collectAnnotations(
+                classFile,
+                testMethod,
+                method,
+                Attribute.RuntimeInvisibleParameterAnnotations);
+        List<Map<String, Annotation>> actualVisible = collectAnnotations(
+                classFile,
+                testMethod,
+                method,
+                Attribute.RuntimeVisibleParameterAnnotations);
+
+        List<TestCase.TestParameterInfo> parameters = testMethod.parameters;
+        for (int i = 0; i < parameters.size(); ++i) {
+            TestCase.TestParameterInfo parameter = parameters.get(i);
+            checkEquals(actualInvisible.get(i).keySet(), parameter.getRuntimeInvisibleAnnotations(),
+                    "RuntimeInvisibleParameterAnnotations");
+            checkEquals(actualVisible.get(i).keySet(), parameter.getRuntimeVisibleAnnotations(),
+                    "RuntimeVisibleParameterAnnotations");
+        }
+
+        for (int i = 0; i < parameters.size(); ++i) {
+            TestCase.TestParameterInfo parameter = parameters.get(i);
+            for (TestAnnotationInfo expectedAnnotation : parameter.annotations.values()) {
+                RetentionPolicy policy = getRetentionPolicy(expectedAnnotation.annotationName);
+                if (policy == RetentionPolicy.SOURCE) {
+                    continue;
+                }
+                printf("Testing: isVisible: %s %s%n", policy.toString(), expectedAnnotation.annotationName);
+                Annotation actualAnnotation =
+                        (policy == RetentionPolicy.RUNTIME
+                                ? actualVisible
+                                : actualInvisible)
+                                .get(i).get(expectedAnnotation.annotationName);
+                if (checkNotNull(actualAnnotation, "Annotation is found : "
+                        + expectedAnnotation.annotationName)) {
+                    expectedAnnotation.testAnnotation(this, classFile,
+                            actualAnnotation);
+                }
+            }
+        }
+    }
+
+    private List<Map<String, Annotation>> collectAnnotations(
+            ClassFile classFile,
+            TestCase.TestMethodInfo testMethod,
+            Method method,
+            String attribute) throws ConstantPoolException {
+
+        Attributes attributes = method.attributes;
+        RuntimeParameterAnnotations_attribute attr = (RuntimeParameterAnnotations_attribute) attributes.get(attribute);
+
+        List<Map<String, Annotation>> actualAnnotations = new ArrayList<>();
+        RetentionPolicy policy = getRetentionPolicy(attribute);
+        if (testMethod.isParameterAnnotated(policy)) {
+            if (!checkNotNull(attr, "Attribute " + attribute + " must not be null")) {
+                testMethod.parameters.forEach($ -> actualAnnotations.add(new HashMap<>()));
+                return actualAnnotations;
+            }
+            for (Annotation[] anns : attr.parameter_annotations) {
+                Map<String, Annotation> annotations = new HashMap<>();
+                for (Annotation ann : anns) {
+                    String name = classFile.constant_pool.getUTF8Value(ann.type_index);
+                    annotations.put(name.substring(1, name.length() - 1), ann);
+                }
+                actualAnnotations.add(annotations);
+            }
+            checkEquals(countNumberOfAttributes(attributes.attrs,
+                    getRetentionPolicy(attribute) == RetentionPolicy.RUNTIME
+                            ? RuntimeVisibleParameterAnnotations_attribute.class
+                            : RuntimeInvisibleParameterAnnotations_attribute.class),
+                    1l,
+                    String.format("Number of %s", attribute));
+        } else {
+            checkNull(attr, String.format("%s should be null", attribute));
+            testMethod.parameters.forEach($ -> actualAnnotations.add(new HashMap<>()));
+        }
+        return actualAnnotations;
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/classfiles/attributes/annotations/TestAnnotationInfo.java	Thu Jul 16 19:31:01 2015 -0700
@@ -0,0 +1,441 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+import com.sun.tools.classfile.Annotation;
+import com.sun.tools.classfile.ClassFile;
+import com.sun.tools.classfile.ConstantPool;
+import com.sun.tools.classfile.ConstantPoolException;
+
+import java.lang.annotation.RetentionPolicy;
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class TestAnnotationInfo {
+    public final String annotationName;
+    public final RetentionPolicy policy;
+    public final boolean isContainer;
+    public final List<Pair> elementValues;
+
+    public TestAnnotationInfo(String typeIndexName, RetentionPolicy policy, Pair... values) {
+        this(typeIndexName, policy, false, values);
+    }
+
+    public TestAnnotationInfo(String typeIndexName, RetentionPolicy policy, boolean isRepeatable, Pair... values) {
+        this.annotationName = typeIndexName;
+        this.policy = policy;
+        this.isContainer = isRepeatable;
+        elementValues = Arrays.asList(values);
+    }
+
+    public void testAnnotation(TestResult testResult, ClassFile classFile, Annotation annotation)
+            throws ConstantPoolException {
+        testResult.checkEquals(classFile.constant_pool.getUTF8Value(annotation.type_index),
+                String.format("L%s;", annotationName), "Testing annotation name : " + annotationName);
+        testResult.checkEquals(annotation.num_element_value_pairs,
+                elementValues.size(), "Number of element values");
+        if (!testResult.checkEquals(annotation.num_element_value_pairs, elementValues.size(),
+                "Number of element value pairs")) {
+            return;
+        }
+        for (int i = 0; i < annotation.num_element_value_pairs; ++i) {
+            Annotation.element_value_pair pair = annotation.element_value_pairs[i];
+            testResult.checkEquals(classFile.constant_pool.getUTF8Value(pair.element_name_index),
+                    elementValues.get(i).elementName, "element_name_index : " + elementValues.get(i).elementName);
+            elementValues.get(i).elementValue.testElementValue(testResult, classFile, pair.value);
+        }
+    }
+
+    @Override
+    public String toString() {
+        return String.format("@%s(%s)", annotationName,
+                elementValues.stream()
+                        .map(Pair::toString)
+                        .filter(s -> !s.isEmpty())
+                        .collect(Collectors.joining(", ")));
+    }
+
+    public static class Pair {
+        public final String elementName;
+        public final TestElementValue elementValue;
+
+        public Pair(String elementName, TestElementValue elementValue) {
+            this.elementName = elementName;
+            this.elementValue = elementValue;
+        }
+
+        @Override
+        public String toString() {
+            return elementName + "=" + elementValue;
+        }
+    }
+
+    public static abstract class TestElementValue {
+        private final int tag;
+
+        public TestElementValue(int tag) {
+            this.tag = tag;
+        }
+
+        public void testTag(TestResult testCase, int actualTag) {
+            testCase.checkEquals(actualTag, tag, "tag " + (char) tag);
+        }
+
+        public abstract void testElementValue(TestResult testResult,
+                                              ClassFile classFile,
+                                              Annotation.element_value element_value)
+                throws ConstantPoolException;
+    }
+
+    public static class TestIntegerElementValue extends TestElementValue {
+        private final int value;
+
+        public TestIntegerElementValue(int tag, int value) {
+            super(tag);
+            this.value = value;
+        }
+
+        @Override
+        public void testElementValue(TestResult testResult,
+                                     ClassFile classFile,
+                                     Annotation.element_value element_value)
+                throws ConstantPoolException {
+            testTag(testResult, element_value.tag);
+            Annotation.Primitive_element_value ev =
+                    (Annotation.Primitive_element_value) element_value;
+            ConstantPool.CONSTANT_Integer_info info =
+                    (ConstantPool.CONSTANT_Integer_info) classFile.constant_pool.get(ev.const_value_index);
+            testResult.checkEquals(info.value, value, "const_value_index : " + value);
+        }
+
+        @Override
+        public String toString() {
+            return String.valueOf(value);
+        }
+    }
+
+    public static class TestBooleanElementValue extends TestElementValue {
+        private final boolean value;
+
+        public TestBooleanElementValue(boolean value) {
+            super('Z');
+            this.value = value;
+        }
+
+        @Override
+        public void testElementValue(TestResult testResult,
+                                     ClassFile classFile,
+                                     Annotation.element_value element_value)
+                throws ConstantPoolException {
+            testTag(testResult, element_value.tag);
+            Annotation.Primitive_element_value ev =
+                    (Annotation.Primitive_element_value) element_value;
+            ConstantPool.CONSTANT_Integer_info info =
+                    (ConstantPool.CONSTANT_Integer_info) classFile.constant_pool.get(ev.const_value_index);
+            testResult.checkEquals(info.value, value ? 1 : 0, "const_value_index : " + value);
+        }
+
+        @Override
+        public String toString() {
+            return String.valueOf(value);
+        }
+    }
+
+    public static class TestCharElementValue extends TestElementValue {
+        private final char value;
+
+        public TestCharElementValue(char value) {
+            super('C');
+            this.value = value;
+        }
+
+        @Override
+        public void testElementValue(TestResult testResult,
+                                     ClassFile classFile,
+                                     Annotation.element_value element_value)
+                throws ConstantPoolException {
+            testTag(testResult, element_value.tag);
+            Annotation.Primitive_element_value ev =
+                    (Annotation.Primitive_element_value) element_value;
+            ConstantPool.CONSTANT_Integer_info info =
+                    (ConstantPool.CONSTANT_Integer_info)
+                            classFile.constant_pool.get(ev.const_value_index);
+            testResult.checkEquals(info.value, (int) value, "const_value_index : " + value);
+        }
+
+        @Override
+        public String toString() {
+            return String.format("\'%c\'", value);
+        }
+    }
+
+    public static class TestLongElementValue extends TestElementValue {
+        private final long value;
+
+        public TestLongElementValue(long value) {
+            super('J');
+            this.value = value;
+        }
+
+        @Override
+        public void testElementValue(TestResult testResult,
+                                     ClassFile classFile,
+                                     Annotation.element_value element_value)
+                throws ConstantPool.InvalidIndex {
+            testTag(testResult, element_value.tag);
+            Annotation.Primitive_element_value ev =
+                    (Annotation.Primitive_element_value) element_value;
+            ConstantPool.CONSTANT_Long_info info =
+                    (ConstantPool.CONSTANT_Long_info) classFile.constant_pool.get(ev.const_value_index);
+            testResult.checkEquals(info.value, value, "const_value_index");
+        }
+
+        @Override
+        public String toString() {
+            return String.valueOf(value);
+        }
+    }
+
+    public static class TestFloatElementValue extends TestElementValue {
+        private final float value;
+
+        public TestFloatElementValue(float value) {
+            super('F');
+            this.value = value;
+        }
+
+        @Override
+        public void testElementValue(TestResult testResult,
+                                     ClassFile classFile,
+                                     Annotation.element_value element_value)
+                throws ConstantPool.InvalidIndex {
+            testTag(testResult, element_value.tag);
+            Annotation.Primitive_element_value ev =
+                    (Annotation.Primitive_element_value) element_value;
+            ConstantPool.CONSTANT_Float_info info =
+                    (ConstantPool.CONSTANT_Float_info) classFile.constant_pool.get(ev.const_value_index);
+            testResult.checkEquals(info.value, value, "const_value_index");
+        }
+
+        @Override
+        public String toString() {
+            return String.valueOf(value) + "f";
+        }
+    }
+
+    public static class TestDoubleElementValue extends TestElementValue {
+        private final double value;
+
+        public TestDoubleElementValue(double value) {
+            super('D');
+            this.value = value;
+        }
+
+        @Override
+        public void testElementValue(TestResult testResult,
+                                     ClassFile classFile,
+                                     Annotation.element_value element_value)
+                throws ConstantPoolException {
+            testTag(testResult, element_value.tag);
+            Annotation.Primitive_element_value ev =
+                    (Annotation.Primitive_element_value) element_value;
+            ConstantPool.CONSTANT_Double_info info = (ConstantPool.CONSTANT_Double_info)
+                    classFile.constant_pool.get(ev.const_value_index);
+            testResult.checkEquals(info.value, value, "const_value_index");
+        }
+
+        @Override
+        public String toString() {
+            return String.valueOf(value);
+        }
+    }
+
+    public static class TestStringElementValue extends TestElementValue {
+        private final String value;
+
+        public TestStringElementValue(String value) {
+            super('s');
+            this.value = value;
+        }
+
+        @Override
+        public void testElementValue(TestResult testResult,
+                                     ClassFile classFile,
+                                     Annotation.element_value element_value)
+                throws ConstantPoolException {
+            testTag(testResult, element_value.tag);
+            Annotation.Primitive_element_value ev =
+                    (Annotation.Primitive_element_value) element_value;
+            ConstantPool.CONSTANT_Utf8_info info =
+                    (ConstantPool.CONSTANT_Utf8_info) classFile.constant_pool.get(ev.const_value_index);
+            testResult.checkEquals(info.value, value, "const_value_index");
+        }
+
+        @Override
+        public String toString() {
+            return String.format("\"%s\"", value);
+        }
+    }
+
+    public static class TestEnumElementValue extends TestElementValue {
+        private final String typeName;
+        private final String constName;
+
+        public TestEnumElementValue(String typeName, String constName) {
+            super('e');
+            this.typeName = typeName;
+            this.constName = constName;
+        }
+
+        @Override
+        public void testElementValue(
+                TestResult testResult,
+                ClassFile classFile,
+                Annotation.element_value element_value)
+                throws ConstantPoolException {
+            testTag(testResult, element_value.tag);
+            Annotation.Enum_element_value ev = (Annotation.Enum_element_value) element_value;
+            testResult.checkEquals(classFile.constant_pool.getUTF8Info(ev.type_name_index).value,
+                    String.format("L%s;", typeName), "type_name_index");
+            testResult.checkEquals(classFile.constant_pool.getUTF8Info(ev.const_name_index).value,
+                    constName, "const_name_index");
+        }
+
+        @Override
+        public String toString() {
+            return typeName + "." + constName;
+        }
+    }
+
+    public static class TestClassElementValue extends TestElementValue {
+        private final String className;
+
+        private final static Map<String, String> mappedClassName;
+
+        static {
+            mappedClassName = new HashMap<>();
+            mappedClassName.put("void", "V");
+            mappedClassName.put("char", "C");
+            mappedClassName.put("byte", "B");
+            mappedClassName.put("short", "S");
+            mappedClassName.put("int", "I");
+            mappedClassName.put("long", "J");
+            mappedClassName.put("float", "F");
+            mappedClassName.put("double", "D");
+        }
+
+        public TestClassElementValue(String className) {
+            super('c');
+            this.className = className;
+        }
+
+        @Override
+        public void testElementValue(
+                TestResult testResult,
+                ClassFile classFile,
+                Annotation.element_value element_value)
+                throws ConstantPoolException {
+            testTag(testResult, element_value.tag);
+            Annotation.Class_element_value ev = (Annotation.Class_element_value) element_value;
+            String expectedClassName = className.replace(".class", "");
+            expectedClassName = mappedClassName.getOrDefault(expectedClassName,
+                    String.format("Ljava/lang/%s;", expectedClassName));
+            testResult.checkEquals(
+                    classFile.constant_pool.getUTF8Info(ev.class_info_index).value,
+                    expectedClassName, "class_info_index : " + expectedClassName);
+        }
+
+        @Override
+        public String toString() {
+            return className;
+        }
+    }
+
+    public static class TestArrayElementValue extends TestElementValue {
+        public final List<TestElementValue> values;
+
+        public TestArrayElementValue(TestElementValue...values) {
+            super('[');
+            this.values = new ArrayList<>(Arrays.asList(values));
+        }
+
+        @Override
+        public void testElementValue(
+                TestResult testResult,
+                ClassFile classFile,
+                Annotation.element_value element_value)
+                throws ConstantPoolException {
+            testTag(testResult, element_value.tag);
+            Annotation.Array_element_value ev = (Annotation.Array_element_value) element_value;
+
+            for (int i = 0; i < values.size(); ++i) {
+                values.get(i).testElementValue(testResult, classFile, ev.values[i]);
+            }
+        }
+
+        @Override
+        public String toString() {
+            return values.stream()
+                    .map(TestElementValue::toString)
+                    .collect(Collectors.joining(", ", "{", "}"));
+        }
+    }
+
+    public static class TestAnnotationElementValue extends TestElementValue {
+        private final String annotationName;
+        private final TestAnnotationInfo annotation;
+
+        public TestAnnotationElementValue(String className, TestAnnotationInfo annotation) {
+            super('@');
+            this.annotationName = className;
+            this.annotation = annotation;
+        }
+
+        @Override
+        public void testElementValue(
+                TestResult testResult,
+                ClassFile classFile,
+                Annotation.element_value element_value)
+                throws ConstantPoolException {
+            testTag(testResult, element_value.tag);
+            Annotation ev = ((Annotation.Annotation_element_value) element_value).annotation_value;
+            testResult.checkEquals(
+                    classFile.constant_pool.getUTF8Info(ev.type_index).value,
+                    String.format("L%s;", annotationName),
+                    "type_index");
+            for (int i = 0; i < ev.num_element_value_pairs; ++i) {
+                Annotation.element_value_pair pair = ev.element_value_pairs[i];
+                Pair expectedPair = annotation.elementValues.get(i);
+                expectedPair.elementValue.testElementValue(testResult, classFile, pair.value);
+                testResult.checkEquals(
+                        classFile.constant_pool.getUTF8Info(pair.element_name_index).value,
+                        expectedPair.elementName,
+                        "element_name_index");
+            }
+        }
+
+        @Override
+        public String toString() {
+            return annotation.toString();
+        }
+    }
+}
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/classfiles/attributes/annotations/TestCase.java	Thu Jul 16 19:31:01 2015 -0700
@@ -0,0 +1,459 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+import java.lang.annotation.RetentionPolicy;
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class TestCase {
+
+    /**
+     * The top-level classes of the test case.
+     */
+    public final Map<String, TestClassInfo> classes = new LinkedHashMap<>();
+
+    /**
+     * Constructs a test class info with {@code classType} as top-level class,
+     * with {@code outerClassName} as name and {@code mods} as modifiers.
+     *
+     * @param classType a class type
+     * @param outerClassName a name
+     * @param mods an array of modifiers
+     */
+    public TestClassInfo addClassInfo(ClassType classType, String outerClassName, String...mods) {
+        return addClassInfo(null, classType, outerClassName, mods);
+    }
+
+    /**
+     * Constructs a test class info with {@code classType} as top-level class,
+     * with {@code outerClassName} as name, {@code parent} class name
+     * as parent class and {@code mods} as modifiers.
+     *
+     * @param classType a class type
+     * @param outerClassName a name
+     * @param mods an array of modifiers
+     */
+    public TestClassInfo addClassInfo(String parent, ClassType classType, String outerClassName, String...mods) {
+        TestClassInfo clazz = new TestClassInfo(classType, outerClassName, parent, mods);
+        if (classes.put(outerClassName, clazz) != null) {
+            throw new IllegalArgumentException("Duplicate class name: " + outerClassName);
+        }
+        return clazz;
+    }
+
+    public String generateSource() {
+        return classes.values().stream()
+                .map(TestMemberInfo::generateSource)
+                .collect(Collectors.joining("\n"));
+    }
+
+    /**
+     * Returns {@code TestClassInfo} by class signature.
+     * Example, {@code getTestClassInfo(&quot;Test$1Local&quot;)}
+     * returns local inner class of class {@code Test}.
+     *
+     * @param classSignature a class signature
+     * @return {@code TestClassInfo} by class signature
+     */
+    public TestClassInfo getTestClassInfo(String classSignature) {
+        String[] cs = classSignature.split("\\$");
+        if (cs.length > 0 && classes.containsKey(cs[0])) {
+            // check signature corresponds to top level class
+            if (cs.length == 1) {
+                return classes.get(cs[0]);
+            }
+        } else {
+            throw new IllegalArgumentException("Cannot find class : " + classSignature);
+        }
+        TestClassInfo current = classes.get(cs[0]);
+        // find class info in the inner classes
+        for (int i = 1; i < cs.length; ++i) {
+            Map<String, TestClassInfo> innerClasses = current.innerClasses;
+            Map<String, TestMethodInfo> methods = current.methods;
+            current = innerClasses.get(cs[i]);
+            // if current is null then class info does not exist or the class is local
+            if (current == null) {
+                if (!cs[i].isEmpty()) {
+                    // the class is local, remove leading digit
+                    String className = cs[i].substring(1);
+                    Optional<TestClassInfo> opt = methods.values().stream()
+                            .flatMap(c -> c.localClasses.values().stream())
+                            .filter(c -> c.name.equals(className)).findAny();
+                    if (opt.isPresent()) {
+                        current = opt.get();
+                        // continue analysis of local class
+                        continue;
+                    }
+                }
+                throw new IllegalArgumentException("Cannot find class : " + classSignature);
+            }
+        }
+        return current;
+    }
+
+    /**
+     * Class represents a program member.
+     */
+    public static abstract class TestMemberInfo {
+        // next two fields are used for formatting
+        protected final int indention;
+        protected final ClassType containerType;
+        public final List<String> mods;
+        public final String name;
+        public final Map<String, TestAnnotationInfo> annotations;
+
+        TestMemberInfo(int indention, ClassType containerType, String name, String... mods) {
+            this.indention = indention;
+            this.containerType = containerType;
+            this.mods = Arrays.asList(mods);
+            this.name = name;
+            this.annotations = new HashMap<>();
+        }
+
+        public abstract String generateSource();
+
+        public boolean isAnnotated(RetentionPolicy policy) {
+            return annotations.values().stream()
+                    .filter(a -> a.policy == policy)
+                    .findAny().isPresent();
+        }
+
+        public Set<String> getRuntimeVisibleAnnotations() {
+            return getRuntimeAnnotations(RetentionPolicy.RUNTIME);
+        }
+
+        public Set<String> getRuntimeInvisibleAnnotations() {
+            return getRuntimeAnnotations(RetentionPolicy.CLASS);
+        }
+
+        private Set<String> getRuntimeAnnotations(RetentionPolicy policy) {
+            return annotations.values().stream()
+                    .filter(e -> e.policy == policy)
+                    .map(a -> a.annotationName)
+                    .distinct()
+                    .collect(Collectors.toSet());
+        }
+
+        /**
+         * Generates source for annotations.
+         *
+         * @param prefix a leading text
+         * @param suffix a trailing text
+         * @param joining a text between annotations
+         * @return source for annotations
+         */
+        protected String generateSourceForAnnotations(String prefix, String suffix, String joining) {
+            StringBuilder sb = new StringBuilder();
+            for (TestAnnotationInfo annotation : annotations.values()) {
+                sb.append(prefix);
+                if (annotation.isContainer) {
+                    // the annotation is repeatable
+                    // container consists of an array of annotations
+                    TestAnnotationInfo.TestArrayElementValue containerElementValue =
+                            (TestAnnotationInfo.TestArrayElementValue) annotation.elementValues.get(0).elementValue;
+                    // concatenate sources of repeatable annotations
+                    sb.append(containerElementValue.values.stream()
+                            .map(TestAnnotationInfo.TestElementValue::toString)
+                            .collect(Collectors.joining(joining)));
+                } else {
+                    sb.append(annotation);
+                }
+                sb.append(suffix);
+            }
+            String src = sb.toString();
+            return src.trim().isEmpty() ? "" : src;
+
+        }
+
+        /**
+         * Generates source for annotations.
+         *
+         * @return source for annotations
+         */
+        public String generateSourceForAnnotations() {
+            return generateSourceForAnnotations(indention(), "\n", "\n" + indention());
+        }
+
+        /**
+         * Adds annotation info to the member.
+         *
+         * @param anno an annotation info
+         */
+        public void addAnnotation(TestAnnotationInfo anno) {
+            String containerName = anno.annotationName + "Container";
+            TestAnnotationInfo annotation = annotations.get(anno.annotationName);
+            TestAnnotationInfo containerAnnotation = annotations.get(containerName);
+
+            if (annotation == null) {
+                // if annotation is null then either it is first adding of the annotation to the member
+                // or there is the container of the annotation.
+                if (containerAnnotation == null) {
+                    // first adding to the member
+                    annotations.put(anno.annotationName, anno);
+                } else {
+                    // add annotation to container
+                    TestAnnotationInfo.TestArrayElementValue containerElementValue =
+                            ((TestAnnotationInfo.TestArrayElementValue) containerAnnotation.elementValues.get(0).elementValue);
+                    containerElementValue.values.add(new TestAnnotationInfo.TestAnnotationElementValue(anno.annotationName, anno));
+                }
+            } else {
+                // remove previously added annotation and add new container of repeatable annotation
+                // which contains previously added and new annotation
+                annotations.remove(anno.annotationName);
+                containerAnnotation = new TestAnnotationInfo(
+                        containerName,
+                        anno.policy,
+                        true,
+                        new TestAnnotationInfo.Pair("value",
+                                new TestAnnotationInfo.TestArrayElementValue(
+                                        new TestAnnotationInfo.TestAnnotationElementValue(anno.annotationName, annotation),
+                                        new TestAnnotationInfo.TestAnnotationElementValue(anno.annotationName, anno))));
+                annotations.put(containerName, containerAnnotation);
+            }
+        }
+
+        public String indention() {
+            char[] a = new char[4 * indention];
+            Arrays.fill(a, ' ');
+            return new String(a);
+        }
+
+        public String getName() {
+            return name;
+        }
+    }
+
+    /**
+     * The class represents a class.
+     */
+    public static class TestClassInfo extends TestMemberInfo {
+        public final ClassType classType;
+        public final String parent;
+        public final Map<String, TestClassInfo> innerClasses;
+        public final Map<String, TestMethodInfo> methods;
+        public final Map<String, TestFieldInfo> fields;
+
+        TestClassInfo(int indention, ClassType classType, String className, String... mods) {
+            this(indention, classType, className, null, mods);
+        }
+
+        TestClassInfo(ClassType classType, String className, String parent, String... mods) {
+            this(0, classType, className, parent, mods);
+        }
+
+        TestClassInfo(int indention, ClassType classType, String className, String parent, String... mods) {
+            super(indention, null, className, mods);
+            this.classType = classType;
+            this.parent = parent;
+            innerClasses = new LinkedHashMap<>();
+            methods = new LinkedHashMap<>();
+            fields = new LinkedHashMap<>();
+        }
+
+        /**
+         * Generates source which represents the class.
+         *
+         * @return source which represents the class
+         */
+        @Override
+        public String generateSource() {
+            String sourceForAnnotations = generateSourceForAnnotations();
+            String classModifiers = mods.stream().collect(Collectors.joining(" "));
+            return sourceForAnnotations
+                    + String.format("%s%s %s %s %s {%n",
+                    indention(),
+                    classModifiers,
+                    classType.getDescription(),
+                    name,
+                    parent == null ? "" : "extends " + parent)
+                    + classType.collectFields(fields.values())
+                    + classType.collectMethods(methods.values())
+                    + classType.collectInnerClasses(innerClasses.values())
+                    + indention() + "}";
+        }
+
+        /**
+         * Adds a new inner class to the class.
+         *
+         * @param classType a class type
+         * @param className a class name
+         * @param mods modifiers
+         * @return a new added inner class to the class
+         */
+        public TestClassInfo addInnerClassInfo(ClassType classType, String className, String... mods) {
+            TestClassInfo testClass = new TestClassInfo(indention + 1, classType, className, mods);
+            if (innerClasses.put(className, testClass) != null) {
+                throw new IllegalArgumentException("Duplicated class : " + className);
+            }
+            return testClass;
+        }
+
+        /**
+         * Adds a new method to the class.
+         *
+         * @param methodName a method name
+         * @param mods modifiers
+         * @return a new inner class to the class
+         */
+        public TestMethodInfo addMethodInfo(String methodName, String... mods) {
+            return addMethodInfo(methodName, false, mods);
+        }
+
+        /**
+         * Adds a new method to the class.
+         *
+         * @param methodName a method name
+         * @param isSynthetic if {@code true} the method is synthetic
+         * @param mods modifiers
+         * @return a new method added to the class
+         */
+        public TestMethodInfo addMethodInfo(String methodName, boolean isSynthetic, String... mods) {
+            boolean isConstructor = methodName.contains("<init>");
+            if (isConstructor) {
+                methodName = methodName.replace("<init>", name);
+            }
+            TestMethodInfo testMethod = new TestMethodInfo(indention + 1, classType, methodName, isConstructor, isSynthetic, mods);
+            if (methods.put(methodName, testMethod) != null) {
+                throw new IllegalArgumentException("Duplicated method : " + methodName);
+            }
+            return testMethod;
+        }
+
+        /**
+         * Adds a new field to the class.
+         *
+         * @param fieldName a method name
+         * @param mods modifiers
+         * @return a new field added to the class
+         */
+        public TestFieldInfo addFieldInfo(String fieldName, String... mods) {
+            TestFieldInfo field = new TestFieldInfo(indention + 1, classType, fieldName, mods);
+            if (fields.put(fieldName, field) != null) {
+                throw new IllegalArgumentException("Duplicated field : " + fieldName);
+            }
+            return field;
+        }
+
+        public TestMethodInfo getTestMethodInfo(String methodName) {
+            return methods.get(methodName);
+        }
+
+        public TestFieldInfo getTestFieldInfo(String fieldName) {
+            return fields.get(fieldName);
+        }
+    }
+
+    public static class TestMethodInfo extends TestMemberInfo {
+        public final boolean isConstructor;
+        public final boolean isSynthetic;
+        public final Map<String, TestClassInfo> localClasses;
+        public final List<TestParameterInfo> parameters;
+
+        TestMethodInfo(int indention, ClassType containerType, String methodName,
+                               boolean isConstructor, boolean isSynthetic, String... mods) {
+            super(indention, containerType, methodName, mods);
+            this.isSynthetic = isSynthetic;
+            this.localClasses = new LinkedHashMap<>();
+            this.parameters = new ArrayList<>();
+            this.isConstructor = isConstructor;
+        }
+
+        public boolean isParameterAnnotated(RetentionPolicy policy) {
+            return parameters.stream()
+                    .filter(p -> p.isAnnotated(policy))
+                    .findFirst().isPresent();
+        }
+
+        public TestParameterInfo addParameter(String type, String name) {
+            TestParameterInfo testParameter = new TestParameterInfo(type, name);
+            parameters.add(testParameter);
+            return testParameter;
+        }
+
+        /**
+         * Adds a local class to the method.
+         *
+         * @param className a class name
+         * @param mods modifiers
+         * @return a local class added to the method
+         */
+        public TestClassInfo addLocalClassInfo(String className, String... mods) {
+            TestClassInfo testClass = new TestClassInfo(indention + 1, ClassType.CLASS, className, mods);
+            if (localClasses.put(className, testClass) != null) {
+                throw new IllegalArgumentException("Duplicated class : " + className);
+            }
+            return testClass;
+        }
+
+        @Override
+        public String generateSource() {
+            if (isSynthetic) {
+                return "";
+            }
+            return generateSourceForAnnotations() +
+                    containerType.methodToString(this);
+        }
+
+        @Override
+        public String getName() {
+            return name.replaceAll("\\(.*\\)", "");
+        }
+    }
+
+    /**
+     * The class represents a method parameter.
+     */
+    public static class TestParameterInfo extends TestMemberInfo {
+        public final String type;
+
+        TestParameterInfo(String type, String name) {
+            super(0, null, name);
+            this.type = type;
+        }
+
+        @Override
+        public String generateSource() {
+            return generateSourceForAnnotations() + type + " " + name;
+        }
+
+        public String generateSourceForAnnotations() {
+            return generateSourceForAnnotations("", " ", " ");
+        }
+    }
+
+    /**
+     * The class represents a field.
+     */
+    public static class TestFieldInfo extends TestMemberInfo {
+
+        TestFieldInfo(int indention, ClassType containerType, String fieldName, String... mods) {
+            super(indention, containerType, fieldName, mods);
+        }
+
+        @Override
+        public String generateSource() {
+            return generateSourceForAnnotations() +
+                    containerType.fieldToString(this);
+        }
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/classfiles/attributes/annotations/WorkAnnotations.java	Thu Jul 16 19:31:01 2015 -0700
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+import java.lang.annotation.*;
+
+@Retention(RetentionPolicy.CLASS)
+@Repeatable(RuntimeInvisibleRepeatableContainer.class)
+@interface RuntimeInvisibleRepeatable {
+    boolean booleanValue() default false;
+    byte byteValue() default 0;
+    char charValue() default 0;
+    short shortValue() default 0;
+    int intValue() default 0;
+    long longValue() default 0;
+    float floatValue() default 0;
+    double doubleValue() default 0;
+    String stringValue() default "";
+    int[] arrayValue1() default {};
+    String[] arrayValue2() default {};
+    Class<?> classValue1() default void.class;
+    Class<?> classValue2() default void.class;
+    EnumValue enumValue() default EnumValue.VALUE1;
+    AnnotationValue annoValue() default @AnnotationValue(stringValue = "StringValue");
+    AnnotationValue[] annoArrayValue() default
+            {@AnnotationValue(stringValue = "StringValue1"),
+                    @AnnotationValue(stringValue = "StringValue2"),
+                    @AnnotationValue(stringValue = "StringValue3")};
+}
+
+@Retention(RetentionPolicy.CLASS)
+@interface RuntimeInvisibleRepeatableContainer {
+    RuntimeInvisibleRepeatable[] value();
+}
+
+@interface RuntimeInvisibleNotRepeatable {
+    boolean booleanValue() default false;
+    byte byteValue() default 0;
+    char charValue() default 0;
+    short shortValue() default 0;
+    int intValue() default 0;
+    long longValue() default 0;
+    float floatValue() default 0;
+    double doubleValue() default 0;
+    String stringValue() default "";
+    int[] arrayValue1() default {};
+    String[] arrayValue2() default {};
+    Class<?> classValue1() default void.class;
+    Class<?> classValue2() default void.class;
+    EnumValue enumValue() default EnumValue.VALUE1;
+    AnnotationValue annoValue() default @AnnotationValue(stringValue = "StringValue");
+    AnnotationValue[] annoArrayValue() default
+            {@AnnotationValue(stringValue = "StringValue1"),
+                    @AnnotationValue(stringValue = "StringValue2"),
+                    @AnnotationValue(stringValue = "StringValue3")};
+}
+
+@Retention(RetentionPolicy.RUNTIME)
+@Repeatable(RuntimeVisibleRepeatableContainer.class)
+@interface RuntimeVisibleRepeatable {
+    boolean booleanValue() default false;
+    byte byteValue() default 0;
+    char charValue() default 0;
+    short shortValue() default 0;
+    int intValue() default 0;
+    long longValue() default 0;
+    float floatValue() default 0;
+    double doubleValue() default 0;
+    String stringValue() default "";
+    int[] arrayValue1() default {};
+    String[] arrayValue2() default {};
+    Class<?> classValue1() default void.class;
+    Class<?> classValue2() default void.class;
+    EnumValue enumValue() default EnumValue.VALUE1;
+    AnnotationValue annoValue() default @AnnotationValue(stringValue = "StringValue");
+    AnnotationValue[] annoArrayValue() default
+            {@AnnotationValue(stringValue = "StringValue1"),
+                    @AnnotationValue(stringValue = "StringValue2"),
+                    @AnnotationValue(stringValue = "StringValue3")};
+}
+
+@Retention(RetentionPolicy.RUNTIME)
+@interface RuntimeVisibleRepeatableContainer {
+    RuntimeVisibleRepeatable[] value();
+}
+
+@Retention(RetentionPolicy.RUNTIME)
+@interface RuntimeVisibleNotRepeatable {
+    boolean booleanValue() default false;
+    byte byteValue() default 0;
+    char charValue() default 0;
+    short shortValue() default 0;
+    int intValue() default 0;
+    long longValue() default 0;
+    float floatValue() default 0;
+    double doubleValue() default 0;
+    String stringValue() default "";
+    int[] arrayValue1() default {};
+    String[] arrayValue2() default {};
+    Class<?> classValue1() default void.class;
+    Class<?> classValue2() default void.class;
+    EnumValue enumValue() default EnumValue.VALUE1;
+    AnnotationValue annoValue() default @AnnotationValue(stringValue = "StringValue");
+    AnnotationValue[] annoArrayValue() default
+            {@AnnotationValue(stringValue = "StringValue1"),
+                    @AnnotationValue(stringValue = "StringValue2"),
+                    @AnnotationValue(stringValue = "StringValue3")};
+}
+
+enum EnumValue {
+    VALUE1, VALUE2, VALUE3
+}
+
+@interface AnnotationValue {
+    String stringValue() default "";
+}
\ No newline at end of file
--- a/test/tools/javac/classfiles/attributes/lib/TestBase.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/test/tools/javac/classfiles/attributes/lib/TestBase.java	Thu Jul 16 19:31:01 2015 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2015, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -21,10 +21,9 @@
  * questions.
  */
 
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.IOException;
-import java.io.InputStream;
+import java.io.*;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.*;
 import java.util.function.Function;
 import java.util.stream.Collectors;
@@ -210,6 +209,12 @@
         assertTrue(found.containsAll(expected), message + " : " + copy);
     }
 
+    public void writeToFile(Path path, String source) throws IOException {
+        try (BufferedWriter writer = Files.newBufferedWriter(path)) {
+            writer.write(source);
+        }
+    }
+
     public File getSourceDir() {
         return new File(System.getProperty("test.src", "."));
     }
--- a/test/tools/javac/classfiles/attributes/lib/TestResult.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/test/tools/javac/classfiles/attributes/lib/TestResult.java	Thu Jul 16 19:31:01 2015 -0700
@@ -24,18 +24,16 @@
 import java.io.PrintWriter;
 import java.io.StringWriter;
 import java.util.*;
-import java.util.stream.Collectors;
 
 /**
  * This class accumulates test results. Test results can be checked with method @{code checkStatus}.
  */
 public class TestResult extends TestBase {
 
-    private final List<Info> testCases;
+    private final List<Info> testCasesInfo;
 
     public TestResult() {
-        testCases = new ArrayList<>();
-        testCases.add(new Info("Global test info"));
+        testCasesInfo = new ArrayList<>();
     }
 
     /**
@@ -44,21 +42,16 @@
      * @param info the information about test case
      */
     public void addTestCase(String info) {
-        testCases.add(new Info(info));
-    }
-
-    private String errorMessage() {
-        return testCases.stream().filter(Info::isFailed)
-                .map(tc -> String.format("Failure in test case:\n%s\n%s", tc.info(), tc.getMessage()))
-                .collect(Collectors.joining("\n"));
+        System.err.println("Test case: " + info);
+        testCasesInfo.add(new Info(info));
     }
 
     public boolean checkEquals(Object actual, Object expected, String message) {
         echo("Testing : " + message);
         if (!Objects.equals(actual, expected)) {
             getLastTestCase().addAssert(String.format("%s\n" +
-                            "Expected: %s,\n" +
-                            "     Got: %s", message, expected, actual));
+                    "Expected: %s,\n" +
+                    "     Got: %s", message, expected, actual));
             return false;
         }
         return true;
@@ -96,14 +89,17 @@
     }
 
     public void addFailure(Throwable th) {
-        testCases.get(testCases.size() - 1).addFailure(th);
+        if (testCasesInfo.isEmpty()) {
+            testCasesInfo.add(new Info("Dummy info"));
+        }
+        getLastTestCase().addFailure(th);
     }
 
     private Info getLastTestCase() {
-        if (testCases.size() == 1) {
+        if (testCasesInfo.isEmpty()) {
             throw new IllegalStateException("Test case should be created");
         }
-        return testCases.get(testCases.size() - 1);
+        return testCasesInfo.get(testCasesInfo.size() - 1);
     }
 
     /**
@@ -114,22 +110,41 @@
      *                             or an exception occurs
      */
     public void checkStatus() throws TestFailedException {
-        if (testCases.stream().anyMatch(Info::isFailed)) {
-            echo(errorMessage());
+        int passed = 0;
+        int failed = 0;
+        for (Info testCaseInfo : testCasesInfo) {
+            if (testCaseInfo.isFailed()) {
+                String info = testCaseInfo.info().replace("\n", LINE_SEPARATOR);
+                String errorMessage = testCaseInfo.getMessage().replace("\n", LINE_SEPARATOR);
+                System.err.printf("Failure in test case:%n%s%n%s%n", info, errorMessage);
+                ++failed;
+            } else {
+                ++passed;
+            }
+        }
+        System.err.printf("Test cases: passed: %d, failed: %d, total: %d.%n", passed, failed, passed + failed);
+        if (failed > 0) {
             throw new TestFailedException("Test failed");
         }
+        if (passed + failed == 0) {
+            throw new TestFailedException("Test cases were not found");
+        }
     }
 
-    private class Info {
+    @Override
+    public void printf(String template, Object... args) {
+        getLastTestCase().printf(template, args);
+    }
+
+    private static class Info {
 
         private final String info;
-        private final List<String> asserts;
-        private final List<Throwable> errors;
+        private final StringWriter writer;
+        private boolean isFailed;
 
         private Info(String info) {
             this.info = info;
-            asserts = new ArrayList<>();
-            errors = new ArrayList<>();
+            writer = new StringWriter();
         }
 
         public String info() {
@@ -137,34 +152,25 @@
         }
 
         public boolean isFailed() {
-            return !asserts.isEmpty() || !errors.isEmpty();
+            return isFailed;
+        }
+
+        public void printf(String template, Object... args) {
+            writer.write(String.format(template, args));
         }
 
         public void addFailure(Throwable th) {
-            errors.add(th);
+            isFailed = true;
             printf("[ERROR] : %s\n", getStackTrace(th));
         }
 
         public void addAssert(String e) {
-            asserts.add(e);
+            isFailed = true;
             printf("[ASSERT] : %s\n", e);
         }
 
         public String getMessage() {
-            return (asserts.size() > 0 ? getAssertMessages(asserts) + "\n" : "")
-                    + getErrorMessages(errors);
-        }
-
-        public String getAssertMessages(List<String> list) {
-            return list.stream()
-                    .map(message -> String.format("[ASSERT] : %s", message))
-                    .collect(Collectors.joining("\n"));
-        }
-
-        public String getErrorMessages(List<? extends Throwable> list) {
-            return list.stream()
-                    .map(throwable -> String.format("[ERROR] : %s", getStackTrace(throwable)))
-                    .collect(Collectors.joining("\n"));
+            return writer.toString();
         }
 
         public String getStackTrace(Throwable throwable) {
--- a/test/tools/javadoc/doclint/DocLintTest.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/test/tools/javadoc/doclint/DocLintTest.java	Thu Jul 16 19:31:01 2015 -0700
@@ -23,7 +23,7 @@
 
 /*
  * @test
- * @bug 8004834 8007610
+ * @bug 8004834 8007610 8129909
  * @summary Add doclint support into javadoc
  * @modules jdk.compiler/com.sun.tools.javac.main
  */
@@ -59,7 +59,7 @@
 
     DocumentationTool javadoc;
     StandardJavaFileManager fm;
-    JavaFileObject file;
+    Iterable<? extends JavaFileObject> files;
 
     final String code =
         /* 01 */    "/** Class comment. */\n" +
@@ -77,6 +77,20 @@
         /* 13 */    "    public int emptyReturn() { return 0; }\n" +
         /* 14 */    "}\n";
 
+    final String p1Code =
+        /* 01 */    "package p1;\n" +
+        /* 02 */    "public class P1Test {\n" +
+        /* 03 */    "    /** Syntax < error. */\n" +
+        /* 04 */    "    public void method() { }\n" +
+        /* 05 */    "}\n";
+
+    final String p2Code =
+        /* 01 */    "package p2;\n" +
+        /* 02 */    "public class P2Test {\n" +
+        /* 03 */    "    /** Syntax < error. */\n" +
+        /* 04 */    "    public void method() { }\n" +
+        /* 05 */    "}\n";
+
     private final String rawDiags = "-XDrawDiagnostics";
 
     private enum Message {
@@ -85,6 +99,9 @@
         DL_ERR9(ERROR, "Test.java:9:14: compiler.err.proc.messager: reference not found"),
         DL_WRN12(WARNING, "Test.java:12:9: compiler.warn.proc.messager: no description for @return"),
 
+        DL_ERR_P1TEST(ERROR, "P1Test.java:3:16: compiler.err.proc.messager: malformed HTML"),
+        DL_ERR_P2TEST(ERROR, "P2Test.java:3:16: compiler.err.proc.messager: malformed HTML"),
+
         // doclint messages when -XDrawDiagnostics is not in effect
         DL_ERR9A(ERROR, "Test.java:9: error: reference not found"),
         DL_WRN12A(WARNING, "Test.java:12: warning: no description for @return"),
@@ -95,7 +112,8 @@
 
         // javadoc messages for bad options
         OPT_BADARG(ERROR, "javadoc: error - Invalid argument for -Xdoclint option"),
-        OPT_BADQUAL(ERROR, "javadoc: error - Access qualifiers not permitted for -Xdoclint arguments");
+        OPT_BADQUAL(ERROR, "javadoc: error - Access qualifiers not permitted for -Xdoclint arguments"),
+        OPT_BADPACKAGEARG(ERROR, "javadoc: error - Invalid argument for -Xdoclint/package option");
 
         final Diagnostic.Kind kind;
         final String text;
@@ -124,12 +142,7 @@
         fm = javadoc.getStandardFileManager(null, null, null);
         try {
             fm.setLocation(StandardLocation.CLASS_OUTPUT, Arrays.asList(new File(".")));
-            file = new SimpleJavaFileObject(URI.create("Test.java"), JavaFileObject.Kind.SOURCE) {
-                @Override
-                public CharSequence getCharContent(boolean ignoreEncoding) {
-                    return code;
-                }
-            };
+            files = Arrays.asList(new TestJFO("Test.java", code));
 
             test(Collections.<String>emptyList(),
                     Main.Result.ERROR,
@@ -175,6 +188,21 @@
                     Main.Result.ERROR,
                     EnumSet.of(Message.OPT_BADARG));
 
+            files = Arrays.asList(new TestJFO("p1/P1Test.java", p1Code),
+                                  new TestJFO("p2/P2Test.java", p2Code));
+
+            test(Arrays.asList(rawDiags),
+                    Main.Result.ERROR,
+                    EnumSet.of(Message.DL_ERR_P1TEST, Message.DL_ERR_P2TEST));
+
+            test(Arrays.asList(rawDiags, "-Xdoclint/package:p1"),
+                    Main.Result.ERROR,
+                    EnumSet.of(Message.DL_ERR_P1TEST));
+
+            test(Arrays.asList(rawDiags, "-Xdoclint/package:*p"),
+                    Main.Result.ERROR,
+                    EnumSet.of(Message.OPT_BADPACKAGEARG));
+
             if (errors > 0)
                 throw new Exception(errors + " errors occurred");
         } finally {
@@ -186,7 +214,6 @@
         System.err.println("test: " + opts);
         StringWriter sw = new StringWriter();
         PrintWriter pw = new PrintWriter(sw);
-        List<JavaFileObject> files = Arrays.asList(file);
         try {
             DocumentationTask t = javadoc.getTask(pw, fm, null, null, opts, files);
             boolean ok = t.call();
@@ -257,4 +284,19 @@
     }
 
     int errors;
+
+    class TestJFO extends SimpleJavaFileObject {
+
+        private final String content;
+
+        public TestJFO(String fileName, String content) {
+            super(URI.create(fileName), JavaFileObject.Kind.SOURCE);
+            this.content = content;
+        }
+
+        @Override
+        public CharSequence getCharContent(boolean ignoreEncoding) {
+            return content;
+        }
+    };
 }
--- a/test/tools/lib/ToolBox.java	Thu Jul 16 13:51:57 2015 -0700
+++ b/test/tools/lib/ToolBox.java	Thu Jul 16 19:31:01 2015 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2015, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -1594,15 +1594,20 @@
         }
 
         /*
-         * A jar: URL is of the form  jar:URL!/entry  where URL is a URL for the .jar file itself.
+         * A jar: URL is of the form  jar:URL!/<entry>  where URL is a URL for the .jar file itself.
          * In Symbol files (i.e. ct.sym) the underlying entry is prefixed META-INF/sym/<base>.
          */
         private final Pattern jarEntry = Pattern.compile(".*!/(?:META-INF/sym/[^/]+/)?(.*)");
 
         /*
-         * A jrt: URL is of the form  jrt:/module/package/file
+         * A jrt: URL is of the form  jrt:/modules/<module>/<package>/<file>
          */
-        private final Pattern jrtEntry = Pattern.compile("/([^/]+)/(.*)");
+        private final Pattern jrtEntry = Pattern.compile("/modules/([^/]+)/(.*)");
+
+        /*
+         * A file: URL is of the form  file:/path/to/modules/<module>/<package>/<file>
+         */
+        private final Pattern fileEntry = Pattern.compile(".*/modules/([^/]+)/(.*)");
 
         private String guessPath(FileObject fo) {
             URI u = fo.toUri();
@@ -1621,6 +1626,13 @@
                     }
                     break;
                 }
+                case "file": {
+                    Matcher m = fileEntry.matcher(u.getSchemeSpecificPart());
+                    if (m.matches()) {
+                        return m.group(2);
+                    }
+                    break;
+                }
             }
             throw new IllegalArgumentException(fo.getName() + "--" + fo.toUri());
         }