}

  @Override
  @ParametricNullness
  public final V getValue() {
    return super.getValue();
  }

  @Override
  @ParametricNullness
  public final V setValue(@ParametricNullness V value) {
    return super.setValue(value);
  }

  @Nullable ImmutableMapEntry<K, V> getNextInKeyBucket() {
    return null;
  }

  @Nullable ImmutableMapEntry<K, V> getNextInValueBucket() {
    return null;
  }

        for (final LabelType labelType : labelTypeList) {
            final LabelTypeItem item = new LabelTypeItem();
            item.setLabel(labelType.getName());
            item.setValue(labelType.getValue());
            item.setPermissions(labelType.getPermissions());
            item.setVirtualHost(labelType.getVirtualHost());
            item.setLocale(labelType.getLocale());

    }
    {
      Entry<Integer, String> entry = unmod.lowerEntry(2);
      assertThrows(UnsupportedOperationException.class, () -> entry.setValue("four"));
    }
    {
      Entry<Integer, String> entry = unmod.higherEntry(2);
      assertThrows(UnsupportedOperationException.class, () -> entry.setValue("four"));
    }
    {

      assertEquals(2 * i, (int) inverse.get(2 * i - 1));
    }
    Set<Entry<Integer, Integer>> entries = bimap.entrySet();
    for (Entry<Integer, Integer> entry : entries) {
      entry.setValue(entry.getValue() + 2 * N);
    }
    for (int i = 0; i < N; i++) {
      assertEquals(2 * N + 2 * i - 1, (int) bimap.get(2 * i));
    }
  }

  public void testBiMapEntrySetIteratorRemove() {

   * {@code put()} or {@code putAll()}, or {@code setValue()} on its entries.
   *
   * <p>In contrast, the maps returned by {@code rowMap().get()} have the same behavior as those
   * returned by {@link #row}. Those maps may support {@code setValue()}, {@code put()}, and {@code
   * putAll()}.
   *

    }

    @Override
    public void add(Entry<K, V> e) {
      throw new UnsupportedOperationException();
    }

    void setValue(@ParametricNullness V value) {
      checkState(current != null);
      current.setValue(value);
    }
  }

  /** An {@code Iterator} over distinct keys in key head order. */
  private final class DistinctKeyIterator implements Iterator<K> {

     * @return The value
     */
    public T getValue() {
        return value;
    }

    /**
     * Sets the value.
     *
     * @param value
     *            The value
     */
    public void setValue(final T value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return value.toString();
    }

    }
    {
      Entry<Integer, String> entry = unmod.lowerEntry(2);
      assertThrows(UnsupportedOperationException.class, () -> entry.setValue("four"));
    }
    {
      Entry<Integer, String> entry = unmod.higherEntry(2);
      assertThrows(UnsupportedOperationException.class, () -> entry.setValue("four"));
    }
    {

    /** Clears the reference queues used by this segment, if any. */
    void maybeClearReferenceQueues() {}

    /** Sets the value of the given {@code entry}. */
    void setValue(E entry, V value) {
      this.map.entryHelper.setValue(self(), entry, value);
    }

    /** Returns a copy of the given {@code entry}. */
    @Nullable E copyEntry(E original, E newNext) {

  @Override
  @ParametricNullness
  public abstract K getKey();

  @Override
  @ParametricNullness
  public abstract V getValue();

  @Override
  @ParametricNullness
  public V setValue(@ParametricNullness V value) {
    throw new UnsupportedOperationException();
  }

  @Override
  public boolean equals(@Nullable Object object) {
    if (object instanceof Entry) {