diff options
Diffstat (limited to 'test/953-invoke-polymorphic-compiler/src/Main.java')
| -rw-r--r-- | test/953-invoke-polymorphic-compiler/src/Main.java | 374 |
1 files changed, 374 insertions, 0 deletions
diff --git a/test/953-invoke-polymorphic-compiler/src/Main.java b/test/953-invoke-polymorphic-compiler/src/Main.java new file mode 100644 index 0000000000..20a8fec112 --- /dev/null +++ b/test/953-invoke-polymorphic-compiler/src/Main.java @@ -0,0 +1,374 @@ +/* + * 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; +import java.lang.reflect.Constructor; +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.nio.charset.Charset; +import java.nio.charset.StandardCharsets; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class Main { + public static void assertTrue(boolean value) { + if (!value) { + throw new AssertionError("assertTrue value: " + value); + } + } + + public static void assertFalse(boolean value) { + if (value) { + throw new AssertionError("assertTrue value: " + value); + } + } + + public static void assertEquals(int i1, int i2) { + if (i1 == i2) { return; } + throw new AssertionError("assertEquals i1: " + i1 + ", i2: " + i2); + } + + public static void assertEquals(long i1, long i2) { + if (i1 == i2) { return; } + throw new AssertionError("assertEquals l1: " + i1 + ", l2: " + i2); + } + + public static void assertEquals(Object o, Object p) { + if (o == p) { return; } + if (o != null && p != null && o.equals(p)) { return; } + throw new AssertionError("assertEquals: o1: " + o + ", o2: " + p); + } + + 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); + } + + public static void fail() { + System.err.println("fail"); + Thread.dumpStack(); + } + + public static void fail(String message) { + System.err.println("fail: " + message); + Thread.dumpStack(); + } + + public static int Min2Print2(int a, int b) { + int[] values = new int[] { a, b }; + System.err.println("Running Main.Min2Print2(" + Arrays.toString(values) + ")"); + return a > b ? a : b; + } + + public static int Min2Print3(int a, int b, int c) { + int[] values = new int[] { a, b, c }; + System.err.println("Running Main.Min2Print3(" + Arrays.toString(values) + ")"); + return a > b ? a : b; + } + + public static int Min2Print6(int a, int b, int c, int d, int e, int f) { + int[] values = new int[] { a, b, c, d, e, f }; + System.err.println("Running Main.Min2Print6(" + Arrays.toString(values) + ")"); + return a > b ? a : b; + } + + public static int Min2Print26(int a, int b, int c, int d, + int e, int f, int g, int h, + int i, int j, int k, int l, + int m, int n, int o, int p, + int q, int r, int s, int t, + int u, int v, int w, int x, + int y, int z) { + int[] values = new int[] { a, b, c, d, e, f, g, h, i, j, k, l, m, + n, o, p, q, r, s, t, u, v, w, x, y, z }; + System.err.println("Running Main.Min2Print26(" + Arrays.toString(values) + ")"); + return a > b ? a : b; + } + + public static void $opt$BasicTest() throws Throwable { + MethodHandle mh; + mh = MethodHandles.lookup().findStatic( + Main.class, "Min2Print2", MethodType.methodType(int.class, int.class, int.class)); + assertEquals((int) mh.invokeExact(33, -4), 33); + assertEquals((int) mh.invokeExact(-4, 33), 33); + + mh = MethodHandles.lookup().findStatic( + Main.class, "Min2Print3", + MethodType.methodType(int.class, int.class, int.class, int.class)); + assertEquals((int) mh.invokeExact(33, -4, 17), 33); + assertEquals((int) mh.invokeExact(-4, 17, 33), 17); + assertEquals((int) mh.invokeExact(17, 33, -4), 33); + + mh = MethodHandles.lookup().findStatic( + Main.class, "Min2Print6", + MethodType.methodType( + int.class, int.class, int.class, int.class, int.class, int.class, int.class)); + assertEquals((int) mh.invokeExact(33, -4, 77, 88, 99, 111), 33); + try { + // Too few arguments + assertEquals((int) mh.invokeExact(33, -4, 77, 88), 33); + fail("No WMTE for too few arguments"); + } catch (WrongMethodTypeException e) {} + try { + // Too many arguments + assertEquals((int) mh.invokeExact(33, -4, 77, 88, 89, 90, 91), 33); + fail("No WMTE for too many arguments"); + } catch (WrongMethodTypeException e) {} + assertEquals((int) mh.invokeExact(-4, 77, 88, 99, 111, 33), 77); + assertEquals((int) mh.invokeExact(77, 88, 99, 111, 33, -4), 88); + assertEquals((int) mh.invokeExact(88, 99, 111, 33, -4, 77), 99); + assertEquals((int) mh.invokeExact(99, 111, 33, -4, 77, 88), 111); + assertEquals((int) mh.invokeExact(111, 33, -4, 77, 88, 99), 111); + + // A preposterous number of arguments. + mh = MethodHandles.lookup().findStatic( + Main.class, "Min2Print26", + MethodType.methodType( + // Return-type + int.class, + // Arguments + int.class, int.class, int.class, int.class, int.class, int.class, int.class, int.class, + int.class, int.class, int.class, int.class, int.class, int.class, int.class, int.class, + int.class, int.class, int.class, int.class, int.class, int.class, int.class, int.class, + int.class, int.class)); + assertEquals(1, (int) mh.invokeExact(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25)); + assertEquals(25, (int) mh.invokeExact(25, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24)); + assertEquals(25, (int) mh.invokeExact(24, 25, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23)); + + try { + // Wrong argument type + mh.invokeExact("a"); + fail("No WMTE for wrong arguments"); + } catch (WrongMethodTypeException wmte) {} + + try { + // Invoke on null handle. + MethodHandle mh0 = null; + mh0.invokeExact("bad"); + fail("No NPE for you"); + } catch (NullPointerException npe) {} + + System.err.println("BasicTest done."); + } + + private static boolean And(boolean lhs, boolean rhs) { + return lhs & rhs; + } + + private static boolean Xor(boolean lhs, boolean rhs) { + return lhs ^ rhs; + } + + private static String Multiply(String value, int n) { + String result = ""; + for (int i = 0; i < n; ++i) { + result = value + result; + } + return result; + } + + private static byte Multiply(byte value, byte n) { + return (byte)(value * n); + } + + private static short Multiply(short value, short n) { + return (short)(value * n); + } + + private static int Multiply(int value, int n) { + return value * n; + } + + private static long Multiply(long value, long n) { + return value * n; + } + + private static float Multiply(float value, float n) { + return value * n; + } + + private static double Multiply(double value, double n) { + return value * n; + } + + private static char Next(char c) { + return (char)(c + 1); + } + + public static void $opt$ReturnBooleanTest() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + MethodHandle mh = + lookup.findStatic(Main.class, "And", + MethodType.methodType(boolean.class, boolean.class, boolean.class)); + assertEquals(true, (boolean) mh.invokeExact(true, true)); + assertEquals(false, (boolean) mh.invokeExact(true, false)); + assertEquals(false, (boolean) mh.invokeExact(false, true)); + assertEquals(false, (boolean) mh.invokeExact(false, false)); + assertEquals(true, (boolean) mh.invoke(true, true)); + assertEquals(false, (boolean) mh.invoke(true, false)); + assertEquals(false, (boolean) mh.invoke(false, true)); + assertEquals(false, (boolean) mh.invoke(false, false)); + + mh = lookup.findStatic(Main.class, "Xor", + MethodType.methodType(boolean.class, boolean.class, boolean.class)); + assertEquals(false, (boolean) mh.invokeExact(true, true)); + assertEquals(true, (boolean) mh.invokeExact(true, false)); + assertEquals(true, (boolean) mh.invokeExact(false, true)); + assertEquals(false, (boolean) mh.invokeExact(false, false)); + assertEquals(false, (boolean) mh.invoke(true, true)); + assertEquals(true, (boolean) mh.invoke(true, false)); + assertEquals(true, (boolean) mh.invoke(false, true)); + assertEquals(false, (boolean) mh.invoke(false, false)); + + System.err.println("$opt$ReturnBooleanTest done."); + } + + public static void $opt$ReturnCharTest() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + MethodHandle mh = lookup.findStatic(Main.class, "Next", + MethodType.methodType(char.class, char.class)); + assertEquals('B', (char) mh.invokeExact('A')); + assertEquals((char) -55, (char) mh.invokeExact((char) -56)); + System.err.println("$opt$ReturnCharTest done."); + } + + public static void $opt$ReturnByteTest() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + MethodHandle mh = lookup.findStatic(Main.class, "Multiply", + MethodType.methodType(byte.class, byte.class, byte.class)); + assertEquals((byte) 30, (byte) mh.invokeExact((byte) 10, (byte) 3)); + assertEquals((byte) -90, (byte) mh.invoke((byte) -10, (byte) 9)); + System.err.println("$opt$ReturnByteTest done."); + } + + public static void $opt$ReturnShortTest() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + MethodHandle mh = lookup.findStatic(Main.class, "Multiply", + MethodType.methodType(short.class, short.class, short.class)); + assertEquals((short) 3000, (short) mh.invokeExact((short) 1000, (short) 3)); + assertEquals((short) -3000, (short) mh.invoke((short) -1000, (short) 3)); + System.err.println("$opt$ReturnShortTest done."); + } + + public static void $opt$ReturnIntTest() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + MethodHandle mh = lookup.findStatic(Main.class, "Multiply", + MethodType.methodType(int.class, int.class, int.class)); + assertEquals(3_000_000, (int) mh.invokeExact(1_000_000, 3)); + assertEquals(-3_000_000, (int) mh.invoke(-1_000, 3_000)); + System.err.println("$opt$ReturnIntTest done."); + } + + public static void $opt$ReturnLongTest() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + MethodHandle mh = lookup.findStatic(Main.class, "Multiply", + MethodType.methodType(long.class, long.class, long.class)); + assertEquals(4_294_967_295_000L, (long) mh.invokeExact(1000L, 4_294_967_295L)); + assertEquals(-4_294_967_295_000L, (long) mh.invoke(-1000L, 4_294_967_295L)); + System.err.println("$opt$ReturnLongTest done."); + } + + public static void $opt$ReturnFloatTest() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + MethodHandle mh = lookup.findStatic(Main.class, "Multiply", + MethodType.methodType(float.class, float.class, float.class)); + assertEquals(3.0F, (float) mh.invokeExact(1000.0F, 3e-3F)); + assertEquals(-3.0F, (float) mh.invoke(-1000.0F, 3e-3F)); + System.err.println("$opt$ReturnFloatTest done."); + } + + public static void $opt$ReturnDoubleTest() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + MethodHandle mh = lookup.findStatic(Main.class, "Multiply", + MethodType.methodType(double.class, double.class, double.class)); + assertEquals(3033000.0, (double) mh.invokeExact(1000.0, 3.033e3)); + assertEquals(-3033000.0, (double) mh.invoke(-1000.0, 3.033e3)); + System.err.println("$opt$ReturnDoubleTest done."); + } + + public static void $opt$ReturnStringTest() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + MethodHandle mh = lookup.findStatic(Main.class, "Multiply", + MethodType.methodType(String.class, String.class, int.class)); + assertEquals("100010001000", (String) mh.invokeExact("1000", 3)); + assertEquals("100010001000", (String) mh.invoke("1000", 3)); + System.err.println("$opt$ReturnStringTest done."); + } + + public static void ReturnValuesTest() throws Throwable { + $opt$ReturnBooleanTest(); + $opt$ReturnCharTest(); + $opt$ReturnByteTest(); + $opt$ReturnShortTest(); + $opt$ReturnIntTest(); + $opt$ReturnLongTest(); + $opt$ReturnFloatTest(); + $opt$ReturnDoubleTest(); + $opt$ReturnStringTest(); + System.err.println("ReturnValuesTest done."); + } + + static class ValueHolder { + public boolean m_z; + public static boolean s_z; + } + + public static void $opt$AccessorsTest() throws Throwable { + ValueHolder valueHolder = new ValueHolder(); + MethodHandles.Lookup lookup = MethodHandles.lookup(); + + MethodHandle setMember = lookup.findSetter(ValueHolder.class, "m_z", boolean.class); + MethodHandle getMember = lookup.findGetter(ValueHolder.class, "m_z", boolean.class); + MethodHandle setStatic = lookup.findStaticSetter(ValueHolder.class, "s_z", boolean.class); + MethodHandle getStatic = lookup.findStaticGetter(ValueHolder.class, "s_z", boolean.class); + + boolean [] values = { false, true, false, true, false }; + for (boolean value : values) { + assertEquals((boolean) getStatic.invoke(), ValueHolder.s_z); + setStatic.invoke(value); + ValueHolder.s_z = value; + assertEquals(ValueHolder.s_z, value); + assertEquals((boolean) getStatic.invoke(), value); + + assertEquals((boolean) getMember.invoke(valueHolder), valueHolder.m_z); + setMember.invoke(valueHolder, value); + valueHolder.m_z = value; + assertEquals(valueHolder.m_z, value); + assertEquals((boolean) getMember.invoke(valueHolder), value); + } + } + + public static void main(String[] args) throws Throwable { + $opt$BasicTest(); + ReturnValuesTest(); + $opt$AccessorsTest(); + } +} |