Merge pull request #2553 from sharwell/update-xunit

vweijsters · web-flow · commit 79abcc6a1955 · 2017-11-05T21:12:12.000+01:00
Update xunit to 2.3.0
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/IsPatternExpressionSyntaxWrapperTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/IsPatternExpressionSyntaxWrapperTests.cs
@@ -49,7 +49,7 @@ public void TestProperties()
             var newIsKeyword = SyntaxFactory.Token(SyntaxKind.IsKeyword).WithLeadingTrivia(SyntaxFactory.Space);
             var modifiedIsKeyword = isPatternExpressionSyntax.WithIsKeyword(newIsKeyword);
             Assert.NotNull(modifiedIsKeyword.SyntaxNode);
-            Assert.Equal(1, modifiedIsKeyword.IsKeyword.LeadingTrivia.Count);
+            Assert.Single(modifiedIsKeyword.IsKeyword.LeadingTrivia);
             Assert.Equal(" ", modifiedIsKeyword.IsKeyword.LeadingTrivia.ToString());
 
             var newPattern = SyntaxFactory.ConstantPattern(newExpression);
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/LocalFunctionStatementSyntaxWrapperTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/LocalFunctionStatementSyntaxWrapperTests.cs
@@ -67,7 +67,7 @@ public void TestProperties()
             var wrapperWithModifiedModifiers = wrapper.WithModifiers(newModifiers);
             Assert.NotNull(wrapperWithModifiedModifiers.SyntaxNode);
             Assert.NotEqual(syntaxNode.Modifiers, wrapperWithModifiedModifiers.Modifiers);
-            Assert.Equal(0, wrapperWithModifiedModifiers.Modifiers.Count);
+            Assert.Empty(wrapperWithModifiedModifiers.Modifiers);
 
             var newReturnType = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.BoolKeyword));
             var wrapperWithModifiedReturnType = wrapper.WithReturnType(newReturnType);
@@ -86,25 +86,25 @@ public void TestProperties()
             var wrapperWithModifiedTypeParameterList = wrapper.WithTypeParameterList(newTypeParameterList);
             Assert.NotNull(wrapperWithModifiedTypeParameterList.SyntaxNode);
             Assert.NotSame(syntaxNode.TypeParameterList, wrapperWithModifiedTypeParameterList.TypeParameterList);
-            Assert.Equal(0, wrapperWithModifiedTypeParameterList.TypeParameterList.Parameters.Count);
+            Assert.Empty(wrapperWithModifiedTypeParameterList.TypeParameterList.Parameters);
 
             var newParameterList = SyntaxFactory.ParameterList();
             var wrapperWithModifiedParameterList = wrapper.WithParameterList(newParameterList);
             Assert.NotNull(wrapperWithModifiedParameterList.SyntaxNode);
             Assert.NotSame(syntaxNode.ParameterList, wrapperWithModifiedParameterList.ParameterList);
-            Assert.Equal(0, wrapperWithModifiedParameterList.ParameterList.Parameters.Count);
+            Assert.Empty(wrapperWithModifiedParameterList.ParameterList.Parameters);
 
             var newConstraintClauses = SyntaxFactory.List<TypeParameterConstraintClauseSyntax>();
             var wrapperWithModifiedConstraintClauses = wrapper.WithConstraintClauses(newConstraintClauses);
             Assert.NotNull(wrapperWithModifiedConstraintClauses.SyntaxNode);
             Assert.NotEqual(syntaxNode.ConstraintClauses, wrapperWithModifiedConstraintClauses.ConstraintClauses);
-            Assert.Equal(0, wrapperWithModifiedConstraintClauses.ConstraintClauses.Count);
+            Assert.Empty(wrapperWithModifiedConstraintClauses.ConstraintClauses);
 
             var newBody = SyntaxFactory.Block();
             var wrapperWithModifiedBody = wrapper.WithBody(newBody);
             Assert.NotNull(wrapperWithModifiedBody.SyntaxNode);
             Assert.Equal(SyntaxKind.Block, wrapperWithModifiedBody.Body.Kind());
