* The entry was manually removed by the user. This can result from the user invoking {@link
   * Cache#invalidate}, {@link Cache#invalidateAll(Iterable)}, {@link Cache#invalidateAll()}, {@link
   * Map#remove}, {@link ConcurrentMap#remove}, or {@link Iterator#remove}.
   */
  EXPLICIT {
    @Override
    boolean wasEvicted() {
      return false;
    }
  },

  /**

  }

  @Override
  public void add(Range<C> range) {
    throw new UnsupportedOperationException();
  }

  @Override
  public void remove(Range<C> range) {
    throw new UnsupportedOperationException();
  }

  @Override
  public void clear() {
    remove(Range.<C>all());
  }

  @Override
  public boolean enclosesAll(RangeSet<C> other) {
    return enclosesAll(other.asRanges());
  }

  @Override

   *
   * <p>To both remove the element and obtain the previous count of that element, use {@link
   * #remove(Object, int) remove}{@code (element, 1)} instead.
   *
   * @param element the element to remove one occurrence of
   * @return {@code true} if an occurrence was found and removed
   */
  @CanIgnoreReturnValue
  @Override
  boolean remove(@Nullable Object element);

  /**

          return eventClass.cast(event)
        }
      }
    } catch (e: NoSuchElementException) {
      throw AssertionError("full event sequence: $fullEventSequence", e)
    }
  }

  /**
   * Remove and return the next event from the recorded sequence.
   *
   * @param eventClass a class to assert that the returned event is an instance of, or null to
   *     take any event class.

    }

    /**
     *
     */
    private void doClose() {
        this.treeHandle.release();
        this.next = null;
    }

    @Override
    public void remove() {
        throw new UnsupportedOperationException("remove");
    }

        }
      };
  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);
  }

                return mockResource1;
            }
        };

        // When
        iterator.next(); // Move to first element
        iterator.remove();

        // Then
        verify(mockDelegate).remove();
    }

    /**
     * Test multiple calls to hasNext without calling next.
     */
    @Test
    void testMultipleHasNextCalls() {
        // Given

     */
    @Override
    public void close() throws CIFSException {
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.CloseableIterator#remove()
     */
    @Override
    public void remove() {
    }

func Lstat(name string) (info os.FileInfo, err error) {
	defer updateOSMetrics(osMetricLstat, name)(err)
	return os.Lstat(name)
}

// Remove captures time taken to call os.Remove
func Remove(deletePath string) (err error) {
	defer updateOSMetrics(osMetricRemove, deletePath)(err)
	return os.Remove(deletePath)
}

// Stat captures time taken to call os.Stat
func Stat(name string) (info os.FileInfo, err error) {

    map.remove("a");
    assertFalse(underlying.containsKey("a"));

    Set<String> keys = map.keySet();
    keys.remove("b");
    assertFalse(underlying.containsKey("b"));

    Iterator<String> keyIterator = keys.iterator();
    keyIterator.next();
    keyIterator.remove();
    assertFalse(underlying.containsKey("c"));