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

    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

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

    assertTrue(cycle.hasNext());
    assertThrows(IllegalStateException.class, () -> cycle.remove());
  }

  public void testCycleRemoveSameElementTwice() {
    Iterator<String> cycle = Iterators.cycle("a", "b");
    cycle.next();
    cycle.remove();
    assertThrows(IllegalStateException.class, () -> cycle.remove());
  }

  public void testCycleWhenRemoveIsNotSupported() {

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

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

        assertEquals(3, values.length);
        assertEquals("url:test", values[0]);
        assertTrue(values[1].startsWith("time:"));
        assertTrue(values[2].startsWith("done:"));

        localLogMsg.remove();
        crawlerStatsHelper.done(key);
        assertNull(localLogMsg.get());
    }

    @Test
    public void test_beginDoneWithRecord1() {
        String key = "test";
        crawlerStatsHelper.begin(key);

tasks.validatePlugins {
    enableStricterValidation = true
}

// Remove gradleApi() and gradleTestKit() as we want to compile/run against Gradle modules
// TODO consider splitting `java-gradle-plugin` to provide only what's necessary here
configurations.all {
    withDependencies {
        remove(project.dependencies.gradleApi())
        remove(project.dependencies.gradleTestKit())
    }
}

	"testing"
	"time"
)

// Test lock fails.
func TestLockFail(t *testing.T) {
	f, err := os.CreateTemp(t.TempDir(), "lock")
	if err != nil {
		t.Fatal(err)
	}
	f.Close()
	defer func() {
		err = os.Remove(f.Name())
		if err != nil {
			t.Fatal(err)
		}
	}()

	_, err = LockedOpenFile(f.Name(), os.O_APPEND, 0o600)
	if err == nil {
		t.Fatal("Should fail here")
	}
}

// Tests lock directory fail.

    assertFalse(entrySet.remove(immutableEntry(10, 'X')));
    assertTrue(entrySet.remove(immutableEntry(20, 'X')));
    assertFalse(entrySet.remove(immutableEntry(15, 'X')));
    entrySet = row.entrySet();
    assertTrue(entrySet.remove(immutableEntry(10, 'X')));
    assertFalse(entrySet.remove(immutableEntry(20, 'X')));
    assertFalse(entrySet.remove(immutableEntry(15, 'X')));
  }

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