-            Assert.Equal(0, wrapperWithModifiedBody.Body.Statements.Count);
+            Assert.Empty(wrapperWithModifiedBody.Body.Statements);
 
             var newExpressionBody = SyntaxFactory.ArrowExpressionClause(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression));
             var wrapperWithModifiedExpressionBody = wrapper.WithExpressionBody(newExpressionBody);
@@ -115,7 +115,7 @@ public void TestProperties()
             var newSemicolonToken = SyntaxFactory.Token(SyntaxKind.SemicolonToken).WithLeadingTrivia(SyntaxFactory.Space);
             var wrapperWithModifiedSemicolonToken = wrapper.WithSemicolonToken(newSemicolonToken);
             Assert.NotNull(wrapperWithModifiedSemicolonToken.SyntaxNode);
-            Assert.Equal(1, wrapperWithModifiedSemicolonToken.SemicolonToken.LeadingTrivia.Count);
+            Assert.Single(wrapperWithModifiedSemicolonToken.SemicolonToken.LeadingTrivia);
             Assert.Equal(" ", wrapperWithModifiedSemicolonToken.SemicolonToken.LeadingTrivia.ToString());
 
             var addedModifiers = new SyntaxToken[] { SyntaxFactory.Token(SyntaxKind.AsyncKeyword) };
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/RefExpressionSyntaxWrapperTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/RefExpressionSyntaxWrapperTests.cs
@@ -45,7 +45,7 @@ public void TestProperties()
             var newRefKeyword = SyntaxFactory.Token(SyntaxKind.RefKeyword).WithLeadingTrivia(SyntaxFactory.Space);
             var wrapperWithModifiedRefKeyword = wrapper.WithRefKeyword(newRefKeyword);
             Assert.NotNull(wrapperWithModifiedRefKeyword.SyntaxNode);
-            Assert.Equal(1, wrapperWithModifiedRefKeyword.RefKeyword.LeadingTrivia.Count);
+            Assert.Single(wrapperWithModifiedRefKeyword.RefKeyword.LeadingTrivia);
             Assert.Equal(" ", wrapperWithModifiedRefKeyword.RefKeyword.LeadingTrivia.ToString());
         }
 
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/RefTypeSyntaxWrapperTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/RefTypeSyntaxWrapperTests.cs
@@ -45,7 +45,7 @@ public void TestProperties()
             var newRefKeyword = SyntaxFactory.Token(SyntaxKind.RefKeyword).WithLeadingTrivia(SyntaxFactory.Space);
             var wrapperWithModifiedRefKeyword = wrapper.WithRefKeyword(newRefKeyword);
             Assert.NotNull(wrapperWithModifiedRefKeyword.SyntaxNode);
-            Assert.Equal(1, wrapperWithModifiedRefKeyword.RefKeyword.LeadingTrivia.Count);
+            Assert.Single(wrapperWithModifiedRefKeyword.RefKeyword.LeadingTrivia);
             Assert.Equal(" ", wrapperWithModifiedRefKeyword.RefKeyword.LeadingTrivia.ToString());
         }
 
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/ThrowExpressionSyntaxWrapperTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/ThrowExpressionSyntaxWrapperTests.cs
@@ -45,7 +45,7 @@ public void TestProperties()
             var newThrowKeyword = SyntaxFactory.Token(SyntaxKind.ThrowKeyword).WithLeadingTrivia(SyntaxFactory.Space);
             var modifiedThrowKeyword = throwExpressionSyntax.WithThrowKeyword(newThrowKeyword);
             Assert.NotNull(modifiedThrowKeyword.SyntaxNode);
-            Assert.Equal(1, modifiedThrowKeyword.ThrowKeyword.LeadingTrivia.Count);
+            Assert.Single(modifiedThrowKeyword.ThrowKeyword.LeadingTrivia);
             Assert.Equal(" ", modifiedThrowKeyword.ThrowKeyword.LeadingTrivia.ToString());
         }
 
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/TupleElementSyntaxWrapperTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/TupleElementSyntaxWrapperTests.cs
@@ -46,7 +46,7 @@ public void TestProperties()
             var newIdentifier = SyntaxFactory.Identifier("y").WithLeadingTrivia(SyntaxFactory.Space);
             var wrapperWithModifiedIdentifier = wrapper.WithIdentifier(newIdentifier);
             Assert.NotNull(wrapperWithModifiedIdentifier.SyntaxNode);
