NET-3453 Formally verify compiler warnings in rule UTs

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>
GitOrigin-RevId: 7488e0a265c1a181a232f7c1d5f7b935fdd10e27

Author: 2 people

analyzers/tests/SonarAnalyzer.Test/Rules/InvalidCastToInterfaceTest.cs

@@ -23,7 +23,9 @@ namespace SonarAnalyzer.Test.Rules;
 public class InvalidCastToInterfaceTest
 {
     private readonly VerifierBuilder builderCS = new VerifierBuilder<CS.InvalidCastToInterface>();  // Syntax-based part of the rule, there also exists Sonar SE part
-    private readonly VerifierBuilder builderVB = new VerifierBuilder<VB.InvalidCastToInterface>();  // Syntax-based part only
+
+    private readonly VerifierBuilder builderVB = new VerifierBuilder<VB.InvalidCastToInterface>()   // Syntax-based part only
+        .WithWarningsAsErrors("BC42322");
 
     [TestMethod]
     [DataRow(ProjectType.Product)]

analyzers/tests/SonarAnalyzer.Test/Rules/LiteralSuffixUpperCaseTest.cs

@@ -21,7 +21,8 @@ namespace SonarAnalyzer.Test.Rules;
 [TestClass]
 public class LiteralSuffixUpperCaseTest
 {
-    private readonly VerifierBuilder builder = new VerifierBuilder<LiteralSuffixUpperCase>();
+    private readonly VerifierBuilder builder = new VerifierBuilder<LiteralSuffixUpperCase>()
+        .WithWarningsAsErrors("CS0078");
 
     [TestMethod]
     public void LiteralSuffixUpperCase() =>

analyzers/tests/SonarAnalyzer.Test/Rules/ReferenceEqualityCheckWhenEqualsExistsTest.cs

@@ -25,6 +25,8 @@ public class ReferenceEqualityCheckWhenEqualsExistsTest
         public void ReferenceEqualityCheckWhenEqualsExists() =>
             new VerifierBuilder<ReferenceEqualityCheckWhenEqualsExists>()
                 .AddPaths("ReferenceEqualityCheckWhenEqualsExists.cs", "ReferenceEqualityCheckWhenEqualsExists2.cs")
-                .WithAutogenerateConcurrentFiles(false).Verify();
+                .WithAutogenerateConcurrentFiles(false)
+                .WithWarningsAsErrors("CS0253")
+                .Verify();
     }
 }

analyzers/tests/SonarAnalyzer.Test/Rules/UnchangedLocalVariablesShouldBeConstTest.cs

@@ -58,8 +58,9 @@ public void UnchangedLocalVariablesShouldBeConst_TopLevelStatements() =>
     [TestMethod]
     public void UnchangedLocalVariablesShouldBeConst_Latest() =>
         verifier.AddPaths("UnchangedLocalVariablesShouldBeConst.Latest.cs")
-        .WithOptions(LanguageOptions.CSharpLatest)
-        .Verify();
+            .WithOptions(LanguageOptions.CSharpLatest)
+            .WithWarningsAsErrors("CS9193")
+            .Verify();
 
     [TestMethod]
     public void UnchangedLocalVariablesShouldBeConst_CshtmlIdeGenerated() =>

analyzers/tests/SonarAnalyzer.Test/Rules/UnnecessaryMathematicalComparisonTest.cs

@@ -21,7 +21,8 @@ namespace SonarAnalyzer.Test.Rules;
 [TestClass]
 public class UnnecessaryMathematicalComparisonTest
 {
-    private readonly VerifierBuilder builderCS = new VerifierBuilder<CS.UnnecessaryMathematicalComparison>();
+    private readonly VerifierBuilder builderCS = new VerifierBuilder<CS.UnnecessaryMathematicalComparison>()
+        .WithWarningsAsErrors("CS0652");
 
     [TestMethod]
     public void UnnecessaryMathematicalComparison_CS() =>

analyzers/tests/SonarAnalyzer.Test/Rules/UnnecessaryUsingsTest.cs

@@ -24,7 +24,8 @@ public class UnnecessaryUsingsTest
 {
     private readonly VerifierBuilder builder = new VerifierBuilder<UnnecessaryUsings>()
         .AddReferences(MetadataReferenceFacade.MicrosoftWin32Primitives)
-        .AddReferences(MetadataReferenceFacade.SystemSecurityCryptography);
+        .AddReferences(MetadataReferenceFacade.SystemSecurityCryptography)
+        .WithWarningsAsErrors("CS0105");
 
     public TestContext TestContext { get; set; }
 

analyzers/tests/SonarAnalyzer.Test/TestCases/InvalidCastToInterface.vb

@@ -174,7 +174,7 @@ Public Class Other
         o = DirectCast(IBar, IFoo)
         o = DirectCast(Bar, Foo)        ' Compliant causes compiler error ' Error   [BC30311] - invalid cast
         o = DirectCast(IBar, Foo)
-        o = DirectCast(FinalBar, IFoo)  ' Compliant causes compiler error ' Warning [BC42322] - invalid cast
+        o = DirectCast(FinalBar, IFoo)  ' Error [BC42322] - Compliant, causes compiler warning
         o = DirectCast(Generic, Bar)    ' Compliant causes compiler error ' Error   [BC30311] - invalid cast
 
         o = TryCast(Bar, IFoo)

analyzers/tests/SonarAnalyzer.Test/TestCases/LiteralSuffixUpperCase.Fixed.cs

@@ -10,6 +10,7 @@ class LiteralSuffixUpperCase
     {
         public void Test(long ui)
         {
+            // Error @+1 [CS0078] - compiler warning "The 'l' suffix is easily confused with the digit '1' -- use 'L' for clarity"
             const long b = 0L;      // Fixed
             const ulong c = 0Ul;
             const ulong d = 0uL;
@@ -22,6 +23,7 @@ public void Test(long ui)
             const int k = 0; // Compliant
             const uint l = 0u;
 
+            // Error @+1 [CS0078] - compiler warning "The 'l' suffix is easily confused with the digit '1' -- use 'L' for clarity"
             Test(45L); // Fixed
         }
         public void TestOk()

analyzers/tests/SonarAnalyzer.Test/TestCases/LiteralSuffixUpperCase.Latest.cs

@@ -4,7 +4,9 @@
 
     public void M()
     {
+        // Error @+1 [CS0078] - compiler warning "The 'l' suffix is easily confused with the digit '1' -- use 'L' for clarity"
         (Property, var b) = (0l,  // Noncompliant
+                             // Error @+1 [CS0078] - compiler warning "The 'l' suffix is easily confused with the digit '1' -- use 'L' for clarity"
                              0l); // Noncompliant
     }
 

analyzers/tests/SonarAnalyzer.Test/TestCases/LiteralSuffixUpperCase.cs

@@ -10,6 +10,7 @@ class LiteralSuffixUpperCase
     {
         public void Test(long ui)
         {
+            // Error @+1 [CS0078] - compiler warning "The 'l' suffix is easily confused with the digit '1' -- use 'L' for clarity"
             const long b = 0l;      // Noncompliant {{Upper case this literal suffix.}}
 //                          ^
             const ulong c = 0Ul;
@@ -23,6 +24,7 @@ public void Test(long ui)
             const int k = 0; // Compliant
             const uint l = 0u;
 
+            // Error @+1 [CS0078] - compiler warning "The 'l' suffix is easily confused with the digit '1' -- use 'L' for clarity"
             Test(45l); // Noncompliant
         }
         public void TestOk()