public void SerializedActionQueue_Limit() { // Verify that the queue throws an [InvalidOperationException] if the number of items in // the queue are exceeded. I'm going to do this by queuing a relatively long-running action // and then quickly submitting four more actions where the last one should exceed the limit // of three actions I'm going to set for the queue. var queue = new SerializedActionQueue(3); var done = false; var task1 = false; try { queue.EnqueueAction(() => { task1 = true; Thread.Sleep(TimeSpan.FromSeconds(1)); done = true; }); Helper.WaitFor(() => task1, TimeSpan.FromSeconds(1)); queue.EnqueueAction(() => Thread.Sleep(0)); queue.EnqueueAction(() => Thread.Sleep(0)); queue.EnqueueAction(() => Thread.Sleep(0)); ExtendedAssert.Throws <InvalidOperationException>(() => queue.EnqueueAction(() => Thread.Sleep(0))); Helper.WaitFor(() => done, TimeSpan.FromSeconds(5)); } finally { queue.Clear(); } }
public void SerializedActionQueue_Param4() { // Verify that a one parameter action gets invoked properly. var queue = new SerializedActionQueue(); var value1 = (string)null; var value2 = (string)null; var value3 = (string)null; var value4 = 0; try { queue.EnqueueAction <string, string, string, int>("p1", "p2", "p3", 4, (p1, p2, p3, p4) => { value1 = p1; value2 = p2; value3 = p3; value4 = p4; }); Helper.WaitFor(() => value1 != null, TimeSpan.FromSeconds(1)); Assert.AreEqual("p1", value1); Assert.AreEqual("p2", value2); Assert.AreEqual("p3", value3); Assert.AreEqual(4, value4); } finally { queue.Clear(); } }
public void SerializedActionQueue_QueueWhileIdle() { // Verify that actions queued while the queue is idle get executed. var queue = new SerializedActionQueue(); var done = false; try { for (int i = 0; i < 100; i++) { done = false; queue.EnqueueAction(() => { done = true; }); Helper.WaitFor(() => done, TimeSpan.FromSeconds(1)); } } finally { queue.Clear(); } }
public void SerializedActionQueue_QueueWhileProcessing() { // Verify that the actions queued while the queue is processing another // action eventually get executed as well. var queue = new SerializedActionQueue(); var task1 = false; var task2 = false; var task3 = false; var task4 = false; try { queue.EnqueueAction(() => { task1 = true; Thread.Sleep(TimeSpan.FromSeconds(1)); }); Helper.WaitFor(() => task1, TimeSpan.FromSeconds(1)); queue.EnqueueAction(() => task2 = true); queue.EnqueueAction(() => task3 = true); queue.EnqueueAction(() => task4 = true); Helper.WaitFor(() => task1 && task2 && task3 && task4, TimeSpan.FromSeconds(5)); } finally { queue.Clear(); } }
public void SerializedActionQueue_Shutdown() { // Verify that ShutDown() actually clears pending actions and also // disables queuing and execution of future actions. var queue = new SerializedActionQueue(); var task0 = false; var task1 = false; var task2 = false; var task3 = false; var task4 = false; var done = false; try { // Verify that pending actions are cleared. queue.EnqueueAction(() => { task1 = true; Thread.Sleep(TimeSpan.FromSeconds(2)); done = true; }); queue.EnqueueAction(() => task2 = true); queue.EnqueueAction(() => task3 = true); queue.EnqueueAction(() => task4 = true); Helper.WaitFor(() => task1, TimeSpan.FromSeconds(1)); queue.Shutdown(); Helper.WaitFor(() => done, TimeSpan.FromSeconds(5)); Assert.IsFalse(task2); Assert.IsFalse(task3); Assert.IsFalse(task4); // Verify the new actions are ignored. task1 = task2 = task3 = task4 = false; queue.EnqueueAction(() => task0 = true); queue.EnqueueAction <int>(1, (p1) => task1 = true); queue.EnqueueAction <int, int>(1, 2, (p1, p2) => task2 = true); queue.EnqueueAction <int, int, int>(1, 2, 3, (p1, p2, p3) => task3 = true); queue.EnqueueAction <int, int, int, int>(1, 2, 3, 4, (p1, p2, p3, p4) => task4 = true); Thread.Sleep(TimeSpan.FromSeconds(2)); Assert.IsFalse(task0 || task1 || task2 || task3 || task4); } finally { queue.Clear(); } }
public void SerializedActionQueue_Clear() { // Verify that Clear() actually works. I'm going to do this by queuing a relatively long-running action // and then quickly submitting three more actions. Each action will set a boolean if it executes. // I'm going to wait for an indication that the first action begun executing and then clear the // queue and verify that the remaining actions did not execute.k var queue = new SerializedActionQueue(); var task1 = false; var task2 = false; var task3 = false; var task4 = false; var done = false; try { queue.EnqueueAction(() => { task1 = true; Thread.Sleep(TimeSpan.FromSeconds(2)); done = true; }); queue.EnqueueAction(() => task2 = true); queue.EnqueueAction(() => task3 = true); queue.EnqueueAction(() => task4 = true); Helper.WaitFor(() => task1, TimeSpan.FromSeconds(1)); queue.Clear(); Helper.WaitFor(() => done, TimeSpan.FromSeconds(5)); Assert.IsFalse(task2); Assert.IsFalse(task3); Assert.IsFalse(task4); } finally { queue.Clear(); } }
public void SerializedActionQueue_ExecuteInOrder() { // Make sure that actions submitted to a SerializedActionQueue are executed in order. var queue = new SerializedActionQueue(); try { int count = 0; int action1Count = -1; int action2Count = -1; int action3Count = -1; int action4Count = -1; queue.EnqueueAction(() => { Interlocked.Increment(ref count); action1Count = count; }); queue.EnqueueAction(() => { Thread.Sleep(1000); Interlocked.Increment(ref count); action2Count = count; }); queue.EnqueueAction(() => { Interlocked.Increment(ref count); Thread.Sleep(1000); action3Count = count; Thread.Sleep(1000); }); queue.EnqueueAction(() => { Interlocked.Increment(ref count); action4Count = count; Thread.Sleep(1000); }); Helper.WaitFor(() => action1Count != -1 && action2Count != -1 && action3Count != -1 && action4Count != -1, TimeSpan.FromMilliseconds(5000)); Assert.AreEqual(1, action1Count); Assert.AreEqual(2, action2Count); Assert.AreEqual(3, action3Count); Assert.AreEqual(4, action4Count); } finally { queue.Clear(); } }
public void SerializedActionQueue_Param1() { // Verify that a one parameter action gets invoked properly. var queue = new SerializedActionQueue(); var value1 = (string)null; try { queue.EnqueueAction <string>("p1", (p1) => { value1 = p1; }); Helper.WaitFor(() => value1 != null, TimeSpan.FromSeconds(1)); Assert.AreEqual("p1", value1); } finally { queue.Clear(); } }