RicochetTest.java revision 4183:4732a76af216
1/* 2 * Copyright (c) 2011, 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. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26/* @test 27 * @summary unit tests for recursive method handles 28 * @run junit/othervm -DRicochetTest.MAX_ARITY=255 test.java.lang.invoke.RicochetTest 29 */ 30 31package test.java.lang.invoke; 32 33import java.lang.invoke.*; 34import java.util.*; 35import org.junit.*; 36import static java.lang.invoke.MethodType.*; 37import static java.lang.invoke.MethodHandles.*; 38import static org.junit.Assert.*; 39import static org.junit.Assume.*; 40 41 42/** 43 * 44 * @author jrose 45 */ 46public class RicochetTest { 47 private static final Class CLASS = RicochetTest.class; 48 private static final int MAX_ARITY = Integer.getInteger(CLASS.getSimpleName()+".MAX_ARITY", 40); 49 50 public static void main(String... av) throws Throwable { 51 RicochetTest test = new RicochetTest(); 52 if (av.length > 0) test.testOnly = Arrays.asList(av).toString(); 53 if (REPEAT == 1 || test.testOnly != null) { 54 test.testAll(); 55 if (test.testOnlyTests == null) throw new RuntimeException("no matching test: "+test.testOnly); 56 } else if (REPEAT == 0) { 57 org.junit.runner.JUnitCore.runClasses(RicochetTest.class); 58 } else { 59 verbose(1, "REPEAT="+REPEAT); 60 for (int i = 0; i < REPEAT; i++) { 61 test.testRepetition = (i+1); 62 verbose(0, "[#"+test.testRepetition+"]"); 63 test.testAll(); 64 } 65 } 66 } 67 int testRepetition; 68 69 public void testAll() throws Throwable { 70 testNull(); 71 testBoxInteger(); 72 testFilterReturnValue(); 73 testFilterObject(); 74 testBoxLong(); 75 testFilterInteger(); 76 testIntSpreads(); 77 testByteSpreads(); 78 testLongSpreads(); 79 testIntCollects(); 80 testReturns(); 81 } 82 83 @Test 84 public void testNull() throws Throwable { 85 if (testRepetition > (1+REPEAT/100)) return; // trivial test 86 if (!startTest("testNull")) return; 87 assertEquals(opI(37), opI.invokeWithArguments(37)); 88 assertEqualFunction(opI, opI); 89 } 90 91 @Test 92 public void testBoxInteger() throws Throwable { 93 if (!startTest("testBoxInteger")) return; 94 assertEqualFunction(opI, opI.asType(opL_I.type()).asType(opI.type())); 95 } 96 97 @Test 98 public void testFilterReturnValue() throws Throwable { 99 if (!startTest("testFilterReturnValue")) return; 100 int[] ints = { 12, 23, 34, 45, 56, 67, 78, 89 }; 101 Object res = list8ints.invokeExact(ints[0], ints[1], ints[2], ints[3], ints[4], ints[5], ints[6], ints[7]); 102 assertEquals(Arrays.toString(ints), res.toString()); 103 MethodHandle idreturn = filterReturnValue(list8ints, identity(Object.class)); 104 res = idreturn.invokeExact(ints[0], ints[1], ints[2], ints[3], ints[4], ints[5], ints[6], ints[7]); 105 assertEquals(Arrays.toString(ints), res.toString()); 106 MethodHandle add0 = addL.bindTo(0); 107 assertEqualFunction(filterReturnValue(opL2, add0), opL2); 108 } 109 110 @Test 111 public void testFilterObject() throws Throwable { 112 if (!startTest("testFilterObject")) return; 113 MethodHandle add0 = addL.bindTo(0); 114 assertEqualFunction(sequence(opL2, add0), opL2); 115 int bump13 = -13; // value near 20 works as long as test values are near [-80..80] 116 MethodHandle add13 = addL.bindTo(bump13); 117 MethodHandle add13_0 = addL.bindTo(opI2(bump13, 0)); 118 MethodHandle add13_1 = addL.bindTo(opI2(0, bump13)); 119 assertEqualFunction(sequence(opL2, add13_0), 120 filterArguments(opL2, 0, add13)); 121 assertEqualFunction(sequence(opL2, add13_1), 122 filterArguments(opL2, 1, add13)); 123 System.out.println("[testFilterObject done]"); 124 } 125 126 @Test 127 public void testBoxLong() throws Throwable { 128 if (!startTest("testBoxLong")) return; 129 assertEqualFunction(opJ, opJ.asType(opL_J.type()).asType(opJ.type())); 130 } 131 132 @Test 133 public void testFilterInteger() throws Throwable { 134 if (!startTest("testFilterInteger")) return; 135 assertEqualFunction(opI, sequence(convI_L, opL_I)); 136 } 137 138 @Test 139 public void testIntSpreads() throws Throwable { 140 if (!startTest("testIntSpreads")) return; 141 MethodHandle id = identity(int[].class); 142 final int MAX = MAX_ARITY-2; // 253+1 would cause parameter overflow with 'this' added 143 for (int nargs = 0; nargs <= MAX; nargs++) { 144 if (nargs > 30 && nargs < MAX-20) nargs += 10; 145 int[] args = new int[nargs]; 146 for (int j = 0; j < args.length; j++) args[j] = (int)(j + 11); 147 //System.out.println("testIntSpreads "+Arrays.toString(args)); 148 int[] args1 = (int[]) id.invokeExact(args); 149 assertArrayEquals(args, args1); 150 MethodHandle coll = id.asCollector(int[].class, nargs); 151 int[] args2 = args; 152 switch (nargs) { 153 case 0: args2 = (int[]) coll.invokeExact(); break; 154 case 1: args2 = (int[]) coll.invokeExact(args[0]); break; 155 case 2: args2 = (int[]) coll.invokeExact(args[0], args[1]); break; 156 case 3: args2 = (int[]) coll.invokeExact(args[0], args[1], args[2]); break; 157 case 4: args2 = (int[]) coll.invokeExact(args[0], args[1], args[2], args[3]); break; 158 case 5: args2 = (int[]) coll.invokeExact(args[0], args[1], args[2], args[3], args[4]); break; 159 } 160 assertArrayEquals(args, args2); 161 MethodHandle mh = coll.asSpreader(int[].class, nargs); 162 int[] args3 = (int[]) mh.invokeExact(args); 163 assertArrayEquals(args, args3); 164 } 165 } 166 167 @Test 168 public void testByteSpreads() throws Throwable { 169 if (!startTest("testByteSpreads")) return; 170 MethodHandle id = identity(byte[].class); 171 final int MAX = MAX_ARITY-2; // 253+1 would cause parameter overflow with 'this' added 172 for (int nargs = 0; nargs <= MAX; nargs++) { 173 if (nargs > 30 && nargs < MAX-20) nargs += 10; 174 byte[] args = new byte[nargs]; 175 for (int j = 0; j < args.length; j++) args[j] = (byte)(j + 11); 176 //System.out.println("testByteSpreads "+Arrays.toString(args)); 177 byte[] args1 = (byte[]) id.invokeExact(args); 178 assertArrayEquals(args, args1); 179 MethodHandle coll = id.asCollector(byte[].class, nargs); 180 byte[] args2 = args; 181 switch (nargs) { 182 case 0: args2 = (byte[]) coll.invokeExact(); break; 183 case 1: args2 = (byte[]) coll.invokeExact(args[0]); break; 184 case 2: args2 = (byte[]) coll.invokeExact(args[0], args[1]); break; 185 case 3: args2 = (byte[]) coll.invokeExact(args[0], args[1], args[2]); break; 186 case 4: args2 = (byte[]) coll.invokeExact(args[0], args[1], args[2], args[3]); break; 187 case 5: args2 = (byte[]) coll.invokeExact(args[0], args[1], args[2], args[3], args[4]); break; 188 } 189 assertArrayEquals(args, args2); 190 MethodHandle mh = coll.asSpreader(byte[].class, nargs); 191 byte[] args3 = (byte[]) mh.invokeExact(args); 192 assertArrayEquals(args, args3); 193 } 194 } 195 196 @Test 197 public void testLongSpreads() throws Throwable { 198 if (!startTest("testLongSpreads")) return; 199 MethodHandle id = identity(long[].class); 200 final int MAX = (MAX_ARITY - 2) / 2; // 253/2+1 would cause parameter overflow with 'this' added 201 for (int nargs = 0; nargs <= MAX; nargs++) { 202 if (nargs > 30 && nargs < MAX-20) nargs += 10; 203 long[] args = new long[nargs]; 204 for (int j = 0; j < args.length; j++) args[j] = (long)(j + 11); 205 //System.out.println("testLongSpreads "+Arrays.toString(args)); 206 long[] args1 = (long[]) id.invokeExact(args); 207 assertArrayEquals(args, args1); 208 MethodHandle coll = id.asCollector(long[].class, nargs); 209 long[] args2 = args; 210 switch (nargs) { 211 case 0: args2 = (long[]) coll.invokeExact(); break; 212 case 1: args2 = (long[]) coll.invokeExact(args[0]); break; 213 case 2: args2 = (long[]) coll.invokeExact(args[0], args[1]); break; 214 case 3: args2 = (long[]) coll.invokeExact(args[0], args[1], args[2]); break; 215 case 4: args2 = (long[]) coll.invokeExact(args[0], args[1], args[2], args[3]); break; 216 case 5: args2 = (long[]) coll.invokeExact(args[0], args[1], args[2], args[3], args[4]); break; 217 } 218 assertArrayEquals(args, args2); 219 MethodHandle mh = coll.asSpreader(long[].class, nargs); 220 long[] args3 = (long[]) mh.invokeExact(args); 221 assertArrayEquals(args, args3); 222 } 223 } 224 225 @Test 226 public void testIntCollects() throws Throwable { 227 if (!startTest("testIntCollects")) return; 228 for (MethodHandle lister : INT_LISTERS) { 229 int outputs = lister.type().parameterCount(); 230 for (int collects = 0; collects <= Math.min(outputs, INT_COLLECTORS.length-1); collects++) { 231 int inputs = outputs - 1 + collects; 232 if (inputs < 0) continue; 233 for (int pos = 0; pos + collects <= inputs; pos++) { 234 MethodHandle collector = INT_COLLECTORS[collects]; 235 int[] args = new int[inputs]; 236 int ap = 0, arg = 31; 237 for (int i = 0; i < pos; i++) 238 args[ap++] = arg++ + 0; 239 for (int i = 0; i < collects; i++) 240 args[ap++] = arg++ + 10; 241 while (ap < args.length) 242 args[ap++] = arg++ + 20; 243 // calculate piecemeal: 244 //System.out.println("testIntCollects "+Arrays.asList(lister, pos, collector)+" on "+Arrays.toString(args)); 245 int[] collargs = Arrays.copyOfRange(args, pos, pos+collects); 246 int coll = (int) collector.asSpreader(int[].class, collargs.length).invokeExact(collargs); 247 int[] listargs = Arrays.copyOfRange(args, 0, outputs); 248 System.arraycopy(args, pos+collects, listargs, pos+1, outputs - (pos+1)); 249 listargs[pos] = coll; 250 //System.out.println(" coll="+coll+" listargs="+Arrays.toString(listargs)); 251 Object expect = lister.asSpreader(int[].class, listargs.length).invokeExact(listargs); 252 //System.out.println(" expect="+expect); 253 254 // now use the combined MH, and test the output: 255 MethodHandle mh = collectArguments(lister, pos, INT_COLLECTORS[collects]); 256 if (mh == null) continue; // no infix collection, yet 257 assert(mh.type().parameterCount() == inputs); 258 Object observe = mh.asSpreader(int[].class, args.length).invokeExact(args); 259 assertEquals(expect, observe); 260 } 261 } 262 } 263 } 264 265 private static MethodHandle collectArguments(MethodHandle lister, int pos, MethodHandle collector) { 266 int collects = collector.type().parameterCount(); 267 int outputs = lister.type().parameterCount(); 268 if (pos == outputs - 1) 269 return MethodHandles.filterArguments(lister, pos, 270 collector.asSpreader(int[].class, collects)) 271 .asCollector(int[].class, collects); 272 //return MethodHandles.collectArguments(lister, pos, collector); //no such animal 273 return null; 274 } 275 276 private static final Class<?>[] RETURN_TYPES = { 277 Object.class, String.class, Integer.class, 278 int.class, long.class, 279 boolean.class, byte.class, char.class, short.class, 280 float.class, double.class, 281 void.class, 282 }; 283 284 @Test 285 public void testReturns() throws Throwable { 286 if (!startTest("testReturns")) return; 287 // fault injection: 288 int faultCount = 0; // total of 1296 tests 289 faultCount = Integer.getInteger("testReturns.faultCount", 0); 290 for (Class<?> ret : RETURN_TYPES) { 291 // make a complicated identity function and pass something through it 292 System.out.println(ret.getSimpleName()); 293 Class<?> vret = (ret == void.class) ? Void.class : ret; 294 MethodHandle id = // (vret)->ret 295 identity(vret).asType(methodType(ret, vret)); 296 final int LENGTH = 4; 297 int[] index = {0}; 298 Object vals = java.lang.reflect.Array.newInstance(vret, LENGTH); 299 MethodHandle indexGetter = //()->int 300 insertArguments(arrayElementGetter(index.getClass()), 0, index, 0); 301 MethodHandle valSelector = // (int)->vret 302 arrayElementGetter(vals.getClass()).bindTo(vals); 303 MethodHandle valGetter = // ()->vret 304 foldArguments(valSelector, indexGetter); 305 if (ret != void.class) { 306 for (int i = 0; i < LENGTH; i++) { 307 Object val = (i + 50); 308 if (ret == boolean.class) val = (i % 3 == 0); 309 if (ret == String.class) val = "#"+i; 310 if (ret == char.class) val = (char)('a'+i); 311 if (ret == byte.class) val = (byte)~i; 312 if (ret == short.class) val = (short)(1<<i); 313 java.lang.reflect.Array.set(vals, i, val); 314 } 315 } 316 for (int i = 0; i < LENGTH; i++) { 317 Object val = java.lang.reflect.Array.get(vals, i); 318 System.out.println(i+" => "+val); 319 index[0] = i; 320 if (--faultCount == 0) index[0] ^= 1; 321 Object x = valGetter.invokeWithArguments(); 322 assertEquals(val, x); 323 // make a return-filter call: x = id(valGetter()) 324 if (--faultCount == 0) index[0] ^= 1; 325 x = filterReturnValue(valGetter, id).invokeWithArguments(); 326 assertEquals(val, x); 327 // make a filter call: x = id(*,valGetter(),*) 328 for (int len = 1; len <= 4; len++) { 329 for (int pos = 0; pos < len; pos++) { 330 MethodHandle proj = id; // lambda(..., vret x,...){x} 331 for (int j = 0; j < len; j++) { 332 if (j == pos) continue; 333 proj = dropArguments(proj, j, Object.class); 334 } 335 assert(proj.type().parameterCount() == len); 336 // proj: (Object*, pos: vret, Object*)->ret 337 assertEquals(vret, proj.type().parameterType(pos)); 338 MethodHandle vgFilter = dropArguments(valGetter, 0, Object.class); 339 if (--faultCount == 0) index[0] ^= 1; 340 x = filterArguments(proj, pos, vgFilter).invokeWithArguments(new Object[len]); 341 assertEquals(val, x); 342 } 343 } 344 // make a fold call: 345 for (int len = 0; len <= 4; len++) { 346 for (int fold = 0; fold <= len; fold++) { 347 MethodHandle proj = id; // lambda(ret x, ...){x} 348 if (ret == void.class) proj = constant(Object.class, null); 349 int arg0 = (ret == void.class ? 0 : 1); 350 for (int j = 0; j < len; j++) { 351 proj = dropArguments(proj, arg0, Object.class); 352 } 353 assert(proj.type().parameterCount() == arg0 + len); 354 // proj: (Object*, pos: vret, Object*)->ret 355 if (arg0 != 0) assertEquals(vret, proj.type().parameterType(0)); 356 MethodHandle vgFilter = valGetter.asType(methodType(ret)); 357 for (int j = 0; j < fold; j++) { 358 vgFilter = dropArguments(vgFilter, j, Object.class); 359 } 360 x = foldArguments(proj, vgFilter).invokeWithArguments(new Object[len]); 361 if (--faultCount == 0) index[0] ^= 1; 362 assertEquals(val, x); 363 } 364 } 365 } 366 } 367 //System.out.println("faultCount="+faultCount); 368 } 369 370 private static MethodHandle sequence(MethodHandle mh1, MethodHandle... mhs) { 371 MethodHandle res = mh1; 372 for (MethodHandle mh2 : mhs) 373 res = filterReturnValue(res, mh2); 374 return res; 375 } 376 private static void assertEqualFunction(MethodHandle x, MethodHandle y) throws Throwable { 377 assertEquals(x.type(), y.type()); //?? 378 MethodType t = x.type(); 379 if (t.parameterCount() == 0) { 380 assertEqualFunctionAt(null, x, y); 381 return; 382 } 383 Class<?> ptype = t.parameterType(0); 384 if (ptype == long.class || ptype == Long.class) { 385 for (long i = -10; i <= 10; i++) { 386 assertEqualFunctionAt(i, x, y); 387 } 388 } else { 389 for (int i = -10; i <= 10; i++) { 390 assertEqualFunctionAt(i, x, y); 391 } 392 } 393 } 394 private static void assertEqualFunctionAt(Object v, MethodHandle x, MethodHandle y) throws Throwable { 395 Object[] args = new Object[x.type().parameterCount()]; 396 Arrays.fill(args, v); 397 Object xval = invokeWithCatch(x, args); 398 Object yval = invokeWithCatch(y, args); 399 String msg = "ok"; 400 if (!Objects.equals(xval, yval)) { 401 msg = ("applying "+x+" & "+y+" to "+v); 402 } 403 assertEquals(msg, xval, yval); 404 } 405 private static Object invokeWithCatch(MethodHandle mh, Object... args) throws Throwable { 406 try { 407 return mh.invokeWithArguments(args); 408 } catch (Throwable ex) { 409 System.out.println("threw: "+mh+Arrays.asList(args)); 410 ex.printStackTrace(); 411 return ex; 412 } 413 } 414 415 private static final Lookup LOOKUP = lookup(); 416 private static MethodHandle findStatic(String name, 417 Class<?> rtype, 418 Class<?>... ptypes) { 419 try { 420 return LOOKUP.findStatic(LOOKUP.lookupClass(), name, methodType(rtype, ptypes)); 421 } catch (ReflectiveOperationException ex) { 422 throw new RuntimeException(ex); 423 } 424 } 425 private static MethodHandle findStatic(String name, 426 Class<?> rtype, 427 List<?> ptypes) { 428 return findStatic(name, rtype, ptypes.toArray(new Class<?>[ptypes.size()])); 429 } 430 static int getProperty(String name, int dflt) { 431 String qual = LOOKUP.lookupClass().getName(); 432 String prop = System.getProperty(qual+"."+name); 433 if (prop == null) prop = System.getProperty(name); 434 if (prop == null) return dflt; 435 return Integer.parseInt(prop); 436 } 437 438 private static int opI(int... xs) { 439 stress(); 440 int base = 100; 441 int z = 0; 442 for (int x : xs) { 443 z = (z * base) + (x % base); 444 } 445 verbose("opI", xs.length, xs, z); 446 return z; 447 } 448 private static int opI2(int x, int y) { return opI(x, y); } // x*100 + y%100 449 private static int opI3(int x, int y, int z) { return opI(x, y, z); } 450 private static int opI4(int w, int x, int y, int z) { return opI(w, x, y, z); } 451 private static int opI(int x) { return opI2(x, 37); } 452 private static Object opI_L(int x) { return (Object) opI(x); } 453 private static long opJ3(long x, long y, long z) { return (long) opI3((int)x, (int)y, (int)z); } 454 private static long opJ2(long x, long y) { return (long) opI2((int)x, (int)y); } 455 private static long opJ(long x) { return (long) opI((int)x); } 456 private static Object opL2(Object x, Object y) { return (Object) opI2((int)x, (int)y); } 457 private static Object opL(Object x) { return (Object) opI((int)x); } 458 private static int opL2_I(Object x, Object y) { return (int) opI2((int)x, (int)y); } 459 private static int opL_I(Object x) { return (int) opI((int)x); } 460 private static long opL_J(Object x) { return (long) opI((int)x); } 461 private static final MethodHandle opI, opI2, opI3, opI4, opI_L, opJ, opJ2, opJ3, opL2, opL, opL2_I, opL_I, opL_J; 462 static { 463 opI4 = findStatic("opI4", int.class, int.class, int.class, int.class, int.class); 464 opI3 = findStatic("opI3", int.class, int.class, int.class, int.class); 465 opI2 = findStatic("opI2", int.class, int.class, int.class); 466 opI = findStatic("opI", int.class, int.class); 467 opI_L = findStatic("opI_L", Object.class, int.class); 468 opJ = findStatic("opJ", long.class, long.class); 469 opJ2 = findStatic("opJ2", long.class, long.class, long.class); 470 opJ3 = findStatic("opJ3", long.class, long.class, long.class, long.class); 471 opL2 = findStatic("opL2", Object.class, Object.class, Object.class); 472 opL = findStatic("opL", Object.class, Object.class); 473 opL2_I = findStatic("opL2_I", int.class, Object.class, Object.class); 474 opL_I = findStatic("opL_I", int.class, Object.class); 475 opL_J = findStatic("opL_J", long.class, Object.class); 476 } 477 private static final MethodHandle[] INT_COLLECTORS = { 478 constant(int.class, 42), opI, opI2, opI3, opI4 479 }; 480 private static final MethodHandle[] LONG_COLLECTORS = { 481 constant(long.class, 42), opJ, opJ2, opJ3 482 }; 483 484 private static int addI(int x, int y) { stress(); return x+y; } 485 private static Object addL(Object x, Object y) { return addI((int)x, (int)y); } 486 private static final MethodHandle addI, addL; 487 static { 488 addI = findStatic("addI", int.class, int.class, int.class); 489 addL = findStatic("addL", Object.class, Object.class, Object.class); 490 } 491 492 private static Object list8ints(int a, int b, int c, int d, int e, int f, int g, int h) { 493 return Arrays.asList(a, b, c, d, e, f, g, h); 494 } 495 private static Object list8longs(long a, long b, long c, long d, long e, long f, long g, long h) { 496 return Arrays.asList(a, b, c, d, e, f, g, h); 497 } 498 private static final MethodHandle list8ints = findStatic("list8ints", Object.class, 499 Collections.nCopies(8, int.class)); 500 private static final MethodHandle list8longs = findStatic("list8longs", Object.class, 501 Collections.nCopies(8, long.class)); 502 private static final MethodHandle[] INT_LISTERS, LONG_LISTERS; 503 static { 504 int listerCount = list8ints.type().parameterCount() + 1; 505 INT_LISTERS = new MethodHandle[listerCount]; 506 LONG_LISTERS = new MethodHandle[listerCount]; 507 MethodHandle lister = list8ints; 508 MethodHandle llister = list8longs; 509 for (int i = listerCount - 1; ; i--) { 510 INT_LISTERS[i] = lister; 511 LONG_LISTERS[i] = llister; 512 if (i == 0) break; 513 lister = insertArguments(lister, i-1, (int)0); 514 llister = insertArguments(llister, i-1, (long)0); 515 } 516 } 517 518 private static Object convI_L(int x) { stress(); return (Object) x; } 519 private static int convL_I(Object x) { stress(); return (int) x; } 520 private static Object convJ_L(long x) { stress(); return (Object) x; } 521 private static long convL_J(Object x) { stress(); return (long) x; } 522 private static int convJ_I(long x) { stress(); return (int) x; } 523 private static long convI_J(int x) { stress(); return (long) x; } 524 private static final MethodHandle convI_L, convL_I, convJ_L, convL_J, convJ_I, convI_J; 525 static { 526 convI_L = findStatic("convI_L", Object.class, int.class); 527 convL_I = findStatic("convL_I", int.class, Object.class); 528 convJ_L = findStatic("convJ_L", Object.class, long.class); 529 convL_J = findStatic("convL_J", long.class, Object.class); 530 convJ_I = findStatic("convJ_I", int.class, long.class); 531 convI_J = findStatic("convI_J", long.class, int.class); 532 } 533 534 // stress modes: 535 private static final int REPEAT = getProperty("REPEAT", 0); 536 private static final int STRESS = getProperty("STRESS", 0); 537 private static /*v*/ int STRESS_COUNT; 538 private static final Object[] SINK = new Object[4]; 539 private static void stress() { 540 if (STRESS <= 0) return; 541 int count = STRESS + (STRESS_COUNT++ & 0x1); // non-constant value 542 for (int i = 0; i < count; i++) { 543 SINK[i % SINK.length] = new Object[STRESS + i % (SINK.length + 1)]; 544 } 545 } 546 547 // verbosity: 548 private static final int VERBOSITY = getProperty("VERBOSITY", 0) + (REPEAT == 0 ? 0 : -1); 549 private static void verbose(Object a, Object b, Object c, Object d) { 550 if (VERBOSITY <= 0) return; 551 verbose(1, a, b, c, d); 552 } 553 private static void verbose(Object a, Object b, Object c) { 554 if (VERBOSITY <= 0) return; 555 verbose(1, a, b, c); 556 } 557 private static void verbose(int level, Object a, Object... bcd) { 558 if (level > VERBOSITY) return; 559 String m = a.toString(); 560 if (bcd != null && bcd.length > 0) { 561 List<Object> l = new ArrayList<>(bcd.length); 562 for (Object x : bcd) { 563 if (x instanceof Object[]) x = Arrays.asList((Object[])x); 564 if (x instanceof int[]) x = Arrays.toString((int[])x); 565 if (x instanceof long[]) x = Arrays.toString((long[])x); 566 l.add(x); 567 } 568 m = m+Arrays.asList(bcd); 569 } 570 System.out.println(m); 571 } 572 String testOnly; 573 String testOnlyTests; 574 private boolean startTest(String name) { 575 if (testOnly != null && !testOnly.contains(name)) 576 return false; 577 verbose(0, "["+name+"]"); 578 testOnlyTests = (testOnlyTests == null) ? name : testOnlyTests+" "+name; 579 return true; 580 } 581 582} 583