Merge pull request #1403 from rabbitmq/lukebakken/update-deps

lukebakken · web-flow · commit 5d7741de024e · 2023-10-13T07:49:04.000-07:00
Update package dependencies
diff --git a/projects/Benchmarks/Benchmarks.csproj b/projects/Benchmarks/Benchmarks.csproj
@@ -15,7 +15,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" Version="0.13.7" />
+    <PackageReference Include="BenchmarkDotNet" Version="0.13.9" />
     <PackageReference Include="Ductus.FluentDocker" Version="2.10.59" />
   </ItemGroup>
 
diff --git a/projects/OAuth2Test/OAuth2Test.csproj b/projects/OAuth2Test/OAuth2Test.csproj
@@ -21,18 +21,21 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
     <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
     <PackageReference Include="PublicApiGenerator" Version="11.0.0" />
-    <PackageReference Include="xunit" Version="2.5.0" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0" />
+    <PackageReference Include="xunit" Version="2.5.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.1">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
     <PackageReference Include="System.Net.Http" Version="4.3.4" />
-    <PackageReference Include="System.Text.Json" Version="7.0.2" />
-    <PackageReference Include="WireMock.Net" Version="1.5.24" />
-    <PackageReference Include="Verify.Xunit" Version="20.8.0" />
+    <PackageReference Include="System.Text.Json" Version="7.0.3" />
+    <PackageReference Include="WireMock.Net" Version="1.5.39" />
+    <PackageReference Include="Verify.Xunit" Version="22.1.3" />
     <PackageReference Include="Xunit.SkippableFact" Version="1.4.13" />
   </ItemGroup>
 
diff --git a/projects/RabbitMQ.Client.OAuth2/RabbitMQ.Client.OAuth2.csproj b/projects/RabbitMQ.Client.OAuth2/RabbitMQ.Client.OAuth2.csproj
@@ -49,7 +49,7 @@
   <ItemGroup>
     <None Remove="icon.png" />
     <Content Include="icon.png" PackagePath="" />
-    <None Include="README.md" Pack="true" PackagePath="/"/>
+    <None Include="README.md" Pack="true" PackagePath="/" />
     <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
       <_Parameter1>Unit, PublicKey=00240000048000009400000006020000002400005253413100040000010001008d20ec856aeeb8c3153a77faa2d80e6e43b5db93224a20cc7ae384f65f142e89730e2ff0fcc5d578bbe96fa98a7196c77329efdee4579b3814c0789e5a39b51df6edd75b602a33ceabdfcf19a3feb832f31d8254168cd7ba5700dfbca301fbf8db614ba41ba18474de0a5f4c2d51c995bc3636c641c8cbe76f45717bfcb943b5</_Parameter1>
     </AssemblyAttribute>
@@ -62,7 +62,7 @@
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1" PrivateAssets="All" />
     <PackageReference Include="MinVer" Version="4.3.0" PrivateAssets="all" />
     <PackageReference Include="System.Net.Http.Json" Version="7.0.1" />
-    <PackageReference Include="System.Text.Json" Version="7.0.2" />
+    <PackageReference Include="System.Text.Json" Version="7.0.3" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/projects/Unit/TestAsyncConsumer.cs b/projects/Unit/TestAsyncConsumer.cs
@@ -130,8 +130,11 @@ public async Task TestBasicRoundtripConcurrent()
                     // ensure we get a delivery
                     await Task.WhenAll(publish1SyncSource.Task, publish2SyncSource.Task);
 
-                    Assert.True(publish1SyncSource.Task.Result, $"1 - Non concurrent dispatch lead to deadlock after {maximumWaitTime}");
-                    Assert.True(publish2SyncSource.Task.Result, $"2 - Non concurrent dispatch lead to deadlock after {maximumWaitTime}");
+                    bool result1 = await publish1SyncSource.Task;
+                    Assert.True(result1, $"1 - Non concurrent dispatch lead to deadlock after {maximumWaitTime}");
+
+                    bool result2 = await publish2SyncSource.Task;
+                    Assert.True(result2, $"2 - Non concurrent dispatch lead to deadlock after {maximumWaitTime}");
                 }
             }
         }
