- Attempt to fix sensitive diagnostics tests having trouble with CI-SqlClient-Package runs.

paulmedynski · paulmedynski · commit d4c681a16ea4 · 2025-10-21T17:05:51.000-03:00
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/TracingTests/DiagnosticTest.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/TracingTests/DiagnosticTest.cs
@@ -246,9 +246,9 @@ public void ExecuteXmlReaderErrorTest()
         [Fact]
         public void ExecuteScalarAsyncTest()
         {
-            RemoteExecutor.Invoke(() =>
+            RemoteExecutor.Invoke(async () =>
             {
-                CollectStatisticsDiagnosticsAsync(async connectionString =>
+                await CollectStatisticsDiagnosticsAsync(async connectionString =>
                 {
 #if NET
                     await using (SqlConnection conn = new SqlConnection(connectionString))
@@ -264,17 +264,17 @@ public void ExecuteScalarAsyncTest()
                         conn.Open();
                         await cmd.ExecuteScalarAsync();
                     }
-                }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteCommandBefore, WriteCommandAfter, WriteConnectionCloseBefore, WriteConnectionCloseAfter]).Wait();
+                }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteCommandBefore, WriteCommandAfter, WriteConnectionCloseBefore, WriteConnectionCloseAfter]);
                 return RemoteExecutor.SuccessExitCode;
             }).Dispose();
         }
 
         [Fact]
         public void ExecuteScalarAsyncErrorTest()
         {
-            RemoteExecutor.Invoke(() =>
+            RemoteExecutor.Invoke(async () =>
             {
-                CollectStatisticsDiagnosticsAsync(async connectionString =>
+                await CollectStatisticsDiagnosticsAsync(async connectionString =>
                 {
 #if NET
                     await using (SqlConnection conn = new SqlConnection(connectionString))
@@ -290,17 +290,17 @@ public void ExecuteScalarAsyncErrorTest()
                         conn.Open();
                         await Assert.ThrowsAsync<SqlException>(() => cmd.ExecuteScalarAsync());
                     }
-                }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteCommandBefore, WriteCommandError, WriteConnectionCloseBefore, WriteConnectionCloseAfter]).Wait();
+                }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteCommandBefore, WriteCommandError, WriteConnectionCloseBefore, WriteConnectionCloseAfter]);
                 return RemoteExecutor.SuccessExitCode;
             }).Dispose();
         }
 
         [Fact]
         public void ExecuteNonQueryAsyncTest()
         {
-            RemoteExecutor.Invoke(() =>
+            RemoteExecutor.Invoke(async () =>
             {
-                CollectStatisticsDiagnosticsAsync(async connectionString =>
+                await CollectStatisticsDiagnosticsAsync(async connectionString =>
                 {
 #if NET
                     await using (SqlConnection conn = new SqlConnection(connectionString))
@@ -316,17 +316,17 @@ public void ExecuteNonQueryAsyncTest()
                         conn.Open();
                         await cmd.ExecuteNonQueryAsync();
                     }
-                }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteCommandBefore, WriteCommandAfter, WriteConnectionCloseBefore, WriteConnectionCloseAfter]).Wait();
+                }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteCommandBefore, WriteCommandAfter, WriteConnectionCloseBefore, WriteConnectionCloseAfter]);
                 return RemoteExecutor.SuccessExitCode;
             }).Dispose();
         }
 
         [Fact]
         public void ExecuteNonQueryAsyncErrorTest()
         {
-            RemoteExecutor.Invoke(() =>
+            RemoteExecutor.Invoke(async () =>
             {
-                CollectStatisticsDiagnosticsAsync(async connectionString =>
+                await CollectStatisticsDiagnosticsAsync(async connectionString =>
                 {
 #if NET
                     await using (SqlConnection conn = new SqlConnection(connectionString))
@@ -342,17 +342,17 @@ public void ExecuteNonQueryAsyncErrorTest()
                         conn.Open();
                         await Assert.ThrowsAsync<SqlException>(() => cmd.ExecuteNonQueryAsync());
                     }
-                }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteCommandBefore, WriteCommandError, WriteConnectionCloseBefore, WriteConnectionCloseAfter]).Wait();
+                }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteCommandBefore, WriteCommandError, WriteConnectionCloseBefore, WriteConnectionCloseAfter]);
                 return RemoteExecutor.SuccessExitCode;
             }).Dispose();
         }
 
         [Fact]
         public void ExecuteReaderAsyncTest()
         {
-            RemoteExecutor.Invoke(() =>
+            RemoteExecutor.Invoke(async () =>
             {
-                CollectStatisticsDiagnosticsAsync(async connectionString =>
+                await CollectStatisticsDiagnosticsAsync(async connectionString =>
                 {
 #if NET
                     await using (SqlConnection conn = new SqlConnection(connectionString))
@@ -372,17 +372,17 @@ public void ExecuteReaderAsyncTest()
                             // Read to end
                         }
                     }
-                }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteCommandBefore, WriteCommandAfter, WriteConnectionCloseBefore, WriteConnectionCloseAfter]).Wait();
+                }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteCommandBefore, WriteCommandAfter, WriteConnectionCloseBefore, WriteConnectionCloseAfter]);
                 return RemoteExecutor.SuccessExitCode;
             }).Dispose();
         }
 
         [Fact]
         public void ExecuteReaderAsyncErrorTest()
         {
-            RemoteExecutor.Invoke(() =>
+            RemoteExecutor.Invoke(async () =>
             {
-                CollectStatisticsDiagnosticsAsync(async connectionString =>
+                await CollectStatisticsDiagnosticsAsync(async connectionString =>
                 {
 #if NET
                     await using (SqlConnection conn = new SqlConnection(connectionString))
@@ -399,7 +399,7 @@ public void ExecuteReaderAsyncErrorTest()
                         // @TODO: TestTdsServer should not throw on ExecuteReader, should throw on reader.Read
                         await Assert.ThrowsAsync<SqlException>(() => cmd.ExecuteReaderAsync());
                     }
-                }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteCommandBefore, WriteCommandError, WriteConnectionCloseBefore, WriteConnectionCloseAfter]).Wait();
+                }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteCommandBefore, WriteCommandError, WriteConnectionCloseBefore, WriteConnectionCloseAfter]);
                 return RemoteExecutor.SuccessExitCode;
             }).Dispose();
         }
