changeset 10203:3a5c987ff3a0

Merge
author lana
date Mon, 14 Oct 2013 09:52:36 -0700
parents 96644227daed f15a0087181e
children dd0deeb04933
files
diffstat 6 files changed, 62 insertions(+), 15 deletions(-) [+]
line wrap: on
line diff
--- a/src/share/classes/java/lang/ClassLoader.java	Fri Oct 11 23:27:23 2013 -0700
+++ b/src/share/classes/java/lang/ClassLoader.java	Mon Oct 14 09:52:36 2013 -0700
@@ -1061,6 +1061,10 @@
      * built-in to the virtual machine is searched.  That failing, this method
      * will invoke {@link #findResource(String)} to find the resource.  </p>
      *
+     * @apiNote When overriding this method it is recommended that an
+     * implementation ensures that any delegation is consistent with the {@link
+     * #getResources(java.lang.String) getResources(String)} method.
+     *
      * @param  name
      *         The resource name
      *
@@ -1094,6 +1098,13 @@
      * <p> The search order is described in the documentation for {@link
      * #getResource(String)}.  </p>
      *
+     * @apiNote When overriding this method it is recommended that an
+     * implementation ensures that any delegation is consistent with the {@link
+     * #getResource(java.lang.String) getResource(String)} method. This should
+     * ensure that the first element returned by the Enumeration's
+     * {@code nextElement} method is the same resource that the
+     * {@code getResource(String)} method would return.
+     *
      * @param  name
      *         The resource name
      *
--- a/src/share/classes/java/util/ServiceLoader.java	Fri Oct 11 23:27:23 2013 -0700
+++ b/src/share/classes/java/util/ServiceLoader.java	Mon Oct 14 09:52:36 2013 -0700
@@ -453,6 +453,12 @@
      * Invoking its {@link java.util.Iterator#remove() remove} method will
      * cause an {@link UnsupportedOperationException} to be thrown.
      *
+     * @implNote When adding providers to the cache, the {@link #iterator
+     * Iterator} processes resources in the order that the {@link
+     * java.lang.ClassLoader#getResources(java.lang.String)
+     * ClassLoader.getResources(String)} method finds the service configuration
+     * files.
+     *
      * @return  An iterator that lazily loads providers for this loader's
      *          service
      */
--- a/test/java/lang/management/MemoryMXBean/LowMemoryTest2.java	Fri Oct 11 23:27:23 2013 -0700
+++ b/test/java/lang/management/MemoryMXBean/LowMemoryTest2.java	Mon Oct 14 09:52:36 2013 -0700
@@ -26,7 +26,7 @@
  *
  * The test set a listener to be notified when any of the non-heap pools
  * exceed 80%. It then starts a thread that continuously loads classes.
- * In the HotSpot implementation this causes perm space to be consumed.
+ * In the HotSpot implementation this causes metaspace to be consumed.
  * Test completes when we the notification is received or an OutOfMemory
  * is generated.
  */
@@ -100,7 +100,14 @@
 
             // TestNNNNNN
 
-            String name = "Test" + Integer.toString(count++);
+            int load_count = count++;
+            if (load_count > 999999) {
+                // The test will create a corrupt class file if the count
+                // exceeds 999999. Fix the test if this exception is thrown.
+                throw new RuntimeException("Load count exceeded");
+            }
+
+            String name = "Test" + Integer.toString(load_count);
 
             byte value[];
             try {
@@ -133,8 +140,9 @@
          * Note: Once the usage threshold has been exceeded the low memory
          * detector thread will attempt to deliver its notification - this can
          * potentially create a race condition with this thread contining to
-         * fill up perm space. To avoid the low memory detector getting an OutOfMemory
-         * we throttle this thread once the threshold has been exceeded.
+         * fill up metaspace. To avoid the low memory detector getting an
+         * OutOfMemory we throttle this thread once the threshold has been
+         * exceeded.
          */
         public void run() {
             List pools = ManagementFactory.getMemoryPoolMXBeans();
@@ -180,7 +188,7 @@
 
         // Set threshold of 80% of all NON_HEAP memory pools
         // In the Hotspot implementation this means we should get a notification
-        // if the CodeCache or perm generation fills up.
+        // if the CodeCache or metaspace fills up.
 
         while (iter.hasNext()) {
             MemoryPoolMXBean p = (MemoryPoolMXBean) iter.next();
@@ -188,7 +196,12 @@
 
                 // set threshold
                 MemoryUsage mu = p.getUsage();
-                long threshold = (mu.getMax() * 80) / 100;
+                long max = mu.getMax();
+                if (max < 0) {
+                    throw new RuntimeException("There is no maximum set for "
+                            + p.getName() + " memory pool so the test is invalid");
+                }
+                long threshold = (max * 80) / 100;
 
                 p.setUsageThreshold(threshold);
 
--- a/test/java/lang/management/MemoryMXBean/LowMemoryTest2.sh	Fri Oct 11 23:27:23 2013 -0700
+++ b/test/java/lang/management/MemoryMXBean/LowMemoryTest2.sh	Mon Oct 14 09:52:36 2013 -0700
@@ -51,14 +51,17 @@
 
 # Run test with each GC configuration
 # 
-# Notes: To ensure that perm gen fills up we disable class unloading.
-# Also we set the max perm space to 8MB - otherwise the test takes too
+# Notes: To ensure that metaspace fills up we disable class unloading.
+# Also we set the max metaspace to 8MB - otherwise the test takes too
 # long to run. 
 
-go -noclassgc -XX:PermSize=8m -XX:MaxPermSize=8m -XX:+UseSerialGC LowMemoryTest2
-go -noclassgc -XX:PermSize=8m -XX:MaxPermSize=8m -XX:+UseParallelGC LowMemoryTest2
-go -noclassgc -XX:PermSize=8m -XX:MaxPermSize=8m -XX:+UseParNewGC -XX:+UseConcMarkSweepGC \
-    LowMemoryTest2
+go -noclassgc -XX:MaxMetaspaceSize=16m -XX:+UseSerialGC LowMemoryTest2
+go -noclassgc -XX:MaxMetaspaceSize=16m -XX:+UseParallelGC LowMemoryTest2
+go -noclassgc -XX:MaxMetaspaceSize=16m -XX:+UseParNewGC -XX:+UseConcMarkSweepGC LowMemoryTest2
+
+# Test class metaspace - might hit MaxMetaspaceSize instead if
+# UseCompressedClassPointers is off or if 32 bit.
+go -noclassgc -XX:MaxMetaspaceSize=16m -XX:CompressedClassSpaceSize=4m LowMemoryTest2
 
 echo ''
 if [ $failures -gt 0 ];
--- a/test/java/net/Socks/SocksProxyVersion.java	Fri Oct 11 23:27:23 2013 -0700
+++ b/test/java/net/Socks/SocksProxyVersion.java	Mon Oct 14 09:52:36 2013 -0700
@@ -41,6 +41,10 @@
     volatile boolean failed;
 
     public static void main(String[] args) throws Exception {
+        if (InetAddress.getLocalHost().isLoopbackAddress()) {
+            System.out.println("Test cannot run. getLocalHost returns a loopback address");
+            return;
+        }
         new SocksProxyVersion();
     }
 
--- a/test/sun/security/ssl/com/sun/net/ssl/internal/ssl/DHKeyExchange/DHEKeySizing.java	Fri Oct 11 23:27:23 2013 -0700
+++ b/test/sun/security/ssl/com/sun/net/ssl/internal/ssl/DHKeyExchange/DHEKeySizing.java	Mon Oct 14 09:52:36 2013 -0700
@@ -111,7 +111,15 @@
 
 public class DHEKeySizing {
 
-    private static boolean debug = true;
+    private final static boolean debug = true;
+
+    // key length bias because of the stripping of leading zero bytes of
+    // negotiated DH keys.
+    //
+    // This is an effort to mimum intermittent failure when we cannot
+    // estimate what's the exact number of leading zero bytes of
+    // negotiated DH keys.
+    private final static int KEY_LEN_BIAS = 6;
 
     private SSLContext sslc;
     private SSLEngine ssle1;    // client
@@ -269,7 +277,8 @@
         twoToOne.flip();
 
         log("Message length of ServerHello series: " + twoToOne.remaining());
-        if (lenServerKeyEx != twoToOne.remaining()) {
+        if (twoToOne.remaining() < (lenServerKeyEx - KEY_LEN_BIAS) ||
+                twoToOne.remaining() > lenServerKeyEx) {
             throw new Exception(
                 "Expected to generate ServerHello series messages of " +
                 lenServerKeyEx + " bytes, but not " + twoToOne.remaining());
@@ -289,7 +298,8 @@
         oneToTwo.flip();
 
         log("Message length of ClientKeyExchange: " + oneToTwo.remaining());
-        if (lenClientKeyEx != oneToTwo.remaining()) {
+        if (oneToTwo.remaining() < (lenClientKeyEx - KEY_LEN_BIAS) ||
+                oneToTwo.remaining() > lenClientKeyEx) {
             throw new Exception(
                 "Expected to generate ClientKeyExchange message of " +
                 lenClientKeyEx + " bytes, but not " + oneToTwo.remaining());