+ "\"aud\":\"client-123\"," + "\"exp\":1700000000," + "\"iat\":1699999900," + "\"nonce\":\"abc123\","
                + "\"at_hash\":\"hashvalue\"," + "\"c_hash\":\"codehash\"" + "}";
        final Map<String, Object> attributes = new HashMap<>();

        authenticator.parseJwtClaim(jwtClaim, attributes);

    HONDA,
    POODLE,
  }

  public void testGetIfPresent() {
    assertThat(Enums.getIfPresent(TestEnum.class, "CHEETO")).hasValue(TestEnum.CHEETO);
    assertThat(Enums.getIfPresent(TestEnum.class, "HONDA")).hasValue(TestEnum.HONDA);
    assertThat(Enums.getIfPresent(TestEnum.class, "POODLE")).hasValue(TestEnum.POODLE);

    assertThat(Enums.getIfPresent(TestEnum.class, "CHEETO")).isPresent();

    HONDA,
    POODLE,
  }

  public void testGetIfPresent() {
    assertThat(Enums.getIfPresent(TestEnum.class, "CHEETO")).hasValue(TestEnum.CHEETO);
    assertThat(Enums.getIfPresent(TestEnum.class, "HONDA")).hasValue(TestEnum.HONDA);
    assertThat(Enums.getIfPresent(TestEnum.class, "POODLE")).hasValue(TestEnum.POODLE);

    assertThat(Enums.getIfPresent(TestEnum.class, "CHEETO")).isPresent();

    assertThat(iterable.firstMatch(equalTo("cool"))).hasValue("cool");
    assertThat(iterable.firstMatch(equalTo("pants"))).hasValue("pants");
    assertThat(iterable.firstMatch(Predicates.alwaysFalse())).isAbsent();
    assertThat(iterable.firstMatch(Predicates.alwaysTrue())).hasValue("cool");
  }

  private static final class IntegerValueOfFunction implements Function<String, Integer> {

    assertThat(MediaType.parse("text/plain; charset =utf-8").charset()).hasValue(UTF_8);
    assertThat(MediaType.parse("text/plain; charset= utf-8").charset()).hasValue(UTF_8);
    assertThat(MediaType.parse("text/plain; charset = utf-8").charset()).hasValue(UTF_8);
    assertThat(MediaType.parse("text/plain;charset =utf-8").charset()).hasValue(UTF_8);
  }

  public void testGetCharset() {

    graph.putEdgeValue(1, 2, "A");
    assertThat(graph.edgeValue(EndpointPair.unordered(1, 2))).hasValue("A");
  }

  @Test
  public void edgeValue_undirected_backwards() {
    graph = ValueGraphBuilder.undirected().build();
    graph.putEdgeValue(1, 2, "A");
    assertThat(graph.edgeValue(EndpointPair.unordered(2, 1))).hasValue("A");
  }

  @Test
  public void edgeValue_undirected_mismatch() {

        String value = null;
        boolean haveValue = false;
        if (encoding != null) {
            try {
                value = item.getString(encoding);
                haveValue = true;
            } catch (final Exception e) {}
        }
        if (!haveValue) {
            try {
                value = item.getString(Charset.forName("ISO-8859-1"));

  }

  public void testTryFind() {
    Iterable<String> list = newArrayList("cool", "pants");
    assertThat(tryFind(list, equalTo("cool"))).hasValue("cool");
    assertThat(tryFind(list, equalTo("pants"))).hasValue("pants");
    assertThat(tryFind(list, Predicates.alwaysTrue())).hasValue("cool");
    assertThat(tryFind(list, Predicates.alwaysFalse())).isAbsent();
    assertCanIterateAgain(list);
  }

      if (owner.value() != this) {
        // nothing to do, we must have been cancelled, don't bother inspecting the future.
        return;
      }
      Object valueToSet = getFutureValue(future);
      if (casValue(owner, this, valueToSet)) {
        complete(
            owner,
            /*
             * Interruption doesn't propagate through a DelegatingToFuture chain (see

        @SuppressWarnings({"unchecked", "nullness"})
        K castKey = (K) key;
        @SuppressWarnings({"unchecked", "nullness"}) // similar to the above
        V castValue = (V) value;

        alertListenerIfPresent(castKey, castValue, RemovalCause.EXPLICIT);
        remove(key);
        return true;
      }
      return false;
    }
  }

  @Override