xUnit update; remove xUnit warnings

bartelink · bartelink · commit 5cdcb14e9b74 · 2018-04-18T19:25:51.000+01:00
diff --git a/test/Serilog.Sinks.Async.PerformanceTests/Serilog.Sinks.Async.PerformanceTests.csproj b/test/Serilog.Sinks.Async.PerformanceTests/Serilog.Sinks.Async.PerformanceTests.csproj
@@ -18,8 +18,8 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.0.0" />
-    <PackageReference Include="xunit" Version="2.2.0" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />
+    <PackageReference Include="xunit" Version="2.3.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.1" />
     <PackageReference Include="BenchmarkDotNet" Version="0.10.6" />
     <PackageReference Include="Serilog.Sinks.File" Version="3.1.0" />
   </ItemGroup>
diff --git a/test/Serilog.Sinks.Async.Tests/BackgroundWorkerSinkIntegrationSpec.cs b/test/Serilog.Sinks.Async.Tests/BackgroundWorkerSinkIntegrationSpec.cs
@@ -130,7 +130,7 @@ public void WhenAuditSingle_ThenQueued()
 
                 var result = RetrieveEvents(_memorySink, 1);
 
-                Assert.Equal(1, result.Count);
+                Assert.Single(result);
             }
 
             [Fact]
diff --git a/test/Serilog.Sinks.Async.Tests/BackgroundWorkerSinkSpec.cs b/test/Serilog.Sinks.Async.Tests/BackgroundWorkerSinkSpec.cs
@@ -39,7 +39,7 @@ public async Task WhenEmitSingle_ThenRelaysToInnerSink()
 
                 await Task.Delay(TimeSpan.FromSeconds(3));
 
-                Assert.Equal(1, _innerSink.Events.Count);
+                Assert.Single(_innerSink.Events);
             }
         }
 
@@ -88,7 +88,7 @@ public async Task WhenQueueFull_ThenDropsEvents()
         {
             using (var sink = new BackgroundWorkerSink(_logger, 1, false))
             {
-                // Cause a delay when emmitting to the inner sink, allowing us to fill the queue to capacity 
+                // Cause a delay when emmitting to the inner sink, allowing us to fill the queue to capacity
                 // after the first event is popped
                 _innerSink.DelayEmit = TimeSpan.FromMilliseconds(300);
 
@@ -109,7 +109,7 @@ public async Task WhenQueueFull_ThenDropsEvents()
                     Assert.True(sw.ElapsedMilliseconds < 200, "Should not block the caller when the queue is full");
                 });
 
-                // If we *weren't* dropped events, the delay in the inner sink would mean the 5 events would take 
+                // If we *weren't* dropped events, the delay in the inner sink would mean the 5 events would take
                 // at least 15 seconds to process
                 await Task.Delay(TimeSpan.FromSeconds(2));
 
@@ -123,7 +123,7 @@ public async Task WhenQueueFull_ThenBlocks()
         {
             using (var sink = new BackgroundWorkerSink(_logger, 1, true))
             {
-                // Cause a delay when emmitting to the inner sink, allowing us to fill the queue to capacity 
+                // Cause a delay when emmitting to the inner sink, allowing us to fill the queue to capacity
                 // after the first event is popped
                 _innerSink.DelayEmit = TimeSpan.FromMilliseconds(300);
 
@@ -141,7 +141,7 @@ public async Task WhenQueueFull_ThenBlocks()
                     sink.Emit(e);
                     sw.Stop();
 
-                    // Emit should return immediately the first time, since the queue is not yet full. On 
+                    // Emit should return immediately the first time, since the queue is not yet full. On
                     // subsequent calls, the queue should be full, so we should be blocked
                     if (i > 0)
                     {
diff --git a/test/Serilog.Sinks.Async.Tests/BackgroundWorkerSinkTests.cs b/test/Serilog.Sinks.Async.Tests/BackgroundWorkerSinkTests.cs
@@ -32,7 +32,7 @@ public void DisposeCompletesWithoutWorkPerformed()
             {
             }
 
-            Assert.Equal(0, collector.Events.Count);
+            Assert.Empty(collector.Events);
         }
     }
 }
