}
}

// deleteExpired deletes expired records from the oldest bucket, waiting for the newest entry
// in it to expire first.
func (c *LRU[K, V]) deleteExpired() {
	c.mu.Lock()
	bucketIdx := c.nextCleanupBucket
	timeToExpire := time.Until(c.buckets[bucketIdx].newestEntry)
	// wait for newest entry to expire before cleanup without holding lock
	if timeToExpire > 0 {
		c.mu.Unlock()

    return Sets.newHashSetWithExpectedSize(expectedSize);
  }

  /** Returns the platform preferred implementation of a thread-safe hash set. */
  static <E> Set<E> newConcurrentHashSet() {
    return ConcurrentHashMap.newKeySet();
  }

  /**
   * Returns the platform preferred implementation of an insertion ordered set based on a hash
   * table.
   */

        } else if (budgetChars > CONTEXT_TRUNCATION_BUFFER) {
            // Fallback: truncate the newest message to fit
            final LlmMessage newest = history.get(history.size() - 1);
            final String truncated = newest.getContent().substring(0, Math.min(budgetChars, newest.getContent().length()));
            request.addMessage(new LlmMessage(newest.getRole(), truncated));
            if (logger.isDebugEnabled()) {

        for (int i = 0; i < 1100; i++) {
            helper.offer(new LogNotificationEvent(i, "ERROR", "org.test", "msg" + i, null));
        }
        List<LogNotificationEvent> events = helper.drainAll();
        // The newest events should be retained; oldest dropped
        // Last event should be msg1099
        LogNotificationEvent last = events.get(events.size() - 1);
        assertEquals("msg1099", last.getMessage());
    }

)

private class ConcurrentMultiMap<K, V> {
    private val map = ConcurrentHashMap<K, MutableSet<V>>()

    fun add(key: K, value: V) =
        map.computeIfAbsent(key, { _ -> ConcurrentHashMap.newKeySet() }).add(value)

    fun getOrEmpty(key: K): Set<V> = map[key] ?: emptySet()
}

abstract class TestFilesCleanupService @Inject constructor(
    private val fileSystemOperations: FileSystemOperations,

  private var serverSocket: ServerSocket? = null
  private val connectionCount = AtomicInteger()
  private val openSockets: MutableSet<Socket> = ConcurrentHashMap.newKeySet()

  fun play() {
    serverSocket = ServerSocket(0)
    executor.execute {
      val threadName = "SocksProxy ${serverSocket!!.localPort}"
      Thread.currentThread().name = threadName
      try {

        final LlmChatRequest request = new LlmChatRequest();
        client.testAddIntentHistory(request, history);
        // Default: maxMessages=6, maxChars=3000
        // From newest: A2(2), Q2(2+2=4), assistant(500+4=504), Short(5+504=509) => all fit
        assertEquals(4, request.getMessages().size());
    }

    @Test
    public void test_addIntentHistory_maxMessages() {

     * newest entry exceeds the maximum weight all on its own.
     *
     * @param newest the most recently added entry
     */
    @GuardedBy("this")
    void evictEntries(ReferenceEntry<K, V> newest) {
      if (!map.evictsBySize()) {
        return;
      }

      drainRecencyQueue();

     * newest entry exceeds the maximum weight all on its own.
     *
     * @param newest the most recently added entry
     */
    @GuardedBy("this")
    void evictEntries(ReferenceEntry<K, V> newest) {
      if (!map.evictsBySize()) {
        return;
      }

      drainRecencyQueue();

    assertThat(request.header("d")).isEqualTo("f")
    val requestHeaders = request.headers
    assertThat(LinkedHashSet(requestHeaders.values("D"))).isEqualTo(newSet("e", "f"))
    assertThat(LinkedHashSet(requestHeaders.values("d"))).isEqualTo(newSet("e", "f"))
    val response = getResponse(request)
    response.close()
    val recordedRequest = server.takeRequest()