@@ -158,7 +161,7 @@ public async Task TestBasicRoundtripConcurrentManyMessages()
                 }
             }
 
-            Task publishTask = Task.Run(() =>
+            Task publishTask = Task.Run(async () =>
                     {
                         using (IConnection c = cf.CreateConnection())
                         {
@@ -167,14 +170,14 @@ public async Task TestBasicRoundtripConcurrentManyMessages()
                                 QueueDeclareOk q = m.QueueDeclare(queue: queueName, exclusive: false, durable: true);
                                 for (int i = 0; i < publish_total; i++)
                                 {
-                                    m.BasicPublish(string.Empty, queueName, body1);
-                                    m.BasicPublish(string.Empty, queueName, body2);
+                                    await m.BasicPublishAsync(string.Empty, queueName, body1);
+                                    await m.BasicPublishAsync(string.Empty, queueName, body2);
                                 }
                             }
                         }
                     });
 
-            Task consumeTask = Task.Run(() =>
+            Task consumeTask = Task.Run(async () =>
                     {
                         var publish1SyncSource = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
                         var publish2SyncSource = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
@@ -219,10 +222,13 @@ public async Task TestBasicRoundtripConcurrentManyMessages()
                                 m.BasicConsume(queueName, true, consumer);
 
                                 // ensure we get a delivery
-                                Task.WhenAll(publish1SyncSource.Task, publish2SyncSource.Task);
+                                await Task.WhenAll(publish1SyncSource.Task, publish2SyncSource.Task);
+
+                                bool result1 = await publish1SyncSource.Task;
+                                Assert.True(result1, $"Non concurrent dispatch lead to deadlock after {maximumWaitTime}");
 
-                                Assert.True(publish1SyncSource.Task.Result, $"Non concurrent dispatch lead to deadlock after {maximumWaitTime}");
-                                Assert.True(publish2SyncSource.Task.Result, $"Non concurrent dispatch lead to deadlock after {maximumWaitTime}");
+                                bool result2 = await publish2SyncSource.Task;
+                                Assert.True(result2, $"Non concurrent dispatch lead to deadlock after {maximumWaitTime}");
                             }
                         }
                     });
@@ -262,7 +268,7 @@ public void TestBasicRoundtripNoWait()
         }
 
         [Fact]
-        public void ConcurrentEventingTestForReceived()
+        public async void ConcurrentEventingTestForReceived()
         {
             const int NumberOfThreads = 4;
             const int NumberOfRegistrations = 5000;
@@ -300,7 +306,7 @@ public void ConcurrentEventingTestForReceived()
                     }
 
                     countdownEvent.Wait();
-                    Task.WaitAll(tasks);
+                    await Task.WhenAll(tasks);
 
                     // Add last receiver
                     var are = new AutoResetEvent(false);
diff --git a/projects/Unit/TestConsumer.cs b/projects/Unit/TestConsumer.cs
@@ -74,11 +74,9 @@ public async Task TestBasicRoundtripConcurrent()
                     {
                         case publish1:
                             publish1SyncSource.TrySetResult(true);
-                            publish2SyncSource.Task.GetAwaiter().GetResult();
                             break;
                         case publish2:
                             publish2SyncSource.TrySetResult(true);
-                            publish1SyncSource.Task.GetAwaiter().GetResult();
                             break;
                     }
                 };
@@ -87,8 +85,11 @@ public async Task TestBasicRoundtripConcurrent()
 
                 await Task.WhenAll(publish1SyncSource.Task, publish2SyncSource.Task);
 
-                Assert.True(publish1SyncSource.Task.Result, $"Non concurrent dispatch lead to deadlock after {maximumWaitTime}");
-                Assert.True(publish2SyncSource.Task.Result, $"Non concurrent dispatch lead to deadlock after {maximumWaitTime}");
+                bool result1 = await publish1SyncSource.Task;
+                Assert.True(result1, $"Non concurrent dispatch lead to deadlock after {maximumWaitTime}");
+
+                bool result2 = await publish1SyncSource.Task;
+                Assert.True(result2, $"Non concurrent dispatch lead to deadlock after {maximumWaitTime}");
             }
         }
     }