@@ -409,9 +409,9 @@ public void ExecuteReaderAsyncErrorTest()
         public void ExecuteXmlReaderAsyncTest()
         {
             // @TODO: TestTdsServer does not handle xml reader, so connect to a real server as a workaround
-            RemoteExecutor.Invoke(() =>
+            RemoteExecutor.Invoke(async () =>
             {
-                CollectStatisticsDiagnosticsAsync(async _ =>
+                await CollectStatisticsDiagnosticsAsync(async _ =>
                 {
 #if NET
                     await using (SqlConnection conn = new SqlConnection(DataTestUtility.TCPConnectionString))
@@ -431,7 +431,7 @@ public void ExecuteXmlReaderAsyncTest()
                             // Read to end
                         }
                     }
-                }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteCommandBefore, WriteCommandAfter, WriteConnectionCloseBefore, WriteConnectionCloseAfter]).Wait();
+                }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteCommandBefore, WriteCommandAfter, WriteConnectionCloseBefore, WriteConnectionCloseAfter]);
                 return RemoteExecutor.SuccessExitCode;
             }).Dispose();
         }
@@ -440,10 +440,9 @@ public void ExecuteXmlReaderAsyncTest()
         public void ExecuteXmlReaderAsyncErrorTest()
         {
             // @TODO: TestTdsServer does not handle xml reader, so connect to a real server as a workaround
-            RemoteExecutor.Invoke(() =>
+            RemoteExecutor.Invoke(async () =>
             {
-
-                CollectStatisticsDiagnosticsAsync(async _ =>
+                await CollectStatisticsDiagnosticsAsync(async _ =>
                 {
 #if NET
                     await using (SqlConnection conn = new SqlConnection(DataTestUtility.TCPConnectionString))
@@ -466,7 +465,7 @@ public void ExecuteXmlReaderAsyncErrorTest()
                         XmlReader reader = await cmd.ExecuteXmlReaderAsync();
                         await Assert.ThrowsAsync<SqlException>(() => reader.ReadAsync());
                     }
-                }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteCommandBefore, WriteCommandAfter, WriteConnectionCloseBefore, WriteConnectionCloseAfter]).Wait();
+                }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteCommandBefore, WriteCommandAfter, WriteConnectionCloseBefore, WriteConnectionCloseAfter]);
                 return RemoteExecutor.SuccessExitCode;
             }).Dispose();
         }
