1 /*
2  * Licensed to the Apache Software Foundation (ASF) under one or more
3  * contributor license agreements.  See the NOTICE file distributed with
4  * this work for additional information regarding copyright ownership.
5  * The ASF licenses this file to You under the Apache License, Version 2.0
6  * (the "License"); you may not use this file except in compliance with
7  * the License.  You may obtain a copy of the License at
8  *
9  *   http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17 
18 package org.apache.harmony.annotation.tests.java.lang.annotation;
19 
20 import junit.framework.TestCase;
21 
22 import java.lang.annotation.Annotation;
23 import java.lang.reflect.Method;
24 import java.util.ArrayList;
25 import java.util.Arrays;
26 import java.util.HashMap;
27 import java.util.List;
28 import java.util.Map;
29 
30 /**
31  * Test case of java.lang.annotation.Annotation
32  */
33 public class AnnotationTest extends TestCase {
34 
test_annotationType()35     public void test_annotationType() {
36         Annotation [] annotations = AnnotatedClass.class.getDeclaredAnnotations();
37         assertEquals(1, annotations.length);
38         Annotation anno = annotations[0];
39         assertEquals(TestAnnotation1.class, anno.annotationType());
40     }
41 
test_equals()42     public void test_equals() throws Exception {
43         // test type
44         Method m1 = AnnotatedClass2.class
45                 .getDeclaredMethod("a", new Class[] {});
46         Method m2 = AnnotatedClass2.class
47                 .getDeclaredMethod("b", new Class[] {});
48         assertFalse("other annotation class type",
49                 m1.getDeclaredAnnotations()[0].equals(m2
50                         .getDeclaredAnnotations()[0]));
51 
52         // test equality / non equality for base types and compound types
53         List<Method> methods = Arrays.asList(AnnotatedClass.class.getDeclaredMethods());
54         Map<String, List<Method>> eqs = new HashMap<String, List<Method>>();
55         Map<String, List<Method>> neqs = new HashMap<String, List<Method>>();
56         for (Method m : methods) {
57             String name = m.getName();
58             //System.out.println("name "+name);
59             Map<String, List<Method>> curT = name.charAt(0) == 'e'? eqs : neqs;
60             String testNum = name.substring(1,3); // 01
61             List<Method> mlist = curT.get(testNum);
62             if (mlist == null) {
63                 mlist = new ArrayList<Method>();
64                 curT.put(testNum, mlist);
65             }
66             mlist.add(AnnotatedClass.class.getDeclaredMethod(name, new Class[] {}));
67         }
68 
69         for (List<Method> eqList : eqs.values()) {
70             for (int i = 0; i < eqList.size() -1; i++) {
71                 for (int j = i+1; j < eqList.size(); j++) {
72                     Method me1 = eqList.get(i);
73                     Method me2 = eqList.get(j);
74                     //System.out.println("eq test for "+me1.getName()+", "+me2.getName());
75                     Annotation a1 = me1.getDeclaredAnnotations()[0];
76                     Annotation a2 = me2.getDeclaredAnnotations()[0];
77                     assertEquals("must be equal : method1:"+me1.getName()+", method2: "+me2.getName(), a1, a2);
78                     assertEquals("same hashcode", a1.hashCode(), a2.hashCode());
79                 }
80             }
81         }
82 
83         for (List<Method> eqList : neqs.values()) {
84             for (int i = 0; i < eqList.size() -1; i++) {
85                 for (int j = i+1; j < eqList.size(); j++) {
86                     Method me1 = eqList.get(i);
87                     Method me2 = eqList.get(j);
88                     Annotation a1 = me1.getDeclaredAnnotations()[0];
89                     Annotation a2 = me2.getDeclaredAnnotations()[0];
90                     //System.out.println("ne test for "+me1.getName()+", "+me2.getName());
91                     assertFalse("must not be equal : method1:"+me1.getName()+", method2: "+me2.getName(),
92                             a1.equals(a2));
93                     if (a1.hashCode() != a2.hashCode()) {
94                         assertFalse("not same hashcode -> not equals", a1.equals(a2));
95                     }
96                 }
97 
98             }
99         }
100     }
101 
test_hashCode()102     public void test_hashCode() throws SecurityException, NoSuchMethodException {
103         Annotation a1 = AnnotatedClass.class.getDeclaredAnnotations()[0];
104         assertEquals(a1.hashCode(), (127 * "value".hashCode() ^ "foobar".hashCode()));
105         // i+= 127 *(key.hashCode() ^ memberValHashCode(value);
106 
107         Method m1 = AnnotatedClass.class.getDeclaredMethod("e34c", new Class[] {});
108         int arrHc = Arrays.hashCode(new Object[]{});
109         /*
110         TestAnnotation3[] arrAnno() default {};
111         String[] arrString() default {};
112         Class[] arrClass() default {};
113         TestEnum1[] arrEnum() default {};
114          */
115         assertEquals(
116                 (127 * "arrAnno".hashCode() ^ arrHc) +
117                 (127 * "arrString".hashCode() ^ arrHc)+
118                 (127 * "arrClass".hashCode() ^ arrHc) +
119                 (127 * "arrEnum".hashCode() ^ arrHc)
120                 ,
121                 m1.getDeclaredAnnotations()[0].hashCode());
122 
123         Method m2 = AnnotatedClass3.class.getDeclaredMethod("a", new Class[] {});
124         assertEquals(
125                 (127 * "i".hashCode() ^ 12345),
126                 m2.getDeclaredAnnotations()[0].hashCode());
127 
128     }
129 
test35304()130     public static void test35304() throws Exception {
131         Class c = AnnotationTest.class;
132         Class[] parameterTypes = new Class[] { String.class, String.class };
133         Annotation[][] annotations = c.getDeclaredMethod("test35304_method", parameterTypes).getParameterAnnotations();
134         assertEquals(2, annotations.length); // Two parameters.
135         assertEquals(0, annotations[0].length); // No annotations on the first.
136         assertEquals(1, annotations[1].length); // One annotation on the second.
137     }
138 
test35304_method(String s1, @Deprecated String s2)139     private static String test35304_method(String s1, @Deprecated String s2) { return null; }
140 }
141 
142 class AnnotatedClass2 {
143     @TestAnnotation3()
a()144     void a() {}
145     @TestAnnotation3b()
b()146     void b() {}
147 }
148 
149 class AnnotatedClass3 {
150     @TestAnnotation4(i = 12345)
a()151     void a() {}
152 }
153 
154 @TestAnnotation1("foobar")
155 class AnnotatedClass {
156 
157     // ----- boolean -----
158     @TestAnnotation3(z = false)
e01a()159     void e01a() {}
160     @TestAnnotation3(z = false)
e01b()161     void e01b() {}
162     @TestAnnotation3()
e01c()163     void e01c() {}
164 
165     @TestAnnotation3(z = true)
e02a()166     void e02a() {}
167     @TestAnnotation3(z = true)
e02b()168     void e02b() {}
169 
170     @TestAnnotation3(z = false)
n03a()171     void n03a() {}
172     @TestAnnotation3(z = true)
n03b()173     void n03b() {}
174 
175 
176     // ----- byte -----
177     @TestAnnotation3(b = 0)
e04a()178     void e04a() {}
179     @TestAnnotation3(b = 0)
e04b()180     void e04b() {}
181     @TestAnnotation3()
e04c()182     void e04c() {}
183 
184     @TestAnnotation3(b= 127)
e05a()185     void e05a() {}
186     @TestAnnotation3(b = 127)
e05b()187     void e05b() {}
188 
189     @TestAnnotation3(b = -128)
n06a()190     void n06a() {}
191     @TestAnnotation3(b = 127)
n06b()192     void n06b() {}
193 
194 
195     // ----- short -----
196     @TestAnnotation3(s = 0)
e07a()197     void e07a() {}
198     @TestAnnotation3(s = 0)
e07b()199     void e07b() {}
200     @TestAnnotation3()
e07c()201     void e07c() {}
202 
203     @TestAnnotation3(s= 32767)
e08a()204     void e08a() {}
205     @TestAnnotation3(s = 32767)
e08b()206     void e08b() {}
207 
208     @TestAnnotation3(s = -32768)
n09a()209     void n09a() {}
210     @TestAnnotation3(s = 32767)
n09b()211     void n09b() {}
212 
213 
214     // ----- int -----
215     @TestAnnotation3(i = 100)
e10a()216     void e10a() {}
217     @TestAnnotation3(i = 100)
e10b()218     void e10b() {}
219     @TestAnnotation3()
e10c()220     void e10c() {}
221 
222     @TestAnnotation3(i = Integer.MAX_VALUE)
e11a()223     void e11a() {}
224     @TestAnnotation3(i = Integer.MAX_VALUE)
e11b()225     void e11b() {}
226 
227     @TestAnnotation3(i = Integer.MAX_VALUE)
n12a()228     void n12a() {}
229     @TestAnnotation3(i = Integer.MIN_VALUE)
n12b()230     void n12b() {}
231 
232 
233     // ----- long -----
234     @TestAnnotation3(j = 0)
e13a()235     void e13a() {}
236     @TestAnnotation3(j = 0)
e13b()237     void e13b() {}
238     @TestAnnotation3()
e13c()239     void e13c() {}
240 
241     @TestAnnotation3(j = Long.MAX_VALUE)
e14a()242     void e14a() {}
243     @TestAnnotation3(j = Long.MAX_VALUE)
e14b()244     void e14b() {}
245 
246     @TestAnnotation3(j = Long.MAX_VALUE)
n15a()247     void n15a() {}
248     @TestAnnotation3(j = Long.MIN_VALUE)
n15b()249     void n15b() {}
250 
251 
252     // ----- float -----
253     @TestAnnotation3(f = 0.0f)
e16a()254     void e16a() {}
255     @TestAnnotation3(f = 0.0f)
e16b()256     void e16b() {}
257     @TestAnnotation3()
e16c()258     void e16c() {}
259 
260     @TestAnnotation3(f = Float.MAX_VALUE)
e17a()261     void e17a() {}
262     @TestAnnotation3(f = Float.MAX_VALUE)
e17b()263     void e17b() {}
264 
265     @TestAnnotation3(f = Float.NaN)
e18a()266     void e18a() {}
267     @TestAnnotation3(f = Float.NaN)
e18b()268     void e18b() {}
269 
270     @TestAnnotation3(f = Long.MAX_VALUE)
n19a()271     void n19a() {}
272     @TestAnnotation3(f = Long.MIN_VALUE)
n19b()273     void n19b() {}
274 
275     @TestAnnotation3(f = 0.0f)
n20a()276     void n20a() {}
277     @TestAnnotation3(f = -0.0f)
n20b()278     void n20b() {}
279 
280 
281     // ----- double -----
282     @TestAnnotation3(d = 0.0d)
e21a()283     void e21a() {}
284     @TestAnnotation3(d = 0.0d)
e21b()285     void e21b() {}
286     @TestAnnotation3()
e21c()287     void e21c() {}
288 
289     @TestAnnotation3(d = Double.MAX_VALUE)
e22a()290     void e22a() {}
291     @TestAnnotation3(d = Double.MAX_VALUE)
e22b()292     void e22b() {}
293 
294     @TestAnnotation3(d = Double.NaN)
e23a()295     void e23a() {}
296     @TestAnnotation3(d = Double.NaN)
e23b()297     void e23b() {}
298 
299 
300     @TestAnnotation3(d = Double.MAX_VALUE)
n24a()301     void n24a() {}
302     @TestAnnotation3(d = Double.MIN_VALUE)
n24b()303     void n24b() {}
304 
305     @TestAnnotation3(d = 0.0d)
n25a()306     void n25a() {}
307     @TestAnnotation3(d = -0.0d)
n25b()308     void n25b() {}
309 
310 
311  // ----- String -----
312     @TestAnnotation3(aString = "")
e26a()313     void e26a() {}
314     @TestAnnotation3(aString = "")
e26b()315     void e26b() {}
316     @TestAnnotation3()
e26c()317     void e26c() {}
318 
319     @TestAnnotation3(aString = "asjdfk jkls dfjklsd fklsd jklds kflds jfkldsfjd"+"d")
e27a()320     void e27a() {}
321     @TestAnnotation3(aString = "asjdfk jkls dfjklsd fklsd jklds kflds jfkldsfj"+"dd")
e27b()322     void e27b() {}
323 
324     @TestAnnotation3(aString = "a")
n28a()325     void n28a() {}
326     @TestAnnotation3(aString = "b")
n28b()327     void n28b() {}
328 
329 
330     // ----- Class-----
331     @TestAnnotation3(aClazz = Void.class)
e29a()332     void e29a() {}
333     @TestAnnotation3(aClazz = Void.class)
e29b()334     void e29b() {}
335     @TestAnnotation3()
e29c()336     void e29c() {}
337 
338     @TestAnnotation3(aClazz = Integer.class)
n30a()339     void n30a() {}
340     @TestAnnotation3(aClazz = int.class)
n30b()341     void n30b() {}
342 
343 
344     // ----- Enum-----
345     @TestAnnotation3(aEnum = TestEnum1.F)
e31a()346     void e31a() {}
347     @TestAnnotation3(aEnum = TestEnum1.F)
e31b()348     void e31b() {}
349     @TestAnnotation3()
e31c()350     void e31c() {}
351 
352     @TestAnnotation3(aEnum = TestEnum1.F)
n32a()353     void n32a() {}
354     @TestAnnotation3(aEnum = TestEnum1.A)
n32b()355     void n32b() {}
356 
357     @TestAnnotation3(aEnum = TestEnum1.F)
n33a()358     void n33a() {}
359     @TestAnnotation3(aEnum = TestEnum1.L)
n33b()360     void n33b() {}
361 
362 
363     // ----- String arr-----
364     @TestAnnotation2(arrString = {})
e34a()365     void e34a() {}
366     @TestAnnotation2(arrString = {})
e34b()367     void e34b() {}
368     @TestAnnotation2(arrString = {})
e34c()369     void e34c() {}
370 
371     @TestAnnotation2(arrString = { "a", "b"})
e35a()372     void e35a() {}
373     @TestAnnotation2(arrString = { "a", "b" })
e35b()374     void e35b() {}
375 
376     @TestAnnotation2(arrString = { "a", "b"})
n36a()377     void n36a() {}
378     @TestAnnotation2(arrString = { "a", "c" })
n36b()379     void n36b() {}
380 
381 
382     // ----- Class arr-----
383     @TestAnnotation2(arrClass= {})
e37a()384     void e37a() {}
385     @TestAnnotation2(arrClass = {})
e37b()386     void e37b() {}
387     @TestAnnotation2(arrClass = {})
e37c()388     void e37c() {}
389 
390     @TestAnnotation2(arrClass = { Void.class, Integer.class})
e38a()391     void e38a() {}
392     @TestAnnotation2(arrClass = { Void.class, Integer.class})
e38b()393     void e38b() {}
394 
395     @TestAnnotation2(arrClass = { Void.class, Integer.class})
n39a()396     void n39a() {}
397     @TestAnnotation2(arrClass = { Void.class, int.class})
n39b()398     void n39b() {}
399 
400     // ----- Enum arr-----
401     @TestAnnotation2(arrEnum= {})
e40a()402     void e40a() {}
403     @TestAnnotation2(arrEnum = {})
e40b()404     void e40b() {}
405     @TestAnnotation2(arrEnum = {})
e40c()406     void e40c() {}
407 
408     @TestAnnotation2(arrEnum = { TestEnum1.A, TestEnum1.F })
e41a()409     void e41a() {}
410     @TestAnnotation2(arrEnum = { TestEnum1.A, TestEnum1.F })
e41b()411     void e41b() {}
412 
413     @TestAnnotation2(arrEnum = { TestEnum1.A, TestEnum1.F })
n42a()414     void n42a() {}
415     @TestAnnotation2(arrEnum = { TestEnum1.A, TestEnum1.L })
n42b()416     void n42b() {}
417 
418 
419     // ----- Annotation arr-----
420     @TestAnnotation2(arrAnno= {})
e43a()421     void e43a() {}
422     @TestAnnotation2(arrAnno = {})
e43b()423     void e43b() {}
424     @TestAnnotation2()
e43c()425     void e43c() {}
426 
427     @TestAnnotation2(arrAnno = { @TestAnnotation3(i = 20), @TestAnnotation3(j = 123)})
e44a()428     void e44a() {}
429     @TestAnnotation2(arrAnno = { @TestAnnotation3(i = 20), @TestAnnotation3(j = 123)})
e44b()430     void e44b() {}
431 
432     @TestAnnotation2(arrAnno = { @TestAnnotation3(i = 20), @TestAnnotation3(j = 123)})
n45a()433     void n45a() {}
434     @TestAnnotation2(arrAnno = { @TestAnnotation3(i = 20), @TestAnnotation3(j = 124)})
n45b()435     void n45b() {}
436 
437     @TestAnnotation2(arrAnno = { @TestAnnotation3(i = 20), @TestAnnotation3(j = 123)})
n46a()438     void n46a() {}
439     @TestAnnotation2(arrAnno = { @TestAnnotation3(i = -20), @TestAnnotation3(j = 123)})
n46b()440     void n46b() {}
441 
442 }
443