How to use AsyncDisposableWrapper class of Xunit.Sdk package

...57		/// Add an action to the list of things to be done during disposal.58		/// </summary>59		/// <param name="cleanupAction">The cleanup action.</param>60		public void AddAsyncAction(Func<ValueTask> cleanupAction) =>61			Add(new AsyncDisposableWrapper(cleanupAction));62		void AddInternal(object? @object)63		{64			if (@object != null)65				trackedObjects.Push(@object);66		}67		/// <summary>68		/// Add a collection of objects to be disposed. They may optionally support <see cref="IDisposable"/>69		/// and/or <see cref="IAsyncDisposable"/>.70		/// </summary>71		/// <param name="objects">The objects to be disposed.</param>72		public void AddRange(object?[]? objects)73		{74			lock (trackedObjects)75			{76				GuardNotDisposed();77				if (objects != null)78					foreach (var @object in objects)79						AddInternal(@object);80			}81		}82		/// <summary>83		/// Removes all objects from the disposal tracker.84		/// </summary>85		public void Clear()86		{87			lock (trackedObjects)88			{89				GuardNotDisposed();90				trackedObjects.Clear();91			}92		}93		/// <summary>94		/// Disposes all the objects that were added to the disposal tracker, in the reverse order95		/// of which they were added. For any object which implements both <see cref="IDisposable"/>96		/// and <see cref="IAsyncDisposable"/> we will favor <see cref="IAsyncDisposable.DisposeAsync"/>97		/// and not call <see cref="IDisposable.Dispose"/>.98		/// </summary>99		public async ValueTask DisposeAsync()100		{101			lock (trackedObjects)102			{103				GuardNotDisposed();104				disposed = true;105			}106			var exceptions = new List<Exception>();107			foreach (var trackedObject in trackedObjects)108			{109				try110				{111					if (trackedObject is IAsyncDisposable asyncDisposable)112						await asyncDisposable.DisposeAsync();113					else if (trackedObject is IDisposable disposable)114						disposable.Dispose();115				}116				catch (Exception ex)117				{118					exceptions.Add(ex);119				}120			}121			if (exceptions.Count == 1)122				ExceptionDispatchInfo.Capture(exceptions[0]).Throw();123			if (exceptions.Count != 0)124				throw new AggregateException(exceptions);125		}126		void GuardNotDisposed()127		{128			if (disposed)129				throw new ObjectDisposedException(GetType().FullName);130		}131		class AsyncDisposableWrapper : IAsyncDisposable132		{133			readonly Func<ValueTask> cleanupAction;134			public AsyncDisposableWrapper(Func<ValueTask> cleanupAction) =>135				this.cleanupAction = Guard.ArgumentNotNull(cleanupAction);136			public ValueTask DisposeAsync() =>137				cleanupAction();138		}139		class DisposableWrapper : IDisposable140		{141			readonly Action cleanupAction;142			public DisposableWrapper(Action cleanupAction) =>143				this.cleanupAction = Guard.ArgumentNotNull(cleanupAction);144			public void Dispose() =>145				cleanupAction();146		}147	}148}...