-            Assert.Equal(1, wrapperWithModifiedIdentifier.Identifier.LeadingTrivia.Count);
+            Assert.Single(wrapperWithModifiedIdentifier.Identifier.LeadingTrivia);
             Assert.Equal(" ", wrapperWithModifiedIdentifier.Identifier.LeadingTrivia.ToString());
         }
 
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/TupleExpressionSyntaxWrapperTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/TupleExpressionSyntaxWrapperTests.cs
@@ -47,7 +47,7 @@ public void TestProperties()
             var newOpenParenToken = SyntaxFactory.Token(SyntaxKind.OpenParenToken).WithLeadingTrivia(SyntaxFactory.Space);
             var wrapperWithModifiedOpenParenToken = wrapper.WithOpenParenToken(newOpenParenToken);
             Assert.NotNull(wrapperWithModifiedOpenParenToken.SyntaxNode);
-            Assert.Equal(1, wrapperWithModifiedOpenParenToken.OpenParenToken.LeadingTrivia.Count);
+            Assert.Single(wrapperWithModifiedOpenParenToken.OpenParenToken.LeadingTrivia);
             Assert.Equal(" ", wrapperWithModifiedOpenParenToken.OpenParenToken.LeadingTrivia.ToString());
 
             var newArguments = wrapper.Arguments.Replace(wrapper.Arguments[0], SyntaxFactory.Argument(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));
@@ -65,7 +65,7 @@ public void TestProperties()
             var newCloseParenToken = SyntaxFactory.Token(SyntaxKind.CloseParenToken).WithLeadingTrivia(SyntaxFactory.Space);
             var wrapperWithModifiedCloseParenToken = wrapper.WithCloseParenToken(newCloseParenToken);
             Assert.NotNull(wrapperWithModifiedCloseParenToken.SyntaxNode);
-            Assert.Equal(1, wrapperWithModifiedCloseParenToken.CloseParenToken.LeadingTrivia.Count);
+            Assert.Single(wrapperWithModifiedCloseParenToken.CloseParenToken.LeadingTrivia);
             Assert.Equal(" ", wrapperWithModifiedCloseParenToken.CloseParenToken.LeadingTrivia.ToString());
         }
 
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/TupleTypeSyntaxWrapperTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/TupleTypeSyntaxWrapperTests.cs
@@ -44,7 +44,7 @@ public void TestProperties()
             var newOpenParenToken = SyntaxFactory.Token(SyntaxKind.OpenParenToken).WithLeadingTrivia(SyntaxFactory.Space);
             var wrapperWithModifiedOpenParenToken = wrapper.WithOpenParenToken(newOpenParenToken);
             Assert.NotNull(wrapperWithModifiedOpenParenToken.SyntaxNode);
-            Assert.Equal(1, wrapperWithModifiedOpenParenToken.OpenParenToken.LeadingTrivia.Count);
+            Assert.Single(wrapperWithModifiedOpenParenToken.OpenParenToken.LeadingTrivia);
             Assert.Equal(" ", wrapperWithModifiedOpenParenToken.OpenParenToken.LeadingTrivia.ToString());
 
             var newElements = wrapper.Elements.Replace(wrapper.Elements[0], (TupleElementSyntaxWrapper)SyntaxFactory.TupleElement(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.StringKeyword))));
@@ -62,7 +62,7 @@ public void TestProperties()
             var newCloseParenToken = SyntaxFactory.Token(SyntaxKind.CloseParenToken).WithLeadingTrivia(SyntaxFactory.Space);
             var wrapperWithModifiedCloseParenToken = wrapper.WithCloseParenToken(newCloseParenToken);
             Assert.NotNull(wrapperWithModifiedCloseParenToken.SyntaxNode);
