Make async disposal test more deterministic.

Author: tillig

test/Autofac.Test/Core/DisposerTests.cs

@@ -61,7 +61,9 @@ public void CannotAddObjectsToDisposerAfterSyncDispose()
     [Fact]
     public async Task DisposerDisposesOfObjectsAsyncIfIAsyncDisposableDeclared()
     {
-        var instance = new AsyncDisposeTracker();
+        var semaphore = new SemaphoreSlim(1);
+        var instance = new AsyncDisposeTracker(semaphore);
+        await semaphore.WaitAsync();
 
         var disposer = new Disposer();
         disposer.AddInstanceForDisposal(instance);
@@ -74,6 +76,7 @@ public async Task DisposerDisposesOfObjectsAsyncIfIAsyncDisposableDeclared()
         Assert.False(instance.IsAsyncDisposed);
 
         // Now we wait.
+        semaphore.Release();
         await result;
 
         Assert.False(instance.IsSyncDisposed);

test/Autofac.Test/Util/AsyncDisposeTracker.cs

@@ -5,12 +5,24 @@ namespace Autofac.Test.Util;
 
 public sealed class AsyncDisposeTracker : IDisposable, IAsyncDisposable
 {
+    private readonly SemaphoreSlim _semaphore;
+
     public event EventHandler<EventArgs> Disposing;
 
     public bool IsSyncDisposed { get; set; }
 
     public bool IsAsyncDisposed { get; set; }
 
+    public AsyncDisposeTracker()
+        : this(null)
+    {
+    }
+
+    public AsyncDisposeTracker(SemaphoreSlim semaphore)
+    {
+        _semaphore = semaphore;
+    }
+
     public void Dispose()
     {
         IsSyncDisposed = true;
@@ -20,10 +32,20 @@ public void Dispose()
 
     public async ValueTask DisposeAsync()
     {
-        await Task.Delay(1);
-
-        IsAsyncDisposed = true;
-
-        Disposing?.Invoke(this, EventArgs.Empty);
+        if (_semaphore != null)
+        {
+            await _semaphore.WaitAsync();
+        }
+
+        try
+        {
+            IsAsyncDisposed = true;
+
+            Disposing?.Invoke(this, EventArgs.Empty);
+        }
+        finally
+        {
+            _semaphore?.Release();
+        }
     }
 }