public void AddingToSameKeyTwiceAlwaysThrows() { object o = new object(); WeakDictionary <object, object> dict = new WeakDictionary <object, object>(); dict.Add("foo1", o); dict.Add("foo1", o); }
public void TestAddSameKeyThrowsException() { WeakDictionary<KeyObject, int> weakDict = new WeakDictionary<KeyObject, int>(this.comparer, 5); KeyObject key = new KeyObject(10); weakDict.Add(key, 10); Action testAction = () => { weakDict.Add(key, 10); }; testAction.ShouldThrow<ArgumentException>(); }
//[ExpectedException(typeof(ArgumentException))] public void AddingToSameKeyTwiceAlwaysThrows() { object o = new object(); WeakDictionary <object, object> dict = new WeakDictionary <object, object>(); dict.Add("foo1", o); //dict.Add("foo1", o); Assert.That(() => dict.Add("foo1", o), Throws.TypeOf <ArgumentException>()); }
public void CanAddItemAfterPreviousItemIsCollected() { WeakDictionary <object, object> dict = new WeakDictionary <object, object>(); dict.Add("foo", new object()); GC.Collect(); dict.Add("foo", new object()); }
public void CanAddSameObjectTwiceWithDifferentKeys() { object o = new object(); WeakDictionary <object, object> dict = new WeakDictionary <object, object>(); dict.Add("foo1", o); dict.Add("foo2", o); Assert.AreSame(dict["foo1"], dict["foo2"]); }
public void RemovingAKeyOfOneObjectDoesNotAffectOtherKeysForSameObject() { object o = new object(); WeakDictionary <object, object> dict = new WeakDictionary <object, object>(); dict.Add("foo1", o); dict.Add("foo2", o); dict.Remove("foo1"); Assert.AreSame(o, dict["foo2"]); }
public void CanInformCountainedValue() { WeakDictionary <object, object> dict = new WeakDictionary <object, object>(); object o = new object(); dict.Add("foo1", "bar"); dict.Add("foo2", o); Assert.IsTrue(dict.ContainsValue("bar")); Assert.IsTrue(dict.ContainsValue(o)); }
public void RemovingAKeyDoesNotAffectOtherKeys() { object o1 = new object(); object o2 = new object(); WeakDictionary <object, object> dict = new WeakDictionary <object, object>(); dict.Add("foo1", o1); dict.Add("foo2", o2); dict.Remove("foo1"); Assert.AreSame(o2, dict["foo2"]); }
public void CanRegisterTwoObjectsAndGetThemBoth() { object o1 = new object(); object o2 = new object(); WeakDictionary <object, object> dict = new WeakDictionary <object, object>(); dict.Add("foo1", o1); dict.Add("foo2", o2); Assert.AreSame(o1, dict["foo1"]); Assert.AreSame(o2, dict["foo2"]); }
public void TestAddDiffTupleForSameObjectThrowsException() { WeakDictionary <object, int> weakDict = new WeakDictionary <object, int>(this.comparer, 5); var key = new Tuple <object, MemberInfo>(new KeyObject(10), this.memberInfo); weakDict.Add(key, 10); var key2 = new Tuple <object, MemberInfo>(key.Item1, this.memberInfo); Action testAction = () => { weakDict.Add(key2, 10); }; testAction.ShouldThrow <ArgumentException>(); }
public void TestRemoveDeadItemWhenAddMoreThanCurrentRefreshIntervalItems() { WeakDictionary <KeyObject, int> weakDict = new WeakDictionary <KeyObject, int>(this.comparer, 5); for (int i = 0; i < 4; i++) { AddAnItem(weakDict, i); } // Force gc to collect dead items GC.Collect(); if (GC.WaitForFullGCComplete() == GCNotificationStatus.Succeeded) { var key1 = new KeyObject(11); weakDict.Add(key1, 11); var key2 = new KeyObject(12); // Weak dictionary will remove dead items during this adding operation. // Then the currentRefreshInterval will be 1(still alive)+5=6. weakDict.Add(key2, 12); Assert.Equal(2, weakDict.Count); for (int i = 0; i < 3; i++) { AddAnItem(weakDict, i); } // Force gc to collect dead items GC.Collect(); if (GC.WaitForFullGCComplete() == GCNotificationStatus.Succeeded) { // Add the six item to dictionary. var key6 = new KeyObject(16); // Weak dictionary will not clean dead entities. weakDict.Add(key6, 16); Assert.Equal(6, weakDict.Count); var key14 = new KeyObject(114); // Weak dictionary will remove dead items during this adding operation. // Then the currentRefreshInterval will be 3(still alive)+5=8. weakDict.Add(key14, 114); Assert.Equal(4, weakDict.Count); } } }
public void CountReturnsNumberOfKeysWithLiveValues() { object o = new object(); WeakDictionary <object, object> dict = new WeakDictionary <object, object>(); dict.Add("foo1", o); dict.Add("foo2", o); Assert.AreEqual(2, dict.Count); o = null; GC.Collect(); Assert.AreEqual(0, dict.Count); }
/// <summary> /// Patches the events for a specific treeview. /// </summary> /// <param name="treeView">The TreeView.</param> private static void CorrectEventsForTreeView(TreeView treeView) { if (EventsPatched.ContainsKey(treeView)) { throw new InvalidOperationException("Events for this TreeView has been previously patched: '" + treeView.Name + "'"); } EventsPatched.Add(treeView, new Dictionary <string, List <Delegate> >()); foreach (string eventName in EventsToCorrect.Keys) { EventInfo eventInfo = treeView.GetType().GetEvent(eventName); if (eventInfo == null) { throw new InvalidOperationException("Event info for event '" + eventName + "' could not be found"); } EventsPatched[treeView].Add(eventName, new List <Delegate>()); Delegate[] eventDelegates = ContainerHelper.GetEventSubscribers(treeView, eventName); if (eventDelegates != null) { foreach (Delegate del in eventDelegates) { EventsPatched[treeView][eventName].Add(del); eventInfo.RemoveEventHandler(treeView, del); } } eventInfo.AddEventHandler(treeView, EventsToCorrect[eventName]); } }
/// <summary> /// Creates an instance of the type with the specified constructor arguments. /// </summary> /// <param name = "type">The type.</param> /// <param name = "args">The constructor args.</param> /// <returns>The created instance.</returns> protected override object ActivateInstance(Type type, object[] args) { object result; if (_singletones.TryGetValue(type, out result)) { return(result); } RegisterAsKind kind; lock (_syncObject) { if (!_types.TryGetValue(type, out kind)) { kind = GetKind(type); _types.Add(type, kind); } } result = base.ActivateInstance(type, args); if (kind == RegisterAsKind.Singleton) { _singletones.Add(type, result); } return(result); }
public void NullIsAValidValue() { WeakDictionary <object, object> dict = new WeakDictionary <object, object>(); dict.Add("foo", null); Assert.IsNull(dict["foo"]); }
public void TestRemoveDeadItemWhenAddMoreThanRefreshIntervalItems() { WeakDictionary <object, int> weakDict = new WeakDictionary <object, int>(this.comparer, 5); for (int i = 0; i < 2; i++) { AddKeyObject(weakDict, i); } for (int i = 0; i < 3; i++) { AddTupleObject(weakDict, i); } // Force gc to collect dead items GC.Collect(); if (GC.WaitForFullGCComplete() == GCNotificationStatus.Succeeded) { var key = new KeyObject(6); weakDict.Add(key, 6); // The countLimit after the first clean is 6 now. Assert.Equal(1, weakDict.Count); } }
public virtual IRevertChangesSavepoint CreateSavepoint(Object source) { if (source == null) { return(null); } List <Object> objList = new List <Object>(); List <IObjRef> objRefs = new List <IObjRef>(); FindAllObjectsToBackup(source, objList, objRefs, new IdentityHashSet <Object>()); IDictionary <Object, RevertChangesSavepoint.IBackup> originalToValueBackup = new IdentityDictionary <Object, RevertChangesSavepoint.IBackup>(); // Iterate manually through the list because the list itself should not be 'backuped' for (int a = objList.Count; a-- > 0;) { BackupObjects(objList[a], originalToValueBackup); } WeakDictionary <Object, RevertChangesSavepoint.IBackup> weakObjectsToBackup = new WeakDictionary <Object, RevertChangesSavepoint.IBackup>(new IdentityEqualityComparer <Object>()); DictionaryExtension.Loop(originalToValueBackup, delegate(Object obj, RevertChangesSavepoint.IBackup backup) { if (backup != null) { weakObjectsToBackup.Add(obj, backup); } }); return(BeanContext.RegisterBean <RevertChangesSavepoint>().PropertyValue("Changes", weakObjectsToBackup).Finish()); }
public void TestAddANullKeyThrowsException() { WeakDictionary <KeyObject, int> weakDict = new WeakDictionary <KeyObject, int>(this.comparer, 5); Action testAction = () => { weakDict.Add(null, 10); }; testAction.ShouldThrow <ArgumentNullException>(); }
/// <summary> /// Patches the events for a specific button. /// </summary> /// <param name="btn"></param> private static void CorretEventsForButton(Button btn) { Delegate[] EventDelegates = null; if (EventsPatched.ContainsKey(btn)) { throw new InvalidOperationException("Events for this button has been previously patched: '" + btn.Name + "'"); } EventsPatched.Add(btn, new Dictionary <string, List <Delegate> >()); foreach (string eventName in EventsToCorrect.Keys) { EventInfo eInfo = btn.GetType().GetEvent(eventName); if (eInfo == null) { throw new InvalidOperationException("Event info for event '" + eventName + "' could not be found"); } EventsPatched[btn].Add(eventName, new List <Delegate>()); EventDelegates = ContainerHelper.GetEventSubscribers(btn, eventName); if (EventDelegates != null) { foreach (Delegate del in EventDelegates) { EventsPatched[btn][eventName].Add(del); eInfo.RemoveEventHandler(btn, del); } } eInfo.AddEventHandler(btn, EventsToCorrect[eventName]); } }
private void AddTupleObject(WeakDictionary <object, int> dict, int id) { KeyObject key = new KeyObject(id); var tuple = new Tuple <object, MemberInfo>(key, this.memberInfo); dict.Add(tuple, rand.Next()); }
public void KeyCanBeGarbageCollected() { WeakDictionary <object, object> dict = new WeakDictionary <object, object>(); dict.Add(new object(), "foo"); GC.Collect(); Assert.IsTrue(dict.Count == 0); }
public void RegistrationDoesNotPreventGarbageCollection() { WeakDictionary <object, object> dict = new WeakDictionary <object, object>(); dict.Add("foo", new object()); GC.Collect(); object unused = dict["foo"]; }
private WeakDictionary <object, int> CreateDict(out List <object> keys) { WeakDictionary <object, int> weakDict = CreateDictWithoutItem(); keys = new List <object>(); for (int i = 0; i < 5; i++) { KeyObject key = new KeyObject(i); keys.Add(key); weakDict.Add(key, 2 * i); var tuple = new Tuple <object, MemberInfo>(key, this.memberInfo); keys.Add(tuple); weakDict.Add(tuple, 2 * i + 1); } return(weakDict); }
public void CanFindOutIfContainsAKey() { WeakDictionary <object, object> dict = new WeakDictionary <object, object>(); dict.Add("foo", null); Assert.IsTrue(dict.ContainsKey("foo")); Assert.IsFalse(dict.ContainsKey("foo2")); }
/// <summary> /// <b>Expert:</b> Adds a custom AttributeImpl instance with one or more Attribute interfaces. /// <p><font color="red"><b>Please note:</b> It is not guaranteed, that <c>att</c> is added to /// the <c>AttributeSource</c>, because the provided attributes may already exist. /// You should always retrieve the wanted attributes using <see cref="GetAttribute{T}"/> after adding /// with this method and cast to your class. /// The recommended way to use custom implementations is using an <see cref="AttributeFactory"/> /// </font></p> /// </summary> public void AddAttributeImpl(Attribute att) { Type clazz = att.GetType(); if (attributeImpls.TryGetValue(clazz, out var impl)) { return; } LinkedList <WeakReference> foundInterfaces; lock (knownImplClasses) { foundInterfaces = knownImplClasses[clazz]; if (foundInterfaces == null) { // we have a strong reference to the class instance holding all interfaces in the list (parameter "att"), // so all WeakReferences are never evicted by GC knownImplClasses.Add(clazz, foundInterfaces = new LinkedList <WeakReference>()); // find all interfaces that this attribute instance implements // and that extend the Attribute interface Type actClazz = clazz; do { Type[] interfaces = actClazz.GetInterfaces(); for (int i = 0; i < interfaces.Length; i++) { Type curInterface = interfaces[i]; if (curInterface != typeof(IAttribute) && typeof(IAttribute).IsAssignableFrom(curInterface)) { foundInterfaces.AddLast(new WeakReference(curInterface)); } } actClazz = actClazz.BaseType; }while (actClazz != null); } } // add all interfaces of this AttributeImpl to the maps foreach (var curInterfaceRef in foundInterfaces) { System.Type curInterface = (System.Type)curInterfaceRef.Target; System.Diagnostics.Debug.Assert(curInterface != null, "We have a strong reference on the class holding the interfaces, so they should never get evicted"); // Attribute is a superclass of this interface if (!attributes.TryGetValue(curInterface, out var _)) { // invalidate state to force recomputation in captureState() this.currentState[0] = null; attributes[curInterface] = new AttributeImplItem(curInterface, att); if (!attributeImpls.TryGetValue(clazz, out _)) { attributeImpls[clazz] = new AttributeImplItem(clazz, att); } } } }
/// <summary> /// <b>Expert:</b> Adds a custom AttributeImpl instance with one or more Attribute interfaces. /// <p><font color="red"><b>Please note:</b> It is not guaranteed, that <c>attr</c> is added to /// the <c>AttributeSource</c>, because the provided attributes may already exist. /// You should always retrieve the wanted attributes using <see cref="GetAttribute{T}"/> after adding /// with this method and cast to your class. /// The recommended way to use custom implementations is using an <see cref="AttributeFactory"/> /// </font></p> /// </summary> public virtual void AddAttributeImpl(Attribute attr) { Type attrType = attr.GetType(); if (attributeImpls.Contains(attrType)) { return; } LinkedList <WeakReference> foundInterfaces; lock (knownImplClasses) { foundInterfaces = knownImplClasses[attrType]; if (foundInterfaces == null) { // we have a strong reference to the class instance holding all interfaces in the list (parameter "attr"), // so all WeakReferences are never evicted by GC knownImplClasses.Add(attrType, foundInterfaces = new LinkedList <WeakReference>()); // find all interfaces that this attribute instance implements // and that extend the Attribute interface var type = attrType; do { var interfaces = type.GetInterfaces(); foreach (var curInterface in interfaces) { if (curInterface != typeof(IAttribute) && typeof(IAttribute).IsAssignableFrom(curInterface)) { foundInterfaces.AddLast(new WeakReference(curInterface)); } } type = type.BaseType; }while (type != null); } } // add all interfaces of this AttributeImpl to the maps foreach (var curInterfaceRef in foundInterfaces) { Type curInterface = (Type)curInterfaceRef.Target; System.Diagnostics.Debug.Assert(curInterface != null, "We have a strong reference on the class holding the interfaces, so they should never get evicted"); // Attribute is a superclass of this interface if (!attributes.ContainsKey(curInterface)) { // invalidate state to force recomputation in captureState() this.currentState[0] = null; attributes.Add(new AttributeImplItem(curInterface, attr)); if (!attributeImpls.ContainsKey(attrType)) { attributeImpls.Add(new AttributeImplItem(attrType, attr)); } } } }
public void CanRemoveAnObjectThatWasAlreadyAdded() { object o = new object(); WeakDictionary <object, object> dict = new WeakDictionary <object, object>(); dict.Add("foo", o); dict.Remove("foo"); object unused = dict["foo"]; }
public void CanRegisterObjectAndFindItByID() { object o = new object(); WeakDictionary <object, object> dict = new WeakDictionary <object, object>(); dict.Add("foo", o); Assert.IsNotNull(dict["foo"]); Assert.AreSame(o, dict["foo"]); }
/// <summary> /// Static - Gets the property MaskColor for the button. /// </summary> /// <param name="button">The button.</param> /// <returns>The current MaskColor for this button.</returns> public static Color GetMaskColorProperty(Button button) { if (!MaskColor.ContainsKey(button)) { MaskColor.Add(button, Color.Silver); } return(MaskColor[button]); }
public void KeyCanBeOfArbitraryType() { object oKey = new object(); object oVal = new object(); WeakDictionary <object, object> dict = new WeakDictionary <object, object>(); dict.Add(oKey, oVal); Assert.AreSame(oVal, dict[oKey]); }
public void TestBasicOps() { WeakDictionary<string, string> wd = new WeakDictionary<string, string>(); List<string> list = new List<string>(); for (int i = 0; i < 100; i++) { list.Add(i.ToString()); } foreach (string s in list) { wd.Add("k" + s, "v" + s); } foreach(string key in list) { Assert.AreEqual(wd["k"+key],"v"+key); } foreach (string key in list) { wd.Remove("k"+key); } Assert.AreEqual(0,wd.Count); foreach (string s in list) { wd.Add("k" + s, "v" + s); } foreach (string key in wd.Keys) { Assert.True(list.Contains(key.Substring(1))); } foreach(KeyValuePair<string,string> kv in wd) { Assert.True(list.Contains(kv.Key.Substring(1))); Assert.AreEqual(kv.Key.Substring(1), kv.Value.Substring(1)); } }
private WeakDictionary<object, int> CreateDict(out List<KeyObject> keys) { WeakDictionary<object, int> weakDict = new WeakDictionary<object, int>(this.comparer, refreshInterval: 5); keys = new List<KeyObject>(); for (int i = 0; i < 10; i++) { KeyObject key = new KeyObject(i); keys.Add(key); weakDict.Add(key, i); } return weakDict; }
public void TestAddANullKeyThrowsException() { WeakDictionary<KeyObject, int> weakDict = new WeakDictionary<KeyObject, int>(this.comparer, 5); Action testAction = () => { weakDict.Add(null, 10); }; testAction.ShouldThrow<ArgumentNullException>(); }
private void AddAnItem(WeakDictionary<KeyObject, int> dict, int id) { KeyObject key = new KeyObject(id); dict.Add(key, rand.Next()); }
public void TestRemoveDeadItemWhenAddMoreThanCurrentRefreshIntervalItems() { WeakDictionary<KeyObject, int> weakDict = new WeakDictionary<KeyObject, int>(this.comparer, 5); for (int i = 0; i < 4; i++) { AddAnItem(weakDict, i); } // Force gc to collect dead items GC.Collect(); if (GC.WaitForFullGCComplete() == GCNotificationStatus.Succeeded) { var key1 = new KeyObject(11); weakDict.Add(key1, 11); var key2 = new KeyObject(12); // Weak dictionary will remove dead items during this adding operation. // Then the currentRefreshInterval will be 1(still alive)+5=6. weakDict.Add(key2, 12); Assert.AreEqual(2, weakDict.Count); for (int i = 0; i < 3; i++) { AddAnItem(weakDict, i); } // Force gc to collect dead items GC.Collect(); if (GC.WaitForFullGCComplete() == GCNotificationStatus.Succeeded) { // Add the six item to dictionary. var key6 = new KeyObject(16); // Weak dictionary will not clean dead entities. weakDict.Add(key6, 16); Assert.AreEqual(6, weakDict.Count); var key14 = new KeyObject(114); // Weak dictionary will remove dead items during this adding operation. // Then the currentRefreshInterval will be 3(still alive)+5=8. weakDict.Add(key14, 114); Assert.AreEqual(4, weakDict.Count); } } }
public void TestRemoveDeadItemWhenAddMoreThanRefreshIntervalItems() { WeakDictionary<KeyObject, int> weakDict = new WeakDictionary<KeyObject, int>(this.comparer, 5); for (int i = 0; i < 5; i++) { AddAnItem(weakDict, i); } // Force gc to collect dead items GC.Collect(); if (GC.WaitForFullGCComplete() == GCNotificationStatus.Succeeded) { var key = new KeyObject(6); weakDict.Add(key, 6); // The countLimit after the first clean is 6 now. Assert.AreEqual(1, weakDict.Count); } }
private void AddTupleObject(WeakDictionary<object, int> dict, int id) { KeyObject key = new KeyObject(id); var tuple = new Tuple<object, MemberInfo>(key, this.memberInfo); dict.Add(tuple, rand.Next()); }
public void TestAddDiffTupleForSameObjectThrowsException() { WeakDictionary<object, int> weakDict = new WeakDictionary<object, int>(this.comparer, 5); var key = new Tuple<object, MemberInfo>(new KeyObject(10), this.memberInfo); weakDict.Add(key, 10); var key2 = new Tuple<object, MemberInfo>(key.Item1, this.memberInfo); Action testAction = () => { weakDict.Add(key2, 10); }; testAction.ShouldThrow<ArgumentException>(); }