-            Assert.Equal(1, wrapperWithModifiedCloseParenToken.CloseParenToken.LeadingTrivia.Count);
+            Assert.Single(wrapperWithModifiedCloseParenToken.CloseParenToken.LeadingTrivia);
             Assert.Equal(" ", wrapperWithModifiedCloseParenToken.CloseParenToken.LeadingTrivia.ToString());
         }
 
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/WhenClauseSyntaxWrapperTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/WhenClauseSyntaxWrapperTests.cs
@@ -45,7 +45,7 @@ public void TestProperties()
             var newWhenKeyword = SyntaxFactory.Token(SyntaxKind.WhenKeyword).WithLeadingTrivia(SyntaxFactory.Space);
             var wrapperWithModifiedWhenKeyword = wrapper.WithWhenKeyword(newWhenKeyword);
             Assert.NotNull(wrapperWithModifiedWhenKeyword.SyntaxNode);
-            Assert.Equal(1, wrapperWithModifiedWhenKeyword.WhenKeyword.LeadingTrivia.Count);
+            Assert.Single(wrapperWithModifiedWhenKeyword.WhenKeyword.LeadingTrivia);
             Assert.Equal(" ", wrapperWithModifiedWhenKeyword.WhenKeyword.LeadingTrivia.ToString());
         }
 
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/StyleCop.Analyzers.Test.CSharp7.csproj b/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/StyleCop.Analyzers.Test.CSharp7.csproj
@@ -16,8 +16,8 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.CodeAnalysis" Version="2.1.0" />
-    <PackageReference Include="xunit" Version="2.3.0-beta3-build3705" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.0-beta5-build3769" PrivateAssets="all" />
+    <PackageReference Include="xunit" Version="2.3.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.0" PrivateAssets="all" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test/DocumentationRules/SA1603UnitTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test/DocumentationRules/SA1603UnitTests.cs
@@ -20,7 +20,7 @@ public class SA1603UnitTests : DiagnosticVerifier
         public void TestDisabledByDefaultAndNotConfigurable()
         {
             var analyzer = this.GetCSharpDiagnosticAnalyzers().Single();
-            Assert.Equal(1, analyzer.SupportedDiagnostics.Length);
+            Assert.Single(analyzer.SupportedDiagnostics);
             Assert.False(analyzer.SupportedDiagnostics[0].IsEnabledByDefault);
             Assert.Contains(WellKnownDiagnosticTags.NotConfigurable, analyzer.SupportedDiagnostics[0].CustomTags);
         }
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test/DocumentationRules/SA1628UnitTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test/DocumentationRules/SA1628UnitTests.cs
@@ -20,7 +20,7 @@ public class SA1628UnitTests : DiagnosticVerifier
         public void TestDisabledByDefaultAndNotConfigurable()
         {
             var analyzer = this.GetCSharpDiagnosticAnalyzers().Single();
-            Assert.Equal(1, analyzer.SupportedDiagnostics.Length);
+            Assert.Single(analyzer.SupportedDiagnostics);
             Assert.False(analyzer.SupportedDiagnostics[0].IsEnabledByDefault);
             Assert.Contains(WellKnownDiagnosticTags.NotConfigurable, analyzer.SupportedDiagnostics[0].CustomTags);
         }
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test/DocumentationRules/SA1630UnitTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test/DocumentationRules/SA1630UnitTests.cs
@@ -20,7 +20,7 @@ public class SA1630UnitTests : DiagnosticVerifier
         public void TestDisabledByDefaultAndNotConfigurable()
         {
             var analyzer = this.GetCSharpDiagnosticAnalyzers().Single();
-            Assert.Equal(1, analyzer.SupportedDiagnostics.Length);
+            Assert.Single(analyzer.SupportedDiagnostics);
             Assert.False(analyzer.SupportedDiagnostics[0].IsEnabledByDefault);
             Assert.Contains(WellKnownDiagnosticTags.NotConfigurable, analyzer.SupportedDiagnostics[0].CustomTags);
         }
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test/DocumentationRules/SA1631UnitTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test/DocumentationRules/SA1631UnitTests.cs
@@ -20,7 +20,7 @@ public class SA1631UnitTests : DiagnosticVerifier
         public void TestDisabledByDefaultAndNotConfigurable()
         {
             var analyzer = this.GetCSharpDiagnosticAnalyzers().Single();
-            Assert.Equal(1, analyzer.SupportedDiagnostics.Length);
+            Assert.Single(analyzer.SupportedDiagnostics);
             Assert.False(analyzer.SupportedDiagnostics[0].IsEnabledByDefault);
             Assert.Contains(WellKnownDiagnosticTags.NotConfigurable, analyzer.SupportedDiagnostics[0].CustomTags);
         }
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test/DocumentationRules/SA1632UnitTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test/DocumentationRules/SA1632UnitTests.cs
@@ -20,7 +20,7 @@ public class SA1632UnitTests : DiagnosticVerifier
         public void TestDisabledByDefaultAndNotConfigurable()
         {
             var analyzer = this.GetCSharpDiagnosticAnalyzers().Single();
-            Assert.Equal(1, analyzer.SupportedDiagnostics.Length);
+            Assert.Single(analyzer.SupportedDiagnostics);
             Assert.False(analyzer.SupportedDiagnostics[0].IsEnabledByDefault);
             Assert.Contains(WellKnownDiagnosticTags.NotConfigurable, analyzer.SupportedDiagnostics[0].CustomTags);
         }
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test/DocumentationRules/SA1645UnitTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test/DocumentationRules/SA1645UnitTests.cs
@@ -20,7 +20,7 @@ public class SA1645UnitTests : DiagnosticVerifier
         public void TestDisabledByDefaultAndNotConfigurable()
         {
             var analyzer = this.GetCSharpDiagnosticAnalyzers().Single();
-            Assert.Equal(1, analyzer.SupportedDiagnostics.Length);
+            Assert.Single(analyzer.SupportedDiagnostics);
             Assert.False(analyzer.SupportedDiagnostics[0].IsEnabledByDefault);
             Assert.Contains(WellKnownDiagnosticTags.NotConfigurable, analyzer.SupportedDiagnostics[0].CustomTags);
         }
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test/DocumentationRules/SA1646UnitTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test/DocumentationRules/SA1646UnitTests.cs
@@ -20,7 +20,7 @@ public class SA1646UnitTests : DiagnosticVerifier
         public void TestDisabledByDefaultAndNotConfigurable()
         {
             var analyzer = this.GetCSharpDiagnosticAnalyzers().Single();
-            Assert.Equal(1, analyzer.SupportedDiagnostics.Length);
+            Assert.Single(analyzer.SupportedDiagnostics);
             Assert.False(analyzer.SupportedDiagnostics[0].IsEnabledByDefault);
             Assert.Contains(WellKnownDiagnosticTags.NotConfigurable, analyzer.SupportedDiagnostics[0].CustomTags);
         }
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test/DocumentationRules/SA1647UnitTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test/DocumentationRules/SA1647UnitTests.cs
@@ -20,7 +20,7 @@ public class SA1647UnitTests : DiagnosticVerifier
         public void TestDisabledByDefaultAndNotConfigurable()
         {
             var analyzer = this.GetCSharpDiagnosticAnalyzers().Single();
-            Assert.Equal(1, analyzer.SupportedDiagnostics.Length);
+            Assert.Single(analyzer.SupportedDiagnostics);
             Assert.False(analyzer.SupportedDiagnostics[0].IsEnabledByDefault);
             Assert.Contains(WellKnownDiagnosticTags.NotConfigurable, analyzer.SupportedDiagnostics[0].CustomTags);
         }
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test/DocumentationRules/SA1650UnitTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test/DocumentationRules/SA1650UnitTests.cs
@@ -20,7 +20,7 @@ public class SA1650UnitTests : DiagnosticVerifier
         public void TestDisabledByDefaultAndNotConfigurable()
         {
             var analyzer = this.GetCSharpDiagnosticAnalyzers().Single();
-            Assert.Equal(1, analyzer.SupportedDiagnostics.Length);
+            Assert.Single(analyzer.SupportedDiagnostics);
             Assert.False(analyzer.SupportedDiagnostics[0].IsEnabledByDefault);
             Assert.Contains(WellKnownDiagnosticTags.NotConfigurable, analyzer.SupportedDiagnostics[0].CustomTags);
         }
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test/ExportCodeFixProviderAttributeNameTest.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test/ExportCodeFixProviderAttributeNameTest.cs
@@ -43,7 +43,7 @@ public void TestExportCodeFixProviderAttribute(Type codeFixProvider)
 
             Assert.NotNull(exportCodeFixProviderAttribute);
             Assert.Equal(codeFixProvider.Name, exportCodeFixProviderAttribute.Name);
