// Escapers operate on characters: no characters, no escaping.
    Assert.assertEquals("", escaper.escape(""));
    // Assert that escapers throw null pointer exceptions.
    try {
      escaper.escape((String) null);
      Assert.fail("exception not thrown when escaping a null string");
    } catch (NullPointerException e) {
      // pass
    }
  }

  /**

            form.clearSecurityInfo();
            return asIndexHtml();
        };
        validatePasswordForm(form, toIndexPage);
        final String username = getUserBean().map(FessUserBean::getUserId).get();
        try {
            userService.changePassword(username, form.newPassword);
            saveInfo(messages -> messages.addSuccessChangedPassword(GLOBAL));
        } catch (final Exception e) {

      }
    }

  fun cancelStream() =
    apply {
      actions += { stream -> stream.cancel() }
    }

  fun requestIOException() =
    apply {
      actions += { stream ->
        try {
          stream.source.exhausted()
          throw AssertionError("expected IOException")
        } catch (expected: IOException) {
        }
      }
    }

  @JvmOverloads
  fun sendResponse(

  public void testContains_nullContained() {
    initMapWithNullValue();
    assertTrue("containsValue(null) should return true", getMap().containsValue(null));
  }

  public void testContains_wrongType() {
    try {
      // noinspection SuspiciousMethodCalls
      assertFalse(
          "containsValue(wrongType) should return false or throw",
          getMap().containsValue(WrongType.VALUE));

    Request request = new Request.Builder()
        .url("https://www.googleapis.com/urlshortener/v1/url?key=" + GOOGLE_API_KEY)
        .post(jsonRequestBody)
        .build();

    try (Response response = client.newCall(request).execute()) {
      if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

      System.out.println(response.body().string());
    }
  }

    assertTrue(future.isDone());
    assertFalse(future.isCancelled());

    assertTrue(latch.await(5, SECONDS));
    assertTrue(future.isDone());
    assertFalse(future.isCancelled());

    try {
      future.get();
      fail("Future should rethrow the exception.");
    } catch (ExecutionException e) {
      assertThat(e).hasCauseThat().hasMessageThat().isEqualTo(message);
    }
  }

  public void addListener(Runnable listener, Executor executor) {
    checkNotNull(listener, "Runnable was null.");
    checkNotNull(executor, "Executor was null.");
    try {
      executor.execute(listener);
    } catch (Exception e) { // sneaky checked exception
      // ListenableFuture's contract is that it will not throw unchecked exceptions, so log the bad

    protected int readDataWireFormat(final byte[] buffer, int bufferIndex, final int len) {
        final int start = bufferIndex;

        if (this.getErrorCode() != 0) {
            return 4;
        }

        try {
            this.securityDescriptor = new SecurityDescriptor();
            bufferIndex += this.securityDescriptor.decode(buffer, bufferIndex, len);
        } catch (final IOException ioe) {

            throws ArtifactResolutionException, ArtifactNotFoundException {
        if (Artifact.RELEASE_VERSION.equals(artifact.getVersion())) {
            try {
                String version = resolveVersion(artifact, request);

                if (Artifact.RELEASE_VERSION.equals(version)) {

        method.setAccessible(true);

        // This should fail because localhost doesn't support SMB multi-channel
        // but the method should not throw NullPointerException
        try {
            method.invoke(multiChannelManager, localhost, loopback);
            // If it doesn't throw, that's unexpected for localhost
            fail("Expected CIFSException for localhost multi-channel attempt");