1 /*
   2  * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 /* @test
  25  * @summary unit tests for java.lang.invoke.MethodHandles
  26  * @library /lib/testlibrary /java/lang/invoke/common
  27  * @compile MethodHandlesTest.java MethodHandlesCastFailureTest.java remote/RemoteExample.java
  28  * @run junit/othervm/timeout=2500 -XX:+IgnoreUnrecognizedVMOptions
  29  *                                 -XX:-VerifyDependencies
  30  *                                 -esa
  31  *                                 test.java.lang.invoke.MethodHandlesCastFailureTest
  32  */
  33 
  34 package test.java.lang.invoke;
  35 
  36 import org.junit.*;
  37 import test.java.lang.invoke.lib.CodeCacheOverflowProcessor;
  38 
  39 import java.lang.invoke.MethodHandle;
  40 import java.lang.invoke.MethodHandles;
  41 import java.lang.invoke.MethodType;
  42 
  43 import static org.junit.Assert.*;
  44 
  45 public class MethodHandlesCastFailureTest extends MethodHandlesTest {
  46 
  47     @Test  // SLOW
  48     public void testCastFailure() throws Throwable {
  49         CodeCacheOverflowProcessor.runMHTest(this::testCastFailure0);
  50     }
  51 
  52     public void testCastFailure0() throws Throwable {
  53         if (CAN_SKIP_WORKING)  return;
  54         startTest("testCastFailure");
  55         testCastFailure("cast/argument", 11000);
  56         if (CAN_TEST_LIGHTLY)  return;
  57         testCastFailure("unbox/argument", 11000);
  58         testCastFailure("cast/return", 11000);
  59         testCastFailure("unbox/return", 11000);
  60     }
  61 
  62     static class Surprise {
  63         public MethodHandle asMethodHandle() {
  64             return VALUE.bindTo(this);
  65         }
  66         Object value(Object x) {
  67             trace("value", x);
  68             if (boo != null)  return boo;
  69             return x;
  70         }
  71         Object boo;
  72         void boo(Object x) { boo = x; }
  73 
  74         static void trace(String x, Object y) {
  75             if (verbosity > 8) System.out.println(x+"="+y);
  76         }
  77         static Object  refIdentity(Object x)  { trace("ref.x", x); return x; }
  78         static Integer boxIdentity(Integer x) { trace("box.x", x); return x; }
  79         static int     intIdentity(int x)     { trace("int.x", x); return x; }
  80         static MethodHandle VALUE, REF_IDENTITY, BOX_IDENTITY, INT_IDENTITY;
  81         static {
  82             try {
  83                 VALUE = PRIVATE.findVirtual(
  84                     Surprise.class, "value",
  85                         MethodType.methodType(Object.class, Object.class));
  86                 REF_IDENTITY = PRIVATE.findStatic(
  87                     Surprise.class, "refIdentity",
  88                         MethodType.methodType(Object.class, Object.class));
  89                 BOX_IDENTITY = PRIVATE.findStatic(
  90                     Surprise.class, "boxIdentity",
  91                         MethodType.methodType(Integer.class, Integer.class));
  92                 INT_IDENTITY = PRIVATE.findStatic(
  93                     Surprise.class, "intIdentity",
  94                         MethodType.methodType(int.class, int.class));
  95             } catch (NoSuchMethodException | IllegalAccessException ex) {
  96                 throw new RuntimeException(ex);
  97             }
  98         }
  99     }
 100 
 101     @SuppressWarnings("ConvertToStringSwitch")
 102     void testCastFailure(String mode, int okCount) throws Throwable {
 103         countTest(false);
 104         if (verbosity > 2)  System.out.println("mode="+mode);
 105         Surprise boo = new Surprise();
 106         MethodHandle identity = Surprise.REF_IDENTITY, surprise0 = boo.asMethodHandle(), surprise = surprise0;
 107         if (mode.endsWith("/return")) {
 108             if (mode.equals("unbox/return")) {
 109                 // fail on return to ((Integer)surprise).intValue
 110                 surprise = surprise.asType(MethodType.methodType(int.class, Object.class));
 111                 identity = identity.asType(MethodType.methodType(int.class, Object.class));
 112             } else if (mode.equals("cast/return")) {
 113                 // fail on return to (Integer)surprise
 114                 surprise = surprise.asType(MethodType.methodType(Integer.class, Object.class));
 115                 identity = identity.asType(MethodType.methodType(Integer.class, Object.class));
 116             }
 117         } else if (mode.endsWith("/argument")) {
 118             MethodHandle callee = null;
 119             if (mode.equals("unbox/argument")) {
 120                 // fail on handing surprise to int argument
 121                 callee = Surprise.INT_IDENTITY;
 122             } else if (mode.equals("cast/argument")) {
 123                 // fail on handing surprise to Integer argument
 124                 callee = Surprise.BOX_IDENTITY;
 125             }
 126             if (callee != null) {
 127                 callee = callee.asType(MethodType.genericMethodType(1));
 128                 surprise = MethodHandles.filterArguments(callee, 0, surprise);
 129                 identity = MethodHandles.filterArguments(callee, 0, identity);
 130             }
 131         }
 132         assertNotSame(mode, surprise, surprise0);
 133         identity = identity.asType(MethodType.genericMethodType(1));
 134         surprise = surprise.asType(MethodType.genericMethodType(1));
 135         Object x = 42;
 136         for (int i = 0; i < okCount; i++) {
 137             Object y = identity.invokeExact(x);
 138             assertEquals(x, y);
 139             Object z = surprise.invokeExact(x);
 140             assertEquals(x, z);
 141         }
 142         boo.boo("Boo!");
 143         Object y = identity.invokeExact(x);
 144         assertEquals(x, y);
 145         try {
 146             Object z = surprise.invokeExact(x);
 147             System.out.println("Failed to throw; got z="+z);
 148             assertTrue(false);
 149         } catch (ClassCastException ex) {
 150             if (verbosity > 2)
 151                 System.out.println("caught "+ex);
 152             if (verbosity > 3)
 153                 ex.printStackTrace(System.out);
 154             assertTrue(true);  // all is well
 155         }
 156     }
 157 }