fail<Any>()
    } catch (expected: IllegalArgumentException) {
      assertThat(expected.message).isEqualTo("string does not include a private key")
    }
    try {
      decode(pkcs8Pem)
      fail<Any>()
    } catch (expected: IllegalArgumentException) {
      assertThat(expected.message).isEqualTo("string does not include a certificate")
    }
    try {

 * allowing the error page to display relevant information and preserve search context.
 */
public class ErrorForm {

    /** Map of form fields and their validation error messages */
    public Map<String, String[]> fields = new HashMap<>();

    /** Search query parameter that caused the error */
    public String q;

    /** URL parameter associated with the error */
    public String url;

        }

        public void setThrowException(boolean throwException) {
            this.throwException = throwException;
        }

        public void setExceptionMessage(String message) {
            this.exceptionMessage = message;
        }

        public long getPurgeExpiry() {
            return purgeExpiry;
        }
    }

    // Read error: ssl=0x7fd1d8d0fee8: Failure in SSL library, usually a protocol error
    if (!platform.isConscrypt()) {
      assertThat(event.exception.message).isIn(
        "Unexpected handshake message: client_hello",
        "(unexpected_message) Unexpected handshake message: client_hello",
      )
    }
  }

  @Test
  @Throws(IOException::class)
  fun multipleConnectsForSingleCall() {
    enableTls()

package gradlebuild.docs.dsl.docbook;

import gradlebuild.docs.DocGenerationException;

public class ClassDocGenerationException extends DocGenerationException {
    public ClassDocGenerationException(String message, Throwable throwable) {
        super(message, throwable);
    }

    fun buildErrorMessage(formattedMismatches: Map<File, String>): String {
        val messages = formattedMismatches.map {
            "API changes in file '${it.key.name}' should be in alphabetical order (by type and member), yet these changes were not:\n" +
                "$formattedMismatches\n"
        }.joinToString(separator = "\n")

    }.also { expected ->
      assertThat(expected.message).isEqualTo("Code must be in range [1000,5000): 98724976")
    }
  }

  @Test fun closeReservedThrows() {
    assertFailsWith<IllegalArgumentException> {
      clientWriter.writeClose(1005, "Hello".encodeUtf8())
    }.also { expected ->
      assertThat(expected.message).isEqualTo("Code 1005 is reserved and may not be used.")
    }
  }

      }
      return result
    }

  @JvmName("-deprecated_url")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "url"),
    level = DeprecationLevel.ERROR,
  )
  fun url(): HttpUrl = url

  @JvmName("-deprecated_method")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "method"),
    level = DeprecationLevel.ERROR,
  )

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

    assertThrows(CancellationException.class, future::get);
  }

  public void testFailedFuture(@Nullable String message) throws InterruptedException {
    assertTrue(future.isDone());
    assertFalse(future.isCancelled());

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

            }
            if ("favorite_log".equals(name)) {
                return writeNdjsonResponse(id, getFavoriteLogNdjsonWriteCall());
            }
        }

        throwValidationErrorApi(messages -> messages.addErrorsCouldNotFindBackupIndex(GLOBAL));
        return StreamResponse.asEmptyBody(); // no-op
    }

    private StreamResponse writeNdjsonResponse(final String id, final Consumer<Writer> writeCall) {