diff --git a/projects/Unit/TestExtensions.cs b/projects/Unit/TestExtensions.cs
@@ -50,7 +50,7 @@ public async Task TestConfirmBarrier()
             {
                 _channel.BasicPublish("", string.Empty);
             }
-            Assert.True(await _channel.WaitForConfirmsAsync().ConfigureAwait(false));
+            Assert.True(await _channel.WaitForConfirmsAsync());
         }
 
         [Fact]
@@ -73,12 +73,12 @@ public async Task TestExchangeBinding()
             _channel.QueueBind(queue, "dest", string.Empty);
 
             _channel.BasicPublish("src", string.Empty);
-            await _channel.WaitForConfirmsAsync().ConfigureAwait(false);
+            await _channel.WaitForConfirmsAsync();
             Assert.NotNull(_channel.BasicGet(queue, true));
 
             _channel.ExchangeUnbind("dest", "src", string.Empty);
             _channel.BasicPublish("src", string.Empty);
-            await _channel.WaitForConfirmsAsync().ConfigureAwait(false);
+            await _channel.WaitForConfirmsAsync();
             Assert.Null(_channel.BasicGet(queue, true));
 
             _channel.ExchangeDelete("src");
diff --git a/projects/Unit/TestFloodPublishing.cs b/projects/Unit/TestFloodPublishing.cs
@@ -88,7 +88,7 @@ public async Task TestUnthrottledFloodPublishingAsync()
                                 }
                             }
 
-                            await channel.BasicPublishAsync(CachedString.Empty, CachedString.Empty, _body).ConfigureAwait(false);
+                            await channel.BasicPublishAsync(CachedString.Empty, CachedString.Empty, _body);
                         }
                     }
                     finally
@@ -135,7 +135,7 @@ public async Task TestMultithreadFloodPublishingAsync()
                     {
                         for (int i = 0; i < publishCount; i++)
                         {
-                            await pubCh.BasicPublishAsync(string.Empty, queueName, sendBody).ConfigureAwait(false);
+                            await pubCh.BasicPublishAsync(string.Empty, queueName, sendBody);
                         }
                     }
                 });
@@ -154,11 +154,11 @@ public async Task TestMultithreadFloodPublishingAsync()
                         }
                     };
                     consumeCh.BasicConsume(queueName, true, consumer);
-                    Assert.True(pub.Wait(_tenSeconds));
+
                     Assert.True(autoResetEvent.WaitOne(_tenSeconds));
                 }
 
-                await pub.ConfigureAwait(false);
+                await pub;
                 Assert.Equal(publishCount, receivedCount);
             }
         }
diff --git a/projects/Unit/TestMessageCount.cs b/projects/Unit/TestMessageCount.cs
@@ -50,7 +50,7 @@ public async Task TestMessageCountMethod()
             Assert.Equal(0u, _channel.MessageCount(q));
 
             _channel.BasicPublish("", q, _encoding.GetBytes("msg"));
-            await _channel.WaitForConfirmsAsync().ConfigureAwait(false);
+            await _channel.WaitForConfirmsAsync();
             Assert.Equal(1u, _channel.MessageCount(q));
         }
     }
