Queue <ExpressionBuilder> DoAdd(WorkflowRuntimeException value)
{
var key = value.InnerException;
if (key != null)
{
var nestedKey = key as WorkflowRuntimeException;
if (nestedKey != null)
{
var callStack = DoAdd(nestedKey);
if (callStack != null)
{
callStack.Enqueue(value.Builder);
return(callStack);
}
}
else
{
var weakKey = new WeakKey <Exception>(key);
if (exceptions.ContainsKey(weakKey))
{
return(null);
}
CollectUnusedExceptions();
var callStack = new Queue <ExpressionBuilder>();
callStack.Enqueue(value.Builder);
exceptions.Add(weakKey, callStack);
return(callStack);
}
}
return(null);
}
//
//You can use the following additional attributes as you write your tests:
//
//Use ClassInitialize to run code before running the first test in the class
//[ClassInitialize()]
//public static void MyClassInitialize(TestContext testContext)
//{
//}
//
//Use ClassCleanup to run code after all tests in a class have run
//[ClassCleanup()]
//public static void MyClassCleanup()
//{
//}
//
//Use TestInitialize to run code before running each test
//[TestInitialize()]
//public void MyTestInitialize()
//{
//}
//
//Use TestCleanup to run code after each test has run
//[TestCleanup()]
//public void MyTestCleanup()
//{
//}
//
#endregion
/// <summary>
///A test for GetValue
///</summary>
public void GetValueTestHelper <E>(E e)
where E : class
{
WeakKey <E> target = new WeakKey <E>()
{
_elementReference = new WeakReference(e)
};
E value = null;
E valueExpected = e;
bool actual;
actual = target.GetValue(out value, true);
Assert.AreEqual(valueExpected, value);
Assert.IsTrue(actual);
((WeakReference)target._elementReference).Target = null;
actual = target.GetValue(out value, true);
Assert.IsFalse(actual);
((WeakReference)target._elementReference).Target = WeakKey <E> .NullValue;
actual = target.GetValue(out value, true);
Assert.IsTrue(actual);
Assert.AreEqual(null, value);
target._elementReference = e;
actual = target.GetValue(out value, false);
Assert.AreEqual(valueExpected, value);
Assert.IsTrue(actual);
}
/// <summary>
/// Gets or adds the attached values container.
/// </summary>
protected override LightDictionaryBase <string, object> GetOrAddAttachedDictionary(object item, bool addNew)
{
var dependencyObject = item as DependencyObject;
if (dependencyObject != null)
{
var dict = (AttachedValueDictionary)dependencyObject.GetValue(AttachedValueDictionaryProperty);
if (dict == null && addNew)
{
dict = new AttachedValueDictionary();
dependencyObject.SetValue(AttachedValueDictionaryProperty, dict);
}
return(dict);
}
lock (_internalDictionary)
{
WeakReference reference;
if (!_internalDictionary.TryGetValue(new WeakKey(item, false), out reference))
{
if (!addNew)
{
return(null);
}
var weakKey = new WeakKey(item, true);
reference = new WeakReference(new AttachedValueDictionary(weakKey, this), true);
_internalDictionary.Add(weakKey, reference);
}
return((LightDictionaryBase <string, object>)reference.Target);
}
}
/// <summary>
/// Equality between keys.
/// </summary>
/// <param name="obj">The object to compare to.</param>
/// <returns>True if they are equivalent.</returns>
public override bool Equals(object obj)
{
WeakKey other = obj as WeakKey;
if (other == null)
{
return(false);
}
object a = this.Target;
object b = other.Target;
if (a == null && b == null)
{
return(true);
}
else if (a == null || b == null)
{
return(false);
}
else
{
return(a.Equals(b));
}
}
public bool Remove(KeyValuePair <K, V> item)
{
WeakKey key = new WeakKey(item.Key);
lock (_sync)
{
return(_internalDictionary.Remove(key));
}
}
public bool TryGetValue(K key, out V value)
{
WeakKey k = new WeakKey(key);
lock (_sync)
{
return(_internalDictionary.TryGetValue(k, out value));
}
}
public bool TryGetValue(TKey key, out TValue value)
{
WeakKey tkey = new WeakKey(key);
lock (_internalObject)
{
return(_internalDictionary.TryGetValue(tkey, out value));
}
}
public bool Remove(KeyValuePair <TKey, TValue> item)
{
WeakKey key = new WeakKey(item.Key);
lock (_internalObject)
{
return(_internalDictionary.Remove(key));
}
}
/// <summary>
///A test for SetValue
///</summary>
public void SetValueTestHelper <E>(E e)
where E : class
{
WeakKey <E> target = new WeakKey <E>();
E value = e;
target.SetValue(value, false);
Assert.AreEqual(e, target._elementReference);
target.SetValue(value, true);
Assert.AreEqual(e, ((WeakReference)target._elementReference).Target);
}
public void Add(TKey key, TValue value)
{
WeakKey tkey = new WeakKey(key);
lock (_internalObject)
{
_internalDictionary.Add(tkey, value);
}
// This looks a bit weird but the purpose of the lost key finder is to execute
// code in some future garbage collection phase so we immediately create some garbage.
new LostKeyFinder(this, tkey);
}
/// <summary>
///A test for IsGarbage
///</summary>
public void IsGarbageTestHelper <E>(E e)
where E : class
{
WeakKey <E> target = new WeakKey <E>()
{
_elementReference = new WeakReference(e)
}; // TODO: Initialize to an appropriate value
Assert.IsFalse(target.IsGarbage);
((WeakReference)target._elementReference).Target = null;
Assert.IsTrue(target.IsGarbage);
}
/// <summary>
/// Clears all attached properties in the specified item.
/// </summary>
protected override bool ClearInternal(object item)
{
var dependencyObject = item as DependencyObject;
if (dependencyObject != null)
{
dependencyObject.ClearValue(AttachedValueDictionaryProperty);
return(true);
}
var weakKey = new WeakKey(item, false);
return(ClearInternal(ref weakKey));
}
public void TestWeakKeyHashBehavior()
{
var controlA = new TestControlA();
var controlB = new TestControlA();
var weakA = new WeakKey <Control>(controlA);
var weakA2 = new WeakKey <Control>(controlA);
Assert.IsTrue(weakA.Equals(weakA));
Assert.IsTrue(weakA.GetHashCode() == weakA2.GetHashCode());
Assert.IsTrue(weakA.Equals(weakA2));
Assert.IsTrue(weakA != weakA2);
Assert.IsTrue(!weakA.Equals(controlA));
Assert.IsTrue(!controlA.Equals(weakA));
var weakB = new WeakKey <Control>(controlB);
Assert.IsTrue(!weakA.Equals(weakB));
Assert.IsTrue(weakA.GetHashCode() != weakB.GetHashCode()); //Always true? Not sure, but I hope so!
var set = new HashSet <WeakKey <Control> >();
set.Add(weakA);
Assert.IsTrue(set.Count == 1);
set.Add(weakA2);
Assert.IsTrue(set.Count == 1);
set.Add(weakB);
Assert.IsTrue(set.Count == 2);
// Couldn't get this to work.
//controlA = null;
//controlB = null;
//GC.Collect(); //defaults are all generation and 'forced' collection
//foreach (SkinService.WeakKey<Control> key in set)
// Assert.IsTrue(!key.IsAlive);
// Proves that WeakReference can't do the job!
//var weakRefA = new WeakReference(controlA);
//var weakRefA2 = new WeakReference(controlA);
//var weakRefB = new WeakReference(controlB);
//var set2 = new HashSet<WeakReference>();
//set2.Add(weakRefA);
//Assert.IsTrue(set2.Count == 1);
//set2.Add(weakRefA2);
//Assert.IsTrue(set2.Count == 1); //it's 2!
//set2.Add(weakRefB);
//Assert.IsTrue(set2.Count == 2); //it's 3!
}
public void TestWeakKeyHashBehavior()
{
var controlA = new TestControlA();
var controlB = new TestControlA();
var weakA = new WeakKey<Control>(controlA);
var weakA2 = new WeakKey<Control>(controlA);
Assert.IsTrue(weakA.Equals(weakA));
Assert.IsTrue(weakA.GetHashCode() == weakA2.GetHashCode());
Assert.IsTrue(weakA.Equals(weakA2));
Assert.IsTrue(weakA != weakA2);
Assert.IsTrue(!weakA.Equals(controlA));
Assert.IsTrue(!controlA.Equals(weakA));
var weakB = new WeakKey<Control>(controlB);
Assert.IsTrue(!weakA.Equals(weakB));
Assert.IsTrue(weakA.GetHashCode() != weakB.GetHashCode()); //Always true? Not sure, but I hope so!
var set = new HashSet<WeakKey<Control>>();
set.Add(weakA);
Assert.IsTrue(set.Count == 1);
set.Add(weakA2);
Assert.IsTrue(set.Count == 1);
set.Add(weakB);
Assert.IsTrue(set.Count == 2);
// Couldn't get this to work.
//controlA = null;
//controlB = null;
//GC.Collect(); //defaults are all generation and 'forced' collection
//foreach (SkinService.WeakKey<Control> key in set)
// Assert.IsTrue(!key.IsAlive);
// Proves that WeakReference can't do the job!
//var weakRefA = new WeakReference(controlA);
//var weakRefA2 = new WeakReference(controlA);
//var weakRefB = new WeakReference(controlB);
//var set2 = new HashSet<WeakReference>();
//set2.Add(weakRefA);
//Assert.IsTrue(set2.Count == 1);
//set2.Add(weakRefA2);
//Assert.IsTrue(set2.Count == 1); //it's 2!
//set2.Add(weakRefB);
//Assert.IsTrue(set2.Count == 2); //it's 3!
}
private bool ClearInternal(ref WeakKey key)
{
lock (_internalDictionary)
{
WeakReference value;
if (!_internalDictionary.TryGetValue(key, out value) || !_internalDictionary.Remove(key))
{
return(false);
}
var dictionary = (AttachedValueDictionary)value.Target;
if (dictionary != null)
{
dictionary.Clear();
}
key.Free();
return(true);
}
}
public V this[K key]
{
get {
lock (_sync) {
return(_internalDictionary[new WeakKey(key)]);
}
}
set
{
WeakKey k = new WeakKey(key);
lock (_sync)
{
_internalDictionary[k] = value;
}
// This looks a bit weird but the purpose of the lost key finder is to execute
// code in some future garbage collection phase so we immediately create some garbage.
new LostKeyFinder(this, k);
}
}
/// <summary>
///A test for GetHashCode
///</summary>
void GetHashCodeTestHelper <E>(E e)
where E : class
{
WeakKeyComparer <E> target = new WeakKeyComparer <E>()
{
_equalityComparer = EqualityComparer <E> .Default
};
var key = new WeakKey <E>()
{
_elementReference = new WeakReference(e)
};
int hash1 = target.GetHashCode(ref key, true);
key.SetValue(e, false);
int hash2 = target.GetHashCode(ref key, false);
Assert.AreEqual(hash1, hash2);
}
public TValue this[TKey key]
{
get {
lock (_internalObject) {
return(_internalDictionary[new WeakKey(key)]);
}
}
set
{
WeakKey Tkey = new WeakKey(key);
lock (_internalObject)
{
//_internalDictionary[Tkey] = value;
_internalDictionary.Add(Tkey, value);
}
// This looks a bit weird but the purpose of the lost key finder is to execute
// code in some future garbage collection phase so we immediately create some garbage.
new LostKeyFinder(this, Tkey);
}
}
public bool TryGetValue(Exception key, out WorkflowException value)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
value = null;
var weakKey = new WeakKey <Exception>(key);
var result = exceptions.TryGetValue(weakKey, out Queue <ExpressionBuilder> callStack);
if (result)
{
while (callStack.Count > 0)
{
var builder = callStack.Dequeue();
value = new WorkflowRuntimeException(key.Message, builder, value ?? key);
}
}
return(result);
}
//
//You can use the following additional attributes as you write your tests:
//
//Use ClassInitialize to run code before running the first test in the class
//[ClassInitialize()]
//public static void MyClassInitialize(TestContext testContext)
//{
//}
//
//Use ClassCleanup to run code after all tests in a class have run
//[ClassCleanup()]
//public static void MyClassCleanup()
//{
//}
//
//Use TestInitialize to run code before running each test
//[TestInitialize()]
//public void MyTestInitialize()
//{
//}
//
//Use TestCleanup to run code after each test has run
//[TestCleanup()]
//public void MyTestCleanup()
//{
//}
//
#endregion
/// <summary>
///A test for Equals
///</summary>
void EqualsTestHelper <E>(E e1, E e2)
where E : class
{
WeakKeyComparer <E> target = new WeakKeyComparer <E>()
{
_equalityComparer = EqualityComparer <E> .Default
};
var key1 = new WeakKey <E>()
{
_elementReference = new WeakReference(e1)
};
var key2 = new WeakKey <E>()
{
_elementReference = new WeakReference(e2)
};
Assert.IsFalse(target.Equals(ref key1, true, ref key2, true));
Assert.IsFalse(target.Equals(ref key2, true, ref key1, true));
Assert.IsTrue(target.Equals(ref key1, true, ref key1, true));
Assert.IsTrue(target.Equals(ref key2, true, ref key2, true));
key2.SetValue(e1, true);
Assert.IsTrue(target.Equals(ref key1, true, ref key2, true));
Assert.IsTrue(target.Equals(ref key2, true, ref key1, true));
((WeakReference)key1._elementReference).Target = null;
Assert.IsFalse(target.Equals(ref key1, true, ref key2, true));
Assert.IsFalse(target.Equals(ref key2, true, ref key1, true));
((WeakReference)key2._elementReference).Target = null;
Assert.IsFalse(target.Equals(ref key1, true, ref key2, true));
Assert.IsFalse(target.Equals(ref key2, true, ref key1, true));
Assert.IsTrue(target.Equals(ref key1, true, ref key1, true));
Assert.IsTrue(target.Equals(ref key2, true, ref key2, true));
key1.SetValue(e1, true);
key2.SetValue(e2, false);
Assert.IsFalse(target.Equals(ref key1, true, ref key2, false));
Assert.IsFalse(target.Equals(ref key2, false, ref key1, true));
Assert.IsTrue(target.Equals(ref key1, true, ref key1, true));
Assert.IsTrue(target.Equals(ref key2, false, ref key2, false));
key2.SetValue(e1, false);
Assert.IsTrue(target.Equals(ref key1, true, ref key2, false));
Assert.IsTrue(target.Equals(ref key2, false, ref key1, true));
key2.SetValue(null, false);
Assert.IsFalse(target.Equals(ref key1, true, ref key2, false));
Assert.IsFalse(target.Equals(ref key2, false, ref key1, true));
((WeakReference)key1._elementReference).Target = null;
Assert.IsFalse(target.Equals(ref key1, true, ref key2, false));
Assert.IsFalse(target.Equals(ref key2, false, ref key1, true));
key1.SetValue(e1, false);
key2.SetValue(e2, false);
Assert.IsFalse(target.Equals(ref key1, false, ref key2, false));
Assert.IsFalse(target.Equals(ref key2, false, ref key1, false));
key2.SetValue(e1, false);
Assert.IsTrue(target.Equals(ref key1, false, ref key2, false));
Assert.IsTrue(target.Equals(ref key2, false, ref key1, false));
}
public LostKeyFinder(WeakKeyDictionary <TKey, TValue> dictionary, WeakKey key)
{
_dictionary = dictionary;
_key = key;
}
protected bool ShouldEntryBeRemoved(WeakKey <Key> key, Value val)
{
return(!key.IsAlive);
}
public AttachedValueDictionary(WeakKey reference, WeakReferenceAttachedValueProvider provider)
: base(true)
{
_reference = reference;
Add(ProviderKey, provider);
}
public LostKeyFinder(WeakKeyDictionary <K, V> dictionary, WeakKey key)
{
_dictionary = dictionary;
_key = key;
}