h.add(sz)
			}
			got := h.toMap()
			exp := test.want
			// what is in exp is in got
			for k := range exp {
				if exp[k] != got[k] {
					t.Fatalf("interval %s: Expected %d values but got %d values\n", k, exp[k], got[k])
				}
			}
			// what is absent in exp is absent in got too
			for k := range got {
				if _, ok := exp[k]; !ok && got[k] > 0 {

    assertTrue(getMap().isEmpty());
    assertTrue(inv.isEmpty());
  }

  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testValuesClearClearsInverse() {
    BiMap<V, K> inv = getMap().inverse();
    getMap().values().clear();
    assertTrue(getMap().isEmpty());
    assertTrue(inv.isEmpty());
  }

  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testClearInverseClears() {
    BiMap<V, K> inv = getMap().inverse();

    return delegate().removeAll(key);
  }

  @CanIgnoreReturnValue
  @Override
  public List<V> replaceValues(@ParametricNullness K key, Iterable<? extends V> values) {
    return delegate().replaceValues(key, values);
  }

    assertTrue(getMap().isEmpty());
    assertTrue(inv.isEmpty());
  }

  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testValuesClearClearsInverse() {
    BiMap<V, K> inv = getMap().inverse();
    getMap().values().clear();
    assertTrue(getMap().isEmpty());
    assertTrue(inv.isEmpty());
  }

  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testClearInverseClears() {
    BiMap<V, K> inv = getMap().inverse();

        // nothing
    }

    public ExtractData(final String content) {
        this.content = content;
    }

    public void putValues(final String key, final String[] values) {
        metadata.put(key, values);
    }

    public void putValue(final String key, final String value) {
        metadata.put(key, new String[] { value });
    }

    public String[] getValues(final String key) {

  // An array of string values. If the operator is In or NotIn,
  // the values array must be non-empty. If the operator is Exists or DoesNotExist,
  // the values array must be empty. If the operator is Gt or Lt, the values
  // array must have a single element, which will be interpreted as an integer.
  // This array is replaced during a strategic merge patch.
  // +optional
  repeated string values = 3;
}

     *
     * <p>If the graph is directed, the resultant edge will be directed; otherwise, it will be
     * undirected.
     *
     * <p>Values do not have to be unique. However, values must be non-null.
     *
     * <p>If {@code nodeU} and {@code nodeV} are not already present in this graph, this method will

    List<@Nullable Integer> values = Arrays.asList(1, null);
    assertThrows(
        NullPointerException.class,
        () -> Multimaps.index((List<Integer>) values, Functions.identity()));
  }

  public void testIndex_nullKey() {
    List<Integer> values = Arrays.asList(1, 2);
    assertThrows(
        NullPointerException.class, () -> Multimaps.index(values, Functions.constant(null)));
  }

   *
   * <p>Weak values will be garbage collected once they are weakly reachable. This makes them a poor
   * candidate for caching; consider {@link #softValues} instead.
   *
   * <p><b>Note:</b> when this method is used, the resulting cache will use identity ({@code ==})
   * comparison to determine equality of values.
   *

   */
  fun withTag(
    tagClass: Int = DerHeader.TAG_CLASS_CONTEXT_SPECIFIC,
    tag: Long,
  ): BasicDerAdapter<T> = copy(tagClass = tagClass, tag = tag)

  /** Returns a copy of this adapter that doesn't encode values equal to [defaultValue]. */
  fun optional(defaultValue: T? = null): BasicDerAdapter<T> = copy(isOptional = true, defaultValue = defaultValue)

  /**