Java example source code file (RepeatedUnitTest.java)

This example Java source code file (RepeatedUnitTest.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

annotatedelement, annotation, class, containee, father, grandma, inheritedcontainee, inheritedcontainer, inheritednonrepeated, me1, mother, nonrepeated, reflection, superof5, superof7, superof8, util

The RepeatedUnitTest.java Java example source code

/*
 * 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 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 {}