public void TestCollect4() { var dictionary = new WeakKeyDictionary <object, int>(); var key1 = new Key(1, 9001); var key4 = new Key(4, 9001); new Action(() => { dictionary.Add(key1, 1); dictionary.Add(new Key(2, 9001), 2); dictionary.Add(new Key(3, 9001), 3); dictionary.Add(key4, 4); })(); GC.Collect(); GC.WaitForPendingFinalizers(); dictionary.Count.Should().Be(4); dictionary.Collect(); dictionary.Count.Should().Be(2); dictionary[key1].Should().Be(1); dictionary[key4].Should().Be(4); dictionary._freeCount.Should().Be(2, "Because 2 previously used entries were reclaimed"); EnsureIntegrity(dictionary); }
public void TestAdd8() { var dictionary = new WeakKeyDictionary <object, int>(); var key1 = new Key(1, 42); WeakReference <Key> weakKey2 = null; var key3 = new Key(3, 42); new Action(() => { var key2 = new Key(2, 42); weakKey2 = new WeakReference <Key>(key2); dictionary.Add(key1, 1); dictionary.Add(key2, 2); dictionary.Add(key3, 3); })(); dictionary.Count.Should().Be(3); dictionary._freeCount.Should().Be(0); GC.Collect(); GC.WaitForPendingFinalizers(); // This is a special case that tests that iterating over an entry within a bucket // that has been collected by the GC works as expected: There has been a bug that caused // the iteration within the bucket to completely stop. var key4 = new Key(1, 42); new Action(() => dictionary.Add(key4, 4)) .Should().Throw <ArgumentException>() .WithMessage("An item with the same key has already been added."); dictionary.Count.Should().Be(2); dictionary._freeCount.Should().Be(1); }
public void TestAdd2() { var dictionary = new WeakKeyDictionary <string, int>(); dictionary.Add("Foobar", 42); dictionary.Add("Klondyke Bar", 9001); dictionary.Count.Should().Be(2); dictionary.ContainsKey("Foobar").Should().BeTrue(); dictionary.ContainsKey("Klondyke Bar").Should().BeTrue(); dictionary.Version.Should().Be(2); EnsureIntegrity(dictionary); }
public void TestAdd3() { var dictionary = new WeakKeyDictionary <string, int>(); dictionary.Add("Foobar", 42); new Action(() => dictionary.Add("Foobar", 42)) .Should().Throw <ArgumentException>() .WithMessage("An item with the same key has already been added."); dictionary.Count.Should().Be(1); dictionary.ContainsKey("Foobar").Should().BeTrue(); dictionary.Version.Should().Be(1); EnsureIntegrity(dictionary); }
public void TestAddPerformance() { const int num = 1000000; var keys = Enumerable.Range(0, num).Select(i => new object()).ToList(); var dictionary = new Dictionary <object, int>(); var weakDictionary = new WeakKeyDictionary <object, int>(); var sw1 = new Stopwatch(); sw1.Start(); for (int i = 0; i < num; ++i) { dictionary.Add(keys[i], i); } sw1.Stop(); var sw2 = new Stopwatch(); sw2.Start(); for (int i = 0; i < num; ++i) { weakDictionary.Add(keys[i], i); } sw2.Stop(); Console.WriteLine("Dictionary.Add: {0}ms", sw1.ElapsedMilliseconds); Console.WriteLine("WeakKeyDictionary.Add: {0}ms", sw2.ElapsedMilliseconds); sw2.ElapsedMilliseconds.Should().BeLessOrEqualTo(sw1.ElapsedMilliseconds * 10, "Because the weak key dictionary should not be slower than by an order of magnitude"); }
public void WeakKeyDictionaryWithData_CopyToEndOfSufficientlyLargeKeyValuePairArray_Succeeds() { const int NumValuesToAdd = 20; var keeperArounder = new List <KeyValuePair <string, int> >(); ICollection <KeyValuePair <string, int> > dictionary = new WeakKeyDictionary <string, int>(); for (int i = 0; i < NumValuesToAdd; ++i) { var entry = new KeyValuePair <string, int>(i.ToString(), i); keeperArounder.Add(entry); dictionary.Add(entry); } Assert.Equal(NumValuesToAdd, dictionary.Count); var destination = new KeyValuePair <string, int> [50]; const int StartIndex = 30; dictionary.CopyTo(destination, StartIndex); for (int i = 0; i < NumValuesToAdd; ++i) { Assert.Equal(i.ToString(), destination[i + StartIndex].Key); Assert.Equal(i, destination[i + StartIndex].Value); } }
public void WeakKeyDictionaryWithData_EnumerateUsingIDictionaryEnumerator_ValidateContents() { IDictionary dictionary = new WeakKeyDictionary <string, int>(); var values = new[] { -1, 48, 62, 88, -32 }; for (int i = 0; i < values.Length; ++i) { dictionary.Add(values[i].ToString(), values[i]); } var dictionaryEnumerator = dictionary.GetEnumerator(); while (dictionaryEnumerator.MoveNext()) { var current = dictionaryEnumerator.Current; var entry = dictionaryEnumerator.Entry; Assert.Equal(current, entry); var key = dictionaryEnumerator.Key; var value = dictionaryEnumerator.Value; var entryKey = entry.Key as string; var entryValue = (int)entry.Value; Assert.Equal(key, entryKey); Assert.Equal(value, entryValue); } var disposable = dictionaryEnumerator as IDisposable; if (disposable != null) { disposable.Dispose(); dictionaryEnumerator = null; disposable = null; } }
/// <summary> /// Subscribes supplied object to property changed notifications and invokes the provided callback /// </summary> /// <typeparam name="T">Type of subject</typeparam> /// <param name="vmb">Subject</param> /// <param name="path">Property path</param> /// <param name="callback">Notification callback</param> public static void NotifyOn <T>(this T vmb, string path, Action <object, object> callback) { Dictionary <string, NotificationHelperDp> block; if (!_notifiers.TryGetValue(vmb, out block)) { _notifiers.Add(vmb, block = new Dictionary <string, NotificationHelperDp>()); } block.Remove(path); NotificationHelperDp binder = new NotificationHelperDp(callback); BindingOperations.SetBinding(binder, NotificationHelperDp.BindValueProperty, #if NET || NETCORE || NETFRAMEWORK new Binding(path) { Source = vmb }); #else new Binding { Source = vmb, Path = new PropertyPath(path) }); #endif block.Add(path, binder); }
public void TestCollect1() { var dictionary = new WeakKeyDictionary <object, int>(); WeakReference <object> weakKey = null; new Action(() => { var key = new ByReferenceClass(); weakKey = new WeakReference <object>(key); dictionary.Add(key, 42); dictionary.Count.Should().Be(1); })(); GC.Collect(); GC.WaitForPendingFinalizers(); weakKey.Should().NotBeNull(); dictionary.Collect(); dictionary.Count.Should().Be(0); object unused; weakKey.TryGetTarget(out unused).Should().BeFalse("Because the dictionary shouldn't keep the key alive"); EnsureIntegrity(dictionary); }
public void TestAdd5() { var dictionary = new WeakKeyDictionary <Key, int>(); var key1 = new Key(1, 42); var key2 = new Key(2, 42); key1.GetHashCode().Should().Be(key2.GetHashCode()); key1.Equals(key2).Should().BeFalse(); dictionary.Add(key1, 9); dictionary.Add(key2, 10); dictionary.Count.Should().Be(2); dictionary.ContainsKey(key1).Should().BeTrue(); dictionary.ContainsKey(key2).Should().BeTrue(); EnsureIntegrity(dictionary); }
public void TestAdd9() { var dictionary = new WeakKeyDictionary <object, string>(); new Action(() => dictionary.Add(null, "foo")) .Should().Throw <ArgumentNullException>() .WithMessage("Value cannot be null.\r\nParameter name: key"); }
public void TestIndexer1() { var dictionary = new WeakKeyDictionary <string, int>(); dictionary.Add("a", 1); dictionary["a"].Should().Be(1); EnsureIntegrity(dictionary); }
public void TestCollect6() { var dictionary = new WeakKeyDictionary <object, int>(); var key1 = new object(); var key2 = new object(); dictionary.Add(key1, 1337); dictionary.Add(key2, 42); dictionary.Version.Should().Be(2); dictionary.Count.Should().Be(2); dictionary.Collect(); dictionary.Version.Should().Be(2); dictionary.Count.Should().Be(2); dictionary[key1].Should().Be(1337); dictionary[key2].Should().Be(42); EnsureIntegrity(dictionary); }
public void TestTryGetValue1() { var dictionary = new WeakKeyDictionary <string, int>(); dictionary.Add("1", 42); dictionary.Add("2", 9001); dictionary.Add("3", 1337); int value; dictionary.TryGetValue("1", out value).Should().BeTrue(); value.Should().Be(42); dictionary.TryGetValue("2", out value).Should().BeTrue(); value.Should().Be(9001); dictionary.TryGetValue("3", out value).Should().BeTrue(); value.Should().Be(1337); EnsureIntegrity(dictionary); }
public void TestIndexer2() { var dictionary = new WeakKeyDictionary <string, int>(); dictionary.Add("a", 1); new Action(() => { int value = dictionary["b"]; }) .Should().Throw <ArgumentException>() .WithMessage("The given key was not present in the dictionary."); EnsureIntegrity(dictionary); }
public void TestCollect2() { var dictionary = new WeakKeyDictionary <object, int>(); new Action(() => { dictionary.Add(new Key(1, 9001), 1); dictionary.Add(new Key(2, 9001), 2); dictionary.Add(new Key(3, 9001), 3); })(); GC.Collect(); GC.WaitForPendingFinalizers(); dictionary.Count.Should().Be(3); dictionary.Collect(); dictionary.Count.Should().Be(0); EnsureIntegrity(dictionary); }
public void TestCollect8() { var dictionary = new WeakKeyDictionary <object, int>(); var key1 = new Key(1, 9001); var key4 = new Key(4, 9001); new Action(() => { dictionary.Add(key1, 1); dictionary.Add(new Key(2, 9001), 2); dictionary.Add(new Key(3, 9001), 3); dictionary.Add(key4, 4); })(); GC.Collect(); GC.WaitForPendingFinalizers(); dictionary.Collect(); dictionary.Count.Should().Be(2); var key2 = new Key(2, 9001); var key3 = new Key(3, 9001); dictionary.Add(key2, 2); dictionary.Add(key3, 3); dictionary.Count.Should().Be(4); dictionary[key2].Should().Be(2); dictionary[key3].Should().Be(3); EnsureIntegrity(dictionary); }
public void TestAdd4() { var dictionary = new WeakKeyDictionary <string, int>(); dictionary.Capacity.Should().Be(3); dictionary.Add("a", 1); dictionary.Add("b", 2); dictionary.Add("c", 3); dictionary.Capacity.Should().Be(3); dictionary.Add("d", 4); dictionary.Capacity.Should().BeInRange(3, 7); dictionary.Count.Should().Be(4); dictionary["a"].Should().Be(1); dictionary["b"].Should().Be(2); dictionary["c"].Should().Be(3); dictionary["d"].Should().Be(4); EnsureIntegrity(dictionary); }
public void WeakKeyDictionary_AddKeyValue_TryGetValueSucceeds() { const int Value = 1; var key = new DisposableTestObject("key"); var dictionary = new WeakKeyDictionary <DisposableTestObject, int>(); dictionary.Add(key, Value); int value; Assert.True(dictionary.TryGetValue(key, out value)); Assert.Equal(Value, value); }
public void WeakKeyDictionary_AddObjectKeyValuePair_TryGetValueSucceeds() { var dictionary = new WeakKeyDictionary <object, object>(); object key = "Why, it's a Key!"; object value = new object(); dictionary.Add(key, value); object valueOut; Assert.True(dictionary.TryGetValue("Why, it's a Key!", out valueOut)); Assert.True(object.ReferenceEquals(value, valueOut)); }
public void WeakKeyDictionaryWithData_ResetIDictionaryEnumerator_ThrowsNotSupportedException() { IDictionary dictionary = new WeakKeyDictionary <DisposableTestObject, int>(); var values = new[] { -1, 48, 62, 88, -32 }; for (int i = 0; i < values.Length; ++i) { dictionary.Add(new DisposableTestObject(values[i].ToString()), values[i]); } var dictionaryEnumerator = dictionary.GetEnumerator(); Assert.Throws <NotSupportedException>(() => dictionaryEnumerator.Reset()); }
public void TestAdd6() { var dictionary = new WeakKeyDictionary <object, int>(); var key1 = new Key(1, 42); WeakReference <Key> weakKey2 = null; var key3 = new Key(3, 42); new Action(() => { var key2 = new Key(2, 42); weakKey2 = new WeakReference <Key>(key2); dictionary.Add(key1, 1); dictionary.Add(key2, 2); dictionary.Add(key3, 3); })(); GC.Collect(); GC.WaitForPendingFinalizers(); dictionary.Count.Should().Be(3); dictionary.Capacity.Should().Be(3); dictionary.Version.Should().Be(3); weakKey2.Should().NotBeNull(); Key currentKey2; weakKey2.TryGetTarget(out currentKey2).Should().BeFalse("Because the key no longer exists"); var key4 = new Key(4, 42); dictionary.Add(key4, 4); dictionary.Count.Should().Be(3); dictionary.Capacity.Should().Be(3); dictionary.Version.Should().Be(5); EnsureIntegrity(dictionary); }
public void TestTryGetValue2() { var dictionary = new WeakKeyDictionary <string, int>(); int value; dictionary.TryGetValue("1", out value).Should().BeFalse(); value.Should().Be(0); dictionary.Add("1", 42); dictionary.TryGetValue("2", out value).Should().BeFalse(); value.Should().Be(0); EnsureIntegrity(dictionary); }
public void WeakKeyDictionaryWithData_CopyToBeginningOfSufficientlyLargeKeyValuePairArray_Succeeds() { const int NumValuesToAdd = 4; ICollection <KeyValuePair <string, int> > dictionary = new WeakKeyDictionary <string, int>(); for (int i = 0; i < NumValuesToAdd; ++i) { dictionary.Add(new KeyValuePair <string, int>(i.ToString(), i)); } Assert.Equal(NumValuesToAdd, dictionary.Count); var destination = new KeyValuePair <string, int> [50]; const int StartIndex = 0; dictionary.CopyTo(destination, StartIndex); }
public void WeakKeyDictionaryWithData_CopyToArrayWithInvalidRank_ThrowsArgumentException() { const int NumValuesToAdd = 2; var weakKeyDictionary = new WeakKeyDictionary <string, int>(); ICollection dictionary = weakKeyDictionary; for (int i = 0; i < NumValuesToAdd; ++i) { weakKeyDictionary.Add(new KeyValuePair <string, int>(i.ToString(), i)); } Assert.Equal(NumValuesToAdd, weakKeyDictionary.Count); var destination = new KeyValuePair <string, int> [2, 2]; Assert.Throws <ArgumentException>(() => dictionary.CopyTo(destination, 0)); }
public void WeakKeyDictionaryWithData_CopyToNullKeyValuePairArray_ThrowsArgumentNullException() { const int NumValuesToAdd = 10; var keeperArounder = new List <KeyValuePair <string, int> >(); ICollection <KeyValuePair <string, int> > dictionary = new WeakKeyDictionary <string, int>(); for (int i = 0; i < NumValuesToAdd; ++i) { var entry = new KeyValuePair <string, int>(i.ToString(), i); keeperArounder.Add(entry); dictionary.Add(entry); } Assert.Equal(NumValuesToAdd, dictionary.Count); Assert.Throws <ArgumentNullException>(() => dictionary.CopyTo(null, 0)); }
public void WeakKeyDictionary_AddKeyValuePair_TryGetValueSucceeds() { const int Value = 2; var key = new DisposableTestObject("key"); var keeperArounder = new List <KeyValuePair <DisposableTestObject, int> >(); var dictionary = new WeakKeyDictionary <DisposableTestObject, int>(); var entry = new KeyValuePair <DisposableTestObject, int>(key, Value); keeperArounder.Add(entry); dictionary.Add(entry); int value; Assert.True(dictionary.TryGetValue(key, out value)); Assert.Equal(Value, value); }
public void WeakKeyDictionaryWithData_CopyToKeyValuePairArrayWithIndexResultingInWritePastEndOfArray_ThrowsArgumentException() { const int NumValuesToAdd = 80; var keeperArounder = new List <KeyValuePair <string, int> >(); ICollection <KeyValuePair <string, int> > dictionary = new WeakKeyDictionary <string, int>(); for (int i = 0; i < NumValuesToAdd; ++i) { var data = new KeyValuePair <string, int>(i.ToString(), i); keeperArounder.Add(data); dictionary.Add(data); } Assert.True(NumValuesToAdd >= dictionary.Count); var destination = new KeyValuePair <string, int> [50]; Assert.Throws <ArgumentException>(() => dictionary.CopyTo(destination, 48)); }
public void WeakKeyDictionaryWithData_CopyToKeyValuePairArrayWithNegativeIndex_ThrowsArgumentOutOfRangeException() { const int NumValuesToAdd = 6; var keeperArounder = new List <KeyValuePair <string, int> >(); ICollection <KeyValuePair <string, int> > dictionary = new WeakKeyDictionary <string, int>(); for (int i = 0; i < NumValuesToAdd; ++i) { var entry = new KeyValuePair <string, int>(i.ToString(), i); keeperArounder.Add(entry); dictionary.Add(entry); } Assert.Equal(NumValuesToAdd, dictionary.Count); var destination = new KeyValuePair <string, int> [2]; Assert.Throws <ArgumentOutOfRangeException>(() => dictionary.CopyTo(destination, -1)); }
public void WeakKeyDictionaryAsICollectionWithData_Clear_EnsureEmpty() { const int NumValuesToAdd = 100; ICollection <KeyValuePair <string, int> > dictionary = new WeakKeyDictionary <string, int>(); var keeperArounder = new List <KeyValuePair <string, int> >(); for (int i = 0; i < NumValuesToAdd; ++i) { var entry = new KeyValuePair <string, int>(i.ToString(), i); keeperArounder.Add(entry); dictionary.Add(entry); } Assert.Equal(NumValuesToAdd, dictionary.Count); dictionary.Clear(); Assert.Equal(0, dictionary.Count); }
public void Test_WeakKeyDictionary() { var normalKeyDiction = new Dictionary<TestKey, int>(); var key = new TestKey("Yohan"); var keyReference = new WeakReference(key); normalKeyDiction.Add(key, 1); Assert.AreEqual(1, normalKeyDiction.Count); Assert.AreEqual(1, normalKeyDiction[key]); Assert.IsTrue(keyReference.IsAlive); key = null; GC.Collect(); //Normal Dictionary hold the strong reference to the key. Assert.IsTrue(keyReference.IsAlive); var weakKeyDictionary = new WeakKeyDictionary<TestKey, int>(); key = new TestKey("Yohan"); keyReference = new WeakReference(key); weakKeyDictionary.Add(key, 1); Assert.AreEqual(1, weakKeyDictionary.Count); Assert.AreEqual(1, weakKeyDictionary[key]); IList keys = weakKeyDictionary.Keys; Assert.AreEqual(1, keys.Count); Assert.IsTrue(keyReference.IsAlive); key = null; GC.Collect(); //WeakKeyDictionary hold the WeakReference of the key. Assert.IsFalse(keyReference.IsAlive); GC.KeepAlive(normalKeyDiction); }
public void Test_WeakKeyDictionary_CRUD() { var weakKeyDictionary = new WeakKeyDictionary<TestKey, int>(); var key = new TestKey("Yohan"); weakKeyDictionary.Add(key, 1); Assert.AreEqual(1, weakKeyDictionary.Count); Assert.AreEqual(1, weakKeyDictionary[key]); weakKeyDictionary.Remove(key); Assert.AreEqual(0, weakKeyDictionary.Count); Exception exception = null; try { weakKeyDictionary.Remove(null); } catch (ArgumentNullException e) { exception = e; } Assert.IsNotNull(exception); exception = null; try { var i = weakKeyDictionary[new TestKey("1")]; } catch (KeyNotFoundException e) { exception = e; } Assert.IsNotNull(exception); key = new TestKey("Yohan2"); weakKeyDictionary.Add(key, 1); Assert.AreEqual(1, weakKeyDictionary[key]); weakKeyDictionary.Clear(); Assert.AreEqual(0, weakKeyDictionary.Count); weakKeyDictionary.Add(key, 1); Assert.IsTrue(weakKeyDictionary.ContainsKey(key)); Assert.IsTrue(weakKeyDictionary.ContainsValue(1)); weakKeyDictionary[key] = 2; Assert.AreEqual(2, weakKeyDictionary[key]); bool contains = weakKeyDictionary.ContainsValue(2); Assert.IsTrue(contains); exception = null; try { weakKeyDictionary[null] = 3; } catch (ArgumentNullException e) { exception = e; } Assert.IsNotNull(exception); exception = null; try { weakKeyDictionary.Add(key, 1); } catch (ArgumentException e) { exception = e; } Assert.IsNotNull(exception); int value; weakKeyDictionary.TryGetValue(key, out value); Assert.AreEqual(2, value); var count = weakKeyDictionary.Count; key = null; GC.Collect(); weakKeyDictionary.Add(new TestKey("yohan9"), 2); Assert.AreEqual(count, weakKeyDictionary.Keys.Count); }