@@ -506,9 +505,9 @@ public void ConnectionOpenErrorTest()
         [Fact]
         public void ConnectionOpenAsyncTest()
         {
-            RemoteExecutor.Invoke(() =>
+            RemoteExecutor.Invoke(async () =>
             {
-                CollectStatisticsDiagnosticsAsync(async connectionString =>
+                await CollectStatisticsDiagnosticsAsync(async connectionString =>
                 {
 #if NET
                     await using (SqlConnection sqlConnection = new SqlConnection(connectionString))
@@ -518,17 +517,17 @@ public void ConnectionOpenAsyncTest()
                     {
                         await sqlConnection.OpenAsync();
                     }
-                }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteConnectionCloseBefore, WriteConnectionCloseAfter]).Wait();
+                }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteConnectionCloseBefore, WriteConnectionCloseAfter]);
                 return RemoteExecutor.SuccessExitCode;
             }).Dispose();
         }
 
         [Fact]
         public void ConnectionOpenAsyncErrorTest()
         {
-            RemoteExecutor.Invoke(() =>
+            RemoteExecutor.Invoke(async () =>
             {
-                CollectStatisticsDiagnosticsAsync(async _ =>
+                await CollectStatisticsDiagnosticsAsync(async _ =>
                 {
 #if NET
                     await using (SqlConnection sqlConnection = new SqlConnection(BadConnectionString))
@@ -538,7 +537,7 @@ public void ConnectionOpenAsyncErrorTest()
                     {
                         await Assert.ThrowsAsync<SqlException>(() => sqlConnection.OpenAsync());
                     }
-                }, [WriteConnectionOpenBefore, WriteConnectionOpenError]).Wait();
+                }, [WriteConnectionOpenBefore, WriteConnectionOpenError]);
                 return RemoteExecutor.SuccessExitCode;
             }).Dispose();
         }

Original file line number	Diff line number	Diff line change
`@@ -246,9 +246,9 @@ public void ExecuteXmlReaderErrorTest()`
`246`	`246`	`[Fact]`
`247`	`247`	`public void ExecuteScalarAsyncTest()`
`248`	`248`	`{`
`249`		`- RemoteExecutor.Invoke(() =>`
	`249`	`+ RemoteExecutor.Invoke(async () =>`
`250`	`250`	`{`
`251`		`- CollectStatisticsDiagnosticsAsync(async connectionString =>`
	`251`	`+ await CollectStatisticsDiagnosticsAsync(async connectionString =>`
`252`	`252`	`{`
`253`	`253`	`#if NET`
`254`	`254`	`await using (SqlConnection conn = new SqlConnection(connectionString))`
`@@ -264,17 +264,17 @@ public void ExecuteScalarAsyncTest()`
`264`	`264`	`conn.Open();`
`265`	`265`	`await cmd.ExecuteScalarAsync();`
`266`	`266`	`}`
`267`		`- }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteCommandBefore, WriteCommandAfter, WriteConnectionCloseBefore, WriteConnectionCloseAfter]).Wait();`
	`267`	`+ }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteCommandBefore, WriteCommandAfter, WriteConnectionCloseBefore, WriteConnectionCloseAfter]);`
`268`	`268`	`return RemoteExecutor.SuccessExitCode;`
`269`	`269`	`}).Dispose();`
`270`	`270`	`}`
`271`	`271`
`272`	`272`	`[Fact]`
`273`	`273`	`public void ExecuteScalarAsyncErrorTest()`
`274`	`274`	`{`
`275`		`- RemoteExecutor.Invoke(() =>`
	`275`	`+ RemoteExecutor.Invoke(async () =>`
