* Finally, every possible combination of row and column keys is always considered to have a value
 * associated with it: It is not possible to "remove" a value, only to replace it with {@code null},
 * which will still appear when iterating over the table's contents in a foreach loop or a call to a

    // test that setToTest is still valid
    assertThat(setToTest).isEqualTo(wrappedSet);
    assertThat(setToTest).isEqualTo(copyOfWrappedSet);

    // invalidate setToTest
    wrappedSet.remove(1);
    // sanity check on update of wrappedSet
    assertThat(wrappedSet).isNotEqualTo(copyOfWrappedSet);

    ImmutableSet<Integer> copyOfModifiedSet = ImmutableSet.copyOf(wrappedSet); // {2,3}

          iterator.next();
          iterator.remove();
        });

    Set<Entry<Integer, String>> entries = unmod.entrySet();
    assertThrows(
        UnsupportedOperationException.class,
        () -> {
          Iterator<Entry<Integer, String>> iterator = entries.iterator();
          iterator.next();
          iterator.remove();
        });
    {

     * implementation, because {@code map.get()} returns a view collection that changes in the
     * course of a call to {@code remove()}. Thus, the expectation doesn't hold that {@code
     * map.remove(x)} returns the same value which {@code map.get(x)} did immediately beforehand.
     */
    @Override
    public void testRemove() {
      Map<String, Map<Integer, Character>> map;

        delimiters = settings.get("delimiters", NGramSynonymTokenizer.DEFAULT_DELIMITERS);
        expand = settings.getAsBoolean("expand", true);

        settings.getAsBoolean("expand_ngram", false); // TODO remove

        synonymLoader = new SynonymLoader(env, settings, expand, SynonymLoader.getAnalyzer(ignoreCase));
        if (synonymLoader.getSynonymMap() == null) {
            if (settings.getAsList("synonyms", null) != null) {

    String[] strings = this.strings;
    for (int i = 0; i < reps; i++) {
      for (int j = 0; j < capacity; j++) {
        queue.add(strings[j]);
      }
      for (int j = 0; j < capacity; j++) {
        queue.remove();
      }
    }
  }

  @CollectionSize.Require(absent = {ZERO, ONE})
  public void testSubList_subListRemoveAffectsOriginalLargeList() {
    List<E> subList = getList().subList(1, 3);
    subList.remove(e2());
    List<E> expected = copyToList(createSamplesArray());
    expected.remove(2);
    expectContents(expected);
  }

  @ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
  @CollectionSize.Require(absent = {ZERO, ONE})

  @CollectionSize.Require(absent = {ZERO, ONE})
  public void testSubList_subListRemoveAffectsOriginalLargeList() {
    List<E> subList = getList().subList(1, 3);
    subList.remove(e2());
    List<E> expected = copyToList(createSamplesArray());
    expected.remove(2);
    expectContents(expected);
  }

  @ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
  @CollectionSize.Require(absent = {ZERO, ONE})

   * assume that using setCount() to increase the count is permitted iff add()
   * is permitted and similarly for decrease/remove(). We assume that a
   * setCount() no-op is permitted if either add() or remove() is permitted,
   * though we also allow it to "succeed" if neither is permitted.
   */

  private void assertSetCount(E element, int count) {

                return actual.toString();
            }

            @Override
            public Source resolve(String relative) {
                return Sources.buildSource(actual.resolve(relative));
            }

            @Override
            public ModelSource resolve(ModelLocator modelLocator, String relative) {