Use latest language features (#2176)

* Make use of language features line AsyncDispose, init etc. * Fix build errors * Improve Unit Tests * Improve Unit Tests * Improve Unit Tests * Update samples * Remove obsolete benchmarks * Code cleanup * Improve unit tests * Improve Unit Tests * Fix Unit Tests * Improve Unit Tests * Improve Unit Tests * Restore unit tests * Exclude load tests from unit tests
2026-10-20 19:58:57 +08:00 · 2025-08-30 10:52:59 +02:00
parent 247988e633
commit e43e7f8e36
330 changed files with 21417 additions and 22919 deletions
@@ -9,120 +9,114 @@ using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Internal;

-namespace MQTTnet.Tests.Internal
+namespace MQTTnet.Tests.Internal;
+
+// ReSharper disable InconsistentNaming
+[TestClass]
+public sealed class AsyncSignal_Tests
 {
-    [TestClass]
-    public sealed class AsyncSignal_Tests
+    [TestMethod]
+    [ExpectedException(typeof(TaskCanceledException))]
+    public async Task Cancel_If_No_Signal()
    {
-        [TestMethod]
-        [ExpectedException(typeof(TaskCanceledException))]
-        public async Task Cancel_If_No_Signal()
-        {
-            var asyncSignal = new AsyncSignal();
+        var asyncSignal = new AsyncSignal();

-            using (var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(2)))
+        using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(2));
+        await asyncSignal.WaitAsync(timeout.Token);
+
+        Assert.Fail("There is no signal. So we must fail here!");
+    }
+
+    [TestMethod]
+    [ExpectedException(typeof(ObjectDisposedException))]
+    public async Task Dispose_Properly()
+    {
+        var asyncSignal = new AsyncSignal();
+
+        // The timeout will not be reached but another task will kill the async signal.
+        using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(999));
+        _ = Task.Run(
+            async () =>
            {
-                await asyncSignal.WaitAsync(timeout.Token);
+                await Task.Delay(2000, CancellationToken.None);
+                asyncSignal.Dispose();
+            },
+            CancellationToken.None);

-                Assert.Fail("There is no signal. So we must fail here!");
-            }
-        }
+        await asyncSignal.WaitAsync(timeout.Token);

-        [TestMethod]
-        [ExpectedException(typeof(ObjectDisposedException))]
-        public async Task Dispose_Properly()
+        Assert.Fail("There is no signal. So we must fail here!");
+    }
+
+    [TestMethod]
+    public async Task Reset_Signal()
+    {
+        var asyncSignal = new AsyncSignal();
+
+        // WaitAsync should fail because no signal is available.
+        for (var i = 0; i < 10; i++)
        {
-            var asyncSignal = new AsyncSignal();
-
-            // The timeout will not be reached but another task will kill the async signal.
-            using (var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(999)))
+            try
            {
-                _ = Task.Run(
-                    async () =>
-                    {
-                        await Task.Delay(2000, CancellationToken.None);
-                        asyncSignal.Dispose();
-                    },
-                    CancellationToken.None);
-
-                await asyncSignal.WaitAsync(timeout.Token);
-
-                Assert.Fail("There is no signal. So we must fail here!");
-            }
-        }
-
-        [TestMethod]
-        public async Task Reset_Signal()
-        {
-            var asyncSignal = new AsyncSignal();
-
-            // WaitAsync should fail because no signal is available.
-            for (var i = 0; i < 10; i++)
-            {
-                try
+                using (var timeout = new CancellationTokenSource(TimeSpan.FromMilliseconds(100)))
                {
-                    using (var timeout = new CancellationTokenSource(TimeSpan.FromMilliseconds(100)))
-                    {
-                        await asyncSignal.WaitAsync(timeout.Token);
-                    }
-                    
-                    Assert.Fail("This must fail because the signal is not yet set.");
+                    await asyncSignal.WaitAsync(timeout.Token);
                }
-                catch (OperationCanceledException)
-                {
-                }
-                
-                asyncSignal.Set();
-                
-                // WaitAsync should return directly because the signal is available.
-                await asyncSignal.WaitAsync();
+
+                Assert.Fail("This must fail because the signal is not yet set.");
            }
-        }
-
-        [TestMethod]
-        public async Task Signal()
-        {
-            var asyncSignal = new AsyncSignal();
-
-            // The timeout will not be reached but another task will kill the async signal.
-            using (var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(3)))
+            catch (OperationCanceledException)
            {
-                var stopwatch = Stopwatch.StartNew();
-
-                _ = Task.Run(
-                    async () =>
-                    {
-                        await Task.Delay(1000, CancellationToken.None);
-                        asyncSignal.Set();
-                    },
-                    CancellationToken.None);
-
-                await asyncSignal.WaitAsync(timeout.Token);
-
-                stopwatch.Stop();
-
-                Assert.IsTrue(stopwatch.ElapsedMilliseconds > 900);
            }
-        }

-        [TestMethod]
-        [ExpectedException(typeof(InvalidOperationException))]
-        public async Task Fail_For_Two_Waiters()
-        {
-            var asyncSignal = new AsyncSignal();
+            asyncSignal.Set();

-            // This thread will wait properly because it is the first waiter.
-            _ = Task.Run(
-                async () =>
-                {
-                    await asyncSignal.WaitAsync();
-                },
-                CancellationToken.None);
-
-            await Task.Delay(1000);
-            
-            // Now the current thread must fail because there is already a waiter.
+            // WaitAsync should return directly because the signal is available.
            await asyncSignal.WaitAsync();
        }
    }
+
+    [TestMethod]
+    public async Task Signal()
+    {
+        var asyncSignal = new AsyncSignal();
+
+        // The timeout will not be reached but another task will kill the async signal.
+        using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(3));
+        var stopwatch = Stopwatch.StartNew();
+
+        _ = Task.Run(
+            async () =>
+            {
+                await Task.Delay(1000, CancellationToken.None);
+                asyncSignal.Set();
+            },
+            CancellationToken.None);
+
+        await asyncSignal.WaitAsync(timeout.Token);
+
+        stopwatch.Stop();
+
+        Assert.IsTrue(stopwatch.ElapsedMilliseconds > 900);
+    }
+
+    [TestMethod]
+    [ExpectedException(typeof(InvalidOperationException))]
+    public async Task Fail_For_Two_Waiters()
+    {
+        var asyncSignal = new AsyncSignal();
+
+        // This thread will wait properly because it is the first waiter.
+        _ = Task.Run(
+            async () =>
+            {
+                await asyncSignal.WaitAsync().ConfigureAwait(false);
+            },
+            CancellationToken.None);
+
+        await Task.Delay(1000);
+
+        // Now the current thread must fail because there is already a waiter.
+        await asyncSignal.WaitAsync().ConfigureAwait(false);
+    }
 }