Stabilize tests (#481)

Author: bitfaster

BitFaster.Caching.UnitTests/Atomic/AtomicFactoryTests.cs

@@ -167,56 +167,68 @@ public async Task WhenCallersRunConcurrentlyResultIsFromWinner()
             winnerCount.Should().Be(1);
         }
 
-        [Fact(Skip="Unstable")]
+        [Fact]
         public async Task WhenCallersRunConcurrentlyAndFailExceptionIsPropogated()
         {
-            var enter1 = new ManualResetEvent(false);
-            var enter2 = new ManualResetEvent(false);
-            var factory = new ManualResetEvent(false);
-            var resume = new ManualResetEvent(false);
-
-            var atomicFactory = new AtomicFactory<int, int>();
-            var throwCount = 0;
-
-            Task<int> first = Task.Run(() =>
-            {
-                enter1.Set();
-                return atomicFactory.GetValue(1, k =>
+            int count = 0, timesContended = 0;
+
+            // Overlapping the value factory calls is hard to achieve reliably.
+            // Therefore, try many times and verify it was possible to provoke
+            // at least once.
+            while (count++ < 256)
+            { 
+                var enter1 = new ManualResetEvent(false);
+                var enter2 = new ManualResetEvent(false);
+                var factory = new ManualResetEvent(false);
+                var resume = new ManualResetEvent(false);
+
+                var atomicFactory = new AtomicFactory<int, int>();
+                var throwCount = 0;
+
+                Task<int> first = Task.Run(() =>
                 {
-                    factory.Set();
-                    resume.WaitOne();
-
-                    Interlocked.Increment(ref throwCount);
-                    throw new Exception();
+                    enter1.Set();
+                    return atomicFactory.GetValue(1, k =>
+                    {
+                        factory.Set();
+                        resume.WaitOne();
+
+                        Interlocked.Increment(ref throwCount);
+                        throw new Exception();
+                    });
                 });
-            });
 
-            Task<int> second = Task.Run(() =>
-            {
-                enter2.Set();
-                return atomicFactory.GetValue(1, k =>
+                Task<int> second = Task.Run(() =>
                 {
-                    factory.Set();
-                    resume.WaitOne();
-
-                    Interlocked.Increment(ref throwCount);
-                    throw new Exception();
+                    enter2.Set();
+                    return atomicFactory.GetValue(1, k =>
+                    {
+                        factory.Set();
+                        resume.WaitOne();
+
+                        Interlocked.Increment(ref throwCount);
+                        throw new Exception();
+                    });
                 });
-            });
 
-            enter1.WaitOne();
-            enter2.WaitOne();
-            factory.WaitOne();
-            resume.Set();
+                enter1.WaitOne();
+                enter2.WaitOne();
+                factory.WaitOne();
+                resume.Set();
 
-            Func<Task> act1 = () => first;
-            Func<Task> act2 = () => second;
+                Func<Task> act1 = () => first;
+                Func<Task> act2 = () => second;
 
-            await act1.Should().ThrowAsync<Exception>();
-            await act2.Should().ThrowAsync<Exception>();
+                await act1.Should().ThrowAsync<Exception>();
+                await act2.Should().ThrowAsync<Exception>();
+
+                if (throwCount == 1)
+                {
+                    timesContended++;
+                }
+            }
 
-            // verify only one exception was thrown
-            throwCount.Should().Be(1);
+            timesContended.Should().BeGreaterThan(0);
         }
 
         [Fact]

BitFaster.Caching.UnitTests/Lru/ConcurrentLruAfterAccessTests.cs

@@ -96,15 +96,22 @@ public void WhenItemIsUpdatedTtlIsExtended()
         [Fact]
         public void WhenItemIsReadTtlIsExtended()
         {
-            Timed.Execute(
-                capacity,
-                cap =>
-                {
-                    var lru = new ConcurrentLruBuilder<int, string>()
-                        .WithCapacity(cap)
+            var lru = new ConcurrentLruBuilder<int, string>()
+                        .WithCapacity(capacity)
                         .WithExpireAfterAccess(TimeSpan.FromMilliseconds(100))
                         .Build();
 
+            // execute the method to ensure it is always jitted
+            lru.GetOrAdd(-1, valueFactory.Create);
+            lru.GetOrAdd(-2, valueFactory.Create);
+            lru.GetOrAdd(-3, valueFactory.Create);
+
+            Timed.Execute(
+                lru,
+                lru =>
+                {
+                    
+
                     lru.GetOrAdd(1, valueFactory.Create);
 
                     return lru;