313 lines
11 KiB
Java
313 lines
11 KiB
Java
/*
|
|
* 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 {}
|