test/jdk/java/lang/annotation/repeatingAnnotations/RepeatedUnitTest.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 {}