/*
* Copyright (c) 2012, 2013, 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 7154390 8005712 8007278 8004912
* @summary Unit test for repeated annotation reflection
*
* @compile RepeatedUnitTest.java subpackage/package-info.java subpackage/Container.java subpackage/Containee.java subpackage/NonRepeated.java subpackage/InheritedContainee.java subpackage/InheritedContainer.java subpackage/InheritedNonRepeated.java
* @run main RepeatedUnitTest
*/
import subpackage.*;
import java.lang.annotation.*;
import java.lang.reflect.*;
import java.util.*;
public class RepeatedUnitTest {
public static void main(String[] args) throws Exception {
// PACKAGE ANNOTATIONS
Class c = Class.forName("subpackage.NonRepeated"); // force package "subpackage" load
Package p = Package.getPackage("subpackage");
packageNonRepeated(p);
packageRepeated(p);
packageContainer(p);
// INHERITED/NON-INHERITED ON CLASS
inheritedMe1();
inheritedMe2();
inheritedMe3();
inheritedMe4();
inheritedMe5(); // ContainerOnSuperSingleOnSub
inheritedMe6(); // RepeatableOnSuperSingleOnSub
inheritedMe7(); // SingleAnnoOnSuperContainerOnSub
inheritedMe8(); // SingleOnSuperRepeatableOnSub
// CONSTRUCTOR
checkMultiplier(Me1.class.getConstructor(new Class[0]), 10);
// FIELD
checkMultiplier(Me1.class.getField("foo"), 1);
// METHOD
checkMultiplier(Me1.class.getDeclaredMethod("mee", (Class<?>[])null), 100);
// INNER CLASS
checkMultiplier(Me1.MiniMee.class, 1000);
// ENUM ELEMENT
checkMultiplier(Me1.E.class.getField("EE"), 10000);
// ENUM
checkMultiplier(Me1.E.class, 100000);
}
static void packageNonRepeated(AnnotatedElement e) {
NonRepeated nr = e.getAnnotation(NonRepeated.class);
check(nr.value() == 10);
check(1 == countAnnotation(e, NonRepeated.class));
nr = e.getAnnotationsByType(NonRepeated.class)[0];
check(nr.value() == 10);
check(1 == containsAnnotationOfType(e.getAnnotations(), NonRepeated.class));
}
static void packageRepeated(AnnotatedElement e) {
Containee c = e.getAnnotation(Containee.class);
check(c == null);
check(2 == countAnnotation(e, Containee.class));
c = e.getAnnotationsByType(Containee.class)[0];
check(c.value() == 1);
c = e.getAnnotationsByType(Containee.class)[1];
check(c.value() == 2);
check(0 == containsAnnotationOfType(e.getAnnotations(), Containee.class));
}
static void packageContainer(AnnotatedElement e) {
Container cr = e.getAnnotation(Container.class);
check(null != cr);
check(1 == containsAnnotationOfType(e.getAnnotationsByType(Container.class), Container.class));
check(1 == countAnnotation(e, Container.class));
}
static void inheritedMe1() {
AnnotatedElement e = Me1.class;
check(null == e.getAnnotation(NonRepeated.class));
check(e.getAnnotation(InheritedNonRepeated.class).value() == 20);
check(0 == countAnnotation(e, Containee.class));
check(4 == countAnnotation(e, InheritedContainee.class));
check(0 == countAnnotation(e, Container.class));
check(1 == countAnnotation(e, InheritedContainer.class));
}
static void inheritedMe2() {
AnnotatedElement e = Me2.class;
check(e.getAnnotation(NonRepeated.class).value() == 100);
check(e.getAnnotation(InheritedNonRepeated.class).value() == 200);
check(4 == countAnnotation(e, Containee.class));
check(4 == countAnnotation(e, InheritedContainee.class));
check(1 == countAnnotation(e, Container.class));
check(1 == countAnnotation(e, InheritedContainer.class));
check(1 == countAnnotation(e, NonRepeated.class));
check(1 == countAnnotation(e, InheritedNonRepeated.class));
check(e.getAnnotationsByType(Containee.class)[2].value() == 300);
check(e.getAnnotationsByType(InheritedContainee.class)[2].value() == 300);
check(e.getAnnotationsByType(InheritedNonRepeated.class)[0].value() == 200);
check(e.getAnnotationsByType(NonRepeated.class)[0].value() == 100);
}
static void inheritedMe3() {
AnnotatedElement e = Me3.class;
check(null == e.getAnnotation(NonRepeated.class));
check(0 == countAnnotation(e, Containee.class));
check(4 == countAnnotation(e, InheritedContainee.class));
check(0 == countAnnotation(e, Container.class));
check(1 == countAnnotation(e, InheritedContainer.class));
check(e.getAnnotationsByType(InheritedContainee.class)[2].value() == 350);
check(e.getAnnotationsByType(InheritedNonRepeated.class)[0].value() == 15);
}
static void inheritedMe4() {
AnnotatedElement e = Me4.class;
check(e.getAnnotation(NonRepeated.class).value() == 1000);
check(e.getAnnotation(InheritedNonRepeated.class).value() == 2000);
check(4 == countAnnotation(e, Containee.class));
check(4 == countAnnotation(e, InheritedContainee.class));
check(1 == countAnnotation(e, Container.class));
check(1 == countAnnotation(e, InheritedContainer.class));
check(1 == countAnnotation(e, NonRepeated.class));
check(1 == countAnnotation(e, InheritedNonRepeated.class));
check(e.getAnnotationsByType(Containee.class)[2].value() == 3000);
check(e.getAnnotationsByType(InheritedContainee.class)[2].value() == 3000);
check(e.getAnnotationsByType(InheritedNonRepeated.class)[0].value() == 2000);
check(e.getAnnotationsByType(NonRepeated.class)[0].value() == 1000);
}
static void inheritedMe5() {
AnnotatedElement e = Me5.class;
check(2 == e.getAnnotations().length);
check(1 == countAnnotation(e, InheritedContainee.class));
}
static void inheritedMe6() {
AnnotatedElement e = Me6.class;
check(2 == e.getAnnotations().length);
check(1 == countAnnotation(e, InheritedContainee.class));
}
static void inheritedMe7() {
AnnotatedElement e = Me7.class;
check(2 == e.getAnnotations().length);
check(2 == countAnnotation(e, InheritedContainee.class));
}
static void inheritedMe8() {
AnnotatedElement e = Me8.class;
check(2 == e.getAnnotations().length);
check(2 == countAnnotation(e, InheritedContainee.class));
}
static void checkMultiplier(AnnotatedElement e, int m) {
// Basic sanity of non-repeating getAnnotation(Class)
check(e.getAnnotation(NonRepeated.class).value() == 5 * m);
// Check count of annotations returned from getAnnotationsByType(Class)
check(4 == countAnnotation(e, Containee.class));
check(1 == countAnnotation(e, Container.class));
check(1 == countAnnotation(e, NonRepeated.class));
// Check contents of array returned from getAnnotationsByType(Class)
check(e.getAnnotationsByType(Containee.class)[2].value() == 3 * m);
check(e.getAnnotationsByType(NonRepeated.class)[0].value() == 5 * m);
// Check getAnnotation(Class)
check(e.getAnnotation(Containee.class) == null);
check(e.getAnnotation(Container.class) != null);
// Check count of annotations returned from getAnnotations()
check(0 == containsAnnotationOfType(e.getAnnotations(), Containee.class));
check(1 == containsAnnotationOfType(e.getAnnotations(), Container.class));
check(1 == containsAnnotationOfType(e.getAnnotations(), NonRepeated.class));
}
static void check(Boolean b) {
if (!b) throw new RuntimeException();
}
static int countAnnotation(AnnotatedElement e, Class<? extends Annotation> c) {
return containsAnnotationOfType(e.getAnnotationsByType(c), c);
}
static <A extends Annotation> int containsAnnotationOfType(A[] l, Class<? extends Annotation> a) {
int count = 0;
for (Annotation an : l) {
if (an.annotationType().equals(a))
count++;
}
return count;
}
}
@NonRepeated @InheritedNonRepeated
@InheritedContainee(1) @InheritedContainee(2) @InheritedContainee(3) @InheritedContainee(4)
@Containee(1) @Containee(2) @Containee(3) @Containee(4)
class Grandma {}
class Mother extends Grandma {}
@NonRepeated(5) @InheritedNonRepeated(15)
@InheritedContainee(150) @InheritedContainee(250) @InheritedContainee(350) @InheritedContainee(450)
@Containee(150) @Containee(250) @Containee(350) @Containee(450)
class Father extends Grandma {}
class Me1 extends Mother {
@NonRepeated(5)
@Containee(1) @Containee(2) @Containee(3) @Containee(4)
public String foo = "";
@NonRepeated(50)
@Containee(10) @Containee(20) @Containee(30) @Containee(40)
public Me1() {
}
@NonRepeated(500)
@Containee(100) @Containee(200) @Containee(300) @Containee(400)
public void mee() {
}
@NonRepeated(5000)
@Containee(1000) @Containee(2000) @Containee(3000) @Containee(4000)
public class MiniMee {}
@NonRepeated(500000)
@Containee(100000) @Containee(200000) @Containee(300000) @Containee(400000)
public enum E {
@NonRepeated(50000)
@Containee(10000) @Containee(20000) @Containee(30000) @Containee(40000)
EE(),
}
}
@NonRepeated(100) @InheritedNonRepeated(200)
@InheritedContainee(100) @InheritedContainee(200) @InheritedContainee(300) @InheritedContainee(400)
@Containee(100) @Containee(200) @Containee(300) @Containee(400)
class Me2 extends Mother {}
class Me3 extends Father {}
@NonRepeated(1000) @InheritedNonRepeated(2000)
@InheritedContainee(1000) @InheritedContainee(2000) @InheritedContainee(3000) @InheritedContainee(4000)
@Containee(1000) @Containee(2000) @Containee(3000) @Containee(4000)
class Me4 extends Father {}
@InheritedContainer({@InheritedContainee(1), @InheritedContainee(2)})
class SuperOf5 {}
@InheritedContainee(3)
class Me5 extends SuperOf5{}
@InheritedContainee(1) @InheritedContainee(2)
class SuperOf6 {}
@InheritedContainee(3)
class Me6 extends SuperOf6 {}
@InheritedContainee(1)
class SuperOf7 {}
@InheritedContainer({@InheritedContainee(2), @InheritedContainee(3)})
class Me7 extends SuperOf7 {}
@InheritedContainee(1)
class SuperOf8 {}
@InheritedContainee(2) @InheritedContainee(3)
class Me8 extends SuperOf8 {}