Merge branch 'master' of https://github.com/rsdn/CodeJam

Author: andrewvk

Main/src/Threading/AsyncLock.cs

@@ -25,11 +25,15 @@ public class AsyncLock
 		/// </param>
 		/// <param name="cancellation">The CancellationToken token to observe.</param>
 		/// <returns>A task that returns <see cref="IDisposable"/> to release the lock.</returns>
-		[NotNull]
-		[ItemNotNull]
-		public async Task<IDisposable> Acquire(TimeSpan timeout, CancellationToken cancellation)
+		[NotNull, ItemNotNull]
+		public async Task<IDisposable> AcquireAsync(TimeSpan timeout, CancellationToken cancellation)
 		{
-			await _semaphore.WaitAsync(timeout, cancellation);
+			var succeed = await _semaphore.WaitAsync(timeout, cancellation);
+			if (!succeed)
+			{
+				cancellation.ThrowIfCancellationRequested();
+				throw new TimeoutException($"Attempt to take lock timed out in {timeout}.");
+			}
 			return Disposable.Create(() => _semaphore.Release());
 		}
 
@@ -42,10 +46,9 @@ public async Task<IDisposable> Acquire(TimeSpan timeout, CancellationToken cance
 		/// </param>
 		/// <param name="cancellation">The CancellationToken token to observe.</param>
 		/// <returns>A task that returns <see cref="IDisposable"/> to release the lock.</returns>
-		[NotNull]
-		[ItemNotNull]
-		public Task<IDisposable> Acquire(int timeout, CancellationToken cancellation) =>
-			Acquire(TimeSpan.FromMilliseconds(timeout), cancellation);
+		[NotNull, ItemNotNull]
+		public Task<IDisposable> AcquireAsync(int timeout, CancellationToken cancellation) =>
+			AcquireAsync(TimeSpan.FromMilliseconds(timeout), cancellation);
 
 		/// <summary>
 		/// Acquires async lock.
@@ -55,9 +58,8 @@ public Task<IDisposable> Acquire(int timeout, CancellationToken cancellation) =>
 		/// indefinitely, or a 0 to return immediately.
 		/// </param>
 		/// <returns>A task that returns <see cref="IDisposable"/> to release the lock.</returns>
-		[NotNull]
-		[ItemNotNull]
-		public Task<IDisposable> Acquire(int timeout) => Acquire(TimeSpan.FromMilliseconds(timeout), CancellationToken.None);
+		[NotNull, ItemNotNull]
+		public Task<IDisposable> AcquireAsync(int timeout) => AcquireAsync(TimeSpan.FromMilliseconds(timeout), CancellationToken.None);
 
 		/// <summary>
 		/// Acquires async lock.
@@ -68,26 +70,23 @@ public Task<IDisposable> Acquire(int timeout, CancellationToken cancellation) =>
 		/// to return immediately.
 		/// </param>
 		/// <returns>A task that returns <see cref="IDisposable"/> to release the lock.</returns>
-		[NotNull]
-		[ItemNotNull]
-		public Task<IDisposable> Acquire(TimeSpan timeout) => Acquire(timeout, CancellationToken.None);
+		[NotNull, ItemNotNull]
+		public Task<IDisposable> AcquireAsync(TimeSpan timeout) => AcquireAsync(timeout, CancellationToken.None);
 
 		/// <summary>
 		/// Acquires async lock.
 		/// </summary>
 		/// <param name="cancellation">The CancellationToken token to observe.</param>
 		/// <returns>A task that returns <see cref="IDisposable"/> to release the lock.</returns>
-		[NotNull]
-		[ItemNotNull]
-		public Task<IDisposable> Acquire(CancellationToken cancellation) => Acquire(-1, cancellation);
+		[NotNull, ItemNotNull]
+		public Task<IDisposable> AcquireAsync(CancellationToken cancellation) => AcquireAsync(-1, cancellation);
 
 		/// <summary>
 		/// Acquires async lock.
 		/// </summary>
 		/// <returns>A task that returns <see cref="IDisposable"/> to release the lock.</returns>
-		[NotNull]
-		[ItemNotNull]
-		public Task<IDisposable> Acquire() => Acquire(-1);
+		[NotNull, ItemNotNull]
+		public Task<IDisposable> AcquireAsync() => AcquireAsync(-1);
 	}
 }
 #endif

