synchronized (finishedSessionIdList) {
            finishedSessionIdList.add(sessionId);
        }
    }

    /**
     * Deletes all data associated with a specific crawler session.
     * Removes URL filters, URL queues, and access result data for the session.
     *
     * @param sessionId the session ID whose data should be deleted
     */
    private void deleteBySessionId(final String sessionId) {

      assertNull(table.get("foo", 3));
      assertNull(table.remove(null, 1));
      assertNull(table.remove("foo", null));
      assertNull(table.remove(null, null));
      assertSize(2);
    } else {
      assertThrows(UnsupportedOperationException.class, () -> table.remove("foo", 3));
      assertEquals((Character) 'c', table.get("foo", 3));
    }
  }

  public void testRowClearAndPut() {
    if (supportsRemove()) {

    assertThrows(UnsupportedOperationException.class, () -> collection.remove(e0()));
    expectUnchanged();
    assertTrue("remove(present) should not remove the element", collection.contains(e0()));
  }

  @CollectionFeature.Require(absent = SUPPORTS_REMOVE)
  public void testRemove_unsupportedNotPresent() {
    try {
      assertFalse(
          "remove(notPresent) should return false or throw UnsupportedOperationException",

    derivedFeatures.remove(CollectionFeature.GENERAL_PURPOSE);
    derivedFeatures.remove(CollectionFeature.SUPPORTS_ADD);
    derivedFeatures.remove(CollectionFeature.ALLOWS_NULL_VALUES);
    derivedFeatures.add(CollectionFeature.REJECTS_DUPLICATES_AT_CREATION);
    if (!derivedFeatures.remove(CollectionFeature.SERIALIZABLE_INCLUDING_VIEWS)) {
      derivedFeatures.remove(CollectionFeature.SERIALIZABLE);
    }

    /**
     * Test sitemaps add and remove operations
     */
    public void test_sitemaps() {
        // Initial state
        assertNull(crawlerContext.removeSitemaps());

        // Add sitemaps
        String[] sitemaps = new String[] { "http://example.com/sitemap.xml", "http://test.com/sitemap.xml" };
        crawlerContext.addSitemaps(sitemaps);

        // Remove and verify

    map.put(one, two);
    map.remove(one);
    assertNotified(listener, one, two, RemovalCause.EXPLICIT);

    map.put(two, three);
    map.remove(two, three);
    assertNotified(listener, two, three, RemovalCause.EXPLICIT);

    map.put(three, four);
    Iterator<?> i = map.entrySet().iterator();
    i.next();
    i.remove();
    assertNotified(listener, three, four, RemovalCause.EXPLICIT);

    assertThat(callbacks.remove()).isEqualTo(Event(null, "add", "73857293"))
    assertThat(callbacks.remove()).isEqualTo(Event(null, "remove", "2153"))
    assertThat(callbacks.remove()).isEqualTo(Event(null, "add", "113411"))
  }

  @Test
  fun commentsIgnored() {
    consumeEvents(
      """
      |: test stream
      |
      |data: first event
      |id: 1
      |
      |
      """.trimMargin(),
    )

    assertThrows(UnsupportedOperationException.class, () -> getMap().remove(k0()));
    expectUnchanged();
    assertEquals("remove(present) should not remove the element", v0(), get(k0()));
  }

  @MapFeature.Require(absent = SUPPORTS_REMOVE)
  public void testRemove_unsupportedNotPresent() {
    try {
      assertNull(
          "remove(notPresent) should return null or throw UnsupportedOperationException",

                if (from == Bound.NO_BOUND) {
                  extremeValues.remove(0);
                  extremeValues.remove(0);
                }
                if (to == Bound.NO_BOUND) {
                  extremeValues.remove(extremeValues.size() - 1);
                  extremeValues.remove(extremeValues.size() - 1);
                }

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