fix: correct xUnit Assert.Same/NotSame conversion method names

TUnit.Analyzers.CodeFixers/XUnitMigrationCodeFixProvider.cs

@@ -569,9 +569,9 @@ protected override bool IsFrameworkAssertionNamespace(string namespaceName)
 
                 // Reference assertions
                 "Same" when arguments.Count >= 2 =>
-                    CreateTUnitAssertion("IsSameReference", arguments[1].Expression, arguments[0]),
+                    CreateTUnitAssertion("IsSameReferenceAs", arguments[1].Expression, arguments[0]),
                 "NotSame" when arguments.Count >= 2 =>
-                    CreateTUnitAssertion("IsNotSameReference", arguments[1].Expression, arguments[0]),
+                    CreateTUnitAssertion("IsNotSameReferenceAs", arguments[1].Expression, arguments[0]),
 
                 // String/Collection contains
                 "Contains" when arguments.Count >= 2 =>

TUnit.Analyzers.Tests/XUnitMigrationAnalyzerTests.cs

@@ -861,6 +861,82 @@ public async Task MyTest()
             );
     }
 
+    [Test]
+    public async Task Assert_Same_Can_Be_Converted()
+    {
+        await CodeFixer
+            .VerifyCodeFixAsync(
+                """
+                {|#0:using TUnit.Core;
+
+                public class MyClass
+                {
+                    [Fact]
+                    public void MyTest()
+                    {
+                        var expected = new object();
+                        var actual = expected;
+                        Assert.Same(expected, actual);
+                    }
+                }|}
+                """,
+                Verifier.Diagnostic(Rules.XunitMigration).WithLocation(0),
+                """
+                using TUnit.Core;
+
+                public class MyClass
+                {
+                    [Test]
+                    public async Task MyTest()
+                    {
+                        var expected = new object();
+                        var actual = expected;
+                        await Assert.That(actual).IsSameReferenceAs(expected);
+                    }
+                }
+                """,
+                ConfigureXUnitTest
+            );
+    }
+
+    [Test]
+    public async Task Assert_NotSame_Can_Be_Converted()
+    {
+        await CodeFixer
+            .VerifyCodeFixAsync(
+                """
+                {|#0:using TUnit.Core;
+
+                public class MyClass
+                {
+                    [Fact]
+                    public void MyTest()
+                    {
+                        var obj1 = new object();
+                        var obj2 = new object();
+                        Assert.NotSame(obj1, obj2);
+                    }
+                }|}
+                """,
+                Verifier.Diagnostic(Rules.XunitMigration).WithLocation(0),
+                """
+                using TUnit.Core;
+
+                public class MyClass
+                {
+                    [Test]
+                    public async Task MyTest()
+                    {
+                        var obj1 = new object();
+                        var obj2 = new object();
+                        await Assert.That(obj2).IsNotSameReferenceAs(obj1);
+                    }
+                }
+                """,
+                ConfigureXUnitTest
+            );
+    }
+
     private static void ConfigureXUnitTest(Verifier.Test test)
     {
         var globalUsings = ("GlobalUsings.cs", SourceText.From("global using Xunit;"));