`276`	`276`	`{`
`277`		`- CollectStatisticsDiagnosticsAsync(async connectionString =>`
	`277`	`+ await CollectStatisticsDiagnosticsAsync(async connectionString =>`
`278`	`278`	`{`
`279`	`279`	`#if NET`
`280`	`280`	`await using (SqlConnection conn = new SqlConnection(connectionString))`
`@@ -290,17 +290,17 @@ public void ExecuteScalarAsyncErrorTest()`
`290`	`290`	`conn.Open();`
`291`	`291`	`await Assert.ThrowsAsync<SqlException>(() => cmd.ExecuteScalarAsync());`
`292`	`292`	`}`
`293`		`- }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteCommandBefore, WriteCommandError, WriteConnectionCloseBefore, WriteConnectionCloseAfter]).Wait();`
	`293`	`+ }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteCommandBefore, WriteCommandError, WriteConnectionCloseBefore, WriteConnectionCloseAfter]);`
`294`	`294`	`return RemoteExecutor.SuccessExitCode;`
`295`	`295`	`}).Dispose();`
`296`	`296`	`}`
`297`	`297`
`298`	`298`	`[Fact]`
`299`	`299`	`public void ExecuteNonQueryAsyncTest()`
`300`	`300`	`{`
`301`		`- RemoteExecutor.Invoke(() =>`
	`301`	`+ RemoteExecutor.Invoke(async () =>`
`302`	`302`	`{`
`303`		`- CollectStatisticsDiagnosticsAsync(async connectionString =>`
	`303`	`+ await CollectStatisticsDiagnosticsAsync(async connectionString =>`
`304`	`304`	`{`
`305`	`305`	`#if NET`
`306`	`306`	`await using (SqlConnection conn = new SqlConnection(connectionString))`
`@@ -316,17 +316,17 @@ public void ExecuteNonQueryAsyncTest()`
`316`	`316`	`conn.Open();`
`317`	`317`	`await cmd.ExecuteNonQueryAsync();`
`318`	`318`	`}`
`319`		`- }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteCommandBefore, WriteCommandAfter, WriteConnectionCloseBefore, WriteConnectionCloseAfter]).Wait();`
	`319`	`+ }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteCommandBefore, WriteCommandAfter, WriteConnectionCloseBefore, WriteConnectionCloseAfter]);`
`320`	`320`	`return RemoteExecutor.SuccessExitCode;`
`321`	`321`	`}).Dispose();`
`322`	`322`	`}`
`323`	`323`
`324`	`324`	`[Fact]`
`325`	`325`	`public void ExecuteNonQueryAsyncErrorTest()`
`326`	`326`	`{`
`327`		`- RemoteExecutor.Invoke(() =>`
	`327`	`+ RemoteExecutor.Invoke(async () =>`
`328`	`328`	`{`
`329`		`- CollectStatisticsDiagnosticsAsync(async connectionString =>`
	`329`	`+ await CollectStatisticsDiagnosticsAsync(async connectionString =>`
`330`	`330`	`{`
`331`	`331`	`#if NET`
`332`	`332`	`await using (SqlConnection conn = new SqlConnection(connectionString))`
`@@ -342,17 +342,17 @@ public void ExecuteNonQueryAsyncErrorTest()`
`342`	`342`	`conn.Open();`
`343`	`343`	`await Assert.ThrowsAsync<SqlException>(() => cmd.ExecuteNonQueryAsync());`
`344`	`344`	`}`
`345`		`- }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteCommandBefore, WriteCommandError, WriteConnectionCloseBefore, WriteConnectionCloseAfter]).Wait();`
	`345`	`+ }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteCommandBefore, WriteCommandError, WriteConnectionCloseBefore, WriteConnectionCloseAfter]);`
`346`	`346`	`return RemoteExecutor.SuccessExitCode;`
`347`	`347`	`}).Dispose();`
`348`	`348`	`}`
`349`	`349`
`350`	`350`	`[Fact]`
`351`	`351`	`public void ExecuteReaderAsyncTest()`
`352`	`352`	`{`
`353`		`- RemoteExecutor.Invoke(() =>`
	`353`	`+ RemoteExecutor.Invoke(async () =>`
