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

              @Override
              public @Nullable String remove(Object key) {
                return map.remove(key);
              }

              class EntrySet extends AbstractSet<Map.Entry<String, String>> {
                @Override
                public Iterator<Entry<String, String>> iterator() {

    rangeSet.add(Range.closed(3, 6));
    rangeSet.remove(Range.closedOpen(1, 3));
    testInvariants(rangeSet);
    assertThat(rangeSet.asRanges()).containsExactly(Range.closed(3, 6));
  }

  public void testRemovePartFromBelowLowerBound() {
    TreeRangeSet<Integer> rangeSet = TreeRangeSet.create();
    rangeSet.add(Range.closed(3, 6));
    rangeSet.remove(Range.closed(1, 3));
    testInvariants(rangeSet);

    }
  }

  /**
   * A sensible definition of {@link #poll} in terms of {@link #remove}. If you override {@link
   * #remove}, you may wish to override {@link #poll} to forward to this implementation.
   *
   * @since 7.0
   */
  protected @Nullable E standardPoll() {
    try {
      return remove();
    } catch (NoSuchElementException caught) {
      return null;
    }
  }

      putNext(this, next);
    }

    void unpark() {
      // This is racy with removeWaiter. The consequence of the race is that we may spuriously call
      // unpark even though the thread has already removed itself from the list. But even if we did
      // use a CAS, that race would still exist (it would just be ever so slightly smaller).
      Thread w = thread;
      if (w != null) {
        thread = null;

    threadPool.shutdown();
    threadPool.awaitTermination(300, SECONDS);
  }

  /**
   * Calls get() repeatedly from many different threads, and tests that all of the removed entries
   * (removed because of size limits or expiration) trigger appropriate removal notifications.
   */
  @GwtIncompatible // QueuingRemovalListener

          stale-issue-label: "stale"
          # reason for closed the issue default value is not_planned
          close-issue-reason: completed
          # List of labels to remove when issues/PRs unstale. 
          labels-to-remove-when-unstale: 'stat:awaiting response'
          only-labels: "stat:awaiting response"
          stale-issue-message: > 

 *
 * <p>For instance, if <i>steps</i> is 5, one example sequence that will be tested is:
 *
 * <ol>
 *   <li>remove();
 *   <li>hasNext()
 *   <li>hasNext();
 *   <li>remove();
 *   <li>next();
 * </ol>
 *
 * <p>This particular order of operations may be unrealistic, and testing all 3^5 of them may be
 * thought of as overkill; however, it's difficult to determine which proper subset of this massive

   */
  @GwtIncompatible
  @J2ktIncompatible
  @CanIgnoreReturnValue
  @IgnoreJRERequirement // TODO: b/288085449 - Remove this once we use library-desugaring scents.
  @Beta // TODO: b/288085449 - Remove @Beta after we're sure that Java 8 APIs are safe for Android
  public FakeTicker advance(Duration duration) {
    return advance(duration.toNanos());
  }

  /**

        }

        return null
    }

    private static String modifierChangeDetail(String modifier, boolean added) {
        return "$modifier modifier was ${added ? "added" : "removed"}"
    }

    assertTrue(result.remove(v0()));
    assertFalse(multimap().containsEntry(k0(), v0()));
    assertEquals(2, multimap().size());
  }

  @CollectionSize.Require(absent = ZERO)
  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testPropagatesRemoveLastElementToMultimap() {
    Collection<V> result = multimap().asMap().get(k0());
    assertTrue(result.remove(v0()));
    assertGet(k0());
  }