public void TestPublicNestedClassPublicNamedMethod()
{
Reset();
const int index = 99;
_itemPublic = new PublicNestedTestClass(index);
_action = _itemPublic.GetAction(WeakActionTestCase.PublicNamedMethod);
_reference = new WeakReference(_itemPublic);
Assert.IsTrue(_reference.IsAlive);
Assert.IsTrue(_action.IsAlive);
_action.Execute();
Assert.AreEqual(
PublicNestedTestClass.Expected + PublicNestedTestClass.Public + index,
PublicNestedTestClass.Result);
_itemPublic = null;
GC.Collect();
Assert.IsFalse(_reference.IsAlive);
}
public void TestPublicNestedClassInternalNamedMethod()
{
Reset();
const int index = 99;
_itemPublic = new PublicNestedTestClass(index);
_reference = new WeakReference(_itemPublic);
_action = _itemPublic.GetAction(WeakActionTestCase.InternalNamedMethod);
Assert.IsTrue(_reference.IsAlive);
Assert.IsTrue(_action.IsAlive);
_action.Execute();
Assert.AreEqual(
PublicNestedTestClass.Expected + PublicNestedTestClass.Internal + index,
PublicNestedTestClass.Result);
_itemPublic = null;
GC.Collect();
#if SILVERLIGHT
Assert.IsTrue(_reference.IsAlive); // Anonymous, private and internal methods cannot be GCed
_action = null;
GC.Collect();
Assert.IsFalse(_reference.IsAlive);
#else
Assert.IsFalse(_reference.IsAlive);
#endif
}
public void TestPublicClassPublicStaticMethod()
{
Reset();
const string parameter = "My parameter";
_itemPublic = new PublicTestClass<string>();
_reference = new WeakReference(_itemPublic);
_action = _itemPublic.GetAction(WeakActionTestCase.PublicStaticMethod);
Assert.IsTrue(_reference.IsAlive);
Assert.IsTrue(_action.IsAlive);
_action.Execute(parameter);
Assert.AreEqual(
PublicTestClass<string>.Expected + PublicTestClass<string>.PublicStatic + parameter,
PublicTestClass<string>.Result);
_itemPublic = null;
GC.Collect();
Assert.IsFalse(_reference.IsAlive);
}
/// <summary>
/// Initializes a new instance of the RelayCommand class.
/// </summary>
/// <param name="execute">The execution logic.</param>
/// <param name="canExecute">The execution status logic.</param>
/// <exception cref="ArgumentNullException">If the execute argument is null.</exception>
public RelayCommand(Action execute, Func<bool> canExecute)
{
if (execute == null)
{
throw new ArgumentNullException("execute");
}
_execute = new WeakAction(execute);
if (canExecute != null)
{
_canExecute = new WeakFunc<bool>(canExecute);
}
}
public WeakAction GetAction(WeakActionTestCase testCase)
{
WeakAction action = null;
switch (testCase)
{
case WeakActionTestCase.PublicNamedMethod:
action = new WeakAction(
this,
DoStuffPublically);
break;
case WeakActionTestCase.InternalNamedMethod:
action = new WeakAction(
this,
DoStuffInternally);
break;
case WeakActionTestCase.PrivateNamedMethod:
action = new WeakAction(
this,
DoStuffPrivately);
break;
case WeakActionTestCase.PublicStaticMethod:
action = new WeakAction(
this,
DoStuffPublicallyAndStatically);
break;
case WeakActionTestCase.PrivateStaticMethod:
action = new WeakAction(
this,
DoStuffPrivatelyAndStatically);
break;
case WeakActionTestCase.AnonymousStaticMethod:
action = new WeakAction(
this,
() => Result = Expected);
break;
case WeakActionTestCase.AnonymousMethod:
action = new WeakAction(
this,
() => Result = Expected + _index);
break;
}
return action;
}
public void TestPublicClassPublicStaticMethod()
{
Reset();
_itemPublic = new PublicTestClass();
_reference = new WeakReference(_itemPublic);
_action = _itemPublic.GetAction(WeakActionTestCase.PublicStaticMethod);
Assert.IsTrue(_reference.IsAlive);
Assert.IsTrue(_action.IsAlive);
_action.Execute();
Assert.AreEqual(
PublicTestClass.Expected + PublicTestClass.PublicStatic,
PublicTestClass.Result);
_itemPublic = null;
GC.Collect();
Assert.IsFalse(_reference.IsAlive);
}
public void TestPrivateNestedClassAnonymousStaticMethod()
{
Reset();
_itemPrivate = new PrivateNestedTestClass();
_reference = new WeakReference(_itemPrivate);
_action = _itemPrivate.GetAction(WeakActionTestCase.AnonymousStaticMethod);
Assert.IsTrue(_reference.IsAlive);
Assert.IsTrue(_action.IsAlive);
_action.Execute();
Assert.AreEqual(
PrivateNestedTestClass.Expected,
PrivateNestedTestClass.Result);
_itemPrivate = null;
GC.Collect();
Assert.IsFalse(_reference.IsAlive);
}
public void TestInternalNestedClassPrivateStaticMethod()
{
Reset();
_itemInternal = new InternalNestedTestClass();
_reference = new WeakReference(_itemInternal);
_action = _itemInternal.GetAction(WeakActionTestCase.PrivateStaticMethod);
Assert.IsTrue(_reference.IsAlive);
Assert.IsTrue(_action.IsAlive);
_action.Execute();
Assert.AreEqual(
InternalNestedTestClass.Expected + InternalNestedTestClass.PrivateStatic,
InternalNestedTestClass.Result);
_itemInternal = null;
GC.Collect();
Assert.IsFalse(_reference.IsAlive);
}
public void TestStaticMethodWithNonNullTarget()
{
Reset();
_common = new CommonTestClass();
_reference = new WeakReference(_common);
Assert.IsTrue(_reference.IsAlive);
var action = new WeakAction<string>(_common, DoStuffStatic);
Assert.IsTrue(action.IsAlive);
_common = null;
GC.Collect();
Assert.IsFalse(_reference.IsAlive);
Assert.IsFalse(action.IsAlive);
}
public void TestStaticMethodWithNullTarget()
{
Reset();
var action = new WeakAction<string>(null, DoStuffStatic);
Assert.IsTrue(action.IsAlive);
}
public void TestInternalClassAnonymousStaticMethod()
{
Reset();
const string parameter = "My parameter";
_itemInternal = new InternalTestClass<string>();
_reference = new WeakReference(_itemInternal);
_action = _itemInternal.GetAction(WeakActionTestCase.AnonymousStaticMethod);
Assert.IsTrue(_reference.IsAlive);
Assert.IsTrue(_action.IsAlive);
_action.Execute(parameter);
Assert.AreEqual(
InternalTestClass<string>.Expected + parameter,
InternalTestClass<string>.Result);
_itemInternal = null;
GC.Collect();
Assert.IsFalse(_reference.IsAlive);
}
public void TestInternalClassAnonymousMethod()
{
Reset();
const int index = 99;
const string parameter = "My parameter";
_itemInternal = new InternalTestClass<string>(index);
_reference = new WeakReference(_itemInternal);
_action = _itemInternal.GetAction(WeakActionTestCase.AnonymousMethod);
Assert.IsTrue(_reference.IsAlive);
Assert.IsTrue(_action.IsAlive);
_action.Execute(parameter);
Assert.AreEqual(
InternalTestClass<string>.Expected + index + parameter,
InternalTestClass<string>.Result);
_itemInternal = null;
GC.Collect();
#if SILVERLIGHT
Assert.IsTrue(_reference.IsAlive); // Anonymous, private and internal methods cannot be GCed
_action = null;
GC.Collect();
Assert.IsFalse(_reference.IsAlive);
#else
Assert.IsFalse(_reference.IsAlive);
#endif
}
public void TestNonStaticMethodWithNullTarget()
{
Reset();
var action = new WeakAction(null, DoStuff);
Assert.IsFalse(action.IsAlive);
}
