soak test ScopedAsyncAtomicFactory (#428)

* soak

* dispose

---------

Author: bitfaster

BitFaster.Caching.UnitTests/Atomic/ScopedAsyncAtomicFactorySoakTests.cs

@@ -0,0 +1,80 @@
+using System.Collections.Concurrent;
+using System.Linq;
+using System.Threading.Tasks;
+using BitFaster.Caching.Atomic;
+using FluentAssertions;
+using Xunit;
+
+namespace BitFaster.Caching.UnitTests.Atomic
+{
+    [Collection("Soak")]
+    public class ScopedAsyncAtomicFactorySoakTests
+    {
+        private const int threads = 4;
+        private const int items = 1024;
+
+        [Fact]
+        public async Task WhenGetOrAddIsConcurrentValuesCreatedAtomically()
+        {
+            var dictionary = new ConcurrentDictionary<int, ScopedAsyncAtomicFactory<int, Disposable>>(concurrencyLevel: threads, capacity: items);
+            var counters = new int[threads];
+
+            await Threaded.RunAsync(threads, async (r) =>
+            {
+                for (int i = 0; i < items; i++)
+                {
+                    while (true)
+                    {
+                        var scope = dictionary.GetOrAdd(i, k => new ScopedAsyncAtomicFactory<int, Disposable>());
+                        var (success, lifetime) = await scope.TryCreateLifetimeAsync(i, k => { counters[r]++; return Task.FromResult(new Scoped<Disposable>(new Disposable(k))); });
+
+                        if (success)
+                        {
+                            using (lifetime)
+                            {
+                                lifetime.Value.IsDisposed.Should().BeFalse();
+                            }
+
+                            break;
+                        }
+                    }
+                }
+            });
+
+            counters.Sum(x => x).Should().Be(items);
+        }
+
+        [Fact]
+        public async Task WhenGetOrAddAndDisposeIsConcurrentLifetimesAreValid()
+        {
+            var dictionary = new ConcurrentDictionary<int, ScopedAsyncAtomicFactory<int, Disposable>>(concurrencyLevel: threads, capacity: items);
+
+            await Threaded.RunAsync(threads, async (r) =>
+            {
+                for (int i = 0; i < items; i++)
+                {
+                    if (dictionary.TryRemove(i, out var d))
+                    {
+                        d.Dispose();
+                    }
+
+                    while (true)
+                    {
+                        var scope = dictionary.GetOrAdd(i, k => new ScopedAsyncAtomicFactory<int, Disposable>());
+                        var (success, lifetime) = await scope.TryCreateLifetimeAsync(i, k => { return Task.FromResult(new Scoped<Disposable>(new Disposable(k))); });
+
+                        if (success)
+                        {
+                            using (lifetime)
+                            {
+                                lifetime.Value.IsDisposed.Should().BeFalse();
+                            }
+
+                            break;
+                        }
+                    }
+                }
+            });
+        }
+    }
+}

BitFaster.Caching.UnitTests/Atomic/ScopedAtomicFactorySoakTests.cs

@@ -10,11 +10,12 @@ namespace BitFaster.Caching.UnitTests.Atomic
     [Collection("Soak")]
     public class ScopedAtomicFactorySoakTests
     {
+        private const int threads = 4;
+        private const int items = 1024;
+
         [Fact]
         public async Task WhenGetOrAddIsConcurrentValuesCreatedAtomically()
         {
-            const int threads = 4;
-            const int items = 1024;
             var dictionary = new ConcurrentDictionary<int, ScopedAtomicFactory<int, Disposable>>(concurrencyLevel: threads, capacity: items);
             var counters = new int[threads];
 
@@ -43,12 +44,9 @@ await Threaded.Run(threads, (r) =>
         }
 
         [Fact]
-        public async Task WhenGetOrAddAndDisposeIsConcurrentValuesCreatedAtomically()
+        public async Task WhenGetOrAddAndDisposeIsConcurrentLifetimesAreValid()
         {
-            const int threads = 4;
-            const int items = 1024;
             var dictionary = new ConcurrentDictionary<int, ScopedAtomicFactory<int, Disposable>>(concurrencyLevel: threads, capacity: items);
-            var counters = new int[threads];
 
             await Threaded.Run(threads, (r) =>
             {
@@ -63,7 +61,7 @@ await Threaded.Run(threads, (r) =>
                     {
                         var scoped = dictionary.GetOrAdd(i, k => new ScopedAtomicFactory<int, Disposable>());
 
-                        if (scoped.TryCreateLifetime(i, k => { counters[r]++; return new Scoped<Disposable>(new Disposable(k)); }, out var lifetime))
+                        if (scoped.TryCreateLifetime(i, k => { return new Scoped<Disposable>(new Disposable(k)); }, out var lifetime))
                         {
                             using (lifetime)
                             {
@@ -73,7 +71,6 @@ await Threaded.Run(threads, (r) =>
                             break;
                         }
                     }
-
                 }
             });
         }