public interface TypeToInstanceMap<B extends @Nullable Object>
    extends Map<TypeToken<? extends @NonNull B>, B> {

  /**
   * Returns the value the specified class is mapped to, or {@code null} if no entry for this class
   * is present. This will only return a value that was bound to this specific class, not a value
   * that may have been bound to a subtype.
   *
   * <p>{@code getInstance(Foo.class)} is equivalent to {@code

        assertArrayEquals(new byte[0], t.toByteArray(), "empty array expected when mechanismToken is null");
    }

    @Test
    @DisplayName("toByteArray returns mechanismToken reference when present")
    void toByteArrayReturnsToken() throws IOException {
        TestSpnegoToken t = new TestSpnegoToken();
        byte[] raw = new byte[] { 11, 12, 13 };
        t.parse(raw);

      if (array[i] == target) {
        return i;
      }
    }
    return -1;
  }

  /**
   * Returns the least value present in {@code array}.
   *
   * @param array a <i>nonempty</i> array of {@code long} values
   * @return the value present in {@code array} that is less than or equal to every other value in
   *     the array
   * @throws IllegalArgumentException if {@code array} is empty
   */

   * associated with that range is returned.
   */
  @Nullable V get(K key);

  /**
   * Returns the range containing this key and its associated value, if such a range is present in
   * the range map, or {@code null} otherwise.
   */
  @Nullable Entry<Range<K>, V> getEntry(K key);

  /**
   * Returns the minimal range {@linkplain Range#encloses(Range) enclosing} the ranges in this

    expectAdded(entry(null, v3()));
  }

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testMergePresent() {
    assertEquals(
        "Map.merge(present, value, function) should return function result",
        v4(),
        getMap()
            .merge(
                k0(),
                v3(),
                (oldV, newV) -> {

    if (containedKey && Objects.equals(value, get(key))) {
      return value;
    }
    if (force) {
      inverse().remove(value);
    } else {
      checkArgument(!containsValue(value), "value already present: %s", value);
    }
    V oldValue = delegate.put(key, value);
    updateInverseMap(key, containedKey, oldValue, value);
    return oldValue;
  }

  private void updateInverseMap(

   * endpoints are unordered and the graph is directed; it simply returns {@code false}. This is for
   * consistency with the behavior of {@link Collection#contains(Object)} (which does not generally
   * throw if the object cannot be present in the collection), and the desire to have this method's
   * behavior be compatible with {@code edges().contains(endpoints)}.
   *
   * @since 27.1
   */
  @Override

    expectAdded(entry(null, v3()));
  }

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testMergePresent() {
    assertEquals(
        "Map.merge(present, value, function) should return function result",
        v4(),
        getMap()
            .merge(
                k0(),
                v3(),
                (oldV, newV) -> {

   */
  @get:JvmName("httpOnly") val httpOnly: Boolean,
  /**
   * Returns true if this cookie does not expire at the end of the current session.
   *
   * This is true if either 'expires' or 'max-age' is present.
   */
  @get:JvmName("persistent") val persistent: Boolean,
  /**
   * Returns true if this cookie's domain should be interpreted as a single host name, or false if

        // Verify no metadata extracted
        assertNull(extractData.getValues("title"));
        assertNull(extractData.getValues("author"));

        // But content should still be present
        final String content = extractData.getContent();
        assertTrue(content.contains("Sample Document"));
    }

    public void test_maxDepth() {
        jsonExtractor.setMaxDepth(1);