Added HtmlHelper.IsDarkColor and enhanced UnitTests

AMWD.Common.Tests/Utilities/DelayedTaskTests.cs

@@ -1,8 +1,8 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+using System.Diagnostics;
+using System.Threading;
 using System.Threading.Tasks;
+using AMWD.Common.Utilities;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace AMWD.Common.Tests.Utilities
@@ -11,6 +11,278 @@ namespace AMWD.Common.Tests.Utilities
 	[System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
 	public class DelayedTaskTests
 	{
-		// TODO
+		[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 50ms as the precision below 50ms is really bad for System.Timer
+			Assert.AreEqual(250, sw.ElapsedMilliseconds, 50);
+		}
+
+		[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 50ms as the precision below 50ms is really bad for System.Timer
+			Assert.AreEqual(1250, sw.ElapsedMilliseconds, 50);
+			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 50ms as the precision below 50ms is really bad for System.Timer
+			Assert.AreEqual(50, sw.ElapsedMilliseconds, 50);
+			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);
+		}
 	}
 }