iterator.hasNext());
    iterator.remove();
    assertTrue(
        "multiset isn't empty after multiset.entrySet() iterator.remove()",
        getMultiset().isEmpty());
  }

  @CollectionSize.Require(absent = ZERO)
  @CollectionFeature.Require(SUPPORTS_REMOVE)
  public void testEntrySet_removePresent() {
    assertTrue(
        "multiset.entrySet.remove(presentEntry) returned false",

    assertThat(callbacks.remove()).isEqualTo(Event(null, "add", "73857293"))
    assertThat(callbacks.remove()).isEqualTo(Event(null, "remove", "2153"))
    assertThat(callbacks.remove()).isEqualTo(Event(null, "add", "113411"))
  }

  @Test
  fun commentsIgnored() {
    consumeEvents(
      """
      |: test stream
      |
      |data: first event
      |id: 1
      |
      |
      """.trimMargin(),
    )

            LeaseManager.LeaseEntry leaseEntry = baseLeaseManager.getLease(entry.getLeaseKey());
            if (leaseEntry == null || !leaseEntry.hasReadCache()) {
                // Lease lost, remove cache entry
                directoryCache.remove(directoryPath);
                return null;
            }
        }

        return entry;
    }

    /**
     * Check if directory listing can be cached
     *

	globalCertsDir, err = newConfigDir(certsDir, certsSet, defaultCertsDir.Get)
	logger.FatalIf(err, "Unable to initialize the certs directory")

	// Remove this code when we deprecate and remove config-dir.
	// This code is to make sure we inherit from the config-dir
	// option if certs-dir is not provided.
	if !certsSet && configSet {

    assertThrows(UnsupportedOperationException.class, () -> getMap().remove(k0()));
    expectUnchanged();
    assertEquals("remove(present) should not remove the element", v0(), get(k0()));
  }

  @MapFeature.Require(absent = SUPPORTS_REMOVE)
  public void testRemove_unsupportedNotPresent() {
    try {
      assertNull(
          "remove(notPresent) should return null or throw UnsupportedOperationException",

    map.put(one, two);
    map.remove(one);
    assertNotified(listener, one, two, RemovalCause.EXPLICIT);

    map.put(two, three);
    map.remove(two, three);
    assertNotified(listener, two, three, RemovalCause.EXPLICIT);

    map.put(three, four);
    Iterator<?> i = map.entrySet().iterator();
    i.next();
    i.remove();
    assertNotified(listener, three, four, RemovalCause.EXPLICIT);

      return delegate.poll();
    }

    @Override
    public E remove() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.remove();
    }

    @Override
    public boolean remove(Object object) {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.remove(object);
    }

    @Override
    public @Nullable E peek() {

  @CollectionSize.Require(absent = ZERO)
  public void testRemoveKeyRemovesFromInverse() {
    getMap().remove(k0());
    expectMissing(e0());
  }

  @MapFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(absent = ZERO)
  public void testRemoveKeyFromKeySetRemovesFromInverse() {
    getMap().keySet().remove(k0());
    expectMissing(e0());
  }

  @MapFeature.Require(SUPPORTS_REMOVE)

     * <p>
     * If the array does not contain the object, the original array is returned as is.
     * </p>
     *
     * @param <T>
     *            the type of the array elements
     * @param array
     *            the array
     * @param obj
     *            the element to remove from the array
     * @return the array after removal
     */

  public void testRemoveAtIndex_unsupported() {
    assertThrows(UnsupportedOperationException.class, () -> getList().remove(0));
    expectUnchanged();
  }

  @ListFeature.Require(SUPPORTS_REMOVE_WITH_INDEX)
  public void testRemoveAtIndex_negative() {
    assertThrows(IndexOutOfBoundsException.class, () -> getList().remove(-1));
    expectUnchanged();
  }

  @ListFeature.Require(SUPPORTS_REMOVE_WITH_INDEX)