| /* |
| * Copyright (C) 2016 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| import java.lang.invoke.MethodHandle; |
| import java.lang.invoke.MethodHandles; |
| import java.lang.invoke.MethodHandles.Lookup; |
| import java.lang.invoke.MethodType; |
| import java.lang.invoke.WrongMethodTypeException; |
| |
| public class Main { |
| public static void main(String[] args) throws Throwable { |
| testThrowException(); |
| testDropArguments(); |
| testCatchException(); |
| testGuardWithTest(); |
| testArrayElementGetter(); |
| testArrayElementSetter(); |
| testIdentity(); |
| testConstant(); |
| testBindTo(); |
| testFilterReturnValue(); |
| testPermuteArguments(); |
| testInvokers(); |
| testSpreaders_reference(); |
| testSpreaders_primitive(); |
| testInvokeWithArguments(); |
| testAsCollector(); |
| testFilterArguments(); |
| testCollectArguments(); |
| testInsertArguments(); |
| testFoldArguments(); |
| } |
| |
| public static void testThrowException() throws Throwable { |
| MethodHandle handle = MethodHandles.throwException(String.class, |
| IllegalArgumentException.class); |
| |
| if (handle.type().returnType() != String.class) { |
| fail("Unexpected return type for handle: " + handle + |
| " [ " + handle.type() + "]"); |
| } |
| |
| final IllegalArgumentException iae = new IllegalArgumentException("boo!"); |
| try { |
| handle.invoke(iae); |
| fail("Expected an exception of type: java.lang.IllegalArgumentException"); |
| } catch (IllegalArgumentException expected) { |
| if (expected != iae) { |
| fail("Wrong exception: expected " + iae + " but was " + expected); |
| } |
| } |
| } |
| |
| public static void dropArguments_delegate(String message, long message2) { |
| System.out.println("Message: " + message + ", Message2: " + message2); |
| } |
| |
| public static void testDropArguments() throws Throwable { |
| MethodHandle delegate = MethodHandles.lookup().findStatic(Main.class, |
| "dropArguments_delegate", |
| MethodType.methodType(void.class, new Class<?>[] { String.class, long.class })); |
| |
| MethodHandle transform = MethodHandles.dropArguments(delegate, 0, int.class, Object.class); |
| |
| // The transformer will accept two additional arguments at position zero. |
| try { |
| transform.invokeExact("foo", 42l); |
| fail(); |
| } catch (WrongMethodTypeException expected) { |
| } |
| |
| transform.invokeExact(45, new Object(), "foo", 42l); |
| transform.invoke(45, new Object(), "foo", 42l); |
| |
| // Additional arguments at position 1. |
| transform = MethodHandles.dropArguments(delegate, 1, int.class, Object.class); |
| transform.invokeExact("foo", 45, new Object(), 42l); |
| transform.invoke("foo", 45, new Object(), 42l); |
| |
| // Additional arguments at position 2. |
| transform = MethodHandles.dropArguments(delegate, 2, int.class, Object.class); |
| transform.invokeExact("foo", 42l, 45, new Object()); |
| transform.invoke("foo", 42l, 45, new Object()); |
| |
| // Note that we still perform argument conversions even for the arguments that |
| // are subsequently dropped. |
| try { |
| transform.invoke("foo", 42l, 45l, new Object()); |
| fail(); |
| } catch (WrongMethodTypeException expected) { |
| } catch (IllegalArgumentException expected) { |
| // TODO(narayan): We currently throw the wrong type of exception here, |
| // it's IAE and should be WMTE instead. |
| } |
| |
| // Check that asType works as expected. |
| transform = MethodHandles.dropArguments(delegate, 0, int.class, Object.class); |
| transform = transform.asType(MethodType.methodType(void.class, |
| new Class<?>[] { short.class, Object.class, String.class, long.class })); |
| transform.invokeExact((short) 45, new Object(), "foo", 42l); |
| |
| // Invalid argument location, should not be allowed. |
| try { |
| MethodHandles.dropArguments(delegate, -1, int.class, Object.class); |
| fail(); |
| } catch (IllegalArgumentException expected) { |
| } |
| |
| // Invalid argument location, should not be allowed. |
| try { |
| MethodHandles.dropArguments(delegate, 3, int.class, Object.class); |
| fail(); |
| } catch (IllegalArgumentException expected) { |
| } |
| |
| try { |
| MethodHandles.dropArguments(delegate, 1, void.class); |
| fail(); |
| } catch (IllegalArgumentException expected) { |
| } |
| } |
| |
| public static String testCatchException_target(String arg1, long arg2, String exceptionMessage) |
| throws Throwable { |
| if (exceptionMessage != null) { |
| throw new IllegalArgumentException(exceptionMessage); |
| } |
| |
| System.out.println("Target: Arg1: " + arg1 + ", Arg2: " + arg2); |
| return "target"; |
| } |
| |
| public static String testCatchException_handler(IllegalArgumentException iae, String arg1, long arg2, |
| String exMsg) { |
| System.out.println("Handler: " + iae + ", Arg1: " + arg1 + ", Arg2: " + arg2 + ", ExMsg: " + exMsg); |
| return "handler1"; |
| } |
| |
| public static String testCatchException_handler2(IllegalArgumentException iae, String arg1) { |
| System.out.println("Handler: " + iae + ", Arg1: " + arg1); |
| return "handler2"; |
| } |
| |
| public static void testCatchException() throws Throwable { |
| MethodHandle target = MethodHandles.lookup().findStatic(Main.class, |
| "testCatchException_target", |
| MethodType.methodType(String.class, new Class<?>[] { String.class, long.class, String.class })); |
| |
| MethodHandle handler = MethodHandles.lookup().findStatic(Main.class, |
| "testCatchException_handler", |
| MethodType.methodType(String.class, new Class<?>[] { IllegalArgumentException.class, |
| String.class, long.class, String.class })); |
| |
| MethodHandle adapter = MethodHandles.catchException(target, IllegalArgumentException.class, |
| handler); |
| |
| String returnVal = null; |
| |
| // These two should end up calling the target always. We're passing a null exception |
| // message here, which means the target will not throw. |
| returnVal = (String) adapter.invoke("foo", 42, null); |
| assertEquals("target", returnVal); |
| returnVal = (String) adapter.invokeExact("foo", 42l, (String) null); |
| assertEquals("target", returnVal); |
| |
| // We're passing a non-null exception message here, which means the target will throw, |
| // which in turn means that the handler must be called for the next two invokes. |
| returnVal = (String) adapter.invoke("foo", 42, "exceptionMessage"); |
| assertEquals("handler1", returnVal); |
| returnVal = (String) adapter.invokeExact("foo", 42l, "exceptionMessage"); |
| assertEquals("handler1", returnVal); |
| |
| handler = MethodHandles.lookup().findStatic(Main.class, |
| "testCatchException_handler2", |
| MethodType.methodType(String.class, new Class<?>[] { IllegalArgumentException.class, |
| String.class })); |
| adapter = MethodHandles.catchException(target, IllegalArgumentException.class, handler); |
| |
| returnVal = (String) adapter.invoke("foo", 42, "exceptionMessage"); |
| assertEquals("handler2", returnVal); |
| returnVal = (String) adapter.invokeExact("foo", 42l, "exceptionMessage"); |
| assertEquals("handler2", returnVal); |
| |
| // Test that the type of the invoke doesn't matter. Here we call |
| // IllegalArgumentException.toString() on the exception that was thrown by |
| // the target. |
| handler = MethodHandles.lookup().findVirtual(IllegalArgumentException.class, |
| "toString", MethodType.methodType(String.class)); |
| adapter = MethodHandles.catchException(target, IllegalArgumentException.class, handler); |
| |
| returnVal = (String) adapter.invoke("foo", 42, "exceptionMessage"); |
| assertEquals("java.lang.IllegalArgumentException: exceptionMessage", returnVal); |
| returnVal = (String) adapter.invokeExact("foo", 42l, "exceptionMessage2"); |
| assertEquals("java.lang.IllegalArgumentException: exceptionMessage2", returnVal); |
| |
| // Check that asType works as expected. |
| adapter = MethodHandles.catchException(target, IllegalArgumentException.class, |
| handler); |
| adapter = adapter.asType(MethodType.methodType(String.class, |
| new Class<?>[] { String.class, int.class, String.class })); |
| returnVal = (String) adapter.invokeExact("foo", 42, "exceptionMessage"); |
| assertEquals("java.lang.IllegalArgumentException: exceptionMessage", returnVal); |
| } |
| |
| public static boolean testGuardWithTest_test(String arg1, long arg2) { |
| return "target".equals(arg1) && 42 == arg2; |
| } |
| |
| public static String testGuardWithTest_target(String arg1, long arg2, int arg3) { |
| System.out.println("target: " + arg1 + ", " + arg2 + ", " + arg3); |
| return "target"; |
| } |
| |
| public static String testGuardWithTest_fallback(String arg1, long arg2, int arg3) { |
| System.out.println("fallback: " + arg1 + ", " + arg2 + ", " + arg3); |
| return "fallback"; |
| } |
| |
| public static void testGuardWithTest() throws Throwable { |
| MethodHandle test = MethodHandles.lookup().findStatic(Main.class, |
| "testGuardWithTest_test", |
| MethodType.methodType(boolean.class, new Class<?>[] { String.class, long.class })); |
| |
| final MethodType type = MethodType.methodType(String.class, |
| new Class<?>[] { String.class, long.class, int.class }); |
| |
| final MethodHandle target = MethodHandles.lookup().findStatic(Main.class, |
| "testGuardWithTest_target", type); |
| final MethodHandle fallback = MethodHandles.lookup().findStatic(Main.class, |
| "testGuardWithTest_fallback", type); |
| |
| MethodHandle adapter = MethodHandles.guardWithTest(test, target, fallback); |
| |
| String returnVal = null; |
| |
| returnVal = (String) adapter.invoke("target", 42, 56); |
| assertEquals("target", returnVal); |
| returnVal = (String) adapter.invokeExact("target", 42l, 56); |
| assertEquals("target", returnVal); |
| |
| returnVal = (String) adapter.invoke("fallback", 42l, 56); |
| assertEquals("fallback", returnVal); |
| returnVal = (String) adapter.invokeExact("target", 42l, 56); |
| assertEquals("target", returnVal); |
| |
| // Check that asType works as expected. |
| adapter = adapter.asType(MethodType.methodType(String.class, |
| new Class<?>[] { String.class, int.class, int.class })); |
| returnVal = (String) adapter.invokeExact("target", 42, 56); |
| assertEquals("target", returnVal); |
| } |
| |
| public static void testArrayElementGetter() throws Throwable { |
| MethodHandle getter = MethodHandles.arrayElementGetter(int[].class); |
| |
| { |
| int[] array = new int[1]; |
| array[0] = 42; |
| int value = (int) getter.invoke(array, 0); |
| if (value != 42) { |
| fail("Unexpected value: " + value); |
| } |
| |
| try { |
| value = (int) getter.invoke(array, -1); |
| fail(); |
| } catch (ArrayIndexOutOfBoundsException expected) { |
| } |
| |
| try { |
| value = (int) getter.invoke(null, -1); |
| fail(); |
| } catch (NullPointerException expected) { |
| } |
| } |
| |
| { |
| getter = MethodHandles.arrayElementGetter(long[].class); |
| long[] array = new long[1]; |
| array[0] = 42; |
| long value = (long) getter.invoke(array, 0); |
| if (value != 42l) { |
| fail("Unexpected value: " + value); |
| } |
| } |
| |
| { |
| getter = MethodHandles.arrayElementGetter(short[].class); |
| short[] array = new short[1]; |
| array[0] = 42; |
| short value = (short) getter.invoke(array, 0); |
| if (value != 42l) { |
| fail("Unexpected value: " + value); |
| } |
| } |
| |
| { |
| getter = MethodHandles.arrayElementGetter(char[].class); |
| char[] array = new char[1]; |
| array[0] = 42; |
| char value = (char) getter.invoke(array, 0); |
| if (value != 42l) { |
| fail("Unexpected value: " + value); |
| } |
| } |
| |
| { |
| getter = MethodHandles.arrayElementGetter(byte[].class); |
| byte[] array = new byte[1]; |
| array[0] = (byte) 0x8; |
| byte value = (byte) getter.invoke(array, 0); |
| if (value != (byte) 0x8) { |
| fail("Unexpected value: " + value); |
| } |
| } |
| |
| { |
| getter = MethodHandles.arrayElementGetter(boolean[].class); |
| boolean[] array = new boolean[1]; |
| array[0] = true; |
| boolean value = (boolean) getter.invoke(array, 0); |
| if (!value) { |
| fail("Unexpected value: " + value); |
| } |
| } |
| |
| { |
| getter = MethodHandles.arrayElementGetter(float[].class); |
| float[] array = new float[1]; |
| array[0] = 42.0f; |
| float value = (float) getter.invoke(array, 0); |
| if (value != 42.0f) { |
| fail("Unexpected value: " + value); |
| } |
| } |
| |
| { |
| getter = MethodHandles.arrayElementGetter(double[].class); |
| double[] array = new double[1]; |
| array[0] = 42.0; |
| double value = (double) getter.invoke(array, 0); |
| if (value != 42.0) { |
| fail("Unexpected value: " + value); |
| } |
| } |
| |
| { |
| getter = MethodHandles.arrayElementGetter(String[].class); |
| String[] array = new String[3]; |
| array[0] = "42"; |
| array[1] = "48"; |
| array[2] = "54"; |
| String value = (String) getter.invoke(array, 0); |
| assertEquals("42", value); |
| value = (String) getter.invoke(array, 1); |
| assertEquals("48", value); |
| value = (String) getter.invoke(array, 2); |
| assertEquals("54", value); |
| } |
| } |
| |
| public static void testArrayElementSetter() throws Throwable { |
| MethodHandle setter = MethodHandles.arrayElementSetter(int[].class); |
| |
| { |
| int[] array = new int[2]; |
| setter.invoke(array, 0, 42); |
| setter.invoke(array, 1, 43); |
| |
| if (array[0] != 42) { |
| fail("Unexpected value: " + array[0]); |
| } |
| if (array[1] != 43) { |
| fail("Unexpected value: " + array[1]); |
| } |
| |
| try { |
| setter.invoke(array, -1, 42); |
| fail(); |
| } catch (ArrayIndexOutOfBoundsException expected) { |
| } |
| |
| try { |
| setter.invoke(null, 0, 42); |
| fail(); |
| } catch (NullPointerException expected) { |
| } |
| } |
| |
| { |
| setter = MethodHandles.arrayElementSetter(long[].class); |
| long[] array = new long[1]; |
| setter.invoke(array, 0, 42l); |
| if (array[0] != 42l) { |
| fail("Unexpected value: " + array[0]); |
| } |
| } |
| |
| { |
| setter = MethodHandles.arrayElementSetter(short[].class); |
| short[] array = new short[1]; |
| setter.invoke(array, 0, (short) 42); |
| if (array[0] != 42l) { |
| fail("Unexpected value: " + array[0]); |
| } |
| } |
| |
| { |
| setter = MethodHandles.arrayElementSetter(char[].class); |
| char[] array = new char[1]; |
| setter.invoke(array, 0, (char) 42); |
| if (array[0] != 42) { |
| fail("Unexpected value: " + array[0]); |
| } |
| } |
| |
| { |
| setter = MethodHandles.arrayElementSetter(byte[].class); |
| byte[] array = new byte[1]; |
| setter.invoke(array, 0, (byte) 0x8); |
| if (array[0] != (byte) 0x8) { |
| fail("Unexpected value: " + array[0]); |
| } |
| } |
| |
| { |
| setter = MethodHandles.arrayElementSetter(boolean[].class); |
| boolean[] array = new boolean[1]; |
| setter.invoke(array, 0, true); |
| if (!array[0]) { |
| fail("Unexpected value: " + array[0]); |
| } |
| } |
| |
| { |
| setter = MethodHandles.arrayElementSetter(float[].class); |
| float[] array = new float[1]; |
| setter.invoke(array, 0, 42.0f); |
| if (array[0] != 42.0f) { |
| fail("Unexpected value: " + array[0]); |
| } |
| } |
| |
| { |
| setter = MethodHandles.arrayElementSetter(double[].class); |
| double[] array = new double[1]; |
| setter.invoke(array, 0, 42.0); |
| if (array[0] != 42.0) { |
| fail("Unexpected value: " + array[0]); |
| } |
| } |
| |
| { |
| setter = MethodHandles.arrayElementSetter(String[].class); |
| String[] array = new String[3]; |
| setter.invoke(array, 0, "42"); |
| setter.invoke(array, 1, "48"); |
| setter.invoke(array, 2, "54"); |
| assertEquals("42", array[0]); |
| assertEquals("48", array[1]); |
| assertEquals("54", array[2]); |
| } |
| } |
| |
| public static void testIdentity() throws Throwable { |
| { |
| MethodHandle identity = MethodHandles.identity(boolean.class); |
| boolean value = (boolean) identity.invoke(false); |
| if (value) { |
| fail("Unexpected value: " + value); |
| } |
| } |
| |
| { |
| MethodHandle identity = MethodHandles.identity(byte.class); |
| byte value = (byte) identity.invoke((byte) 0x8); |
| if (value != (byte) 0x8) { |
| fail("Unexpected value: " + value); |
| } |
| } |
| |
| { |
| MethodHandle identity = MethodHandles.identity(char.class); |
| char value = (char) identity.invoke((char) -56); |
| if (value != (char) -56) { |
| fail("Unexpected value: " + value); |
| } |
| } |
| |
| { |
| MethodHandle identity = MethodHandles.identity(short.class); |
| short value = (short) identity.invoke((short) -59); |
| if (value != (short) -59) { |
| fail("Unexpected value: " + Short.toString(value)); |
| } |
| } |
| |
| { |
| MethodHandle identity = MethodHandles.identity(int.class); |
| int value = (int) identity.invoke(52); |
| if (value != 52) { |
| fail("Unexpected value: " + value); |
| } |
| } |
| |
| { |
| MethodHandle identity = MethodHandles.identity(long.class); |
| long value = (long) identity.invoke(-76l); |
| if (value != (long) -76) { |
| fail("Unexpected value: " + value); |
| } |
| } |
| |
| { |
| MethodHandle identity = MethodHandles.identity(float.class); |
| float value = (float) identity.invoke(56.0f); |
| if (value != (float) 56.0f) { |
| fail("Unexpected value: " + value); |
| } |
| } |
| |
| { |
| MethodHandle identity = MethodHandles.identity(double.class); |
| double value = (double) identity.invoke((double) 72.0); |
| if (value != (double) 72.0) { |
| fail("Unexpected value: " + value); |
| } |
| } |
| |
| { |
| MethodHandle identity = MethodHandles.identity(String.class); |
| String value = (String) identity.invoke("bazman"); |
| assertEquals("bazman", value); |
| } |
| } |
| |
| public static void testConstant() throws Throwable { |
| // int constants. |
| { |
| MethodHandle constant = MethodHandles.constant(int.class, 56); |
| int value = (int) constant.invoke(); |
| if (value != 56) { |
| fail("Unexpected value: " + value); |
| } |
| |
| // short constant values are converted to int. |
| constant = MethodHandles.constant(int.class, (short) 52); |
| value = (int) constant.invoke(); |
| if (value != 52) { |
| fail("Unexpected value: " + value); |
| } |
| |
| // char constant values are converted to int. |
| constant = MethodHandles.constant(int.class, (char) 'b'); |
| value = (int) constant.invoke(); |
| if (value != (int) 'b') { |
| fail("Unexpected value: " + value); |
| } |
| |
| // int constant values are converted to int. |
| constant = MethodHandles.constant(int.class, (byte) 0x1); |
| value = (int) constant.invoke(); |
| if (value != 1) { |
| fail("Unexpected value: " + value); |
| } |
| |
| // boolean, float, double and long primitive constants are not convertible |
| // to int, so the handle creation must fail with a CCE. |
| try { |
| MethodHandles.constant(int.class, false); |
| fail(); |
| } catch (ClassCastException expected) { |
| } |
| |
| try { |
| MethodHandles.constant(int.class, 0.1f); |
| fail(); |
| } catch (ClassCastException expected) { |
| } |
| |
| try { |
| MethodHandles.constant(int.class, 0.2); |
| fail(); |
| } catch (ClassCastException expected) { |
| } |
| |
| try { |
| MethodHandles.constant(int.class, 73l); |
| fail(); |
| } catch (ClassCastException expected) { |
| } |
| } |
| |
| // long constants. |
| { |
| MethodHandle constant = MethodHandles.constant(long.class, 56l); |
| long value = (long) constant.invoke(); |
| if (value != 56l) { |
| fail("Unexpected value: " + value); |
| } |
| |
| constant = MethodHandles.constant(long.class, (int) 56); |
| value = (long) constant.invoke(); |
| if (value != 56l) { |
| fail("Unexpected value: " + value); |
| } |
| } |
| |
| // byte constants. |
| { |
| MethodHandle constant = MethodHandles.constant(byte.class, (byte) 0x12); |
| byte value = (byte) constant.invoke(); |
| if (value != (byte) 0x12) { |
| fail("Unexpected value: " + value); |
| } |
| } |
| |
| // boolean constants. |
| { |
| MethodHandle constant = MethodHandles.constant(boolean.class, true); |
| boolean value = (boolean) constant.invoke(); |
| if (!value) { |
| fail("Unexpected value: " + value); |
| } |
| } |
| |
| // char constants. |
| { |
| MethodHandle constant = MethodHandles.constant(char.class, 'f'); |
| char value = (char) constant.invoke(); |
| if (value != 'f') { |
| fail("Unexpected value: " + value); |
| } |
| } |
| |
| // short constants. |
| { |
| MethodHandle constant = MethodHandles.constant(short.class, (short) 123); |
| short value = (short) constant.invoke(); |
| if (value != (short) 123) { |
| fail("Unexpected value: " + value); |
| } |
| } |
| |
| // float constants. |
| { |
| MethodHandle constant = MethodHandles.constant(float.class, 56.0f); |
| float value = (float) constant.invoke(); |
| if (value != 56.0f) { |
| fail("Unexpected value: " + value); |
| } |
| } |
| |
| // double constants. |
| { |
| MethodHandle constant = MethodHandles.constant(double.class, 256.0); |
| double value = (double) constant.invoke(); |
| if (value != 256.0) { |
| fail("Unexpected value: " + value); |
| } |
| } |
| |
| // reference constants. |
| { |
| MethodHandle constant = MethodHandles.constant(String.class, "256.0"); |
| String value = (String) constant.invoke(); |
| assertEquals("256.0", value); |
| } |
| } |
| |
| public static void testBindTo() throws Throwable { |
| MethodHandle stringCharAt = MethodHandles.lookup().findVirtual( |
| String.class, "charAt", MethodType.methodType(char.class, int.class)); |
| |
| char value = (char) stringCharAt.invoke("foo", 0); |
| if (value != 'f') { |
| fail("Unexpected value: " + value); |
| } |
| |
| MethodHandle bound = stringCharAt.bindTo("foo"); |
| value = (char) bound.invoke(0); |
| if (value != 'f') { |
| fail("Unexpected value: " + value); |
| } |
| |
| try { |
| stringCharAt.bindTo(new Object()); |
| fail(); |
| } catch (ClassCastException expected) { |
| } |
| |
| bound = stringCharAt.bindTo(null); |
| try { |
| bound.invoke(0); |
| fail(); |
| } catch (NullPointerException expected) { |
| } |
| |
| MethodHandle integerParseInt = MethodHandles.lookup().findStatic( |
| Integer.class, "parseInt", MethodType.methodType(int.class, String.class)); |
| |
| bound = integerParseInt.bindTo("78452"); |
| int intValue = (int) bound.invoke(); |
| if (intValue != 78452) { |
| fail("Unexpected value: " + intValue); |
| } |
| } |
| |
| public static String filterReturnValue_target(int a) { |
| return "ReturnValue" + a; |
| } |
| |
| public static boolean filterReturnValue_filter(String value) { |
| return value.indexOf("42") != -1; |
| } |
| |
| public static int filterReturnValue_intTarget(String a) { |
| return Integer.parseInt(a); |
| } |
| |
| public static int filterReturnValue_intFilter(int b) { |
| return b + 1; |
| } |
| |
| public static void filterReturnValue_voidTarget() { |
| } |
| |
| public static int filterReturnValue_voidFilter() { |
| return 42; |
| } |
| |
| public static void testFilterReturnValue() throws Throwable { |
| // A target that returns a reference. |
| { |
| final MethodHandle target = MethodHandles.lookup().findStatic(Main.class, |
| "filterReturnValue_target", MethodType.methodType(String.class, int.class)); |
| final MethodHandle filter = MethodHandles.lookup().findStatic(Main.class, |
| "filterReturnValue_filter", MethodType.methodType(boolean.class, String.class)); |
| |
| MethodHandle adapter = MethodHandles.filterReturnValue(target, filter); |
| |
| boolean value = (boolean) adapter.invoke((int) 42); |
| if (!value) { |
| fail("Unexpected value: " + value); |
| } |
| value = (boolean) adapter.invoke((int) 43); |
| if (value) { |
| fail("Unexpected value: " + value); |
| } |
| } |
| |
| // A target that returns a primitive. |
| { |
| final MethodHandle target = MethodHandles.lookup().findStatic(Main.class, |
| "filterReturnValue_intTarget", MethodType.methodType(int.class, String.class)); |
| final MethodHandle filter = MethodHandles.lookup().findStatic(Main.class, |
| "filterReturnValue_intFilter", MethodType.methodType(int.class, int.class)); |
| |
| MethodHandle adapter = MethodHandles.filterReturnValue(target, filter); |
| |
| int value = (int) adapter.invoke("56"); |
| if (value != 57) { |
| fail("Unexpected value: " + value); |
| } |
| } |
| |
| // A target that returns void. |
| { |
| final MethodHandle target = MethodHandles.lookup().findStatic(Main.class, |
| "filterReturnValue_voidTarget", MethodType.methodType(void.class)); |
| final MethodHandle filter = MethodHandles.lookup().findStatic(Main.class, |
| "filterReturnValue_voidFilter", MethodType.methodType(int.class)); |
| |
| MethodHandle adapter = MethodHandles.filterReturnValue(target, filter); |
| |
| int value = (int) adapter.invoke(); |
| if (value != 42) { |
| fail("Unexpected value: " + value); |
| } |
| } |
| } |
| |
| public static void permuteArguments_callee(boolean a, byte b, char c, |
| short d, int e, long f, float g, double h) { |
| if (a == true && b == (byte) 'b' && c == 'c' && d == (short) 56 && |
| e == 78 && f == (long) 97 && g == 98.0f && f == 97.0) { |
| return; |
| } |
| |
| fail("Unexpected arguments: " + a + ", " + b + ", " + c |
| + ", " + d + ", " + e + ", " + f + ", " + g + ", " + h); |
| } |
| |
| public static void permuteArguments_boxingCallee(boolean a, Integer b) { |
| if (a && b.intValue() == 42) { |
| return; |
| } |
| |
| fail("Unexpected arguments: " + a + ", " + b); |
| } |
| |
| public static void testPermuteArguments() throws Throwable { |
| { |
| final MethodHandle target = MethodHandles.lookup().findStatic( |
| Main.class, "permuteArguments_callee", |
| MethodType.methodType(void.class, new Class<?>[] { |
| boolean.class, byte.class, char.class, short.class, int.class, |
| long.class, float.class, double.class })); |
| |
| final MethodType newType = MethodType.methodType(void.class, new Class<?>[] { |
| double.class, float.class, long.class, int.class, short.class, char.class, |
| byte.class, boolean.class }); |
| |
| final MethodHandle permutation = MethodHandles.permuteArguments( |
| target, newType, new int[] { 7, 6, 5, 4, 3, 2, 1, 0 }); |
| |
| permutation.invoke((double) 97.0, (float) 98.0f, (long) 97, 78, |
| (short) 56, 'c', (byte) 'b', (boolean) true); |
| |
| // The permutation array was not of the right length. |
| try { |
| MethodHandles.permuteArguments(target, newType, |
| new int[] { 7 }); |
| fail(); |
| } catch (IllegalArgumentException expected) { |
| } |
| |
| // The permutation array has an element that's out of bounds |
| // (there's no argument with idx == 8). |
| try { |
| MethodHandles.permuteArguments(target, newType, |
| new int[] { 8, 6, 5, 4, 3, 2, 1, 0 }); |
| fail(); |
| } catch (IllegalArgumentException expected) { |
| } |
| |
| // The permutation array maps to an incorrect type. |
| try { |
| MethodHandles.permuteArguments(target, newType, |
| new int[] { 7, 7, 5, 4, 3, 2, 1, 0 }); |
| fail(); |
| } catch (IllegalArgumentException expected) { |
| } |
| } |
| |
| // Tests for reference arguments as well as permutations that |
| // repeat arguments. |
| { |
| final MethodHandle target = MethodHandles.lookup().findVirtual( |
| String.class, "concat", MethodType.methodType(String.class, String.class)); |
| |
| final MethodType newType = MethodType.methodType(String.class, String.class, |
| String.class); |
| |
| assertEquals("foobar", (String) target.invoke("foo", "bar")); |
| |
| MethodHandle permutation = MethodHandles.permuteArguments(target, |
| newType, new int[] { 1, 0 }); |
| assertEquals("barfoo", (String) permutation.invoke("foo", "bar")); |
| |
| permutation = MethodHandles.permuteArguments(target, newType, new int[] { 0, 0 }); |
| assertEquals("foofoo", (String) permutation.invoke("foo", "bar")); |
| |
| permutation = MethodHandles.permuteArguments(target, newType, new int[] { 1, 1 }); |
| assertEquals("barbar", (String) permutation.invoke("foo", "bar")); |
| } |
| |
| // Tests for boxing and unboxing. |
| { |
| final MethodHandle target = MethodHandles.lookup().findStatic( |
| Main.class, "permuteArguments_boxingCallee", |
| MethodType.methodType(void.class, new Class<?>[] { boolean.class, Integer.class })); |
| |
| final MethodType newType = MethodType.methodType(void.class, |
| new Class<?>[] { Integer.class, boolean.class }); |
| |
| MethodHandle permutation = MethodHandles.permuteArguments(target, |
| newType, new int[] { 1, 0 }); |
| |
| permutation.invoke(42, true); |
| permutation.invoke(42, Boolean.TRUE); |
| permutation.invoke(Integer.valueOf(42), true); |
| permutation.invoke(Integer.valueOf(42), Boolean.TRUE); |
| } |
| } |
| |
| private static Object returnBar() { |
| return "bar"; |
| } |
| |
| public static void testInvokers() throws Throwable { |
| final MethodType targetType = MethodType.methodType(String.class, String.class); |
| final MethodHandle target = MethodHandles.lookup().findVirtual( |
| String.class, "concat", targetType); |
| |
| MethodHandle invoker = MethodHandles.invoker(target.type()); |
| assertEquals("barbar", (String) invoker.invoke(target, "bar", "bar")); |
| assertEquals("barbar", (String) invoker.invoke(target, (Object) returnBar(), "bar")); |
| try { |
| String foo = (String) invoker.invoke(target, "bar", "bar", 24); |
| fail(); |
| } catch (WrongMethodTypeException expected) { |
| } |
| |
| MethodHandle exactInvoker = MethodHandles.exactInvoker(target.type()); |
| assertEquals("barbar", (String) exactInvoker.invoke(target, "bar", "bar")); |
| try { |
| String foo = (String) exactInvoker.invoke(target, (Object) returnBar(), "bar"); |
| fail(); |
| } catch (WrongMethodTypeException expected) { |
| } |
| try { |
| String foo = (String) exactInvoker.invoke(target, "bar", "bar", 24); |
| fail(); |
| } catch (WrongMethodTypeException expected) { |
| } |
| } |
| |
| public static int spreadReferences(String a, String b, String c) { |
| System.out.println("a: " + a + ", b:" + b + ", c: " + c); |
| return 42; |
| } |
| |
| public static int spreadReferences_Unbox(String a, int b) { |
| System.out.println("a: " + a + ", b:" + b); |
| return 43; |
| } |
| |
| public static void testSpreaders_reference() throws Throwable { |
| MethodType methodType = MethodType.methodType(int.class, |
| new Class<?>[] { String.class, String.class, String.class }); |
| MethodHandle delegate = MethodHandles.lookup().findStatic( |
| Main.class, "spreadReferences", methodType); |
| |
| // Basic checks on array lengths. |
| // |
| // Array size = 0 |
| MethodHandle mhAsSpreader = delegate.asSpreader(String[].class, 0); |
| int ret = (int) mhAsSpreader.invoke("a", "b", "c", new String[] {}); |
| assertEquals(42, ret); |
| // Array size = 1 |
| mhAsSpreader = delegate.asSpreader(String[].class, 1); |
| ret = (int) mhAsSpreader.invoke("a", "b", new String[] { "c" }); |
| assertEquals(42, ret); |
| // Array size = 2 |
| mhAsSpreader = delegate.asSpreader(String[].class, 2); |
| ret = (int) mhAsSpreader.invoke("a", new String[] { "b", "c" }); |
| assertEquals(42, ret); |
| // Array size = 3 |
| mhAsSpreader = delegate.asSpreader(String[].class, 3); |
| ret = (int) mhAsSpreader.invoke(new String[] { "a", "b", "c"}); |
| assertEquals(42, ret); |
| |
| // Exception case, array size = 4 is illegal. |
| try { |
| delegate.asSpreader(String[].class, 4); |
| fail(); |
| } catch (IllegalArgumentException expected) { |
| } |
| |
| // Exception case, calling with an arg of the wrong size. |
| // Array size = 3 |
| mhAsSpreader = delegate.asSpreader(String[].class, 3); |
| try { |
| ret = (int) mhAsSpreader.invoke(new String[] { "a", "b"}); |
| } catch (IllegalArgumentException expected) { |
| } |
| |
| // Various other hijinks, pass as Object[] arrays, Object etc. |
| mhAsSpreader = delegate.asSpreader(Object[].class, 2); |
| ret = (int) mhAsSpreader.invoke("a", new String[] { "b", "c" }); |
| assertEquals(42, ret); |
| |
| mhAsSpreader = delegate.asSpreader(Object[].class, 2); |
| ret = (int) mhAsSpreader.invoke("a", new Object[] { "b", "c" }); |
| assertEquals(42, ret); |
| |
| mhAsSpreader = delegate.asSpreader(Object[].class, 2); |
| ret = (int) mhAsSpreader.invoke("a", (Object) new Object[] { "b", "c" }); |
| assertEquals(42, ret); |
| |
| // Test implicit unboxing. |
| MethodType methodType2 = MethodType.methodType(int.class, |
| new Class<?>[] { String.class, int.class }); |
| MethodHandle delegate2 = MethodHandles.lookup().findStatic( |
| Main.class, "spreadReferences_Unbox", methodType2); |
| |
| // .. with an Integer[] array. |
| mhAsSpreader = delegate2.asSpreader(Integer[].class, 1); |
| ret = (int) mhAsSpreader.invoke("a", new Integer[] { 43 }); |
| assertEquals(43, ret); |
| |
| // .. with an Integer[] array declared as an Object[] argument type. |
| mhAsSpreader = delegate2.asSpreader(Object[].class, 1); |
| ret = (int) mhAsSpreader.invoke("a", new Integer[] { 43 }); |
| assertEquals(43, ret); |
| |
| // .. with an Object[] array. |
| mhAsSpreader = delegate2.asSpreader(Object[].class, 1); |
| ret = (int) mhAsSpreader.invoke("a", new Object[] { Integer.valueOf(43)}); |
| assertEquals(43, ret); |
| |
| // -- Part 2-- |
| // Run a subset of these tests on MethodHandles.spreadInvoker, which only accepts |
| // a trailing argument type of Object[]. |
| MethodHandle spreadInvoker = MethodHandles.spreadInvoker(methodType2, 1); |
| ret = (int) spreadInvoker.invoke(delegate2, "a", new Object[] { Integer.valueOf(43)}); |
| assertEquals(43, ret); |
| |
| ret = (int) spreadInvoker.invoke(delegate2, "a", new Integer[] { 43 }); |
| assertEquals(43, ret); |
| |
| // NOTE: Annoyingly, the second argument here is leadingArgCount and not |
| // arrayLength. |
| spreadInvoker = MethodHandles.spreadInvoker(methodType, 3); |
| ret = (int) spreadInvoker.invoke(delegate, "a", "b", "c", new String[] {}); |
| assertEquals(42, ret); |
| |
| spreadInvoker = MethodHandles.spreadInvoker(methodType, 0); |
| ret = (int) spreadInvoker.invoke(delegate, new String[] { "a", "b", "c" }); |
| assertEquals(42, ret); |
| |
| // Exact invokes: Double check that the expected parameter type is |
| // Object[] and not T[]. |
| try { |
| spreadInvoker.invokeExact(delegate, new String[] { "a", "b", "c" }); |
| fail(); |
| } catch (WrongMethodTypeException expected) { |
| } |
| |
| ret = (int) spreadInvoker.invoke(delegate, new Object[] { "a", "b", "c" }); |
| assertEquals(42, ret); |
| } |
| |
| public static int spreadBoolean(String a, Boolean b, boolean c) { |
| System.out.println("a: " + a + ", b:" + b + ", c: " + c); |
| return 44; |
| } |
| |
| public static int spreadByte(String a, Byte b, byte c, |
| short d, int e, long f, float g, double h) { |
| System.out.println("a: " + a + ", b:" + b + ", c: " + c + |
| ", d: " + d + ", e: " + e + ", f:" + f + ", g: " + g + |
| ", h: " + h); |
| return 45; |
| } |
| |
| public static int spreadChar(String a, Character b, char c, |
| int d, long e, float f, double g) { |
| System.out.println("a: " + a + ", b:" + b + ", c: " + c + |
| ", d: " + d + ", e: " + e + ", f:" + f + ", g: " + g); |
| return 46; |
| } |
| |
| public static int spreadShort(String a, Short b, short c, |
| int d, long e, float f, double g) { |
| System.out.println("a: " + a + ", b:" + b + ", c: " + c + |
| ", d: " + d + ", e: " + e + ", f:" + f + ", g:" + g); |
| return 47; |
| } |
| |
| public static int spreadInt(String a, Integer b, int c, |
| long d, float e, double f) { |
| System.out.println("a: " + a + ", b:" + b + ", c: " + c + |
| ", d: " + d + ", e: " + e + ", f:" + f); |
| return 48; |
| } |
| |
| public static int spreadLong(String a, Long b, long c, float d, double e) { |
| System.out.println("a: " + a + ", b:" + b + ", c: " + c + |
| ", d: " + d + ", e: " + e); |
| return 49; |
| } |
| |
| public static int spreadFloat(String a, Float b, float c, double d) { |
| System.out.println("a: " + a + ", b:" + b + ", c: " + c + ", d: " + d); |
| return 50; |
| } |
| |
| public static int spreadDouble(String a, Double b, double c) { |
| System.out.println("a: " + a + ", b:" + b + ", c: " + c); |
| return 51; |
| } |
| |
| public static void testSpreaders_primitive() throws Throwable { |
| // boolean[] |
| // --------------------- |
| MethodType type = MethodType.methodType(int.class, |
| new Class<?>[] { String.class, Boolean.class, boolean.class }); |
| MethodHandle delegate = MethodHandles.lookup().findStatic( |
| Main.class, "spreadBoolean", type); |
| |
| MethodHandle spreader = delegate.asSpreader(boolean[].class, 2); |
| int ret = (int) spreader.invokeExact("a", new boolean[] { true, false }); |
| assertEquals(44, ret); |
| ret = (int) spreader.invoke("a", new boolean[] { true, false }); |
| assertEquals(44, ret); |
| |
| // boolean can't be cast to String (the first argument to the method). |
| try { |
| delegate.asSpreader(boolean[].class, 3); |
| fail(); |
| } catch (WrongMethodTypeException expected) { |
| } |
| |
| // int can't be cast to boolean to supply the last argument to the method. |
| try { |
| delegate.asSpreader(int[].class, 1); |
| fail(); |
| } catch (WrongMethodTypeException expected) { |
| } |
| |
| // byte[] |
| // --------------------- |
| type = MethodType.methodType(int.class, |
| new Class<?>[] { |
| String.class, Byte.class, byte.class, |
| short.class, int.class, long.class, |
| float.class, double.class }); |
| delegate = MethodHandles.lookup().findStatic(Main.class, "spreadByte", type); |
| |
| spreader = delegate.asSpreader(byte[].class, 7); |
| ret = (int) spreader.invokeExact("a", |
| new byte[] { 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7 }); |
| assertEquals(45, ret); |
| ret = (int) spreader.invoke("a", |
| new byte[] { 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7 }); |
| assertEquals(45, ret); |
| |
| // char[] |
| // --------------------- |
| type = MethodType.methodType(int.class, |
| new Class<?>[] { |
| String.class, Character.class,char.class, |
| int.class, long.class, float.class, double.class }); |
| delegate = MethodHandles.lookup().findStatic(Main.class, "spreadChar", type); |
| |
| spreader = delegate.asSpreader(char[].class, 6); |
| ret = (int) spreader.invokeExact("a", |
| new char[] { '1', '2', '3', '4', '5', '6' }); |
| assertEquals(46, ret); |
| ret = (int) spreader.invokeExact("a", |
| new char[] { '1', '2', '3', '4', '5', '6' }); |
| assertEquals(46, ret); |
| |
| // short[] |
| // --------------------- |
| type = MethodType.methodType(int.class, |
| new Class<?>[] { |
| String.class, Short.class, short.class, |
| int.class, long.class, float.class, double.class }); |
| delegate = MethodHandles.lookup().findStatic(Main.class, "spreadShort", type); |
| |
| spreader = delegate.asSpreader(short[].class, 6); |
| ret = (int) spreader.invokeExact("a", |
| new short[] { 0x1, 0x2, 0x3, 0x4, 0x5, 0x6 }); |
| assertEquals(47, ret); |
| ret = (int) spreader.invoke("a", |
| new short[] { 0x1, 0x2, 0x3, 0x4, 0x5, 0x6 }); |
| assertEquals(47, ret); |
| |
| // int[] |
| // --------------------- |
| type = MethodType.methodType(int.class, |
| new Class<?>[] { |
| String.class, Integer.class, int.class, |
| long.class, float.class, double.class }); |
| delegate = MethodHandles.lookup().findStatic(Main.class, "spreadInt", type); |
| |
| spreader = delegate.asSpreader(int[].class, 5); |
| ret = (int) spreader.invokeExact("a", new int[] { 1, 2, 3, 4, 5 }); |
| assertEquals(48, ret); |
| ret = (int) spreader.invokeExact("a", new int[] { 1, 2, 3, 4, 5 }); |
| assertEquals(48, ret); |
| |
| // long[] |
| // --------------------- |
| type = MethodType.methodType(int.class, |
| new Class<?>[] { |
| String.class, Long.class, long.class, float.class, double.class }); |
| delegate = MethodHandles.lookup().findStatic(Main.class, "spreadLong", type); |
| |
| spreader = delegate.asSpreader(long[].class, 4); |
| ret = (int) spreader.invokeExact("a", |
| new long[] { 0x1, 0x2, 0x3, 0x4 }); |
| assertEquals(49, ret); |
| ret = (int) spreader.invoke("a", |
| new long[] { 0x1, 0x2, 0x3, 0x4 }); |
| assertEquals(49, ret); |
| |
| // float[] |
| // --------------------- |
| type = MethodType.methodType(int.class, |
| new Class<?>[] { |
| String.class, Float.class, float.class, double.class }); |
| delegate = MethodHandles.lookup().findStatic(Main.class, "spreadFloat", type); |
| |
| spreader = delegate.asSpreader(float[].class, 3); |
| ret = (int) spreader.invokeExact("a", |
| new float[] { 1.0f, 2.0f, 3.0f }); |
| assertEquals(50, ret); |
| ret = (int) spreader.invokeExact("a", |
| new float[] { 1.0f, 2.0f, 3.0f }); |
| assertEquals(50, ret); |
| |
| // double[] |
| // --------------------- |
| type = MethodType.methodType(int.class, |
| new Class<?>[] { String.class, Double.class, double.class }); |
| delegate = MethodHandles.lookup().findStatic(Main.class, "spreadDouble", type); |
| |
| spreader = delegate.asSpreader(double[].class, 2); |
| ret = (int) spreader.invokeExact("a", new double[] { 1.0, 2.0 }); |
| assertEquals(51, ret); |
| ret = (int) spreader.invokeExact("a", new double[] { 1.0, 2.0 }); |
| assertEquals(51, ret); |
| } |
| |
| public static void testInvokeWithArguments() throws Throwable { |
| MethodType methodType = MethodType.methodType(int.class, |
| new Class<?>[] { String.class, String.class, String.class }); |
| MethodHandle handle = MethodHandles.lookup().findStatic( |
| Main.class, "spreadReferences", methodType); |
| |
| Object ret = handle.invokeWithArguments(new Object[] { "a", "b", "c"}); |
| assertEquals(42, (int) ret); |
| handle.invokeWithArguments(new String[] { "a", "b", "c" }); |
| assertEquals(42, (int) ret); |
| |
| // Pass in an array that's too small. Should throw an IAE. |
| try { |
| handle.invokeWithArguments(new Object[] { "a", "b" }); |
| fail(); |
| } catch (IllegalArgumentException expected) { |
| } catch (WrongMethodTypeException expected) { |
| } |
| |
| // Test implicit unboxing. |
| MethodType methodType2 = MethodType.methodType(int.class, |
| new Class<?>[] { String.class, int.class }); |
| MethodHandle handle2 = MethodHandles.lookup().findStatic( |
| Main.class, "spreadReferences_Unbox", methodType2); |
| |
| ret = (int) handle2.invokeWithArguments(new Object[] { "a", 43 }); |
| assertEquals(43, (int) ret); |
| } |
| |
| public static int collectBoolean(String a, boolean[] b) { |
| System.out.println("a: " + a + ", b:" + b[0] + ", c: " + b[1]); |
| return 44; |
| } |
| |
| public static int collectByte(String a, byte[] b) { |
| System.out.println("a: " + a + ", b:" + b[0] + ", c: " + b[1]); |
| return 45; |
| } |
| |
| public static int collectChar(String a, char[] b) { |
| System.out.println("a: " + a + ", b:" + b[0] + ", c: " + b[1]); |
| return 46; |
| } |
| |
| public static int collectShort(String a, short[] b) { |
| System.out.println("a: " + a + ", b:" + b[0] + ", c: " + b[1]); |
| return 47; |
| } |
| |
| public static int collectInt(String a, int[] b) { |
| System.out.println("a: " + a + ", b:" + b[0] + ", c: " + b[1]); |
| return 48; |
| } |
| |
| public static int collectLong(String a, long[] b) { |
| System.out.println("a: " + a + ", b:" + b[0] + ", c: " + b[1]); |
| return 49; |
| } |
| |
| public static int collectFloat(String a, float[] b) { |
| System.out.println("a: " + a + ", b:" + b[0] + ", c: " + b[1]); |
| return 50; |
| } |
| |
| public static int collectDouble(String a, double[] b) { |
| System.out.println("a: " + a + ", b:" + b[0] + ", c: " + b[1]); |
| return 51; |
| } |
| |
| public static int collectCharSequence(String a, CharSequence[] b) { |
| System.out.println("a: " + a + ", b:" + b[0] + ", c: " + b[1]); |
| return 99; |
| } |
| |
| public static void testAsCollector() throws Throwable { |
| // Reference arrays. |
| // ------------------- |
| MethodHandle trailingRef = MethodHandles.lookup().findStatic( |
| Main.class, "collectCharSequence", |
| MethodType.methodType(int.class, String.class, CharSequence[].class)); |
| |
| // int[] is not convertible to CharSequence[].class. |
| try { |
| trailingRef.asCollector(int[].class, 1); |
| fail(); |
| } catch (IllegalArgumentException expected) { |
| } |
| |
| // Object[] is not convertible to CharSequence[].class. |
| try { |
| trailingRef.asCollector(Object[].class, 1); |
| fail(); |
| } catch (IllegalArgumentException expected) { |
| } |
| |
| // String[].class is convertible to CharSequence.class |
| MethodHandle collector = trailingRef.asCollector(String[].class, 2); |
| assertEquals(99, (int) collector.invoke("a", "b", "c")); |
| |
| // Too few arguments should fail with a WMTE. |
| try { |
| collector.invoke("a", "b"); |
| fail(); |
| } catch (WrongMethodTypeException expected) { |
| } |
| |
| // Too many arguments should fail with a WMTE. |
| try { |
| collector.invoke("a", "b", "c", "d"); |
| fail(); |
| } catch (WrongMethodTypeException expected) { |
| } |
| |
| // Checks on other array types. |
| |
| MethodHandle target = MethodHandles.lookup().findStatic( |
| Main.class, "collectBoolean", |
| MethodType.methodType(int.class, String.class, boolean[].class)); |
| assertEquals(44, (int) target.asCollector(boolean[].class, 2).invoke("a", true, false)); |
| |
| target = MethodHandles.lookup().findStatic(Main.class, "collectByte", |
| MethodType.methodType(int.class, String.class, byte[].class)); |
| assertEquals(45, (int) target.asCollector(byte[].class, 2).invoke("a", (byte) 1, (byte) 2)); |
| |
| target = MethodHandles.lookup().findStatic(Main.class, "collectChar", |
| MethodType.methodType(int.class, String.class, char[].class)); |
| assertEquals(46, (int) target.asCollector(char[].class, 2).invoke("a", 'a', 'b')); |
| |
| target = MethodHandles.lookup().findStatic(Main.class, "collectShort", |
| MethodType.methodType(int.class, String.class, short[].class)); |
| assertEquals(47, (int) target.asCollector(short[].class, 2).invoke("a", (short) 3, (short) 4)); |
| |
| target = MethodHandles.lookup().findStatic(Main.class, "collectInt", |
| MethodType.methodType(int.class, String.class, int[].class)); |
| assertEquals(48, (int) target.asCollector(int[].class, 2).invoke("a", 42, 43)); |
| |
| target = MethodHandles.lookup().findStatic(Main.class, "collectLong", |
| MethodType.methodType(int.class, String.class, long[].class)); |
| assertEquals(49, (int) target.asCollector(long[].class, 2).invoke("a", 100, 99)); |
| |
| target = MethodHandles.lookup().findStatic(Main.class, "collectFloat", |
| MethodType.methodType(int.class, String.class, float[].class)); |
| assertEquals(50, (int) target.asCollector(float[].class, 2).invoke("a", 8.9f, 9.1f)); |
| |
| target = MethodHandles.lookup().findStatic(Main.class, "collectDouble", |
| MethodType.methodType(int.class, String.class, double[].class)); |
| assertEquals(51, (int) target.asCollector(double[].class, 2).invoke("a", 6.7, 7.8)); |
| } |
| |
| public static String filter1(char a) { |
| return String.valueOf(a); |
| } |
| |
| public static char filter2(String b) { |
| return b.charAt(0); |
| } |
| |
| public static String badFilter1(char a, char b) { |
| return "bad"; |
| } |
| |
| public static int filterTarget(String a, char b, String c, char d) { |
| System.out.println("a: " + a + ", b: " + b + ", c:" + c + ", d:" + d); |
| return 56; |
| } |
| |
| public static void testFilterArguments() throws Throwable { |
| MethodHandle filter1 = MethodHandles.lookup().findStatic( |
| Main.class, "filter1", MethodType.methodType(String.class, char.class)); |
| MethodHandle filter2 = MethodHandles.lookup().findStatic( |
| Main.class, "filter2", MethodType.methodType(char.class, String.class)); |
| |
| MethodHandle target = MethodHandles.lookup().findStatic( |
| Main.class, "filterTarget", MethodType.methodType(int.class, |
| String.class, char.class, String.class, char.class)); |
| |
| // In all the cases below, the values printed will be 'a', 'b', 'c', 'd'. |
| |
| // Filter arguments [0, 1] - all other arguments are passed through |
| // as is. |
| MethodHandle adapter = MethodHandles.filterArguments( |
| target, 0, filter1, filter2); |
| assertEquals(56, (int) adapter.invokeExact('a', "bXXXX", "c", 'd')); |
| |
| // Filter arguments [1, 2]. |
| adapter = MethodHandles.filterArguments(target, 1, filter2, filter1); |
| assertEquals(56, (int) adapter.invokeExact("a", "bXXXX", 'c', 'd')); |
| |
| // Filter arguments [2, 3]. |
| adapter = MethodHandles.filterArguments(target, 2, filter1, filter2); |
| assertEquals(56, (int) adapter.invokeExact("a", 'b', 'c', "dXXXXX")); |
| |
| // Try out a few error cases : |
| |
| // The return types of the filter doesn't align with the expected argument |
| // type of the target. |
| try { |
| adapter = MethodHandles.filterArguments(target, 2, filter2, filter1); |
| fail(); |
| } catch (IllegalArgumentException expected) { |
| } |
| |
| // There are more filters than arguments. |
| try { |
| adapter = MethodHandles.filterArguments(target, 3, filter2, filter1); |
| fail(); |
| } catch (IllegalArgumentException expected) { |
| } |
| |
| // We pass in an obviously bogus position. |
| try { |
| adapter = MethodHandles.filterArguments(target, -1, filter2, filter1); |
| fail(); |
| } catch (ArrayIndexOutOfBoundsException expected) { |
| } |
| |
| // We pass in a function that has more than one argument. |
| MethodHandle badFilter1 = MethodHandles.lookup().findStatic( |
| Main.class, "badFilter1", |
| MethodType.methodType(String.class, char.class, char.class)); |
| |
| try { |
| adapter = MethodHandles.filterArguments(target, 0, badFilter1, filter2); |
| fail(); |
| } catch (IllegalArgumentException expected) { |
| } |
| } |
| |
| static void voidFilter(char a, char b) { |
| System.out.println("voidFilter"); |
| } |
| |
| static String filter(char a, char b) { |
| return String.valueOf(a) + "+" + b; |
| } |
| |
| static char badFilter(char a, char b) { |
| return 0; |
| } |
| |
| static int target(String a, String b, String c) { |
| System.out.println("a: " + a + ", b: " + b + ", c: " + c); |
| return 57; |
| } |
| |
| public static void testCollectArguments() throws Throwable { |
| // Test non-void filters. |
| MethodHandle filter = MethodHandles.lookup().findStatic( |
| Main.class, "filter", |
| MethodType.methodType(String.class, char.class, char.class)); |
| |
| MethodHandle target = MethodHandles.lookup().findStatic( |
| Main.class, "target", |
| MethodType.methodType(int.class, String.class, String.class, String.class)); |
| |
| // Filter at position 0. |
| MethodHandle adapter = MethodHandles.collectArguments(target, 0, filter); |
| assertEquals(57, (int) adapter.invokeExact('a', 'b', "c", "d")); |
| |
| // Filter at position 1. |
| adapter = MethodHandles.collectArguments(target, 1, filter); |
| assertEquals(57, (int) adapter.invokeExact("a", 'b', 'c', "d")); |
| |
| // Filter at position 2. |
| adapter = MethodHandles.collectArguments(target, 2, filter); |
| assertEquals(57, (int) adapter.invokeExact("a", "b", 'c', 'd')); |
| |
| // Test void filters. Note that we're passing in one more argument |
| // than usual because the filter returns nothing - we have to invoke with |
| // the full set of filter args and the full set of target args. |
| filter = MethodHandles.lookup().findStatic(Main.class, "voidFilter", |
| MethodType.methodType(void.class, char.class, char.class)); |
| adapter = MethodHandles.collectArguments(target, 0, filter); |
| assertEquals(57, (int) adapter.invokeExact('a', 'b', "a", "b", "c")); |
| |
| adapter = MethodHandles.collectArguments(target, 1, filter); |
| assertEquals(57, (int) adapter.invokeExact("a", 'a', 'b', "b", "c")); |
| |
| // Test out a few failure cases. |
| filter = MethodHandles.lookup().findStatic( |
| Main.class, "filter", |
| MethodType.methodType(String.class, char.class, char.class)); |
| |
| // Bogus filter position. |
| try { |
| adapter = MethodHandles.collectArguments(target, 3, filter); |
| fail(); |
| } catch (IndexOutOfBoundsException expected) { |
| } |
| |
| // Mismatch in filter return type. |
| filter = MethodHandles.lookup().findStatic( |
| Main.class, "badFilter", |
| MethodType.methodType(char.class, char.class, char.class)); |
| try { |
| adapter = MethodHandles.collectArguments(target, 0, filter); |
| fail(); |
| } catch (IllegalArgumentException expected) { |
| } |
| } |
| |
| static int insertReceiver(String a, int b, Integer c, String d) { |
| System.out.println("a: " + a + ", b:" + b + ", c:" + c + ", d:" + d); |
| return 73; |
| } |
| |
| public static void testInsertArguments() throws Throwable { |
| MethodHandle target = MethodHandles.lookup().findStatic( |
| Main.class, "insertReceiver", |
| MethodType.methodType(int.class, |
| String.class, int.class, Integer.class, String.class)); |
| |
| // Basic single element array inserted at position 0. |
| MethodHandle adapter = MethodHandles.insertArguments( |
| target, 0, new Object[] { "foo" }); |
| assertEquals(73, (int) adapter.invokeExact(45, Integer.valueOf(56), "bar")); |
| |
| // Exercise unboxing. |
| adapter = MethodHandles.insertArguments( |
| target, 1, new Object[] { Integer.valueOf(56), 57 }); |
| assertEquals(73, (int) adapter.invokeExact("foo", "bar")); |
| |
| // Exercise a widening conversion. |
| adapter = MethodHandles.insertArguments( |
| target, 1, new Object[] { (short) 56, Integer.valueOf(57) }); |
| assertEquals(73, (int) adapter.invokeExact("foo", "bar")); |
| |
| // Insert an argument at the last position. |
| adapter = MethodHandles.insertArguments( |
| target, 3, new Object[] { "bar" }); |
| assertEquals(73, (int) adapter.invokeExact("foo", 45, Integer.valueOf(46))); |
| |
| // Exercise a few error cases. |
| |
| // A reference type that can't be cast to another reference type. |
| try { |
| MethodHandles.insertArguments(target, 3, new Object[] { new Object() }); |
| fail(); |
| } catch (ClassCastException expected) { |
| } |
| |
| // A boxed type that can't be unboxed correctly. |
| try { |
| MethodHandles.insertArguments(target, 1, new Object[] { Long.valueOf(56) }); |
| fail(); |
| } catch (ClassCastException expected) { |
| } |
| } |
| |
| public static String foldFilter(char a, char b) { |
| return String.valueOf(a) + "+" + b; |
| } |
| |
| public static void voidFoldFilter(String e, char a, char b) { |
| System.out.println(String.valueOf(a) + "+" + b); |
| } |
| |
| public static int foldTarget(String a, char b, char c, String d) { |
| System.out.println("a: " + a + " ,b:" + b + " ,c:" + c + " ,d:" + d); |
| return 89; |
| } |
| |
| public static void mismatchedVoidFilter(Integer a) { |
| } |
| |
| public static Integer mismatchedNonVoidFilter(char a, char b) { |
| return null; |
| } |
| |
| public static void testFoldArguments() throws Throwable { |
| // Test non-void filters. |
| MethodHandle filter = MethodHandles.lookup().findStatic( |
| Main.class, "foldFilter", |
| MethodType.methodType(String.class, char.class, char.class)); |
| |
| MethodHandle target = MethodHandles.lookup().findStatic( |
| Main.class, "foldTarget", |
| MethodType.methodType(int.class, String.class, |
| char.class, char.class, String.class)); |
| |
| // Folder with a non-void type. |
| MethodHandle adapter = MethodHandles.foldArguments(target, filter); |
| assertEquals(89, (int) adapter.invokeExact('c', 'd', "e")); |
| |
| // Folder with a void type. |
| filter = MethodHandles.lookup().findStatic( |
| Main.class, "voidFoldFilter", |
| MethodType.methodType(void.class, String.class, char.class, char.class)); |
| adapter = MethodHandles.foldArguments(target, filter); |
| assertEquals(89, (int) adapter.invokeExact("a", 'c', 'd', "e")); |
| |
| // Test a few erroneous cases. |
| |
| filter = MethodHandles.lookup().findStatic( |
| Main.class, "mismatchedVoidFilter", |
| MethodType.methodType(void.class, Integer.class)); |
| try { |
| adapter = MethodHandles.foldArguments(target, filter); |
| fail(); |
| } catch (IllegalArgumentException expected) { |
| } |
| |
| filter = MethodHandles.lookup().findStatic( |
| Main.class, "mismatchedNonVoidFilter", |
| MethodType.methodType(Integer.class, char.class, char.class)); |
| try { |
| adapter = MethodHandles.foldArguments(target, filter); |
| fail(); |
| } catch (IllegalArgumentException expected) { |
| } |
| } |
| |
| public static void fail() { |
| System.out.println("FAIL"); |
| Thread.dumpStack(); |
| } |
| |
| public static void fail(String message) { |
| System.out.println("fail: " + message); |
| Thread.dumpStack(); |
| } |
| |
| public static void assertEquals(int i1, int i2) { |
| if (i1 != i2) throw new AssertionError("Expected: " + i1 + " was " + i2); |
| } |
| |
| public static void assertEquals(String s1, String s2) { |
| if (s1 == s2) { |
| return; |
| } |
| |
| if (s1 != null && s2 != null && s1.equals(s2)) { |
| return; |
| } |
| |
| throw new AssertionError("assertEquals s1: " + s1 + ", s2: " + s2); |
| } |
| } |