`354`	`354`	`{`
`355`		`- CollectStatisticsDiagnosticsAsync(async connectionString =>`
	`355`	`+ await CollectStatisticsDiagnosticsAsync(async connectionString =>`
`356`	`356`	`{`
`357`	`357`	`#if NET`
`358`	`358`	`await using (SqlConnection conn = new SqlConnection(connectionString))`
`@@ -372,17 +372,17 @@ public void ExecuteReaderAsyncTest()`
`372`	`372`	`// Read to end`
`373`	`373`	`}`
`374`	`374`	`}`
`375`		`- }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteCommandBefore, WriteCommandAfter, WriteConnectionCloseBefore, WriteConnectionCloseAfter]).Wait();`
	`375`	`+ }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteCommandBefore, WriteCommandAfter, WriteConnectionCloseBefore, WriteConnectionCloseAfter]);`
`376`	`376`	`return RemoteExecutor.SuccessExitCode;`
`377`	`377`	`}).Dispose();`
`378`	`378`	`}`
`379`	`379`
`380`	`380`	`[Fact]`
`381`	`381`	`public void ExecuteReaderAsyncErrorTest()`
`382`	`382`	`{`
`383`		`- RemoteExecutor.Invoke(() =>`
	`383`	`+ RemoteExecutor.Invoke(async () =>`
`384`	`384`	`{`
`385`		`- CollectStatisticsDiagnosticsAsync(async connectionString =>`
	`385`	`+ await CollectStatisticsDiagnosticsAsync(async connectionString =>`
`386`	`386`	`{`
`387`	`387`	`#if NET`
`388`	`388`	`await using (SqlConnection conn = new SqlConnection(connectionString))`
`@@ -399,7 +399,7 @@ public void ExecuteReaderAsyncErrorTest()`
`399`	`399`	`// @TODO: TestTdsServer should not throw on ExecuteReader, should throw on reader.Read`
`400`	`400`	`await Assert.ThrowsAsync<SqlException>(() => cmd.ExecuteReaderAsync());`
`401`	`401`	`}`
`402`		`- }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteCommandBefore, WriteCommandError, WriteConnectionCloseBefore, WriteConnectionCloseAfter]).Wait();`
	`402`	`+ }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteCommandBefore, WriteCommandError, WriteConnectionCloseBefore, WriteConnectionCloseAfter]);`
`403`	`403`	`return RemoteExecutor.SuccessExitCode;`
`404`	`404`	`}).Dispose();`
`405`	`405`	`}`
`@@ -409,9 +409,9 @@ public void ExecuteReaderAsyncErrorTest()`
`409`	`409`	`public void ExecuteXmlReaderAsyncTest()`
`410`	`410`	`{`
`411`	`411`	`// @TODO: TestTdsServer does not handle xml reader, so connect to a real server as a workaround`
`412`		`- RemoteExecutor.Invoke(() =>`
	`412`	`+ RemoteExecutor.Invoke(async () =>`
`413`	`413`	`{`
`414`		`- CollectStatisticsDiagnosticsAsync(async _ =>`
	`414`	`+ await CollectStatisticsDiagnosticsAsync(async _ =>`
`415`	`415`	`{`
`416`	`416`	`#if NET`
`417`	`417`	`await using (SqlConnection conn = new SqlConnection(DataTestUtility.TCPConnectionString))`
`@@ -431,7 +431,7 @@ public void ExecuteXmlReaderAsyncTest()`
`431`	`431`	`// Read to end`
`432`	`432`	`}`
`433`	`433`	`}`
`434`		`- }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteCommandBefore, WriteCommandAfter, WriteConnectionCloseBefore, WriteConnectionCloseAfter]).Wait();`
	`434`	`+ }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteCommandBefore, WriteCommandAfter, WriteConnectionCloseBefore, WriteConnectionCloseAfter]);`
`435`	`435`	`return RemoteExecutor.SuccessExitCode;`
`436`	`436`	`}).Dispose();`
`437`	`437`	`}`
`@@ -440,10 +440,9 @@ public void ExecuteXmlReaderAsyncTest()`
`440`	`440`	`public void ExecuteXmlReaderAsyncErrorTest()`
`441`	`441`	`{`
`442`	`442`	`// @TODO: TestTdsServer does not handle xml reader, so connect to a real server as a workaround`
`443`		`- RemoteExecutor.Invoke(() =>`
	`443`	`+ RemoteExecutor.Invoke(async () =>`
