ConcurrentLfu.Clear() polluted by removed items

BitFaster.Caching.UnitTests/Lfu/ConcurrentLfuTests.cs

@@ -56,8 +56,8 @@
         [Fact]
         public async Task WhenKeyIsRequesteItIsCreatedAndCachedAsync()
         {
             var result1 = await cache.GetOrAddAsync(1, valueFactory.CreateAsync).ConfigureAwait(false);
             var result2 = await cache.GetOrAddAsync(1, valueFactory.CreateAsync).ConfigureAwait(false);
 
             valueFactory.timesCalled.Should().Be(1);
             result1.Should().Be(result2);
@@ -66,8 +66,8 @@
         [Fact]
         public async Task WhenKeyIsRequestedWithArgItIsCreatedAndCachedAsync()
         {
             var result1 = await cache.GetOrAddAsync(1, valueFactory.CreateAsync, 9).ConfigureAwait(false);
             var result2 = await cache.GetOrAddAsync(1, valueFactory.CreateAsync, 17).ConfigureAwait(false);
 
             valueFactory.timesCalled.Should().Be(1);
             result1.Should().Be(result2);
@@ -677,15 +677,64 @@
         [Fact]
         public void WhenClearedCacheIsEmpty()
         {
-            cache.GetOrAdd(1, k => k);
-            cache.GetOrAdd(2, k => k);
-            cache.DoMaintenance();
+            int key = 0;
+            const int count = 20;
+
+            for (int j = 0; j < 100;  j++) 
+            { 
+                cache = new ConcurrentLfu<int, int>(1, count, new NullScheduler(), EqualityComparer<int>.Default);
+
+                for (int i = 0; i < count; i++)
+                {
+                    cache.GetOrAdd(key++, k => k);
+                }
 
-            cache.Clear();
-            cache.DoMaintenance();
+                cache.Count.Should().Be(count);
 
-            cache.Count.Should().Be(0);
-            cache.TryGet(1, out var _).Should().BeFalse();
+                cache.Clear();
+
+                cache.Count.Should().Be(0);
+                cache.TryGet(1, out var _).Should().BeFalse();
+            }
+        }
+
+        [Fact]
+        public async Task TestClear()
+        {
+            var cache = new ConcurrentLfuBuilder<string, string>()
+                .WithScheduler(new BackgroundThreadScheduler())
+                .WithCapacity(40)
+                .WithAtomicGetOrAdd()
+                .AsAsyncCache()
+                .Build();
+
+            var emptyCount = 0;
+            for (var a = 0; a < 200; a++)
+            {
+                for (var i = 0; i < 10; i++)
+                {
+                    var str = "a" + i;
+                    await getOrAdd(str);
+                }
+
+                cache.Clear();
+                //cache.Clear(); // attempt to trigger maintenance after previous clear operation
+
+                if (cache.Count != 0)
+                {
+                    emptyCount += cache.Count;
+                    emptyCount += cache.Count;
+                }
+
+
+            }
+
+            emptyCount.Should().Be(0);
+
+            async Task getOrAdd(string key)
+            {
+                await cache.GetOrAddAsync(key, Task.FromResult);
+            }
         }
 
         [Fact]

BitFaster.Caching/Lfu/ConcurrentLfu.cs

@@ -426,7 +426,12 @@ private static void TakeCandidatesInLruOrder(LfuNodeList<K, V> lru, List<LfuNode
 
             while (candidates.Count < itemCount && curr != null)
             {
-                candidates.Add(curr);
+                // LRUs can contain items that are already removed, skip those 
+                if (!curr.WasRemoved)
+                { 
+                    candidates.Add(curr); 
+                }
+
                 curr = curr.Next;
             }
         }