assertFailsWith<IllegalStateException> {
      iterator.remove()
    }
  }

  @Test
  fun iteratorRemoveOncePerCallToNext() {
    set("a", "a1", "a2")
    val iterator = cache.snapshots()
    iterator.next().use {
      iterator.remove()
    }
    assertFailsWith<IllegalStateException> {
      iterator.remove()
    }
  }

  @Test

        }
      };
  Stimulus<E, Iterator<E>> remove =
      new Stimulus<E, Iterator<E>>("remove") {
        @Override
        void executeAndCompare(ListIterator<E> reference, Iterator<E> target) {
          internalExecuteAndCompare(reference, target, REMOVE_METHOD);
        }
      };

  List<Stimulus<E, Iterator<E>>> iteratorStimuli() {
    return asList(hasNext, next, remove);
  }

    public MetadataGraph removeVertex(MetadataGraphVertex v) {
        if (vertices != null && v != null) {
            vertices.remove(v);
        }

        if (incidentEdges != null) {
            incidentEdges.remove(v);
        }

        if (excidentEdges != null) {
            excidentEdges.remove(v);
        }

        return this;
    }

public class SetRemoveTester<E> extends AbstractSetTester<E> {
  @CollectionFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(absent = ZERO)
  public void testRemove_present() {
    getSet().remove(e0());
    assertFalse(
        "After remove(present) a set should not contain the removed element.",
        getSet().contains(e0()));
  }

public class SetRemoveTester<E> extends AbstractSetTester<E> {
  @CollectionFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(absent = ZERO)
  public void testRemove_present() {
    getSet().remove(e0());
    assertFalse(
        "After remove(present) a set should not contain the removed element.",
        getSet().contains(e0()));
  }

    }

    @Test
    @DisplayName("Remove delegates to underlying iterator")
    void removeDelegation() {
        when(delegate.hasNext()).thenReturn(false);

        TestIterator iterator = new TestIterator(null);
        iterator.remove();

        verify(delegate).remove();
    }

    @Test
    @DisplayName("Remove propagates UnsupportedOperationException")
    void removeException() {

              @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() {

 *
 * <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

          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: > 

            if (log.isDebugEnabled()) {
                log.debug("Removing transport connection " + trans + " (" + System.identityHashCode(trans) + ")");
            }
            this.connections.remove(trans);
            this.nonPooledConnections.remove(trans);
            activeConnections.decrementAndGet();
            connectionsRemoved.incrementAndGet();
        }
    }

    /**
     * {@inheritDoc}
     *