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

        return delegate().iterator();
      }

      @Override
      public int size() {
        return delegate().size();
      }

      @Override
      public boolean remove(Object o) {
        return delegate().remove(o);
      }

      @Override
      public void clear() {
        delegate().clear();
      }
    };
  }

  @Override
  public @Nullable Entry<K, V> firstEntry() {

                    // Stop async notification monitoring
                    stopAsyncNotificationMonitoring(registration.getRegistrationId());

                    registrations.remove(registration.getRegistrationId());
                    listeners.remove(registration.getRegistrationId());

                    log.info("Successfully unregistered witness: {}", registration.getRegistrationId());
                } else {

          }

          @Override
          public T next() {
            return listIter.previous();
          }

          @Override
          public void remove() {
            listIter.remove();
          }
        };
  }

  static <T extends @Nullable Object> Iterator<T> cycle(Iterable<T> iterable) {
    return new Iterator<T>() {

        Object key = warmed.get(i - WARMUP_MIN).getKey();
        Object value = warmed.get(i - WARMUP_MIN).getValue();
        assertThat(cache.asMap().remove(key, -1)).isFalse();
        assertThat(cache.asMap().remove(key, value)).isTrue();
        assertThat(cache.asMap().remove(key, -1)).isFalse();
        assertThat(cache.asMap().containsKey(key)).isFalse();
      }
      checkEmpty(cache);
    }
  }

    }

    /**
     * Moves the result set to the next position.
     *
     * @param resultSet
     *            The result set. Must not be {@literal null}.
     * @return Whether the result set successfully moved to the next position.
     */
    public static boolean next(final ResultSet resultSet) {
        assertArgumentNotNull("resultSet", resultSet);

        try {
            return resultSet.next();

$TMP_DOWNLOAD_DIR = New-Item -Itemtype Directory -Path "$TMP_DOWNLOAD_DIR_HOLDER.dir"
$TMP_DOWNLOAD_DIR_HOLDER.Delete() | Out-Null
trap {
  if ($TMP_DOWNLOAD_DIR.Exists) {
    try { Remove-Item $TMP_DOWNLOAD_DIR -Recurse -Force | Out-Null }
    catch { Write-Warning "Cannot remove $TMP_DOWNLOAD_DIR" }
  }
}

New-Item -Itemtype Directory -Path "$MAVEN_HOME_PARENT" -Force | Out-Null

# Download and Install Apache Maven

                return p;
            }
        }
        return null;
    }

    /**
     * Remove all occurances of the given type
     *
     * @param pairs the list of AV pairs to modify
     * @param type the AV pair type to remove
     */
    public static void remove(final List<AvPair> pairs, final int type) {
        final Iterator<AvPair> it = pairs.iterator();
        while (it.hasNext()) {

    assertThat(map.containsKey(one)).isTrue();
    assertThat(map.containsValue(one)).isTrue();
    assertThat(map.remove(one)).isSameInstanceAs(one);
    assertThat(map).isEmpty();

    cache.getUnchecked(one);
    assertThat(map).hasSize(1);
    assertThat(map.remove(one, two)).isFalse();
    assertThat(map.remove(one, one)).isTrue();
    assertThat(map).isEmpty();

    cache.getUnchecked(one);

    assertEquals(Multisets.immutableEntry(k0(), 1), itr.next());
    itr.remove();
    assertTrue(multimap().isEmpty());
  }

  @CollectionSize.Require(SEVERAL)
  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testKeysEntrySetRemove() {
    resetContainer(mapEntry(k0(), v0()), mapEntry(k0(), v1()), mapEntry(k1(), v0()));
    assertTrue(multimap().keys().entrySet().remove(Multisets.immutableEntry(k0(), 2)));