--- old/test/java/rmi/activation/Activatable/shutdownGracefully/ShutdownGracefully.java	2014-02-06 15:56:37.000000000 +0800
+++ new/test/java/rmi/activation/Activatable/shutdownGracefully/ShutdownGracefully.java	2014-02-06 15:56:36.000000000 +0800
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2014, 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
@@ -142,90 +142,17 @@
                 System.err.println("received exception from registration " +
                                    "call that should have failed...");
             }
-
-            /*
-             * no longer needed because the security manager
-             * throws an exception during snapshot
-             */
-            /*
-            try {
-                registering.shutdown();
-
-                System.err.println("received exception from remote " +
-                                   "call that should have failed...");
-            } catch (RemoteException e) {
+            if (rmid.waitFor(SHUTDOWN_TIMEOUT) == 0) {
+                System.err.println("rmid has gracefully shutdown in time");
+            } else {
+                TestLibrary.bomb("rmid did not shutdown " +
+                             "gracefully in time");
             }
-            */
-
         } catch (Exception e) {
             TestLibrary.bomb("\nfailure: unexpected exception ", e);
         } finally {
-            try {
-                Thread.sleep(4000);
-            } catch (InterruptedException e) {
-            }
-
-            registering = null;
-
-            // Need to make sure that rmid goes away by itself
-            JavaVM rmidProcess = rmid;
-            if (rmidProcess != null) {
-                try {
-                    Runnable waitThread =
-                        new ShutdownDetectThread(rmidProcess);
-
-                    synchronized (waitThread) {
-                        (new Thread(waitThread)).start();
-                        waitThread.wait(SHUTDOWN_TIMEOUT);
-                        System.err.println("rmid has shutdown");
-
-                        if (!rmidDone) {
-                            // ensure that this rmid does not infect
-                            // other tests.
-                            rmidProcess.destroy();
-                            TestLibrary.bomb("rmid did not shutdown " +
-                                             "gracefully in time");
-                        }
-                    }
-                } catch (Exception e) {
-                    TestLibrary.bomb("exception waiting for rmid " +
-                                     "to shut down");
-                }
-            }
-            // else rmid should be down
-        }
-
-        System.err.println
-            ("\nsuccess: ShutdownGracefully test passed ");
-    }
-
-    private static boolean rmidDone = false;
-
-    /**
-     * class that waits for rmid to exit
-     */
-    private static class ShutdownDetectThread implements Runnable {
-        private JavaVM rmidProcess = null;
-
-        ShutdownDetectThread(JavaVM rmidProcess) {
-            this.rmidProcess = rmidProcess;
-        }
-        public void run() {
-            System.err.println("waiting for rmid to shutdown");
-
-            try {
-                rmidProcess.waitFor();
-            } catch (InterruptedException e) {
-                // should not happen
-            }
-
-            synchronized (this) {
-                // notify parent thread when rmid has exited
-                this.notify();
-                rmidDone = true;
-            }
-
-            RMID.removeLog();
+            if(rmid != null)
+                rmid.destroy();
         }
     }
 
--- old/test/java/rmi/testlibrary/JavaVM.java	2014-02-06 15:56:38.000000000 +0800
+++ new/test/java/rmi/testlibrary/JavaVM.java	2014-02-06 15:56:38.000000000 +0800
@@ -26,6 +26,9 @@
 import java.io.OutputStream;
 import java.util.Arrays;
 import java.util.StringTokenizer;
+import java.util.concurrent.TimeoutException;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 
 /**
  * RMI regression test utility class that uses Runtime.exec to spawn a
@@ -172,6 +175,47 @@
         return status;
     }
 
+        /**
+     * Causes the current thread to wait the subprocess to exit, if necessary,
+     * until the subprocess represented by this Process object has terminated,
+     * or the specified waiting time elapses.
+     * @param timeout the maximum milliseconds to wait
+     * @return true if the JavaVM has exited and false if the waiting time
+     *         elapsed before the subprocess has exited.
+     * @throws InterruptedException if the current thread is interrupted
+     *         while waiting.
+     * @throws TimeoutException if subprocess does not end after timeout
+     *         milliseconds passed
+     */
+    public int waitFor(long timeout)
+            throws InterruptedException, TimeoutException {
+        long startTime = System.currentTimeMillis();
+        long rem = timeout;
+
+        do {
+            try {
+                int status = vm.exitValue();
+                outPipe.join();
+                errPipe.join();
+                return status;
+            } catch (IllegalThreadStateException ex) {
+                if (rem > 0) {
+                    Thread.sleep(Math.min(rem, 100));
+                }
+            }
+            rem = timeout - (System.currentTimeMillis() - startTime);
+        } while (rem > 0);
+        new Thread(){
+            @Override
+            public void run() {
+                try {
+                    JavaVM.this.waitFor();
+                } catch (InterruptedException ignore) {}
+            }
+        }.start();
+        throw new TimeoutException();
+    }
+
     /**
      * Starts the subprocess, waits for it to exit, and returns its exit status.
      */