test/jdk/java/lang/invoke/TryFinallyTest.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

 /* @test
  * @bug 8139885 8150824 8150825 8194238 8233920
  * @run testng/othervm -ea -esa -Xverify:all test.java.lang.invoke.TryFinallyTest
  */

 package test.java.lang.invoke;

 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
 import java.lang.invoke.MethodHandles.Lookup;
 import java.lang.invoke.MethodType;

 import static java.lang.invoke.MethodType.methodType;

 import static org.testng.AssertJUnit.*;

 import org.testng.annotations.*;

 /**
  * Tests for the tryFinally method handle combinator introduced in JEP 274.
  */
 public class TryFinallyTest {

     static final Lookup LOOKUP = MethodHandles.lookup();

     @Test
     public static void testTryFinally() throws Throwable {
         MethodHandle hello = MethodHandles.tryFinally(TryFinally.MH_greet, TryFinally.MH_exclaim);
         assertEquals(TryFinally.MT_hello, hello.type());
         assertEquals("Hello, world!", hello.invoke("world"));
     }

     @DataProvider
     static Object[][] tryFinallyArgs() {
         return new Object[][] {
                 { boolean.class, true },
                 { byte.class, (byte) 2 },
                 { short.class, (short) 2 },
                 { char.class, (char) 2 },
                 { int.class, 2 },
                 { long.class, 2L },
                 { float.class, 2f },
                 { double.class, 2D },
                 { Object.class, new Object() }
         };
     }

     @Test(dataProvider = "tryFinallyArgs")
     public static void testTryFinally(Class<?> argType, Object arg) throws Throwable {
         MethodHandle identity = MethodHandles.identity(argType);
         MethodHandle tryFinally = MethodHandles.tryFinally(
                 identity,
                 MethodHandles.dropArguments(identity, 0, Throwable.class));
         assertEquals(methodType(argType, argType), tryFinally.type());
         assertEquals(arg, tryFinally.invoke(arg));
     }

     @Test(dataProvider = "tryFinallyArgs", expectedExceptions = TryFinally.T1.class)
     public static void testTryFinallyException(Class<?> argType, Object arg) throws Throwable {
         MethodHandle identity = TryFinally.MH_throwingTargetIdentity.asType(methodType(argType, argType));
         MethodHandle tryFinally = MethodHandles.tryFinally(
                 identity,
                 MethodHandles.dropArguments(identity, 0, TryFinally.T1.class));
         assertEquals(methodType(argType, argType), tryFinally.type());
         tryFinally.invoke(arg); // should throw
     }

     @Test
     public static void testTryFinallyVoid() throws Throwable {
         MethodHandle tfVoid = MethodHandles.tryFinally(TryFinally.MH_print, TryFinally.MH_printMore);
         assertEquals(TryFinally.MT_printHello, tfVoid.type());
         tfVoid.invoke("world");
     }

     @Test
     public static void testTryFinallySublist() throws Throwable {
         MethodHandle helloMore = MethodHandles.tryFinally(TryFinally.MH_greetMore, TryFinally.MH_exclaimMore);
         assertEquals(TryFinally.MT_moreHello, helloMore.type());
         assertEquals("Hello, world and universe (but world first)!", helloMore.invoke("world", "universe"));
     }

     @DataProvider
     static Object[][] omitTrailingArguments() {
         MethodHandle c = TryFinally.MH_voidCleanup;
         return new Object[][]{
                 {c},
                 {MethodHandles.dropArguments(c, 1, int.class)},
                 {MethodHandles.dropArguments(c, 1, int.class, long.class)},
                 {MethodHandles.dropArguments(c, 1, int.class, long.class, Object.class, int.class)},
                 {MethodHandles.dropArguments(c, 1, int.class, long.class, Object.class, int.class, long.class)}
         };
     }

     @Test(dataProvider = "omitTrailingArguments")
     public static void testTryFinallyOmitTrailingArguments(MethodHandle cleanup) throws Throwable {
         MethodHandle tf = MethodHandles.tryFinally(TryFinally.MH_dummyTarget, cleanup);
         tf.invoke(1, 2L, "a", 23, 42L, "b");
     }

     @DataProvider
     static Object[][] negativeTestData() {
         MethodHandle intid = MethodHandles.identity(int.class);
         MethodHandle intco = MethodHandles.constant(int.class, 0);
         MethodHandle errTarget = MethodHandles.dropArguments(intco, 0, int.class, double.class, String.class, int.class);
         MethodHandle errCleanup = MethodHandles.dropArguments(MethodHandles.constant(int.class, 0), 0, Throwable.class,
                 int.class, double.class, Object.class);
         MethodHandle voidTarget = TryFinally.MH_voidTarget;
         MethodHandle voidICleanup = MethodHandles.dropArguments(TryFinally.MH_voidCleanup, 1, int.class);
         return new Object[][]{
                 {intid, MethodHandles.identity(double.class),
                         "target and return types must match: double != int"},
                 {intid, MethodHandles.dropArguments(intid, 0, String.class),
                         "cleanup first argument and Throwable must match: (String,int)int != class java.lang.Throwable"},
                 {intid, MethodHandles.dropArguments(intid, 0, Throwable.class, double.class),
                         "cleanup second argument and target return type must match: (Throwable,double,int)int != int"},
                 {errTarget, errCleanup,
                         "cleanup parameters after (Throwable,result) and target parameter list prefix must match: " +
                                 errCleanup.type() + " != " + errTarget.type()},
                 {voidTarget, voidICleanup,
                         "cleanup parameters after (Throwable,result) and target parameter list prefix must match: " +
                                 voidICleanup.type() + " != " + voidTarget.type()}
         };
     }

     @Test(dataProvider = "negativeTestData")
     public static void testTryFinallyNegative(MethodHandle target, MethodHandle cleanup, String expectedMessage) {
         boolean caught = false;
         try {
             MethodHandles.tryFinally(target, cleanup);
         } catch (IllegalArgumentException iae) {
             assertEquals(expectedMessage, iae.getMessage());
             caught = true;
         }
         assertTrue(caught);
     }

     @Test
     public static void testTryFinallyThrowableCheck() {
         MethodHandle mh = MethodHandles.tryFinally(TryFinally.MH_throwingTarget,
                                                    TryFinally.MH_catchingCleanup);
         try {
             mh.invoke();
             fail("ClassCastException expected");
         } catch (Throwable t) {
             assertTrue("Throwable not assignable to ClassCastException: " + t,
                        ClassCastException.class.isAssignableFrom(t.getClass()));
         }
     }

     static class TryFinally {

         static String greet(String whom) {
             return "Hello, " + whom;
         }

         static String exclaim(Throwable t, String r, String whom) {
             return r + "!";
         }

         static void print(String what) {
             System.out.print("Hello, " + what);
         }

         static void printMore(Throwable t, String what) {
             System.out.println("!");
         }

         static String greetMore(String first, String second) {
             return "Hello, " + first + " and " + second;
         }

         static String exclaimMore(Throwable t, String r, String first) {
             return r + " (but " + first + " first)!";
         }

         static void voidTarget() {}

         static void voidCleanup(Throwable t) {}

         static class T1 extends Throwable {}

         static class T2 extends Throwable {}

         static void throwingTarget() throws Throwable {
             throw new T1();
         }

         static Object throwingTargetIdentity(Object o) throws Throwable {
             throw new T1();
         }

         static void catchingCleanup(T2 t) throws Throwable {
         }

         static final Class<TryFinally> TRY_FINALLY = TryFinally.class;

         static final MethodType MT_greet = methodType(String.class, String.class);
         static final MethodType MT_exclaim = methodType(String.class, Throwable.class, String.class, String.class);
         static final MethodType MT_print = methodType(void.class, String.class);
         static final MethodType MT_printMore = methodType(void.class, Throwable.class, String.class);
         static final MethodType MT_greetMore = methodType(String.class, String.class, String.class);
         static final MethodType MT_exclaimMore = methodType(String.class, Throwable.class, String.class, String.class);
         static final MethodType MT_voidTarget = methodType(void.class);
         static final MethodType MT_voidCleanup = methodType(void.class, Throwable.class);
         static final MethodType MT_throwingTarget = methodType(void.class);
         static final MethodType MT_throwingTargetIdentity = methodType(Object.class, Object.class);
         static final MethodType MT_catchingCleanup = methodType(void.class, T2.class);

         static final MethodHandle MH_greet;
         static final MethodHandle MH_exclaim;
         static final MethodHandle MH_print;
         static final MethodHandle MH_printMore;
         static final MethodHandle MH_greetMore;
         static final MethodHandle MH_exclaimMore;
         static final MethodHandle MH_voidTarget;
         static final MethodHandle MH_voidCleanup;
         static final MethodHandle MH_throwingTarget;
         static final MethodHandle MH_throwingTargetIdentity;
         static final MethodHandle MH_catchingCleanup;

         static final MethodHandle MH_dummyTarget;

         static final MethodType MT_hello = methodType(String.class, String.class);
         static final MethodType MT_printHello = methodType(void.class, String.class);
         static final MethodType MT_moreHello = methodType(String.class, String.class, String.class);

         static {
             try {
                 MH_greet = LOOKUP.findStatic(TRY_FINALLY, "greet", MT_greet);
                 MH_exclaim = LOOKUP.findStatic(TRY_FINALLY, "exclaim", MT_exclaim);
                 MH_print = LOOKUP.findStatic(TRY_FINALLY, "print", MT_print);
                 MH_printMore = LOOKUP.findStatic(TRY_FINALLY, "printMore", MT_printMore);
                 MH_greetMore = LOOKUP.findStatic(TRY_FINALLY, "greetMore", MT_greetMore);
                 MH_exclaimMore = LOOKUP.findStatic(TRY_FINALLY, "exclaimMore", MT_exclaimMore);
                 MH_voidTarget = LOOKUP.findStatic(TRY_FINALLY, "voidTarget", MT_voidTarget);
                 MH_voidCleanup = LOOKUP.findStatic(TRY_FINALLY, "voidCleanup", MT_voidCleanup);
                 MH_throwingTarget = LOOKUP.findStatic(TRY_FINALLY, "throwingTarget", MT_throwingTarget);
                 MH_throwingTargetIdentity = LOOKUP.findStatic(TRY_FINALLY, "throwingTargetIdentity", MT_throwingTargetIdentity);
                 MH_catchingCleanup = LOOKUP.findStatic(TRY_FINALLY, "catchingCleanup", MT_catchingCleanup);
                 MH_dummyTarget = MethodHandles.dropArguments(MH_voidTarget, 0, int.class, long.class, Object.class,
                         int.class, long.class, Object.class);
             } catch (Exception e) {
                 throw new ExceptionInInitializerError(e);
             }
         }

     }

 }
	/*
	* Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	/* @test
	* @bug 8139885 8150824 8150825 8194238 8233920
	* @run testng/othervm -ea -esa -Xverify:all test.java.lang.invoke.TryFinallyTest
	*/

	package test.java.lang.invoke;

	import java.lang.invoke.MethodHandle;
	import java.lang.invoke.MethodHandles;
	import java.lang.invoke.MethodHandles.Lookup;
	import java.lang.invoke.MethodType;

	import static java.lang.invoke.MethodType.methodType;

	import static org.testng.AssertJUnit.*;

	import org.testng.annotations.*;

	/**
	* Tests for the tryFinally method handle combinator introduced in JEP 274.
	*/
	public class TryFinallyTest {

	static final Lookup LOOKUP = MethodHandles.lookup();

	@Test
	public static void testTryFinally() throws Throwable {
	MethodHandle hello = MethodHandles.tryFinally(TryFinally.MH_greet, TryFinally.MH_exclaim);
	assertEquals(TryFinally.MT_hello, hello.type());
	assertEquals("Hello, world!", hello.invoke("world"));
	}

	@DataProvider
	static Object[][] tryFinallyArgs() {
	return new Object[][] {
	{ boolean.class, true },
	{ byte.class, (byte) 2 },
	{ short.class, (short) 2 },
	{ char.class, (char) 2 },
	{ int.class, 2 },
	{ long.class, 2L },
	{ float.class, 2f },
	{ double.class, 2D },
	{ Object.class, new Object() }
	};
	}

	@Test(dataProvider = "tryFinallyArgs")
	public static void testTryFinally(Class<?> argType, Object arg) throws Throwable {
	MethodHandle identity = MethodHandles.identity(argType);
	MethodHandle tryFinally = MethodHandles.tryFinally(
	identity,
	MethodHandles.dropArguments(identity, 0, Throwable.class));
	assertEquals(methodType(argType, argType), tryFinally.type());
	assertEquals(arg, tryFinally.invoke(arg));
	}

	@Test(dataProvider = "tryFinallyArgs", expectedExceptions = TryFinally.T1.class)
	public static void testTryFinallyException(Class<?> argType, Object arg) throws Throwable {
	MethodHandle identity = TryFinally.MH_throwingTargetIdentity.asType(methodType(argType, argType));
	MethodHandle tryFinally = MethodHandles.tryFinally(
	identity,
	MethodHandles.dropArguments(identity, 0, TryFinally.T1.class));
	assertEquals(methodType(argType, argType), tryFinally.type());
	tryFinally.invoke(arg); // should throw
	}

	@Test
	public static void testTryFinallyVoid() throws Throwable {
	MethodHandle tfVoid = MethodHandles.tryFinally(TryFinally.MH_print, TryFinally.MH_printMore);
	assertEquals(TryFinally.MT_printHello, tfVoid.type());
	tfVoid.invoke("world");
	}

	@Test
	public static void testTryFinallySublist() throws Throwable {
	MethodHandle helloMore = MethodHandles.tryFinally(TryFinally.MH_greetMore, TryFinally.MH_exclaimMore);
	assertEquals(TryFinally.MT_moreHello, helloMore.type());
	assertEquals("Hello, world and universe (but world first)!", helloMore.invoke("world", "universe"));
	}

	@DataProvider
	static Object[][] omitTrailingArguments() {
	MethodHandle c = TryFinally.MH_voidCleanup;
	return new Object[][]{
	{c},
	{MethodHandles.dropArguments(c, 1, int.class)},
	{MethodHandles.dropArguments(c, 1, int.class, long.class)},
	{MethodHandles.dropArguments(c, 1, int.class, long.class, Object.class, int.class)},
	{MethodHandles.dropArguments(c, 1, int.class, long.class, Object.class, int.class, long.class)}
	};
	}

	@Test(dataProvider = "omitTrailingArguments")
	public static void testTryFinallyOmitTrailingArguments(MethodHandle cleanup) throws Throwable {
	MethodHandle tf = MethodHandles.tryFinally(TryFinally.MH_dummyTarget, cleanup);
	tf.invoke(1, 2L, "a", 23, 42L, "b");
	}

	@DataProvider
	static Object[][] negativeTestData() {
	MethodHandle intid = MethodHandles.identity(int.class);
	MethodHandle intco = MethodHandles.constant(int.class, 0);
	MethodHandle errTarget = MethodHandles.dropArguments(intco, 0, int.class, double.class, String.class, int.class);
	MethodHandle errCleanup = MethodHandles.dropArguments(MethodHandles.constant(int.class, 0), 0, Throwable.class,
	int.class, double.class, Object.class);
	MethodHandle voidTarget = TryFinally.MH_voidTarget;
	MethodHandle voidICleanup = MethodHandles.dropArguments(TryFinally.MH_voidCleanup, 1, int.class);
	return new Object[][]{
	{intid, MethodHandles.identity(double.class),
	"target and return types must match: double != int"},
	{intid, MethodHandles.dropArguments(intid, 0, String.class),
	"cleanup first argument and Throwable must match: (String,int)int != class java.lang.Throwable"},
	{intid, MethodHandles.dropArguments(intid, 0, Throwable.class, double.class),
	"cleanup second argument and target return type must match: (Throwable,double,int)int != int"},
	{errTarget, errCleanup,
	"cleanup parameters after (Throwable,result) and target parameter list prefix must match: " +
	errCleanup.type() + " != " + errTarget.type()},
	{voidTarget, voidICleanup,
	"cleanup parameters after (Throwable,result) and target parameter list prefix must match: " +
	voidICleanup.type() + " != " + voidTarget.type()}
	};
	}

	@Test(dataProvider = "negativeTestData")
	public static void testTryFinallyNegative(MethodHandle target, MethodHandle cleanup, String expectedMessage) {
	boolean caught = false;
	try {
	MethodHandles.tryFinally(target, cleanup);
	} catch (IllegalArgumentException iae) {
	assertEquals(expectedMessage, iae.getMessage());
	caught = true;
	}
	assertTrue(caught);
	}

	@Test
	public static void testTryFinallyThrowableCheck() {
	MethodHandle mh = MethodHandles.tryFinally(TryFinally.MH_throwingTarget,
	TryFinally.MH_catchingCleanup);
	try {
	mh.invoke();
	fail("ClassCastException expected");
	} catch (Throwable t) {
	assertTrue("Throwable not assignable to ClassCastException: " + t,
	ClassCastException.class.isAssignableFrom(t.getClass()));
	}
	}

	static class TryFinally {

	static String greet(String whom) {
	return "Hello, " + whom;
	}

	static String exclaim(Throwable t, String r, String whom) {
	return r + "!";
	}

	static void print(String what) {
	System.out.print("Hello, " + what);
	}

	static void printMore(Throwable t, String what) {
	System.out.println("!");
	}

	static String greetMore(String first, String second) {
	return "Hello, " + first + " and " + second;
	}

	static String exclaimMore(Throwable t, String r, String first) {
	return r + " (but " + first + " first)!";
	}

	static void voidTarget() {}

	static void voidCleanup(Throwable t) {}

	static class T1 extends Throwable {}

	static class T2 extends Throwable {}

	static void throwingTarget() throws Throwable {
	throw new T1();
	}

	static Object throwingTargetIdentity(Object o) throws Throwable {
	throw new T1();
	}

	static void catchingCleanup(T2 t) throws Throwable {
	}

	static final Class<TryFinally> TRY_FINALLY = TryFinally.class;

	static final MethodType MT_greet = methodType(String.class, String.class);
	static final MethodType MT_exclaim = methodType(String.class, Throwable.class, String.class, String.class);
	static final MethodType MT_print = methodType(void.class, String.class);
	static final MethodType MT_printMore = methodType(void.class, Throwable.class, String.class);
	static final MethodType MT_greetMore = methodType(String.class, String.class, String.class);
	static final MethodType MT_exclaimMore = methodType(String.class, Throwable.class, String.class, String.class);
	static final MethodType MT_voidTarget = methodType(void.class);
	static final MethodType MT_voidCleanup = methodType(void.class, Throwable.class);
	static final MethodType MT_throwingTarget = methodType(void.class);
	static final MethodType MT_throwingTargetIdentity = methodType(Object.class, Object.class);
	static final MethodType MT_catchingCleanup = methodType(void.class, T2.class);

	static final MethodHandle MH_greet;
	static final MethodHandle MH_exclaim;
	static final MethodHandle MH_print;
	static final MethodHandle MH_printMore;
	static final MethodHandle MH_greetMore;
	static final MethodHandle MH_exclaimMore;
	static final MethodHandle MH_voidTarget;
	static final MethodHandle MH_voidCleanup;
	static final MethodHandle MH_throwingTarget;
	static final MethodHandle MH_throwingTargetIdentity;
	static final MethodHandle MH_catchingCleanup;

	static final MethodHandle MH_dummyTarget;

	static final MethodType MT_hello = methodType(String.class, String.class);
	static final MethodType MT_printHello = methodType(void.class, String.class);
	static final MethodType MT_moreHello = methodType(String.class, String.class, String.class);

	static {
	try {
	MH_greet = LOOKUP.findStatic(TRY_FINALLY, "greet", MT_greet);
	MH_exclaim = LOOKUP.findStatic(TRY_FINALLY, "exclaim", MT_exclaim);
	MH_print = LOOKUP.findStatic(TRY_FINALLY, "print", MT_print);
	MH_printMore = LOOKUP.findStatic(TRY_FINALLY, "printMore", MT_printMore);
	MH_greetMore = LOOKUP.findStatic(TRY_FINALLY, "greetMore", MT_greetMore);
	MH_exclaimMore = LOOKUP.findStatic(TRY_FINALLY, "exclaimMore", MT_exclaimMore);
	MH_voidTarget = LOOKUP.findStatic(TRY_FINALLY, "voidTarget", MT_voidTarget);
	MH_voidCleanup = LOOKUP.findStatic(TRY_FINALLY, "voidCleanup", MT_voidCleanup);
	MH_throwingTarget = LOOKUP.findStatic(TRY_FINALLY, "throwingTarget", MT_throwingTarget);
	MH_throwingTargetIdentity = LOOKUP.findStatic(TRY_FINALLY, "throwingTargetIdentity", MT_throwingTargetIdentity);
	MH_catchingCleanup = LOOKUP.findStatic(TRY_FINALLY, "catchingCleanup", MT_catchingCleanup);
	MH_dummyTarget = MethodHandles.dropArguments(MH_voidTarget, 0, int.class, long.class, Object.class,
	int.class, long.class, Object.class);
	} catch (Exception e) {
	throw new ExceptionInInitializerError(e);
	}
	}

	}

	}