diff --git a/projects/Unit/TestPublisherConfirms.cs b/projects/Unit/TestPublisherConfirms.cs
@@ -57,20 +57,20 @@ public TestPublisherConfirms(ITestOutputHelper output) : base(output)
         [Fact]
         public void TestWaitForConfirmsWithoutTimeout()
         {
-            TestWaitForConfirms(200, (ch) =>
+            TestWaitForConfirms(200, async (ch) =>
             {
-                Assert.True(ch.WaitForConfirmsAsync().GetAwaiter().GetResult());
+                Assert.True(await ch.WaitForConfirmsAsync());
             });
         }
 
         [Fact]
         public void TestWaitForConfirmsWithTimeout()
         {
-            TestWaitForConfirms(200, (ch) =>
+            TestWaitForConfirms(200, async (ch) =>
             {
                 using (var cts = new CancellationTokenSource(TimeSpan.FromSeconds(4)))
                 {
-                    Assert.True(ch.WaitForConfirmsAsync(cts.Token).GetAwaiter().GetResult());
+                    Assert.True(await ch.WaitForConfirmsAsync(cts.Token));
                 }
             });
         }
@@ -81,13 +81,13 @@ public void TestWaitForConfirmsWithTimeout_MightThrowTaskCanceledException()
             bool waitResult = false;
             bool sawTaskCanceled = false;
 
-            TestWaitForConfirms(10000, (ch) =>
+            TestWaitForConfirms(10000, async (ch) =>
             {
                 using (var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1)))
                 {
                     try
                     {
-                        waitResult = ch.WaitForConfirmsAsync(cts.Token).GetAwaiter().GetResult();
+                        waitResult = await ch.WaitForConfirmsAsync(cts.Token);
                     }
                     catch (TaskCanceledException)
                     {
@@ -105,7 +105,7 @@ public void TestWaitForConfirmsWithTimeout_MightThrowTaskCanceledException()
         [Fact]
         public void TestWaitForConfirmsWithTimeout_MessageNacked_WaitingHasTimedout_ReturnFalse()
         {
-            TestWaitForConfirms(2000, (ch) =>
+            TestWaitForConfirms(2000, async (ch) =>
             {
                 IChannel actualChannel = ((AutorecoveringChannel)ch).InnerChannel;
                 actualChannel
@@ -115,7 +115,7 @@ public void TestWaitForConfirmsWithTimeout_MessageNacked_WaitingHasTimedout_Retu
 
                 using (var cts = new CancellationTokenSource(TimeSpan.FromSeconds(4)))
                 {
-                    Assert.False(ch.WaitForConfirmsAsync(cts.Token).GetAwaiter().GetResult());
+                    Assert.False(await ch.WaitForConfirmsAsync(cts.Token));
                 }
             });
         }
@@ -142,7 +142,7 @@ public async Task TestWaitForConfirmsWithEvents()
                     {
                         ch.BasicPublish("", QueueName, _encoding.GetBytes("msg"));
                     }
-                    await ch.WaitForConfirmsAsync().ConfigureAwait(false);
+                    await ch.WaitForConfirmsAsync();
 
                     // Note: number of event invocations is not guaranteed
                     // to be equal to N because acks can be batched,
diff --git a/projects/Unit/Unit.csproj b/projects/Unit/Unit.csproj
@@ -20,15 +20,18 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
     <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
     <PackageReference Include="PublicApiGenerator" Version="11.0.0" />
-    <PackageReference Include="xunit" Version="2.5.0" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0" />
-    <PackageReference Include="Verify.Xunit" Version="20.8.0" />
+    <PackageReference Include="xunit" Version="2.5.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.1">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="Verify.Xunit" Version="22.1.3" />
     <PackageReference Include="Xunit.SkippableFact" Version="1.4.13" />
   </ItemGroup>
 

Original file line number	Diff line number	Diff line change
`@@ -130,8 +130,11 @@ public async Task TestBasicRoundtripConcurrent()`
`130`	`130`	`// ensure we get a delivery`
`131`	`131`	`await Task.WhenAll(publish1SyncSource.Task, publish2SyncSource.Task);`
`132`	`132`
`133`		`- Assert.True(publish1SyncSource.Task.Result, $"1 - Non concurrent dispatch lead to deadlock after {maximumWaitTime}");`
`134`		`- Assert.True(publish2SyncSource.Task.Result, $"2 - Non concurrent dispatch lead to deadlock after {maximumWaitTime}");`
	`133`	`+ bool result1 = await publish1SyncSource.Task;`
	`134`	`+ Assert.True(result1, $"1 - Non concurrent dispatch lead to deadlock after {maximumWaitTime}");`
	`135`	`+`
	`136`	`+ bool result2 = await publish2SyncSource.Task;`
	`137`	`+ Assert.True(result2, $"2 - Non concurrent dispatch lead to deadlock after {maximumWaitTime}");`
`135`	`138`	`}`
`136`	`139`	`}`
`137`	`140`	`}`
`@@ -158,7 +161,7 @@ public async Task TestBasicRoundtripConcurrentManyMessages()`
`158`	`161`	`}`
`159`	`162`	`}`
`160`	`163`
`161`		`- Task publishTask = Task.Run(() =>`
	`164`	`+ Task publishTask = Task.Run(async () =>`
`162`	`165`	`{`
`163`	`166`	`using (IConnection c = cf.CreateConnection())`
`164`	`167`	`{`
`@@ -167,14 +170,14 @@ public async Task TestBasicRoundtripConcurrentManyMessages()`
`167`	`170`	`QueueDeclareOk q = m.QueueDeclare(queue: queueName, exclusive: false, durable: true);`
`168`	`171`	`for (int i = 0; i < publish_total; i++)`
`169`	`172`	`{`
`170`		`- m.BasicPublish(string.Empty, queueName, body1);`
`171`		`- m.BasicPublish(string.Empty, queueName, body2);`
	`173`	`+ await m.BasicPublishAsync(string.Empty, queueName, body1);`
	`174`	`+ await m.BasicPublishAsync(string.Empty, queueName, body2);`
`172`	`175`	`}`
`173`	`176`	`}`
`174`	`177`	`}`
`175`	`178`	`});`
`176`	`179`
`177`		`- Task consumeTask = Task.Run(() =>`
	`180`	`+ Task consumeTask = Task.Run(async () =>`
`178`	`181`	`{`
`179`	`182`	`var publish1SyncSource = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);`
`180`	`183`	`var publish2SyncSource = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);`
`@@ -219,10 +222,13 @@ public async Task TestBasicRoundtripConcurrentManyMessages()`
`219`	`222`	`m.BasicConsume(queueName, true, consumer);`
`220`	`223`
`221`	`224`	`// ensure we get a delivery`
`222`		`- Task.WhenAll(publish1SyncSource.Task, publish2SyncSource.Task);`
	`225`	`+ await Task.WhenAll(publish1SyncSource.Task, publish2SyncSource.Task);`
	`226`	`+`
	`227`	`+ bool result1 = await publish1SyncSource.Task;`
	`228`	`+ Assert.True(result1, $"Non concurrent dispatch lead to deadlock after {maximumWaitTime}");`
`223`	`229`
`224`		`- Assert.True(publish1SyncSource.Task.Result, $"Non concurrent dispatch lead to deadlock after {maximumWaitTime}");`
`225`		`- Assert.True(publish2SyncSource.Task.Result, $"Non concurrent dispatch lead to deadlock after {maximumWaitTime}");`
	`230`	`+ bool result2 = await publish2SyncSource.Task;`
	`231`	`+ Assert.True(result2, $"Non concurrent dispatch lead to deadlock after {maximumWaitTime}");`
`226`	`232`	`}`
`227`	`233`	`}`
`228`	`234`	`});`
`@@ -262,7 +268,7 @@ public void TestBasicRoundtripNoWait()`
`262`	`268`	`}`
`263`	`269`
`264`	`270`	`[Fact]`
`265`		`- public void ConcurrentEventingTestForReceived()`
	`271`	`+ public async void ConcurrentEventingTestForReceived()`
`266`	`272`	`{`
`267`	`273`	`const int NumberOfThreads = 4;`
`268`	`274`	`const int NumberOfRegistrations = 5000;`
`@@ -300,7 +306,7 @@ public void ConcurrentEventingTestForReceived()`
`300`	`306`	`}`
`301`	`307`
`302`	`308`	`countdownEvent.Wait();`
`303`		`- Task.WaitAll(tasks);`
	`309`	`+ await Task.WhenAll(tasks);`
`304`	`310`
`305`	`311`	`// Add last receiver`
`306`	`312`	`var are = new AutoResetEvent(false);`
Original file line number	Diff line number	Diff line change
`@@ -74,11 +74,9 @@ public async Task TestBasicRoundtripConcurrent()`
`74`	`74`	`{`
`75`	`75`	`case publish1:`
`76`	`76`	`publish1SyncSource.TrySetResult(true);`
`77`		`- publish2SyncSource.Task.GetAwaiter().GetResult();`
`78`	`77`	`break;`
`79`	`78`	`case publish2:`
`80`	`79`	`publish2SyncSource.TrySetResult(true);`
`81`		`- publish1SyncSource.Task.GetAwaiter().GetResult();`
`82`	`80`	`break;`
`83`	`81`	`}`
`84`	`82`	`};`
`@@ -87,8 +85,11 @@ public async Task TestBasicRoundtripConcurrent()`
`87`	`85`
`88`	`86`	`await Task.WhenAll(publish1SyncSource.Task, publish2SyncSource.Task);`
`89`	`87`
`90`		`- Assert.True(publish1SyncSource.Task.Result, $"Non concurrent dispatch lead to deadlock after {maximumWaitTime}");`
`91`		`- Assert.True(publish2SyncSource.Task.Result, $"Non concurrent dispatch lead to deadlock after {maximumWaitTime}");`
	`88`	`+ bool result1 = await publish1SyncSource.Task;`
	`89`	`+ Assert.True(result1, $"Non concurrent dispatch lead to deadlock after {maximumWaitTime}");`
	`90`	`+`
	`91`	`+ bool result2 = await publish1SyncSource.Task;`
	`92`	`+ Assert.True(result2, $"Non concurrent dispatch lead to deadlock after {maximumWaitTime}");`
`92`	`93`	`}`
`93`	`94`	`}`
`94`	`95`	`}`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ public async Task TestConfirmBarrier()`
`50`	`50`	`{`
`51`	`51`	`_channel.BasicPublish("", string.Empty);`
`52`	`52`	`}`
`53`		`- Assert.True(await _channel.WaitForConfirmsAsync().ConfigureAwait(false));`
	`53`	`+ Assert.True(await _channel.WaitForConfirmsAsync());`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`[Fact]`
`@@ -73,12 +73,12 @@ public async Task TestExchangeBinding()`
`73`	`73`	`_channel.QueueBind(queue, "dest", string.Empty);`
`74`	`74`
`75`	`75`	`_channel.BasicPublish("src", string.Empty);`
`76`		`- await _channel.WaitForConfirmsAsync().ConfigureAwait(false);`
	`76`	`+ await _channel.WaitForConfirmsAsync();`
`77`	`77`	`Assert.NotNull(_channel.BasicGet(queue, true));`
`78`	`78`
`79`	`79`	`_channel.ExchangeUnbind("dest", "src", string.Empty);`
`80`	`80`	`_channel.BasicPublish("src", string.Empty);`
`81`		`- await _channel.WaitForConfirmsAsync().ConfigureAwait(false);`
	`81`	`+ await _channel.WaitForConfirmsAsync();`
`82`	`82`	`Assert.Null(_channel.BasicGet(queue, true));`
`83`	`83`
`84`	`84`	`_channel.ExchangeDelete("src");`
Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,7 @@ public async Task TestUnthrottledFloodPublishingAsync()`
`88`	`88`	`}`
`89`	`89`	`}`
`90`	`90`
`91`		`- await channel.BasicPublishAsync(CachedString.Empty, CachedString.Empty, _body).ConfigureAwait(false);`
	`91`	`+ await channel.BasicPublishAsync(CachedString.Empty, CachedString.Empty, _body);`
`92`	`92`	`}`
`93`	`93`	`}`
`94`	`94`	`finally`
`@@ -135,7 +135,7 @@ public async Task TestMultithreadFloodPublishingAsync()`
`135`	`135`	`{`
`136`	`136`	`for (int i = 0; i < publishCount; i++)`
`137`	`137`	`{`
`138`		`- await pubCh.BasicPublishAsync(string.Empty, queueName, sendBody).ConfigureAwait(false);`
	`138`	`+ await pubCh.BasicPublishAsync(string.Empty, queueName, sendBody);`
`139`	`139`	`}`
`140`	`140`	`}`
`141`	`141`	`});`
`@@ -154,11 +154,11 @@ public async Task TestMultithreadFloodPublishingAsync()`
`154`	`154`	`}`
`155`	`155`	`};`
`156`	`156`	`consumeCh.BasicConsume(queueName, true, consumer);`
`157`		`- Assert.True(pub.Wait(_tenSeconds));`
	`157`	`+`
`158`	`158`	`Assert.True(autoResetEvent.WaitOne(_tenSeconds));`
`159`	`159`	`}`
`160`	`160`
`161`		`- await pub.ConfigureAwait(false);`
	`161`	`+ await pub;`
`162`	`162`	`Assert.Equal(publishCount, receivedCount);`
`163`	`163`	`}`
`164`	`164`	`}`
Original file line number	Diff line number	Diff line change
`@@ -57,20 +57,20 @@ public TestPublisherConfirms(ITestOutputHelper output) : base(output)`
`57`	`57`	`[Fact]`
`58`	`58`	`public void TestWaitForConfirmsWithoutTimeout()`
`59`	`59`	`{`
`60`		`- TestWaitForConfirms(200, (ch) =>`
	`60`	`+ TestWaitForConfirms(200, async (ch) =>`
`61`	`61`	`{`
`62`		`- Assert.True(ch.WaitForConfirmsAsync().GetAwaiter().GetResult());`
	`62`	`+ Assert.True(await ch.WaitForConfirmsAsync());`
`63`	`63`	`});`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`[Fact]`
`67`	`67`	`public void TestWaitForConfirmsWithTimeout()`
`68`	`68`	`{`
`69`		`- TestWaitForConfirms(200, (ch) =>`
	`69`	`+ TestWaitForConfirms(200, async (ch) =>`
`70`	`70`	`{`
`71`	`71`	`using (var cts = new CancellationTokenSource(TimeSpan.FromSeconds(4)))`
`72`	`72`	`{`
`73`		`- Assert.True(ch.WaitForConfirmsAsync(cts.Token).GetAwaiter().GetResult());`
	`73`	`+ Assert.True(await ch.WaitForConfirmsAsync(cts.Token));`
`74`	`74`	`}`
`75`	`75`	`});`
`76`	`76`	`}`
`@@ -81,13 +81,13 @@ public void TestWaitForConfirmsWithTimeout_MightThrowTaskCanceledException()`
`81`	`81`	`bool waitResult = false;`
`82`	`82`	`bool sawTaskCanceled = false;`
`83`	`83`
`84`		`- TestWaitForConfirms(10000, (ch) =>`
	`84`	`+ TestWaitForConfirms(10000, async (ch) =>`
`85`	`85`	`{`
`86`	`86`	`using (var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(1)))`
`87`	`87`	`{`
`88`	`88`	`try`
`89`	`89`	`{`
`90`		`- waitResult = ch.WaitForConfirmsAsync(cts.Token).GetAwaiter().GetResult();`
	`90`	`+ waitResult = await ch.WaitForConfirmsAsync(cts.Token);`
`91`	`91`	`}`
`92`	`92`	`catch (TaskCanceledException)`
`93`	`93`	`{`
`@@ -105,7 +105,7 @@ public void TestWaitForConfirmsWithTimeout_MightThrowTaskCanceledException()`
`105`	`105`	`[Fact]`
`106`	`106`	`public void TestWaitForConfirmsWithTimeout_MessageNacked_WaitingHasTimedout_ReturnFalse()`
`107`	`107`	`{`
`108`		`- TestWaitForConfirms(2000, (ch) =>`
	`108`	`+ TestWaitForConfirms(2000, async (ch) =>`
`109`	`109`	`{`
`110`	`110`	`IChannel actualChannel = ((AutorecoveringChannel)ch).InnerChannel;`
`111`	`111`	`actualChannel`
`@@ -115,7 +115,7 @@ public void TestWaitForConfirmsWithTimeout_MessageNacked_WaitingHasTimedout_Retu`
`115`	`115`
`116`	`116`	`using (var cts = new CancellationTokenSource(TimeSpan.FromSeconds(4)))`
`117`	`117`	`{`
`118`		`- Assert.False(ch.WaitForConfirmsAsync(cts.Token).GetAwaiter().GetResult());`
	`118`	`+ Assert.False(await ch.WaitForConfirmsAsync(cts.Token));`
`119`	`119`	`}`
`120`	`120`	`});`
`121`	`121`	`}`
`@@ -142,7 +142,7 @@ public async Task TestWaitForConfirmsWithEvents()`
`142`	`142`	`{`
`143`	`143`	`ch.BasicPublish("", QueueName, _encoding.GetBytes("msg"));`
`144`	`144`	`}`
`145`		`- await ch.WaitForConfirmsAsync().ConfigureAwait(false);`
	`145`	`+ await ch.WaitForConfirmsAsync();`
`146`	`146`
`147`	`147`	`// Note: number of event invocations is not guaranteed`
`148`	`148`	`// to be equal to N because acks can be batched,`