public static void TestRemove3() { LurchTable <int, int> dict = new LurchTable <int, int>(); dict[99] = -99; ICollection <KeyValuePair <int, int> > col = dict; // Make sure we cannot "remove" a key/value pair which is not in the dictionary for (int i = 0; i < 200; i++) { if (i != 99) { Assert.False(col.Remove(new KeyValuePair <int, int>(i, -99)), "Should not remove not existing a key/value pair - new KeyValuePair<int, int>(i, -99)"); Assert.False(col.Remove(new KeyValuePair <int, int>(99, -i)), "Should not remove not existing a key/value pair - new KeyValuePair<int, int>(99, -i)"); } } // Can we remove a key/value pair successfully? Assert.True(col.Remove(new KeyValuePair <int, int>(99, -99)), "Failed to remove existing key/value pair"); // Make sure the key/value pair is gone Assert.False(col.Remove(new KeyValuePair <int, int>(99, -99)), "Should not remove the key/value pair which has been removed"); // And that the dictionary is empty. We will check the count in a few different ways: Assert.Equal(0, dict.Count); Assert.Equal(0, dict.ToArray().Length); }
public LocaleObjectCache(int initialCapacity) { // ICU4N: Since .NET doesn't have a memory-sensitive cache, we are using an LRU cache with a fixed size. // This ensures that the culture(s) that the application uses most stay near the top of the cache and // less used cultures get popped off of the bottom of the cache. _map = new LurchTable <TKey, Lazy <TValue> >(initialCapacity, LurchTableOrder.Access, limit: 64, comparer: null); }
public static void TestAddNullValue_ConcurrentDictionaryOfString_null() { // using ConcurrentDictionary<TKey, TValue> class LurchTable <string, string> dict1 = new LurchTable <string, string>(); dict1["key"] = null; }
public static void TestBugFix669376() { var cd = new LurchTable <string, int>(new OrdinalStringComparer()); cd["test"] = 10; Assert.True(cd.ContainsKey("TEST"), "Customized comparer didn't work"); }
public Task AddDiagnostics(string category, string type, string step, DiagnosticsData data) { var loweredCategory = (category ?? "").ToSlug().ToLower(); var loweredType = (type ?? "").ToSlug().ToLower(); var loweredStep = (step ?? "").ToSlug().ToLower(); if (!Data.ContainsKey(loweredCategory)) { Data[loweredCategory] = new ConcurrentDictionary <string, LurchTable <string, ConcurrentBag <DiagnosticsData> > >(); } if (!Data[loweredCategory].ContainsKey(loweredType)) { Data[loweredCategory][loweredType] = new LurchTable <string, ConcurrentBag <DiagnosticsData> >(50); } if (!Data[loweredCategory][loweredType].ContainsKey(loweredStep)) { Data[loweredCategory][loweredType][loweredStep] = new ConcurrentBag <DiagnosticsData>(); } Data[loweredCategory][loweredType][loweredStep].Add(data); return(Task.CompletedTask); }
public static void TestICollection() { ICollection dictionary = new LurchTable <int, int>(); Assert.False(dictionary.IsSynchronized, "TestICollection: FAILED. IsSynchronized returned true!"); int key = -1; int value = +1; //add one item to the dictionary ((LurchTable <int, int>)dictionary).TryAdd(key, value); var objectArray = new object[1]; dictionary.CopyTo(objectArray, 0); Assert.Equal(key, ((KeyValuePair <int, int>)objectArray[0]).Key); Assert.Equal(value, ((KeyValuePair <int, int>)objectArray[0]).Value); var keyValueArray = new KeyValuePair <int, int> [1]; dictionary.CopyTo(keyValueArray, 0); Assert.Equal(key, keyValueArray[0].Key); Assert.Equal(value, keyValueArray[0].Value); var entryArray = new DictionaryEntry[1]; dictionary.CopyTo(entryArray, 0); Assert.Equal(key, (int)entryArray[0].Key); Assert.Equal(value, (int)entryArray[0].Value); }
public void IDictionary_NonGeneric_Contains_KeyOfWrongType() { if (!IsReadOnly) { IDictionary dictionary = new LurchTable <string, int>(); Assert.False(dictionary.Contains(1)); } }
public EntityCache(string entityPluralSchemaName, int capacity, Func <string, string, string> recordValidator, params string[] attributesToCache) { _entityPluralSchemaName = entityPluralSchemaName; _recordValidator = recordValidator; CachedRecords = new LurchTable <Guid, TRecord>(capacity); CachedAttributeNames = new List <string>(attributesToCache); _selectAttributes = string.Join(",", attributesToCache); }
public static void TryRemove_KeyValuePair_MatchesKeyWithDefaultComparer() { var dict = new LurchTable <string, string>(StringComparer.OrdinalIgnoreCase); dict.TryAdd("key", "value"); Assert.False(dict.TryRemove(new KeyValuePair <string, string>("key", "VALUE"))); Assert.True(dict.TryRemove(new KeyValuePair <string, string>("KEY", "value"))); }
public void Dictionary_Generic_Constructor_int_IEqualityComparer(int count) { SCG.IEqualityComparer <TKey> comparer = GetKeyIEqualityComparer(); LurchTable <TKey, TValue> dictionary = new LurchTable <TKey, TValue>(count, LurchTableOrder.None, comparer); Assert.Equal(0, dictionary.Count); Assert.Equal(comparer, dictionary.EqualityComparer); }
public static void TestConstructor() { var dictionary = new LurchTable <int, int>(new[] { new KeyValuePair <int, int>(1, 1) }); Assert.False(dictionary.IsEmpty); Assert.Equal(1, dictionary.Keys.Count); Assert.Equal(1, dictionary.Values.Count); }
public static void TestAddNullValue_IDictionaryOfString_null() { // using IDictionary<TKey, TValue> interface IDictionary <string, string> dict2 = new LurchTable <string, string>(); dict2["key"] = null; dict2.Add("key2", null); }
public static void TestAddNullValue_IDictionary_ReferenceType_null() { // using IDictionary interface IDictionary dict3 = new LurchTable <string, string>(); dict3["key"] = null; dict3.Add("key2", null); }
public void LurchTableDemo() { var counts = new Counts(); //Queue where producer helps when queue is full using (var queue = new LurchTable <string, int>(LurchTableOrder.Insertion, 10)) { var stop = new ManualResetEvent(false); queue.ItemRemoved += kv => { Interlocked.Increment(ref counts.Dequeued); Console.WriteLine("[{0}] - {1}", Thread.CurrentThread.ManagedThreadId, kv.Key); }; //start some threads eating queue: var thread = new Thread(() => { while (!stop.WaitOne(0)) { KeyValuePair <string, int> kv; while (queue.TryDequeue(out kv)) { continue; } } }) { Name = "worker", IsBackground = true }; thread.Start(); var names = Directory.GetFiles(Path.GetTempPath(), "*", SearchOption.AllDirectories); if (names.Length < 1) { throw new Exception("Not enough trash in your temp dir."); } var loops = Math.Max(1, 100 / names.Length); for (int i = 0; i < loops; i++) { foreach (var name in names) { Interlocked.Increment(ref counts.Queued); queue[name] = i; } } //help empty the queue KeyValuePair <string, int> tmp; while (queue.TryDequeue(out tmp)) { continue; } //shutdown stop.Set(); thread.Join(); } Assert.AreEqual(counts.Queued, counts.Dequeued); }
public void IDictionary_NonGeneric_ItemSet_KeyOfWrongType() { if (!IsReadOnly) { IDictionary dictionary = new LurchTable <string, string>(); AssertExtensions.Throws <ArgumentException>("key", () => dictionary[23] = CreateTValue(12345)); Assert.Empty(dictionary); } }
public void Dictionary_Generic_Constructor_IEqualityComparer(int count) { SCG.IEqualityComparer <TKey> comparer = GetKeyIEqualityComparer(); SCG.IDictionary <TKey, TValue> source = GenericIDictionaryFactory(count); LurchTable <TKey, TValue> copied = new LurchTable <TKey, TValue>(source, comparer); Assert.Equal(source, copied); Assert.Equal(comparer, copied.EqualityComparer); }
public static void TestIDictionary() { IDictionary dictionary = new LurchTable <string, int>(); Assert.False(dictionary.IsReadOnly); // Empty dictionary should not enumerate Assert.Empty(dictionary); const int SIZE = 10; for (int i = 0; i < SIZE; i++) { dictionary.Add(i.ToString(), i); } Assert.Equal(SIZE, dictionary.Count); //test contains Assert.False(dictionary.Contains(1), "TestIDictionary: FAILED. Contain returned true for incorrect key type"); Assert.False(dictionary.Contains("100"), "TestIDictionary: FAILED. Contain returned true for incorrect key"); Assert.True(dictionary.Contains("1"), "TestIDictionary: FAILED. Contain returned false for correct key"); //test GetEnumerator int count = 0; foreach (var obj in dictionary) { DictionaryEntry entry = (DictionaryEntry)obj; string key = (string)entry.Key; int value = (int)entry.Value; int expectedValue = int.Parse(key); Assert.True(value == expectedValue, string.Format("TestIDictionary: FAILED. Unexpected value returned from GetEnumerator, expected {0}, actual {1}", value, expectedValue)); count++; } Assert.Equal(SIZE, count); Assert.Equal(SIZE, dictionary.Keys.Count); Assert.Equal(SIZE, dictionary.Values.Count); //Test Remove dictionary.Remove("9"); Assert.Equal(SIZE - 1, dictionary.Count); //Test this[] for (int i = 0; i < dictionary.Count; i++) { Assert.Equal(i, (int)dictionary[i.ToString()]); } dictionary["1"] = 100; // try a valid setter Assert.Equal(100, (int)dictionary["1"]); //non-existing key Assert.Null(dictionary["NotAKey"]); }
private static SCG.IDictionary <T, T> CreateDictionary <T>(int size, Func <int, T> keyValueSelector, SCG.IEqualityComparer <T> comparer = null) { SCG.Dictionary <T, T> temp = Enumerable.Range(0, size + 1).ToDictionary(keyValueSelector, keyValueSelector, comparer); LurchTable <T, T> dict = new LurchTable <T, T>(temp, comparer); // Remove first item to reduce Count to size and alter the contiguity of the dictionary dict.Remove(keyValueSelector(0)); return(dict); }
/// <summary> /// 构造函数中使用config文件初始化token缓存大小 /// </summary> private SingleUserTokenMutability() { //int _limit = Convert.ToInt32(System.Configuration.ConfigurationManager.AppSettings["LurchTableCache"]); //存放的数据应该是devicetype长度的 int _limit = System.Enum.GetNames(typeof(DeviceType)).Length; //构造函数中处理缓存大小,从xml中配置 _tokenDictionary_s = new LurchTable<string, UserDeviceMutability>(_limit,LurchTableOrder.Access); }
private static void TestRemove2(int removesPerThread) { LurchTable <int, int> dict = new LurchTable <int, int>(); for (int i = 0; i < removesPerThread; i++) { dict[i] = -i; } // The dictionary contains keys [0..N), each key mapped to a value equal to the key. // Threads will cooperatively remove all even keys. const int SIZE = 2; int running = SIZE; bool[][] seen = new bool[SIZE][]; for (int i = 0; i < SIZE; i++) { seen[i] = new bool[removesPerThread]; } using (ManualResetEvent mre = new ManualResetEvent(false)) { for (int t = 0; t < SIZE; t++) { int thread = t; Task.Run( () => { for (int key = 0; key < removesPerThread; key++) { int value; if (dict.TryRemove(key, out value)) { seen[thread][key] = true; Assert.Equal(-key, value); } } if (Interlocked.Decrement(ref running) == 0) { mre.Set(); } }); } mre.WaitOne(); } Assert.Equal(0, dict.Count); for (int i = 0; i < removesPerThread; i++) { Assert.False(seen[0][i] == seen[1][i], string.Format("> FAILED. Two threads appear to have removed the same element. TestRemove2(removesPerThread={0})", removesPerThread) ); } }
public static void TestAddNullValue_IDictionary_ValueType_null_add() { Action action = () => { IDictionary dict5 = new LurchTable <string, int>(); dict5.Add("key", null); }; Assert.Throws <ArgumentNullException>(action); }
public void IDictionary_NonGeneric_Add_NullValueWhenDefaultTValueIsNonNull() { if (!IsReadOnly) { IDictionary dictionary = new LurchTable <string, int>(); object missingKey = GetNewKey(dictionary); Assert.Throws <ArgumentNullException>(() => dictionary.Add(missingKey, null)); Assert.Empty(dictionary); } }
public void Dictionary_Generic_RemoveKey_ValidKeyNotContainedInDictionary(int count) { LurchTable <TKey, TValue> dictionary = (LurchTable <TKey, TValue>)GenericIDictionaryFactory(count); TValue value; TKey missingKey = GetNewKey(dictionary); Assert.False(dictionary.Remove(missingKey, out value)); Assert.Equal(count, dictionary.Count); Assert.Equal(default(TValue), value); }
public void IDictionary_NonGeneric_ItemSet_ValueOfWrongType() { if (!IsReadOnly) { IDictionary dictionary = new LurchTable <string, string>(); object missingKey = GetNewKey(dictionary); AssertExtensions.Throws <ArgumentException>("value", () => dictionary[missingKey] = 324); Assert.Empty(dictionary); } }
public void IDictionary_NonGeneric_Add_KeyOfWrongType() { if (!IsReadOnly) { IDictionary dictionary = new LurchTable <string, string>(); object missingKey = 23; AssertExtensions.Throws <ArgumentException>("key", () => dictionary.Add(missingKey, CreateTValue(12345))); Assert.Empty(dictionary); } }
/// <summary> /// 构造函数中使用config文件初始化token缓存大小 /// </summary> public SingleUserToken() { int _limit = Convert.ToInt32(System.Configuration.ConfigurationManager.AppSettings["LurchTableCache"]); //防止出现意外没有找到配置的问题 if (_limit<1) { _limit = 5; } //构造函数中处理缓存大小,从xml中配置 _tokenLurchtables = new LurchTable<string, UserToken>(LurchTableOrder.Access,_limit); }
protected UserDeviceMutability() { //配置文件中获取内存大小,用于存放的记录数量上限 int _limit = Convert.ToInt32(System.Configuration.ConfigurationManager.AppSettings["LurchTableCache"]); //防止出现意外没有找到配置的问题 if (_limit < 1) { _limit = 5; } _userTokenMutability_s = new LurchTable<string, UserTokenMutability>(LurchTableOrder.Access, _limit); }
public static void TestAddNullValue_IDictionary_ValueType_null_indexer() { // using IDictionary interface and value type values Action action = () => { IDictionary dict4 = new LurchTable <string, int>(); dict4["key"] = null; }; Assert.Throws <ArgumentNullException>(action); }
public void LurchTable_Generic_ValueCollection_GetEnumerator(int count) { LurchTable <string, string> dictionary = new LurchTable <string, string>(); int seed = 13453; while (dictionary.Count < count) { dictionary.Add(CreateT(seed++), CreateT(seed++)); } dictionary.Values.GetEnumerator(); }
protected override ICollection NonGenericICollectionFactory(int count) { LurchTable <string, string> list = new LurchTable <string, string>(); int seed = 13453; for (int i = 0; i < count; i++) { list.Add(CreateT(seed++), CreateT(seed++)); } return(list.Values); }
public void Dictionary_Generic_RemoveKey_DefaultKeyContainedInDictionary(int count) { if (DefaultValueAllowed) { LurchTable <TKey, TValue> dictionary = (LurchTable <TKey, TValue>)(GenericIDictionaryFactory(count)); TKey missingKey = default(TKey); TValue value; dictionary.TryAdd(missingKey, default(TValue)); Assert.True(dictionary.Remove(missingKey, out value)); } }
public StorageCache(INodeStorage store, int sizeLimit) { _asyncThreshold = 50; _writeBehindFunc = Flush; _asyncWriteBehind = null; _store = store; _cache = new LurchTable <IStorageHandle, object>(LurchTableOrder.Access, sizeLimit, 1000000, sizeLimit >> 4, 1000, EqualityComparer <IStorageHandle> .Default); _dirty = new LurchTable <IStorageHandle, object>(LurchTableOrder.Modified, sizeLimit, 1000000, sizeLimit >> 4, 1000, EqualityComparer <IStorageHandle> .Default); _dirty.ItemRemoved += OnItemRemoved; }
public void CompareTest() { const int size = 1000000; int reps = 3; Stopwatch timer; IDictionary <Guid, TestValue> dict = new ConcurrentDictionary <Guid, TestValue>(new Dictionary <Guid, TestValue>(size)); IDictionary <Guid, TestValue> test = new LurchTable <Guid, TestValue>(size); for (int rep = 0; rep < reps; rep++) { var sample = CreateSample(Guid.NewGuid(), size, 1); timer = Stopwatch.StartNew(); Parallel(1, sample, item => dict.Add(item, new TestValue { Id = item, Count = rep })); Trace.TraceInformation("Dict Add: {0}", timer.Elapsed); timer = Stopwatch.StartNew(); Parallel(1, sample, item => test.Add(item, new TestValue { Id = item, Count = rep })); Trace.TraceInformation("Test Add: {0}", timer.Elapsed); timer = Stopwatch.StartNew(); Parallel(1, sample, item => dict[item] = new TestValue { Id = item, Count = rep }); Trace.TraceInformation("Dict Update: {0}", timer.Elapsed); timer = Stopwatch.StartNew(); Parallel(1, sample, item => test[item] = new TestValue { Id = item, Count = rep }); Trace.TraceInformation("Test Update: {0}", timer.Elapsed); timer = Stopwatch.StartNew(); Parallel(1, sample, item => dict.Remove(item)); Trace.TraceInformation("Dict Rem: {0}", timer.Elapsed); Assert.AreEqual(0, dict.Count); timer = Stopwatch.StartNew(); Parallel(1, sample, item => test.Remove(item)); Trace.TraceInformation("Test Rem: {0}", timer.Elapsed); test.Clear(); dict.Clear(); GC.Collect(); GC.WaitForPendingFinalizers(); } }
public void LurchTableDemo() { var counts = new Counts(); //Queue where producer helps when queue is full using (var queue = new LurchTable<string, int>(LurchTableOrder.Insertion, 10)) { var stop = new ManualResetEvent(false); queue.ItemRemoved += kv => { Interlocked.Increment(ref counts.Dequeued); Console.WriteLine("[{0}] - {1}", Thread.CurrentThread.ManagedThreadId, kv.Key); }; //start some threads eating queue: var thread = new Thread(() => { while (!stop.WaitOne(0)) { KeyValuePair<string, int> kv; while (queue.TryDequeue(out kv)) continue; } }) { Name = "worker", IsBackground = true }; thread.Start(); var names = Directory.GetFiles(Path.GetTempPath(), "*", SearchOption.AllDirectories); if (names.Length < 1) throw new Exception("Not enough trash in your temp dir."); var loops = Math.Max(1, 100/names.Length); for(int i=0; i < loops; i++) foreach (var name in names) { Interlocked.Increment(ref counts.Queued); queue[name] = i; } //help empty the queue KeyValuePair<string, int> tmp; while (queue.TryDequeue(out tmp)) continue; //shutdown stop.Set(); thread.Join(); } Assert.AreEqual(counts.Queued, counts.Dequeued); }