public void Size_3_Cache_Add_4_Get_Value_1_Should_Return_False() { MemoryCache <Key, Value> cache = new MemoryCache <Key, Value>(3, new KeyComparer()); cache.AddOrUpdate(new Key { x = 1, y = 1 }, new Value { a = 1, b = 1 }); cache.AddOrUpdate(new Key { x = 2, y = 1 }, new Value { a = 2, b = 1 }); cache.AddOrUpdate(new Key { x = 3, y = 1 }, new Value { a = 3, b = 1 }); cache.AddOrUpdate(new Key { x = 4, y = 1 }, new Value { a = 4, b = 1 }); Value value; Assert.IsFalse(cache.TryGetValue(new Key { x = 1, y = 1 }, out value)); }
public void Size_3_Cache_Add_3_Update_1_To_11_Get_Value_1_Should_Return_11() { MemoryCache <Key, Value> cache = new MemoryCache <Key, Value>(3, new KeyComparer()); cache.AddOrUpdate(new Key { x = 1, y = 1 }, new Value { a = 1, b = 1 }); cache.AddOrUpdate(new Key { x = 2, y = 1 }, new Value { a = 2, b = 1 }); cache.AddOrUpdate(new Key { x = 3, y = 1 }, new Value { a = 3, b = 1 }); cache.AddOrUpdate(new Key { x = 1, y = 1 }, new Value { a = 11, b = 1 }); Value value; Assert.IsTrue(cache.TryGetValue(new Key { x = 1, y = 1 }, out value)); Assert.AreEqual(11, value.a); }
public void Size_2_Cache_Add_1_Update_Value_Cache_Size_Should_Be_1() { MemoryCache <int, int> cache = new MemoryCache <int, int>(2); cache.AddOrUpdate(1, 1); cache.AddOrUpdate(1, 2); Assert.AreEqual(1, cache.CurrentSize); }
public void MustGiveSizeOption() { var cache = new MemoryCache <int, string>(10); var options = new CacheEntryOptions(); Assert.ThrowsException <ArgumentException>(() => cache.AddOrUpdate(10, "hello")); Assert.ThrowsException <ArgumentException>(() => cache.AddOrUpdate(10, "hello", options)); }
public void Size_1_Cache_Add_2_Get_Value_1_Should_Return_False() { MemoryCache <int, int> cache = new MemoryCache <int, int>(1); cache.AddOrUpdate(1, 1); cache.AddOrUpdate(2, 2); int value; Assert.IsFalse(cache.TryGetValue(1, out value)); }
public void Size_1_Cache_Add_1_Update_Value_To_5_Value_Should_Be_5() { MemoryCache <int, int> cache = new MemoryCache <int, int>(1); cache.AddOrUpdate(1, 1); cache.AddOrUpdate(1, 5); int value; cache.TryGetValue(1, out value); Assert.AreEqual(5, value); }
public void Size_1_Cache_Add_2_Get_Value_2_Should_Return_2() { MemoryCache <int, int> cache = new MemoryCache <int, int>(1); cache.AddOrUpdate(1, 1); cache.AddOrUpdate(2, 2); int value; Assert.IsTrue(cache.TryGetValue(2, out value)); Assert.AreEqual(2, value); }
public void Size_3_Cache_Add_4_Get_Value_4_Should_Return_True() { MemoryCache <int, int> cache = new MemoryCache <int, int>(3); cache.AddOrUpdate(1, 1); cache.AddOrUpdate(2, 2); cache.AddOrUpdate(3, 3); cache.AddOrUpdate(4, 4); int value; Assert.IsTrue(cache.TryGetValue(4, out value)); }
public void Size_3_Cache_Add_2_Update_1_To_11_Get_Value_1_Should_Return_11() { MemoryCache <int, int> cache = new MemoryCache <int, int>(3); cache.AddOrUpdate(1, 1); cache.AddOrUpdate(2, 2); cache.AddOrUpdate(1, 11); int value; Assert.IsTrue(cache.TryGetValue(1, out value)); Assert.AreEqual(11, value); }
public void Size_3_Cache_Add_4_Update_3_To_33_Get_Value_3_Should_Return_33() { MemoryCache <int, int> cache = new MemoryCache <int, int>(3); cache.AddOrUpdate(1, 1); cache.AddOrUpdate(2, 2); cache.AddOrUpdate(3, 3); cache.AddOrUpdate(4, 4); cache.AddOrUpdate(3, 33); int value; Assert.IsTrue(cache.TryGetValue(3, out value)); Assert.AreEqual(33, value); }
public void CanReplaceADuplicate() { var cache = new MemoryCache <string, string>(); cache.AddOrUpdate("abc", "def"); cache.AddOrUpdate("abc", "deef"); Assert.AreEqual(1, cache.Count); Assert.AreEqual(0, cache.Size); var result = cache.TryGetValue("abc", out var value); Assert.IsTrue(result); Assert.AreEqual("deef", value); }
public void CanAddAnEntry() { var cache = new MemoryCache <string, string>(); cache.AddOrUpdate("abc", "def"); Assert.AreEqual(1, cache.Count); }
public void Size_2_Cache_Add_2_Cache_Size_Should_Be_2() { MemoryCache <Key, Value> cache = new MemoryCache <Key, Value>(2, new KeyComparer()); cache.AddOrUpdate(new Key { x = 1, y = 1 }, new Value { a = 1, b = 1 }); cache.AddOrUpdate(new Key { x = 2, y = 1 }, new Value { a = 2, b = 2 }); Assert.AreEqual(2, cache.CurrentSize); }
public void Cache_AddOrUpdate_SameKey_ShouldRenewLifetime() { int capacity = 5; int itemsToInsert = 5; int keyStart = 0; int keyOfInterest = 1; // the specific key in the cache to test against var memcache = new MemoryCache <int, SimpleTestClass>(capacity); // Insert as many entries as needed ParallelAddOrUpdateHelper <int, SimpleTestClass>(itemsToInsert, memcache, () => { return(keyStart++); }, () => { return(new SimpleTestClass()); }); // Assert that the first key added is _not_ the youngest item // This is a poor test as who knows what order ParallelHelper inserted them. var initalKeyAge = memcache.KeysByAge; Assert.AreNotEqual(capacity - 1, Array.IndexOf(initalKeyAge, keyOfInterest)); // Update keyOfInterest to trigger a renew on lifetime memcache.AddOrUpdate(keyOfInterest, new SimpleTestClass()); // Assert that the keyOfInterest is the youngest now var updatedKeyAge = memcache.KeysByAge; Assert.IsTrue((capacity - 2 <= Array.IndexOf(updatedKeyAge, keyOfInterest))); }
public void Size_0_Cache_Add_1_Cache_Size_Should_Be_0() { MemoryCache <int, int> cache = new MemoryCache <int, int>(0); cache.AddOrUpdate(1, 1); Assert.AreEqual(0, cache.CurrentSize); }
public void CacheKeepsMostRecentlyUsedItems() { var cache = new MemoryCache <int, string>(10); for (int i = 0; i < 15; i++) { cache.AddOrUpdate(i, RandomUtils.GetInt32().ToString()); if (i == 8) { // Use first 3 items. for (int k = 0; k < 3; ++k) { cache.TryGetValue(k, out string unused); } } } // Cache should have 0-2 & 8-14. for (int i = 0; i < 15; i++) { bool success = cache.TryGetValue(i, out string unused); if (i < 3 || i > 7) { Assert.True(success); } else { Assert.False(success); } } Assert.Equal(10, cache.Count); }
/// <summary> /// This method was to used to track down an issue using Parallel.For in a test context. /// </summary> /// <typeparam name="TKey"></typeparam> /// <typeparam name="TValue"></typeparam> /// <param name="timesToRun"></param> /// <param name="cache"></param> /// <param name="keyFunction"></param> /// <param name="objectToInsertFunction"></param> /// <param name="postAction"></param> private void DEBUG_ParallelAddOrUpdateHelperWithPostAction <TKey, TValue>(int timesToRun, MemoryCache <TKey, TValue> cache, Func <TKey> keyFunction, Func <TValue> objectToInsertFunction, Action <int> postAction ) { // using Parallel.For "amusingly" enough caused the cache to occasionally be in a bad state when asserting in some cases, // discovered when trying to Assert that a cache miss _had_ happened, but the thread executing it wasn't reflective // of the actual state of the cache. // Technically the below code should be the same as the above, however there can be a state where the test will // reach the stage to attempt a cache miss, and get in at a moment where the Parallel.For hasn't finished but released a lock, // resulting in the AddOrUpdate's still running, while the test is completed. // Using Task.WaitAll ensures that everything _is_ finished. /* * Parallel.For(0, timesToRun, i => { * cache.AddOrUpdate(keyFunction(), objectToInsertFunction()); * postAction(i); * });*/ var tasks = new List <Task>(timesToRun); for (int i = 0; i < timesToRun; i++) { cache.AddOrUpdate(keyFunction(), objectToInsertFunction()); postAction(i); // Run an action, passing the current iteration to it } Task.WaitAll(tasks.ToArray()); }
public void CanAddAndUpdate() { var cache = new MemoryCache <string, string>(); var values = new List <Common.Caching.Abstract.KeyValuePair <string, string> >(); cache["key::10"] = "abc"; cache["key::50"] = "def"; cache["key::55"] = "duf"; Assert.AreEqual("abc", cache["key::10"]); Assert.AreEqual("def", cache["key::50"]); Assert.AreEqual("duf", cache["key::55"]); for (var idx = 0; idx < 100; idx++) { var kvp = new Common.Caching.Abstract.KeyValuePair <string, string> { Key = $"key::{idx}", Value = $"value::{idx}" }; values.Add(kvp); } cache.AddOrUpdate(values); Assert.AreEqual("value::10", cache["key::10"]); Assert.AreEqual("value::50", cache["key::50"]); Assert.AreEqual("value::55", cache["key::55"]); }
public void Cache_TryGetValue_SameKey_ShouldRenewLifetime() { int capacity = 5; int itemsToInsert = 5; int keyStart = 0; int keyOfInterest = 1; // the specific key in the cache to test against var memcache = new MemoryCache <int, SimpleTestClass>(capacity); // Insert as many entries as needed ParallelAddOrUpdateHelper <int, SimpleTestClass>(itemsToInsert, memcache, () => { return(keyStart++); }, () => { return(new SimpleTestClass()); }); // Assert that the first key added is _not_ the youngest item // This is a poor test as who knows what order ParallelHelper inserted them. var initalKeyAge = memcache.KeysByAge; Assert.AreNotEqual(capacity - 1, Array.IndexOf(initalKeyAge, keyOfInterest)); // Update the keyOfInterest with a value we control var newValue = new SimpleTestClass(); memcache.AddOrUpdate(keyOfInterest, newValue); // Get keyOfInterest to renew its lifetime memcache.TryGetValue(keyOfInterest, out SimpleTestClass cachedValue); // Assert that getting the value updated its lifetime, and that the value did not change var updatedKeyAge = memcache.KeysByAge; Assert.AreEqual(capacity - 1, Array.IndexOf(updatedKeyAge, keyOfInterest)); Assert.AreEqual(newValue, cachedValue); }
public void CanAddNullValue() { var cache = new MemoryCache <string, string>(); cache.AddOrUpdate("abc", null); Assert.AreEqual(1, cache.Count); Assert.AreEqual(0, cache.Size); }
/// <summary> /// Wrapper for Parallel.For /// <para> /// Calls AddOrUpdate on the given cache as many times as timesToRun, using the specified key and value generation functions. /// </para> /// </summary> /// <typeparam name="TKey"></typeparam> /// <typeparam name="TValue"></typeparam> /// <param name="timesToRun"></param> /// <param name="cache"></param> /// <param name="keyFunction"></param> /// <param name="objectToInsertFunction"></param> private void ParallelAddOrUpdateHelper <TKey, TValue>(int timesToRun, MemoryCache <TKey, TValue> cache, Func <TKey> keyFunction, Func <TValue> objectToInsertFunction) { var tasks = new List <Task>(timesToRun); for (int i = 0; i < timesToRun; i++) { cache.AddOrUpdate(keyFunction(), objectToInsertFunction()); } Task.WaitAll(tasks.ToArray()); }
public DatabasePoolController() { cacheManager = new MemoryCache(); logger = new ApplicationInsightsLogger(); if (!cacheManager.Exist(DatabaseType.Used.GetEnumDescription()).Result) { cacheManager.AddOrUpdate(new List <string>(), DatabaseType.Used.GetEnumDescription()); } if (!cacheManager.Exist(DatabaseType.Open.GetEnumDescription()).Result) { cacheManager.AddOrUpdate(new List <string>(), DatabaseType.Open.GetEnumDescription()); } if (!cacheManager.Exist(DatabaseType.BeingCreated.GetEnumDescription()).Result) { cacheManager.AddOrUpdate(new List <string>(), DatabaseType.BeingCreated.GetEnumDescription()); } dbOperations = new AzureDbOperations(); }
public void WillThrowOnOverflow() { var cache = new MemoryCache <string, string>(10); var opts = new CacheEntryOptions { Size = 15 }; Assert.ThrowsException <ArgumentOutOfRangeException>(() => cache.AddOrUpdate("abc", "def", opts)); Assert.AreEqual(0, cache.Count); Assert.AreEqual(0, cache.Size); }
public void CanUpdateSize() { var cache = new MemoryCache <string, string>(100); var opts = new CacheEntryOptions { Size = 10 }; cache.AddOrUpdate("abc", "def", opts); Assert.AreEqual(1, cache.Count); Assert.AreEqual(10, cache.Size); }
public void Size_1_Cache_Add_1_Update_Value_To_5_Value_Should_Be_5() { MemoryCache <Key, Value> cache = new MemoryCache <Key, Value>(1, new KeyComparer()); cache.AddOrUpdate(new Key { x = 1, y = 1 }, new Value { a = 1, b = 1 }); cache.AddOrUpdate(new Key { x = 1, y = 1 }, new Value { a = 5, b = 1 }); Value value; cache.TryGetValue(new Key { x = 1, y = 1 }, out value); Assert.AreEqual(5, value.a); }
public void Size_1_Cache_Add_2_Get_Value_2_Should_Return_2() { MemoryCache <Key, Value> cache = new MemoryCache <Key, Value>(1, new KeyComparer()); cache.AddOrUpdate(new Key { x = 1, y = 1 }, new Value { a = 1, b = 1 }); cache.AddOrUpdate(new Key { x = 2, y = 1 }, new Value { a = 2, b = 1 }); Value value; Assert.IsTrue(cache.TryGetValue(new Key { x = 2, y = 1 }, out value)); Assert.AreEqual(2, value.a); }
public void CacheDoesNotExceedMaxItemsLimit() { int maxItemsCount = 100; var cache = new MemoryCache <int, string>(maxItemsCount); for (int i = 0; i < maxItemsCount * 2; i++) { cache.AddOrUpdate(i, RandomUtils.GetInt32().ToString()); } Assert.Equal(maxItemsCount, cache.Count); }
public void Cache_AddOrUpdateOnce_And_TryGet_SimpleData() { int capacity = 1; var testValue = new SimpleTestClass(); var memcache = new MemoryCache <int, SimpleTestClass>(capacity); memcache.AddOrUpdate(1, testValue); memcache.TryGetValue(1, out SimpleTestClass insertedValue); Assert.AreEqual(testValue, insertedValue); }
public void Size_3_Cache_Add_4_Update_3_To_33_Update_1_To_11_Add_5th_Get_Value_3_Add_6th_Get_5_Get_3_Update_1_To_11_Get_6_Should_Return_False() { MemoryCache <int, int> cache = new MemoryCache <int, int>(3); cache.AddOrUpdate(1, 1); cache.AddOrUpdate(2, 2); cache.AddOrUpdate(3, 3); cache.AddOrUpdate(4, 4); cache.AddOrUpdate(3, 33); cache.AddOrUpdate(1, 11); cache.AddOrUpdate(5, 5); int value; cache.TryGetValue(3, out value); cache.AddOrUpdate(6, 6); cache.TryGetValue(5, out value); cache.TryGetValue(3, out value); cache.AddOrUpdate(1, 11); Assert.IsFalse(cache.TryGetValue(6, out value)); }
public void CacheDoesNotExceedCapacity() { int capacity = 10; int itemsToInsert = 100; var memcache = new MemoryCache <int, SimpleTestClass>(capacity); Parallel.For(0, itemsToInsert, i => { var newEntry = new SimpleTestClass(); memcache.AddOrUpdate(i, newEntry); }); Assert.AreEqual(10, memcache.CacheSize); }