Moved all UnitTests to a single project. Implemented parts of AspNetCore UnitTests.

UnitTests/Common/Utilities/DelayedTaskTests.cs

@@ -0,0 +1,288 @@
+using System;
+using System.Diagnostics;
+using System.Threading;
+using System.Threading.Tasks;
+using AMWD.Common.Utilities;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace UnitTests.Common.Utilities
+{
+	[TestClass]
+	[System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+	public class DelayedTaskTests
+	{
+		[TestMethod]
+		public void ShouldCreateNewDelayedTaskNotStarting()
+		{
+			// arrange
+			int executionCount = 0;
+			var delay = TimeSpan.FromMilliseconds(100);
+			var action = () => { executionCount++; };
+
+			// act
+			var cts = new CancellationTokenSource(delay.Add(TimeSpan.FromSeconds(1)));
+			var delayedTask = DelayedTask.Create(action, delay);
+			SpinWait.SpinUntil(() => executionCount > 0 || cts.IsCancellationRequested);
+
+			// assert
+			Assert.IsNotNull(delayedTask);
+			Assert.AreEqual(delay, delayedTask.Delay);
+			Assert.IsFalse(delayedTask.IsRunning);
+			Assert.IsFalse(delayedTask.IsWaitingToRun);
+			Assert.IsNull(delayedTask.Exception);
+			Assert.AreEqual(0, executionCount);
+		}
+
+		[TestMethod]
+		public void ShouldCreateNewDelayedTaskStarting()
+		{
+			// arrange
+			int executionCount = 0;
+			var delay = TimeSpan.FromMilliseconds(100);
+			var action = () => { executionCount++; };
+
+			// act
+			var cts = new CancellationTokenSource(delay.Add(TimeSpan.FromSeconds(1)));
+			var delayedTask = DelayedTask.Run(action, delay);
+			SpinWait.SpinUntil(() => executionCount > 0 || cts.IsCancellationRequested);
+
+			// assert
+			Assert.IsNotNull(delayedTask);
+			Assert.AreEqual(delay, delayedTask.Delay);
+			Assert.IsFalse(delayedTask.IsRunning);
+			Assert.IsFalse(delayedTask.IsWaitingToRun);
+			Assert.IsNull(delayedTask.Exception);
+			Assert.AreEqual(1, executionCount);
+		}
+
+		[TestMethod]
+		public void ShouldRunOnceAfterReset()
+		{
+			// arrange
+			int executionCount = 0;
+			var delay = TimeSpan.FromMilliseconds(100);
+			var action = () => { executionCount++; };
+
+			// act
+			var cts = new CancellationTokenSource(delay.Add(TimeSpan.FromSeconds(1)));
+			var delayedTask = DelayedTask.Create(action, delay);
+			delayedTask.Reset();
+			SpinWait.SpinUntil(() => executionCount > 0 || cts.IsCancellationRequested);
+
+			// assert
+			Assert.IsNotNull(delayedTask);
+			Assert.AreEqual(delay, delayedTask.Delay);
+			Assert.IsFalse(delayedTask.IsRunning);
+			Assert.IsFalse(delayedTask.IsWaitingToRun);
+			Assert.IsNull(delayedTask.Exception);
+			Assert.AreEqual(1, executionCount);
+		}
+
+		[TestMethod]
+		public void ShouldCancelWaitingTask()
+		{
+			// arrange
+			int executionCount = 0;
+			var delay = TimeSpan.FromMilliseconds(100);
+			var action = () => { executionCount++; };
+
+			// act
+			var cts = new CancellationTokenSource(delay.Add(TimeSpan.FromSeconds(1)));
+			var delayedTask = DelayedTask.Run(action, delay);
+			delayedTask.Cancel();
+			SpinWait.SpinUntil(() => executionCount > 0 || cts.IsCancellationRequested);
+
+			// assert
+			Assert.IsNotNull(delayedTask);
+			Assert.AreEqual(delay, delayedTask.Delay);
+			Assert.IsFalse(delayedTask.IsRunning);
+			Assert.IsFalse(delayedTask.IsWaitingToRun);
+			Assert.IsNull(delayedTask.Exception);
+			Assert.AreEqual(0, executionCount);
+		}
+
+		[TestMethod]
+		public async Task ShouldResetRunningDelay()
+		{
+			// arrange
+			int executionCount = 0;
+			var sw = new Stopwatch();
+
+			var delay = TimeSpan.FromMilliseconds(200);
+			var action = () => { sw.Stop(); executionCount++; };
+
+			// act
+			var cts = new CancellationTokenSource(delay.Add(TimeSpan.FromSeconds(1)));
+			sw.Start();
+			var delayedTask = DelayedTask.Run(action, delay);
+			await Task.Delay(50);
+			delayedTask.Reset();
+			SpinWait.SpinUntil(() => executionCount > 0 || cts.IsCancellationRequested);
+
+			// assert
+			Assert.IsNotNull(delayedTask);
+			Assert.AreEqual(delay, delayedTask.Delay);
+			Assert.IsFalse(delayedTask.IsRunning);
+			Assert.IsFalse(delayedTask.IsWaitingToRun);
+			Assert.IsNull(delayedTask.Exception);
+			Assert.AreEqual(1, executionCount);
+			// delta of 60ms as the precision below 50ms is really bad for System.Timer
+			Assert.AreEqual(250, sw.ElapsedMilliseconds, 60);
+		}
+
+		[TestMethod]
+		public async Task ShouldNotExecutedImmediateOnCreated()
+		{
+			// arrange
+			int executionCount = 0;
+			var sw = new Stopwatch();
+
+			var delay = TimeSpan.FromMilliseconds(200);
+			var action = () => { sw.Stop(); executionCount++; };
+
+			// act
+			var cts = new CancellationTokenSource(delay.Add(TimeSpan.FromSeconds(1)));
+			sw.Start();
+			var delayedTask = DelayedTask.Create(action, delay);
+			await Task.Delay(50);
+			bool isSuccess = delayedTask.ExecutePending();
+			SpinWait.SpinUntil(() => executionCount > 0 || cts.IsCancellationRequested);
+			sw.Stop();
+
+			// assert
+			Assert.IsNotNull(delayedTask);
+			Assert.AreEqual(delay, delayedTask.Delay);
+			Assert.IsFalse(delayedTask.IsRunning);
+			Assert.IsFalse(delayedTask.IsWaitingToRun);
+			Assert.IsNull(delayedTask.Exception);
+			Assert.AreEqual(0, executionCount);
+			// delta of 60ms as the precision below 50ms is really bad for System.Timer
+			Assert.AreEqual(1250, sw.ElapsedMilliseconds, 60);
+			Assert.IsFalse(isSuccess);
+		}
+
+		[TestMethod]
+		public async Task ShouldExecuteImmediateOnExecutePendingWhenRunning()
+		{
+			// arrange
+			int executionCount = 0;
+			var sw = new Stopwatch();
+
+			var delay = TimeSpan.FromMilliseconds(200);
+			var action = () => { sw.Stop(); executionCount++; };
+
+			// act
+			var cts = new CancellationTokenSource(delay.Add(TimeSpan.FromSeconds(1)));
+			sw.Start();
+			var delayedTask = DelayedTask.Run(action, delay);
+			await Task.Delay(50);
+			bool isSuccess = delayedTask.ExecutePending();
+			SpinWait.SpinUntil(() => executionCount > 0 || cts.IsCancellationRequested);
+
+			// assert
+			Assert.IsNotNull(delayedTask);
+			Assert.AreEqual(delay, delayedTask.Delay);
+			Assert.IsFalse(delayedTask.IsRunning);
+			Assert.IsFalse(delayedTask.IsWaitingToRun);
+			Assert.IsNull(delayedTask.Exception);
+			Assert.AreEqual(1, executionCount);
+			// delta of 60ms as the precision below 50ms is really bad for System.Timer
+			Assert.AreEqual(50, sw.ElapsedMilliseconds, 60);
+			Assert.IsTrue(isSuccess);
+		}
+
+		[TestMethod]
+		public void ShouldReturnAnAwaiter()
+		{
+			// arrange
+			int executionCount = 0;
+			var delay = TimeSpan.FromMilliseconds(100);
+			var action = () => { executionCount++; };
+			var delayedTask = DelayedTask.Create(action, delay);
+
+			// act
+			delayedTask.Reset();
+			var awaiter = delayedTask.GetAwaiter();
+			SpinWait.SpinUntil(() => awaiter.IsCompleted);
+
+			// assert
+			Assert.IsNotNull(delayedTask);
+			Assert.IsNotNull(awaiter);
+			Assert.IsFalse(delayedTask.IsRunning);
+			Assert.IsFalse(delayedTask.IsWaitingToRun);
+			Assert.IsNull(delayedTask.Exception);
+			Assert.AreEqual(1, executionCount);
+		}
+
+		[TestMethod]
+		public void ShouldHaveAnExceptionSet()
+		{
+			// arrange
+			var delay = TimeSpan.FromMilliseconds(100);
+			var action = () => { throw new Exception("TEST :D"); };
+
+			// act
+			var delayedTask = DelayedTask.Run(action, delay);
+
+			var awaiter = delayedTask.GetAwaiter();
+			SpinWait.SpinUntil(() => awaiter.IsCompleted);
+
+			// assert
+			Assert.IsNotNull(delayedTask);
+			Assert.IsFalse(delayedTask.IsRunning);
+			Assert.IsFalse(delayedTask.IsWaitingToRun);
+			Assert.IsNotNull(delayedTask.Exception);
+		}
+
+		[TestMethod]
+		public void ShouldUseExceptionHandler()
+		{
+			// arrange
+			string exceptionText = null;
+			var delay = TimeSpan.FromMilliseconds(100);
+			var action = () => { throw new Exception("TEST :D"); };
+			var exceptionHandler = (Exception ex) =>
+			{
+				exceptionText = ex.Message;
+			};
+
+			// act
+			var delayedTask = DelayedTask.Run(action, delay)
+				.WithExceptionHandler(exceptionHandler);
+
+			var awaiter = delayedTask.GetAwaiter();
+			SpinWait.SpinUntil(() => awaiter.IsCompleted);
+
+			// assert
+			Assert.IsNotNull(delayedTask);
+			Assert.IsFalse(delayedTask.IsRunning);
+			Assert.IsFalse(delayedTask.IsWaitingToRun);
+			Assert.IsNotNull(delayedTask.Exception);
+			Assert.AreEqual("TEST :D", exceptionText);
+		}
+
+		[TestMethod]
+		public async Task ShouldReturnNormalTask()
+		{
+			// arrange
+			int executionCount = 0;
+			var delay = TimeSpan.FromMilliseconds(100);
+			var action = () => { executionCount++; };
+			var delayedTask = DelayedTask.Create(action, delay);
+
+			// act
+			delayedTask.Reset();
+			var task = delayedTask.Task;
+			await task;
+
+			// assert
+			Assert.IsNotNull(delayedTask);
+			Assert.IsNotNull(task);
+			Assert.IsInstanceOfType(task, typeof(Task));
+			Assert.IsFalse(delayedTask.IsRunning);
+			Assert.IsFalse(delayedTask.IsWaitingToRun);
+			Assert.AreEqual(1, executionCount);
+			Assert.AreEqual(TaskStatus.RanToCompletion, task.Status);
+		}
+	}
+}