| /* |
| * Copyright (c) 2016, 2017, 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. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * 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. |
| */ |
| |
| /* |
| * Create class file using ASM, slightly modified the ASMifier output |
| */ |
| |
| import org.testng.Assert; |
| import org.testng.annotations.Test; |
| |
| import java.lang.annotation.Annotation; |
| import java.lang.annotation.AnnotationFormatError; |
| import java.util.Arrays; |
| import java.util.Set; |
| import java.util.stream.Collectors; |
| import java.util.stream.Stream; |
| |
| /* |
| * @test |
| * @bug 8158510 |
| * @summary Verify valid annotation |
| * @modules java.base/jdk.internal.org.objectweb.asm |
| * @modules java.base/sun.reflect.annotation |
| * @clean AnnotationWithVoidReturn AnnotationWithParameter |
| * AnnotationWithExtraInterface AnnotationWithException |
| * AnnotationWithHashCode AnnotationWithDefaultMember |
| * AnnotationWithoutAnnotationAccessModifier HolderX |
| * @compile -XDignore.symbol.file ClassFileGenerator.java GoodAnnotation.java |
| * @run main ClassFileGenerator |
| * @run testng AnnotationVerifier |
| */ |
| |
| public class AnnotationVerifier { |
| |
| //======================================================= |
| // GoodAnnotation... |
| |
| @GoodAnnotation |
| static class HolderA { |
| } |
| |
| @Test |
| public void holderA_goodAnnotation() { |
| testGetAnnotation(HolderA.class, GoodAnnotation.class, true); |
| } |
| |
| @Test |
| public void holderA_annotations() { |
| testGetAnnotations(HolderA.class, GoodAnnotation.class); |
| } |
| |
| //======================================================= |
| // AnnotationWithParameter... |
| |
| /* |
| @Retention(RetentionPolicy.RUNTIME) |
| public @interface AnnotationWithParameter { |
| int m(int x) default -1; |
| } |
| */ |
| |
| @GoodAnnotation |
| @AnnotationWithParameter |
| static class HolderB { |
| } |
| |
| @Test |
| public void holderB_annotationWithParameter() { |
| testGetAnnotation(HolderB.class, AnnotationWithParameter.class, false); |
| } |
| |
| @Test |
| public void holderB_goodAnnotation() { |
| testGetAnnotation(HolderB.class, GoodAnnotation.class, true); |
| } |
| |
| @Test |
| public void holderB_annotations() { |
| testGetAnnotations(HolderB.class, GoodAnnotation.class); |
| } |
| |
| //======================================================= |
| // AnnotationWithVoidReturn... |
| |
| /* |
| @Retention(RetentionPolicy.RUNTIME) |
| public @interface AnnotationWithVoidReturn { |
| void m() default 1; |
| } |
| */ |
| |
| @GoodAnnotation |
| @AnnotationWithVoidReturn |
| static class HolderC { |
| } |
| |
| @Test(expectedExceptions = AnnotationFormatError.class) |
| public void holderC_annotationWithVoidReturn() { |
| testGetAnnotation(HolderC.class, AnnotationWithVoidReturn.class, false); |
| } |
| |
| @Test(expectedExceptions = AnnotationFormatError.class) |
| public void holderC_goodAnnotation() { |
| testGetAnnotation(HolderC.class, GoodAnnotation.class, false); |
| } |
| |
| @Test(expectedExceptions = AnnotationFormatError.class) |
| public void holderC_annotations() { |
| testGetAnnotations(HolderC.class); |
| } |
| |
| //======================================================= |
| // AnnotationWithExtraInterface... |
| |
| /* |
| @Retention(RetentionPolicy.RUNTIME) |
| public @interface AnnotationWithExtraInterface extends java.io.Serializable { |
| int m() default 1; |
| } |
| */ |
| |
| @GoodAnnotation |
| @AnnotationWithExtraInterface |
| static class HolderD { |
| } |
| |
| @Test(expectedExceptions = AnnotationFormatError.class) |
| public void holderD_annotationWithExtraInterface() { |
| testGetAnnotation(HolderD.class, AnnotationWithExtraInterface.class, false); |
| } |
| |
| @Test(expectedExceptions = AnnotationFormatError.class) |
| public void holderD_goodAnnotation() { |
| testGetAnnotation(HolderD.class, GoodAnnotation.class, false); |
| } |
| |
| @Test(expectedExceptions = AnnotationFormatError.class) |
| public void holderD_annotations() { |
| testGetAnnotations(HolderD.class); |
| } |
| |
| //======================================================= |
| // AnnotationWithException... |
| |
| /* |
| @Retention(RetentionPolicy.RUNTIME) |
| public @interface AnnotationWithException { |
| int m() throws Exception default 1; |
| } |
| */ |
| |
| @GoodAnnotation |
| @AnnotationWithException |
| static class HolderE { |
| } |
| |
| @AnnotationWithException |
| static class HolderE2 { |
| } |
| |
| @Test |
| public void holderE_annotationWithException() { |
| testGetAnnotation(HolderE.class, AnnotationWithException.class, true); |
| } |
| |
| @Test |
| public void holderE_goodAnnotation() { |
| testGetAnnotation(HolderE.class, GoodAnnotation.class, true); |
| } |
| |
| @Test |
| public void holderE_annotations() { |
| testGetAnnotations(HolderE.class, GoodAnnotation.class, AnnotationWithException.class); |
| } |
| |
| @Test(expectedExceptions = AnnotationFormatError.class) |
| public void holderE_annotationWithException_equals() { |
| AnnotationWithException ann1, ann2; |
| try { |
| ann1 = HolderE.class.getAnnotation(AnnotationWithException.class); |
| ann2 = HolderE2.class.getAnnotation(AnnotationWithException.class); |
| } catch (Throwable t) { |
| throw new AssertionError("Unexpected exception", t); |
| } |
| Assert.assertNotNull(ann1); |
| Assert.assertNotNull(ann2); |
| |
| testEquals(ann1, ann2, true); // this throws AnnotationFormatError |
| } |
| |
| //======================================================= |
| // AnnotationWithHashCode... |
| |
| /* |
| @Retention(RetentionPolicy.RUNTIME) |
| public @interface AnnotationWithHashCode { |
| int hashCode() default 1; |
| } |
| */ |
| |
| @GoodAnnotation |
| @AnnotationWithHashCode |
| static class HolderF { |
| } |
| |
| @AnnotationWithHashCode |
| static class HolderF2 { |
| } |
| |
| @Test |
| public void holderF_annotationWithHashCode() { |
| testGetAnnotation(HolderF.class, AnnotationWithHashCode.class, true); |
| } |
| |
| @Test |
| public void holderF_goodAnnotation() { |
| testGetAnnotation(HolderF.class, GoodAnnotation.class, true); |
| } |
| |
| @Test |
| public void holderF_annotations() { |
| testGetAnnotations(HolderF.class, GoodAnnotation.class, AnnotationWithHashCode.class); |
| } |
| |
| @Test(expectedExceptions = AnnotationFormatError.class) |
| public void holderF_annotationWithHashCode_equals() { |
| AnnotationWithHashCode ann1, ann2; |
| try { |
| ann1 = HolderF.class.getAnnotation(AnnotationWithHashCode.class); |
| ann2 = HolderF2.class.getAnnotation(AnnotationWithHashCode.class); |
| } catch (Throwable t) { |
| throw new AssertionError("Unexpected exception", t); |
| } |
| Assert.assertNotNull(ann1); |
| Assert.assertNotNull(ann2); |
| |
| testEquals(ann1, ann2, true); // this throws AnnotationFormatError |
| } |
| |
| //======================================================= |
| // AnnotationWithDefaultMember... |
| |
| /* |
| @Retention(RetentionPolicy.RUNTIME) |
| public @interface AnnotationWithDefaultMember { |
| int m() default 1; |
| default int d() default 2 { return 2; } |
| } |
| */ |
| |
| @GoodAnnotation |
| @AnnotationWithDefaultMember |
| static class HolderG { |
| } |
| |
| @AnnotationWithDefaultMember |
| static class HolderG2 { |
| } |
| |
| @Test |
| public void holderG_annotationWithDefaultMember() { |
| testGetAnnotation(HolderG.class, AnnotationWithDefaultMember.class, true); |
| } |
| |
| @Test |
| public void holderG_goodAnnotation() { |
| testGetAnnotation(HolderG.class, GoodAnnotation.class, true); |
| } |
| |
| @Test |
| public void holderG_annotations() { |
| testGetAnnotations(HolderG.class, GoodAnnotation.class, AnnotationWithDefaultMember.class); |
| } |
| |
| @Test(expectedExceptions = AnnotationFormatError.class) |
| public void holderG_annotationWithDefaultMember_equals() { |
| AnnotationWithDefaultMember ann1, ann2; |
| try { |
| ann1 = HolderG.class.getAnnotation(AnnotationWithDefaultMember.class); |
| ann2 = HolderG2.class.getAnnotation(AnnotationWithDefaultMember.class); |
| } catch (Throwable t) { |
| throw new AssertionError("Unexpected exception", t); |
| } |
| Assert.assertNotNull(ann1); |
| Assert.assertNotNull(ann2); |
| |
| testEquals(ann1, ann2, true); // this throws AnnotationFormatError |
| } |
| |
| //======================================================= |
| // AnnotationWithoutAnnotationAccessModifier... |
| |
| /* |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| public interface AnnotationWithoutAnnotationAccessModifier extends Annotation { |
| int m() default 1; |
| } |
| |
| @GoodAnnotation |
| @AnnotationWithoutAnnotationAccessModifier |
| static class HolderX { |
| } |
| |
| */ |
| |
| @Test |
| public void holderX_annotationWithoutAnnotationAccessModifier() { |
| testGetAnnotation(HolderX.class, AnnotationWithoutAnnotationAccessModifier.class, false); |
| } |
| |
| @Test |
| public void holderX_goodAnnotation() { |
| testGetAnnotation(HolderX.class, GoodAnnotation.class, true); |
| } |
| |
| @Test |
| public void holderX_annotations() { |
| testGetAnnotations(HolderX.class, GoodAnnotation.class); |
| } |
| |
| //======================================================= |
| // utils |
| // |
| |
| private static void testGetAnnotation(Class<?> holderClass, |
| Class<? extends Annotation> annType, |
| boolean expectedPresent) { |
| Object result = null; |
| try { |
| try { |
| result = holderClass.getAnnotation(annType); |
| if (expectedPresent != (result != null)) { |
| throw new AssertionError("Expected " + |
| (expectedPresent ? "non-null" : "null") + |
| " result, but got: " + result); |
| } |
| } catch (Throwable t) { |
| result = t; |
| throw t; |
| } |
| } finally { |
| System.out.println("\n" + |
| holderClass.getSimpleName() + |
| ".class.getAnnotation(" + |
| annType.getSimpleName() + |
| ".class) = " + |
| result); |
| } |
| } |
| |
| private static void testGetAnnotations(Class<?> holderClass, |
| Class<? extends Annotation> ... expectedTypes) { |
| Object result = null; |
| try { |
| try { |
| Annotation[] anns = holderClass.getAnnotations(); |
| |
| Set<Class<? extends Annotation>> gotTypes = |
| Stream.of(anns) |
| .map(Annotation::annotationType) |
| .collect(Collectors.toSet()); |
| |
| Set<Class<? extends Annotation>> expTypes = |
| Stream.of(expectedTypes) |
| .collect(Collectors.toSet()); |
| |
| if (!expTypes.equals(gotTypes)) { |
| throw new AssertionError("Expected annotation types: " + expTypes + |
| " but got: " + Arrays.toString(anns)); |
| } |
| result = Arrays.toString(anns); |
| } catch (Throwable t) { |
| result = t; |
| throw t; |
| } |
| } finally { |
| System.out.println("\n" + |
| holderClass.getSimpleName() + |
| ".class.getAnnotations() = " + |
| result); |
| } |
| } |
| |
| private static void testEquals(Annotation ann1, Annotation ann2, boolean expectedEquals) { |
| Object result = null; |
| try { |
| try { |
| boolean gotEquals = ann1.equals(ann2); |
| Assert.assertEquals(gotEquals, expectedEquals); |
| result = gotEquals; |
| } catch (Throwable t) { |
| result = t; |
| throw t; |
| } |
| } finally { |
| System.out.println("\n" + ann1 + ".equals(" + ann2 + ") = " + result); |
| } |
| } |
| } |