public void MultipleConcurrentDispatchAsyncsRunInSerialFollowedByDispatchSync()
{
var q = new SerialQueue(realPool);
var hit = new List <int>();
q.DispatchAsync(() => {
hit.Add(1);
Thread.Sleep(50);
hit.Add(2);
});
q.DispatchAsync(() => {
hit.Add(3);
Thread.Sleep(50);
hit.Add(4);
});
q.DispatchSync(() => {
hit.Add(5);
});
q.DispatchSync(() => {
hit.Add(6);
});
q.DispatchAsync(() => {
hit.Add(7);
Thread.Sleep(50);
hit.Add(8);
});
q.DispatchSync(() => {
hit.Add(9);
});
CollectionAssert.AreEqual(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 }, hit);
}
public unsafe void CloseSocket()
{
_queue.DispatchAsync(() =>
{
_connected.Wait();
ResetConnections();
_c4Queue.DispatchAsync(() => Native.c4socket_closed(_socket, new C4Error()));
});
}
public void TasksRunOneAtATime()
{
SerialQueue queue = new SerialQueue(new ManagedThreadPoolDispatcher());
bool taskRunning = false;
for (int i = 0; i < 10; ++i)
{
queue.DispatchAsync(null, (_) =>
{
Assert.IsFalse(taskRunning);
taskRunning = true;
Thread.Sleep(TimeSpan.FromMilliseconds(30));
Assert.IsTrue(taskRunning);
taskRunning = false;
});
}
queue.DispatchSync(null, (_) =>
{
// just to ensure that the tests don't finish prematurely.
});
}
public void MultipleDispatchAsyncCallsGetProcessedByOneWorker()
{
var q = new SerialQueue(mockPool);
var hit = new List <int>();
q.DispatchAsync(() => {
hit.Add(1);
});
q.DispatchAsync(() => {
hit.Add(2);
});
CollectionAssert.AreEqual(new int[0], hit);
mockPool.RunNextAction();
CollectionAssert.AreEqual(new[] { 1, 2 }, hit);
Assert.AreEqual(0, mockPool.Actions.Count);
}
// Normal closure (requested by client)
public unsafe void CloseSocket()
{
// Wait my turn!
_queue.DispatchAsync(() =>
{
ResetConnections();
_c4Queue.DispatchAsync(() =>
{
if (_closed)
{
WriteLog.To.Sync.W(Tag, "Double close detected, ignoring...");
return;
}
WriteLog.To.Sync.I(Tag, "Closing socket normally due to request from LiteCore");
ReleaseSocket(new C4Error(0, 0));
});
});
}
public void CantCallDispatchAsyncOnDisposedQueue()
{
var sq = new SerialQueue(invalidPool);
sq.Dispose();
var hit = new List <int>();
AssertEx.Throws <ObjectDisposedException>(() => {
sq.DispatchAsync(() => hit.Add(1));
});
}
public void AsyncRunsOnSeparateThreads()
{
SerialQueue queue = new SerialQueue(new ManagedThreadPoolDispatcher());
int threadId = Thread.CurrentThread.ManagedThreadId;
for (int i = 0; i < 10; ++i)
{
queue.DispatchAsync(null, (_) =>
{
Assert.AreNotEqual(threadId, Thread.CurrentThread.ManagedThreadId);
});
}
}
private void ReachabilityChanged(object sender, NetworkReachabilityChangeEventArgs e)
{
Debug.Assert(e != null);
_threadSafetyQueue.DispatchAsync(() =>
{
if (_repl == null && e.Status == NetworkReachabilityStatus.Reachable)
{
Log.To.Sync.I(Tag, $"{this}: Server may now be reachable; retrying...");
_retryCount = 0;
Retry();
}
});
}
public void DispatchAsyncCanBeCanceled()
{
var q = new SerialQueue(mockPool);
var hit = new List <int>();
var d = q.DispatchAsync(() => hit.Add(1));
Assert.AreEqual(1, mockPool.Actions.Count);
d.Dispose();
Assert.AreEqual(1, mockPool.Actions.Count); // we can't "take it out" of the threadpool as not all threadpools support that
mockPool.RunNextAction();
CollectionAssert.AreEqual(new int[0], hit); // lambda didn't run
Assert.AreEqual(0, mockPool.Actions.Count);
}
public void DispatchAsyncQueuesToThreadpool()
{
var q = new SerialQueue(mockPool);
var hit = new List <int>();
q.DispatchAsync(() => {
hit.Add(1);
});
CollectionAssert.AreEqual(new int[0], hit);
mockPool.RunNextAction();
CollectionAssert.AreEqual(new[] { 1 }, hit);
Assert.AreEqual(0, mockPool.Actions.Count);
}
public void NestedDispatchSyncInsideDispatchAsyncDoesntDeadlock()
{
var q = new SerialQueue(new TaskThreadPool());
var hit = new List <int>();
var mre = new ManualResetEvent(false);
q.DispatchAsync(() => {
hit.Add(1);
q.DispatchSync(() => {
hit.Add(2);
});
hit.Add(3);
mre.Set();
});
mre.WaitOne();
CollectionAssert.AreEqual(new[] { 1, 2, 3 }, hit);
}
public void DispatchAsyncCanBeSafelyCanceledAfterItsRun()
{
var q = new SerialQueue(mockPool);
var hit = new List <int>();
var d = q.DispatchAsync(() => hit.Add(1));
mockPool.RunNextAction();
CollectionAssert.AreEqual(new int[] { 1 }, hit);
Assert.AreEqual(0, mockPool.Actions.Count);
d.Dispose();
CollectionAssert.AreEqual(new int[] { 1 }, hit); // lambda didn't run
Assert.AreEqual(0, mockPool.Actions.Count);
}
public void DispatchSyncConcurrentWithAnotherDispatchAsyncWorksProperly()
{
var q = new SerialQueue(new TaskThreadPool());
var hit = new List <int>();
var are = new AutoResetEvent(false);
q.DispatchAsync(() => {
hit.Add(1);
are.Set();
Thread.Sleep(100); // we can't block on an event as that would deadlock, we just have to slow it down enough to force the DispatchSync to wait
hit.Add(2);
});
are.WaitOne();
q.DispatchSync(() => {
hit.Add(3);
});
CollectionAssert.AreEqual(new[] { 1, 2, 3 }, hit);
}
public void TasksCompletedInProperSequence()
{
int numberTest = 0;
SerialQueue queue = new SerialQueue(new ManagedThreadPoolDispatcher());
for (int i = 0; i < 100; ++i)
{
int localValue = i;
queue.DispatchAsync(null, (_) =>
{
Assert.AreEqual(numberTest++, localValue);
});
}
queue.DispatchSync(null, (_) =>
{
Assert.AreEqual(numberTest, 100);
});
}
protected override void QueueTask(Task task)
{
_queue.DispatchAsync(() => TryExecuteTask(task));
}