Improve MTP unit tests (#6861)

Author: Youssef1313

test/UnitTests/Microsoft.Testing.Platform.UnitTests/Helpers/SystemAsyncMonitorTests.cs

@@ -24,10 +24,7 @@ public async Task AsyncMonitor_ShouldCorrectlyLock()
 
         await Task.WhenAll([.. tasks]);
 
-        // Give more time to be above 3s
-        Thread.Sleep(500);
-
-        Assert.IsGreaterThan(3000, stopwatch.ElapsedMilliseconds);
+        Assert.IsGreaterThanOrEqualTo(3000, stopwatch.ElapsedMilliseconds);
 
         async Task TestLock()
         {

test/UnitTests/Microsoft.Testing.Platform.UnitTests/Helpers/TaskExtensionsTests.cs

@@ -72,49 +72,47 @@ public async Task CancellationAsync_NonCanceledWithArgument_Succeeds()
 
     [TestMethod]
     public async Task CancellationAsync_ObserveException_Succeeds()
-        => await RetryHelper.RetryAsync(
-            async () =>
-            {
-                ManualResetEvent waitException = new(false);
-                await Assert.ThrowsAsync<OperationCanceledException>(async ()
-                    => await Task.Run(
-                        async () =>
-                        {
-                            await Task.Delay(TimeSpan.FromSeconds(10), TestContext.CancellationToken);
-                            waitException.Set();
-                            throw new InvalidOperationException();
-                        }, TestContext.CancellationToken).WithCancellationAsync(new CancellationTokenSource(TimeSpan.FromSeconds(1)).Token));
-
-                waitException.WaitOne();
-                await Task.Delay(TimeSpan.FromSeconds(4), TestContext.CancellationToken);
-            }, 3, TimeSpan.FromSeconds(3));
+    {
+        ManualResetEvent waitException = new(false);
+        CancellationToken token = new CancellationTokenSource(TimeSpan.FromSeconds(1)).Token;
+        OperationCanceledException ex = await Assert.ThrowsAsync<OperationCanceledException>(async ()
+            => await Task.Run(
+                async () =>
+                {
+                    await Task.Delay(TimeSpan.FromSeconds(5), TestContext.CancellationToken);
+                    waitException.Set();
+                    throw new InvalidOperationException();
+                }, TestContext.CancellationToken).WithCancellationAsync(token));
+#if !NETFRAMEWORK // Polyfill bug in Task.WaitAsync implementation :/
+        Assert.AreEqual(token, ex.CancellationToken);
+#endif
+        waitException.WaitOne();
+    }
 
     [TestMethod]
     public async Task CancellationAsyncWithReturnValue_ObserveException_Succeeds()
-        => await RetryHelper.RetryAsync(
-            async () =>
+    {
+        ManualResetEvent waitException = new(false);
+        CancellationToken token = new CancellationTokenSource(TimeSpan.FromSeconds(1)).Token;
+        OperationCanceledException ex = await Assert.ThrowsAsync<OperationCanceledException>(async ()
+            => await Task.Run(async () =>
             {
-                ManualResetEvent waitException = new(false);
-                await Assert.ThrowsAsync<OperationCanceledException>(async ()
-                    => await Task.Run(async () =>
-                    {
-                        await Task.Delay(TimeSpan.FromSeconds(10), TestContext.CancellationToken);
-                        try
-                        {
-                            return 2;
-                        }
-                        finally
-                        {
-                            waitException.Set();
+                await Task.Delay(TimeSpan.FromSeconds(5), TestContext.CancellationToken);
+                try
+                {
+                    return 2;
+                }
+                finally
+                {
+                    waitException.Set();
 #pragma warning disable CA2219 // Do not raise exceptions in finally clauses
-                            throw new InvalidOperationException();
+                    throw new InvalidOperationException();
 #pragma warning restore CA2219 // Do not raise exceptions in finally clauses
-                        }
-                    }).WithCancellationAsync(new CancellationTokenSource(TimeSpan.FromSeconds(1)).Token));
-
-                waitException.WaitOne();
-                await Task.Delay(TimeSpan.FromSeconds(4), TestContext.CancellationToken);
-            }, 3, TimeSpan.FromSeconds(3));
+                }
+            }).WithCancellationAsync(token));
+        Assert.AreEqual(token, ex.CancellationToken);
+        waitException.WaitOne();
+    }
 
     private static async Task<string> DoSomething()
     {

test/UnitTests/Microsoft.Testing.Platform.UnitTests/ServerMode/ServerTests.cs

@@ -30,26 +30,25 @@ private static bool IsHotReloadEnabled(SystemEnvironment environment)
         || environment.GetEnvironmentVariable(EnvironmentVariableConstants.TESTINGPLATFORM_HOTRELOAD_ENABLED) == "1";
 
     [TestMethod]
-    public async Task ServerCanBeStartedAndAborted_TcpIp() => await RetryHelper.RetryAsync(
-                async () =>
-                {
-                    using var server = TcpServer.Create();
-
-                    TestApplicationHooks testApplicationHooks = new();
-                    string[] args = ["--no-banner", "--server", "--client-host", "localhost", "--client-port", $"{server.Port}", "--internal-testingplatform-skipbuildercheck"];
-                    ITestApplicationBuilder builder = await TestApplication.CreateBuilderAsync(args);
-                    builder.TestHost.AddTestHostApplicationLifetime(_ => testApplicationHooks);
-                    builder.RegisterTestFramework(_ => new TestFrameworkCapabilities(), (_, __) => new MockTestAdapter());
-                    var testApplication = (TestApplication)await builder.BuildAsync();
-                    testApplication.ServiceProvider.GetRequiredService<SystemConsole>().SuppressOutput();
-                    Task<int> serverTask = testApplication.RunAsync();
-
-                    await testApplicationHooks.WaitForBeforeRunAsync();
-                    ITestApplicationCancellationTokenSource stopService = testApplication.ServiceProvider.GetTestApplicationCancellationTokenSource();
-
-                    stopService.Cancel();
-                    Assert.AreEqual(ExitCodes.TestSessionAborted, await serverTask);
-                }, 3, TimeSpan.FromSeconds(10));
+    public async Task ServerCanBeStartedAndAborted_TcpIp()
+    {
+        using var server = TcpServer.Create();
+
+        TestApplicationHooks testApplicationHooks = new();
+        string[] args = ["--no-banner", "--server", "--client-host", "localhost", "--client-port", $"{server.Port}", "--internal-testingplatform-skipbuildercheck"];
+        ITestApplicationBuilder builder = await TestApplication.CreateBuilderAsync(args);
+        builder.TestHost.AddTestHostApplicationLifetime(_ => testApplicationHooks);
+        builder.RegisterTestFramework(_ => new TestFrameworkCapabilities(), (_, __) => new MockTestAdapter());
+        var testApplication = (TestApplication)await builder.BuildAsync();
+        testApplication.ServiceProvider.GetRequiredService<SystemConsole>().SuppressOutput();
+        Task<int> serverTask = testApplication.RunAsync();
+
+        await testApplicationHooks.WaitForBeforeRunAsync();
+        ITestApplicationCancellationTokenSource stopService = testApplication.ServiceProvider.GetTestApplicationCancellationTokenSource();
+
+        stopService.Cancel();
+        Assert.AreEqual(ExitCodes.TestSessionAborted, await serverTask);
+    }
 
     [TestMethod]
     public async Task ServerCanInitialize()