--- old/test/jdk/java/net/httpclient/http2/BasicTest.java	2017-11-30 04:05:09.270196698 -0800
+++ new/test/jdk/java/net/httpclient/http2/BasicTest.java	2017-11-30 04:05:09.007173709 -0800
@@ -26,21 +26,27 @@
  * @bug 8087112
  * @library /lib/testlibrary server
  * @build jdk.testlibrary.SimpleSSLContext
- * @modules jdk.incubator.httpclient/jdk.incubator.http.internal.common
+ * @modules java.base/sun.net.www.http
+ *          jdk.incubator.httpclient/jdk.incubator.http.internal.common
  *          jdk.incubator.httpclient/jdk.incubator.http.internal.frame
  *          jdk.incubator.httpclient/jdk.incubator.http.internal.hpack
  * @run testng/othervm -Djdk.httpclient.HttpClient.log=ssl,requests,responses,errors BasicTest
  */
 
+import java.io.IOException;
 import java.net.*;
 import jdk.incubator.http.*;
 import static jdk.incubator.http.HttpClient.Version.HTTP_2;
 import javax.net.ssl.*;
 import java.nio.file.*;
 import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
 import jdk.testlibrary.SimpleSSLContext;
-import static jdk.incubator.http.HttpRequest.BodyProcessor.fromFile;
-import static jdk.incubator.http.HttpRequest.BodyProcessor.fromString;
+import static jdk.incubator.http.HttpRequest.BodyPublisher.fromFile;
+import static jdk.incubator.http.HttpRequest.BodyPublisher.fromString;
 import static jdk.incubator.http.HttpResponse.BodyHandler.asFile;
 import static jdk.incubator.http.HttpResponse.BodyHandler.asString;
 
@@ -51,25 +57,28 @@
     static int httpPort, httpsPort;
     static Http2TestServer httpServer, httpsServer;
     static HttpClient client = null;
-    static ExecutorService exec;
+    static ExecutorService clientExec;
+    static ExecutorService serverExec;
     static SSLContext sslContext;
 
-    static String httpURIString, httpsURIString;
+    static String pingURIString, httpURIString, httpsURIString;
 
     static void initialize() throws Exception {
         try {
             SimpleSSLContext sslct = new SimpleSSLContext();
             sslContext = sslct.get();
             client = getClient();
-            httpServer = new Http2TestServer(false, 0, exec, sslContext);
+            httpServer = new Http2TestServer(false, 0, serverExec, sslContext);
             httpServer.addHandler(new Http2EchoHandler(), "/");
+            httpServer.addHandler(new EchoWithPingHandler(), "/ping");
             httpPort = httpServer.getAddress().getPort();
 
-            httpsServer = new Http2TestServer(true, 0, exec, sslContext);
+            httpsServer = new Http2TestServer(true, 0, serverExec, sslContext);
             httpsServer.addHandler(new Http2EchoHandler(), "/");
 
             httpsPort = httpsServer.getAddress().getPort();
             httpURIString = "http://127.0.0.1:" + httpPort + "/foo/";
+            pingURIString = "http://127.0.0.1:" + httpPort + "/ping/";
             httpsURIString = "https://127.0.0.1:" + httpsPort + "/bar/";
 
             httpServer.start();
@@ -81,16 +90,46 @@
         }
     }
 
-    @Test(timeOut=3000000)
+    static List<CompletableFuture<Long>> cfs = Collections
+        .synchronizedList( new LinkedList<>());
+
+    static CompletableFuture<Long> currentCF;
+
+    static class EchoWithPingHandler extends Http2EchoHandler {
+        private final Object lock = new Object();
+
+        @Override
+        public void handle(Http2TestExchange exchange) throws IOException {
+            // for now only one ping active at a time. don't want to saturate
+            synchronized(lock) {
+                CompletableFuture<Long> cf = currentCF;
+                if (cf == null || cf.isDone()) {
+                    cf = exchange.sendPing();
+                    assert cf != null;
+                    cfs.add(cf);
+                    currentCF = cf;
+                }
+            }
+            super.handle(exchange);
+        }
+    }
+
+    @Test
     public static void test() throws Exception {
         try {
             initialize();
-            simpleTest(false);
-            simpleTest(true);
+            simpleTest(false, false);
+            simpleTest(false, true);
+            simpleTest(true, false);
             streamTest(false);
             streamTest(true);
             paramsTest();
-            Thread.sleep(1000 * 4);
+            CompletableFuture.allOf(cfs.toArray(new CompletableFuture[0])).join();
+            synchronized (cfs) {
+                for (CompletableFuture<Long> cf : cfs) {
+                    System.out.printf("Ping ack received in %d millisec\n", cf.get());
+                }
+            }
         } catch (Throwable tt) {
             System.err.println("tt caught");
             tt.printStackTrace();
@@ -98,15 +137,16 @@
         } finally {
             httpServer.stop();
             httpsServer.stop();
-            exec.shutdownNow();
+            //clientExec.shutdown();
         }
     }
 
     static HttpClient getClient() {
         if (client == null) {
-            exec = Executors.newCachedThreadPool();
+            serverExec = Executors.newCachedThreadPool();
+            clientExec = Executors.newCachedThreadPool();
             client = HttpClient.newBuilder()
-                               .executor(exec)
+                               .executor(clientExec)
                                .sslContext(sslContext)
                                .version(HTTP_2)
                                .build();
@@ -115,10 +155,14 @@
     }
 
     static URI getURI(boolean secure) {
+        return getURI(secure, false);
+    }
+
+    static URI getURI(boolean secure, boolean ping) {
         if (secure)
             return URI.create(httpsURIString);
         else
-            return URI.create(httpURIString);
+            return URI.create(ping ? pingURIString: httpURIString);
     }
 
     static void checkStatus(int expected, int found) throws Exception {
@@ -170,11 +214,11 @@
                 });
         response.join();
         compareFiles(src, dest);
-        System.err.println("DONE");
+        System.err.println("streamTest: DONE");
     }
 
     static void paramsTest() throws Exception {
-        Http2TestServer server = new Http2TestServer(true, 0, exec, sslContext);
+        Http2TestServer server = new Http2TestServer(true, 0, serverExec, sslContext);
         server.addHandler((t -> {
             SSLSession s = t.getSSLSession();
             String prot = s.getProtocol();
@@ -196,10 +240,11 @@
             throw new RuntimeException("paramsTest failed "
                 + Integer.toString(stat));
         }
+        System.err.println("paramsTest: DONE");
     }
 
-    static void simpleTest(boolean secure) throws Exception {
-        URI uri = getURI(secure);
+    static void simpleTest(boolean secure, boolean ping) throws Exception {
+        URI uri = getURI(secure, ping);
         System.err.println("Request to " + uri);
 
         // Do a simple warmup request
@@ -237,6 +282,6 @@
             Thread.sleep(100);
         }
         CompletableFuture.allOf(responses).join();
-        System.err.println("DONE");
+        System.err.println("simpleTest: DONE");
     }
 }