test(refactor): improve code coverage

tests/Moq.Analyzers.Test/Common/DiagnosticEditPropertiesTests.cs

@@ -11,6 +11,85 @@
         Assert.Equal("2", dict[DiagnosticEditProperties.EditPositionKey]);
     }
 
+    [Fact]
+    public void ToImmutableDictionary_AllEnumValues_RoundTrips()
+    {
+        foreach (DiagnosticEditProperties.EditType type in Enum.GetValues(typeof(DiagnosticEditProperties.EditType)))
+        {
+            DiagnosticEditProperties props = new DiagnosticEditProperties { TypeOfEdit = type, EditPosition = 0 };
+            ImmutableDictionary<string, string?> dict = props.ToImmutableDictionary();
+            Assert.Equal(type.ToString(), dict[DiagnosticEditProperties.EditTypeKey]);
+            Assert.Equal("0", dict[DiagnosticEditProperties.EditPositionKey]);
+            Assert.True(DiagnosticEditProperties.TryGetFromImmutableDictionary(dict, out DiagnosticEditProperties? roundTripped));
+            Assert.Equal(type, roundTripped!.TypeOfEdit);
+        }
+    }
+
+    [Fact]
+    public void ToImmutableDictionary_HandlesNegativeAndLargeEditPosition()
+    {
+        DiagnosticEditProperties propsNeg = new DiagnosticEditProperties { TypeOfEdit = DiagnosticEditProperties.EditType.Insert, EditPosition = -1 };
+        ImmutableDictionary<string, string?> dictNeg = propsNeg.ToImmutableDictionary();
+        Assert.Equal("-1", dictNeg[DiagnosticEditProperties.EditPositionKey]);
+        Assert.True(DiagnosticEditProperties.TryGetFromImmutableDictionary(dictNeg, out DiagnosticEditProperties? roundTrippedNeg));
+        Assert.Equal(-1, roundTrippedNeg!.EditPosition);
+
+        DiagnosticEditProperties propsLarge = new DiagnosticEditProperties { TypeOfEdit = DiagnosticEditProperties.EditType.Replace, EditPosition = int.MaxValue };
+        ImmutableDictionary<string, string?> dictLarge = propsLarge.ToImmutableDictionary();
+        Assert.Equal(int.MaxValue.ToString(), dictLarge[DiagnosticEditProperties.EditPositionKey]);
+        Assert.True(DiagnosticEditProperties.TryGetFromImmutableDictionary(dictLarge, out DiagnosticEditProperties? roundTrippedLarge));
+        Assert.Equal(int.MaxValue, roundTrippedLarge!.EditPosition);
+    }
+
+    [Fact]
+    public void TryGetFromImmutableDictionary_IgnoresExtraKeys()
+    {
+        ImmutableDictionary<string, string?> dict = ImmutableDictionary<string, string?>.Empty
+            .Add(DiagnosticEditProperties.EditTypeKey, "Insert")
+            .Add(DiagnosticEditProperties.EditPositionKey, "1")
+            .Add("ExtraKey", "ExtraValue");
+        Assert.True(DiagnosticEditProperties.TryGetFromImmutableDictionary(dict, out DiagnosticEditProperties? props));
+        Assert.Equal(DiagnosticEditProperties.EditType.Insert, props!.TypeOfEdit);
+        Assert.Equal(1, props.EditPosition);
+    }
+
+    [Fact]
+    public void DiagnosticEditProperties_EqualityAndImmutability()
+    {
+        DiagnosticEditProperties a = new DiagnosticEditProperties { TypeOfEdit = DiagnosticEditProperties.EditType.Insert, EditPosition = 1 };
+        DiagnosticEditProperties b = new DiagnosticEditProperties { TypeOfEdit = DiagnosticEditProperties.EditType.Insert, EditPosition = 1 };
+        DiagnosticEditProperties c = new DiagnosticEditProperties { TypeOfEdit = DiagnosticEditProperties.EditType.Replace, EditPosition = 1 };
+        Assert.Equal(a, b);
+        Assert.NotEqual(a, c);
+        Assert.True(a.Equals(b));
+        Assert.False(a.Equals(c));
+        Assert.Equal(a.GetHashCode(), b.GetHashCode());
+    }
+
+    [Fact]
+    public void TryGetFromImmutableDictionary_ParsesCultureInvariant()
+    {
+        // Use reflection to set CurrentCulture to avoid RS1035 banned symbol in test context
+        System.Type cultureType = typeof(System.Globalization.CultureInfo);
+        System.Reflection.PropertyInfo? currentCultureProperty = cultureType.GetProperty("CurrentCulture");
+        object? originalCulture = currentCultureProperty!.GetValue(null);
+        try
+        {
+            System.Globalization.CultureInfo frCulture = new System.Globalization.CultureInfo("fr-FR");
+            currentCultureProperty.SetValue(null, frCulture);
+            ImmutableDictionary<string, string?> dict = ImmutableDictionary<string, string?>.Empty
+                .Add(DiagnosticEditProperties.EditTypeKey, "Insert")
+                .Add(DiagnosticEditProperties.EditPositionKey, "1234");
+            DiagnosticEditProperties? props;
+            Assert.True(DiagnosticEditProperties.TryGetFromImmutableDictionary(dict, out props));
+            Assert.Equal(1234, props!.EditPosition);
+        }
+        finally
+        {
+            currentCultureProperty.SetValue(null, originalCulture);
+        }
+    }
+
     [Fact]
     public void TryGetFromImmutableDictionary_Succeeds_WithValidDictionary()
     {

tests/Moq.Analyzers.Test/Common/DiagnosticExtensionsTests.cs

@@ -0,0 +1,66 @@
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Moq.Analyzers.Common;
+using Xunit;
+
+namespace Moq.Analyzers.Test.Common;
+
+public class DiagnosticExtensionsTests
+{
+    [Fact]
+    public void CreateDiagnostic_FromSyntaxNode_Basic()
+    {
+        SyntaxTree tree = CSharpSyntaxTree.ParseText("class C { void M() {} }");
+        SyntaxNode root = tree.GetRoot();
+        DiagnosticDescriptor rule = new DiagnosticDescriptor("TEST0001", "Test", "Test message", "Test", DiagnosticSeverity.Warning, true);
+        Diagnostic diag = root.CreateDiagnostic(rule);
+        Assert.Equal("TEST0001", diag.Id);
+        Assert.Equal(DiagnosticSeverity.Warning, diag.Severity);
+    }
+
+    [Fact]
+    public void CreateDiagnostic_FromLocation_WithProperties()
+    {
+        SyntaxTree tree = CSharpSyntaxTree.ParseText("class C { void M() {} }");
+        Location loc = tree.GetRoot().GetLocation();
+        DiagnosticDescriptor rule = new DiagnosticDescriptor("TEST0002", "Test2", "Test message 2", "Test", DiagnosticSeverity.Info, true);
+        ImmutableDictionary<string, string?> properties = ImmutableDictionary<string, string?>.Empty.Add("Key", "Value");
+        Diagnostic diag = loc.CreateDiagnostic(rule, properties);
+        Assert.Equal("TEST0002", diag.Id);
+        Assert.Equal("Value", diag.Properties["Key"]);
+    }
+
+    [Fact]
+    public void CreateDiagnostic_FromOperation_DelegatesToSyntax()
+    {
+        SyntaxTree tree = CSharpSyntaxTree.ParseText("class C { void M() {} }");
+        SyntaxNode root = tree.GetRoot();
+        CSharpCompilation compilation = CSharpCompilation.Create("Test", new[] { tree });
+        SemanticModel model = compilation.GetSemanticModel(tree);
+        MethodDeclarationSyntax methodDecl = root.DescendantNodes().OfType<MethodDeclarationSyntax>().First();
+        Microsoft.CodeAnalysis.IOperation? operation = model.GetOperation(methodDecl);
+        DiagnosticDescriptor rule = new DiagnosticDescriptor("TEST0003", "Test3", "Test message 3", "Test", DiagnosticSeverity.Error, true);
+        Diagnostic diag = operation!.CreateDiagnostic(rule);
+        Assert.Equal("TEST0003", diag.Id);
+        Assert.Equal(DiagnosticSeverity.Error, diag.Severity);
+    }
+
+    [Fact]
+    public void CreateDiagnostic_FromOperation_WithProperties()
+    {
+        SyntaxTree tree = CSharpSyntaxTree.ParseText("class C { void M() {} }");
+        SyntaxNode root = tree.GetRoot();
+        CSharpCompilation compilation = CSharpCompilation.Create("Test", new[] { tree });
+        SemanticModel model = compilation.GetSemanticModel(tree);
+        MethodDeclarationSyntax methodDecl = root.DescendantNodes().OfType<MethodDeclarationSyntax>().First();
+        Microsoft.CodeAnalysis.IOperation? operation = model.GetOperation(methodDecl);
+        DiagnosticDescriptor rule = new DiagnosticDescriptor("TEST0004", "Test4", "Test message 4", "Test", DiagnosticSeverity.Warning, true);
+        ImmutableDictionary<string, string?> properties = ImmutableDictionary<string, string?>.Empty.Add("Key2", "Value2");
+        Diagnostic diag = operation!.CreateDiagnostic(rule, properties);
+        Assert.Equal("TEST0004", diag.Id);
+        Assert.Equal("Value2", diag.Properties["Key2"]);
+    }
+}