# HG changeset patch
# User mullan
# Date 1434570508 14400
# Node ID 27ccb72932eee12d5c5f39fa52c21d270b17a9b6
# Parent  316a8c3e572a71b96d087fbe6e2bcde54d9e6520# Parent  a823fb6fdf2e38cef732e2811cc13ce4c6b9f2db
Merge

diff -r 316a8c3e572a -r 27ccb72932ee jdk/test/java/lang/invoke/LFCaching/LFCachingTestCase.java
--- a/jdk/test/java/lang/invoke/LFCaching/LFCachingTestCase.java	Wed Jun 17 15:47:12 2015 -0400
+++ b/jdk/test/java/lang/invoke/LFCaching/LFCachingTestCase.java	Wed Jun 17 15:48:28 2015 -0400
@@ -77,7 +77,7 @@
             }
         } catch (IllegalAccessException | IllegalArgumentException |
                 SecurityException | InvocationTargetException ex) {
-            throw new Error("Unexpected exception: ", ex);
+            throw new Error("Unexpected exception", ex);
         }
     }
 }
diff -r 316a8c3e572a -r 27ccb72932ee jdk/test/java/lang/invoke/LFCaching/LFGarbageCollectedTest.java
--- a/jdk/test/java/lang/invoke/LFCaching/LFGarbageCollectedTest.java	Wed Jun 17 15:47:12 2015 -0400
+++ b/jdk/test/java/lang/invoke/LFCaching/LFGarbageCollectedTest.java	Wed Jun 17 15:48:28 2015 -0400
@@ -24,6 +24,7 @@
 /*
  * @test LFGarbageCollectedTest
  * @bug 8046703
+ * @key randomness
  * @ignore 8078602
  * @summary Test verifies that lambda forms are garbage collected
  * @author kshefov
@@ -73,7 +74,7 @@
             try {
                 adapter = testCase.getTestCaseMH(data, TestMethods.Kind.ONE);
             } catch (NoSuchMethodException ex) {
-                throw new Error("Unexpected exception: ", ex);
+                throw new Error("Unexpected exception", ex);
             }
             mtype = adapter.type();
             Object lambdaForm = INTERNAL_FORM.invoke(adapter);
@@ -94,7 +95,7 @@
             collectLambdaForm();
         } catch (IllegalAccessException | IllegalArgumentException |
                 InvocationTargetException ex) {
-            throw new Error("Unexpected exception: ", ex);
+            throw new Error("Unexpected exception", ex);
         }
     }
 
diff -r 316a8c3e572a -r 27ccb72932ee jdk/test/java/lang/invoke/LFCaching/LFMultiThreadCachingTest.java
--- a/jdk/test/java/lang/invoke/LFCaching/LFMultiThreadCachingTest.java	Wed Jun 17 15:47:12 2015 -0400
+++ b/jdk/test/java/lang/invoke/LFCaching/LFMultiThreadCachingTest.java	Wed Jun 17 15:48:28 2015 -0400
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2015, 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
@@ -24,6 +24,7 @@
 /*
  * @test LFMultiThreadCachingTest
  * @bug 8046703
+ * @key randomness
  * @summary Test verifies that lambda forms are cached when run with multiple threads
  * @author kshefov
  * @library /lib/testlibrary/jsr292 /lib/testlibrary
@@ -35,18 +36,23 @@
  */
 
 import java.lang.invoke.MethodHandle;
+import java.util.Collections;
 import java.util.EnumSet;
