Issue 171 - when expect value is null object

src/FluentAssertions.Analyzers.Tests/Tips/MsTestTests.cs

@@ -310,6 +310,32 @@ public void AssertIsNotInstanceOfType_TestCodeFix(string oldAssertion, string ne
         public void AssertObjectAreEqual_TestCodeFix(string oldAssertion, string newAssertion)
             => VerifyCSharpFix<AssertAreEqualCodeFix, AssertAreEqualAnalyzer>("object actual, object expected", oldAssertion, newAssertion);
 
+        [AssertionDataTestMethod]
+        [AssertionDiagnostic("Assert.AreEqual(expected, actual{0});")]
+        [Implemented]
+        public void AssertOptionalIntAreEqual_TestAnalyzer(string assertion) => VerifyCSharpDiagnostic<AssertAreEqualAnalyzer>("int? actual, int? expected", assertion);
+
+        [AssertionDataTestMethod]
+        [AssertionCodeFix(
+            oldAssertion: "Assert.AreEqual(expected, actual{0});",
+            newAssertion: "actual.Should().Be(expected{0});")]
+        [Implemented]
+        public void AssertOptionalIntAreEqual_TestCodeFix(string oldAssertion, string newAssertion)
+            => VerifyCSharpFix<AssertAreEqualCodeFix, AssertAreEqualAnalyzer>("int? actual, int? expected", oldAssertion, newAssertion);
+
+        [AssertionDataTestMethod]
+        [AssertionDiagnostic("Assert.AreEqual(actual, null{0});")]
+        [Implemented]
+        public void AssertOptionalIntAndNullAreEqual_TestAnalyzer(string assertion) => VerifyCSharpDiagnostic<AssertAreEqualAnalyzer>("int? actual", assertion);
+
+        [AssertionDataTestMethod]
+        [AssertionCodeFix(
+            oldAssertion: "Assert.AreEqual(actual, null{0});",
+            newAssertion: "actual.Should().BeNull({0});")]
+        [Implemented]
+        public void AssertOptionalIntAndNullAreEqual_TestCodeFix(string oldAssertion, string newAssertion)
+            => VerifyCSharpFix<AssertAreEqualCodeFix, AssertAreEqualAnalyzer>("int? actual", oldAssertion, newAssertion);
+
         [AssertionDataTestMethod]
         [AssertionDiagnostic("Assert.AreEqual(expected, actual, delta{0});")]
         [AssertionDiagnostic("Assert.AreEqual(expected, actual, 0.6{0});")]
@@ -403,6 +429,33 @@ public void AssertObjectAreNotEqual_TestCodeFix(string oldAssertion, string newA
         public void AssertDoubleAreNotEqual_TestCodeFix(string oldAssertion, string newAssertion)
             => VerifyCSharpFix<AssertAreNotEqualCodeFix, AssertAreNotEqualAnalyzer>("double actual, double expected, double delta", oldAssertion, newAssertion);
 
+
+        [AssertionDataTestMethod]
+        [AssertionDiagnostic("Assert.AreNotEqual(expected, actual{0});")]
+        [Implemented]
+        public void AssertOptionalIntAreNotEqual_TestAnalyzer(string assertion) => VerifyCSharpDiagnostic<AssertAreNotEqualAnalyzer>("int? actual, int? expected", assertion);
+
+        [AssertionDataTestMethod]
+        [AssertionCodeFix(
+            oldAssertion: "Assert.AreNotEqual(expected, actual{0});",
+            newAssertion: "actual.Should().NotBe(expected{0});")]
+        [Implemented]
+        public void AssertOptionalIntAreNotEqual_TestCodeFix(string oldAssertion, string newAssertion)
+            => VerifyCSharpFix<AssertAreNotEqualCodeFix, AssertAreNotEqualAnalyzer>("int? actual, int? expected", oldAssertion, newAssertion);
+
+        [AssertionDataTestMethod]
+        [AssertionDiagnostic("Assert.AreNotEqual(actual, null{0});")]
+        [Implemented]
+        public void AssertOptionalIntAndNullAreNotEqual_TestAnalyzer(string assertion) => VerifyCSharpDiagnostic<AssertAreNotEqualAnalyzer>("int? actual", assertion);
+
+        [AssertionDataTestMethod]
+        [AssertionCodeFix(
+            oldAssertion: "Assert.AreNotEqual(actual, null{0});",
+            newAssertion: "actual.Should().NotBeNull({0});")]
+        [Implemented]
+        public void AssertOptionalIntAndNullAreNotEqual_TestCodeFix(string oldAssertion, string newAssertion)
+            => VerifyCSharpFix<AssertAreNotEqualCodeFix, AssertAreNotEqualAnalyzer>("int? actual", oldAssertion, newAssertion);
+
         [AssertionDataTestMethod]
         [AssertionDiagnostic("Assert.AreNotEqual(expected, actual, delta{0});")]
         [AssertionDiagnostic("Assert.AreNotEqual(expected, actual, 0.6f{0});")]

src/FluentAssertions.Analyzers/Tips/MsTest/AssertAreEqual.cs

@@ -27,6 +27,7 @@ protected override IEnumerable<FluentAssertionsCSharpSyntaxVisitor> Visitors
                 yield return new AssertFloatAreEqualWithDeltaSyntaxVisitor();
                 yield return new AssertDoubleAreEqualWithDeltaSyntaxVisitor();
                 yield return new AssertStringAreEqualSyntaxVisitor();
+                yield return new AssertObjectAreEqualNullSyntaxVisitor();
                 yield return new AssertObjectAreEqualSyntaxVisitor();
             }
         }
@@ -69,6 +70,16 @@ public AssertStringAreEqualSyntaxVisitor() : base(
             }
         }
 
