private var lastTimestampNs: Long? = null

  /** Confirm that the thread does not hold a lock on `lock` during the callback. */
  fun forbidLock(lock: Any) {
    forbiddenLocks.add(lock)
  }

  /**
   * Removes recorded events up to (and including) an event is found whose class equals [eventClass]
   * and returns it.
   */
  fun <T : ConnectionEvent> removeUpToEvent(eventClass: Class<T>): T {

		}
		return ent.Value, true
	}
	return
}

// Remove removes the provided key from the cache, returning if the
// key was contained.
func (c *LRU[K, V]) Remove(key K) bool {
	c.mu.Lock()
	defer c.mu.Unlock()
	if ent, ok := c.items[key]; ok {
		c.removeElement(ent)
		return true
	}
	return false
}

// RemoveOldest removes the oldest item from the cache.

   */
  void add(Range<C> range);

  /**
   * Removes the specified range from this {@code RangeSet} (optional operation). After this
   * operation, if {@code range.contains(c)}, {@code this.contains(c)} will return {@code false}.
   *
   * <p>If {@code range} is empty, this is a no-op.
   *
   * @throws UnsupportedOperationException if this range set does not support the {@code remove}
   *     operation
   */

      if (entryPredicate.apply(entry) && Objects.equals(entry.getValue(), o)) {
        unfilteredItr.remove();
        return true;
      }
    }
    return false;
  }

  @Override
  public boolean removeAll(Collection<?> c) {
    return Iterables.removeIf(
        multimap.unfiltered().entries(),
        and(multimap.entryPredicate(), valuePredicateOnEntries(in(c))));
  }

  @Override

   * Returns the next element in the iteration, without advancing the iteration.
   *
   * <p>Calls to {@code peek()} should not change the state of the iteration, except that it
   * <i>may</i> prevent removal of the most recent element via {@link #remove()}.
   *
   * @throws NoSuchElementException if the iteration has no more elements according to {@link
   *     #hasNext()}
   */
  @ParametricNullness
  E peek();

  /**

            // Clear failover state on success
            failoverStates.remove(channel.getChannelId());

            log.info("Successfully recovered channel {}", channel.getChannelId());

        } catch (Exception e) {
            log.warn("Failed to recover channel {}: {}", channel.getChannelId(), e.getMessage());

            // Schedule next retry or remove
            handleFailure(channel, e);
        }
    }

		evnot.bucketRulesMap[bucketName] = rulesMap
	}
}

// RemoveNotification - removes all notification configuration for bucket name.
func (evnot *EventNotifier) RemoveNotification(bucketName string) {
	evnot.Lock()
	defer evnot.Unlock()

	delete(evnot.bucketRulesMap, bucketName)
}

// RemoveAllBucketTargets - closes and removes all notification targets.
func (evnot *EventNotifier) RemoveAllBucketTargets() {

        @Test
        @DisplayName("Should handle concurrent remove operations")
        void testConcurrentRemoveOperations() throws InterruptedException {
            // Given
            SmbTransport transport2 = mock(SmbTransport.class);
            doNothing().when(transportPool).removeTransport(any());

            // When - simulate concurrent removes

  /** Removes all associations from this range map (optional operation). */
  void clear();

  /**
   * Removes all associations from this range map in the specified range (optional operation).
   *
   * <p>If {@code !range.contains(k)}, {@link #get(Comparable) get(k)} will return the same result
   * before and after a call to {@code remove(range)}. If {@code range.contains(k)}, then after a

      boolean removal = (maximumSize == UNSET_INT) ? false : (size() > maximumSize);
      if ((removalListener != null) && removal) {
        removalListener.onRemoval(
            RemovalNotification.create(
                ignored.getKey(), ignored.getValue().getValue(), RemovalCause.SIZE));
      }
      statsCounter.recordEviction();
      return removal;
    }
  }

  /**