test/langtools/tools/javac/classfiles/attributes/annotations/RuntimeAnnotationsTestBase.java

/*
 * Copyright (c) 2015, 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.
 */

import com.sun.tools.classfile.*;

import java.io.IOException;
import java.lang.annotation.RetentionPolicy;
import java.util.*;
import java.util.function.Supplier;

import javax.tools.JavaFileObject;

public abstract class RuntimeAnnotationsTestBase extends AnnotationsTestBase {

    @Override
    public void test(TestCase testCase, Map<String, ? extends JavaFileObject> classes)
            throws IOException, ConstantPoolException, Descriptor.InvalidDescriptor {
        for (Map.Entry<String, ? extends JavaFileObject> entry : classes.entrySet()) {
            String className = entry.getKey();
            TestCase.TestClassInfo clazz = testCase.getTestClassInfo(className);
            echo("Testing class : " + className);
            ClassFile classFile = readClassFile(entry.getValue());

            testAttributes(clazz, classFile, () -> classFile.attributes);

            testMethods(clazz, classFile);

            testFields(clazz, classFile);
        }
    }

    private void testMethods(TestCase.TestClassInfo clazz, ClassFile classFile)
            throws ConstantPoolException, Descriptor.InvalidDescriptor {
        String className = clazz.getName();
        Set<String> foundMethods = new HashSet<>();
        for (Method method : classFile.methods) {
            String methodName = method.getName(classFile.constant_pool) +
                    method.descriptor.getParameterTypes(classFile.constant_pool);
            if (methodName.startsWith("<init>")) {
                String constructorName = className.replaceAll(".*\\$", "");
                methodName = methodName.replace("<init>", constructorName);
            }
            echo("Testing method : " + methodName);

            TestCase.TestMethodInfo testMethod = clazz.getTestMethodInfo(methodName);
            foundMethods.add(methodName);
            if (testMethod == null) {
                continue;
            }
            testAttributes(testMethod, classFile, () -> method.attributes);
        }
        checkContains(foundMethods, clazz.methods.keySet(), "Methods in class : " + className);
    }

    private void testFields(TestCase.TestClassInfo clazz, ClassFile classFile)
            throws ConstantPoolException {
        Set<String> foundFields = new HashSet<>();
        for (Field field : classFile.fields) {
            String fieldName = field.getName(classFile.constant_pool);
            echo("Testing field : " + fieldName);

            TestCase.TestFieldInfo testField = clazz.getTestFieldInfo(fieldName);
            foundFields.add(fieldName);
            if (testField == null) {
                continue;
            }
            testAttributes(testField, classFile, () -> field.attributes);
        }
        checkContains(foundFields, clazz.fields.keySet(), "Fields in class : " + clazz.getName());
    }

    private void testAttributes(
            TestCase.TestMemberInfo member,
            ClassFile classFile,
            Supplier<Attributes> attributes)
            throws ConstantPoolException {
        Map<String, Annotation> actualInvisible = collectAnnotations(
                classFile,
                member,
                attributes.get(),
                Attribute.RuntimeInvisibleAnnotations);
        Map<String, Annotation> actualVisible = collectAnnotations(
                classFile,
                member,
                attributes.get(),
                Attribute.RuntimeVisibleAnnotations);

        checkEquals(actualInvisible.keySet(),
                member.getRuntimeInvisibleAnnotations(), "RuntimeInvisibleAnnotations");
        checkEquals(actualVisible.keySet(),
                member.getRuntimeVisibleAnnotations(), "RuntimeVisibleAnnotations");

        for (TestAnnotationInfo expectedAnnotation : member.annotations.values()) {
            RetentionPolicy policy = getRetentionPolicy(expectedAnnotation.annotationName);
            if (policy == RetentionPolicy.SOURCE) {
                continue;
            }
            printf("Testing: isVisible: %s %s%n", policy.toString(), expectedAnnotation.annotationName);
            Annotation actualAnnotation =
                    (policy == RetentionPolicy.RUNTIME ? actualVisible : actualInvisible)
                            .get(expectedAnnotation.annotationName);
            if (checkNotNull(actualAnnotation, "Annotation is found : "
                    + expectedAnnotation.annotationName)) {
                expectedAnnotation.testAnnotation(this, classFile, actualAnnotation);
            }
        }
    }

    private Map<String, Annotation> collectAnnotations(
            ClassFile classFile,
            TestCase.TestMemberInfo member,
            Attributes attributes,
            String attribute) throws ConstantPoolException {

        RuntimeAnnotations_attribute attr = (RuntimeAnnotations_attribute) attributes.get(attribute);
        Map<String, Annotation> actualAnnotations = new HashMap<>();
        RetentionPolicy policy = getRetentionPolicy(attribute);
        if (member.isAnnotated(policy)) {
            if (!checkNotNull(attr, String.format("%s should be not null value", attribute))) {
                // test case failed, stop checking
                return actualAnnotations;
            }
            for (Annotation ann : attr.annotations) {
                String name = classFile.constant_pool.getUTF8Value(ann.type_index);
                actualAnnotations.put(name.substring(1, name.length() - 1), ann);
            }
            checkEquals(countNumberOfAttributes(attributes.attrs,
                    getRetentionPolicy(attribute) == RetentionPolicy.RUNTIME
                            ? RuntimeVisibleAnnotations_attribute.class
                            : RuntimeInvisibleAnnotations_attribute.class),
                    1l,
                    String.format("Number of %s", attribute));
        } else {
            checkNull(attr, String.format("%s should be null", attribute));
        }
        return actualAnnotations;
    }
}