// If above limit, remove the caches with the oldest handout time.
	if len(caches)-len(remove) > metacacheMaxEntries {
		remainCaches := make([]metacache, 0, len(caches)-len(remove))
		for id, cache := range caches {
			if _, ok := remove[id]; ok {
				continue
			}
			remainCaches = append(remainCaches, cache)
		}
		if len(remainCaches) > metacacheMaxEntries {
			// Sort oldest last...

/**
 * Resolves conflicting artifacts by always selecting the oldest declaration. Oldest is defined as the
 * declaration whose version is less according to <code>ArtifactVersion.compareTo</code>.
 *
 * @see ArtifactVersion#compareTo
 * @since 3.0
 */
@Named("oldest")
@Singleton
@Deprecated
public class OldestConflictResolver implements ConflictResolver {

            // key3 should definitely exist (just created)
            assertNotNull(limitedManager.getLease(key3));

            // key1 should have been evicted (oldest)
            assertNull(limitedManager.getLease(key1));

            // key2 should still exist (not the oldest)
            assertNotNull(limitedManager.getLease(key2));
        } finally {
            limitedManager.shutdown();
        }
    }

    @Test

		return true
	}
	return false
}

// RemoveOldest removes the oldest item from the cache.
func (c *LRU[K, V]) RemoveOldest() (key K, value V, ok bool) {
	c.mu.Lock()
	defer c.mu.Unlock()
	if ent := c.evictList.Back(); ent != nil {
		c.removeElement(ent)
		return ent.Key, ent.Value, true
	}
	return
}

// GetOldest returns the oldest entry
func (c *LRU[K, V]) GetOldest() (key K, value V, ok bool) {

        }
    }

    /**
     * Evict oldest leases based on LRU
     *
     * @param count number of leases to evict
     */
    private void evictOldestLeases(int count) {
        if (count <= 0 || leases.isEmpty()) {
            return;
        }

        // Find oldest leases by last access time
        leases.entrySet()
                .stream()

@Deprecated
class OldestConflictResolverTest extends AbstractConflictResolverTest {
    // constructors -----------------------------------------------------------

    OldestConflictResolverTest() throws Exception {
        super("oldest");
    }

    // tests ------------------------------------------------------------------

    /**
     * Tests that <code>a:1.0</code> wins in the scenario:
     * <pre>
     * a:1.0
     * b:1.0 -&gt; a:2.0

    val toEvictIdleAtNs: Long
    when {
      // We had at least one OLD connection. Close the oldest one.
      earliestOldConnection != null -> {
        toEvict = earliestOldConnection
        toEvictIdleAtNs = earliestOldIdleAtNs
      }

      // We have too many EVICTABLE connections. Close the oldest one.
      evictableConnectionCount > maxIdleConnections -> {
        toEvict = earliestEvictableConnection

package org.codelibs.core.collection;

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * {@link HashMap} with an upper limit on the number of entries. When a new entry is added, the oldest entry is discarded using LRU if the limit is exceeded.
 * <p>
 * <strong>Thread-Safety:</strong> This class is <strong>NOT thread-safe</strong>.
 * It extends {@link LinkedHashMap} without synchronization. If multiple threads access

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

    @Test

            }

            final int toRemove = sessionCache.size() - maxSize;
            logger.warn("Session cache reached maximum size. Removing oldest sessions. currentSize={}, maxSize={}, removing={}",
                    sessionCache.size(), maxSize, toRemove);

            // Remove oldest sessions
            sessionCache.entrySet()
                    .stream()