1 /*
2 * Copyright (c) 2009, 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 /* @test
25 * @summary example code used in javadoc for java.lang.invoke API
26 * @compile JavaDocExamplesTest.java
27 * @run testng/othervm test.java.lang.invoke.JavaDocExamplesTest
28 */
29
30 package test.java.lang.invoke;
31
32 import java.io.StringWriter;
33 import java.lang.invoke.*;
34 import static java.lang.invoke.MethodHandles.*;
35 import static java.lang.invoke.MethodType.*;
36
37 import java.util.*;
38
39 import org.testng.*;
40 import org.testng.annotations.*;
41
42 /**
43 * @author jrose
44 */
45 public class JavaDocExamplesTest {
46 /** Wrapper for running the TestNG tests in this module.
47 * Put TestNG on the classpath!
48 */
49 public static void main(String... ignore) throws Throwable {
50 new JavaDocExamplesTest().run();
51 }
52
53 public void run() throws Throwable {
54 testMisc();
55 testFindStatic();
56 testFindConstructor();
57 testFindVirtual();
58 testFindSpecial();
59 testPermuteArguments();
60 testDropArguments();
61 testFilterArguments();
62 testFoldArguments();
63 testFoldArguments2();
64 testMethodHandlesSummary();
65 testAsSpreader();
66 testAsCollector();
67 testAsVarargsCollector();
68 testAsFixedArity();
69 testAsTypeCornerCases();
70 testMutableCallSite();
71 }
72 // How much output?
73 static final Class<?> THIS_CLASS = JavaDocExamplesTest.class;
74 static int verbosity = Integer.getInteger(THIS_CLASS.getSimpleName()+".verbosity", 0);
75
76
77 {}
78 private static final Lookup LOOKUP = lookup();
79 // static final private MethodHandle CONCAT_1 = LOOKUP.findVirtual(String.class,
80 // "concat", methodType(String.class, String.class));
81 // static final private MethodHandle HASHCODE_1 = LOOKUP.findVirtual(Object.class,
82 // "hashCode", methodType(int.class));
83
84 // form required if ReflectiveOperationException is intercepted:
85 private static final MethodHandle CONCAT_2, HASHCODE_2, ADD_2, SUB_2;
86 static {
87 try {
88 Class<?> THIS_CLASS = LOOKUP.lookupClass();
89 CONCAT_2 = LOOKUP.findVirtual(String.class,
90 "concat", methodType(String.class, String.class));
91 HASHCODE_2 = LOOKUP.findVirtual(Object.class,
92 "hashCode", methodType(int.class));
93 ADD_2 = LOOKUP.findStatic(THIS_CLASS, "add", methodType(int.class, int.class, int.class));
94 SUB_2 = LOOKUP.findStatic(THIS_CLASS, "sub", methodType(int.class, int.class, int.class));
95 } catch (ReflectiveOperationException ex) {
96 throw new RuntimeException(ex);
97 }
98 }
99 static int add(int x, int y) { return x + y; }
100 static int sub(int x, int y) { return x - y; }
101
102 {}
103
104 @Test public void testMisc() throws Throwable {
105 // Extra tests, not from javadoc:
106 {}
107 MethodHandle CONCAT_3 = LOOKUP.findVirtual(String.class,
108 "concat", methodType(String.class, String.class));
109 MethodHandle HASHCODE_3 = LOOKUP.findVirtual(Object.class,
110 "hashCode", methodType(int.class));
111 //assertEquals("xy", (String) CONCAT_1.invokeExact("x", "y"));
112 assertEquals("xy", (String) CONCAT_2.invokeExact("x", "y"));
113 assertEquals("xy", (String) CONCAT_3.invokeExact("x", "y"));
114 //assertEquals("xy".hashCode(), (int) HASHCODE_1.invokeExact((Object)"xy"));
115 assertEquals("xy".hashCode(), (int) HASHCODE_2.invokeExact((Object)"xy"));
116 assertEquals("xy".hashCode(), (int) HASHCODE_3.invokeExact((Object)"xy"));
117 {}
118 }
119
120 @Test public void testFindStatic() throws Throwable {
121 {}
122 MethodHandle MH_asList = publicLookup().findStatic(Arrays.class,
123 "asList", methodType(List.class, Object[].class));
124 assertEquals("[x, y]", MH_asList.invoke("x", "y").toString());
125 {}
126 }
127
128 @Test public void testFindVirtual() throws Throwable {
129 {}
130 MethodHandle MH_concat = publicLookup().findVirtual(String.class,
131 "concat", methodType(String.class, String.class));
132 MethodHandle MH_hashCode = publicLookup().findVirtual(Object.class,
133 "hashCode", methodType(int.class));
134 MethodHandle MH_hashCode_String = publicLookup().findVirtual(String.class,
135 "hashCode", methodType(int.class));
136 assertEquals("xy", (String) MH_concat.invokeExact("x", "y"));
137 assertEquals("xy".hashCode(), (int) MH_hashCode.invokeExact((Object)"xy"));
138 assertEquals("xy".hashCode(), (int) MH_hashCode_String.invokeExact("xy"));
139 // interface method:
140 MethodHandle MH_subSequence = publicLookup().findVirtual(CharSequence.class,
141 "subSequence", methodType(CharSequence.class, int.class, int.class));
142 assertEquals("def", MH_subSequence.invoke("abcdefghi", 3, 6).toString());
143 // constructor "internal method" must be accessed differently:
144 MethodType MT_newString = methodType(void.class); //()V for new String()
145 try { assertEquals("impossible", lookup()
146 .findVirtual(String.class, "<init>", MT_newString));
147 } catch (NoSuchMethodException ex) { } // OK
148 MethodHandle MH_newString = publicLookup()
149 .findConstructor(String.class, MT_newString);
150 assertEquals("", (String) MH_newString.invokeExact());
151 {}
152 }
153
154 @Test public void testFindConstructor() throws Throwable {
155 {}
156 MethodHandle MH_newArrayList = publicLookup().findConstructor(
157 ArrayList.class, methodType(void.class, Collection.class));
158 Collection orig = Arrays.asList("x", "y");
159 Collection copy = (ArrayList) MH_newArrayList.invokeExact(orig);
160 assert(orig != copy);
161 assertEquals(orig, copy);
162 // a variable-arity constructor:
163 MethodHandle MH_newProcessBuilder = publicLookup().findConstructor(
164 ProcessBuilder.class, methodType(void.class, String[].class));
165 ProcessBuilder pb = (ProcessBuilder)
166 MH_newProcessBuilder.invoke("x", "y", "z");
167 assertEquals("[x, y, z]", pb.command().toString());
168 {}
169 }
170
171 // for testFindSpecial
172 {}
173 static class Listie extends ArrayList {
174 public String toString() { return "[wee Listie]"; }
175 static Lookup lookup() { return MethodHandles.lookup(); }
176 }
177 {}
178
179 @Test public void testFindSpecial() throws Throwable {
180 {}
181 // no access to constructor via invokeSpecial:
182 MethodHandle MH_newListie = Listie.lookup()
183 .findConstructor(Listie.class, methodType(void.class));
184 Listie l = (Listie) MH_newListie.invokeExact();
185 try { assertEquals("impossible", Listie.lookup().findSpecial(
186 Listie.class, "<init>", methodType(void.class), Listie.class));
187 } catch (NoSuchMethodException ex) { } // OK
188 // access to super and self methods via invokeSpecial:
189 MethodHandle MH_super = Listie.lookup().findSpecial(
190 ArrayList.class, "toString" , methodType(String.class), Listie.class);
191 MethodHandle MH_this = Listie.lookup().findSpecial(
192 Listie.class, "toString" , methodType(String.class), Listie.class);
193 MethodHandle MH_duper = Listie.lookup().findSpecial(
194 Object.class, "toString" , methodType(String.class), Listie.class);
195 assertEquals("[]", (String) MH_super.invokeExact(l));
196 assertEquals(""+l, (String) MH_this.invokeExact(l));
197 assertEquals("[]", (String) MH_duper.invokeExact(l)); // ArrayList method
198 try { assertEquals("inaccessible", Listie.lookup().findSpecial(
199 String.class, "toString", methodType(String.class), Listie.class));
200 } catch (IllegalAccessException ex) { } // OK
201 Listie subl = new Listie() { public String toString() { return "[subclass]"; } };
202 assertEquals(""+l, (String) MH_this.invokeExact(subl)); // Listie method
203 {}
204 }
205
206 @Test public void testPermuteArguments() throws Throwable {
207 {{
208 {} /// JAVADOC
209 MethodType intfn1 = methodType(int.class, int.class);
210 MethodType intfn2 = methodType(int.class, int.class, int.class);
211 MethodHandle sub = SUB_2;// ... {int x, int y => x-y} ...;
212 assert(sub.type().equals(intfn2));
213 MethodHandle sub1 = permuteArguments(sub, intfn2, 0, 1);
214 MethodHandle rsub = permuteArguments(sub, intfn2, 1, 0);
215 assert((int)rsub.invokeExact(1, 100) == 99);
216 MethodHandle add = ADD_2;// ... {int x, int y => x+y} ...;
217 assert(add.type().equals(intfn2));
218 MethodHandle twice = permuteArguments(add, intfn1, 0, 0);
219 assert(twice.type().equals(intfn1));
220 assert((int)twice.invokeExact(21) == 42);
221 }}
222 {{
223 {} /// JAVADOC
224 MethodHandle cat = lookup().findVirtual(String.class,
225 "concat", methodType(String.class, String.class));
226 assertEquals("xy", (String) cat.invokeExact("x", "y"));
227 MethodHandle d0 = dropArguments(cat, 0, String.class);
228 assertEquals("yz", (String) d0.invokeExact("x", "y", "z"));
229 MethodHandle d1 = dropArguments(cat, 1, String.class);
230 assertEquals("xz", (String) d1.invokeExact("x", "y", "z"));
231 MethodHandle d2 = dropArguments(cat, 2, String.class);
232 assertEquals("xy", (String) d2.invokeExact("x", "y", "z"));
233 MethodHandle d12 = dropArguments(cat, 1, int.class, boolean.class);
234 assertEquals("xz", (String) d12.invokeExact("x", 12, true, "z"));
235 }}
236 }
237
238 @Test public void testDropArguments() throws Throwable {
239 {{
240 {} /// JAVADOC
241 MethodHandle cat = lookup().findVirtual(String.class,
242 "concat", methodType(String.class, String.class));
243 assertEquals("xy", (String) cat.invokeExact("x", "y"));
244 MethodType bigType = cat.type().insertParameterTypes(0, int.class, String.class);
245 MethodHandle d0 = dropArguments(cat, 0, bigType.parameterList().subList(0,2));
246 assertEquals(bigType, d0.type());
247 assertEquals("yz", (String) d0.invokeExact(123, "x", "y", "z"));
248 }}
249 {{
250 {} /// JAVADOC
251 MethodHandle cat = lookup().findVirtual(String.class,
252 "concat", methodType(String.class, String.class));
253 assertEquals("xy", (String) cat.invokeExact("x", "y"));
254 MethodHandle d0 = dropArguments(cat, 0, String.class);
255 assertEquals("yz", (String) d0.invokeExact("x", "y", "z"));
256 MethodHandle d1 = dropArguments(cat, 1, String.class);
257 assertEquals("xz", (String) d1.invokeExact("x", "y", "z"));
258 MethodHandle d2 = dropArguments(cat, 2, String.class);
259 assertEquals("xy", (String) d2.invokeExact("x", "y", "z"));
260 MethodHandle d12 = dropArguments(cat, 1, int.class, boolean.class);
261 assertEquals("xz", (String) d12.invokeExact("x", 12, true, "z"));
262 }}
263 }
264
265 @Test public void testFilterArguments() throws Throwable {
266 {{
267 {} /// JAVADOC
268 MethodHandle cat = lookup().findVirtual(String.class,
269 "concat", methodType(String.class, String.class));
270 MethodHandle upcase = lookup().findVirtual(String.class,
271 "toUpperCase", methodType(String.class));
272 assertEquals("xy", (String) cat.invokeExact("x", "y"));
273 MethodHandle f0 = filterArguments(cat, 0, upcase);
274 assertEquals("Xy", (String) f0.invokeExact("x", "y")); // Xy
275 MethodHandle f1 = filterArguments(cat, 1, upcase);
276 assertEquals("xY", (String) f1.invokeExact("x", "y")); // xY
277 MethodHandle f2 = filterArguments(cat, 0, upcase, upcase);
278 assertEquals("XY", (String) f2.invokeExact("x", "y")); // XY
279 }}
280 }
281
282 @Test public void testCollectArguments() throws Throwable {
283 {{
284 {} /// JAVADOC
285 MethodHandle deepToString = publicLookup()
286 .findStatic(Arrays.class, "deepToString", methodType(String.class, Object[].class));
287 MethodHandle ts1 = deepToString.asCollector(String[].class, 1);
288 assertEquals("[strange]", (String) ts1.invokeExact("strange"));
289 MethodHandle ts2 = deepToString.asCollector(String[].class, 2);
290 assertEquals("[up, down]", (String) ts2.invokeExact("up", "down"));
291 MethodHandle ts3 = deepToString.asCollector(String[].class, 3);
292 MethodHandle ts3_ts2 = collectArguments(ts3, 1, ts2);
293 assertEquals("[top, [up, down], strange]",
294 (String) ts3_ts2.invokeExact("top", "up", "down", "strange"));
295 MethodHandle ts3_ts2_ts1 = collectArguments(ts3_ts2, 3, ts1);
296 assertEquals("[top, [up, down], [strange]]",
297 (String) ts3_ts2_ts1.invokeExact("top", "up", "down", "strange"));
298 MethodHandle ts3_ts2_ts3 = collectArguments(ts3_ts2, 1, ts3);
299 assertEquals("[top, [[up, down, strange], charm], bottom]",
300 (String) ts3_ts2_ts3.invokeExact("top", "up", "down", "strange", "charm", "bottom"));
301 }}
302 }
303
304 @Test public void testFoldArguments() throws Throwable {
305 {{
306 {} /// JAVADOC
307 MethodHandle trace = publicLookup().findVirtual(java.io.PrintStream.class,
308 "println", methodType(void.class, String.class))
309 .bindTo(System.out);
310 MethodHandle cat = lookup().findVirtual(String.class,
311 "concat", methodType(String.class, String.class));
312 assertEquals("boojum", (String) cat.invokeExact("boo", "jum"));
313 MethodHandle catTrace = foldArguments(cat, trace);
314 // also prints "boo":
315 assertEquals("boojum", (String) catTrace.invokeExact("boo", "jum"));
316 }}
317 }
318
319 static void assertEquals(Object exp, Object act) {
320 if (verbosity > 0)
321 System.out.println("result: "+act);
322 Assert.assertEquals(exp, act);
323 }
324
325 static void assertTrue(boolean b) {
326 if (verbosity > 0) {
327 System.out.println("result: " + b);
328 }
329 Assert.assertTrue(b);
330 }
331
332 @Test public void testMethodHandlesSummary() throws Throwable {
333 {{
334 {} /// JAVADOC
335 Object x, y; String s; int i;
336 MethodType mt; MethodHandle mh;
337 MethodHandles.Lookup lookup = MethodHandles.lookup();
338 // mt is (char,char)String
339 mt = MethodType.methodType(String.class, char.class, char.class);
340 mh = lookup.findVirtual(String.class, "replace", mt);
341 s = (String) mh.invokeExact("daddy",'d','n');
342 // invokeExact(Ljava/lang/String;CC)Ljava/lang/String;
343 assertEquals(s, "nanny");
344 // weakly typed invocation (using MHs.invoke)
345 s = (String) mh.invokeWithArguments("sappy", 'p', 'v');
346 assertEquals(s, "savvy");
347 // mt is (Object[])List
348 mt = MethodType.methodType(java.util.List.class, Object[].class);
349 mh = lookup.findStatic(java.util.Arrays.class, "asList", mt);
350 assert(mh.isVarargsCollector());
351 x = mh.invoke("one", "two");
352 // invoke(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Object;
353 assertEquals(x, java.util.Arrays.asList("one","two"));
354 // mt is (Object,Object,Object)Object
355 mt = MethodType.genericMethodType(3);
356 mh = mh.asType(mt);
357 x = mh.invokeExact((Object)1, (Object)2, (Object)3);
358 // invokeExact(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
359 assertEquals(x, java.util.Arrays.asList(1,2,3));
360 // mt is ()int
361 mt = MethodType.methodType(int.class);
362 mh = lookup.findVirtual(java.util.List.class, "size", mt);
363 i = (int) mh.invokeExact(java.util.Arrays.asList(1,2,3));
364 // invokeExact(Ljava/util/List;)I
365 assert(i == 3);
366 mt = MethodType.methodType(void.class, String.class);
367 mh = lookup.findVirtual(java.io.PrintStream.class, "println", mt);
368 mh.invokeExact(System.out, "Hello, world.");
369 // invokeExact(Ljava/io/PrintStream;Ljava/lang/String;)V
370 {}
371 }}
372 }
373
374 @Test public void testAsSpreader() throws Throwable {
375 {{
376 {} /// JAVADOC
377 MethodHandle equals = publicLookup()
378 .findVirtual(String.class, "equals", methodType(boolean.class, Object.class));
379 assert( (boolean) equals.invokeExact("me", (Object)"me"));
380 assert(!(boolean) equals.invokeExact("me", (Object)"thee"));
381 // spread both arguments from a 2-array:
382 MethodHandle eq2 = equals.asSpreader(Object[].class, 2);
383 assert( (boolean) eq2.invokeExact(new Object[]{ "me", "me" }));
384 assert(!(boolean) eq2.invokeExact(new Object[]{ "me", "thee" }));
385 // try to spread from anything but a 2-array:
386 for (int n = 0; n <= 10; n++) {
387 Object[] badArityArgs = (n == 2 ? null : new Object[n]);
388 try { assert((boolean) eq2.invokeExact(badArityArgs) && false); }
389 catch (IllegalArgumentException ex) { } // OK
390 }
391 // spread both arguments from a String array:
392 MethodHandle eq2s = equals.asSpreader(String[].class, 2);
393 assert( (boolean) eq2s.invokeExact(new String[]{ "me", "me" }));
394 assert(!(boolean) eq2s.invokeExact(new String[]{ "me", "thee" }));
395 // spread second arguments from a 1-array:
396 MethodHandle eq1 = equals.asSpreader(Object[].class, 1);
397 assert( (boolean) eq1.invokeExact("me", new Object[]{ "me" }));
398 assert(!(boolean) eq1.invokeExact("me", new Object[]{ "thee" }));
399 // spread no arguments from a 0-array or null:
400 MethodHandle eq0 = equals.asSpreader(Object[].class, 0);
401 assert( (boolean) eq0.invokeExact("me", (Object)"me", new Object[0]));
402 assert(!(boolean) eq0.invokeExact("me", (Object)"thee", (Object[])null));
403 // asSpreader and asCollector are approximate inverses:
404 for (int n = 0; n <= 2; n++) {
405 for (Class<?> a : new Class<?>[]{Object[].class, String[].class, CharSequence[].class}) {
406 MethodHandle equals2 = equals.asSpreader(a, n).asCollector(a, n);
407 assert( (boolean) equals2.invokeWithArguments("me", "me"));
408 assert(!(boolean) equals2.invokeWithArguments("me", "thee"));
409 }
410 }
411 MethodHandle caToString = publicLookup()
412 .findStatic(Arrays.class, "toString", methodType(String.class, char[].class));
413 assertEquals("[A, B, C]", (String) caToString.invokeExact("ABC".toCharArray()));
414 MethodHandle caString3 = caToString.asCollector(char[].class, 3);
415 assertEquals("[A, B, C]", (String) caString3.invokeExact('A', 'B', 'C'));
416 MethodHandle caToString2 = caString3.asSpreader(char[].class, 2);
417 assertEquals("[A, B, C]", (String) caToString2.invokeExact('A', "BC".toCharArray()));
418 }}
419 }
420
421 @Test public void testAsCollector() throws Throwable {
422 {{
423 {} /// JAVADOC
424 MethodHandle deepToString = publicLookup()
425 .findStatic(Arrays.class, "deepToString", methodType(String.class, Object[].class));
426 assertEquals("[won]", (String) deepToString.invokeExact(new Object[]{"won"}));
427 MethodHandle ts1 = deepToString.asCollector(Object[].class, 1);
428 assertEquals(methodType(String.class, Object.class), ts1.type());
429 //assertEquals("[won]", (String) ts1.invokeExact( new Object[]{"won"})); //FAIL
430 assertEquals("[[won]]", (String) ts1.invokeExact((Object) new Object[]{"won"}));
431 // arrayType can be a subtype of Object[]
432 MethodHandle ts2 = deepToString.asCollector(String[].class, 2);
433 assertEquals(methodType(String.class, String.class, String.class), ts2.type());
434 assertEquals("[two, too]", (String) ts2.invokeExact("two", "too"));
435 MethodHandle ts0 = deepToString.asCollector(Object[].class, 0);
436 assertEquals("[]", (String) ts0.invokeExact());
437 // collectors can be nested, Lisp-style
438 MethodHandle ts22 = deepToString.asCollector(Object[].class, 3).asCollector(String[].class, 2);
439 assertEquals("[A, B, [C, D]]", ((String) ts22.invokeExact((Object)'A', (Object)"B", "C", "D")));
440 // arrayType can be any primitive array type
441 MethodHandle bytesToString = publicLookup()
442 .findStatic(Arrays.class, "toString", methodType(String.class, byte[].class))
443 .asCollector(byte[].class, 3);
444 assertEquals("[1, 2, 3]", (String) bytesToString.invokeExact((byte)1, (byte)2, (byte)3));
445 MethodHandle longsToString = publicLookup()
446 .findStatic(Arrays.class, "toString", methodType(String.class, long[].class))
447 .asCollector(long[].class, 1);
448 assertEquals("[123]", (String) longsToString.invokeExact((long)123));
449 }}
450 }
451
452 @SuppressWarnings("rawtypes")
453 @Test public void testAsVarargsCollector() throws Throwable {
454 {{
455 {} /// JAVADOC
456 MethodHandle deepToString = publicLookup()
457 .findStatic(Arrays.class, "deepToString", methodType(String.class, Object[].class));
458 MethodHandle ts1 = deepToString.asVarargsCollector(Object[].class);
459 assertEquals("[won]", (String) ts1.invokeExact( new Object[]{"won"}));
460 assertEquals("[won]", (String) ts1.invoke( new Object[]{"won"}));
461 assertEquals("[won]", (String) ts1.invoke( "won" ));
462 assertEquals("[[won]]", (String) ts1.invoke((Object) new Object[]{"won"}));
463 // findStatic of Arrays.asList(...) produces a variable arity method handle:
464 MethodHandle asList = publicLookup()
465 .findStatic(Arrays.class, "asList", methodType(List.class, Object[].class));
466 assertEquals(methodType(List.class, Object[].class), asList.type());
467 assert(asList.isVarargsCollector());
468 assertEquals("[]", asList.invoke().toString());
469 assertEquals("[1]", asList.invoke(1).toString());
470 assertEquals("[two, too]", asList.invoke("two", "too").toString());
471 String[] argv = { "three", "thee", "tee" };
472 assertEquals("[three, thee, tee]", asList.invoke(argv).toString());
473 assertEquals("[three, thee, tee]", asList.invoke((Object[])argv).toString());
474 List ls = (List) asList.invoke((Object)argv);
475 assertEquals(1, ls.size());
476 assertEquals("[three, thee, tee]", Arrays.toString((Object[])ls.get(0)));
477 }}
478 }
479
480 @Test public void testAsFixedArity() throws Throwable {
481 {{
482 {} /// JAVADOC
483 MethodHandle asListVar = publicLookup()
484 .findStatic(Arrays.class, "asList", methodType(List.class, Object[].class))
485 .asVarargsCollector(Object[].class);
486 MethodHandle asListFix = asListVar.asFixedArity();
487 assertEquals("[1]", asListVar.invoke(1).toString());
488 Exception caught = null;
489 try { asListFix.invoke((Object)1); }
490 catch (Exception ex) { caught = ex; }
491 assert(caught instanceof ClassCastException);
492 assertEquals("[two, too]", asListVar.invoke("two", "too").toString());
493 try { asListFix.invoke("two", "too"); }
494 catch (Exception ex) { caught = ex; }
495 assert(caught instanceof WrongMethodTypeException);
496 Object[] argv = { "three", "thee", "tee" };
497 assertEquals("[three, thee, tee]", asListVar.invoke(argv).toString());
498 assertEquals("[three, thee, tee]", asListFix.invoke(argv).toString());
499 assertEquals(1, ((List) asListVar.invoke((Object)argv)).size());
500 assertEquals("[three, thee, tee]", asListFix.invoke((Object)argv).toString());
501 }}
502 }
503
504 @Test public void testAsTypeCornerCases() throws Throwable {
505 {{
506 {} /// JAVADOC
507 MethodHandle i2s = publicLookup()
508 .findVirtual(Integer.class, "toString", methodType(String.class));
509 i2s = i2s.asType(i2s.type().unwrap());
510 MethodHandle l2s = publicLookup()
511 .findVirtual(Long.class, "toString", methodType(String.class));
512 l2s = l2s.asType(l2s.type().unwrap());
513
514 Exception caught = null;
515 try { i2s.asType(methodType(String.class, String.class)); }
516 catch (Exception ex) { caught = ex; }
517 assert(caught instanceof WrongMethodTypeException);
518
519 i2s.asType(methodType(String.class, byte.class));
520 i2s.asType(methodType(String.class, Byte.class));
521 i2s.asType(methodType(String.class, Character.class));
522 i2s.asType(methodType(String.class, Integer.class));
523 l2s.asType(methodType(String.class, byte.class));
524 l2s.asType(methodType(String.class, Byte.class));
525 l2s.asType(methodType(String.class, Character.class));
526 l2s.asType(methodType(String.class, Integer.class));
527 l2s.asType(methodType(String.class, Long.class));
528
529 caught = null;
530 try { i2s.asType(methodType(String.class, Long.class)); }
531 catch (Exception ex) { caught = ex; }
532 assert(caught instanceof WrongMethodTypeException);
533
534 MethodHandle i2sGen = i2s.asType(methodType(String.class, Object.class));
535 MethodHandle l2sGen = l2s.asType(methodType(String.class, Object.class));
536
537 i2sGen.invoke(42); // int -> Integer -> Object -> Integer -> int
538 i2sGen.invoke((byte)4); // byte -> Byte -> Object -> Byte -> byte -> int
539 l2sGen.invoke(42); // int -> Integer -> Object -> Integer -> int
540 l2sGen.invoke((byte)4); // byte -> Byte -> Object -> Byte -> byte -> int
541 l2sGen.invoke(0x420000000L);
542
543 caught = null;
544 try { i2sGen.invoke(0x420000000L); } // long -> Long -> Object -> Integer CCE
545 catch (Exception ex) { caught = ex; }
546 assert(caught instanceof ClassCastException);
547
548 caught = null;
549 try { i2sGen.invoke("asdf"); } // String -> Object -> Integer CCE
550 catch (Exception ex) { caught = ex; }
551 assert(caught instanceof ClassCastException);
552 {}
553 }}
554 }
555
556 @Test public void testMutableCallSite() throws Throwable {
557 {{
558 {} /// JAVADOC
559 MutableCallSite name = new MutableCallSite(MethodType.methodType(String.class));
560 MethodHandle MH_name = name.dynamicInvoker();
561 MethodType MT_str1 = MethodType.methodType(String.class);
562 MethodHandle MH_upcase = MethodHandles.lookup()
563 .findVirtual(String.class, "toUpperCase", MT_str1);
564 MethodHandle worker1 = MethodHandles.filterReturnValue(MH_name, MH_upcase);
565 name.setTarget(MethodHandles.constant(String.class, "Rocky"));
566 assertEquals("ROCKY", (String) worker1.invokeExact());
567 name.setTarget(MethodHandles.constant(String.class, "Fred"));
568 assertEquals("FRED", (String) worker1.invokeExact());
569 // (mutation can be continued indefinitely)
570 /*
571 * </pre></blockquote>
572 * <p>
573 * The same call site may be used in several places at once.
574 * <blockquote><pre>
575 */
576 MethodType MT_str2 = MethodType.methodType(String.class, String.class);
577 MethodHandle MH_cat = lookup().findVirtual(String.class,
578 "concat", methodType(String.class, String.class));
579 MethodHandle MH_dear = MethodHandles.insertArguments(MH_cat, 1, ", dear?");
580 MethodHandle worker2 = MethodHandles.filterReturnValue(MH_name, MH_dear);
581 assertEquals("Fred, dear?", (String) worker2.invokeExact());
582 name.setTarget(MethodHandles.constant(String.class, "Wilma"));
583 assertEquals("WILMA", (String) worker1.invokeExact());
584 assertEquals("Wilma, dear?", (String) worker2.invokeExact());
585 {}
586 }}
587 }
588
589 @Test public void testSwitchPoint() throws Throwable {
590 {{
591 {} /// JAVADOC
592 MethodHandle MH_strcat = MethodHandles.lookup()
593 .findVirtual(String.class, "concat", MethodType.methodType(String.class, String.class));
594 SwitchPoint spt = new SwitchPoint();
595 assert(!spt.hasBeenInvalidated());
596 // the following steps may be repeated to re-use the same switch point:
597 MethodHandle worker1 = MH_strcat;
598 MethodHandle worker2 = MethodHandles.permuteArguments(MH_strcat, MH_strcat.type(), 1, 0);
599 MethodHandle worker = spt.guardWithTest(worker1, worker2);
600 assertEquals("method", (String) worker.invokeExact("met", "hod"));
601 SwitchPoint.invalidateAll(new SwitchPoint[]{ spt });
602 assert(spt.hasBeenInvalidated());
603 assertEquals("hodmet", (String) worker.invokeExact("met", "hod"));
604 {}
605 }}
606 }
607
608 @Test public void testFoldArguments2() throws Throwable {
609 {{
610 {} /// JAVADOC
611 // argument-based dispatch for methods of the form boolean x.___(y: String)
612 Lookup lookup = publicLookup();
613 // first, a tracing hack:
614 MethodHandle println = lookup.findVirtual(java.io.PrintStream.class, "println", methodType(void.class, String.class));
615 MethodHandle arrayToString = lookup.findStatic(Arrays.class, "toString", methodType(String.class, Object[].class));
616 MethodHandle concat = lookup.findVirtual(String.class, "concat", methodType(String.class, String.class));
617 MethodHandle arrayToString_DIS = filterReturnValue(arrayToString, concat.bindTo("DIS:"));
618 MethodHandle arrayToString_INV = filterReturnValue(arrayToString, concat.bindTo("INV:"));
619 MethodHandle printArgs_DIS = filterReturnValue(arrayToString_DIS, println.bindTo(System.out)).asVarargsCollector(Object[].class);
620 MethodHandle printArgs_INV = filterReturnValue(arrayToString_INV, println.bindTo(System.out)).asVarargsCollector(Object[].class);
621 // metaobject protocol:
622 MethodType mtype = methodType(boolean.class, String.class);
623 MethodHandle findVirtual = lookup.findVirtual(Lookup.class,
624 "findVirtual", methodType(MethodHandle.class, Class.class, String.class, MethodType.class));
625 MethodHandle getClass = lookup.findVirtual(Object.class,
626 "getClass", methodType(Class.class));
627 MethodHandle dispatch = findVirtual;
628 dispatch = filterArguments(dispatch, 1, getClass);
629 dispatch = insertArguments(dispatch, 3, mtype);
630 dispatch = dispatch.bindTo(lookup);
631 assertEquals(methodType(MethodHandle.class, Object.class, String.class), dispatch.type());
632 MethodHandle invoker = invoker(mtype.insertParameterTypes(0, Object.class));
633 // wrap tracing around the dispatch and invoke steps:
634 dispatch = foldArguments(dispatch, printArgs_DIS.asType(dispatch.type().changeReturnType(void.class)));
635 invoker = foldArguments(invoker, printArgs_INV.asType(invoker.type().changeReturnType(void.class)));
636 invoker = dropArguments(invoker, 2, String.class); // ignore selector
637 // compose the dispatcher and the invoker:
638 MethodHandle invokeDispatched = foldArguments(invoker, dispatch);
639 Object x = "football", y = new java.util.Scanner("bar");
640 assert( (boolean) invokeDispatched.invokeExact(x, "startsWith", "foo"));
641 assert(!(boolean) invokeDispatched.invokeExact(x, "startsWith", "#"));
642 assert( (boolean) invokeDispatched.invokeExact(x, "endsWith", "all"));
643 assert(!(boolean) invokeDispatched.invokeExact(x, "endsWith", "foo"));
644 assert( (boolean) invokeDispatched.invokeExact(y, "hasNext", "[abc]+[rst]"));
645 assert(!(boolean) invokeDispatched.invokeExact(y, "hasNext", "[123]+[789]"));
646 }}
647 }
648
649 static int one(int k) { return 1; }
650 static int inc(int i, int acc, int k) { return i + 1; }
651 static int mult(int i, int acc, int k) { return i * acc; }
652 static boolean pred(int i, int acc, int k) { return i < k; }
653 static int fin(int i, int acc, int k) { return acc; }
654
655 @Test public void testLoop() throws Throwable {
656 MethodHandle MH_inc, MH_one, MH_mult, MH_pred, MH_fin;
657 Class<?> I = int.class;
658 MH_inc = LOOKUP.findStatic(THIS_CLASS, "inc", methodType(I, I, I, I));
659 MH_one = LOOKUP.findStatic(THIS_CLASS, "one", methodType(I, I));
660 MH_mult = LOOKUP.findStatic(THIS_CLASS, "mult", methodType(I, I, I, I));
661 MH_pred = LOOKUP.findStatic(THIS_CLASS, "pred", methodType(boolean.class, I, I, I));
662 MH_fin = LOOKUP.findStatic(THIS_CLASS, "fin", methodType(I, I, I, I));
663 {{
664 {} /// JAVADOC
665 // iterative implementation of the factorial function as a loop handle
666 // null initializer for counter, should initialize to 0
667 MethodHandle[] counterClause = new MethodHandle[]{null, MH_inc};
668 MethodHandle[] accumulatorClause = new MethodHandle[]{MH_one, MH_mult, MH_pred, MH_fin};
669 MethodHandle loop = MethodHandles.loop(counterClause, accumulatorClause);
670 assertEquals(120, loop.invoke(5));
671 {}
672 }}
673 }
674
675 static List<String> initZip(Iterator<String> a, Iterator<String> b) { return new ArrayList<>(); }
676 static boolean zipPred(List<String> zip, Iterator<String> a, Iterator<String> b) { return a.hasNext() && b.hasNext(); }
677 static List<String> zipStep(List<String> zip, Iterator<String> a, Iterator<String> b) {
678 zip.add(a.next());
679 zip.add(b.next());
680 return zip;
681 }
682
683 @Test public void testWhileLoop() throws Throwable {
684 MethodHandle MH_initZip, MH_zipPred, MH_zipStep;
685 Class<?> IT = Iterator.class;
686 Class<?> L = List.class;
687 MH_initZip = LOOKUP.findStatic(THIS_CLASS, "initZip", methodType(L, IT, IT));
688 MH_zipPred = LOOKUP.findStatic(THIS_CLASS, "zipPred", methodType(boolean.class, L, IT, IT));
689 MH_zipStep = LOOKUP.findStatic(THIS_CLASS, "zipStep", methodType(L, L, IT, IT));
690 {{
691 {} /// JAVADOC
692 // implement the zip function for lists as a loop handle
693 MethodHandle loop = MethodHandles.whileLoop(MH_initZip, MH_zipPred, MH_zipStep);
694 List<String> a = Arrays.asList("a", "b", "c", "d");
695 List<String> b = Arrays.asList("e", "f", "g", "h");
696 List<String> zipped = Arrays.asList("a", "e", "b", "f", "c", "g", "d", "h");
697 assertEquals(zipped, (List<String>) loop.invoke(a.iterator(), b.iterator()));
698 {}
699 }}
700 }
701
702 static int zero(int limit) { return 0; }
703 static int step(int i, int limit) { return i + 1; }
704 static boolean pred(int i, int limit) { return i < limit; }
705
706 @Test public void testDoWhileLoop() throws Throwable {
707 MethodHandle MH_zero, MH_step, MH_pred;
708 Class<?> I = int.class;
709 MH_zero = LOOKUP.findStatic(THIS_CLASS, "zero", methodType(I, I));
710 MH_step = LOOKUP.findStatic(THIS_CLASS, "step", methodType(I, I, I));
711 MH_pred = LOOKUP.findStatic(THIS_CLASS, "pred", methodType(boolean.class, I, I));
712 {{
713 {} /// JAVADOC
714 // int i = 0; while (i < limit) { ++i; } return i; => limit
715 MethodHandle loop = MethodHandles.doWhileLoop(MH_zero, MH_step, MH_pred);
716 assertEquals(23, loop.invoke(23));
717 {}
718 }}
719 }
720
721 static String start(String arg) { return arg; }
722 static String step(int counter, String v, String arg) { return "na " + v; }
723
724 @Test public void testCountedLoop() throws Throwable {
725 MethodHandle MH_start, MH_step;
726 Class<?> S = String.class;
727 MH_start = LOOKUP.findStatic(THIS_CLASS, "start", methodType(S, S));
728 MH_step = LOOKUP.findStatic(THIS_CLASS, "step", methodType(S, int.class, S, S));
729 {{
730 {} /// JAVADOC
731 // String s = "Lambdaman!"; for (int i = 0; i < 13; ++i) { s = "na " + s; } return s;
732 // => a variation on a well known theme
733 MethodHandle fit13 = MethodHandles.constant(int.class, 13);
734 MethodHandle loop = MethodHandles.countedLoop(fit13, MH_start, MH_step);
735 assertEquals("na na na na na na na na na na na na na Lambdaman!", loop.invoke("Lambdaman!"));
736 {}
737 }}
738 }
739
740 static List<String> reverseStep(String e, List<String> r, List<String> l) {
741 r.add(0, e);
742 return r;
743 }
744 static List<String> newArrayList(List<String> l) { return new ArrayList<>(); }
745
746 @Test public void testIteratedLoop() throws Throwable {
747 MethodHandle MH_newArrayList, MH_reverseStep;
748 Class<?> L = List.class;
749 MH_newArrayList = LOOKUP.findStatic(THIS_CLASS, "newArrayList", methodType(L, L));
750 MH_reverseStep = LOOKUP.findStatic(THIS_CLASS, "reverseStep", methodType(L, String.class, L, L));
751 {{
752 {} /// JAVADOC
753 // reverse a list
754 MethodHandle loop = MethodHandles.iteratedLoop(null, MH_newArrayList, MH_reverseStep);
755 List<String> list = Arrays.asList("a", "b", "c", "d", "e");
756 List<String> reversedList = Arrays.asList("e", "d", "c", "b", "a");
757 assertEquals(reversedList, (List<String>) loop.invoke(list));
758 {}
759 }}
760 }
761
762 @Test public void testFoldArguments3() throws Throwable {
763 {{
764 {} /// JAVADOC
765 MethodHandle trace = publicLookup().findVirtual(java.io.PrintStream.class,
766 "println", methodType(void.class, String.class))
767 .bindTo(System.out);
768 MethodHandle cat = lookup().findVirtual(String.class,
769 "concat", methodType(String.class, String.class));
770 assertEquals("boojum", (String) cat.invokeExact("boo", "jum"));
771 MethodHandle catTrace = foldArguments(cat, 1, trace);
772 // also prints "jum":
773 assertEquals("boojum", (String) catTrace.invokeExact("boo", "jum"));
774 {}
775 }}
776 }
777
778 @Test public void testAsCollector2() throws Throwable {
779 {{
780 {} /// JAVADOC
781 StringWriter swr = new StringWriter();
782 MethodHandle swWrite = LOOKUP.findVirtual(StringWriter.class, "write", methodType(void.class, char[].class, int.class, int.class)).bindTo(swr);
783 MethodHandle swWrite4 = swWrite.asCollector(0, char[].class, 4);
784 swWrite4.invoke('A', 'B', 'C', 'D', 1, 2);
785 assertEquals("BC", swr.toString());
786 swWrite4.invoke('P', 'Q', 'R', 'S', 0, 4);
787 assertEquals("BCPQRS", swr.toString());
788 swWrite4.invoke('W', 'X', 'Y', 'Z', 3, 1);
789 assertEquals("BCPQRSZ", swr.toString());
790 {}
791 }}
792 }
793
794 @Test public void testAsSpreader2() throws Throwable {
795 {{
796 {} /// JAVADOC
797 MethodHandle compare = LOOKUP.findStatic(Objects.class, "compare", methodType(int.class, Object.class, Object.class, Comparator.class));
798 MethodHandle compare2FromArray = compare.asSpreader(0, Object[].class, 2);
799 Object[] ints = new Object[]{3, 9, 7, 7};
800 Comparator<Integer> cmp = (a, b) -> a - b;
801 assertTrue((int) compare2FromArray.invoke(Arrays.copyOfRange(ints, 0, 2), cmp) < 0);
802 assertTrue((int) compare2FromArray.invoke(Arrays.copyOfRange(ints, 1, 3), cmp) > 0);
803 assertTrue((int) compare2FromArray.invoke(Arrays.copyOfRange(ints, 2, 4), cmp) == 0);
804 {}
805 }}
806 }
807
808 /* ---- TEMPLATE ----
809 @Test public void testFoo() throws Throwable {
810 {{
811 {} /// JAVADOC
812 {}
813 }}
814 }
815 */
816 }