public void CallbackContext_BindingFuncWithDefaultSyncContext_ThrowsInvalidOperationException()
{
using (CallbackContext context = new CallbackContext())
{
var action = context.Bind(() => { return(13); }, new SynchronizationContext());
}
}
public void InvalidBoundSyncedFunc_Invoked_DoesSync()
{
bool sawSync = false;
using (CallbackContext context = new CallbackContext())
using (ActionThread thread = new ActionThread())
{
thread.Start();
// Capture the thread's SynchronizationContext and signal this thread when it's captured.
SynchronizationContext actionThreadSyncContext = thread.DoGet(() => { return(SynchronizationContext.Current); });
var syncContext = new Util.LoggingSynchronizationContext(actionThreadSyncContext)
{
OnPost = () => { sawSync = true; },
OnSend = () => { sawSync = true; }
};
var action = context.Bind(() => { return(13); }, syncContext, false);
context.Reset();
int result = action();
Assert.IsTrue(sawSync, "Context did not use SyncContext for sync");
}
}
public void CallbackContext_WithBoundFunc_IsNotInvalid()
{
using (CallbackContext context = new CallbackContext())
{
var action = context.Bind(() => { return(13); });
Assert.IsFalse(context.Invalidated, "Bound action should be valid");
}
}
public void CallbackContext_Reset_InvalidatesAllActions()
{
bool sawAction1 = false;
bool sawAction2 = false;
using (CallbackContext context = new CallbackContext())
{
var action1 = context.Bind(() => { sawAction1 = true; });
var action2 = context.Bind(() => { sawAction2 = true; });
context.Reset();
action1();
action2();
Assert.IsFalse(sawAction1, "Invalid action did execute");
Assert.IsFalse(sawAction2, "Invalid action did execute");
}
}
public void CallbackContext_ResetAfterBindingFunc_IsInvalid()
{
using (CallbackContext context = new CallbackContext())
{
var action = context.Bind(() => { return(13); });
context.Reset();
Assert.IsTrue(context.Invalidated, "Bound action should be invalid");
}
}
public void CallbackContext_WithInvokedAction_IsNotInvalid()
{
using (CallbackContext context = new CallbackContext())
{
var action = context.Bind(() => { });
action();
Assert.IsFalse(context.Invalidated, "Bound action should be valid");
}
}
public void ValidFunc_Invoked_ReturnsValue()
{
using (CallbackContext context = new CallbackContext())
{
var action = context.Bind(() => { return(13); });
int result = action();
Assert.AreEqual(13, result, "Func result not returned");
}
}
public void BoundFakesyncedAction_Invoked_DoesNotUseSyncObject()
{
using (CallbackContext context = new CallbackContext())
{
var syncObject = new FakeActionSynchronizingObject(false);
var action = context.Bind(() => { }, syncObject);
action();
Assert.IsFalse(syncObject.sawInvoke, "Bound action did run through synchronizing object");
}
}
public void BoundObjectsyncedAction_Invoked_UsesSyncObject()
{
using (CallbackContext context = new CallbackContext())
{
var syncObject = new FakeActionSynchronizingObject(true);
var action = context.Bind(() => { }, syncObject);
action();
Assert.IsTrue(syncObject.sawInvoke, "Bound action did not run through synchronizing object");
}
}
public void BoundFakesyncedFunc_Invoked_ReturnsValue()
{
using (CallbackContext context = new CallbackContext())
{
var syncObject = new FakeFuncSynchronizingObject(false);
var action = context.Bind(() => { return(13); }, syncObject);
int result = action();
Assert.AreEqual(13, result, "Bound func did not return result");
}
}
public void BoundObjectsyncedFunc_Invoked_UsesSyncObject()
{
using (CallbackContext context = new CallbackContext())
{
var syncObject = new FakeFuncSynchronizingObject(true);
var action = context.Bind(() => { return(13); }, syncObject);
int result = action();
Assert.IsTrue(syncObject.sawInvoke, "Bound action did not run through synchronizing object");
}
}
public void CallbackContext_AfterInvokingInvalidAction_IsInvalid()
{
using (CallbackContext context = new CallbackContext())
{
var action = context.Bind(() => { });
context.Reset();
action();
Assert.IsTrue(context.Invalidated, "Bound action should be invalid");
}
}
public void InvalidFunc_Invoked_ReturnsDefault()
{
using (CallbackContext context = new CallbackContext())
{
var action = context.Bind(() => { return(13); });
context.Reset();
int result = action();
Assert.AreEqual(default(int), result, "Invalid func had a non-default return value");
}
}
public void ActionBoundToDefaultSyncContext_Invoked_Executes()
{
using (CallbackContext context = new CallbackContext())
using (ManualResetEvent evt = new ManualResetEvent(false))
{
var action = context.Bind(() => { evt.Set(); }, new SynchronizationContext(), false);
action();
bool signalled = evt.WaitOne(100);
Assert.IsTrue(signalled, "Action did not run");
}
}
public void ValidFunc_Invoked_Executes()
{
bool sawAction = false;
using (CallbackContext context = new CallbackContext())
{
var action = context.Bind(() => { sawAction = true; return(13); });
int result = action();
Assert.IsTrue(sawAction, "Bound action did not execute");
}
}
public void InvalidBoundObjectsyncedFunc_Invoked_ReturnsDefault()
{
using (CallbackContext context = new CallbackContext())
{
var syncObject = new FakeFuncSynchronizingObject(true);
var action = context.Bind(() => { return(13); }, syncObject);
context.Reset();
int result = action();
Assert.AreEqual(0, result, "Invalid func returned non-default value");
}
}
public void FuncBoundToDefaultSyncContext_Invoked_Executes()
{
using (CallbackContext context = new CallbackContext())
using (ManualResetEvent evt = new ManualResetEvent(false))
{
var action = context.Bind(() => { evt.Set(); return(13); }, new SynchronizationContext(), false);
int result = action();
bool signalled = evt.WaitOne(100);
Assert.IsTrue(signalled, "Action did not run");
}
}
public void BoundObjectsyncedAction_Invoked_Executes()
{
bool sawAction = false;
using (CallbackContext context = new CallbackContext())
{
var syncObject = new FakeActionSynchronizingObject(true);
var action = context.Bind(() => { sawAction = true; }, syncObject);
action();
Assert.IsTrue(sawAction, "Bound action did not run");
}
}
public void BoundObjectsyncedFunc_Invoked_SynchronizesWithSyncObject()
{
int sawActionThread = Thread.CurrentThread.ManagedThreadId;
using (CallbackContext context = new CallbackContext())
{
var syncObject = new FakeFuncSynchronizingObject(true);
var action = context.Bind(() => { sawActionThread = Thread.CurrentThread.ManagedThreadId; return(13); }, syncObject);
int result = action();
Assert.AreNotEqual(Thread.CurrentThread.ManagedThreadId, sawActionThread, "Bound action was not synchronized");
}
}
public void BoundFakesyncedAction_Invoked_DoesNotSynchronizeWithSyncObject()
{
int sawActionThread = Thread.CurrentThread.ManagedThreadId;
using (CallbackContext context = new CallbackContext())
{
var syncObject = new FakeActionSynchronizingObject(false);
var action = context.Bind(() => { sawActionThread = Thread.CurrentThread.ManagedThreadId; }, syncObject);
action();
Assert.AreEqual(Thread.CurrentThread.ManagedThreadId, sawActionThread, "Bound action was not run inline");
}
}
public void InvalidAction_Invoked_DoesNotExecute()
{
bool sawAction = false;
using (CallbackContext context = new CallbackContext())
{
var action = context.Bind(() => { sawAction = true; });
context.Reset();
action();
Assert.IsFalse(sawAction, "Invalid action did execute");
}
}
public void BoundFakesyncedFunc_Invoked_Executes()
{
bool sawAction = false;
using (CallbackContext context = new CallbackContext())
{
var syncObject = new FakeFuncSynchronizingObject(false);
var action = context.Bind(() => { sawAction = true; return(13); }, syncObject);
int result = action();
Assert.IsTrue(sawAction, "Bound action did not run");
}
}
public void Action_InvokedAfterContextDispose_DoesNotExecute()
{
bool sawAction = false;
Action action = null;
using (CallbackContext context = new CallbackContext())
{
action = context.Bind(() => { sawAction = true; });
}
action();
Assert.IsFalse(sawAction, "Invalid action did execute");
}
public void InvalidBoundObjectsyncedAction_Invoked_DoesNotExecute()
{
int sawActionThread = Thread.CurrentThread.ManagedThreadId;
using (CallbackContext context = new CallbackContext())
{
var syncObject = new FakeActionSynchronizingObject(true);
var action = context.Bind(() => { sawActionThread = Thread.CurrentThread.ManagedThreadId; }, syncObject);
context.Reset();
action();
Assert.AreEqual(Thread.CurrentThread.ManagedThreadId, sawActionThread, "Bound action was executed");
}
}
public void Func_InvokedAfterContextDispose_ReturnsDefault()
{
Func <int> action = null;
using (CallbackContext context = new CallbackContext())
{
action = context.Bind(() => { return(13); });
}
int result = action();
Assert.AreEqual(0, result, "Invalid func had a non-default return value");
}
public void Action_InvokedAfterContextDispose_DoesNotExecute()
{
bool sawAction = false;
Action action = null;
using (CallbackContext context = new CallbackContext())
{
action = context.Bind(() => { sawAction = true; });
}
action();
Assert.IsFalse(sawAction, "Invalid action did execute");
}
public void Func_InvokedAfterContextDispose_DoesNotExecute()
{
bool sawAction = false;
Func <int> action = null;
using (CallbackContext context = new CallbackContext())
{
action = context.Bind(() => { sawAction = true; return(13); });
}
int result = action();
Assert.IsFalse(sawAction, "Invalid action did execute");
}
public void InvalidBoundSyncedFunc_Invoked_ReturnsDefault()
{
using (CallbackContext context = new CallbackContext())
using (ActionThread thread = new ActionThread())
{
thread.Start();
// Capture the thread's SynchronizationContext and signal this thread when it's captured.
SynchronizationContext actionThreadSyncContext = thread.DoGet(() => { return(SynchronizationContext.Current); });
var action = context.Bind(() => { return(13); }, actionThreadSyncContext, false);
context.Reset();
int result = action();
Assert.AreEqual(0, result, "Invalid Func returned a non-default value");
}
}
public void BoundSyncedFunc_Invoked_ExecutesSynchronized()
{
int sawActionThread = Thread.CurrentThread.ManagedThreadId;
using (CallbackContext context = new CallbackContext())
using (ActionThread thread = new ActionThread())
{
thread.Start();
// Capture the thread's SynchronizationContext
SynchronizationContext actionThreadSyncContext = thread.DoGet(() => { return(SynchronizationContext.Current); });
var action = context.Bind(() => { sawActionThread = Thread.CurrentThread.ManagedThreadId; return(13); }, actionThreadSyncContext);
int result = action();
Assert.AreEqual(thread.ManagedThreadId, sawActionThread, "Bound action was not synchronized");
}
}
public void InvalidBoundSyncedFunc_Invoked_DoesNotExecute()
{
int sawActionThread = Thread.CurrentThread.ManagedThreadId;
using (CallbackContext context = new CallbackContext())
using (ActionThread thread = new ActionThread())
{
thread.Start();
// Capture the thread's SynchronizationContext and signal this thread when it's captured.
SynchronizationContext actionThreadSyncContext = thread.DoGet(() => { return(SynchronizationContext.Current); });
var action = context.Bind(() => { sawActionThread = Thread.CurrentThread.ManagedThreadId; return(13); }, actionThreadSyncContext, false);
context.Reset();
int result = action();
Assert.AreEqual(Thread.CurrentThread.ManagedThreadId, sawActionThread, "Invalid action should not run");
}
}
public void BoundSyncedFunc_Invoked_DecrementsSyncContextOperationCount()
{
bool sawOperationCompleted = false;
using (CallbackContext context = new CallbackContext())
using (ActionThread thread = new ActionThread())
{
thread.Start();
// Capture the thread's SynchronizationContext
SynchronizationContext actionThreadSyncContext = thread.DoGet(() => { return(SynchronizationContext.Current); });
var syncContext = new Util.LoggingSynchronizationContext(actionThreadSyncContext)
{
OnOperationCompleted = () => { sawOperationCompleted = true; }
};
var action = context.Bind(() => { return(13); }, syncContext, false);
int result = action();
Assert.IsFalse(sawOperationCompleted, "Context decremented operation count");
}
}
public void BoundSyncedAction_Invoked_UsesSyncContext()
{
bool sawSync = false;
using (CallbackContext context = new CallbackContext())
using (ActionThread thread = new ActionThread())
{
thread.Start();
// Capture the thread's SynchronizationContext
SynchronizationContext actionThreadSyncContext = thread.DoGet(() => { return(SynchronizationContext.Current); });
var syncContext = new Util.LoggingSynchronizationContext(actionThreadSyncContext)
{
OnPost = () => { sawSync = true; },
OnSend = () => { sawSync = true; }
};
var action = context.Bind(() => { }, syncContext, false);
action();
Assert.IsTrue(sawSync, "Context did not use SyncContext for sync");
}
}
public void CallbackContext_WithInvokedAction_IsNotInvalid()
{
using (CallbackContext context = new CallbackContext())
{
var action = context.Bind(() => { });
action();
Assert.IsFalse(context.Invalidated, "Bound action should be valid");
}
}
public void CallbackContext_ResetAfterBindingFunc_IsInvalid()
{
using (CallbackContext context = new CallbackContext())
{
var action = context.Bind(() => { return 13; });
context.Reset();
Assert.IsTrue(context.Invalidated, "Bound action should be invalid");
}
}
public void CallbackContext_Reset_InvalidatesAllFuncs()
{
bool sawAction1 = false;
bool sawAction2 = false;
using (CallbackContext context = new CallbackContext())
{
var action1 = context.Bind(() => { sawAction1 = true; return 13; });
var action2 = context.Bind(() => { sawAction2 = true; return 17; });
context.Reset();
int result1 = action1();
int result2 = action2();
Assert.IsFalse(sawAction1, "Invalid action did execute");
Assert.IsFalse(sawAction2, "Invalid action did execute");
}
}
public void CallbackContext_AfterInvokingInvalidAction_IsInvalid()
{
using (CallbackContext context = new CallbackContext())
{
var action = context.Bind(() => { });
context.Reset();
action();
Assert.IsTrue(context.Invalidated, "Bound action should be invalid");
}
}
public void CallbackContext_BindingFuncWithDefaultSyncContext_ThrowsInvalidOperationException()
{
using (CallbackContext context = new CallbackContext())
{
var action = context.Bind(() => { return 13; }, new SynchronizationContext());
}
}
public void BoundFakesyncedFunc_Invoked_DoesNotUseSyncObject()
{
using (CallbackContext context = new CallbackContext())
{
var syncObject = new FakeFuncSynchronizingObject(false);
var action = context.Bind(() => { return 13; }, syncObject);
int result = action();
Assert.IsFalse(syncObject.sawInvoke, "Bound action did run through synchronizing object");
}
}
public void BoundSyncedFunc_Invoked_IncrementsSyncContextOperationCount()
{
bool sawOperationStarted = false;
using (CallbackContext context = new CallbackContext())
using (ActionThread thread = new ActionThread())
{
thread.Start();
// Capture the thread's SynchronizationContext
SynchronizationContext actionThreadSyncContext = thread.DoGet(() => { return SynchronizationContext.Current; });
var syncContext = new LoggingSynchronizationContext(actionThreadSyncContext)
{
OnOperationStarted = () => { sawOperationStarted = true; }
};
var action = context.Bind(() => { return 13; }, syncContext, false);
int result = action();
Assert.IsFalse(sawOperationStarted, "Context incremented operation count");
}
}
public void InvalidBoundObjectsyncedFunc_Invoked_ReturnsDefault()
{
using (CallbackContext context = new CallbackContext())
{
var syncObject = new FakeFuncSynchronizingObject(true);
var action = context.Bind(() => { return 13; }, syncObject);
context.Reset();
int result = action();
Assert.AreEqual(0, result, "Invalid func returned non-default value");
}
}
public void Func_InvokedAfterContextDispose_ReturnsDefault()
{
Func<int> action = null;
using (CallbackContext context = new CallbackContext())
{
action = context.Bind(() => { return 13; });
}
int result = action();
Assert.AreEqual(0, result, "Invalid func had a non-default return value");
}
public void BoundObjectsyncedFunc_Invoked_Executes()
{
bool sawAction = false;
using (CallbackContext context = new CallbackContext())
{
var syncObject = new FakeFuncSynchronizingObject(true);
var action = context.Bind(() => { sawAction = true; return 13; }, syncObject);
int result = action();
Assert.IsTrue(sawAction, "Bound action did not run");
}
}
public void BoundObjectsyncedFunc_Invoked_ReturnsValue()
{
using (CallbackContext context = new CallbackContext())
{
var syncObject = new FakeFuncSynchronizingObject(true);
var action = context.Bind(() => { return 13; }, syncObject);
int result = action();
Assert.AreEqual(13, result, "Bound func did not return result");
}
}
public void InvalidFunc_Invoked_ReturnsDefault()
{
using (CallbackContext context = new CallbackContext())
{
var action = context.Bind(() => { return 13; });
context.Reset();
int result = action();
Assert.AreEqual(default(int), result, "Invalid func had a non-default return value");
}
}
public void InvalidBoundSyncedFunc_Invoked_ReturnsDefault()
{
using (CallbackContext context = new CallbackContext())
using (ActionThread thread = new ActionThread())
{
thread.Start();
// Capture the thread's SynchronizationContext and signal this thread when it's captured.
SynchronizationContext actionThreadSyncContext = thread.DoGet(() => { return SynchronizationContext.Current; });
var action = context.Bind(() => { return 13; }, actionThreadSyncContext, false);
context.Reset();
int result = action();
Assert.AreEqual(0, result, "Invalid Func returned a non-default value");
}
}
public void InvalidBoundSyncedFunc_Invoked_DoesNotExecute()
{
int sawActionThread = Thread.CurrentThread.ManagedThreadId;
using (CallbackContext context = new CallbackContext())
using (ActionThread thread = new ActionThread())
{
thread.Start();
// Capture the thread's SynchronizationContext and signal this thread when it's captured.
SynchronizationContext actionThreadSyncContext = thread.DoGet(() => { return SynchronizationContext.Current; });
var action = context.Bind(() => { sawActionThread = Thread.CurrentThread.ManagedThreadId; return 13; }, actionThreadSyncContext, false);
context.Reset();
int result = action();
Assert.AreEqual(Thread.CurrentThread.ManagedThreadId, sawActionThread, "Invalid action should not run");
}
}
public void CallbackContext_WithInvokedFunc_IsNotInvalid()
{
using (CallbackContext context = new CallbackContext())
{
var action = context.Bind(() => { return 13; });
int result = action();
Assert.IsFalse(context.Invalidated, "Bound action should be valid");
}
}
public void BoundFakesyncedAction_Invoked_Executes()
{
bool sawAction = false;
using (CallbackContext context = new CallbackContext())
{
var syncObject = new FakeActionSynchronizingObject(false);
var action = context.Bind(() => { sawAction = true; }, syncObject);
action();
Assert.IsTrue(sawAction, "Bound action did not run");
}
}
public void Func_InvokedAfterContextDispose_DoesNotExecute()
{
bool sawAction = false;
Func<int> action = null;
using (CallbackContext context = new CallbackContext())
{
action = context.Bind(() => { sawAction = true; return 13; });
}
int result = action();
Assert.IsFalse(sawAction, "Invalid action did execute");
}
public void BoundFakesyncedFunc_Invoked_DoesNotSynchronizeWithSyncObject()
{
int sawActionThread = Thread.CurrentThread.ManagedThreadId;
using (CallbackContext context = new CallbackContext())
{
var syncObject = new FakeFuncSynchronizingObject(false);
var action = context.Bind(() => { sawActionThread = Thread.CurrentThread.ManagedThreadId; return 13; }, syncObject);
int result = action();
Assert.AreEqual(Thread.CurrentThread.ManagedThreadId, sawActionThread, "Bound action was not run inline");
}
}
public void InvalidBoundObjectsyncedFunc_Invoked_DoesNotExecute()
{
int sawActionThread = Thread.CurrentThread.ManagedThreadId;
using (CallbackContext context = new CallbackContext())
{
var syncObject = new FakeFuncSynchronizingObject(true);
var action = context.Bind(() => { sawActionThread = Thread.CurrentThread.ManagedThreadId; return 13; }, syncObject);
context.Reset();
int result = action();
Assert.AreEqual(Thread.CurrentThread.ManagedThreadId, sawActionThread, "Bound action was executed");
}
}
public void BoundSyncedFunc_Invoked_ExecutesSynchronized()
{
int sawActionThread = Thread.CurrentThread.ManagedThreadId;
using (CallbackContext context = new CallbackContext())
using (ActionThread thread = new ActionThread())
{
thread.Start();
// Capture the thread's SynchronizationContext
SynchronizationContext actionThreadSyncContext = thread.DoGet(() => { return SynchronizationContext.Current; });
var action = context.Bind(() => { sawActionThread = Thread.CurrentThread.ManagedThreadId; return 13; }, actionThreadSyncContext);
int result = action();
Assert.AreEqual(thread.ManagedThreadId, sawActionThread, "Bound action was not synchronized");
}
}
public void InvalidBoundObjectsyncedFunc_Invoked_SynchronizesWithSyncObject()
{
using (CallbackContext context = new CallbackContext())
{
var syncObject = new FakeFuncSynchronizingObject(true);
var action = context.Bind(() => { return 13; }, syncObject);
context.Reset();
int result = action();
Assert.IsTrue(syncObject.sawInvoke, "Bound action did not run through synchronizing object");
}
}
public void BoundSyncedAction_Invoked_UsesSyncContext()
{
bool sawSync = false;
using (CallbackContext context = new CallbackContext())
using (ActionThread thread = new ActionThread())
{
thread.Start();
// Capture the thread's SynchronizationContext
SynchronizationContext actionThreadSyncContext = thread.DoGet(() => { return SynchronizationContext.Current; });
var syncContext = new LoggingSynchronizationContext(actionThreadSyncContext)
{
OnPost = () => { sawSync = true; },
OnSend = () => { sawSync = true; }
};
var action = context.Bind(() => { }, syncContext, false);
action();
Assert.IsTrue(sawSync, "Context did not use SyncContext for sync");
}
}
public void InvalidBoundSyncedFunc_Invoked_DoesSync()
{
bool sawSync = false;
using (CallbackContext context = new CallbackContext())
using (ActionThread thread = new ActionThread())
{
thread.Start();
// Capture the thread's SynchronizationContext and signal this thread when it's captured.
SynchronizationContext actionThreadSyncContext = thread.DoGet(() => { return SynchronizationContext.Current; });
var syncContext = new LoggingSynchronizationContext(actionThreadSyncContext)
{
OnPost = () => { sawSync = true; },
OnSend = () => { sawSync = true; }
};
var action = context.Bind(() => { return 13; }, syncContext, false);
context.Reset();
int result = action();
Assert.IsTrue(sawSync, "Context did not use SyncContext for sync");
}
}
public void BoundObjectsyncedAction_Invoked_SynchronizesWithSyncObject()
{
int sawActionThread = Thread.CurrentThread.ManagedThreadId;
using (CallbackContext context = new CallbackContext())
{
var syncObject = new FakeActionSynchronizingObject(true);
var action = context.Bind(() => { sawActionThread = Thread.CurrentThread.ManagedThreadId; }, syncObject);
action();
Assert.AreNotEqual(Thread.CurrentThread.ManagedThreadId, sawActionThread, "Bound action was not synchronized");
}
}
public void InvalidFunc_Invoked_DoesNotExecute()
{
bool sawAction = false;
using (CallbackContext context = new CallbackContext())
{
var action = context.Bind(() => { sawAction = true; return 13; });
context.Reset();
int result = action();
Assert.IsFalse(sawAction, "Invalid action did execute");
}
}
public void BoundObjectsyncedAction_Invoked_UsesSyncObject()
{
using (CallbackContext context = new CallbackContext())
{
var syncObject = new FakeActionSynchronizingObject(true);
var action = context.Bind(() => { }, syncObject);
action();
Assert.IsTrue(syncObject.sawInvoke, "Bound action did not run through synchronizing object");
}
}
public void ValidAction_Invoked_Executes()
{
bool sawAction = false;
using (CallbackContext context = new CallbackContext())
{
var action = context.Bind(() => { sawAction = true; });
action();
Assert.IsTrue(sawAction, "Bound action did not execute");
}
}
public void ValidFunc_Invoked_ReturnsValue()
{
using (CallbackContext context = new CallbackContext())
{
var action = context.Bind(() => { return 13; });
int result = action();
Assert.AreEqual(13, result, "Func result not returned");
}
}
