gt:         if (newThread) {
context: /*
   * Copyright (c) 2001, 2011, 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 4423074
   * @summary Need to rebase all the duplicated classes from Merlin.
   *          This test will check out http POST
   * @run main/othervm HttpsPost
   *
   *     SunJSSE does not support dynamic system properties, no way to re-use
   *     system properties in samevm/agentvm mode.
   */
  
  import java.io.*;
  import java.net.*;
  import javax.net.ssl.*;
  
  public class HttpsPost {
  
      /*
       * =============================================================
       * Set the various variables needed for the tests, then
       * specify what tests to run on each side.
       */
  
      /*
       * Should we run the client or server in a separate thread?
       * Both sides can throw exceptions, but do you have a preference
       * as to which side should be the main thread.
       */
      static boolean separateServerThread = true;
  
      /*
       * Where do we find the keystores?
       */
      static String pathToStores = "../../../../../../javax/net/ssl/etc";
      static String keyStoreFile = "keystore";
      static String trustStoreFile = "truststore";
      static String passwd = "passphrase";
  
      /*
       * Is the server ready to serve?
       */
      volatile static boolean serverReady = false;
  
      /*
       * Is the connection ready to close?
       */
      volatile static boolean closeReady = false;
  
      /*
       * Turn on SSL debugging?
       */
      static boolean debug = false;
  
      /*
       * Message posted
       */
      static String postMsg = "Testing HTTP post on a https server";
  
      /*
       * If the client or server is doing some kind of object creation
       * that the other side depends on, and that thread prematurely
       * exits, you may experience a hang.  The test harness will
       * terminate all hung threads after its timeout has expired,
       * currently 3 minutes by default, but you might try to be
       * smart about it....
       */
  
      /*
       * Define the server side of the test.
       *
       * If the server prematurely exits, serverReady will be set to true
       * to avoid infinite hangs.
       */
      void doServerSide() throws Exception {
          SSLServerSocketFactory sslssf =
              (SSLServerSocketFactory) SSLServerSocketFactory.getDefault();
          SSLServerSocket sslServerSocket =
              (SSLServerSocket) sslssf.createServerSocket(serverPort);
          serverPort = sslServerSocket.getLocalPort();
  
          /*
           * Signal Client, we're ready for his connect.
           */
          serverReady = true;
  
          SSLSocket sslSocket = (SSLSocket) sslServerSocket.accept();
          try {
              InputStream sslIS = sslSocket.getInputStream();
              OutputStream sslOS = sslSocket.getOutputStream();
              BufferedReader br =
                          new BufferedReader(new InputStreamReader(sslIS));
              PrintStream ps = new PrintStream(sslOS);
  
              // process HTTP POST request from client
              System.out.println("status line: "+br.readLine());
              String msg = null;
              while ((msg = br.readLine()) != null && msg.length() > 0);
  
              msg = br.readLine();
              if (msg.equals(postMsg)) {
                  ps.println("HTTP/1.1 200 OK\n\n");
              } else {
                  ps.println("HTTP/1.1 500 Not OK\n\n");
              }
              ps.flush();
  
              // close the socket
              while (!closeReady) {
                  Thread.sleep(50);
              }
          } finally {
              sslSocket.close();
              sslServerSocket.close();
          }
      }
  
      /*
       * Define the client side of the test.
       *
       * If the server prematurely exits, serverReady will be set to true
       * to avoid infinite hangs.
       */
      void doClientSide() throws Exception {
          HostnameVerifier reservedHV =
              HttpsURLConnection.getDefaultHostnameVerifier();
          try {
              /*
               * Wait for server to get started.
               */
              while (!serverReady) {
                  Thread.sleep(50);
              }
  
              // Send HTTP POST request to server
              URL url = new URL("https://localhost:"+serverPort);
  
              HttpsURLConnection.setDefaultHostnameVerifier(new NameVerifier());
              HttpsURLConnection http = (HttpsURLConnection)url.openConnection();
              http.setDoOutput(true);
  
              http.setRequestMethod("POST");
              PrintStream ps = new PrintStream(http.getOutputStream());
              try {
                  ps.println(postMsg);
                  ps.flush();
                  if (http.getResponseCode() != 200) {
                      throw new RuntimeException("test Failed");
                  }
              } finally {
                  ps.close();
                  http.disconnect();
                  closeReady = true;
              }
          } finally {
              HttpsURLConnection.setDefaultHostnameVerifier(reservedHV);
          }
      }
  
      static class NameVerifier implements HostnameVerifier {
          public boolean verify(String hostname, SSLSession session) {
              return true;
          }
      }
  
      /*
       * =============================================================
       * The remainder is just support stuff
       */
  
      // use any free port by default
      volatile int serverPort = 0;
  
      volatile Exception serverException = null;
      volatile Exception clientException = null;
  
      public static void main(String[] args) throws Exception {
          String keyFilename =
              System.getProperty("test.src", "./") + "/" + pathToStores +
                  "/" + keyStoreFile;
          String trustFilename =
              System.getProperty("test.src", "./") + "/" + pathToStores +
                  "/" + trustStoreFile;
  
          System.setProperty("javax.net.ssl.keyStore", keyFilename);
          System.setProperty("javax.net.ssl.keyStorePassword", passwd);
          System.setProperty("javax.net.ssl.trustStore", trustFilename);
          System.setProperty("javax.net.ssl.trustStorePassword", passwd);
  
          if (debug)
              System.setProperty("javax.net.debug", "all");
  
          /*
           * Start the tests.
           */
          new HttpsPost();
      }
  
      Thread clientThread = null;
      Thread serverThread = null;
  
      /*
       * Primary constructor, used to drive remainder of the test.
       *
       * Fork off the other side, then do your work.
       */
      HttpsPost() throws Exception {
          if (separateServerThread) {
              startServer(true);
              startClient(false);
          } else {
              startClient(true);
              startServer(false);
          }
  
          /*
           * Wait for other side to close down.
           */
          if (separateServerThread) {
              serverThread.join();
          } else {
              clientThread.join();
          }
  
          /*
           * When we get here, the test is pretty much over.
           *
           * If the main thread excepted, that propagates back
           * immediately.  If the other thread threw an exception, we
           * should report back.
           */
          if (serverException != null)
              throw serverException;
          if (clientException != null)
              throw clientException;
      }
  
      void startServer(boolean newThread) throws Exception {
          if (newThread) {
              serverThread = new Thread() {
                  public void run() {
                      try {
                          doServerSide();
                      } catch (Exception e) {
                          /*
                           * Our server thread just died.
                           *
                           * Release the client, if not active already...
                           */
                          System.err.println("Server died...");
                          serverReady = true;
                          serverException = e;
                      }
                  }
              };
              serverThread.start();
          } else {
              doServerSide();
          }
      }
  
      void startClient(boolean newThread) throws Exception {
  