1/* 2 * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 */ 23 24/* 25 * @test 26 * @bug 8054987 27 * @summary Test sharing of annotations between Executable/Field instances. 28 * Sharing should not be noticeable when performing mutating 29 * operations. 30 * @run testng AnnotationSharing 31 */ 32 33import java.lang.annotation.*; 34import java.lang.reflect.*; 35 36import org.testng.annotations.Test; 37 38public class AnnotationSharing { 39 @Test 40 public void testMethodSharing() throws Exception { 41 Method[] m1 = AnnotationSharing.class.getMethods(); 42 Method[] m2 = AnnotationSharing.class.getMethods(); 43 validateSharingSafelyObservable(m1, m2); 44 } 45 46 @Test 47 public void testDeclaredMethodSharing() throws Exception { 48 Method[] m3 = AnnotationSharing.class.getDeclaredMethods(); 49 Method[] m4 = AnnotationSharing.class.getDeclaredMethods(); 50 validateSharingSafelyObservable(m3, m4); 51 } 52 53 @Test 54 public void testFieldSharing() throws Exception { 55 Field[] f1 = AnnotationSharing.class.getFields(); 56 Field[] f2 = AnnotationSharing.class.getFields(); 57 validateSharingSafelyObservable(f1, f2); 58 } 59 60 @Test 61 public void testDeclaredFieldsSharing() throws Exception { 62 Field[] f3 = AnnotationSharing.class.getDeclaredFields(); 63 Field[] f4 = AnnotationSharing.class.getDeclaredFields(); 64 validateSharingSafelyObservable(f3, f4); 65 } 66 67 @Test 68 public void testMethodSharingOccurs() throws Exception { 69 Method mm1 = AnnotationSharing.class.getDeclaredMethod("m", (Class<?>[])null); 70 Method mm2 = AnnotationSharing.class.getDeclaredMethod("m", (Class<?>[])null); 71 validateAnnotationSharing(mm1, mm2); 72 } 73 74 @Test 75 public void testMethodSharingIsSafe() throws Exception { 76 Method mm1 = AnnotationSharing.class.getDeclaredMethod("m", (Class<?>[])null); 77 Method mm2 = AnnotationSharing.class.getDeclaredMethod("m", (Class<?>[])null); 78 validateAnnotationSharingIsSafe(mm1, mm2); 79 validateArrayValues(mm1.getAnnotation(Baz.class), mm2.getAnnotation(Baz.class)); 80 } 81 82 @Test 83 public void testFieldSharingOccurs() throws Exception { 84 Field ff1 = AnnotationSharing.class.getDeclaredField("f"); 85 Field ff2 = AnnotationSharing.class.getDeclaredField("f"); 86 validateAnnotationSharing(ff1, ff2); 87 } 88 89 @Test 90 public void testFieldSharingIsSafe() throws Exception { 91 Field ff1 = AnnotationSharing.class.getDeclaredField("f"); 92 Field ff2 = AnnotationSharing.class.getDeclaredField("f"); 93 validateAnnotationSharingIsSafe(ff1, ff2); 94 validateArrayValues(ff1.getAnnotation(Baz.class), ff2.getAnnotation(Baz.class)); 95 } 96 97 // Validate that AccessibleObject instances are not shared 98 private static void validateSharingSafelyObservable(AccessibleObject[] m1, AccessibleObject[] m2) 99 throws Exception { 100 101 // Validate that setAccessible works 102 for (AccessibleObject m : m1) 103 m.setAccessible(false); 104 105 for (AccessibleObject m : m2) 106 m.setAccessible(true); 107 108 for (AccessibleObject m : m1) 109 if (m.isAccessible()) 110 throw new RuntimeException(m + " should not be accessible"); 111 112 for (AccessibleObject m : m2) 113 if (!m.isAccessible()) 114 throw new RuntimeException(m + " should be accessible"); 115 116 // Validate that methods are still equal() 117 for (int i = 0; i < m1.length; i++) 118 if (!m1[i].equals(m2[i])) 119 throw new RuntimeException(m1[i] + " and " + m2[i] + " should be equal()"); 120 121 // Validate that the arrays aren't shared 122 for (int i = 0; i < m1.length; i++) 123 m1[i] = null; 124 125 for (int i = 0; i < m2.length; i++) 126 if (m2[i] == null) 127 throw new RuntimeException("Detected sharing of AccessibleObject arrays"); 128 } 129 130 // Validate that annotations are shared 131 private static void validateAnnotationSharing(AccessibleObject m1, AccessibleObject m2) { 132 Bar b1 = m1.getAnnotation(Bar.class); 133 Bar b2 = m2.getAnnotation(Bar.class); 134 135 if (b1 != b2) 136 throw new RuntimeException(b1 + " and " + b2 + " should be =="); 137 138 } 139 140 // Validate that Method instances representing the annotation elements 141 // behave as intended 142 private static void validateAnnotationSharingIsSafe(AccessibleObject m1, AccessibleObject m2) 143 throws Exception { 144 Bar b1 = m1.getAnnotation(Bar.class); 145 Bar b2 = m2.getAnnotation(Bar.class); 146 147 Method mm1 = b1.annotationType().getMethod("value", (Class<?>[]) null); 148 Method mm2 = b2.annotationType().getMethod("value", (Class<?>[]) null); 149 inner(mm1, mm2); 150 151 mm1 = b1.getClass().getMethod("value", (Class<?>[]) null); 152 mm2 = b2.getClass().getMethod("value", (Class<?>[]) null); 153 inner(mm1, mm2); 154 155 } 156 private static void inner(Method mm1, Method mm2) 157 throws Exception { 158 if (!mm1.equals(mm2)) 159 throw new RuntimeException(mm1 + " and " + mm2 + " should be equal()"); 160 161 mm1.setAccessible(false); 162 mm2.setAccessible(true); 163 164 if (mm1.isAccessible()) 165 throw new RuntimeException(mm1 + " should not be accessible"); 166 167 if (!mm2.isAccessible()) 168 throw new RuntimeException(mm2 + " should be accessible"); 169 } 170 171 // Validate that array element values are not shared 172 private static void validateArrayValues(Baz a, Baz b) { 173 String[] s1 = a.value(); 174 String[] s2 = b.value(); 175 176 s1[0] = "22"; 177 178 if (!s2[0].equals("1")) 179 throw new RuntimeException("Mutation of array elements should not be detectable"); 180 } 181 182 @Foo @Bar("val") @Baz({"1", "2"}) 183 public void m() { 184 return ; 185 } 186 187 @Foo @Bar("someValue") @Baz({"1", "22", "33"}) 188 public Object f = new Object(); 189} 190 191@Retention(RetentionPolicy.RUNTIME) 192@interface Foo {} 193 194@Retention(RetentionPolicy.RUNTIME) 195@interface Bar { 196 String value(); 197} 198 199@Retention(RetentionPolicy.RUNTIME) 200@interface Baz { 201 String [] value(); 202} 203