changeset 12276:69e2479c5e31

Merge
author prr
date Mon, 22 Jun 2015 13:28:57 -0700
parents 3fd8114e6dfa 0bc25016547c
children 1f78d4b793a4
files
diffstat 34 files changed, 1394 insertions(+), 239 deletions(-) [+]
line wrap: on
line diff
--- a/.hgtags	Thu Jun 04 18:28:52 2015 +0200
+++ b/.hgtags	Mon Jun 22 13:28:57 2015 -0700
@@ -311,3 +311,4 @@
 4fbcca8ab812198c7fb747ea7b213b6e404f36e9 jdk9-b66
 1abd45df5480a04bff98fba1851d66a5230e67d4 jdk9-b67
 046fd17bb9a0cdf6681124866df9626d17b0516a jdk9-b68
+551323004d0ce2f1d4b0e99552f7e0cdcebc6fca jdk9-b69
--- a/make/lib/CoreLibraries.gmk	Thu Jun 04 18:28:52 2015 +0200
+++ b/make/lib/CoreLibraries.gmk	Mon Jun 22 13:28:57 2015 -0700
@@ -161,7 +161,7 @@
         -export:getLastErrorString \
         jvm.lib $(BUILD_LIBFDLIBM) $(WIN_VERIFY_LIB) \
         shell32.lib delayimp.lib -DELAYLOAD:shell32.dll \
-        advapi32.lib, \
+        advapi32.lib version.lib, \
     VERSIONINFO_RESOURCE := $(GLOBAL_VERSION_INFO_RESOURCE), \
     RC_FLAGS := $(RC_FLAGS) \
         -D "JDK_FNAME=java.dll" \
--- a/src/java.base/share/classes/java/lang/SecurityManager.java	Thu Jun 04 18:28:52 2015 +0200
+++ b/src/java.base/share/classes/java/lang/SecurityManager.java	Mon Jun 22 13:28:57 2015 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1995, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1995, 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
@@ -1447,7 +1447,7 @@
             throw new NullPointerException("package name can't be null");
         }
 
