Unit-Test erweitert, NetRevisionTask aktualisiert, ExceptionTests hinzugefügt...

AMWD.Common.Tests/Extensions/ReaderWriterLockSlimExtensionsTests.cs

@@ -1,9 +1,12 @@
+using System;
 using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace AMWD.Common.Tests.Extensions
 {
 	[TestClass]
+	[System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
 	public class ReaderWriterLockSlimExtensionsTests
 	{
 		[TestMethod]
@@ -38,6 +41,39 @@ namespace AMWD.Common.Tests.Extensions
 			Assert.IsFalse(rwLock.IsWriteLockHeld);
 		}
 
+		[TestMethod]
+		public void ShouldAllowWriteLockAfterUpgradableReadLock()
+		{
+			// arrange
+			var rwLockUsing = new ReaderWriterLockSlim();
+			var rwLockClassic = new ReaderWriterLockSlim();
+
+			// act
+			using var disposableReadUsing = rwLockUsing.GetUpgradeableReadLock();
+			using (rwLockUsing.GetWriteLock())
+			{
+				// assert
+				Assert.IsTrue(rwLockUsing.IsUpgradeableReadLockHeld);
+				Assert.IsTrue(rwLockUsing.IsWriteLockHeld);
+			}
+			// assert
+			Assert.IsTrue(rwLockUsing.IsUpgradeableReadLockHeld);
+			Assert.IsFalse(rwLockUsing.IsWriteLockHeld);
+
+			// act
+			using (rwLockClassic.GetUpgradeableReadLock())
+			{
+				rwLockClassic.EnterWriteLock();
+
+				// assert
+				Assert.IsTrue(rwLockClassic.IsUpgradeableReadLockHeld);
+				Assert.IsTrue(rwLockClassic.IsWriteLockHeld);
+			}
+			// assert
+			Assert.IsFalse(rwLockClassic.IsUpgradeableReadLockHeld);
+			Assert.IsFalse(rwLockClassic.IsWriteLockHeld);
+		}
+
 		[TestMethod]
 		public void ShouldEnterWriteLock()
 		{
@@ -85,14 +121,101 @@ namespace AMWD.Common.Tests.Extensions
 
 			// act
 			using var disposableRead = rwLock.GetUpgradeableReadLock();
-			using var disposaleWrite = rwLock.GetWriteLock();
+			using var disposableWrite = rwLock.GetWriteLock();
 
 			// assert
 			Assert.IsNotNull(disposableRead);
-			Assert.IsNotNull(disposaleWrite);
+			Assert.IsNotNull(disposableWrite);
 			Assert.IsFalse(rwLock.IsReadLockHeld);
 			Assert.IsTrue(rwLock.IsUpgradeableReadLockHeld);
 			Assert.IsTrue(rwLock.IsWriteLockHeld);
 		}
+
+		[TestMethod]
+		public void ShouldGetTimeoutOnReadLock()
+		{
+			// arrange
+			var rwLock = new ReaderWriterLockSlim();
+			bool isTimeout = false;
+
+			// act
+			using var disposableRead = rwLock.GetWriteLock();
+			var awaitableTask = Task.Run(() =>
+			{
+				try
+				{
+					using var disposableRead = rwLock.GetReadLock(10);
+					Assert.Fail();
+				}
+				catch (TimeoutException)
+				{
+					isTimeout = true;
+				}
+				catch (Exception)
+				{ /* keep it quiet */ }
+			});
+			Task.WaitAll(awaitableTask);
+
+			// assert
+			Assert.IsTrue(isTimeout);
+		}
+
+		[TestMethod]
+		public void ShouldGetTimeoutOnUpgradeableReadLock()
+		{
+			// arrange
+			var rwLock = new ReaderWriterLockSlim();
+			bool isTimeout = false;
+
+			// act
+			using var disposableRead = rwLock.GetWriteLock();
+			var awaitableTask = Task.Run(() =>
+			{
+				try
+				{
+					using var disposableRead = rwLock.GetUpgradeableReadLock(10);
+					Assert.Fail();
+				}
+				catch (TimeoutException)
+				{
+					isTimeout = true;
+				}
+				catch (Exception)
+				{ /* keep it quiet */ }
+			});
+			Task.WaitAll(awaitableTask);
+
+			// assert
+			Assert.IsTrue(isTimeout);
+		}
+
+		[TestMethod]
+		public void ShouldGetTimeoutOnWriteLock()
+		{
+			// arrange
+			var rwLock = new ReaderWriterLockSlim();
+			bool isTimeout = false;
+
+			// act
+			using var disposableRead = rwLock.GetReadLock();
+			var awaitableTask = Task.Run(() =>
+			{
+				try
+				{
+					using var disposableRead = rwLock.GetWriteLock(10);
+					Assert.Fail();
+				}
+				catch (TimeoutException)
+				{
+					isTimeout = true;
+				}
+				catch (Exception)
+				{ /* keep it quiet */ }
+			});
+			Task.WaitAll(awaitableTask);
+
+			// assert
+			Assert.IsTrue(isTimeout);
+		}
 	}
 }