+        public class AssertObjectAreEqualNullSyntaxVisitor : FluentAssertionsCSharpSyntaxVisitor
+        {
+            public AssertObjectAreEqualNullSyntaxVisitor() : base(
+                MemberValidator.ArgumentsMatch("AreEqual",
+                    ArgumentValidator.IsIdentifier(),
+                    ArgumentValidator.IsNull()))
+            {
+            }
+        }
+
         // public static void AreEqual<T>(T expected, T actual)
         // public static void AreEqual(object expected, object actual)
         public class AssertObjectAreEqualSyntaxVisitor : FluentAssertionsCSharpSyntaxVisitor
@@ -96,6 +107,9 @@ protected override async Task<ExpressionSyntax> GetNewExpressionAsync(Expression
                 case nameof(AssertAreEqualAnalyzer.AssertStringAreEqualSyntaxVisitor):
                     var semanticModel = await document.GetSemanticModelAsync(cancellationToken);
                     return GetNewExpressionForAreNotEqualOrAreEqualStrings(expression, semanticModel, "AreEqual", "Be", "BeEquivalentTo");
+                case nameof(AssertAreEqualAnalyzer.AssertObjectAreEqualNullSyntaxVisitor):
+                    expression = RenameMethodAndReplaceWithSubjectShould(expression, "AreEqual", "BeNull");
+                    return GetNewExpression(expression, NodeReplacement.RemoveFirstArgument("BeNull"));
                 default:
                     throw new System.InvalidOperationException($"Invalid visitor name - {properties.VisitorName}");
             }

src/FluentAssertions.Analyzers/Tips/MsTest/AssertAreNotEqual.cs

@@ -27,6 +27,7 @@ protected override IEnumerable<FluentAssertionsCSharpSyntaxVisitor> Visitors
                 yield return new AssertFloatAreNotEqualWithDeltaSyntaxVisitor();
                 yield return new AssertDoubleAreNotEqualWithDeltaSyntaxVisitor();
                 yield return new AssertStringAreNotEqualSyntaxVisitor();
+                yield return new AssertObjectAreNotEqualNullSyntaxVisitor();
                 yield return new AssertObjectAreNotEqualSyntaxVisitor();
             }
         }
@@ -57,6 +58,16 @@ public AssertDoubleAreNotEqualWithDeltaSyntaxVisitor() : base(
             }
         }
 
+        public class AssertObjectAreNotEqualNullSyntaxVisitor : FluentAssertionsCSharpSyntaxVisitor
+        {
+            public AssertObjectAreNotEqualNullSyntaxVisitor() : base(
+                MemberValidator.ArgumentsMatch("AreNotEqual",
+                    ArgumentValidator.IsIdentifier(),
+                    ArgumentValidator.IsNull()))
+            {
+            }
+        }
+
         // public static void AreNotEqual(string expected, string actual, bool ignoreCase, CultureInfo culture
         public class AssertStringAreNotEqualSyntaxVisitor : FluentAssertionsCSharpSyntaxVisitor
         {
@@ -97,6 +108,9 @@ protected override async Task<ExpressionSyntax> GetNewExpressionAsync(Expression
                 case nameof(AssertAreNotEqualAnalyzer.AssertStringAreNotEqualSyntaxVisitor):
                     var semanticModel = await document.GetSemanticModelAsync(cancellationToken);
                     return GetNewExpressionForAreNotEqualOrAreEqualStrings(expression, semanticModel, "AreNotEqual", "NotBe", "NotBeEquivalentTo");
+                case nameof(AssertAreNotEqualAnalyzer.AssertObjectAreNotEqualNullSyntaxVisitor):
+                    expression = RenameMethodAndReplaceWithSubjectShould(expression, "AreNotEqual", "NotBeNull");
+                    return GetNewExpression(expression, NodeReplacement.RemoveFirstArgument("NotBeNull"));
                 default:
                     throw new System.InvalidOperationException($"Invalid visitor name - {properties.VisitorName}");
             }

src/FluentAssertions.Analyzers/Utilities/ArgumentValidator.cs

@@ -0,0 +1,17 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System;
+
+namespace FluentAssertions.Analyzers
+{
+    public class ArgumentValidator
+    {
+        public static ArgumentPredicate IsIdentifier() 
+            => (argument, semanticModel) => argument.Expression.IsKind(SyntaxKind.IdentifierName);
+        public static ArgumentPredicate IsType(Func<SemanticModel, INamedTypeSymbol> typeSelector) 
+            => (argument, semanticModel) => semanticModel.GetTypeInfo(argument.Expression).Type.Equals(typeSelector(semanticModel), SymbolEqualityComparer.Default);
+        public static ArgumentPredicate IsNull() 
+            => (argument, semanticModel) => argument.Expression is LiteralExpressionSyntax literal && literal.Token.IsKind(SyntaxKind.NullKeyword);
+    }
+}

src/FluentAssertions.Analyzers/Utilities/MemberValidator.cs

@@ -1,6 +1,5 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-using System;
 using System.Diagnostics;
 
 namespace FluentAssertions.Analyzers
@@ -105,15 +104,4 @@ public static bool ArgumentsMatchPredicate(SeparatedSyntaxList<ArgumentSyntax> a
             return true;
         }
     }
-
-    public class ArgumentValidator
-    {
-        public static ArgumentPredicate IsType(Func<SemanticModel, INamedTypeSymbol> typeSelector)
-        {
-            return (argument, semanticModel) =>
-            {
-                return semanticModel.GetTypeInfo(argument.Expression).Type.Equals(typeSelector(semanticModel), SymbolEqualityComparer.Default);
-            };
-        }
-    }
 }