private String getWebSocketAccept(String key) {
   synchronized (sha1Helper) {
     sha1Helper.reset();
     sha1Helper.update(key.getBytes(B2CConverter.ISO_8859_1));
     return Base64.encode(sha1Helper.digest(WS_ACCEPT));
   }
 }
  private void doTestBasic(
      String user,
      String pwd,
      String uri,
      boolean verifyAuthSchemeCase,
      boolean expectedReject1,
      int expectedRC1,
      boolean expectedReject2,
      int expectedRC2)
      throws Exception {

    // the first access attempt should be challenged
    Map<String, List<String>> reqHeaders1 = new HashMap<>();
    Map<String, List<String>> respHeaders1 = new HashMap<>();

    ByteChunk bc = new ByteChunk();
    int rc = getUrl(HTTP_PREFIX + getPort() + uri, bc, reqHeaders1, respHeaders1);

    if (expectedReject1) {
      assertEquals(expectedRC1, rc);
      assertTrue(bc.getLength() > 0);
    } else {
      assertEquals(200, rc);
      assertEquals("OK", bc.toString());
      return;
    }

    // the second access attempt should be sucessful
    String credentials = user + ":" + pwd;
    byte[] credentialsBytes = ByteChunk.convertToBytes(credentials);
    String base64auth = Base64.encode(credentialsBytes);
    String authScheme = verifyAuthSchemeCase ? "bAsIc " : "Basic ";
    String authLine = authScheme + base64auth;

    List<String> auth = new ArrayList<>();
    auth.add(authLine);
    Map<String, List<String>> reqHeaders2 = new HashMap<>();
    reqHeaders2.put(CLIENT_AUTH_HEADER, auth);

    Map<String, List<String>> respHeaders2 = new HashMap<>();

    bc.recycle();
    rc = getUrl(HTTP_PREFIX + getPort() + uri, bc, reqHeaders2, respHeaders2);

    if (expectedReject2) {
      assertEquals(expectedRC2, rc);
      assertTrue(bc.getLength() > 0);
    } else {
      assertEquals(200, rc);
      assertEquals("OK", bc.toString());
    }
  }
  /**
   * Execute the specified command, based on the configured properties. The input stream will be
   * closed upon completion of this task, whether it was executed successfully or not.
   *
   * @param command Command to be executed
   * @param istream InputStream to include in an HTTP PUT, if any
   * @param contentType Content type to specify for the input, if any
   * @param contentLength Content length to specify for the input, if any
   * @exception BuildException if an error occurs
   */
  public void execute(String command, InputStream istream, String contentType, int contentLength)
      throws BuildException {

    URLConnection conn = null;
    InputStreamReader reader = null;
    try {

      // Create a connection for this command
      conn = (new URL(url + command)).openConnection();
      HttpURLConnection hconn = (HttpURLConnection) conn;

      // Set up standard connection characteristics
      hconn.setAllowUserInteraction(false);
      hconn.setDoInput(true);
      hconn.setUseCaches(false);
      if (istream != null) {
        hconn.setDoOutput(true);
        hconn.setRequestMethod("PUT");
        if (contentType != null) {
          hconn.setRequestProperty("Content-Type", contentType);
        }
        if (contentLength >= 0) {
          hconn.setRequestProperty("Content-Length", "" + contentLength);
        }
      } else {
        hconn.setDoOutput(false);
        hconn.setRequestMethod("GET");
      }
      hconn.setRequestProperty("User-Agent", "Catalina-Ant-Task/1.0");

      // Set up an authorization header with our credentials
      String input = username + ":" + password;
      String output = new String(Base64.encode(input.getBytes()));
      hconn.setRequestProperty("Authorization", "Basic " + output);

      // Establish the connection with the server
      hconn.connect();

      // Send the request data (if any)
      if (istream != null) {
        BufferedOutputStream ostream = new BufferedOutputStream(hconn.getOutputStream(), 1024);
        byte buffer[] = new byte[1024];
        while (true) {
          int n = istream.read(buffer);
          if (n < 0) {
            break;
          }
          ostream.write(buffer, 0, n);
        }
        ostream.flush();
        ostream.close();
        istream.close();
      }

      // Process the response message
      reader = new InputStreamReader(hconn.getInputStream(), CHARSET);
      StringBuffer buff = new StringBuffer();
      String error = null;
      int msgPriority = Project.MSG_INFO;
      boolean first = true;
      while (true) {
        int ch = reader.read();
        if (ch < 0) {
          break;
        } else if ((ch == '\r') || (ch == '\n')) {
          // in Win \r\n would cause handleOutput() to be called
          // twice, the second time with an empty string,
          // producing blank lines
          if (buff.length() > 0) {
            String line = buff.toString();
            buff.setLength(0);
            if (first) {
              if (!line.startsWith("OK -")) {
                error = line;
                msgPriority = Project.MSG_ERR;
              }
              first = false;
            }
            handleOutput(line, msgPriority);
          }
        } else {
          buff.append((char) ch);
        }
      }
      if (buff.length() > 0) {
        handleOutput(buff.toString(), msgPriority);
      }
      if (error != null && isFailOnError()) {
        // exception should be thrown only if failOnError == true
        // or error line will be logged twice
        throw new BuildException(error);
      }
    } catch (Throwable t) {
      if (isFailOnError()) {
        throw new BuildException(t);
      } else {
        handleErrorOutput(t.getMessage());
      }
    } finally {
      closeRedirector();
      if (reader != null) {
        try {
          reader.close();
        } catch (Throwable u) {;
        }
        reader = null;
      }
      if (istream != null) {
        try {
          istream.close();
        } catch (Throwable u) {;
        }
        istream = null;
      }
    }
  }