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); }