`444`	`444`	`{`
`445`		`-`
`446`		`- CollectStatisticsDiagnosticsAsync(async _ =>`
	`445`	`+ await CollectStatisticsDiagnosticsAsync(async _ =>`
`447`	`446`	`{`
`448`	`447`	`#if NET`
`449`	`448`	`await using (SqlConnection conn = new SqlConnection(DataTestUtility.TCPConnectionString))`
`@@ -466,7 +465,7 @@ public void ExecuteXmlReaderAsyncErrorTest()`
`466`	`465`	`XmlReader reader = await cmd.ExecuteXmlReaderAsync();`
`467`	`466`	`await Assert.ThrowsAsync<SqlException>(() => reader.ReadAsync());`
`468`	`467`	`}`
`469`		`- }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteCommandBefore, WriteCommandAfter, WriteConnectionCloseBefore, WriteConnectionCloseAfter]).Wait();`
	`468`	`+ }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteCommandBefore, WriteCommandAfter, WriteConnectionCloseBefore, WriteConnectionCloseAfter]);`
`470`	`469`	`return RemoteExecutor.SuccessExitCode;`
`471`	`470`	`}).Dispose();`
`472`	`471`	`}`
`@@ -506,9 +505,9 @@ public void ConnectionOpenErrorTest()`
`506`	`505`	`[Fact]`
`507`	`506`	`public void ConnectionOpenAsyncTest()`
`508`	`507`	`{`
`509`		`- RemoteExecutor.Invoke(() =>`
	`508`	`+ RemoteExecutor.Invoke(async () =>`
`510`	`509`	`{`
`511`		`- CollectStatisticsDiagnosticsAsync(async connectionString =>`
	`510`	`+ await CollectStatisticsDiagnosticsAsync(async connectionString =>`
`512`	`511`	`{`
`513`	`512`	`#if NET`
`514`	`513`	`await using (SqlConnection sqlConnection = new SqlConnection(connectionString))`
`@@ -518,17 +517,17 @@ public void ConnectionOpenAsyncTest()`
`518`	`517`	`{`
`519`	`518`	`await sqlConnection.OpenAsync();`
`520`	`519`	`}`
`521`		`- }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteConnectionCloseBefore, WriteConnectionCloseAfter]).Wait();`
	`520`	`+ }, [WriteConnectionOpenBefore, WriteConnectionOpenAfter, WriteConnectionCloseBefore, WriteConnectionCloseAfter]);`
`522`	`521`	`return RemoteExecutor.SuccessExitCode;`
`523`	`522`	`}).Dispose();`
`524`	`523`	`}`
`525`	`524`
`526`	`525`	`[Fact]`
`527`	`526`	`public void ConnectionOpenAsyncErrorTest()`
`528`	`527`	`{`
`529`		`- RemoteExecutor.Invoke(() =>`
	`528`	`+ RemoteExecutor.Invoke(async () =>`
`530`	`529`	`{`
`531`		`- CollectStatisticsDiagnosticsAsync(async _ =>`
	`530`	`+ await CollectStatisticsDiagnosticsAsync(async _ =>`
`532`	`531`	`{`
`533`	`532`	`#if NET`
`534`	`533`	`await using (SqlConnection sqlConnection = new SqlConnection(BadConnectionString))`
`@@ -538,7 +537,7 @@ public void ConnectionOpenAsyncErrorTest()`
`538`	`537`	`{`
`539`	`538`	`await Assert.ThrowsAsync<SqlException>(() => sqlConnection.OpenAsync());`
`540`	`539`	`}`
`541`		`- }, [WriteConnectionOpenBefore, WriteConnectionOpenError]).Wait();`
	`540`	`+ }, [WriteConnectionOpenBefore, WriteConnectionOpenError]);`
`542`	`541`	`return RemoteExecutor.SuccessExitCode;`
`543`	`542`	`}).Dispose();`
`544`	`543`	`}`