-            Assert.Equal(1, exportCodeFixProviderAttribute.Languages.Length);
+            Assert.Single(exportCodeFixProviderAttribute.Languages);
             Assert.Equal(LanguageNames.CSharp, exportCodeFixProviderAttribute.Languages[0]);
         }
     }
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test/HelperTests/ObjectPools/SharedPoolsTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test/HelperTests/ObjectPools/SharedPoolsTests.cs
@@ -68,10 +68,10 @@ public void TestStackPool()
 
                 // Keep a copy to verify its length is reset
                 collection = obj.Object;
-                Assert.NotEqual(0, collection.Count);
+                Assert.NotEmpty(collection);
             }
 
-            Assert.Equal(0, collection.Count);
+            Assert.Empty(collection);
         }
 
         [Fact]
@@ -87,10 +87,10 @@ public void TestQueuePool()
 
                 // Keep a copy to verify its length is reset
                 collection = obj.Object;
-                Assert.NotEqual(0, collection.Count);
+                Assert.NotEmpty(collection);
             }
 
-            Assert.Equal(0, collection.Count);
+            Assert.Empty(collection);
         }
 
         [Fact]
@@ -106,10 +106,10 @@ public void TestHashSetPool()
 
                 // Keep a copy to verify its length is reset
                 collection = obj.Object;
