public void SlidingExpiration()
{
var cache = CreateCache();
var fileSize = 10;
var slide = TimeSpan.FromMilliseconds(200);
var calls = 10;
var part = new TimeSpan(2 * slide.Ticks / calls);
var data = FullRead(cache, 123);
Assert.IsNull(data);
//expired long time ago
cache.AddOrUpdateStream(123, GetRandomFile(fileSize), CancellationToken.None,
CacheExpirationPolicy.SlidingUtc(slide));
for (int i = 0; i < calls; i++)
{
data = FullRead(cache, 123);
Assert.IsNotNull(data);
Assert.AreEqual(fileSize, data.Length);
cache.GarbageCollect(CancellationToken.None); //here is expired one collected
Thread.Sleep(part);
}
Thread.Sleep(new TimeSpan(2 * slide.Ticks));
cache.GarbageCollect(CancellationToken.None); //here is expired one collected
data = FullRead(cache, 123);
Assert.IsNull(data);
AssertNoGarbageFiles(cache);
}
public void LockedForReadFileGc()
{
var cache = CreateCache();
var fileSize = 10;
var data = FullRead(cache, 123);
Assert.IsNull(data);
cache.AddOrUpdateStream(123, GetRandomFile(fileSize), CancellationToken.None,
CacheExpirationPolicy.AbsoluteUtc(DateTime.MinValue));
data = FullRead(cache, 123);
Assert.IsNotNull(data);
var ms = new MemoryStream();
using (var s = cache.TryGetStream(123, CancellationToken.None))
{
cache.GarbageCollect(CancellationToken.None); //item is expired but will not be collected.
s.CopyTo(ms);
}
data = FullRead(cache, 123);
Assert.IsNull(data);
AssertHasCachedFiles(cache);
cache.GarbageCollect(CancellationToken.None); //trash collected if not collected on read.
AssertNoCachedFiles(cache);
AssertNoGarbageFiles(cache);
}
public void LockedForReadHardlinkGc()
{
try
{
var cache = CreateCache();
var fileSize = 1 * 1024 * 1024; // 1 mb
cache.AddOrUpdateStream(123, GetRandomFile(fileSize), CancellationToken.None,
CacheExpirationPolicy.AbsoluteUtc(DateTime.MinValue));
var data = FullRead(cache, 123);
Assert.IsNotNull(data);
var targetFilePath = GetRandomPath();
Assert.IsTrue(cache.TryGetFile(123, CancellationToken.None, targetFilePath));
try
{
AssertFile(targetFilePath, fileSize);
AssertHasCachedFiles(cache);
using (var s = File.OpenRead(targetFilePath))
{
var bytes = new byte[8 * 1024];
Assert.IsTrue(s.Read(bytes, 0, bytes.Length) > 0);
cache.GarbageCollect(CancellationToken.None);
}
AssertFile(targetFilePath, fileSize);//item is expired, collected, but available to user
data = FullRead(cache, 123);
Assert.IsNull(data);
cache.GarbageCollect(CancellationToken.None); //trash collected if not collected on read.
AssertNoCachedFiles(cache);
AssertNoGarbageFiles(cache);
AssertFile(targetFilePath, fileSize);
}
finally
{
File.Delete(targetFilePath);
}
}
catch
{
DeleteRandomPaths();
}
}
public async Task AsyncLockedForReadFileGc()
{
try
{
var cache = CreateCache();
var fileSize = 1 * 1024;
var data = FullRead(cache, 123);
Assert.IsNull(data);
var tasks = Enumerable.Range(0, 20).Select(i =>
{
try
{
var filePath = GetRandomPath();
cache.GetFileOrAddStream(123, x => GetRandomFile(fileSize), CancellationToken.None, filePath,
CacheExpirationPolicy.AbsoluteUtc(DateTime.MinValue));
cache.GarbageCollect(CancellationToken.None);
while (true)
{
try
{
AssertFile(filePath, fileSize);
break;
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
throw;
}
return(Task.CompletedTask);
}).ToArray();
await Task.WhenAll(tasks);
cache.GarbageCollect(CancellationToken.None); //trash collected if not collected on read.
AssertNoCachedFiles(cache);
AssertNoGarbageFiles(cache);
}
finally
{
DeleteRandomPaths();
}
}
public void AbsoluteExpiration()
{
var cache = CreateCache();
var fileSize = 1 * 1024;
var data = FullRead(cache, 123);
Assert.IsNull(data);
//expired long time ago
cache.AddOrUpdateStream(123, GetRandomFile(fileSize), CancellationToken.None,
CacheExpirationPolicy.AbsoluteUtc(DateTime.MinValue));
data = FullRead(cache, 123);
Assert.IsNotNull(data);
Assert.AreEqual(fileSize, data.Length);
cache.GarbageCollect(CancellationToken.None); //here is expired one collected
data = FullRead(cache, 123);
Assert.IsNull(data);
AssertNoGarbageFiles(cache);
}
public static async Task GetOrAddAsync_TwoTimesCalledWithNoDateTimeExpire_ResultAlwaysTheSameAndGetValueFuncCalledOneTime(ICache <int, string> cache)
{
const string testValue = "Test1";
var getValueCalled = false;
var getValueCalled1 = false;
var getValueCalled2 = false;
var value = await cache.GetOrAddAsync(1, () =>
{
getValueCalled = true;
return(testValue);
}, CacheExpirationPolicy.AfterAbsoluteDateTime(DateTime.Now.AddMilliseconds(400))).ConfigureAwait(false);
Assert.Equal(testValue, value);
await Task.Delay(50).ConfigureAwait(false);
var secondValue = await cache.GetOrAddAsync(1, () =>
{
getValueCalled1 = true;
return(testValue);
}, CacheExpirationPolicy.AfterAbsoluteDateTime(DateTime.Now.AddMilliseconds(400))).ConfigureAwait(false);
await Task.Delay(400).ConfigureAwait(false);
var thirdValue = await cache.GetOrAddAsync(1, () =>
{
getValueCalled2 = true;
return(testValue);
}, CacheExpirationPolicy.AfterAbsoluteDateTime(DateTime.Now.AddMilliseconds(200))).ConfigureAwait(false);
Assert.Equal(testValue, secondValue);
Assert.Equal(testValue, thirdValue);
Assert.True(getValueCalled);
Assert.False(getValueCalled1);
Assert.True(getValueCalled2);
}
public static async Task GetOrAdd_TwoTimesCalledWithNoTimeSpanExpire_ResultAlwaysTheSameAndGetValueFuncCalledOneTime(ICache <int, string> cache)
{
const string testValue = "Test1";
var getValueCalled = false;
var getValueCalled1 = false;
var getValueCalled2 = false;
var value = cache.GetOrAdd(1, () =>
{
getValueCalled = true;
return(testValue);
}, CacheExpirationPolicy.AfterSlidingTimeSpan(TimeSpan.FromMilliseconds(2000)));
Assert.Equal(testValue, value);
await Task.Delay(1500).ConfigureAwait(false);
var secondValue = cache.GetOrAdd(1, () =>
{
getValueCalled1 = true;
return(testValue);
}, CacheExpirationPolicy.AfterSlidingTimeSpan(TimeSpan.FromMilliseconds(2000)));
await Task.Delay(1500).ConfigureAwait(false);
var thirdValue = cache.GetOrAdd(1, () =>
{
getValueCalled2 = true;
return(testValue);
}, CacheExpirationPolicy.AfterSlidingTimeSpan(TimeSpan.FromMilliseconds(1500)));
Assert.Equal(testValue, secondValue);
Assert.Equal(testValue, thirdValue);
Assert.True(getValueCalled);
Assert.False(getValueCalled1);
Assert.False(getValueCalled2);
}
public static async Task GetOrAddAsync_TwoTimesCalledWithDateTimeExpire_ResultAlwaysTheSameAndGetValueFuncCalledTwoTime(ICache <int, string> cache)
{
const string testValue = "Test1";
var getValueCalledCount = 0;
var value = await cache.GetOrAddAsync(1, () =>
{
getValueCalledCount++;
return(testValue);
}, CacheExpirationPolicy.AfterAbsoluteDateTime(DateTime.Now.AddMilliseconds(50))).ConfigureAwait(false);
Assert.Equal(testValue, value);
await Task.Delay(100).ConfigureAwait(false);
var secondValue = await cache.GetOrAddAsync(1, () =>
{
getValueCalledCount++;
return(testValue);
}, CacheExpirationPolicy.NeverExpire).ConfigureAwait(false);
Assert.Equal(testValue, secondValue);
Assert.Equal(2, getValueCalledCount);
}
/// <summary>
/// CTOR
/// </summary>
public InMemoryCacheConfiguration()
{
ExpirationTime = TimeSpan.FromMinutes(5);
ExpirationPolicy = CacheExpirationPolicy.Sliding;
DataProvider = new InMemoryDataProvider();
}
