Merge pull request #62 from YingP99/assertrule

Add new rule to convert Test Assert.True or False with redundant conditi...

Author: YingP99

src/Microsoft.DotNet.CodeFormatting.Tests/Microsoft.DotNet.CodeFormatting.Tests.csproj

@@ -114,6 +114,7 @@
     <Compile Include="Rules\HasNewLineBeforeFirstUsingFormattingRuleTests.cs" />
     <Compile Include="Rules\PrivateFieldNamingRuleTests.cs" />
     <Compile Include="Rules\NonAsciiCharactersAreEscapedInLiteralsRuleTests.cs" />
+    <Compile Include="Rules\TestAssertTrueOrFalseRuleTests.cs" />
     <Compile Include="Rules\UsesXunitForTestsFormattingRuleTests.cs" />
   </ItemGroup>
   <ItemGroup>

src/Microsoft.DotNet.CodeFormatting.Tests/Rules/TestAssertTrueOrFalseRuleTests.cs

@@ -0,0 +1,201 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Xunit;
+
+namespace Microsoft.DotNet.CodeFormatting.Tests
+{
+    public class TestAssertTrueOrFalseRuleTests : SyntaxRuleTestBase
+    {
+        internal override ISyntaxFormattingRule Rule
+        {
+            get { return new Rules.TestAssertTrueOrFalseRule(); }
+        }
+
+        [Fact]
+        public void TestAssertEqualNotEqual()
+        {
+            var text = @"
+using System;
+using Xunit;
+
+namespace System.UnitTests
+{
+    public class Testing
+    {
+        [Fact]
+        public void MyTest()
+        {
+            int x1 = 123, x2 = 456;
+            Assert.True(x1 == x2);
+            Assert.True(x2 != x1, ""Message"");
+
+            Assert.False(x2 == x1, ""Message"");
+            Assert.False(x1 != x2);
+        }
+    }
+}
+";
+
+            var expected = @"
+using System;
+using Xunit;
+
+namespace System.UnitTests
+{
+    public class Testing
+    {
+        [Fact]
+        public void MyTest()
+        {
+            int x1 = 123, x2 = 456;
+            Assert.Equal(x1, x2);
+            Assert.NotEqual(x2, x1);
+
+            Assert.NotEqual(x2, x1);
+            Assert.Equal(x1, x2);
+        }
+    }
+}
+";
+            Verify(text, expected);
+        }
+
+        [Fact]
+        public void TestAssertEqualNotEqualNull()
+        {
+            var text = @"
+using System;
+using Xunit;
+
+public class Testing
+{
+    [Fact]
+    public void MyTest()
+    {
+        string s1 = ""A"", s2 = null;
+        Assert.True(s1 == null);
+        Assert.True(null != s2, ""Message"");
+
+        Assert.False(null == s1, ""Message"");
+        Assert.False(s2 != null);
+    }
+}
+";
+
+            var expected = @"
+using System;
+using Xunit;
+
+public class Testing
+{
+    [Fact]
+    public void MyTest()
+    {
+        string s1 = ""A"", s2 = null;
+        Assert.Null(s1);
+        Assert.NotNull(s2);
+
+        Assert.NotNull(s1);
+        Assert.Null(s2);
+    }
+}
+";
+            Verify(text, expected);
+        }
+
+        [Fact]
+        public void TestAssertEqualNotEqualTrueOrFalse()
+        {
+            var text = @"
+using System;
+using Xunit;
+
+public class Testing
+{
+    [Fact]
+    public void MyTest()
+    {
+        bool b1 = true, b2 = false;
+        Assert.True(b1 == true);
+        Assert.True(true != b2);
+        Assert.True(b2 == false);
+        Assert.True(false != b1);
+
+        Assert.False(b1 == true);
+        Assert.False(true != b2);
+        Assert.False(b2 == false);
+        Assert.False(false != b1);
+    }
+}
+";
+
+            var expected = @"
+using System;
+using Xunit;
+
+public class Testing
+{
+    [Fact]
+    public void MyTest()
+    {
+        bool b1 = true, b2 = false;
+        Assert.True(b1);
+        Assert.False(b2);
+        Assert.False(b2);
+        Assert.True(b1);
+
+        Assert.False(b1);
+        Assert.True(b2);
+        Assert.True(b2);
+        Assert.False(b1);
+    }
+}
+";
+            Verify(text, expected);
+        }
+
+        [Fact]
+        public void TestAssertEqualNotEqualNegation()
+        {
+            var text = @"
+using System;
+using Xunit;
+
+public class Testing
+{
+    [Fact]
+    public void MyTest()
+    {
+        bool b1 = true, b2 = false;
+        Assert.True(!b1);
+        Assert.False(!b2);
+    }
+}
+";
+
+            var expected = @"
+using System;
+using Xunit;
+
+public class Testing
+{
+    [Fact]
+    public void MyTest()
+    {
+        bool b1 = true, b2 = false;
+        Assert.False(b1);
+        Assert.True(b2);
+    }
+}
+";
+            Verify(text, expected);
+        }
+    }
+}

src/Microsoft.DotNet.CodeFormatting/Microsoft.DotNet.CodeFormatting.csproj

@@ -99,6 +99,7 @@
     <Compile Include="Rules\NonAsciiCharactersAreEscapedInLiteralsRule.cs" />
     <Compile Include="Rules\ExplicitThisRule.cs" />
     <Compile Include="Rules\RuleOrder.cs" />
+    <Compile Include="Rules\TestAssertTrueOrFalseRule.cs" />
     <Compile Include="Rules\UsesXunitForTestsFormattingRule.cs" />
     <Compile Include="RuleTypeConstants.cs" />
   </ItemGroup>
@@ -112,4 +113,4 @@
   </Target>
   <Target Name="AfterBuild">
   </Target>-->
-</Project>
+</Project>

src/Microsoft.DotNet.CodeFormatting/Rules/RuleOrder.cs

@@ -19,6 +19,7 @@ internal static class SyntaxRuleOrder
         public const int HasNewLineBeforeFirstNamespaceFormattingRule = 5;
         public const int BraceNewLineRule = 6;
         public const int NonAsciiChractersAreEscapedInLiterals = 7;
+        public const int TestAssertTrueOrFalseRule = 8;
     }
 
     // Please keep these values sorted by number, not rule name.