-                Assert.NotEqual(0, collection.Count);
+                Assert.NotEmpty(collection);
             }
 
-            Assert.Equal(0, collection.Count);
+            Assert.Empty(collection);
         }
 
         [Fact]
@@ -125,10 +125,10 @@ public void TestDictionaryPool()
 
                 // Keep a copy to verify its length is reset
                 collection = obj.Object;
-                Assert.NotEqual(0, collection.Count);
+                Assert.NotEmpty(collection);
             }
 
-            Assert.Equal(0, collection.Count);
+            Assert.Empty(collection);
         }
 
         [Fact]
@@ -144,10 +144,10 @@ public void TestListPool()
 
                 // Keep a copy to verify its length is reset
                 collection = obj.Object;
-                Assert.NotEqual(0, collection.Count);
+                Assert.NotEmpty(collection);
             }
 
-            Assert.Equal(0, collection.Count);
+            Assert.Empty(collection);
         }
 
         [Fact]
@@ -182,17 +182,17 @@ public void TestClearAndFreeLarge()
             // HashSet<int>
             var set = new HashSet<int>(Enumerable.Range(0, 1024));
             SharedPools.Default<HashSet<int>>().ClearAndFree(set);
-            Assert.Equal(0, set.Count);
+            Assert.Empty(set);
 
             // Stack<int>
             var stack = new Stack<int>(Enumerable.Range(0, 1024));
             SharedPools.Default<Stack<int>>().ClearAndFree(stack);
-            Assert.Equal(0, stack.Count);
+            Assert.Empty(stack);
 
             // Queue<int>
             var queue = new Queue<int>(Enumerable.Range(0, 1024));
             SharedPools.Default<Queue<int>>().ClearAndFree(queue);
-            Assert.Equal(0, queue.Count);
+            Assert.Empty(queue);
 
             // Dictionary<int, int> **This one doesn't go back in the pool!**
             var dictionary = Enumerable.Range(0, 1024).ToDictionary(i => i);
@@ -203,7 +203,7 @@ public void TestClearAndFreeLarge()
             var list = new List<int>(Enumerable.Range(0, 1024));
             Assert.True(list.Capacity >= 1024);
             SharedPools.Default<List<int>>().ClearAndFree(list);
