1 /*
2 * Copyright (c) 2012, 2013, 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 8015701
27 * @summary Test method parameter attribute generation with captured locals.
28 * @compile -parameters CaptureTest.java
29 * @run main CaptureTest
30 */
31 import java.lang.Class;
32 import java.lang.reflect.Constructor;
33 import java.lang.reflect.Parameter;
34 import java.lang.reflect.Modifier;
35 import java.util.List;
36 import java.util.ArrayList;
37
38 public class CaptureTest {
39
40 private static final int SYNTHETIC = 0x1000;
41 private static final int MANDATED = 0x8000;
42
43 public static void main(String... args) throws Exception {
44 new CaptureTest().run();
45 }
46
47
48 private void run() throws Exception {
49 final Encloser pn = new Encloser();
50
51 /* Cases covered here:
52 *
53 * - Local class
54 * - Inner class
55 * - Anonymous class
56 * - Anonymous class extending a local
57 * - Anonymous class extending an inner
58 */
59 pn.makeLocal("hello").check();
60 pn.makeInner("hello").check();
61 pn.makeAnon("hello").check();
62 pn.makeAnonExtendsLocal("hello").check();
63 pn.makeAnonExtendsInner("hello").check();
64
65 if (0 != errors)
66 throw new Exception("MethodParameters test failed with " +
67 errors + " errors");
68 }
69
70 private void error(final String msg) {
71 System.err.println("Error: " + msg);
72 errors++;
73 }
74
75 int errors;
76
77 abstract class Tester {
78
79 public Tester(final int param) {}
80
81 protected abstract String[] names();
82 protected abstract int[] modifiers();
83 protected abstract Class[] types();
84
85 public void check() {
86 final Class<?> cls = this.getClass();
87 final Constructor<?> ctor = cls.getDeclaredConstructors()[0];
88 final Parameter[] params = ctor.getParameters();
89 final String[] names = names();
90 final int[] modifiers = modifiers();
91 final Class[] types = types();
92
93 System.err.println("Testing class " + cls);
94
95 if (params.length == names.length) {
96 for (int i = 0; i < names.length; i++) {
97 System.err.println("Testing parameter " + params[i].getName());
98 if (!params[i].getName().equals(names[i]))
99 error("Expected parameter name " + names[i] +
100 " got " + params[i].getName());
101 if (params[i].getModifiers() != modifiers[i])
102 error("Expected parameter modifiers " +
103 modifiers[i] + " got " +
104 params[i].getModifiers());
105 if (!params[i].getType().equals(types[i]))
106 error("Expected parameter type " + types[i] +
107 " got " + params[i].getType());
108 }
109 } else
110 error("Expected " + names.length + " parameters");
111
112 }
113
114 }
115
116 class Encloser {
117 private class InnerTester extends Tester {
118 public InnerTester(final int innerparam) {
119 super(innerparam);
120 }
121
122 protected String[] names() {
123 return new String[] {
124 "this$1",
125 "innerparam"
126 };
127 }
128
129 protected int[] modifiers() {
130 return new int[] {
131 Modifier.FINAL | SYNTHETIC,
132 Modifier.FINAL
133 };
134 }
135
136 protected Class[] types() {
137 return new Class[] {
138 Encloser.class,
139 int.class
140 };
141 }
142 }
143
144 public Tester makeInner(final String message) {
145 return new InnerTester(2);
146 }
147
148 public Tester makeLocal(final String message) {
149 class LocalTester extends Tester {
150 public LocalTester(final int localparam) {
151 super(localparam);
152 }
153
154 protected String[] names() {
155 return new String[] {
156 "this$1",
157 "localparam",
158 "val$message"
159 };
160 }
161
162 protected int[] modifiers() {
163 return new int[] {
164 Modifier.FINAL | MANDATED,
165 Modifier.FINAL,
166 Modifier.FINAL | SYNTHETIC
167 };
168 }
169
170 protected Class[] types() {
171 return new Class[] {
172 Encloser.class,
173 int.class,
174 String.class
175 };
176 }
177
178 public String message() {
179 return message;
180 }
181 }
182
183 return new LocalTester(2);
184 }
185
186 public Tester makeAnonExtendsLocal(final String message) {
187 abstract class LocalTester extends Tester {
188 public LocalTester(final int localparam) {
189 super(localparam);
190 }
191
192 protected String[] names() {
193 return new String[] {
194 "this$1",
195 "localparam",
196 "val$message"
197 };
198 }
199
200 protected int[] modifiers() {
201 return new int[] {
202 Modifier.FINAL | MANDATED,
203 Modifier.FINAL,
204 Modifier.FINAL | SYNTHETIC
205 };
206 }
207
208 protected Class[] types() {
209 return new Class[] {
210 Encloser.class,
211 int.class,
212 String.class
213 };
214 }
215
216 }
217
218 return new LocalTester(2) {
219 public String message() {
220 return message;
221 }
222 };
223 }
224
225 public Tester makeAnonExtendsInner(final String message) {
226 return new InnerTester(2) {
227 protected String[] names() {
228 return new String[] {
229 "this$1",
230 "innerparam",
231 "val$message"
232 };
233 }
234
235 protected int[] modifiers() {
236 return new int[] {
237 Modifier.FINAL | MANDATED,
238 Modifier.FINAL,
239 Modifier.FINAL | SYNTHETIC
240 };
241 }
242
243 protected Class[] types() {
244 return new Class[] {
245 Encloser.class,
246 int.class,
247 String.class
248 };
249 }
250
251 public String message() {
252 return message;
253 }
254 };
255 }
256
257 public Tester makeAnon(final String message) {
258 return new Tester(2) {
259 protected String[] names() {
260 return new String[] {
261 "this$1",
262 "param",
263 "val$message"
264 };
265 }
266
267 protected int[] modifiers() {
268 return new int[] {
269 Modifier.FINAL | MANDATED,
270 Modifier.FINAL,
271 Modifier.FINAL | SYNTHETIC
272 };
273 }
274
275 protected Class[] types() {
276 return new Class[] {
277 Encloser.class,
278 int.class,
279 String.class
280 };
281 }
282
283 public String message() {
284 return message;
285 }
286 };
287 }
288 }
289 }