Main/tests/Threading/AsyncLockTest.cs

@@ -12,18 +12,77 @@ namespace CodeJam.Threading
 	[TestFixture]
 	public class AsyncLockTest
 	{
+		private static async Task<bool> TryTakeAndHold(
+			AsyncLock asyncLock, TimeSpan holdTime, CancellationToken cancellation = default(CancellationToken), Action callback = null)
+		{
+			try
+			{
+				using (await asyncLock.AcquireAsync(holdTime, cancellation))
+				{
+					callback?.Invoke();
+					await Task.Delay(holdTime);
+				}
+				return true;
+			}
+			catch (OperationCanceledException)
+			{
+				return false;
+			}
+			catch (TimeoutException)
+			{
+				return false;
+			}
+		}
+
+		[Test]
+		[SuppressMessage("ReSharper", "MethodSupportsCancellation")]
+		public async Task LockCancellationTest()
+		{
+			var asyncLock = new AsyncLock();
+			var holdTime = TimeSpan.FromSeconds(8);
+			var delayTime = TimeSpan.FromMilliseconds(200);
+
+			var lock1Started = new ManualResetEventSlim(false);
+
+			var lock1 = TryTakeAndHold(asyncLock, holdTime, callback: () => lock1Started.Set());
+			lock1Started.Wait();
+
+			var cts2 = new CancellationTokenSource();
+			var sw2 = Stopwatch.StartNew();
+			var lock2 = TryTakeAndHold(asyncLock, holdTime, cts2.Token);
+			await Task.Delay(delayTime);
+			cts2.Cancel();
+			var lock2Taken = await lock2;
+			sw2.Stop();
+
+			var sw3 = Stopwatch.StartNew();
+			var lock3 = TryTakeAndHold(asyncLock, delayTime);
+			await Task.Delay(delayTime);
+			var lock3Taken = await lock3;
+			sw3.Stop();
+
+			var lock1Taken = await lock1;
+
+			Assert.IsTrue(lock1Taken);
+			Assert.IsFalse(lock2Taken);
+			Assert.Less(sw2.Elapsed, holdTime - delayTime);
+			Assert.IsFalse(lock3Taken);
+			Assert.Less(sw3.Elapsed, holdTime - delayTime);
+		}
+
 		[Test]
 		public async Task LockTest()
 		{
 			var asyncLock = new AsyncLock();
+
 			var opActive = false;
 			const int time = 200;
 			const int timeInc = 10;
 			const int count = 10;
 
 			async Task Op(int num)
 			{
-				using (await asyncLock.Acquire())
+				using (await asyncLock.AcquireAsync())
 				{
 					Assert.IsFalse(opActive);
 					opActive = true;
@@ -42,36 +101,5 @@ await Enumerable
 			Assert.IsFalse(opActive);
 			Assert.GreaterOrEqual(sw.ElapsedMilliseconds, time * count + timeInc * count / 2);
 		}
-
-		[Test]
-		[SuppressMessage("ReSharper", "MethodSupportsCancellation")]
-		public async Task Cancellation()
-		{
-			var cts = new CancellationTokenSource();
-			var lck = new AsyncLock();
-			const int delay = 5000;
-			const int ensureLockInterval = 30;
-			Task.Run(
-				async () =>
-				{
-					using (await lck.Acquire())
-						await Task.Delay(delay);
-				});
-			await Task.Delay(ensureLockInterval);
-			var sw = Stopwatch.StartNew();
-			var task = Task.Run(
-				async () =>
-				{
-					using (await lck.Acquire(cts.Token))
-						sw.Stop();
-				});
-			cts.Cancel();
-			try
-			{
-				await task;
-			}
-			catch (TaskCanceledException) {}
-			Assert.Less(sw.ElapsedMilliseconds, delay - ensureLockInterval);
-		}
 	}
 }