-        String[] pkgs;
+        String[] restrictedPkgs;
         synchronized (packageAccessLock) {
             /*
              * Do we need to update our property array?
@@ -1457,8 +1457,7 @@
                     AccessController.doPrivileged(
                         new PrivilegedAction<>() {
                             public String run() {
-                                return java.security.Security.getProperty(
-                                    "package.access");
+                                return Security.getProperty("package.access");
                             }
                         }
                     );
@@ -1468,14 +1467,33 @@
 
             // Using a snapshot of packageAccess -- don't care if static field
             // changes afterwards; array contents won't change.
-            pkgs = packageAccess;
+            restrictedPkgs = packageAccess;
         }
 
         /*
          * Traverse the list of packages, check for any matches.
          */
-        for (String restrictedPkg : pkgs) {
-            if (pkg.startsWith(restrictedPkg) || restrictedPkg.equals(pkg + ".")) {
+        final int plen = pkg.length();
+        for (String restrictedPkg : restrictedPkgs) {
+            final int rlast = restrictedPkg.length() - 1;
+
+            // Optimizations:
+            //
+            // If rlast >= plen then restrictedPkg is longer than pkg by at
+            // least one char. This means pkg cannot start with restrictedPkg,
+            // since restrictedPkg will be longer than pkg.
+            //
+            // Similarly if rlast != plen, then pkg + "." cannot be the same
+            // as restrictedPkg, since pkg + "." will have a different length
+            // than restrictedPkg.
+            //
+            if (rlast < plen && pkg.startsWith(restrictedPkg) ||
+                // The following test is equivalent to
+                // restrictedPkg.equals(pkg + ".") but is noticeably more
+                // efficient:
+                rlast == plen && restrictedPkg.startsWith(pkg) &&
+                restrictedPkg.charAt(rlast) == '.')
+            {
                 checkPermission(
                     new RuntimePermission("accessClassInPackage." + pkg));
                 break;  // No need to continue; only need to check this once
--- a/src/java.base/share/classes/java/lang/reflect/AnnotatedArrayType.java	Thu Jun 04 18:28:52 2015 +0200
+++ b/src/java.base/share/classes/java/lang/reflect/AnnotatedArrayType.java	Mon Jun 22 13:28:57 2015 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 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
@@ -39,6 +39,7 @@
      * Returns the potentially annotated generic component type of this array type.
      *
      * @return the potentially annotated generic component type of this array type
+     * @see GenericArrayType#getGenericComponentType()
      */
     AnnotatedType  getAnnotatedGenericComponentType();
 }
--- a/src/java.base/share/classes/java/lang/reflect/AnnotatedParameterizedType.java	Thu Jun 04 18:28:52 2015 +0200
+++ b/src/java.base/share/classes/java/lang/reflect/AnnotatedParameterizedType.java	Mon Jun 22 13:28:57 2015 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 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
@@ -38,6 +38,7 @@
      * Returns the potentially annotated actual type arguments of this parameterized type.
      *
      * @return the potentially annotated actual type arguments of this parameterized type
+     * @see ParameterizedType#getActualTypeArguments()
      */
     AnnotatedType[] getAnnotatedActualTypeArguments();
 }
--- a/src/java.base/share/classes/java/lang/reflect/AnnotatedTypeVariable.java	Thu Jun 04 18:28:52 2015 +0200
+++ b/src/java.base/share/classes/java/lang/reflect/AnnotatedTypeVariable.java	Mon Jun 22 13:28:57 2015 -0700
@@ -36,10 +36,11 @@
 
     /**
      * Returns the potentially annotated bounds of this type variable.
-     * Note that if no bound is explicitly declared, the bound is unannotated
+     * If no bound is explicitly declared, the bound is unannotated
      * {@code Object}.
      *
      * @return the potentially annotated bounds of this type variable
+     * @see TypeVariable#getBounds()
      */
     AnnotatedType[] getAnnotatedBounds();
 }
--- a/src/java.base/share/classes/java/lang/reflect/AnnotatedWildcardType.java	Thu Jun 04 18:28:52 2015 +0200
+++ b/src/java.base/share/classes/java/lang/reflect/AnnotatedWildcardType.java	Mon Jun 22 13:28:57 2015 -0700
@@ -36,20 +36,22 @@
 
     /**
      * Returns the potentially annotated lower bounds of this wildcard type.
-     * Note that if no lower bound is explicitly declared, the lower bound is the
+     * If no lower bound is explicitly declared, the lower bound is the
      * type of null. In this case, a zero length array is returned.
      *
      * @return the potentially annotated lower bounds of this wildcard type or
      * an empty array if no lower bound is explicitly declared.
+     * @see WildcardType#getLowerBounds()
      */
     AnnotatedType[] getAnnotatedLowerBounds();
 
     /**
      * Returns the potentially annotated upper bounds of this wildcard type.
-     * Note that if no upper bound is explicitly declared, the upper bound is
+     * If no upper bound is explicitly declared, the upper bound is
      * unannotated {@code Object}
      *
      * @return the potentially annotated upper bounds of this wildcard type
+     * @see WildcardType#getUpperBounds()
      */
     AnnotatedType[] getAnnotatedUpperBounds();
 }
--- a/src/java.base/share/classes/java/lang/reflect/TypeVariable.java	Thu Jun 04 18:28:52 2015 +0200
+++ b/src/java.base/share/classes/java/lang/reflect/TypeVariable.java	Mon Jun 22 13:28:57 2015 -0700
@@ -51,7 +51,7 @@
 public interface TypeVariable<D extends GenericDeclaration> extends Type, AnnotatedElement {
     /**
      * Returns an array of {@code Type} objects representing the
-     * upper bound(s) of this type variable.  Note that if no upper bound is
+     * upper bound(s) of this type variable.  If no upper bound is
      * explicitly declared, the upper bound is {@code Object}.
      *
      * <p>For each upper bound B: <ul> <li>if B is a parameterized
@@ -67,7 +67,7 @@
      *     for any reason
      * @return an array of {@code Type}s representing the upper
      *     bound(s) of this type variable
-    */
+     */
     Type[] getBounds();
 
     /**
--- a/src/java.base/share/classes/java/lang/reflect/WildcardType.java	Thu Jun 04 18:28:52 2015 +0200
+++ b/src/java.base/share/classes/java/lang/reflect/WildcardType.java	Mon Jun 22 13:28:57 2015 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2004, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 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
@@ -34,7 +34,7 @@
 public interface WildcardType extends Type {
     /**
      * Returns an array of {@code Type} objects representing the  upper
-     * bound(s) of this type variable.  Note that if no upper bound is
+     * bound(s) of this type variable.  If no upper bound is
      * explicitly declared, the upper bound is {@code Object}.
      *
      * <p>For each upper bound B :
@@ -57,7 +57,7 @@
 
     /**
      * Returns an array of {@code Type} objects representing the
-     * lower bound(s) of this type variable.  Note that if no lower bound is
+     * lower bound(s) of this type variable.  If no lower bound is
      * explicitly declared, the lower bound is the type of {@code null}.
      * In this case, a zero length array is returned.
      *
--- a/src/java.base/share/classes/java/security/SecureClassLoader.java	Thu Jun 04 18:28:52 2015 +0200
+++ b/src/java.base/share/classes/java/security/SecureClassLoader.java	Mon Jun 22 13:28:57 2015 -0700
@@ -25,9 +25,11 @@
 
 package java.security;
 
-import java.util.HashMap;
+import java.util.Map;
 import java.util.ArrayList;
 import java.net.URL;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Function;
 
 import sun.security.util.Debug;
 
@@ -48,7 +50,7 @@
     private final boolean initialized;
 
     /*
-     * HashMap that maps the CodeSource URL (as a String) to ProtectionDomain.
+     * Map that maps the CodeSource URL (as a String) to ProtectionDomain.
      * We use a String instead of a CodeSource/URL as the key to avoid
      * potential expensive name service lookups. This does mean that URLs that
      * are equivalent after nameservice lookup will be placed in separate
@@ -56,7 +58,8 @@
      * canonicalized and resolved resulting in a consistent set of granted
      * permissions.
      */
-    private final HashMap<String, ProtectionDomain> pdcache = new HashMap<>(11);
+    private final Map<String, ProtectionDomain> pdcache
+            = new ConcurrentHashMap<>(11);
 
     private static final Debug debug = Debug.getInstance("scl");
 
@@ -206,25 +209,28 @@
             return null;
         }
 
-        ProtectionDomain pd = null;
-        synchronized (pdcache) {
-            // Use a String form of the URL as the key. It should behave in the
-            // same manner as the URL when compared for equality except that no
-            // nameservice lookup is done on the hostname (String comparison
-            // only), and the fragment is not considered.
-            String key = cs.getLocationNoFragString();
-            pd = pdcache.get(key);
-            if (pd == null) {
-                PermissionCollection perms = getPermissions(cs);
-                pd = new ProtectionDomain(cs, perms, this, null);
-                pdcache.put(key, pd);
+        // Use a String form of the URL as the key. It should behave in the
+        // same manner as the URL when compared for equality except that no
+        // nameservice lookup is done on the hostname (String comparison
+        // only), and the fragment is not considered.
+        String key = cs.getLocationNoFragString();
+        if (key == null) {
+            key = "<null>";
+        }
+        return pdcache.computeIfAbsent(key, new Function<>() {
+            @Override
+            public ProtectionDomain apply(String key /* not used */) {
+                PermissionCollection perms
+                        = SecureClassLoader.this.getPermissions(cs);
+                ProtectionDomain pd = new ProtectionDomain(
+                        cs, perms, SecureClassLoader.this, null);
                 if (debug != null) {
-                    debug.println(" getPermissions "+ pd);
+                    debug.println(" getPermissions " + pd);
                     debug.println("");
                 }
+                return pd;
             }
-        }
-        return pd;
+        });
     }
 
     /*
--- a/src/java.base/unix/classes/java/lang/ProcessImpl.java	Thu Jun 04 18:28:52 2015 +0200
+++ b/src/java.base/unix/classes/java/lang/ProcessImpl.java	Mon Jun 22 13:28:57 2015 -0700
@@ -542,7 +542,22 @@
     @Override
     public CompletableFuture<Process> onExit() {
         return ProcessHandleImpl.completion(pid, false)
-                .handleAsync((exitStatus, unusedThrowable) -> this);
+                .handleAsync((exitStatus, unusedThrowable) -> {
+                    boolean interrupted = false;
+                    while (true) {
+                        // Ensure that the concurrent task setting the exit status has completed
+                        try {
+                            waitFor();
+                            break;
+                        } catch (InterruptedException ie) {
+                            interrupted = true;
+                        }
+                    }
+                    if (interrupted) {
+                        Thread.currentThread().interrupt();
+                    }
+                    return this;
+                });
     }
 
     @Override
--- a/src/java.base/windows/native/launcher/java.manifest	Thu Jun 04 18:28:52 2015 +0200
+++ b/src/java.base/windows/native/launcher/java.manifest	Mon Jun 22 13:28:57 2015 -0700
@@ -52,6 +52,8 @@
         <supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/>
         <!-- Windows 8.1 -->
         <supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/>
+        <!-- Windows 10 -->
+        <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
       </application>
     </compatibility>
 
--- a/src/java.base/windows/native/libjava/java_props_md.c	Thu Jun 04 18:28:52 2015 +0200
+++ b/src/java.base/windows/native/libjava/java_props_md.c	Mon Jun 22 13:28:57 2015 -0700
@@ -351,8 +351,8 @@
 GetJavaProperties(JNIEnv* env)
 {
     static java_props_t sprops = {0};
-
-    OSVERSIONINFOEX ver;
+    int majorVersion;
+    int minorVersion;
 
     if (sprops.line_separator) {
         return &sprops;
@@ -383,21 +383,65 @@
     /* OS properties */
     {
         char buf[100];
-        SYSTEM_INFO si;
-        PGNSI pGNSI;
+        boolean is_workstation;
+        boolean is_64bit;
+        DWORD platformId;
+        {
+            OSVERSIONINFOEX ver;
+            ver.dwOSVersionInfoSize = sizeof(ver);
+            GetVersionEx((OSVERSIONINFO *) &ver);
+            majorVersion = ver.dwMajorVersion;
+            minorVersion = ver.dwMinorVersion;
+            is_workstation = (ver.wProductType == VER_NT_WORKSTATION);
+            platformId = ver.dwPlatformId;
+            sprops.patch_level = _strdup(ver.szCSDVersion);
+        }
 
-        ver.dwOSVersionInfoSize = sizeof(ver);
-        GetVersionEx((OSVERSIONINFO *) &ver);
+        {
+            SYSTEM_INFO si;
+            ZeroMemory(&si, sizeof(SYSTEM_INFO));
+            GetNativeSystemInfo(&si);
 
-        ZeroMemory(&si, sizeof(SYSTEM_INFO));
-        // Call GetNativeSystemInfo if supported or GetSystemInfo otherwise.
-        pGNSI = (PGNSI) GetProcAddress(
-                GetModuleHandle(TEXT("kernel32.dll")),
-                "GetNativeSystemInfo");
-        if(NULL != pGNSI)
-            pGNSI(&si);
-        else
-            GetSystemInfo(&si);
+            is_64bit = (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64);
+        }
+        do {
+            // Read the major and minor version number from kernel32.dll
+            VS_FIXEDFILEINFO *file_info;
+            WCHAR kernel32_path[MAX_PATH];
+            UINT len, ret;
+
+            // Get the full path to \Windows\System32\kernel32.dll and use that for
+            // determining what version of Windows we're running on.
+            len = MAX_PATH - (UINT)strlen("\\kernel32.dll") - 1;
+            ret = GetSystemDirectoryW(kernel32_path, len);
+            if (ret == 0 || ret > len) {
+                break;
+            }
+            wcsncat(kernel32_path, L"\\kernel32.dll", MAX_PATH - ret);
+
+            DWORD version_size = GetFileVersionInfoSizeW(kernel32_path, NULL);
+            if (version_size == 0) {
+                break;
+            }
+
+            LPTSTR version_info = (LPTSTR)malloc(version_size);
+            if (version_info == NULL) {
+                break;
+            }
+
+            if (!GetFileVersionInfoW(kernel32_path, 0, version_size, version_info)) {
+                free(version_info);
+                break;
+            }
+
+            if (!VerQueryValueW(version_info, L"\\", (LPVOID*)&file_info, &len)) {
+                free(version_info);
+                break;
+            }
+            majorVersion = HIWORD(file_info->dwProductVersionMS);
+            minorVersion = LOWORD(file_info->dwProductVersionMS);
+            free(version_info);
+        } while (0);
 
         /*
          * From msdn page on OSVERSIONINFOEX, current as of this
@@ -423,17 +467,15 @@
          * Windows Server 2008 R2       6               1  (!VER_NT_WORKSTATION)
          * Windows 8                    6               2  (VER_NT_WORKSTATION)
          * Windows Server 2012          6               2  (!VER_NT_WORKSTATION)
+         * Windows 10                   10              0  (VER_NT_WORKSTATION)
          *
          * This mapping will presumably be augmented as new Windows
          * versions are released.
          */
-        switch (ver.dwPlatformId) {
-        case VER_PLATFORM_WIN32s:
-            sprops.os_name = "Windows 3.1";
-            break;
+        switch (platformId) {
         case VER_PLATFORM_WIN32_WINDOWS:
-           if (ver.dwMajorVersion == 4) {
-                switch (ver.dwMinorVersion) {
+           if (majorVersion == 4) {
+                switch (minorVersion) {
                 case  0: sprops.os_name = "Windows 95";           break;
                 case 10: sprops.os_name = "Windows 98";           break;
                 case 90: sprops.os_name = "Windows Me";           break;
@@ -444,10 +486,10 @@
             }
             break;
         case VER_PLATFORM_WIN32_NT:
-            if (ver.dwMajorVersion <= 4) {
+            if (majorVersion <= 4) {
                 sprops.os_name = "Windows NT";
-            } else if (ver.dwMajorVersion == 5) {
-                switch (ver.dwMinorVersion) {
+            } else if (majorVersion == 5) {
+                switch (minorVersion) {
                 case  0: sprops.os_name = "Windows 2000";         break;
                 case  1: sprops.os_name = "Windows XP";           break;
                 case  2:
@@ -462,8 +504,7 @@
                     * If it is, the operating system is Windows XP 64 bit;
                     * otherwise, it is Windows Server 2003."
                     */
-                    if(ver.wProductType == VER_NT_WORKSTATION &&
-                       si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) {
+                    if (is_workstation && is_64bit) {
                         sprops.os_name = "Windows XP"; /* 64 bit */
                     } else {
                         sprops.os_name = "Windows 2003";
@@ -471,12 +512,12 @@
                     break;
                 default: sprops.os_name = "Windows NT (unknown)"; break;
                 }
-            } else if (ver.dwMajorVersion == 6) {
+            } else if (majorVersion == 6) {
                 /*
                  * See table in MSDN OSVERSIONINFOEX documentation.
                  */
-                if (ver.wProductType == VER_NT_WORKSTATION) {
-                    switch (ver.dwMinorVersion) {
+                if (is_workstation) {
+                    switch (minorVersion) {
                     case  0: sprops.os_name = "Windows Vista";        break;
                     case  1: sprops.os_name = "Windows 7";            break;
                     case  2: sprops.os_name = "Windows 8";            break;
@@ -484,7 +525,7 @@
                     default: sprops.os_name = "Windows NT (unknown)";
                     }
                 } else {
-                    switch (ver.dwMinorVersion) {
+                    switch (minorVersion) {
                     case  0: sprops.os_name = "Windows Server 2008";    break;
                     case  1: sprops.os_name = "Windows Server 2008 R2"; break;
                     case  2: sprops.os_name = "Windows Server 2012";    break;
@@ -492,6 +533,17 @@
                     default: sprops.os_name = "Windows NT (unknown)";
                     }
                 }
+            } else if (majorVersion == 10) {
+                if (is_workstation) {
+                    switch (minorVersion) {
+                    case  0: sprops.os_name = "Windows 10";           break;
+                    default: sprops.os_name = "Windows NT (unknown)";
+                    }
+                } else {
+                    switch (minorVersion) {
+                    default: sprops.os_name = "Windows NT (unknown)";
+                    }
+                }
             } else {
                 sprops.os_name = "Windows NT (unknown)";
             }
@@ -500,7 +552,7 @@
             sprops.os_name = "Windows (unknown)";
             break;
         }
-        sprintf(buf, "%d.%d", ver.dwMajorVersion, ver.dwMinorVersion);
+        sprintf(buf, "%d.%d", majorVersion, minorVersion);
         sprops.os_version = _strdup(buf);
 #if _M_IA64
         sprops.os_arch = "ia64";
@@ -511,9 +563,6 @@
 #else
         sprops.os_arch = "unknown";
 #endif
-
-        sprops.patch_level = _strdup(ver.szCSDVersion);
-
         sprops.desktop = "windows";
     }
 
@@ -624,7 +673,7 @@
                            &display_encoding);
 
             sprops.sun_jnu_encoding = getEncodingInternal(systemDefaultLCID);
-            if (LANGIDFROMLCID(userDefaultLCID) == 0x0c04 && ver.dwMajorVersion == 6) {
+            if (LANGIDFROMLCID(userDefaultLCID) == 0x0c04 && majorVersion == 6) {
                 // MS claims "Vista has built-in support for HKSCS-2004.
                 // All of the HKSCS-2004 characters have Unicode 4.1.
                 // PUA code point assignments". But what it really means
--- a/test/java/lang/ProcessHandle/OnExitTest.java	Thu Jun 04 18:28:52 2015 +0200
+++ b/test/java/lang/ProcessHandle/OnExitTest.java	Mon Jun 22 13:28:57 2015 -0700
@@ -26,21 +26,17 @@
 import java.time.Duration;
 import java.time.Instant;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutionException;
-import java.util.stream.Collectors;
-import jdk.testlibrary.Platform;
 import org.testng.annotations.Test;
 import org.testng.Assert;
 import org.testng.TestNG;
 
 /*
  * @test
- * @library /lib/testlibrary
  * @summary Functions of Process.onExit and ProcessHandle.onExit
  * @author Roger Riggs
  */
--- a/test/java/lang/SecurityManager/CheckPackageAccess.java	Thu Jun 04 18:28:52 2015 +0200
+++ b/test/java/lang/SecurityManager/CheckPackageAccess.java	Mon Jun 22 13:28:57 2015 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 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
@@ -29,12 +29,9 @@
  *  @run main/othervm CheckPackageAccess
  */
 
-import java.security.Security;
 import java.util.Collections;
-import java.util.Arrays;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.StringTokenizer;
 
 /*
  * The main benefit of this test is to catch merge errors or other types
@@ -44,60 +41,12 @@
  */
 public class CheckPackageAccess {
 
-    /*
-     * This array should be updated whenever new packages are added to the
-     * package.access property in the java.security file
-     * NOTE: it should be in the same order as the java.security file
-     */
-    private static final String[] packages = {
-        "sun.",
-        "com.sun.xml.internal.",
-        "com.sun.imageio.",
-        "com.sun.istack.internal.",
-        "com.sun.jmx.",
-        "com.sun.media.sound.",
-        "com.sun.naming.internal.",
-        "com.sun.proxy.",
-        "com.sun.corba.se.",
-        "com.sun.org.apache.bcel.internal.",
-        "com.sun.org.apache.regexp.internal.",
-        "com.sun.org.apache.xerces.internal.",
-        "com.sun.org.apache.xpath.internal.",
-        "com.sun.org.apache.xalan.internal.extensions.",
-        "com.sun.org.apache.xalan.internal.lib.",
-        "com.sun.org.apache.xalan.internal.res.",
-        "com.sun.org.apache.xalan.internal.templates.",
-        "com.sun.org.apache.xalan.internal.utils.",
-        "com.sun.org.apache.xalan.internal.xslt.",
-        "com.sun.org.apache.xalan.internal.xsltc.cmdline.",
-        "com.sun.org.apache.xalan.internal.xsltc.compiler.",
-        "com.sun.org.apache.xalan.internal.xsltc.trax.",
-        "com.sun.org.apache.xalan.internal.xsltc.util.",
-        "com.sun.org.apache.xml.internal.res.",
-        "com.sun.org.apache.xml.internal.security.",
-        "com.sun.org.apache.xml.internal.serializer.utils.",
-        "com.sun.org.apache.xml.internal.utils.",
-        "com.sun.org.glassfish.",
-        "com.sun.tools.script.",
-        "com.oracle.xmlns.internal.",
-        "com.oracle.webservices.internal.",
-        "org.jcp.xml.dsig.internal.",
-        "jdk.internal.",
-        "jdk.nashorn.internal.",
-        "jdk.nashorn.tools.",
-        "jdk.tools.jimage.",
-        "com.sun.activation.registries."
-    };
+    public static void main(String[] args) throws Exception {
+        // get expected list of restricted packages
+        List<String> pkgs = RestrictedPackages.expected();
 
-    public static void main(String[] args) throws Exception {
-        List<String> pkgs = new ArrayList<>(Arrays.asList(packages));
-        String osName = System.getProperty("os.name");
-        if (osName.contains("OS X")) {
-            pkgs.add("apple.");  // add apple package for OS X
-        }
-
-        List<String> jspkgs =
-            getPackages(Security.getProperty("package.access"));
+        // get actual list of restricted packages
+        List<String> jspkgs = RestrictedPackages.actual();
 
         if (!isOpenJDKOnly()) {
             String lastPkg = pkgs.get(pkgs.size() - 1);
@@ -127,7 +76,7 @@
         }
         System.setSecurityManager(new SecurityManager());
         SecurityManager sm = System.getSecurityManager();
-        for (String pkg : packages) {
+        for (String pkg : pkgs) {
             String subpkg = pkg + "foo";
             try {
                 sm.checkPackageAccess(pkg);
@@ -153,18 +102,6 @@
         System.out.println("Test passed");
     }
 
-    private static List<String> getPackages(String p) {
-        List<String> packages = new ArrayList<>();
-        if (p != null && !p.equals("")) {
-            StringTokenizer tok = new StringTokenizer(p, ",");
-            while (tok.hasMoreElements()) {
-                String s = tok.nextToken().trim();
-                packages.add(s);
-            }
-        }
-        return packages;
-    }
-
     private static boolean isOpenJDKOnly() {
         String prop = System.getProperty("java.runtime.name");
         return prop != null && prop.startsWith("OpenJDK");
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/java/lang/SecurityManager/CheckPackageMatching.java	Mon Jun 22 13:28:57 2015 -0700
@@ -0,0 +1,545 @@
+/*
+ * 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.
+ */
+
+/*
+ * @test
+ * @bug 8072692
+ * @summary Check the matching implemented by SecurityManager.checkPackageAccess
+ * @run main/othervm CheckPackageMatching
+ */
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+/*
+ * The purpose of this test is not to verify the content of the package
+ * access list - but to ensure that the matching implemented by the
+ * SecurityManager is correct. This is why we have our own pattern matching
+ * algorithm here.
+ */
+public class CheckPackageMatching {
+
+    /**
+     * The restricted packages listed in the package.access property of the
+     * java.security file.
+     */
+    private static final String[] packages =
+        RestrictedPackages.actual().toArray(new String[0]);
+
+    private static final boolean OPEN_JDK = isOpenJDKOnly();
+
+    /**
+     * PackageMatcher implements a state machine that matches package
+     * names against packages parsed from the package access list.
+     */
+    private static abstract class PackageMatcher {
+        // For each state, chars[state] contains the chars that matches.
+        private final char[][] chars;
+        // For each state, states[state][i] contains the next state to go
+        // to when chars[state][i] matches the current character.
+        private final int[][] states;
+
+        // Some markers. We're making the assumption that 0
+        // cannot be a valid character for a package name.
+        //
+        // We use 0 for marking that we expect an end of string in
+        // char[state][i].
+        private static final char END_OF_STRING = 0;
+        // This special state value indicates that we expect the string to end
+        // there.
+        private static final int END_STATE = -1;
+        // This special state value indicates that we can accept any character
+        // from now on.
+        private static final int WILDCARD_STATE = Integer.MIN_VALUE;
+
+        // Create the data for a new state machine to match package names from
+        // the array of package names passed as argument.
+        // Each package name in the array is expected to end with '.'
+        // For each package in packages we're going to compile state data
+        // that will match the regexp:
+        // ^packages[i].substring(0, packages[i].length()-1).replace(".","\\.")$|^packages[i].replace(".","\\.").*
+        //
+        // Let's say the package array is:
+        //
+        // String[] packages = { "sun.", "com.sun.jmx.", "com.sun.proxy.",
+        //                       "apple." };
+        //
+        // then the state machine will need data that looks like:
+        //
+        // char[][] chars = {
+        //    { 'a', 'c', 's' }, { 'p' }, { 'p' }, { 'l' }, { 'e' }, { 0, '.' },
+        //    { 'o' }, { 'm' }, { '.' }, { 's' }, { 'u' }, { 'n' }, { '.' },
+        //    { 'j', 'p'},
+        //    { 'm' }, { 'x' }, { 0, '.' },
+        //    { 'r' }, { 'o' }, { 'x' }, { 'y' }, { 0, '.' },
+        //    { 'u' }, { 'n' }, { 0, '.' }
+        // }
+        // int[][] states = {
+        //    { 1, 6, 22 }, { 2 }, { 3 }, { 4 }, { 5 },
+        //    { END_STATE, WILDCARD_STATE },
+        //    { 7 }, { 8 }, { 9 }, { 10 }, { 11 }, { 12 }, { 13 }, { 14, 17 },
+        //    { 15 }, { 16 }, { END_STATE, WILDCARD_STATE },
+        //    { 18 }, { 19 }, { 20 }, { 21 }, { END_STATE, WILDCARD_STATE },
+        //    { 23 }, { 24 }, { END_STATE, WILDCARD_STATE }
+        // }
+        //
+        // The machine will start by loading the chars and states for state 0
+        // chars[0] => { 'a', 'c', 's' } states[0] => { 1, 6, 22 }
+        // then it examines the char at index 0 in the candidate name.
+        // if the char matches one of the characters in chars[0], then it goes
+        // to the corresponding state in states[0]. For instance - if the first
+        // char in the candidate name is 's', which corresponds to chars[0][2] -
+        // then it will proceed with the next char in the candidate name and go
+        // to state 22 (as indicated by states[0][2]) - where it will load the
+        // chars and states for states 22: chars[22] = { 'u' },
+        // states[22] = { 23 } etc... until the candidate char at the current
+        // index matches no char in chars[states] => the candidate name doesn't
+        // match - or until it finds a success termination condition: the
+        // candidate chars are exhausted and states[state][0] is END_STATE, or
+        // the candidate chars are not exhausted - and
+        // states[state][chars[state]] is WILDCARD_STATE indicating a '.*' like
+        // regexp.
+        //
+        // [Note that the chars in chars[i] are sorted]
+        //
+        // The compile(...) method is reponsible for building the state machine
+        // data and is called only once in the constructor.
+        //
+        // The matches(String candidate) method will tell whether the candidate
+        // matches by implementing the algorithm described above.
+        //
+        PackageMatcher(String[] packages) {
+            final boolean[] selected = new boolean[packages.length];
+            Arrays.fill(selected, true);
+            final ArrayList<char[]> charList = new ArrayList<>();
+            final ArrayList<int[]> stateList = new ArrayList<>();
+            compile(0, 0, packages, selected, charList, stateList);
+            chars = charList.toArray(new char[0][0]);
+            states = stateList.toArray(new int[0][0]);
+        }
+
+        /**
+         * Compiles the state machine data (recursive).
+         *
+         * @param step  The index of the character which we're looking at in
+         *              this step.
+         * @param state The current state (starts at 0).
+         * @param pkgs  The list of packages from which the automaton is built.
+         * @param selected  Indicates which packages we're looking at in this
+                            step.
+         * @param charList  The list from which we will build
+                            {@code char[][] chars;}
+         * @param stateList The list from which we will build
+                            {@code int[][]  states;}
+         * @return the next available state.
+         */
+        private int compile(int step, int state, String[] pkgs,
+                            boolean[] selected, ArrayList<char[]> charList,
+                            ArrayList<int[]> stateList) {
+            final char[] next = new char[pkgs.length];
+            final int[] nexti = new int[pkgs.length];
+            int j = 0;
+            char min = Character.MAX_VALUE; char max = 0;
+            for (int i = 0; i < pkgs.length; i++) {
+                if (!selected[i]) continue;
+                final String p = pkgs[i];
+                final int len = p.length();
+                if (step > len) {
+                    selected[i] = false;
+                    continue;
+                }
+                if (len - 1 == step) {
+                    boolean unknown = true;
+                    for (int k = 0; k < j ; k++) {
+                        if (next[k] == END_OF_STRING) {
+                            unknown = false;
+                            break;
+                        }
+                    }
+                    if (unknown) {
+                        next[j] = END_OF_STRING;
+                        j++;
+                    }
+                    nexti[i] = END_STATE;
+                }
+                final char c = p.charAt(step);
+                nexti[i] = len - 1 == step ? END_STATE : c;
+                boolean unknown = j == 0 || c < min || c > max;
+                if (!unknown) {
+                    if (c != min || c != max) {
+                        unknown = true;
+                        for (int k = 0; k < j ; k++) {
+                            if (next[k] == c) {
+                                unknown = false;
+                                break;
+                            }
+                        }
+                    }
+                }
+                if (unknown) {
+                    min = min > c ? c : min;
+                    max = max < c ? c : max;
+                    next[j] = c;
+                    j++;
+                }
+            }
+            final char[] nc = new char[j];
+            final int[]  nst = new int[j];
+            System.arraycopy(next, 0, nc, 0, nc.length);
+            Arrays.sort(nc);
+            final boolean ns[] = new boolean[pkgs.length];
+
+            charList.ensureCapacity(state + 1);
+            stateList.ensureCapacity(state + 1);
+            charList.add(state, nc);
+            stateList.add(state, nst);
+            state = state + 1;
+            for (int k = 0; k < nc.length; k++) {
+                int selectedCount = 0;
+                boolean endStateFound = false;
+                boolean wildcardFound = false;
+                for (int l = 0; l < nexti.length; l++) {
+                    if (!(ns[l] = selected[l])) {
+                        continue;
+                    }
+                    ns[l] = nexti[l] == nc[k] || nexti[l] == END_STATE
+                            && nc[k] == '.';
+                    endStateFound = endStateFound || nc[k] == END_OF_STRING
+                                    && nexti[l] == END_STATE;
+                    wildcardFound = wildcardFound || nc[k] == '.'
+                                    && nexti[l] == END_STATE;
+                    if (ns[l]) {
+                        selectedCount++;
+                    }
+                }
+                nst[k] = (endStateFound ? END_STATE
+                         : wildcardFound ? WILDCARD_STATE : state);
+                if (selectedCount == 0 || wildcardFound) {
+                    continue;
+                }
+                state = compile(step + 1, state, pkgs, ns, charList, stateList);
+            }
+            return state;
+        }
+
+        /**
+         * Matches 'pkg' against the list of package names compiled in the
+         * state machine data.
+         *
+         * @param pkg The package name to match. Must not end with '.'.
+         * @return true if the package name matches, false otherwise.
+         */
+        public boolean matches(String pkg) {
+            int state = 0;
+            int i;
+            final int len = pkg.length();
+            next: for (i = 0; i <= len; i++) {
+                if (state == WILDCARD_STATE) {
+                    return true; // all characters will match.
+                }
+                if (state == END_STATE) {
+                    return i == len;
+                }
+                final char[] ch = chars[state];
+                final int[] st = states[state];
+                if (i == len) {
+                    // matches only if we have exhausted the string.
+                    return st[0] == END_STATE;
+                }
+                if (st[0] == END_STATE && st.length == 1) {
+                    // matches only if we have exhausted the string.
+                    return i == len;
+                }
+                final char c = pkg.charAt(i); // look at next char...
+                for (int j = st[0] == END_STATE ? 1 : 0; j < ch.length; j++) {
+                    final char n = ch[j];
+                    if (c == n) {      // found a match
+                        state = st[j]; // get the next state.
+                        continue next; // go to next state
+                    } else if (c < n) {
+                        break; // chars are sorted. we won't find it. no match.
+                    }
+                }
+                break; // no match
+            }
+            return false;
+        }
+    }
+
+    private static final class TestPackageMatcher extends PackageMatcher {
+        private final List<String> list;
+
+        TestPackageMatcher(String[] packages) {
+            super(packages);
+            this.list = Collections.unmodifiableList(Arrays.asList(packages));
+        }
+
+        @Override
+        public boolean matches(String pkg) {
+            final boolean match1 = super.matches(pkg);
+            boolean match2 = false;
+            String p2 = pkg + ".";
+            for (String p : list) {
+                if (pkg.startsWith(p) || p2.equals(p)) {
+                    match2 = true;
+                    break;
+                }
+            }
+            if (match1 != match2) {
+                System.err.println("Test Bug: PackageMatcher.matches(\"" +
+                                   pkg + "\") returned " + match1);
+                System.err.println("Package Access List is: " + list);
+                throw new Error("Test Bug: PackageMatcher.matches(\"" +
+                                pkg + "\") returned " + match1);
+            }
+            return match1;
+        }
+    }
+
+    private static void smokeTest() {
+        // these checks should pass.
+        System.getSecurityManager().checkPackageAccess("com.sun.blah");
+        System.getSecurityManager().checkPackageAccess("com.sun.jm");
+        System.getSecurityManager().checkPackageAccess("com.sun.jmxa");
+        System.getSecurityManager().checkPackageAccess("jmx");
+        List<String> actual = Arrays.asList(packages);
+        for (String p : actual) {
+            if (!actual.contains(p)) {
+                System.err.println("Warning: '" + p + " not in package.access");
+            }
+        }
+        if (!actual.contains("sun.")) {
+            throw new Error("package.access does not contain 'sun.'");
+        }
+    }
+
+    // This is a sanity test for our own test code.
+    private static void testTheTest(String[] pkgs, char[][] chars,
+                                    int[][] states) {
+
+        PackageMatcher m = new TestPackageMatcher(pkgs);
+        String unexpected = "";
+        if (!Arrays.deepEquals(chars, m.chars)) {
+            System.err.println("Char arrays differ");
+            if (chars.length != m.chars.length) {
+                System.err.println("Char array lengths differ: expected="
+                        + chars.length + " actual=" + m.chars.length);
+            }
+            System.err.println(Arrays.deepToString(m.chars).replace((char)0,
+                                                   '0'));
+            unexpected = "chars[]";
+        }
+        if (!Arrays.deepEquals(states, m.states)) {
+            System.err.println("State arrays differ");
+            if (states.length != m.states.length) {
+                System.err.println("Char array lengths differ: expected="
+                        + states.length + " actual=" + m.states.length);
+            }
+            System.err.println(Arrays.deepToString(m.states));
+            if (unexpected.length() > 0) {
+                unexpected = unexpected + " and ";
+            }
+            unexpected = unexpected + "states[]";
+        }
+
+        if (unexpected.length() > 0) {
+            throw new Error("Unexpected "+unexpected+" in PackageMatcher");
+        }
+
+        testMatches(m, pkgs);
+    }
+
+    // This is a sanity test for our own test code.
+    private static void testTheTest() {
+        final String[] packages2 = { "sun.", "com.sun.jmx.",
+                                     "com.sun.proxy.", "apple." };
+
+        final int END_STATE = PackageMatcher.END_STATE;
+        final int WILDCARD_STATE = PackageMatcher.WILDCARD_STATE;
+
+        final char[][] chars2 = {
+            { 'a', 'c', 's' }, { 'p' }, { 'p' }, { 'l' }, { 'e' }, { 0, '.' },
+            { 'o' }, { 'm' }, { '.' }, { 's' }, { 'u' }, { 'n' }, { '.' },
+            { 'j', 'p'},
+            { 'm' }, { 'x' }, { 0, '.' },
+            { 'r' }, { 'o' }, { 'x' }, { 'y' }, { 0, '.' },
+            { 'u' }, { 'n' }, { 0, '.' }
+         };
+
+         final int[][] states2 = {
+            { 1, 6, 22 }, { 2 }, { 3 }, { 4 }, { 5 },
+            { END_STATE, WILDCARD_STATE },
+            { 7 }, { 8 }, { 9 }, { 10 }, { 11 }, { 12 }, { 13 }, { 14, 17 },
+            { 15 }, { 16 }, { END_STATE, WILDCARD_STATE },
+            { 18 }, { 19 }, { 20 }, { 21 }, { END_STATE, WILDCARD_STATE },
+            { 23 }, { 24 }, { END_STATE, WILDCARD_STATE }
+         };
+
+         testTheTest(packages2, chars2, states2);
+
+         final String[] packages3 = { "sun.", "com.sun.pro.",
+                                      "com.sun.proxy.", "apple." };
+
+         final char[][] chars3 = {
+            { 'a', 'c', 's' }, { 'p' }, { 'p' }, { 'l' }, { 'e' }, { 0, '.' },
+            { 'o' }, { 'm' }, { '.' }, { 's' }, { 'u' }, { 'n' }, { '.' },
+            { 'p' }, { 'r' }, { 'o' }, { 0, '.', 'x' },
+            { 'y' }, { 0, '.' },
+            { 'u' }, { 'n' }, { 0, '.' }
+         };
+
+         final int[][] states3 = {
+            { 1, 6, 19 }, { 2 }, { 3 }, { 4 }, { 5 },
+            { END_STATE, WILDCARD_STATE },
+            { 7 }, { 8 }, { 9 }, { 10 }, { 11 }, { 12 }, { 13 }, { 14 },
+            { 15 }, { 16 }, { END_STATE, WILDCARD_STATE, 17 },
+            { 18 }, { END_STATE, WILDCARD_STATE },
+            { 20 }, { 21 }, { END_STATE, WILDCARD_STATE }
+         };
+
+         testTheTest(packages3, chars3, states3);
+    }
+
+    private static volatile boolean sanityTesting = false;
+
+    public static void main(String[] args) {
+        System.setSecurityManager(new SecurityManager());
+
+        // Some smoke tests.
+        smokeTest();
+        System.out.println("Smoke tests passed.");
+
+        // Test our own pattern matching algorithm. Here we actually test
+        // the PackageMatcher class from our own test code.
+        sanityTesting = true;
+        try {
+            testTheTest();
+            System.out.println("Sanity tests passed.");
+        } finally {
+            sanityTesting = false;
+        }
+
+        // Now test the package matching in the security manager.
+        PackageMatcher matcher = new TestPackageMatcher(packages);
+
+        // These should not match.
+        for (String pkg : new String[] {"gloups.machin", "su",
+                                        "org.jcp.xml.dsig.interna",
+                                        "com.sun.jm", "com.sun.jmxa"}) {
+            testMatch(matcher, pkg, false, true);
+        }
+
+        // These should match.
+        for (String pkg : Arrays.asList(
+                new String[] {"sun.gloups.machin", "sun", "sun.com",
+                              "com.sun.jmx", "com.sun.jmx.a",
+                              "org.jcp.xml.dsig.internal",
+                              "org.jcp.xml.dsig.internal.foo"})) {
+            testMatch(matcher, pkg, true, true);
+        }
+
+        // Derive a list of packages that should match or not match from
+        // the list in 'packages' - and check that the security manager
+        // throws the appropriate exception.
+        testMatches(matcher, packages);
+    }
+
+    private static void testMatches(PackageMatcher matcher, String[] pkgs) {
+        Collection<String> pkglist = Arrays.asList(pkgs);
+        PackageMatcher ref = new TestPackageMatcher(packages);
+
+        for (String pkg : pkgs) {
+            String candidate = pkg + "toto";
+            boolean expected = true;
+            testMatch(matcher, candidate, expected,
+                      ref.matches(candidate) == expected);
+        }
+
+        for (String pkg : pkgs) {
+            String candidate = pkg.substring(0, pkg.length() - 1);
+            boolean expected = pkglist.contains(candidate + ".");
+            testMatch(matcher, candidate, expected,
+                      ref.matches(candidate) == expected);
+        }
+
+        for (String pkg : pkgs) {
+            if (!OPEN_JDK && pkg.equals("com.sun.media.sound.")) {
+                // don't test com.sun.media.sound since there is an entry
+                // for com.sun.media in non OpenJDK builds. Otherwise,
+                // the test for this package will fail unexpectedly.
+                continue;
+            }
+            String candidate = pkg.substring(0, pkg.length() - 2);
+            boolean expected = pkglist.contains(candidate + ".");
+            testMatch(matcher, candidate, expected,
+                      ref.matches(candidate) == expected);
+        }
+    }
+
+    private static void testMatch(PackageMatcher matcher, String candidate,
+                                  boolean expected, boolean testSecurityManager)
+    {
+        final boolean m = matcher.matches(candidate);
+        if (m != expected) {
+            final String msg = "\"" + candidate + "\": " +
+                (m ? "matches" : "does not match");
+            throw new Error("PackageMatcher does not give expected results: "
+                            + msg);
+        }
+
+        if (sanityTesting) {
+            testSecurityManager = false;
+        }
+
+        if (testSecurityManager) {
+            System.out.println("Access to " + candidate + " should be " +
+                               (expected ? "rejected" : "granted"));
+            final String errormsg = "\"" + candidate + "\" : " +
+                (expected ? "granted" : "not granted");
+            try {
+                System.getSecurityManager().checkPackageAccess(candidate);
+                if (expected) {
+                    System.err.println(errormsg);
+                    throw new Error("Expected exception not thrown: " +
+                                    errormsg);
+                }
+            } catch (SecurityException x) {
+                if (!expected) {
+                    System.err.println(errormsg);
+                    throw new Error(errormsg + " - unexpected exception: " +
+                                    x, x);
+                } else {
+                    System.out.println("Got expected exception: " + x);
+                }
+            }
+        }
+    }
+
+    private static boolean isOpenJDKOnly() {
+        String prop = System.getProperty("java.runtime.name");
+        return prop != null && prop.startsWith("OpenJDK");
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/java/lang/SecurityManager/RestrictedPackages.java	Mon Jun 22 13:28:57 2015 -0700
@@ -0,0 +1,150 @@
+/*
+ * 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.
+ */
+
+import java.security.Security;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.StringTokenizer;
+
+/**
+ * A collection of utility methods and constants for testing the package
+ * access and package definition security checks.
+ */
+final class RestrictedPackages {
+
+    /*
+     * The expected list of restricted packages.
+     *
+     * This array should be updated whenever new packages are added to the
+     * package.access property in the java.security file
+     * NOTE: it should be in the same order as the java.security file
+     */
+    static final String[] EXPECTED = {
+        "sun.",
+        "com.sun.xml.internal.",
+        "com.sun.imageio.",
+        "com.sun.istack.internal.",
+        "com.sun.jmx.",
+        "com.sun.media.sound.",
+        "com.sun.naming.internal.",
+        "com.sun.proxy.",
+        "com.sun.corba.se.",
+        "com.sun.org.apache.bcel.internal.",
+        "com.sun.org.apache.regexp.internal.",
+        "com.sun.org.apache.xerces.internal.",
+        "com.sun.org.apache.xpath.internal.",
+        "com.sun.org.apache.xalan.internal.extensions.",
+        "com.sun.org.apache.xalan.internal.lib.",
+        "com.sun.org.apache.xalan.internal.res.",
+        "com.sun.org.apache.xalan.internal.templates.",
+        "com.sun.org.apache.xalan.internal.utils.",
+        "com.sun.org.apache.xalan.internal.xslt.",
+        "com.sun.org.apache.xalan.internal.xsltc.cmdline.",
+        "com.sun.org.apache.xalan.internal.xsltc.compiler.",
+        "com.sun.org.apache.xalan.internal.xsltc.trax.",
+        "com.sun.org.apache.xalan.internal.xsltc.util.",
+        "com.sun.org.apache.xml.internal.res.",
+        "com.sun.org.apache.xml.internal.security.",
+        "com.sun.org.apache.xml.internal.serializer.utils.",
+        "com.sun.org.apache.xml.internal.utils.",
+        "com.sun.org.glassfish.",
+        "com.sun.tools.script.",
+        "com.oracle.xmlns.internal.",
+        "com.oracle.webservices.internal.",
+        "org.jcp.xml.dsig.internal.",
+        "jdk.internal.",
+        "jdk.nashorn.internal.",
+        "jdk.nashorn.tools.",
+        "jdk.tools.jimage.",
+        "com.sun.activation.registries."
+    };
+
+    /*
+     * A non-exhaustive list of restricted packages.
+     *
+     * Contrary to what is in the EXPECTED list, this list does not need
+     * to be exhaustive.
+     */
+    static final String[] EXPECTED_NONEXHAUSTIVE = {
+        "sun.",
+        "com.sun.xml.internal.",
+        "com.sun.imageio.",
+        "com.sun.istack.internal.",
+        "com.sun.jmx.",
+        "com.sun.proxy.",
+        "com.sun.org.apache.bcel.internal.",
+        "com.sun.org.apache.regexp.internal.",
+        "com.sun.org.apache.xerces.internal.",
+        "com.sun.org.apache.xpath.internal.",
+        "com.sun.org.apache.xalan.internal.extensions.",
+        "com.sun.org.apache.xalan.internal.lib.",
+        "com.sun.org.apache.xalan.internal.res.",
+        "com.sun.org.apache.xalan.internal.templates.",
+        "com.sun.org.apache.xalan.internal.utils.",
+        "com.sun.org.apache.xalan.internal.xslt.",
+        "com.sun.org.apache.xalan.internal.xsltc.cmdline.",
+        "com.sun.org.apache.xalan.internal.xsltc.compiler.",
+        "com.sun.org.apache.xalan.internal.xsltc.trax.",
+        "com.sun.org.apache.xalan.internal.xsltc.util.",
+        "com.sun.org.apache.xml.internal.res.",
+        "com.sun.org.apache.xml.internal.serializer.utils.",
+        "com.sun.org.apache.xml.internal.utils.",
+        "com.sun.org.apache.xml.internal.security.",
+        "com.sun.org.glassfish.",
+        "org.jcp.xml.dsig.internal."
+    };
+
+    private static final String OS_NAME = System.getProperty("os.name");
+
+    /**
+     * Returns a list of expected restricted packages, including any
+     * OS specific packages. The returned list is mutable.
+     */
+    static List<String> expected() {
+        List<String> pkgs = new ArrayList<>(Arrays.asList(EXPECTED));
+        if (OS_NAME.contains("OS X")) {
+            pkgs.add("apple.");  // add apple package for OS X
+        }
+        return pkgs;
+    }
+
+    /**
+     * Returns a list of actual restricted packages. The returned list
+     * is mutable.
+     */
+    static List<String> actual() {
+        String prop = Security.getProperty("package.access");
+        List<String> packages = new ArrayList<>();
+        if (prop != null && !prop.equals("")) {
+            StringTokenizer tok = new StringTokenizer(prop, ",");
+            while (tok.hasMoreElements()) {
+                String s = tok.nextToken().trim();
+                packages.add(s);
+            }
+        }
+        return packages;
+    }
+
+    private RestrictedPackages() { }
+}
--- a/test/java/lang/invoke/LFCaching/LFCachingTestCase.java	Thu Jun 04 18:28:52 2015 +0200
+++ b/test/java/lang/invoke/LFCaching/LFCachingTestCase.java	Mon Jun 22 13:28:57 2015 -0700
@@ -77,7 +77,7 @@
             }
         } catch (IllegalAccessException | IllegalArgumentException |
                 SecurityException | InvocationTargetException ex) {
-            throw new Error("Unexpected exception: ", ex);
+            throw new Error("Unexpected exception", ex);
         }
     }
 }
--- a/test/java/lang/invoke/LFCaching/LFGarbageCollectedTest.java	Thu Jun 04 18:28:52 2015 +0200
+++ b/test/java/lang/invoke/LFCaching/LFGarbageCollectedTest.java	Mon Jun 22 13:28:57 2015 -0700
@@ -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);
         }
     }
 
--- a/test/java/lang/invoke/LFCaching/LFMultiThreadCachingTest.java	Thu Jun 04 18:28:52 2015 +0200
+++ b/test/java/lang/invoke/LFCaching/LFMultiThreadCachingTest.java	Mon Jun 22 13:28:57 2015 -0700
@@ -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);
         }
--- a/test/java/lang/invoke/LFCaching/LFSingleThreadCachingTest.java	Thu Jun 04 18:28:52 2015 +0200
+++ b/test/java/lang/invoke/LFCaching/LFSingleThreadCachingTest.java	Mon Jun 22 13:28:57 2015 -0700
@@ -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);
     }
--- a/test/java/lang/invoke/LFCaching/LambdaFormTestCase.java	Thu Jun 04 18:28:52 2015 +0200
+++ b/test/java/lang/invoke/LFCaching/LambdaFormTestCase.java	Mon Jun 22 13:28:57 2015 -0700
@@ -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();
--- a/test/java/lang/invoke/MethodHandles/CatchExceptionTest.java	Thu Jun 04 18:28:52 2015 +0200
+++ b/test/java/lang/invoke/MethodHandles/CatchExceptionTest.java	Mon Jun 22 13:28:57 2015 -0700
@@ -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<>(
--- a/test/java/lang/invoke/MethodHandlesTest.java	Thu Jun 04 18:28:52 2015 +0200
+++ b/test/java/lang/invoke/MethodHandlesTest.java	Mon Jun 22 13:28:57 2015 -0700
@@ -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();
--- a/test/java/lang/invoke/TestCatchExceptionWithVarargs.java	Thu Jun 04 18:28:52 2015 +0200
+++ b/test/java/lang/invoke/TestCatchExceptionWithVarargs.java	Mon Jun 22 13:28:57 2015 -0700
@@ -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);
 
--- a/test/java/lang/invoke/VarargsArrayTest.java	Thu Jun 04 18:28:52 2015 +0200
+++ b/test/java/lang/invoke/VarargsArrayTest.java	Mon Jun 22 13:28:57 2015 -0700
@@ -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();
--- a/test/java/nio/channels/DatagramChannel/EmptyBuffer.java	Thu Jun 04 18:28:52 2015 +0200
+++ b/test/java/nio/channels/DatagramChannel/EmptyBuffer.java	Mon Jun 22 13:28:57 2015 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 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
@@ -27,39 +27,50 @@
  * @author Mike McCloskey
  */
 
-import java.io.*;
-import java.net.*;
-import java.nio.*;
-import java.nio.channels.*;
-import java.nio.charset.*;
+import java.io.IOException;
+import java.io.PrintStream;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.channels.ClosedByInterruptException;
+import java.nio.channels.DatagramChannel;
 
 public class EmptyBuffer {
 
-    static PrintStream log = System.err;
+    private static final PrintStream log = System.err;
 
     public static void main(String[] args) throws Exception {
         test();
     }
 
-    static void test() throws Exception {
-        Server server = new Server();
+    private static void test() throws Exception {
+        DatagramChannel dc = DatagramChannel.open();
+        InetAddress localHost = InetAddress.getLocalHost();
+        dc.bind(new InetSocketAddress(localHost, 0));
+
+        Server server = new Server(dc.getLocalAddress());
         Thread serverThread = new Thread(server);
         serverThread.start();
-        DatagramChannel dc = DatagramChannel.open();
+
         try {
+            InetSocketAddress isa = new InetSocketAddress(localHost, server.port());
+            dc.connect(isa);
+
             ByteBuffer bb = ByteBuffer.allocateDirect(12);
             bb.order(ByteOrder.BIG_ENDIAN);
             bb.putInt(1).putLong(1);
             bb.flip();
-            InetAddress address = InetAddress.getLocalHost();
-            InetSocketAddress isa = new InetSocketAddress(address, server.port());
-            dc.connect(isa);
+
             dc.write(bb);
             bb.rewind();
             dc.write(bb);
             bb.rewind();
             dc.write(bb);
+
             Thread.sleep(2000);
+
             serverThread.interrupt();
             server.throwException();
         } finally {
@@ -67,12 +78,14 @@
         }
     }
 
-    public static class Server implements Runnable {
-        final DatagramChannel dc;
-        Exception e = null;
+    private static class Server implements Runnable {
+        private final DatagramChannel dc;
+        private final SocketAddress clientAddress;
+        private Exception e = null;
 
-        Server() throws IOException {
+        Server(SocketAddress clientAddress) throws IOException {
             this.dc = DatagramChannel.open().bind(new InetSocketAddress(0));
+            this.clientAddress = clientAddress;
         }
 
         int port() {
@@ -94,30 +107,37 @@
             log.println();
         }
 
+        @Override
         public void run() {
-            SocketAddress sa = null;
-            int numberReceived = 0;
             try {
                 ByteBuffer bb = ByteBuffer.allocateDirect(12);
                 bb.clear();
                 // Only one clear. The buffer will be full after
                 // the first receive, but it should still block
                 // and receive and discard the next two
+                int numberReceived = 0;
                 while (!Thread.interrupted()) {
+                    SocketAddress sa;
                     try {
                         sa = dc.receive(bb);
                     } catch (ClosedByInterruptException cbie) {
                         // Expected
                         log.println("Took expected exit");
+                        // Verify that enough packets were received
+                        if (numberReceived != 3)
+                            throw new RuntimeException("Failed: Too few datagrams");
                         break;
                     }
                     if (sa != null) {
                         log.println("Client: " + sa);
-                        showBuffer("RECV", bb);
+                        // Check client address so as not to count stray packets
+                        if (sa.equals(clientAddress)) {
+                            showBuffer("RECV", bb);
+                            numberReceived++;
+                        }
+                        if (numberReceived > 3)
+                            throw new RuntimeException("Failed: Too many datagrams");
                         sa = null;
-                        numberReceived++;
-                        if (numberReceived > 3)
-                            throw new RuntimeException("Test failed");
                     }
                 }
             } catch (Exception ex) {
@@ -127,5 +147,4 @@
             }
         }
     }
-
 }
--- a/test/java/nio/file/Files/CopyAndMove.java	Thu Jun 04 18:28:52 2015 +0200
+++ b/test/java/nio/file/Files/CopyAndMove.java	Mon Jun 22 13:28:57 2015 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2008, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2008, 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,9 +23,9 @@
 
 /* @test
  * @bug 4313887 6838333 6917021 7006126 6950237 8006645
- * @summary Unit test for java.nio.file.Files copy and move methods
- * @library ..
- * @build CopyAndMove PassThroughFileSystem
+ * @summary Unit test for java.nio.file.Files copy and move methods (use -Dseed=X to set PRNG seed)
+ * @library .. /lib/testlibrary/
+ * @build jdk.testlibrary.* CopyAndMove PassThroughFileSystem
  * @run main/othervm CopyAndMove
  * @key randomness
  */
@@ -39,9 +39,10 @@
 import java.io.*;
 import java.util.*;
 import java.util.concurrent.TimeUnit;
+import jdk.testlibrary.RandomFactory;
 
 public class CopyAndMove {
-    static final Random rand = new Random();
+    static final Random rand = RandomFactory.getRandom();
     static boolean heads() { return rand.nextBoolean(); }
     private static boolean testPosixAttributes = false;
 
--- a/test/java/util/prefs/CodePointZeroPrefsTest.java	Thu Jun 04 18:28:52 2015 +0200
+++ b/test/java/util/prefs/CodePointZeroPrefsTest.java	Mon Jun 22 13:28:57 2015 -0700
@@ -28,6 +28,7 @@
  * @test
  * @bug 8068373 8075110 8075156
  * @summary Ensure a code point U+0000 null control character is detected.
+ * @run main/othervm -Djava.util.prefs.userRoot=. CodePointZeroPrefsTest
  */
 public class CodePointZeroPrefsTest
 {
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/javax/security/auth/PrivateCredentialPermission/MoreThenOnePrincipals.java	Mon Jun 22 13:28:57 2015 -0700
@@ -0,0 +1,98 @@
+/*
+ * 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.
+ */
+
+import com.sun.security.auth.NTUserPrincipal;
+import com.sun.security.auth.UnixPrincipal;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import javax.security.auth.Subject;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+/*
+ * @test
+ * @bug 8050409
+ * @summary Tests with Subject.getPrivateCredentials to check permission checks with one or more principals.
+ * @run testng/othervm/policy=MoreThenOnePrincipals.policy MoreThenOnePrincipals
+ */
+public class MoreThenOnePrincipals {
+    private static final String[] CRED_VALUES =
+            new String[]{"testPrivateCredential-1", "testPrivateCredentials-2"};
+    private static final HashSet CREDS = new HashSet<>(Arrays.asList(CRED_VALUES));
+
+    /**
+     * Policy file grants access to the private Credential,belonging to a
+     * Subject with at least two associated Principals:"com.sun.security.auth
+     * .NTUserPrincipal", with the name,"NTUserPrincipal-1", and
+     * "com.sun.security.auth.UnixPrincipal", with the name, "UnixPrincipals-1".
+     *
+     * For test1 and test2, subjects are associated with none or only one of
+     * principals mentioned above, SecurityException is expected.
+     * For test 3 and test 4, subjects are associated with two or more
+     * Principals (above principals are included), no exception is expected.
+     *
+     */
+
+    @Test(dataProvider = "Provider1", expectedExceptions = SecurityException.class)
+    public void test1(Subject s) {
+        s.getPrivateCredentials(String.class);
+    }
+
+    @Test(dataProvider = "Provider1", expectedExceptions = SecurityException.class)
+    public void test2(Subject s) {
+        s.getPrivateCredentials().iterator().next();
+    }
+
+    @Test(dataProvider = "Provider2")
+    public void test3(Subject s) {
+        s.getPrivateCredentials(String.class);
+    }
+
+    @Test(dataProvider = "Provider2")
+    public void test4(Subject s) {
+        s.getPrivateCredentials().iterator().next();
+    }
+
+    @DataProvider
+    public Object[][] Provider1() {
+        Subject s1 = new Subject(false, Collections.EMPTY_SET, Collections.EMPTY_SET, CREDS);
+        s1.getPrincipals().add(new NTUserPrincipal("NTUserPrincipal-2"));
+        Subject s2 = new Subject(false, Collections.EMPTY_SET, Collections.EMPTY_SET, CREDS);
+        s2.getPrincipals().add(new NTUserPrincipal("NTUserPrincipal-1"));
+        return new Object[][]{{s1}, {s2}};
+    }
+
+    @DataProvider
+    public Object[][] Provider2() {
+        Subject s3 = new Subject(false, Collections.EMPTY_SET, Collections.EMPTY_SET, CREDS);
+        s3.getPrincipals().add(new NTUserPrincipal("NTUserPrincipal-1"));
+        s3.getPrincipals().add(new UnixPrincipal("UnixPrincipals-1"));
+        Subject s4 = new Subject(false, Collections.EMPTY_SET, Collections.EMPTY_SET, CREDS);
+        s4.getPrincipals().add(new NTUserPrincipal("NTUserPrincipal-1"));
+        s4.getPrincipals().add(new UnixPrincipal("UnixPrincipals-1"));
+        s4.getPrincipals().add(new UnixPrincipal("UnixPrincipals-2"));
+        return new Object[][]{{s3}, {s4}};
+    }
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/javax/security/auth/PrivateCredentialPermission/MoreThenOnePrincipals.policy	Mon Jun 22 13:28:57 2015 -0700
@@ -0,0 +1,10 @@
+grant{
+// permissions for TestNG execution
+permission java.io.FilePermission "*","read,write";
+permission java.lang.RuntimePermission "accessDeclaredMembers";
+permission java.util.PropertyPermission "*","read";
+permission java.lang.reflect.ReflectPermission "suppressAccessChecks";
+// permissions for test itself
+permission javax.security.auth.AuthPermission "modifyPrincipals";
+permission javax.security.auth.PrivateCredentialPermission "* com.sun.security.auth.NTUserPrincipal \"NTUserPrincipal-1\" com.sun.security.auth.UnixPrincipal \"UnixPrincipals-1\"", "read";
+};
--- a/test/lib/security/CheckBlacklistedCerts.java	Thu Jun 04 18:28:52 2015 +0200
+++ b/test/lib/security/CheckBlacklistedCerts.java	Mon Jun 22 13:28:57 2015 -0700
@@ -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
@@ -69,7 +69,9 @@
         };
 
         // Is this an OPENJDK build?
-        if (!new File(home, "lib/security/local_policy.jar").exists()) {
+        String prop = System.getProperty("java.runtime.name");
+        if (prop != null && prop.startsWith("OpenJDK")) {
+            System.out.println("This is a OpenJDK build.");
             blacklists = Arrays.copyOf(blacklists, 1);
         }
 
--- a/test/lib/testlibrary/jdk/testlibrary/Utils.java	Thu Jun 04 18:28:52 2015 +0200
+++ b/test/lib/testlibrary/jdk/testlibrary/Utils.java	Mon Jun 22 13:28:57 2015 -0700
@@ -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;
+    }
 }
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/lib/testlibrary/jsr292/com/oracle/testlibrary/jsr292/CodeCacheOverflowProcessor.java	Mon Jun 22 13:28:57 2015 -0700
@@ -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;
+    }
+}