Verify Assert Argument Order

Test assert methods assume that the "actual" value is a variable
and the "expected" value is a constant for the most part. Inverting
these arguments causes misleading test failure messages that hinder
the ability to quickly diagnose test failures.

Detecting obvious mistakes (where "actual" is constant, and
"expected" is variable) can be done and the arguments swapped.

Fix #105

Author: ChadNedzlek

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

@@ -27,6 +27,7 @@ internal static class LocalSemanticRuleOrder
         public const int ExplicitVisibilityRule = 2;
         public const int IsFormattedFormattingRule = 3;
         public const int RemoveExplicitThisRule = 4;
+        public const int AssertArgumentOrderRule = 5;
     }
 
     // Please keep these values sorted by number, not rule name.    

src/XUnitConverter.Tests/AssertArgumentOrderTest.cs

@@ -0,0 +1,258 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+using Microsoft.CodeAnalysis;
+
+using Xunit;
+
+namespace XUnitConverter.Tests
+{
+    public class AssertArgumentOrderTest : ConverterTestBase
+    {
+        protected override XUnitConverter.ConverterBase CreateConverter()
+        {
+            return new XUnitConverter.AssertArgumentOrderConverter();
+        }
+
+        [Fact]
+        public async Task TestSwapInvertedEqual()
+        {
+            string source = @"
+public class Tests
+{
+    public void TestA()
+    {
+        int actual = 1;
+        Xunit.Assert.Equal(actual, 1);
+    }
+}
+";
+            string expected = @"
+public class Tests
+{
+    public void TestA()
+    {
+        int actual = 1;
+        Xunit.Assert.Equal(1, actual);
+    }
+}
+";
+
+            await Verify(source, expected);
+        }
+
+        [Fact]
+        public async Task TestSwapInvertedEqualEnum()
+        {
+            string source = @"
+public class Tests
+{
+    private enum E
+    {
+        A,
+        B,
+    }
+
+    public void TestA()
+    {
+        E actual = E.A;
+        Xunit.Assert.Equal(actual, E.A);
+    }
+}
+";
+            string expected = @"
+public class Tests
+{
+    private enum E
+    {
+        A,
+        B,
+    }
+
+    public void TestA()
+    {
+        E actual = E.A;
+        Xunit.Assert.Equal(E.A, actual);
+    }
+}
+";
+            await Verify(source, expected);
+        }
+
+        [Fact]
+        public async Task TestSwapInvertedEqualConstField()
+        {
+            string source = @"
+public class Tests
+{
+    private const int A;
+
+    public void TestA()
+    {
+        int actual = A;
+        Xunit.Assert.Equal(actual, A);
+    }
+}
+";
+            string expected = @"
+public class Tests
+{
+    private const int A;
+
+    public void TestA()
+    {
+        int actual = A;
+        Xunit.Assert.Equal(A, actual);
+    }
+}
+";
+            await Verify(source, expected);
+        }
+
+        [Fact]
+        public async Task TestSwapInvertedNotEqual()
+        {
+            string source = @"
+public class Tests
+{
+    public void TestA()
+    {
+        int actual = 1;
+        Xunit.Assert.NotEqual(actual, 1);
+    }
+}
+";
+            string expected = @"
+public class Tests
+{
+    public void TestA()
+    {
+        int actual = 1;
+        Xunit.Assert.NotEqual(1, actual);
+    }
+}
+";
+            await Verify(source, expected);
+        }
+
+        [Fact]
+        public async Task TestSwapInvertedEqualFromUsing()
+        {
+            string source = @"
+using Xunit;
+
+public class Tests
+{
+    public void TestA()
+    {
+        int actual = 1;
+        Assert.Equal(actual, 1);
+    }
+}
+";
+            string expected = @"
+using Xunit;
+
+public class Tests
+{
+    public void TestA()
+    {
+        int actual = 1;
+        Assert.Equal(1, actual);
+    }
+}
+";
+            await Verify(source, expected);
+        }
+
+        [Fact]
+        public async Task TestIgnoredCorrectEqual()
+        {
+            string text = @"
+public class Tests
+{
+    public void TestA()
+    {
+        int actual = 1;
+        Xunit.Assert.Equal(1, actual);
+    }
+}
+";
+            await Verify(text, text);
+        }
+
+        [Fact]
+        public async Task TestIgnoredDoubleConstEqual()
+        {
+            string text = @"
+public class Tests
+{
+    public void TestA()
+    {
+        Xunit.Assert.Equal(1, 2);
+    }
+}
+";
+            await Verify(text, text);
+        }
+
+        [Fact]
+        public async Task TestIgnoredDoubleVariableEqual()
+        {
+            string text = @"
+public class Tests
+{
+    public void TestA()
+    {
+        int actual = 1;
+        int expected = 1;
+        Xunit.Assert.Equal(actual, expected);
+    }
+}
+";
+            await Verify(text, text);
+        }
+
+        [Fact]
+        public async Task TestIgnoredCorrectNotEqual()
+        {
+            string text = @"
+public class Tests
+{
+    public void TestA()
+    {
+        int actual = 1;
+        Xunit.Assert.NotEqual(1, actual);
+    }
+}
+";
+            await Verify(text, text);
+        }
+
+        [Fact]
+        public async Task TestIgnoreOtherAssert()
+        {
+            string text = @"
+public class Assert
+{
+    public void Equal(int expected, int actual)
+    {
+    }
+}
+
+public class Tests
+{
+    public void TestA()
+    {
+        int actual = 1;
+        Assert.NotEqual(1, actual);
+    }
+}
+";
+            await Verify(text, text);
+        }
+    }
+}

src/XUnitConverter.Tests/XUnitConverter.Tests.csproj

@@ -103,6 +103,7 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="AssertArgumentOrderTest.cs" />
     <Compile Include="ConverterTestBase.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="TestAssertTrueOrFalseConverterTests.cs" />