return null;
        },
        /* userPassedSupplier= */ false);
  }

  private static <T extends Throwable> T doAssertThrows(
      Class<T> expectedThrowable, ThrowingSupplier supplier, boolean userPassedSupplier) {
    checkNotNull(expectedThrowable);
    checkNotNull(supplier);
    Predicate<Throwable> predicate = INSTANCE_OF.get(expectedThrowable);
    if (predicate == null) {

          return null;
        },
        /* userPassedSupplier= */ false);
  }

  private static <T extends Throwable> T doAssertThrows(
      Class<T> expectedThrowable, ThrowingSupplier supplier, boolean userPassedSupplier) {
    checkNotNull(expectedThrowable);
    checkNotNull(supplier);
    Predicate<Throwable> predicate = INSTANCE_OF.get(expectedThrowable);
    if (predicate == null) {

          return null;
        },
        /* userPassedSupplier= */ false);
  }

  private static <T extends Throwable> T doAssertThrows(
      Class<T> expectedThrowable, ThrowingSupplier supplier, boolean userPassedSupplier) {
    checkNotNull(expectedThrowable);
    checkNotNull(supplier);
    Predicate<Throwable> predicate = INSTANCE_OF.get(expectedThrowable);
    if (predicate == null) {

    return suite;
  }

  public void testIteratesOnce() {
    Map<AnEnum, AnEnum> map =
        Maps.asMap(
            ImmutableSet.of(AnEnum.A),
            new Function<AnEnum, AnEnum>() {
              boolean used = false;

              @Override
              public AnEnum apply(AnEnum ae) {
                checkState(!used, "should not be applied more than once");
                used = true;
                return ae;

     * @throws DcerpcException if DCERPC initialization fails
     * @throws MalformedURLException if the URL is malformed
     */
    public DcerpcPipeHandle(final String url, final CIFSContext tc, final boolean unshared) throws DcerpcException, MalformedURLException {
        super(tc, DcerpcHandle.parseBinding(url));
        this.pipe = new SmbNamedPipe(makePipeUrl(), pipeFlags, unshared, tc);

    /**
     * Checks if this registration has expired based on the timeout.
     *
     * @param timeoutMs the timeout in milliseconds
     * @return true if the registration is expired
     */
    public boolean isExpired(long timeoutMs) {
        return System.currentTimeMillis() - lastHeartbeat > timeoutMs;
    }

    // Getters and setters

    /**
     * Gets the last heartbeat timestamp.
     *

    IS_DIRECTORY {
      @Override
      public boolean apply(File file) {
        return file.isDirectory();
      }

      @Override
      public String toString() {
        return "Files.isDirectory()";
      }
    },

    IS_FILE {
      @Override
      public boolean apply(File file) {
        return file.isFile();
      }

      @Override

        final String fieldName = item.getFieldName();
        final Charset encoding = Charset.forName(request.getCharacterEncoding());
        String value = null;
        boolean haveValue = false;
        if (encoding != null) {
            try {
                value = item.getString(encoding);
                haveValue = true;
            } catch (final Exception e) {}
        }

    assertThat(explicitAdapter.fromDer(bytes)).isEqualTo("hi")
    assertThat(explicitAdapter.toDer("hi")).isEqualTo(bytes)
  }

  @Test fun `boolean`() {
    val bytes = "0101FF".decodeHex()
    assertThat(Adapters.BOOLEAN.fromDer(bytes)).isEqualTo(true)
    assertThat(Adapters.BOOLEAN.toDer(true)).isEqualTo(bytes)
  }

  @Test fun `positive integer`() {
    val bytes = "020132".decodeHex()

    /**
     * Checks if the response data represents HTML content.
     *
     * @param responseData the response data to check
     * @return true if the content is HTML, false otherwise
     */
    protected boolean isHtml(final ResponseData responseData) {
        final String mimeType = responseData.getMimeType();
        if ("text/html".equals(mimeType) || "application/xhtml+xml".equals(mimeType)) {
            return true;
        }