-            Assert.Equal(0, list.Count);
+            Assert.Empty(list);
             Assert.True(list.Capacity < 1024);
         }
 
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test/Lightup/SeparatedSyntaxListWrapperTestBase.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test/Lightup/SeparatedSyntaxListWrapperTestBase.cs
@@ -14,7 +14,7 @@ public abstract class SeparatedSyntaxListWrapperTestBase
         public void TestBasicProperties()
         {
             var list = this.CreateList();
-            Assert.Equal(0, list.Count);
+            Assert.Empty(list);
             Assert.Equal(0, list.SeparatorCount);
             Assert.Equal(default(SeparatedSyntaxList<SyntaxNode>).FullSpan, list.FullSpan);
             Assert.Equal(default(SeparatedSyntaxList<SyntaxNode>).Span, list.Span);
@@ -26,7 +26,7 @@ public void TestBasicProperties()
             {
                 Assert.IsAssignableFrom<SeparatedSyntaxList<SyntaxNode>>(list.UnderlyingList);
                 var underlyingList = (SeparatedSyntaxList<SyntaxNode>)list.UnderlyingList;
-                Assert.Equal(0, list.Count);
+                Assert.Empty(list);
             }
         }
 
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test/MaintainabilityRules/SA1409UnitTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test/MaintainabilityRules/SA1409UnitTests.cs
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test/NamingRules/SA1301UnitTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test/NamingRules/SA1301UnitTests.cs
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test/ReadabilityRules/SA1109UnitTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test/ReadabilityRules/SA1109UnitTests.cs
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test/ReadabilityRules/SA1116UnitTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test/ReadabilityRules/SA1116UnitTests.cs
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test/ReadabilityRules/SA1117UnitTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test/ReadabilityRules/SA1117UnitTests.cs
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test/ReadabilityRules/SA1121UnitTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test/ReadabilityRules/SA1121UnitTests.cs
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test/ReadabilityRules/SA1126UnitTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test/ReadabilityRules/SA1126UnitTests.cs
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test/Settings/SettingsFileCodeFixProviderUnitTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test/Settings/SettingsFileCodeFixProviderUnitTests.cs
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test/Settings/SettingsUnitTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test/Settings/SettingsUnitTests.cs
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test/StyleCop.Analyzers.Test.csproj b/StyleCop.Analyzers/StyleCop.Analyzers.Test/StyleCop.Analyzers.Test.csproj
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SeparatedSyntaxListWrapper`1.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SeparatedSyntaxListWrapper`1.cs

Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ public void TestProperties()`
`45`	`45`	`var newRefKeyword = SyntaxFactory.Token(SyntaxKind.RefKeyword).WithLeadingTrivia(SyntaxFactory.Space);`
`46`	`46`	`var wrapperWithModifiedRefKeyword = wrapper.WithRefKeyword(newRefKeyword);`
`47`	`47`	`Assert.NotNull(wrapperWithModifiedRefKeyword.SyntaxNode);`
`48`		`- Assert.Equal(1, wrapperWithModifiedRefKeyword.RefKeyword.LeadingTrivia.Count);`
	`48`	`+ Assert.Single(wrapperWithModifiedRefKeyword.RefKeyword.LeadingTrivia);`
`49`	`49`	`Assert.Equal(" ", wrapperWithModifiedRefKeyword.RefKeyword.LeadingTrivia.ToString());`
`50`	`50`	`}`
`51`	`51`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ public void TestProperties()`
`46`	`46`	`var newIdentifier = SyntaxFactory.Identifier("y").WithLeadingTrivia(SyntaxFactory.Space);`
`47`	`47`	`var wrapperWithModifiedIdentifier = wrapper.WithIdentifier(newIdentifier);`
`48`	`48`	`Assert.NotNull(wrapperWithModifiedIdentifier.SyntaxNode);`
`49`		`- Assert.Equal(1, wrapperWithModifiedIdentifier.Identifier.LeadingTrivia.Count);`
	`49`	`+ Assert.Single(wrapperWithModifiedIdentifier.Identifier.LeadingTrivia);`
`50`	`50`	`Assert.Equal(" ", wrapperWithModifiedIdentifier.Identifier.LeadingTrivia.ToString());`
`51`	`51`	`}`
`52`	`52`