1  /*

     2  * Copyright (c) 2006, 2019, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  */

    23 

    24 /*

    25  * @test

    26  * @bug 8224177

    27  * @summary Test warnings from the annotation processing runtime about malformed supported information from processors.

    28  * @compile TestRepeatedItemsRuntime.java

    29  * @compile/ref=gold_sv_none.out  -XDrawDiagnostics -processor TestRepeatedItemsRuntime -proc:only TestRepeatedItemsRuntime.java

    30  * @compile/ref=auric_current.out -XDrawDiagnostics -processor TestRepeatedItemsRuntime -proc:only -Xlint:processing TestRepeatedItemsRuntime.java

    31  */

    32 

    33 import java.lang.annotation.*;

    34 import java.util.*;

    35 import javax.annotation.processing.*;

    36 import javax.lang.model.SourceVersion;

    37 import javax.lang.model.element.TypeElement;

    38 

    39 /**

    40  * A warning should be issued by the logic in

    41  * javax.annotation.processing.AbstractProcessor for the repeated

    42  * information.  The "Foo" option warnings occur regardless of source

    43  * level. The number of times the Baz annotation type is repeated

    44  * depends on whether or not the source level supports modules.

    45  */

    46 @Quux

    47 public class TestRepeatedItemsRuntime extends AbstractProcessor {

    48 

    49     @Override

    50     public SourceVersion getSupportedSourceVersion() {

    51         return SourceVersion.latest();

    52     }

    53 

    54     @Override

    55     public Set<String>getSupportedOptions() {

    56         IdentityHashMap<String, Integer> temp = new IdentityHashMap<>();

    57         // Use String constructor for identity map.

    58         temp.put(new String("foo"), 1);

    59         temp.put(new String("foo"), 2);

    60 

    61         var returnValue = temp.keySet();

    62         assert returnValue.size() == 2;

    63         return returnValue;

    64     }

    65 

    66     /**

    67      * Partial implementation of the Set interface with identity

    68      * semantics and predictable iteration order.

    69      *

    70      * The javax.annotation.processing.Processor protocol relies on

    71      * the iterator.

    72      */

    73     private static class ArrayBackedSet implements Set<String> {

    74         private static String[] data = {"Quux",

    75                                         "Quux",

    76                                         "&&&/foo.Bar",

    77                                         "foo.Bar",

    78                                         "foo.Bar",

    79                                         "quux/Quux",

    80                                         "*"};

    81         public ArrayBackedSet() {}

    82 

    83         // Return an iterator of known iteration order so the set warning messages will be predictable.

    84         @Override

    85         public Iterator<String> iterator() {

    86             return Arrays.asList(data).iterator();

    87         }

    88 

    89         @Override

    90         public boolean add(String e) {

    91             throw new UnsupportedOperationException();

    92         }

    93 

    94         @Override

    95         public boolean addAll(Collection<? extends String> c) {

    96             throw new UnsupportedOperationException();

    97         }

    98 

    99         @Override

   100         public void clear() {

   101             throw new UnsupportedOperationException();

   102         }

   103 

   104         @Override

   105         public boolean contains(Object o){

   106             throw new UnsupportedOperationException();

   107         }

   108 

   109         @Override

   110         public boolean containsAll(Collection<?> c) {

   111             throw new UnsupportedOperationException();

   112         }

   113 

   114         @Override

   115         public boolean equals(Object o) {

   116             return o == this;

   117         }

   118 

   119         @Override

   120         public int hashCode() {

   121             int hash = 0;

   122             for (String s : data) {

   123                 hash += s.hashCode();

   124             }

   125             return hash;

   126         }

   127 

   128         @Override

   129         public boolean isEmpty() {

   130             return data.length > 0;

   131         }

   132 

   133         @Override

   134         public boolean remove(Object o) {

   135             throw new UnsupportedOperationException();

   136         }

   137 

   138         @Override

   139         public boolean removeAll(Collection<?> c) {

   140             throw new UnsupportedOperationException();

   141         }

   142 

   143         @Override

   144         public boolean retainAll(Collection<?> c) {

   145             throw new UnsupportedOperationException();

   146         }

   147 

   148         @Override

   149         public int size() {

   150             return data.length;

   151         }

   152 

   153         @Override

   154         public Object[] toArray() {

   155             return data.clone();

   156         }

   157 

   158         @Override

   159         public <T> T[] toArray(T[] a) {

   160             throw new UnsupportedOperationException();

   161         }

   162     }

   163 

   164     @Override

   165     public Set<String>getSupportedAnnotationTypes() {

   166         return new ArrayBackedSet();

   167     }

   168 

   169     public boolean process(Set<? extends TypeElement> annotations,

   170                            RoundEnvironment roundEnvironment) {

   171         return true;

   172     }

   173 }

   174 

   175 @Retention(RetentionPolicy.RUNTIME)

   176 @interface Quux {

   177 }