public void GetAndOutdateTest()
{
var counter = new CounterForBatch();
var cache = ProCacheFactory
.CreateOptions <int, Wrapper>(InfinityTtl, TimeSpan.FromSeconds(1))
.CreateCache(Getter);
var keys = new[] { 1 };
var res1 = cache.Get(keys, counter).Result;
Task.Delay(1000).Wait();
var res2Task = cache.Get(keys, counter).AsTask();
var res3Task = cache.Get(keys, counter).AsTask();
Task.WaitAll(res2Task, res3Task);
var res2 = res2Task.Result;
var res3 = res3Task.Result;
Task.Delay(1000).Wait();
var res4Task = cache.Get(keys, counter).AsTask();
var res5Task = cache.Get(keys, counter).AsTask();
Task.WaitAll(res4Task, res5Task);
var res4 = res4Task.Result;
var res5 = res5Task.Result;
Assert.AreNotSame(res1.Single().Value, res2.Single().Value);
Assert.AreSame(res1.Single().Value, res3.Single().Value);
Assert.AreNotSame(res2.Single().Value, res4.Single().Value);
Assert.AreSame(res2.Single().Value, res5.Single().Value);
Assert.AreEqual(3, counter.Count);
}
public void GetWithException()
{
var counter = new CounterForBatch();
var cache = ProCacheFactory
.CreateOptions <int, Wrapper>(InfinityTtl, InfinityTtl)
.CreateCache(Getter);
counter.WithThrow = true;
var key = 1;
var t1 = Task.Run(() => cache.Get(key, counter).AsTask());
var t2 = Task.Run(() => cache.Get(key, counter).AsTask());
var ex1 = Assert.CatchAsync(() => t1);
var ex2 = Assert.CatchAsync(() => t2);
counter.WithThrow = false;
var t3 = Task.Run(() => cache.Get(key, counter).AsTask());
var t4 = Task.Run(() => cache.Get(key, counter).AsTask());
Task.WaitAll(t3, t4);
var t5 = Task.Run(() => cache.Get(key, counter).AsTask());
var t6 = Task.Run(() => cache.Get(key, counter).AsTask());
Task.WaitAll(t5, t6);
Assert.AreEqual(2, counter.Count);
}
public void GetPartialTest()
{
var counter = new CounterForBatch();
var cache = ProCacheFactory
.CreateOptions <int, Wrapper>(InfinityTtl, InfinityTtl)
.CreateCache(GetterPatial);
var keys = Enumerable.Range(0, SET_COUNT);
var r1 = new Dictionary <int, Wrapper>(cache.Get(keys, counter).Result);
var r2 = new Dictionary <int, Wrapper>(cache.Get(keys, counter).Result);
for (var i = 0; i < SET_COUNT; i++)
{
if (r1.TryGetValue(i, out var v1))
{
Assert.AreEqual(i, v1.Value);
}
else
{
Assert.AreEqual(1, i % 2);
}
if (r2.TryGetValue(i, out var v2))
{
Assert.AreEqual(i, v2.Value);
}
else
{
Assert.AreEqual(1, i % 2);
}
}
Assert.AreEqual(1, counter.Count);
}
public void GetWithQueueTest()
{
var cache = ProCacheFactory
.CreateOptions <int, float>(InfinityTtl, InfinityTtl, 600, 1)
.CreateCache(SimpleGetter);
var keys1 = Enumerable.Range(0, SET_COUNT);
var keys2 = Enumerable.Range(SET_COUNT - 1, SET_COUNT);
var keys3 = Enumerable.Range(SET_COUNT, SET_COUNT);
var res1Comp = cache.TryGet(keys1, out var res1);
var res2Comp = cache.TryGet(keys2, out var res2);
var res3Comp = cache.TryGet(keys3, out var res3);
Assert.IsTrue(res1Comp);
Assert.IsFalse(res2Comp);
Assert.IsTrue(res3Comp);
Task.WaitAll(res1.AsTask(), res2.AsTask(), res3.AsTask());
var res4Comp = cache.TryGet(keys1, out var _);
var res5Comp = cache.TryGet(keys2, out var _);
var res6Comp = cache.TryGet(keys3, out var _);
Assert.IsTrue(res4Comp);
Assert.IsTrue(res5Comp);
Assert.IsTrue(res6Comp);
}
public void GetAgainTest()
{
var setCount = SET_COUNT / 2;
var counter = new Counter();
var cache = ProCacheFactory
.CreateOptions <int, Wrapper>(InfinityTtl, InfinityTtl)
.CreateCache(Getter);
var result = new Task <Wrapper> [setCount * 2];
for (var i = 0; i < setCount; i++)
{
result[i] = cache.Get(i, counter).AsTask();
}
for (var i = 0; i < setCount; i++)
{
result[i + setCount] = cache.Get(i, counter).AsTask();
}
Task.WaitAll(result);
for (var i = 0; i < setCount; i++)
{
Assert.AreEqual(i, result[i].Result.Value);
}
for (var i = 0; i < setCount; i++)
{
Assert.AreEqual(i, result[i + setCount].Result.Value);
}
Assert.AreEqual(setCount, counter.Count);
}
public void GetTest()
{
var counter = new CounterForBatch();
var cache = ProCacheFactory
.CreateOptions <int, Wrapper>(InfinityTtl, InfinityTtl)
.CreateCache(Getter);
var keys = Enumerable.Range(0, SET_COUNT);
var t1 = Task.Run(() => cache.Get(keys, counter).AsTask());
var t2 = Task.Run(() => cache.Get(keys, counter).AsTask());
var t3 = Task.Run(() => cache.Get(keys, counter).AsTask());
Task.WaitAll(t1, t2, t3);
var r1 = new Dictionary <int, Wrapper>(t1.Result);
var r2 = new Dictionary <int, Wrapper>(t2.Result);
var r3 = new Dictionary <int, Wrapper>(t3.Result);
for (var i = 0; i < SET_COUNT; i++)
{
Assert.AreEqual(i, r1[i].Value);
Assert.AreEqual(i, r2[i].Value);
Assert.AreEqual(i, r3[i].Value);
}
var cnt = counter.GetKeysCount().Sum();
Assert.AreEqual(SET_COUNT, cnt);
}
public void GetAndOutdateTest()
{
var counter = new Counter();
var cache = ProCacheFactory
.CreateOptions <int, Wrapper>(InfinityTtl, TimeSpan.FromSeconds(1))
.CreateCache(Getter);
var res1 = cache.Get(1, counter).Result;
Task.Delay(1000).Wait();
var res2Task = cache.Get(1, counter).AsTask();
var res3Task = cache.Get(1, counter).AsTask();
Task.WaitAll(res2Task, res3Task);
var res2 = res2Task.Result;
var res3 = res3Task.Result;
Task.Delay(1000).Wait();
var res4Task = cache.Get(1, counter).AsTask();
var res5Task = cache.Get(1, counter).AsTask();
Task.WaitAll(res4Task, res5Task);
var res4 = res4Task.Result;
var res5 = res5Task.Result;
Assert.AreNotSame(res1, res2);
Assert.AreSame(res1, res3);
Assert.AreNotSame(res2, res4);
Assert.AreSame(res2, res5);
Assert.AreEqual(3, counter.Count);
}
public void Example()
{
ValueTask <float> getter(int key, CancellationToken cancellation) => new ValueTask <float>(key);
var cache = ProCacheFactory
.CreateOptions <int, float>(expire_ttl: TimeSpan.FromSeconds(120), outdate_ttl: TimeSpan.FromSeconds(60))
.CreateCache(getter);
var result = cache.Get(1).Result;
Assert.AreEqual(result, (float)1);
}
public void Example()
{
ValueTask <IEnumerable <KeyValuePair <int, float> > > getter(int[] keys, CancellationToken cancellation)
=> new ValueTask <IEnumerable <KeyValuePair <int, float> > >(keys.Select(k => new KeyValuePair <int, float>(k, k)));
var cache = ProCacheFactory
.CreateOptions <int, float>(expire_ttl: TimeSpan.FromSeconds(120), outdate_ttl: TimeSpan.FromSeconds(60))
.CreateCache(getter);
var from1to3 = cache.Get(Enumerable.Range(1, 3)).Result;
var from1to6 = cache.Get(Enumerable.Range(1, 6)).Result;
CollectionAssert.AreEqual(new[] { KeyValuePair.Create(1, 1f), KeyValuePair.Create(2, 2f), KeyValuePair.Create(3, 3f) }, from1to3);
CollectionAssert.AreEqual(new[] { KeyValuePair.Create(1, 1f), KeyValuePair.Create(2, 2f), KeyValuePair.Create(3, 3f), KeyValuePair.Create(4, 4f), KeyValuePair.Create(5, 5f), KeyValuePair.Create(6, 6f) }, from1to6);
}
public void HookTest()
{
var miss = new List <int>();
var outdated = new List <int>();
var expired = new List <int>();
ProactiveCache.ProCacheHook <int, float> hook = (k, v, r) =>
{
switch (r)
{
case ProactiveCache.ProCacheHookReason.Miss:
lock (miss)
miss.Add(k);
break;
case ProactiveCache.ProCacheHookReason.Outdated:
lock (outdated)
outdated.Add(k);
break;
case ProactiveCache.ProCacheHookReason.Expired:
lock (expired)
expired.Add(k);
break;
}
};
var cache = ProCacheFactory
.CreateOptions <int, float>(TimeSpan.FromSeconds(3), TimeSpan.FromSeconds(1), 1)
.CreateCache(SimpleGetter, hook);
cache.Get(1);
cache.Get(2);
cache.Get(3);
Task.Delay(1300).Wait();
cache.Get(2);
cache.Get(3);
cache.Get(4);
Task.Delay(3100).Wait();
cache.Get(5);
Task.Delay(100).Wait();
Assert.That(new[] { 1, 2, 3, 4, 5 }, Is.EquivalentTo(miss.OrderBy(e => e)));
Assert.That(new[] { 2, 3 }, Is.EquivalentTo(outdated.OrderBy(e => e)));
Assert.That(new[] { 1, 2, 3, 4 }, Is.EquivalentTo(expired.OrderBy(e => e)));
}
public void GetIntersectTest()
{
var counter = new CounterForBatch();
var cache = ProCacheFactory
.CreateOptions <int, Wrapper>(InfinityTtl, InfinityTtl)
.CreateCache(Getter);
var count = SET_COUNT / 3;
var r1 = (0, count);
var r2 = (SET_COUNT / 4, SET_COUNT / 2);
var r3 = (SET_COUNT - count, count);
var k1 = Enumerable.Range(r1.Item1, r1.Item2);
var k2 = Enumerable.Range(r2.Item1, r2.Item2);
var k3 = Enumerable.Range(r3.Item1, r3.Item2);
var t1 = Task.Run(() => cache.Get(k1, counter).AsTask());
var t2 = Task.Run(() => cache.Get(k2, counter).AsTask());
var t3 = Task.Run(() => cache.Get(k3, counter).AsTask());
Task.WaitAll(t1, t2, t3);
var v1 = new Dictionary <int, Wrapper>(t1.Result);
var v2 = new Dictionary <int, Wrapper>(t2.Result);
var v3 = new Dictionary <int, Wrapper>(t3.Result);
for (var i = 0; i < SET_COUNT; i++)
{
if (i >= r1.Item1 && i < r1.Item1 + r1.Item2)
{
Assert.AreEqual(i, v1[i].Value);
}
if (i >= r2.Item1 && i < r2.Item1 + r2.Item2)
{
Assert.AreEqual(i, v2[i].Value);
}
if (i >= r3.Item1 && i < r3.Item1 + r3.Item2)
{
Assert.AreEqual(i, v3[i].Value);
}
}
var cnt = counter.GetKeysCount().Sum();
Assert.AreEqual(SET_COUNT, cnt);
Assert.AreEqual(3, counter.Count);
}
public void GetAndExpireTest()
{
var counter = new Counter();
var cache = ProCacheFactory
.CreateOptions <int, Wrapper>(TimeSpan.FromSeconds(1), TimeSpan.Zero)
.CreateCache(Getter);
var res1 = cache.Get(1, counter).Result;
var res2 = cache.Get(1, counter).Result;
Task.Delay(1000).Wait();
var res3 = cache.Get(1, counter).Result;
var res4 = cache.Get(1, counter).Result;
Assert.AreSame(res1, res2);
Assert.AreNotSame(res1, res3);
Assert.AreSame(res3, res4);
Assert.AreEqual(2, counter.Count);
}
public void GetAndExpireTest()
{
var counter = new CounterForBatch();
var cache = ProCacheFactory
.CreateOptions <int, Wrapper>(TimeSpan.FromSeconds(1), TimeSpan.Zero)
.CreateCache(Getter);
var keys = new[] { 1 };
var res1 = cache.Get(keys, counter).Result;
var res2 = cache.Get(keys, counter).Result;
Task.Delay(1000).Wait();
var res3 = cache.Get(keys, counter).Result;
var res4 = cache.Get(keys, counter).Result;
Assert.AreSame(res1.Single().Value, res2.Single().Value);
Assert.AreNotSame(res1.Single().Value, res3.Single().Value);
Assert.AreSame(res3.Single().Value, res4.Single().Value);
Assert.AreEqual(2, counter.Count);
}
public void GetWithQueueSyncTest()
{
var cache = ProCacheFactory
.CreateOptions <int, int>(TimeSpan.FromSeconds(2), TimeSpan.Zero, 600, 0)
.CreateCache(SyncSimpleGetter);
var res1Comp = cache.TryGet(1, out var res1);
var res2Comp = cache.TryGet(1, out var res2);
var res3Comp = cache.TryGet(2, out var res3);
var res4Comp = cache.TryGet(2, out var res4);
Assert.IsTrue(res1.IsCompletedSuccessfully);
Assert.IsTrue(res2.IsCompletedSuccessfully);
Assert.IsTrue(res1Comp);
Assert.IsTrue(res2Comp);
Assert.IsTrue(res3.IsCompletedSuccessfully);
Assert.IsTrue(res4.IsCompletedSuccessfully);
Assert.IsFalse(res3Comp);
Assert.IsFalse(res4Comp);
}
public void HookTest()
{
var miss = new List <int>();
var outdated = new List <int>();
var expired = new List <int>();
ProactiveCache.ProCacheBatchHook <int, float> hook = (i, r) =>
{
switch (r)
{
case ProactiveCache.ProCacheHookReason.Miss:
miss.AddRange(i.Select(e => e.Key));
break;
case ProactiveCache.ProCacheHookReason.Outdated:
outdated.AddRange(i.Select(e => e.Key));
break;
case ProactiveCache.ProCacheHookReason.Expired:
expired.AddRange(i.Select(e => e.Key));
break;
}
};
var cache = ProCacheFactory
.CreateOptions <int, float>(TimeSpan.FromSeconds(3), TimeSpan.FromSeconds(1), 1)
.CreateCache(SimpleGetter, hook);
cache.Get(Enumerable.Range(1, 3));
Task.Delay(1300).Wait();
cache.Get(Enumerable.Range(2, 3));
Task.Delay(3100).Wait();
cache.Get(Enumerable.Range(5, 1));
Task.Delay(100).Wait();
Assert.That(new[] { 1, 2, 3, 4, 5 }, Is.EquivalentTo(miss.OrderBy(e => e)));
Assert.That(new[] { 2, 3 }, Is.EquivalentTo(outdated.OrderBy(e => e)));
Assert.That(new[] { 1, 2, 3, 4 }, Is.EquivalentTo(expired.OrderBy(e => e)));
}
public void GetOutdatedWithException()
{
var counter = new CounterForBatch();
var cache = ProCacheFactory
.CreateOptions <int, Wrapper>(InfinityTtl, TimeSpan.FromSeconds(1))
.CreateCache(Getter);
var keys = 1;
var r1 = cache.Get(keys, counter).Result;
Task.Delay(1500).Wait();
counter.WithThrow = true;
var t2 = cache.Get(keys, counter).AsTask();
var t3 = cache.Get(keys, counter).AsTask();
var ex2 = Assert.CatchAsync(() => t2);
var r3 = t3.Result;
Assert.AreSame(r1, r3);
counter.WithThrow = false;
var t4 = cache.Get(keys, counter).AsTask();
var t5 = cache.Get(keys, counter).AsTask();
Task.WaitAll(t4, t5);
var r4 = t4.Result;
var r5 = t5.Result;
Assert.AreNotSame(r1, r4);
Assert.AreSame(r1, r5);
}
public void GetWithQueueTest()
{
var cache = ProCacheFactory
.CreateOptions <int, float>(TimeSpan.FromSeconds(2), TimeSpan.Zero, 600, 2)
.CreateCache(SimpleGetter);
var res1Comp = cache.TryGet(1, out var res1);
var res2Comp = cache.TryGet(1, out var res2);
var res3Comp = cache.TryGet(1, out var res3);
Assert.IsTrue(res1Comp);
Assert.IsTrue(res2Comp);
Assert.IsFalse(res3Comp);
Task.WaitAll(res1.AsTask(), res2.AsTask(), res3.AsTask());
var res4Comp = cache.TryGet(1, out var _);
var res5Comp = cache.TryGet(1, out var _);
var res6Comp = cache.TryGet(1, out var _);
Assert.IsTrue(res4Comp);
Assert.IsTrue(res5Comp);
Assert.IsTrue(res6Comp);
}