1{2    private readonly Func<ValueTask> _disposeAsync;3    public AsyncDisposableWrapper(Func<ValueTask> disposeAsync)4    {5        _disposeAsync = disposeAsync;6    }7    public ValueTask DisposeAsync() => _disposeAsync();8}9{10    private readonly Func<ValueTask> _disposeAsync;11    public AsyncDisposableWrapper(Func<ValueTask> disposeAsync)12    {13        _disposeAsync = disposeAsync;14    }15    public ValueTask DisposeAsync() => _disposeAsync();16}17{18    private readonly Func<ValueTask> _disposeAsync;19    public AsyncDisposableWrapper(Func<ValueTask> disposeAsync)20    {21        _disposeAsync = disposeAsync;22    }23    public ValueTask DisposeAsync() => _disposeAsync();24}25{26    private readonly Func<ValueTask> _disposeAsync;27    public AsyncDisposableWrapper(Func<ValueTask> disposeAsync)28    {29        _disposeAsync = disposeAsync;30    }31    public ValueTask DisposeAsync() => _disposeAsync();32}33{34    private readonly Func<ValueTask> _disposeAsync;35    public AsyncDisposableWrapper(Func<ValueTask> disposeAsync)36    {37        _disposeAsync = disposeAsync;38    }39    public ValueTask DisposeAsync() => _disposeAsync();40}41{42    private readonly Func<ValueTask> _disposeAsync;43    public AsyncDisposableWrapper(Func<ValueTask> disposeAsync)44    {45        _disposeAsync = disposeAsync;46    }47    public ValueTask DisposeAsync() => _disposeAsync();48}49{50    private readonly Func<ValueTask> _disposeAsync;

1using Xunit;2using Xunit.Abstractions;3{4    {5        private readonly ITestOutputHelper _output;6        public UnitTest1(ITestOutputHelper output)7        {8            _output = output;9        }10        public async Task DisposeAsync()11        {12            await Task.Delay(1000);13            _output.WriteLine("DisposeAsync");14        }15        public async Task InitializeAsync()16        {17            await Task.Delay(1000);18            _output.WriteLine("InitializeAsync");19        }20        public void Test1()21        {22            _output.WriteLine("Test1");23        }24    }25}

1using Xunit;2using Xunit.Abstractions;3{4    {5        private readonly ITestOutputHelper output;6        public AsyncDisposableTests(ITestOutputHelper output)7        {8            this.output = output;9        }10        public async Task InitializeAsync()11        {12            output.WriteLine("InitializeAsync");13        }14        public async Task DisposeAsync()15        {16            output.WriteLine("DisposeAsync");17        }18        public async Task Test1()19        {20            output.WriteLine("Test1");21        }22        public async Task Test2()23        {24            output.WriteLine("Test2");25        }26    }27}28using Xunit;29using Xunit.Abstractions;30using Xunit.Sdk;31{32    {33        private readonly ITestOutputHelper output;34        public AsyncDisposableTests(ITestOutputHelper output)35        {36            this.output = output;37        }38        public async Task InitializeAsync()39        {40            output.WriteLine("InitializeAsync");41        }42        public async Task DisposeAsync()43        {44            output.WriteLine("DisposeAsync");45        }46        public ValueTask DisposeAsync()47        {48            return new ValueTask(DisposeAsync());49        }50        public async Task Test1()51        {52            output.WriteLine("Test1");53        }54        public async Task Test2()55        {56            output.WriteLine("Test2");57        }58    }59}

1using System;2using System.Threading;3using System.Threading.Tasks;4using Xunit.Sdk;5{6    {7        public static AsyncDisposableWrapper DisposeAsync(this IAsyncDisposable asyncDisposable)8        {9            return new AsyncDisposableWrapper(asyncDisposable);10        }11    }12}13using System;14using System.Threading;15using System.Threading.Tasks;16using Xunit.Sdk;17{18    {19        public static DisposableWrapper Dispose(this IDisposable disposable)20        {21            return new DisposableWrapper(disposable);22        }23    }24}

1using Xunit;2using Xunit.Abstractions;3using Xunit.Sdk;4{5    {6        public void TestAsyncDisposableWrapper()7        {8            var obj = new AsyncDisposableWrapper(new Disposable());9            obj.DisposeAsync();10        }11    }12    {13        public ValueTask DisposeAsync()14        {15            return new ValueTask(Task.CompletedTask);16        }17    }18}19using Xunit;20using Xunit.Abstractions;21using Xunit.Sdk;22{23    {24        public void TestAsyncDisposableWrapper()25        {26            var obj = new AsyncDisposableWrapper(new Disposable());27            obj.DisposeAsync();28        }29    }30    {31        public ValueTask DisposeAsync()32        {33            return new ValueTask(Task.CompletedTask);34        }35    }36}37using Xunit;38using Xunit.Abstractions;39using Xunit.Sdk;40{41    {42        public void TestAsyncDisposableWrapper()43        {44            var obj = new AsyncDisposableWrapper(new Disposable());45            obj.DisposeAsync();46        }47    }48    {49        public ValueTask DisposeAsync()50        {51            return new ValueTask(Task.CompletedTask);52        }53    }54}55using Xunit;56using Xunit.Abstractions;57using Xunit.Sdk;58{59    {60        public void TestAsyncDisposableWrapper()61        {62            var obj = new AsyncDisposableWrapper(new Disposable());63            obj.DisposeAsync();64        }65    }66    {67        public ValueTask DisposeAsync()68        {69            return new ValueTask(Task.CompletedTask);70        }71    }72}73using Xunit;74using Xunit.Abstractions;75using Xunit.Sdk;76{77    {78        public void TestAsyncDisposableWrapper()79        {

1using Xunit.Sdk;2using Xunit.Abstractions;3using System.Threading.Tasks;4using System;5using Xunit;6{7    public async Task InitializeAsync()8    {9    }10    public async Task DisposeAsync()11    {12    }13}14public async Task TestMethod()15{16    var testClass = new TestClass();17    using (var wrapper = new AsyncDisposableWrapper(testClass))18    {19    }20}21using Xunit.Sdk;22using Xunit.Abstractions;23using System.Threading.Tasks;24using System;25using Xunit;26{27    public void Dispose()28    {29    }30}31public void TestMethod()32{33    var testClass = new TestClass();34    using (var wrapper = new DisposableWrapper(testClass))35    {36    }37}38using Xunit;39using System.Threading.Tasks;40{41    public async Task InitializeAsync()42    {43    }44    public async Task DisposeAsync()45    {46    }47}48public async Task TestMethod()49{50    var testClass = new TestClass();51}52using Xunit;53using System.Threading.Tasks;54{55    public void Dispose()56    {57    }58}59public void TestMethod()60{61    var testClass = new TestClass();62}63using Xunit;64using System.Threading.Tasks;65{66    private readonly TestClassFixture _testClassFixture;67    public TestClass(TestClassFixture testClassFixture)68    {69        _testClassFixture = testClassFixture;70    }71    public void TestMethod()72    {73    }74}75{