test: add rollback limit test for AdaptiveSemaphore on cancellation

Author: jamesmcroft

src/MADE.Threading/AdaptiveSemaphore.cs

@@ -20,7 +20,7 @@ namespace MADE.Threading;
 /// }
 ///
 /// // Reduce concurrency on backpressure.
-/// semaphore.TryShrink();
+/// await semaphore.TryShrinkAsync();
 /// </code>
 /// </remarks>
 public sealed class AdaptiveSemaphore : IDisposable
@@ -96,7 +96,20 @@ public async Task<int> TryShrinkAsync(CancellationToken cancellationToken = defa
             this.limit--;
         }
 
-        await this.semaphore.WaitAsync(cancellationToken).ConfigureAwait(false);
+        try
+        {
+            await this.semaphore.WaitAsync(cancellationToken).ConfigureAwait(false);
+        }
+        catch
+        {
+            lock (this.adjustLock)
+            {
+                this.limit++;
+            }
+
+            throw;
+        }
+
         return this.limit;
     }
 
@@ -122,7 +135,17 @@ public int TryGrow()
             }
 
             this.limit++;
-            this.semaphore.Release();
+
+            try
+            {
+                this.semaphore.Release();
+            }
+            catch
+            {
+                this.limit--;
+                throw;
+            }
+
             return this.limit;
         }
     }
@@ -156,13 +179,16 @@ public IDisposable Wait(CancellationToken cancellationToken = default)
     /// <inheritdoc />
     public void Dispose()
     {
-        if (this.disposed)
+        lock (this.adjustLock)
         {
-            return;
-        }
+            if (this.disposed)
+            {
+                return;
+            }
 
-        this.semaphore.Dispose();
-        this.disposed = true;
+            this.semaphore.Dispose();
+            this.disposed = true;
+        }
     }
 
     private sealed class SemaphoreReleaser : IDisposable

tests/MADE.Threading.Tests/Tests/AdaptiveSemaphoreTests.cs

@@ -151,6 +151,28 @@ public async Task ShouldReduceAvailablePermits()
             semaphore.Limit.ShouldBe(1);
             semaphore.Available.ShouldBe(1);
         }
+
+        [Test]
+        public async Task ShouldRollBackLimitWhenCancelled()
+        {
+            // Arrange
+            using var semaphore = new AdaptiveSemaphore(initial: 1, minimum: 1, maximum: 2);
+            semaphore.TryGrow(); // limit = 2, available = 2
+
+            // Exhaust both permits so the next WaitAsync will block.
+            using var hold1 = await semaphore.WaitAsync();
+            using var hold2 = await semaphore.WaitAsync();
+
+            using var cts = new CancellationTokenSource();
+            cts.Cancel();
+
+            // Act - shrink should decrement limit then fail to acquire, rolling back.
+            await Should.ThrowAsync<OperationCanceledException>(
+                async () => await semaphore.TryShrinkAsync(cts.Token));
+
+            // Assert - limit should be restored to 2.
+            semaphore.Limit.ShouldBe(2);
+        }
     }
 
     public class WhenGrowing