private static void AddCollectableItems(WeakValueDictionary <int, object> c, int startKey, int count) { for (int i = 0; i < count; i++) { c.Add(startKey++, new object()); } }
public void ScavengeOnGrow() { var dictionary = new WeakValueDictionary <object, object>(); for (int i = 0; i < 100; i++) { dictionary[new Object()] = new Object(); // Randomly collect some if (i == 15) { GC.Collect(); } } // We should have scavenged at least once Console.WriteLine("Count {0}", dictionary.Count); Assertion.AssertEquals(true, dictionary.Count < 100); // Finish with explicit scavenge int count1 = dictionary.Count; int removed = dictionary.Scavenge(); int count2 = dictionary.Count; Console.WriteLine("Removed {0}", removed); Assertion.AssertEquals(removed, count1 - count2); }
private void AssertEnumeration(WeakValueDictionary <int, Item> dict, int key) { foreach (var kvp in dict) { Assert.That(kvp.Key, Is.Not.EqualTo(key)); } }
public void When_element_is_added_twice_with_the_same_key_Then_exception_is_thrown() { var dict = new WeakValueDictionary <int, Item> { { 0, new Item() } }; Assert.Throws <ArgumentException>(() => dict.Add(0, new Item())); }
/// <summary> /// Creates an empty cache. /// </summary> internal ProjectRootElementCache(bool autoReloadFromDisk) { DebugTraceCache("Constructing with autoreload from disk: ", autoReloadFromDisk); _weakCache = new WeakValueDictionary <string, ProjectRootElement>(StringComparer.OrdinalIgnoreCase); _strongCache = new LinkedList <ProjectRootElement>(); _autoReloadFromDisk = autoReloadFromDisk; }
public void When_dictionary_is_cleared_Then_it_is_empty() { var dict = new WeakValueDictionary <int, Item> { [0] = null, [1] = new Item() }; dict.Clear(); Assert.That(dict.Count, Is.Zero); }
public void TryGetValue_ReferenceNotFound() { var dictionary = new WeakValueDictionary <string, string>(); string v; bool result = dictionary.TryGetValue("x", out v); Assert.IsFalse(result); Assert.IsNull(v); Assert.IsFalse(dictionary.Contains("x")); }
public void When_null_item_is_added_Then_its_key_exists() { var dict = new WeakValueDictionary <int, Item>(); dict[1] = null; Item item; bool exists = dict.TryGetValue(1, out item); Assert.That(dict.Count, Is.EqualTo(1)); Assert.That(exists, Is.True); Assert.That(item, Is.Null); }
public void When_item_is_added_Then_it_can_be_retrieved() { var dict = new WeakValueDictionary <int, Item>(); Item item = new Item(); dict[1] = item; bool exists = dict.TryGetValue(1, out item); Assert.That(dict.Count, Is.EqualTo(1)); Assert.That(exists, Is.True); Assert.That(item, Is.EqualTo(item)); }
public void When_element_is_set_twice_with_for_the_same_key_Then_key_value_is_changed() { var dict = new WeakValueDictionary <int, Item>(); var item = new Item(); var item2 = new Item(); dict[0] = item; dict[0] = item2; Assert.That(dict.Count, Is.EqualTo(1)); Assert.That(dict[0], Is.EqualTo(item2)); }
public void When_key_is_removed_Then_count_is_decreased() { var dict = new WeakValueDictionary <int, Item> { [0] = new Item(), [1] = new Item() }; bool removed = dict.Remove(0); Assert.That(removed, Is.True); Assert.That(dict.Count, Is.EqualTo(1)); }
public void When_non_existing_key_is_removed_Then_false_is_returned() { var dict = new WeakValueDictionary <int, Item> { [0] = new Item(), [1] = new Item() }; bool removed = dict.Remove(3); Assert.That(removed, Is.False); Assert.That(dict.Count, Is.EqualTo(2)); }
public void When_item_is_added_Then_it_can_be_garbage_collected() { var dict = new WeakValueDictionary <int, Item> { [1] = new Item() }; GC.Collect(); GC.WaitForPendingFinalizers(); AssertEnumeration(dict, 1); Assert.That(dict.ContainsKey(1), Is.False); Assert.That(dict.Count, Is.EqualTo(0)); }
public void When_getting_keys_collection_Then_actual_dictionary_keys_are_returned() { var dict = new WeakValueDictionary <int, Item> { [0] = new Item(), [1] = new Item(), [2] = new Item() }; var keys = dict.Keys; Assert.That(keys.Count, Is.EqualTo(3)); Assert.That(keys, Is.EqualTo(new[] { 0, 1, 2 })); }
protected internal SymbolPool(int firstID, bool useStrongRefs, int poolId) { if (useStrongRefs) { _map = new Dictionary <string, Symbol>(); } else { _map = _weakMap = new WeakValueDictionary <string, Symbol>(); } _nextId = firstID; _poolId = poolId; }
public void SpecifiedEqualityComparer() { string k1 = "key"; string v1 = "value"; var dictionary = new WeakValueDictionary <string, string>(StringComparer.OrdinalIgnoreCase); dictionary[k1] = v1; string v2 = dictionary["KEY"]; Assertion.AssertEquals(true, Object.ReferenceEquals(v1, v2)); }
/// <summary> /// Clears out the cache. /// Called when all projects are unloaded and possibly when a build is done. /// </summary> internal void Clear() { lock (_locker) { LinkedList <ProjectRootElement> oldStrongCache = _strongCache; _weakCache = new WeakValueDictionary <string, ProjectRootElement>(StringComparer.OrdinalIgnoreCase); _strongCache = new LinkedList <ProjectRootElement>(); foreach (ProjectRootElement projectRootElement in oldStrongCache) { RaiseProjectRootElementRemovedFromStrongCache(projectRootElement); } } }
public void Indexer_ReferenceFound() { string k1 = "key"; string v1 = "value"; var dictionary = new WeakValueDictionary<string, string>(); dictionary[k1] = v1; // Now look for the same key we inserted string v2 = dictionary[k1]; Assertion.AssertEquals(true, Object.ReferenceEquals(v1, v2)); Assertion.AssertEquals(true, dictionary.Contains(k1)); }
public void When_getting_values_collection_Then_actual_dictionary_values_without_nulls_are_returned() { var item = new Item(); var item2 = new Item(); var dict = new WeakValueDictionary <int, Item> { [0] = item, [1] = null, [2] = item2 }; var values = dict.Values; Assert.That(values.Count, Is.EqualTo(2)); Assert.That(values, Is.EqualTo(new[] { item, item2 })); }
public void Indexer_ReferenceFound() { string k1 = "key"; string v1 = "value"; var dictionary = new WeakValueDictionary <string, string>(); dictionary[k1] = v1; // Now look for the same key we inserted string v2 = dictionary[k1]; Assertion.AssertEquals(true, Object.ReferenceEquals(v1, v2)); Assertion.AssertEquals(true, dictionary.Contains(k1)); }
public void TryGetValue_ReferenceFound() { string k1 = "key"; string v1 = "value"; var dictionary = new WeakValueDictionary <string, string>(); dictionary[k1] = v1; // Now look for the same key we inserted string v2; bool result = dictionary.TryGetValue(k1, out v2); Assertion.AssertEquals(true, result); Assertion.AssertEquals(true, Object.ReferenceEquals(v1, v2)); }
public void ExplicitScavenge() { object k1 = new object(); object v1 = new object(); var dictionary = new WeakValueDictionary <object, object>(); dictionary[k1] = v1; Assertion.AssertEquals(1, dictionary.Count); v1 = null; GC.Collect(); dictionary.Scavenge(); Assertion.AssertEquals(0, dictionary.Count); }
public void Indexer_NullValue_ReferenceFound() { string k1 = "key"; string v1 = null; var dictionary = new WeakValueDictionary<string, string>(); dictionary[k1] = v1; // Now look for the same key we inserted string v2 = dictionary[k1]; Assertion.AssertEquals(true, Object.ReferenceEquals(v1, v2)); Assertion.AssertEquals(true, dictionary.Contains(k1)); // Should not scavenge values that are null, rather than collected dictionary.Scavenge(); Assertion.AssertEquals(1, dictionary.Count); }
public void EnumerationCleaning() { var c = new WeakValueDictionary <int, object>(); object x = new object(); using (NoGCRegion.Enter(1000)) { c.Add(0, x); c.Add(1, x); c.Add(2, x); AddCollectableItems(c, 3, 3); Assert.AreEqual(6, c.AddCountSinceLastClean); Assert.AreEqual(6, c.UnsafeCount); Assert.IsTrue(c.ContainsKey(1)); #if DEBUG || !NETFRAMEWORK // Causes entry with key 4 not to collection on NETFW release builds Assert.IsTrue(c.ContainsKey(4)); #endif } Helpers.CollectAndWait(); Assert.IsTrue(c.ContainsKey(1)); Assert.IsFalse(c.ContainsKey(4)); foreach (object o in c) { } Assert.IsTrue(c.Remove(0)); Assert.IsTrue(c.Remove(1)); Assert.IsFalse(c.Remove(4)); #if NETCOREAPP2_2 // NS2.0 target does not support removing stale entries as items are encountered. Assert.AreEqual(6, c.AddCountSinceLastClean); Assert.AreEqual(4, c.UnsafeCount); #else Assert.AreEqual(0, c.AddCountSinceLastClean); Assert.AreEqual(1, c.UnsafeCount); #endif GC.KeepAlive(x); }
public void Indexer_NullValue_ReferenceFound() { string k1 = "key"; string v1 = null; var dictionary = new WeakValueDictionary <string, string>(); dictionary[k1] = v1; // Now look for the same key we inserted string v2 = dictionary[k1]; Assertion.AssertEquals(true, Object.ReferenceEquals(v1, v2)); Assertion.AssertEquals(true, dictionary.Contains(k1)); // Should not scavenge values that are null, rather than collected dictionary.Scavenge(); Assertion.AssertEquals(1, dictionary.Count); }
public void EqualityComparer() { string k1 = "key"; string v1 = "value"; var dictionary = new WeakValueDictionary <string, string>(); dictionary[k1] = v1; // Now look for a different but equatable key // Don't create it with a literal or the compiler will intern it! string k2 = String.Concat("k", "ey"); Assert.IsFalse(Object.ReferenceEquals(k1, k2)); string v2 = dictionary[k2]; Assertion.AssertEquals(true, Object.ReferenceEquals(v1, v2)); }
public void When_dictionary_is_serialized_to_xml_Then_valid_xml_is_returned() { var dict = new WeakValueDictionary <int, Item>(); dict[0] = null; dict[1] = new Item { Value = 1 }; string resultingXml; var serializer = new DataContractSerializer(typeof(WeakValueDictionary <int, Item>), new[] { typeof(Item) }); using (var memStream = new MemoryStream()) using (var reader = new StreamReader(memStream)) { serializer.WriteObject(memStream, dict); memStream.Seek(0, SeekOrigin.Begin); resultingXml = reader.ReadToEnd(); } Assert.That(resultingXml, Is.EqualTo(Xml)); }
public void TryGetNullValue_ReferenceFound() { string k1 = "key"; string v1 = null; var dictionary = new WeakValueDictionary <string, string>(); dictionary[k1] = v1; // Now look for the same key we inserted string v2; bool result = dictionary.TryGetValue(k1, out v2); Assertion.AssertEquals(true, result); Assertion.AssertEquals(true, Object.ReferenceEquals(v1, v2)); // Should not scavenge values that are null, rather than collected dictionary.Scavenge(); Assertion.AssertEquals(1, dictionary.Count); }
public void OnlyValuesCollectable() { long memory0 = GC.GetTotalMemory(true); string k1 = new string('k', BigMemoryFootprintTest); string v1 = new string('v', BigMemoryFootprintTest); // Each character is 2 bytes, so about 4MB of this should be the strings long memory1 = GC.GetTotalMemory(true); var dictionary = new WeakValueDictionary <string, string>(); dictionary[k1] = v1; k1 = null; long memory2 = GC.GetTotalMemory(true); // Key not collected, should be about the same long difference = memory1 - memory2; Console.WriteLine("Before {0} Start {1}, end {2}, diff {3}, {4} more than start", memory0, memory1, memory2, difference, memory2 - memory0); Assertion.AssertEquals(true, difference < 500000); // big noise allowance v1 = null; memory2 = GC.GetTotalMemory(true); // Value collected, should be about 2MB less difference = memory1 - memory2; Console.WriteLine("Before {0} Start {1}, end {2}, diff {3}, {4} more than start", memory0, memory1, memory2, difference, memory2 - memory0); Assertion.AssertEquals(true, difference > 1500000); // 2MB minus big noise allowance // This line is VERY important, as it keeps the GC from being too smart and collecting // the dictionary and its large strings because we never use them again. GC.KeepAlive(dictionary); }
/// <summary> /// Discard any entries (weak and strong) which do not have the explicitlyLoaded flag set. /// </summary> internal void DiscardImplicitReferences() { lock (_locker) { // Make a new Weak cache only with items that have been explicitly loaded, this will be a small number, there will most likely // be many items which were not explicitly loaded (ie p2p references). WeakValueDictionary <string, ProjectRootElement> oldWeakCache = _weakCache; _weakCache = new WeakValueDictionary <string, ProjectRootElement>(StringComparer.OrdinalIgnoreCase); LinkedList <ProjectRootElement> oldStrongCache = _strongCache; _strongCache = new LinkedList <ProjectRootElement>(); foreach (string projectPath in oldWeakCache.Keys) { ProjectRootElement rootElement; if (oldWeakCache.TryGetValue(projectPath, out rootElement)) { if (rootElement.IsExplicitlyLoaded) { _weakCache[projectPath] = rootElement; } if (rootElement.IsExplicitlyLoaded && oldStrongCache.Contains(rootElement)) { _strongCache.AddFirst(rootElement); } else { _strongCache.Remove(rootElement); RaiseProjectRootElementRemovedFromStrongCache(rootElement); } } } } }
public void Clean() { var c = new WeakValueDictionary <int, object>(); object x = new object(); using (NoGCRegion.Enter(1000)) { c.Add(0, x); c.Add(1, x); c.Add(2, x); AddCollectableItems(c, 3, 3); Assert.AreEqual(6, c.AddCountSinceLastClean); Assert.AreEqual(6, c.UnsafeCount); } Helpers.CollectAndWait(); c.Clean(); Assert.AreEqual(0, c.AddCountSinceLastClean); Assert.AreEqual(3, c.UnsafeCount); GC.KeepAlive(x); }
/// <summary> /// Creates an empty cache. /// </summary> internal ProjectRootElementCache(bool autoReloadFromDisk) { DebugTraceCache("Constructing with autoreload from disk: ", autoReloadFromDisk); _weakCache = new WeakValueDictionary<string, ProjectRootElement>(StringComparer.OrdinalIgnoreCase); _strongCache = new LinkedList<ProjectRootElement>(); _autoReloadFromDisk = autoReloadFromDisk; }
public void ScavengeOnGrow() { var dictionary = new WeakValueDictionary<object, object>(); for (int i = 0; i < 100; i++) { dictionary[new Object()] = new Object(); // Randomly collect some if (i == 15) { GC.Collect(); } } // We should have scavenged at least once Console.WriteLine("Count {0}", dictionary.Count); Assertion.AssertEquals(true, dictionary.Count < 100); // Finish with explicit scavenge int count1 = dictionary.Count; int removed = dictionary.Scavenge(); int count2 = dictionary.Count; Console.WriteLine("Removed {0}", removed); Assertion.AssertEquals(removed, count1 - count2); }
public void Indexer_NotFound() { var dictionary = new WeakValueDictionary <string, string>(); string value = dictionary["x"]; }
public void EqualityComparer() { string k1 = "key"; string v1 = "value"; var dictionary = new WeakValueDictionary<string, string>(); dictionary[k1] = v1; // Now look for a different but equatable key // Don't create it with a literal or the compiler will intern it! string k2 = String.Concat("k", "ey"); Assert.IsFalse(Object.ReferenceEquals(k1, k2)); string v2 = dictionary[k2]; Assertion.AssertEquals(true, Object.ReferenceEquals(v1, v2)); }
public void OnlyValuesCollectable() { long memory0 = GC.GetTotalMemory(true); string k1 = new string('k', BigMemoryFootprintTest); string v1 = new string('v', BigMemoryFootprintTest); // Each character is 2 bytes, so about 4MB of this should be the strings long memory1 = GC.GetTotalMemory(true); var dictionary = new WeakValueDictionary<string, string>(); dictionary[k1] = v1; k1 = null; long memory2 = GC.GetTotalMemory(true); // Key not collected, should be about the same long difference = memory1 - memory2; Console.WriteLine("Before {0} Start {1}, end {2}, diff {3}, {4} more than start", memory0, memory1, memory2, difference, memory2 - memory0); Assertion.AssertEquals(true, difference < 500000); // big noise allowance v1 = null; memory2 = GC.GetTotalMemory(true); // Value collected, should be about 2MB less difference = memory1 - memory2; Console.WriteLine("Before {0} Start {1}, end {2}, diff {3}, {4} more than start", memory0, memory1, memory2, difference, memory2 - memory0); Assertion.AssertEquals(true, difference > 1500000); // 2MB minus big noise allowance // This line is VERY important, as it keeps the GC from being too smart and collecting // the dictionary and its large strings because we never use them again. GC.KeepAlive(dictionary); }
public void ExplicitScavenge() { object k1 = new object(); object v1 = new object(); var dictionary = new WeakValueDictionary<object, object>(); dictionary[k1] = v1; Assertion.AssertEquals(1, dictionary.Count); v1 = null; GC.Collect(); dictionary.Scavenge(); Assertion.AssertEquals(0, dictionary.Count); }
/// <summary> /// Clears out the cache. /// Called when all projects are unloaded and possibly when a build is done. /// </summary> internal void Clear() { lock (_locker) { LinkedList<ProjectRootElement> oldStrongCache = _strongCache; _weakCache = new WeakValueDictionary<string, ProjectRootElement>(StringComparer.OrdinalIgnoreCase); _strongCache = new LinkedList<ProjectRootElement>(); foreach (ProjectRootElement projectRootElement in oldStrongCache) { RaiseProjectRootElementRemovedFromStrongCache(projectRootElement); } } }
/// <summary> /// Discard any entries (weak and strong) which do not have the explicitlyLoaded flag set. /// </summary> internal void DiscardImplicitReferences() { lock (_locker) { // Make a new Weak cache only with items that have been explicitly loaded, this will be a small number, there will most likely // be many items which were not explicitly loaded (ie p2p references). WeakValueDictionary<string, ProjectRootElement> oldWeakCache = _weakCache; _weakCache = new WeakValueDictionary<string, ProjectRootElement>(StringComparer.OrdinalIgnoreCase); LinkedList<ProjectRootElement> oldStrongCache = _strongCache; _strongCache = new LinkedList<ProjectRootElement>(); foreach (string projectPath in oldWeakCache.Keys) { ProjectRootElement rootElement; if (oldWeakCache.TryGetValue(projectPath, out rootElement)) { if (rootElement.IsExplicitlyLoaded) { _weakCache[projectPath] = rootElement; } if (rootElement.IsExplicitlyLoaded && oldStrongCache.Contains(rootElement)) { _strongCache.AddFirst(rootElement); } else { _strongCache.Remove(rootElement); RaiseProjectRootElementRemovedFromStrongCache(rootElement); } } } } }
public void Indexer_NotFound() { var dictionary = new WeakValueDictionary<string, string>(); string value = dictionary["x"]; }
public void TryGetValue_ReferenceFound() { string k1 = "key"; string v1 = "value"; var dictionary = new WeakValueDictionary<string, string>(); dictionary[k1] = v1; // Now look for the same key we inserted string v2; bool result = dictionary.TryGetValue(k1, out v2); Assertion.AssertEquals(true, result); Assertion.AssertEquals(true, Object.ReferenceEquals(v1, v2)); }
public void SpecifiedEqualityComparer() { string k1 = "key"; string v1 = "value"; var dictionary = new WeakValueDictionary<string, string>(StringComparer.OrdinalIgnoreCase); dictionary[k1] = v1; string v2 = dictionary["KEY"]; Assertion.AssertEquals(true, Object.ReferenceEquals(v1, v2)); }
public void TryGetNullValue_ReferenceFound() { string k1 = "key"; string v1 = null; var dictionary = new WeakValueDictionary<string, string>(); dictionary[k1] = v1; // Now look for the same key we inserted string v2; bool result = dictionary.TryGetValue(k1, out v2); Assertion.AssertEquals(true, result); Assertion.AssertEquals(true, Object.ReferenceEquals(v1, v2)); // Should not scavenge values that are null, rather than collected dictionary.Scavenge(); Assertion.AssertEquals(1, dictionary.Count); }
public void TryGetValue_ReferenceNotFound() { var dictionary = new WeakValueDictionary<string, string>(); string v; bool result = dictionary.TryGetValue("x", out v); Assert.IsFalse(result); Assert.IsNull(v); Assert.IsFalse(dictionary.Contains("x")); }