Fix xUnit2013 by using Assert.Empty where appropriate

sharwell · sharwell · commit 54225ff9509b · 2017-11-05T10:21:22.000-06:00
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);
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test/HelperTests/ObjectPools/SharedPoolsTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test/HelperTests/ObjectPools/SharedPoolsTests.cs
@@ -71,7 +71,7 @@ public void TestStackPool()
                 Assert.NotEqual(0, collection.Count);
             }
 
-            Assert.Equal(0, collection.Count);
+            Assert.Empty(collection);
         }
 
         [Fact]
@@ -90,7 +90,7 @@ public void TestQueuePool()
                 Assert.NotEqual(0, collection.Count);
             }
 
-            Assert.Equal(0, collection.Count);
+            Assert.Empty(collection);
         }
 
         [Fact]
@@ -109,7 +109,7 @@ public void TestHashSetPool()
                 Assert.NotEqual(0, collection.Count);
             }
 
-            Assert.Equal(0, collection.Count);
+            Assert.Empty(collection);
         }
 
         [Fact]
@@ -128,7 +128,7 @@ public void TestDictionaryPool()
                 Assert.NotEqual(0, collection.Count);
             }
 
-            Assert.Equal(0, collection.Count);
+            Assert.Empty(collection);
         }
 
         [Fact]
@@ -147,7 +147,7 @@ public void TestListPool()
                 Assert.NotEqual(0, collection.Count);
             }
 
-            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/Settings/SettingsUnitTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test/Settings/SettingsUnitTests.cs
@@ -27,7 +27,7 @@ public void VerifySettingsDefaults()
             Assert.Equal("PlaceholderCompany", styleCopSettings.DocumentationRules.CompanyName);
             Assert.Equal("Copyright (c) PlaceholderCompany. All rights reserved.", styleCopSettings.DocumentationRules.GetCopyrightText("unused"));
             Assert.True(styleCopSettings.NamingRules.AllowCommonHungarianPrefixes);
-            Assert.Equal(0, styleCopSettings.NamingRules.AllowedHungarianPrefixes.Length);
+            Assert.Empty(styleCopSettings.NamingRules.AllowedHungarianPrefixes);
 
             Assert.NotNull(styleCopSettings.OrderingRules);
             Assert.Equal(UsingDirectivesPlacement.InsideNamespace, styleCopSettings.OrderingRules.UsingDirectivesPlacement);

Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ public void TestStackPool()`
`71`	`71`	`Assert.NotEqual(0, collection.Count);`
`72`	`72`	`}`
`73`	`73`
`74`		`- Assert.Equal(0, collection.Count);`
	`74`	`+ Assert.Empty(collection);`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`[Fact]`
`@@ -90,7 +90,7 @@ public void TestQueuePool()`
`90`	`90`	`Assert.NotEqual(0, collection.Count);`
`91`	`91`	`}`
`92`	`92`
`93`		`- Assert.Equal(0, collection.Count);`
	`93`	`+ Assert.Empty(collection);`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`[Fact]`
`@@ -109,7 +109,7 @@ public void TestHashSetPool()`
`109`	`109`	`Assert.NotEqual(0, collection.Count);`
`110`	`110`	`}`
`111`	`111`
`112`		`- Assert.Equal(0, collection.Count);`
	`112`	`+ Assert.Empty(collection);`
`113`	`113`	`}`
`114`	`114`
`115`	`115`	`[Fact]`
`@@ -128,7 +128,7 @@ public void TestDictionaryPool()`
`128`	`128`	`Assert.NotEqual(0, collection.Count);`
`129`	`129`	`}`
`130`	`130`
`131`		`- Assert.Equal(0, collection.Count);`
	`131`	`+ Assert.Empty(collection);`
`132`	`132`	`}`
`133`	`133`
`134`	`134`	`[Fact]`
`@@ -147,7 +147,7 @@ public void TestListPool()`
`147`	`147`	`Assert.NotEqual(0, collection.Count);`
`148`	`148`	`}`
`149`	`149`
`150`		`- Assert.Equal(0, collection.Count);`
	`150`	`+ Assert.Empty(collection);`
`151`	`151`	`}`
`152`	`152`
`153`	`153`	`[Fact]`
`@@ -182,17 +182,17 @@ public void TestClearAndFreeLarge()`
`182`	`182`	`// HashSet<int>`
`183`	`183`	`var set = new HashSet<int>(Enumerable.Range(0, 1024));`
`184`	`184`	`SharedPools.Default<HashSet<int>>().ClearAndFree(set);`
`185`		`- Assert.Equal(0, set.Count);`
	`185`	`+ Assert.Empty(set);`
`186`	`186`
`187`	`187`	`// Stack<int>`
`188`	`188`	`var stack = new Stack<int>(Enumerable.Range(0, 1024));`
`189`	`189`	`SharedPools.Default<Stack<int>>().ClearAndFree(stack);`
`190`		`- Assert.Equal(0, stack.Count);`
	`190`	`+ Assert.Empty(stack);`
`191`	`191`
`192`	`192`	`// Queue<int>`
`193`	`193`	`var queue = new Queue<int>(Enumerable.Range(0, 1024));`
`194`	`194`	`SharedPools.Default<Queue<int>>().ClearAndFree(queue);`
`195`		`- Assert.Equal(0, queue.Count);`
	`195`	`+ Assert.Empty(queue);`
`196`	`196`
`197`	`197`	`// Dictionary<int, int> This one doesn't go back in the pool!`
`198`	`198`	`var dictionary = Enumerable.Range(0, 1024).ToDictionary(i => i);`
`@@ -203,7 +203,7 @@ public void TestClearAndFreeLarge()`
`203`	`203`	`var list = new List<int>(Enumerable.Range(0, 1024));`
`204`	`204`	`Assert.True(list.Capacity >= 1024);`
`205`	`205`	`SharedPools.Default<List<int>>().ClearAndFree(list);`
`206`		`- Assert.Equal(0, list.Count);`
	`206`	`+ Assert.Empty(list);`
`207`	`207`	`Assert.True(list.Capacity < 1024);`
`208`	`208`	`}`
`209`	`209`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ public abstract class SeparatedSyntaxListWrapperTestBase`
`14`	`14`	`public void TestBasicProperties()`
`15`	`15`	`{`
`16`	`16`	`var list = this.CreateList();`
`17`		`- Assert.Equal(0, list.Count);`
	`17`	`+ Assert.Empty(list);`
`18`	`18`	`Assert.Equal(0, list.SeparatorCount);`
`19`	`19`	`Assert.Equal(default(SeparatedSyntaxList<SyntaxNode>).FullSpan, list.FullSpan);`
`20`	`20`	`Assert.Equal(default(SeparatedSyntaxList<SyntaxNode>).Span, list.Span);`
`@@ -26,7 +26,7 @@ public void TestBasicProperties()`
`26`	`26`	`{`
`27`	`27`	`Assert.IsAssignableFrom<SeparatedSyntaxList<SyntaxNode>>(list.UnderlyingList);`
`28`	`28`	`var underlyingList = (SeparatedSyntaxList<SyntaxNode>)list.UnderlyingList;`
`29`		`- Assert.Equal(0, list.Count);`
	`29`	`+ Assert.Empty(list);`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`