+import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.BrokenBarrierException;
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.CyclicBarrier;
+import com.oracle.testlibrary.jsr292.CodeCacheOverflowProcessor;
 
 /**
  * Multiple threaded lambda forms caching test class.
  */
 public final class LFMultiThreadCachingTest extends LFCachingTestCase {
+
     private static final TestMethods.Kind[] KINDS;
+
     static {
         EnumSet<TestMethods.Kind> set = EnumSet.complementOf(EnumSet.of(TestMethods.Kind.EXCEPT));
         KINDS = set.toArray(new TestMethods.Kind[set.size()]);
@@ -72,21 +78,55 @@
         ConcurrentLinkedQueue<MethodHandle> adapters = new ConcurrentLinkedQueue<>();
         CyclicBarrier begin = new CyclicBarrier(CORES);
         CountDownLatch end = new CountDownLatch(CORES);
+        final Map<Thread, Throwable> threadUncaughtExceptions
+                = Collections.synchronizedMap(new HashMap<Thread, Throwable>(CORES));
+        Thread.UncaughtExceptionHandler exHandler = (t, e) -> {
+            threadUncaughtExceptions.put(t, e);
+        };
         for (int i = 0; i < CORES; ++i) {
             TestMethods.Kind kind = KINDS[i % KINDS.length];
-            new Thread(() -> {
+            Thread t = new Thread(() -> {
                 try {
                     begin.await();
                     adapters.add(getTestMethod().getTestCaseMH(data, kind));
-                } catch (InterruptedException | BrokenBarrierException | IllegalAccessException | NoSuchMethodException ex) {
-                    throw new Error("Unexpected exception: ", ex);
+                } catch (InterruptedException | BrokenBarrierException
+                        | IllegalAccessException | NoSuchMethodException ex) {
+                    throw new Error("Unexpected exception", ex);
                 } finally {
                     end.countDown();
                 }
-            }).start();
+            });
+            t.setUncaughtExceptionHandler(exHandler);
+            t.start();
         }
         try {
             end.await();
+            boolean vmeThrown = false;
+            boolean nonVmeThrown = false;
+            Throwable vme = null;
+            for (Map.Entry<Thread,
+                    Throwable> entry : threadUncaughtExceptions.entrySet()) {
+                Thread t =  entry.getKey();
+                Throwable e = entry.getValue();
+                System.err.printf("%nA thread with name \"%s\" of %d threads"
+                        + " has thrown exception:%n", t.getName(), CORES);
+                e.printStackTrace();
+                if (CodeCacheOverflowProcessor.isThrowableCausedByVME(e)) {
+                    vmeThrown = true;
+                    vme = e;
+                } else {
+                    nonVmeThrown = true;
+                }
+                if (nonVmeThrown) {
+                    throw new Error("One ore more threads have"
+                            + " thrown unexpected exceptions. See log.");
+                }
+                if (vmeThrown) {
+                    throw new Error("One ore more threads have"
+                            + " thrown VirtualMachineError caused by"
+                            + " code cache overflow. See log.", vme);
+                }
+            }
         } catch (InterruptedException ex) {
             throw new Error("Unexpected exception: ", ex);
         }
diff -r 316a8c3e572a -r 27ccb72932ee jdk/test/java/lang/invoke/LFCaching/LFSingleThreadCachingTest.java
--- a/jdk/test/java/lang/invoke/LFCaching/LFSingleThreadCachingTest.java	Wed Jun 17 15:47:12 2015 -0400
+++ b/jdk/test/java/lang/invoke/LFCaching/LFSingleThreadCachingTest.java	Wed Jun 17 15:48:28 2015 -0400
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2015, 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
@@ -24,6 +24,7 @@
 /*
  * @test LFSingleThreadCachingTest
  * @bug 8046703
+ * @key randomness
  * @summary Test verifies that lambda forms are cached when run with single thread
  * @author kshefov
  * @library /lib/testlibrary/jsr292 /lib/testlibrary
@@ -62,7 +63,7 @@
             adapter1 = getTestMethod().getTestCaseMH(data, TestMethods.Kind.ONE);
             adapter2 = getTestMethod().getTestCaseMH(data, TestMethods.Kind.TWO);
         } catch (NoSuchMethodException | IllegalAccessException ex) {
-            throw new Error("Unexpected exception: ", ex);
+            throw new Error("Unexpected exception", ex);
         }
         checkLFCaching(adapter1, adapter2);
     }
diff -r 316a8c3e572a -r 27ccb72932ee jdk/test/java/lang/invoke/LFCaching/LambdaFormTestCase.java
--- a/jdk/test/java/lang/invoke/LFCaching/LambdaFormTestCase.java	Wed Jun 17 15:47:12 2015 -0400
+++ b/jdk/test/java/lang/invoke/LFCaching/LambdaFormTestCase.java	Wed Jun 17 15:48:28 2015 -0400
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2015, 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
@@ -22,7 +22,7 @@
  */
 
 import com.oracle.testlibrary.jsr292.Helper;
-import com.sun.management.HotSpotDiagnosticMXBean;
+import com.oracle.testlibrary.jsr292.CodeCacheOverflowProcessor;
 import java.lang.invoke.MethodHandle;
 import java.lang.management.GarbageCollectorMXBean;
 import java.lang.management.ManagementFactory;
@@ -44,8 +44,6 @@
  */
 public abstract class LambdaFormTestCase {
 
-    private static final double ITERATIONS_TO_CODE_CACHE_SIZE_RATIO
-            = 45 / (128.0 * 1024 * 1024);
     private static final long TIMEOUT = Helper.IS_THOROUGH ? 0L : (long) (Utils.adjustTimeout(Utils.DEFAULT_TEST_TIMEOUT) * 0.9);
 
     /**
@@ -72,7 +70,7 @@
             REF_FIELD = Reference.class.getDeclaredField("referent");
             REF_FIELD.setAccessible(true);
         } catch (Exception ex) {
-            throw new Error("Unexpected exception: ", ex);
+            throw new Error("Unexpected exception", ex);
         }
 
         gcInfo = ManagementFactory.getGarbageCollectorMXBeans();
@@ -101,28 +99,6 @@
             long iterations = Math.max(1, Helper.TEST_LIMIT / testCaseNum);
             System.out.printf("Number of iterations according to -DtestLimit is %d (%d cases)%n",
                     iterations, iterations * testCaseNum);
-            HotSpotDiagnosticMXBean hsDiagBean = ManagementFactory.getPlatformMXBean(HotSpotDiagnosticMXBean.class);
-            long codeCacheSize = Long.parseLong(
-                    hsDiagBean.getVMOption("ReservedCodeCacheSize").getValue());
-            System.out.printf("Code cache size is %d bytes%n", codeCacheSize);
-            long iterationsByCodeCacheSize = (long) (codeCacheSize
-                    * ITERATIONS_TO_CODE_CACHE_SIZE_RATIO);
-            long nonProfiledCodeCacheSize = Long.parseLong(
-                    hsDiagBean.getVMOption("NonProfiledCodeHeapSize").getValue());
-            System.out.printf("Non-profiled code cache size is %d bytes%n", nonProfiledCodeCacheSize);
-            long iterationsByNonProfiledCodeCacheSize = (long) (nonProfiledCodeCacheSize
-                    * ITERATIONS_TO_CODE_CACHE_SIZE_RATIO);
-            System.out.printf("Number of iterations limited by code cache size is %d (%d cases)%n",
-                    iterationsByCodeCacheSize, iterationsByCodeCacheSize * testCaseNum);
-            System.out.printf("Number of iterations limited by non-profiled code cache size is %d (%d cases)%n",
-                    iterationsByNonProfiledCodeCacheSize, iterationsByNonProfiledCodeCacheSize * testCaseNum);
-            iterations = Math.min(iterationsByCodeCacheSize,
-                    Math.min(iterations, iterationsByNonProfiledCodeCacheSize));
-            if (iterations == 0) {
-                System.out.println("Warning: code cache size is too small to provide at"
-                        + " least one iteration! Test will try to do one iteration.");
-                iterations = 1;
-            }
             System.out.printf("Number of iterations is set to %d (%d cases)%n",
                     iterations, iterations * testCaseNum);
             System.out.flush();
@@ -141,22 +117,27 @@
             for (TestMethods testMethod : testMethods) {
                 LambdaFormTestCase testCase = ctor.apply(testMethod);
                 try {
-                    System.err.printf("Tested LF caching feature with MethodHandles.%s method.%n",
+                    System.err.printf("Tested LF caching feature"
+                            + " with MethodHandles.%s method.%n",
                             testCase.getTestMethod().name);
-                    testCase.doTest();
+                    Throwable t = CodeCacheOverflowProcessor
+                            .runMHTest(testCase::doTest);
+                    if (t != null) {
+                        return false;
+                    }
                     System.err.println("PASSED");
-                } catch (OutOfMemoryError e) {
+                } catch (OutOfMemoryError oome) {
                     // Don't swallow OOME so a heap dump can be created.
                     System.err.println("FAILED");
-                    throw e;
+                    throw oome;
                 } catch (Throwable t) {
                     t.printStackTrace();
                     System.err.printf("FAILED. Caused by %s%n", t.getMessage());
                     passed = false;
                     failCounter++;
                 }
-                    testCounter++;
-                }
+                testCounter++;
+            }
             doneIterations++;
             return true;
         }
@@ -205,8 +186,8 @@
      * @param testMethods list of test methods
      */
     public static void runTests(Function<TestMethods, LambdaFormTestCase> ctor, Collection<TestMethods> testMethods) {
-        LambdaFormTestCase.TestRun run =
-                new LambdaFormTestCase.TestRun(ctor, testMethods);
+        LambdaFormTestCase.TestRun run
+                = new LambdaFormTestCase.TestRun(ctor, testMethods);
         TimeLimitedRunner runner = new TimeLimitedRunner(TIMEOUT, 4.0d, run::doIteration);
         try {
             runner.call();
diff -r 316a8c3e572a -r 27ccb72932ee jdk/test/java/lang/invoke/MethodHandles/CatchExceptionTest.java
--- a/jdk/test/java/lang/invoke/MethodHandles/CatchExceptionTest.java	Wed Jun 17 15:47:12 2015 -0400
+++ b/jdk/test/java/lang/invoke/MethodHandles/CatchExceptionTest.java	Wed Jun 17 15:48:28 2015 -0400
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2015, 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
@@ -23,6 +23,7 @@
 package test.java.lang.invoke.MethodHandles;
 
 import com.oracle.testlibrary.jsr292.Helper;
+import com.oracle.testlibrary.jsr292.CodeCacheOverflowProcessor;
 import jdk.testlibrary.Asserts;
 import jdk.testlibrary.TimeLimitedRunner;
 import jdk.testlibrary.Utils;
@@ -35,7 +36,6 @@
 import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.function.Supplier;
-import java.util.concurrent.TimeUnit;
 
 /* @test
  * @library /lib/testlibrary/jsr292 /lib/testlibrary/
@@ -91,6 +91,10 @@
     }
 
     public static void main(String[] args) throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(CatchExceptionTest::test);
+    }
+
+    public static void test() throws Throwable {
         System.out.println("classes = " + ARGS_CLASSES);
 
         TestFactory factory = new TestFactory();
@@ -116,7 +120,6 @@
         return Helper.getParams(ARGS_CLASSES, isVararg, argsCount);
     }
 
-
     private List<Class<?>> getCatcherParams() {
         int catchArgc = 1 + this.argsCount - dropped;
         List<Class<?>> result = new ArrayList<>(
diff -r 316a8c3e572a -r 27ccb72932ee jdk/test/java/lang/invoke/MethodHandlesTest.java
--- a/jdk/test/java/lang/invoke/MethodHandlesTest.java	Wed Jun 17 15:47:12 2015 -0400
+++ b/jdk/test/java/lang/invoke/MethodHandlesTest.java	Wed Jun 17 15:48:28 2015 -0400
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2009, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2009, 2015, 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
@@ -23,6 +23,7 @@
 
 /* @test
  * @summary unit tests for java.lang.invoke.MethodHandles
+ * @library /lib/testlibrary /lib/testlibrary/jsr292
  * @compile MethodHandlesTest.java remote/RemoteExample.java
  * @run junit/othervm/timeout=2500 -XX:+IgnoreUnrecognizedVMOptions -XX:-VerifyDependencies -esa test.java.lang.invoke.MethodHandlesTest
  */
@@ -36,6 +37,7 @@
 import java.util.*;
 import org.junit.*;
 import static org.junit.Assert.*;
+import com.oracle.testlibrary.jsr292.CodeCacheOverflowProcessor;
 
 
 /**
@@ -499,6 +501,10 @@
 
     @Test
     public void testFindStatic() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testFindStatic0);
+    }
+
+    public void testFindStatic0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("findStatic");
         testFindStatic(PubExample.class, void.class, "s0");
@@ -586,6 +592,10 @@
 
     @Test
     public void testFindVirtual() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testFindVirtual0);
+    }
+
+    public void testFindVirtual0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("findVirtual");
         testFindVirtual(Example.class, void.class, "v0");
@@ -616,6 +626,10 @@
 
     @Test
     public void testFindVirtualClone() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testFindVirtualClone0);
+    }
+
+    public void testFindVirtualClone0() throws Throwable {
         // test some ad hoc system methods
         testFindVirtual(false, PUBLIC, Object.class, Object.class, "clone");
         testFindVirtual(true, PUBLIC, Object[].class, Object.class, "clone");
@@ -699,6 +713,10 @@
 
     @Test
     public void testFindSpecial() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testFindSpecial0);
+    }
+
+    public void testFindSpecial0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("findSpecial");
         testFindSpecial(SubExample.class, Example.class, void.class, "v0");
@@ -775,6 +793,10 @@
 
     @Test
     public void testFindConstructor() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testFindConstructor0);
+    }
+
+    public void testFindConstructor0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("findConstructor");
         testFindConstructor(true, EXAMPLE, Example.class);
@@ -818,6 +840,10 @@
 
     @Test
     public void testBind() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testBind0);
+    }
+
+    public void testBind0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("bind");
         testBind(Example.class, void.class, "v0");
@@ -879,6 +905,10 @@
 
     @Test
     public void testUnreflect() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testUnreflect0);
+    }
+
+    public void testUnreflect0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("unreflect");
         testUnreflect(Example.class, true, void.class, "s0");
@@ -985,6 +1015,10 @@
 
     @Test
     public void testUnreflectSpecial() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testUnreflectSpecial0);
+    }
+
+    public void testUnreflectSpecial0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("unreflectSpecial");
         testUnreflectSpecial(Example.class,    Example.class, void.class, "v0");
@@ -1077,23 +1111,38 @@
 
     @Test
     public void testUnreflectGetter() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testUnreflectGetter0);
+    }
+
+    public void testUnreflectGetter0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("unreflectGetter");
         testGetter(TEST_UNREFLECT);
     }
+
     @Test
     public void testFindGetter() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testFindGetter0);
+    }
+
+    public void testFindGetter0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("findGetter");
         testGetter(TEST_FIND_FIELD);
         testGetter(TEST_FIND_FIELD | TEST_BOUND);
     }
+
     @Test
     public void testFindStaticGetter() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testFindStaticGetter0);
+    }
+
+    public void testFindStaticGetter0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("findStaticGetter");
         testGetter(TEST_FIND_STATIC);
     }
+
     public void testGetter(int testMode) throws Throwable {
         Lookup lookup = PRIVATE;  // FIXME: test more lookups than this one
         for (Object[] c : HasFields.CASES) {
@@ -1287,26 +1336,40 @@
         }
     }
 
-
     @Test
     public void testUnreflectSetter() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testUnreflectSetter0);
+    }
+
+    public void testUnreflectSetter0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("unreflectSetter");
         testSetter(TEST_UNREFLECT);
     }
+
     @Test
     public void testFindSetter() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testFindSetter0);
+    }
+
+    public void testFindSetter0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("findSetter");
         testSetter(TEST_FIND_FIELD);
         testSetter(TEST_FIND_FIELD | TEST_BOUND);
     }
+
     @Test
     public void testFindStaticSetter() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testFindStaticSetter0);
+    }
+
+    public void testFindStaticSetter0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("findStaticSetter");
         testSetter(TEST_FIND_STATIC);
     }
+
     public void testSetter(int testMode) throws Throwable {
         Lookup lookup = PRIVATE;  // FIXME: test more lookups than this one
         startTest("unreflectSetter");
@@ -1329,6 +1392,10 @@
 
     @Test
     public void testArrayElementGetter() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testArrayElementGetter0);
+    }
+
+    public void testArrayElementGetter0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("arrayElementGetter");
         testArrayElementGetterSetter(false);
@@ -1336,6 +1403,10 @@
 
     @Test
     public void testArrayElementSetter() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testArrayElementSetter0);
+    }
+
+    public void testArrayElementSetter0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("arrayElementSetter");
         testArrayElementGetterSetter(true);
@@ -1349,6 +1420,10 @@
 
     @Test
     public void testArrayElementErrors() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testArrayElementErrors0);
+    }
+
+    public void testArrayElementErrors0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("arrayElementErrors");
         testArrayElementGetterSetter(false, TEST_ARRAY_NPE);
@@ -1528,6 +1603,10 @@
 
     @Test
     public void testConvertArguments() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testConvertArguments0);
+    }
+
+    public void testConvertArguments0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("convertArguments");
         testConvert(Callee.ofType(1), null, "id", int.class);
@@ -1591,6 +1670,10 @@
 
     @Test
     public void testVarargsCollector() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testVarargsCollector0);
+    }
+
+    public void testVarargsCollector0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("varargsCollector");
         MethodHandle vac0 = PRIVATE.findStatic(MethodHandlesTest.class, "called",
@@ -1605,8 +1688,12 @@
         }
     }
 
-    @Test  // SLOW
+    @Test // SLOW
     public void testPermuteArguments() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testPermuteArguments0);
+    }
+
+    public void testPermuteArguments0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("permuteArguments");
         testPermuteArguments(4, Integer.class,  2, long.class,    6);
@@ -1744,8 +1831,12 @@
     }
 
 
-    @Test  // SLOW
+    @Test // SLOW
     public void testSpreadArguments() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testSpreadArguments0);
+    }
+
+    public void testSpreadArguments0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("spreadArguments");
         for (Class<?> argType : new Class<?>[]{Object.class, Integer.class, int.class}) {
@@ -1838,8 +1929,12 @@
         }
     }
 
-    @Test  // SLOW
+    @Test // SLOW
     public void testAsCollector() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testAsCollector0);
+    }
+
+    public void testAsCollector0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("asCollector");
         for (Class<?> argType : new Class<?>[]{Object.class, Integer.class, int.class}) {
@@ -1880,8 +1975,12 @@
         assertArrayEquals(collectedArgs, returnValue);
     }
 
-    @Test  // SLOW
+    @Test // SLOW
     public void testInsertArguments() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testInsertArguments0);
+    }
+
+    public void testInsertArguments0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("insertArguments");
         for (int nargs = 0; nargs < 50; nargs++) {
@@ -1923,6 +2022,10 @@
 
     @Test
     public void testFilterReturnValue() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testFilterReturnValue0);
+    }
+
+    public void testFilterReturnValue0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("filterReturnValue");
         Class<?> classOfVCList = varargsList(1).invokeWithArguments(0).getClass();
@@ -1972,6 +2075,10 @@
 
     @Test
     public void testFilterArguments() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testFilterArguments0);
+    }
+
+    public void testFilterArguments0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("filterArguments");
         for (int nargs = 1; nargs <= 6; nargs++) {
@@ -2004,6 +2111,10 @@
 
     @Test
     public void testCollectArguments() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testCollectArguments0);
+    }
+
+    public void testCollectArguments0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("collectArguments");
         testFoldOrCollectArguments(true);
@@ -2011,6 +2122,10 @@
 
     @Test
     public void testFoldArguments() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testFoldArguments0);
+    }
+
+    public void testFoldArguments0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("foldArguments");
         testFoldOrCollectArguments(false);
@@ -2112,6 +2227,10 @@
 
     @Test
     public void testDropArguments() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testDropArguments0);
+    }
+
+    public void testDropArguments0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("dropArguments");
         for (int nargs = 0; nargs <= 4; nargs++) {
@@ -2143,6 +2262,10 @@
 
     @Test  // SLOW
     public void testInvokers() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testInvokers0);
+    }
+
+    public void testInvokers0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("exactInvoker, genericInvoker, varargsInvoker, dynamicInvoker");
         // exactInvoker, genericInvoker, varargsInvoker[0..N], dynamicInvoker
@@ -2344,6 +2467,10 @@
 
     @Test
     public void testGuardWithTest() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testGuardWithTest0);
+    }
+
+    public void testGuardWithTest0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("guardWithTest");
         for (int nargs = 0; nargs <= 50; nargs++) {
@@ -2415,6 +2542,10 @@
 
     @Test
     public void testThrowException() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testThrowException0);
+    }
+
+    public void testThrowException0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("throwException");
         testThrowException(int.class, new ClassCastException("testing"));
@@ -2446,6 +2577,10 @@
 
     @Test
     public void testInterfaceCast() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testInterfaceCast0);
+    }
+
+    public void testInterfaceCast0() throws Throwable {
         //if (CAN_SKIP_WORKING)  return;
         startTest("interfaceCast");
         assert( (((Object)"foo") instanceof CharSequence));
@@ -2543,6 +2678,10 @@
 
     @Test  // SLOW
     public void testCastFailure() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testCastFailure0);
+    }
+
+    public void testCastFailure0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("testCastFailure");
         testCastFailure("cast/argument", 11000);
@@ -2655,6 +2794,10 @@
 
     @Test
     public void testUserClassInSignature() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testUserClassInSignature0);
+    }
+
+    public void testUserClassInSignature0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("testUserClassInSignature");
         Lookup lookup = MethodHandles.lookup();
@@ -2706,6 +2849,10 @@
 
     @Test
     public void testAsInterfaceInstance() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testAsInterfaceInstance0);
+    }
+
+    public void testAsInterfaceInstance0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("asInterfaceInstance");
         Lookup lookup = MethodHandles.lookup();
@@ -2869,6 +3016,10 @@
 
     @Test
     public void testRunnableProxy() throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(this::testRunnableProxy0);
+    }
+
+    public void testRunnableProxy0() throws Throwable {
         if (CAN_SKIP_WORKING)  return;
         startTest("testRunnableProxy");
         MethodHandles.Lookup lookup = MethodHandles.lookup();
diff -r 316a8c3e572a -r 27ccb72932ee jdk/test/java/lang/invoke/TestCatchExceptionWithVarargs.java
--- a/jdk/test/java/lang/invoke/TestCatchExceptionWithVarargs.java	Wed Jun 17 15:47:12 2015 -0400
+++ b/jdk/test/java/lang/invoke/TestCatchExceptionWithVarargs.java	Wed Jun 17 15:48:28 2015 -0400
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2015, 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
@@ -24,9 +24,12 @@
 /*
  * @test
  * @bug 8019184
+ * @library /lib/testlibrary /lib/testlibrary/jsr292
  * @summary MethodHandles.catchException() fails when methods have 8 args + varargs
+ * @run main TestCatchExceptionWithVarargs
  */
 
+import com.oracle.testlibrary.jsr292.CodeCacheOverflowProcessor;
 import java.util.*;
 import java.lang.invoke.*;
 
@@ -68,6 +71,11 @@
     }
 
     public static void main(String[] args) throws Throwable {
+        CodeCacheOverflowProcessor
+                .runMHTest(TestCatchExceptionWithVarargs::test);
+    }
+
+    public static void test() throws Throwable {
         List<Class<?>> ptypes = new LinkedList<>();
         ptypes.add(Object[].class);
 
diff -r 316a8c3e572a -r 27ccb72932ee jdk/test/java/lang/invoke/VarargsArrayTest.java
--- a/jdk/test/java/lang/invoke/VarargsArrayTest.java	Wed Jun 17 15:47:12 2015 -0400
+++ b/jdk/test/java/lang/invoke/VarargsArrayTest.java	Wed Jun 17 15:48:28 2015 -0400
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2015, 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
@@ -24,14 +24,14 @@
 package java.lang.invoke;
 
 import sun.invoke.util.Wrapper;
-
 import java.util.Arrays;
 import java.util.Collections;
+import com.oracle.testlibrary.jsr292.CodeCacheOverflowProcessor;
 
 /* @test
  * @summary unit tests for varargs array methods: MethodHandleInfo.varargsArray(int),
  *          MethodHandleInfo.varargsArray(Class,int) & MethodHandleInfo.varargsList(int)
- *
+ * @library /lib/testlibrary /lib/testlibrary/jsr292
  * @run main/bootclasspath java.lang.invoke.VarargsArrayTest
  * @run main/bootclasspath -DVarargsArrayTest.MAX_ARITY=255 -DVarargsArrayTest.START_ARITY=250
  *                         java.lang.invoke.VarargsArrayTest
@@ -47,6 +47,10 @@
     private static final boolean EXHAUSTIVE = Boolean.getBoolean(CLASS.getSimpleName()+".EXHAUSTIVE");
 
     public static void main(String[] args) throws Throwable {
+        CodeCacheOverflowProcessor.runMHTest(VarargsArrayTest::test);
+    }
+
+    public static void test() throws Throwable {
         testVarargsArray();
         testVarargsReferenceArray();
         testVarargsPrimitiveArray();
diff -r 316a8c3e572a -r 27ccb72932ee jdk/test/lib/testlibrary/jdk/testlibrary/Utils.java
--- a/jdk/test/lib/testlibrary/jdk/testlibrary/Utils.java	Wed Jun 17 15:47:12 2015 -0400
+++ b/jdk/test/lib/testlibrary/jdk/testlibrary/Utils.java	Wed Jun 17 15:48:28 2015 -0400
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2015, 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
@@ -25,9 +25,6 @@
 
 import static jdk.testlibrary.Asserts.assertTrue;
 
-import java.io.BufferedReader;
-import java.io.File;
-import java.io.FileReader;
 import java.io.IOException;
 import java.net.InetAddress;
 import java.net.ServerSocket;
@@ -40,6 +37,7 @@
 import java.util.regex.Matcher;
 import java.util.concurrent.TimeUnit;
 import java.util.function.BooleanSupplier;
+import java.util.function.Function;
 
 /**
  * Common library for various test helper functions.
@@ -326,4 +324,38 @@
         }
         return condition.getAsBoolean();
     }
+
+    /**
+     * Interface same as java.lang.Runnable but with
+     * method {@code run()} able to throw any Throwable.
+     */
+    public static interface ThrowingRunnable {
+        void run() throws Throwable;
+    }
+
+    /**
+     * Filters out an exception that may be thrown by the given
+     * test according to the given filter.
+     *
+     * @param test - method that is invoked and checked for exception.
+     * @param filter - function that checks if the thrown exception matches
+     *                 criteria given in the filter's implementation.
+     * @return - exception that matches the filter if it has been thrown or
+     *           {@code null} otherwise.
+     * @throws Throwable - if test has thrown an exception that does not
+     *                     match the filter.
+     */
+    public static Throwable filterException(ThrowingRunnable test,
+            Function<Throwable, Boolean> filter) throws Throwable {
+        try {
+            test.run();
+        } catch (Throwable t) {
+            if (filter.apply(t)) {
+                return t;
+            } else {
+                throw t;
+            }
+        }
+        return null;
+    }
 }
diff -r 316a8c3e572a -r 27ccb72932ee jdk/test/lib/testlibrary/jsr292/com/oracle/testlibrary/jsr292/CodeCacheOverflowProcessor.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/lib/testlibrary/jsr292/com/oracle/testlibrary/jsr292/CodeCacheOverflowProcessor.java	Wed Jun 17 15:48:28 2015 -0400
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2015, 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.
+ *
+ * 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.
+ */
+package com.oracle.testlibrary.jsr292;
+
+import jdk.testlibrary.Utils;
+
+/**
+ * Helper class used to catch and process VirtualMachineError with message "Out
+ * of space in CodeCache". Some JSR292 tests run out of code cache size, so code
+ * cache overflows and VME is thrown. This VME is considered as non-critical in
+ * some JSR292 tests, so it should be processed to prevent test failure.
+ */
+public class CodeCacheOverflowProcessor {
+
+    /**
+     * Checks if an instance of Throwable is caused by VirtualMachineError with
+     * message "Out of space in CodeCache". May be used as filter in method
+     * {@code jdk.testlibrary.Utils.filterException}.
+     *
+     * @param t - Throwable to check.
+     * @return true if Throwable is caused by VME, false otherwise.
+     */
+    public static Boolean isThrowableCausedByVME(Throwable t) {
+        Throwable causeOfT = t;
+        do {
+            if (causeOfT instanceof VirtualMachineError
+                    && causeOfT.getMessage().matches(".*[Oo]ut of space"
+                            + " in CodeCache.*")) {
+                return true;
+            }
+            causeOfT = causeOfT != null ? causeOfT.getCause() : null;
+        } while (causeOfT != null && causeOfT != t);
+        return false;
+    }
+
+    /**
+     * Checks if the given test throws an exception caused by
+     * VirtualMachineError with message "Out of space in CodeCache", and, if VME
+     * takes place, processes it so that no exception is thrown, and prints its
+     * stack trace. If test throws exception not caused by VME, this method just
+     * re-throws this exception.
+     *
+     * @param test - test to check for and process VirtualMachineError.
+     * @return - an exception caused by VME or null
+     *           if test has thrown no exception.
+     * @throws Throwable - if test has thrown an exception
+     *                     that is not caused by VME.
+     */
+    public static Throwable runMHTest(Utils.ThrowingRunnable test) throws Throwable {
+        Throwable t = Utils.filterException(test::run,
+                CodeCacheOverflowProcessor::isThrowableCausedByVME);
+        if (t != null) {
+            System.err.printf("%nNon-critical exception caught becuse of"
+                    + " code cache size is not enough to run all test cases.%n%n");
+            t.printStackTrace();
+        }
+        return t;
+    }
+}