public void CheckAutoFlush(int attempt)
        {
            const int    maxAttempts      = 10;
            const double autoFlushSeconds = 1d;

            // Don't retry if we don't have too.
            if (_success)
            {
                Assert.True(true);
                return;
            }

            // Detect errors on other threads.
            _unhandledException = null;
            ExceptionManager.UnhandledException += (source, args) =>
            {
                if (!args.Exception.StackTrace.Contains(@"InMemoryCache", StringComparison.OrdinalIgnoreCase))
                {
                    return;
                }
                _unhandledException = args.Exception;
            };

            var c = new InMemoryCache <string, DisposableMock>(TimeSpan.FromSeconds(autoFlushSeconds), s =>
            {
                var mock = new DisposableMock
                {
                    Id = s
                };
                return(mock);
            }, true, false);
            const string key = @"TEST";
            var          x1  = c[key];

            Assert.Equal(key, x1.Id);
            Thread.Sleep(TimeSpan.FromSeconds(autoFlushSeconds * 1.5d));

            // x1 hasn't been disposed of because AutoFlush is off.
            Assert.False(x1.IsDisposed);
            var x2 = c[key];

            // x1 will be disposed of now because it will have been cleared when the item was selected
            Assert.True(x1.IsDisposed);
            Assert.False(x2.IsDisposed);
            Assert.NotSame(x1, x2);

            // Now clear the cache and try again.
            c.Flush();
            c.Clear();
            c.Flush();
            var flushCount = 0;

            c.Flushed    += (a, b) => { Interlocked.Increment(ref flushCount); };
            c.AutoDispose = true;
            c.AutoDispose = true;
            c.AutoFlush   = true;
            c.AutoFlush   = true; // The second call should take a different path - we can check in code coverage to ensure this is the case.
            Assert.True(c.AutoFlush);
            flushCount = 0;
            x1         = c[key];
            Assert.Equal(key, x1.Id);
            Assert.False(x1.IsDisposed);
            var       loops    = 0;
            const int maxLoops = 5;

            Assert.Equal(c.AutoDispose, true);
            Assert.Equal(c.AutoFlush, true);

            // Allow multiple iterations in case there is some thread starvation.
            while ((loops++ < maxLoops) && (flushCount <= 0))
            {
                Assert.Equal(c.AutoDispose, true);
                Assert.Equal(c.AutoFlush, true);

                // While we are asleep all expired members of the cache should be automatically disposed of
                Thread.Sleep(TimeSpan.FromSeconds(autoFlushSeconds));

                Assert.Equal(c.AutoDispose, true);
                Assert.Equal(c.AutoFlush, true);
            }

            try
            {
                Assert.Null(_unhandledException);

                // Now x1 has been disposed, even though it hasn't been re-fetched.
                Assert.True(x1.IsDisposed, "Cached value has been disposed of.");

                // There has been a flush, without us needing to do anything.
                Assert.True(flushCount >= 1, "Auto-flush is responsible for disposing of the cached value.");

                _success = true;
            }
            catch
            {
                if (attempt >= maxAttempts)
                {
                    // Allow a couple of attempts because occasionally it fails for no reason.
                    throw;
                }
            }
        }
 public void Update(IReadOnlyCollection <AssetInvestment> assetInvestments)
 {
     _cache.Clear();
     _cache.Set(assetInvestments);
 }