diff --git a/test/Serilog.Sinks.Async.Tests/Serilog.Sinks.Async.Tests.csproj b/test/Serilog.Sinks.Async.Tests/Serilog.Sinks.Async.Tests.csproj
@@ -15,8 +15,8 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.0.0" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />
-    <PackageReference Include="xunit" Version="2.2.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.1" />
+    <PackageReference Include="xunit" Version="2.3.1" />
   </ItemGroup>
 
   <ItemGroup>

Original file line number	Diff line number	Diff line change
`@@ -130,7 +130,7 @@ public void WhenAuditSingle_ThenQueued()`
`130`	`130`
`131`	`131`	`var result = RetrieveEvents(_memorySink, 1);`
`132`	`132`
`133`		`- Assert.Equal(1, result.Count);`
	`133`	`+ Assert.Single(result);`
`134`	`134`	`}`
`135`	`135`
`136`	`136`	`[Fact]`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ public async Task WhenEmitSingle_ThenRelaysToInnerSink()`
`39`	`39`
`40`	`40`	`await Task.Delay(TimeSpan.FromSeconds(3));`
`41`	`41`
`42`		`- Assert.Equal(1, _innerSink.Events.Count);`
	`42`	`+ Assert.Single(_innerSink.Events);`
`43`	`43`	`}`
`44`	`44`	`}`
`45`	`45`
`@@ -88,7 +88,7 @@ public async Task WhenQueueFull_ThenDropsEvents()`
`88`	`88`	`{`
`89`	`89`	`using (var sink = new BackgroundWorkerSink(_logger, 1, false))`
`90`	`90`	`{`
`91`		`- // Cause a delay when emmitting to the inner sink, allowing us to fill the queue to capacity`
	`91`	`+ // Cause a delay when emmitting to the inner sink, allowing us to fill the queue to capacity`
`92`	`92`	`// after the first event is popped`
`93`	`93`	`_innerSink.DelayEmit = TimeSpan.FromMilliseconds(300);`
`94`	`94`
`@@ -109,7 +109,7 @@ public async Task WhenQueueFull_ThenDropsEvents()`
`109`	`109`	`Assert.True(sw.ElapsedMilliseconds < 200, "Should not block the caller when the queue is full");`
`110`	`110`	`});`
`111`	`111`
`112`		`- // If we weren't dropped events, the delay in the inner sink would mean the 5 events would take`
	`112`	`+ // If we weren't dropped events, the delay in the inner sink would mean the 5 events would take`
`113`	`113`	`// at least 15 seconds to process`
`114`	`114`	`await Task.Delay(TimeSpan.FromSeconds(2));`
`115`	`115`
`@@ -123,7 +123,7 @@ public async Task WhenQueueFull_ThenBlocks()`
`123`	`123`	`{`
`124`	`124`	`using (var sink = new BackgroundWorkerSink(_logger, 1, true))`
`125`	`125`	`{`
`126`		`- // Cause a delay when emmitting to the inner sink, allowing us to fill the queue to capacity`
	`126`	`+ // Cause a delay when emmitting to the inner sink, allowing us to fill the queue to capacity`
`127`	`127`	`// after the first event is popped`
`128`	`128`	`_innerSink.DelayEmit = TimeSpan.FromMilliseconds(300);`
`129`	`129`
`@@ -141,7 +141,7 @@ public async Task WhenQueueFull_ThenBlocks()`
`141`	`141`	`sink.Emit(e);`
`142`	`142`	`sw.Stop();`
`143`	`143`
`144`		`- // Emit should return immediately the first time, since the queue is not yet full. On`
	`144`	`+ // Emit should return immediately the first time, since the queue is not yet full. On`
`145`	`145`	`// subsequent calls, the queue should be full, so we should be blocked`
`146`	`146`	`if (i > 0)`
`147`	`147`	`{`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ public void DisposeCompletesWithoutWorkPerformed()`
`32`	`32`	`{`
`33`	`33`	`}`
`34`	`34`
`35`		`- Assert.Equal(0, collector.Events.Count);`
	`35`	`+ Assert.Empty(collector.Events);`
`36`	`36`	`}`
`37`	`37`	`}`
`38`	`38`	`}`