diff --git a/analyzers/tests/SonarAnalyzer.Test/Rules/AbstractTypesShouldNotHaveConstructorsTest.cs b/analyzers/tests/SonarAnalyzer.Test/Rules/AbstractTypesShouldNotHaveConstructorsTest.cs index 0ddc78fdab5..c6374a3206e 100644 --- a/analyzers/tests/SonarAnalyzer.Test/Rules/AbstractTypesShouldNotHaveConstructorsTest.cs +++ b/analyzers/tests/SonarAnalyzer.Test/Rules/AbstractTypesShouldNotHaveConstructorsTest.cs @@ -49,7 +49,7 @@ public class AbstractTypesShouldNotHaveConstructorsTest public void AbstractTypesShouldNotHaveConstructors_CSharp12() => builder.AddPaths("AbstractTypesShouldNotHaveConstructors.CSharp12.cs") .WithOptions(ParseOptionsHelper.FromCSharp12) - .VerifyNoIssues(); // primary constructors are compliant + .VerifyNoIssues(); #endif diff --git a/analyzers/tests/SonarAnalyzer.Test/Rules/AspNet/RouteTemplateShouldNotStartWithSlashTest.cs b/analyzers/tests/SonarAnalyzer.Test/Rules/AspNet/RouteTemplateShouldNotStartWithSlashTest.cs index 9b88336765b..f81a08d0a67 100644 --- a/analyzers/tests/SonarAnalyzer.Test/Rules/AspNet/RouteTemplateShouldNotStartWithSlashTest.cs +++ b/analyzers/tests/SonarAnalyzer.Test/Rules/AspNet/RouteTemplateShouldNotStartWithSlashTest.cs @@ -159,7 +159,7 @@ public class BasicsController : Controller {{(compliant ? string.Empty : " // No builderVB .AddPaths("RouteTemplateShouldNotStartWithSlash.AspNetCore.vb") .AddReferences(AspNetCoreReferences) - .VerifyNoIssues(); // FN + .VerifyNoIssues(); [TestMethod] public void RouteTemplateShouldNotStartWithSlash_CSharp12() => @@ -194,7 +194,7 @@ public class BasicsController : Controller {{(compliant ? string.Empty : " // No builderVB .AddPaths("RouteTemplateShouldNotStartWithSlash.AspNet4x.vb") .AddReferences(AspNet4xReferences(aspNetMvcVersion)) - .VerifyNoIssues(); // FN, VB is not supported + .VerifyNoIssues(); [DataRow("/Index2", false)] [DataRow(@"\Index2", true)] diff --git a/analyzers/tests/SonarAnalyzer.Test/Rules/BypassingAccessibilityTest.cs b/analyzers/tests/SonarAnalyzer.Test/Rules/BypassingAccessibilityTest.cs index 19714e5e189..4ed67bc4fbc 100644 --- a/analyzers/tests/SonarAnalyzer.Test/Rules/BypassingAccessibilityTest.cs +++ b/analyzers/tests/SonarAnalyzer.Test/Rules/BypassingAccessibilityTest.cs @@ -45,7 +45,7 @@ public class BypassingAccessibilityTest [TestMethod] public void BypassingAccessibility_CSharp12() => - builderCS.AddPaths("BypassingAccessibility.CSharp12.cs").WithOptions(ParseOptionsHelper.FromCSharp12).VerifyNoIssues(); // zero-overhead member access is not supported yet + builderCS.AddPaths("BypassingAccessibility.CSharp12.cs").WithOptions(ParseOptionsHelper.FromCSharp12).VerifyNoIssues(); #endif diff --git a/analyzers/tests/SonarAnalyzer.Test/Rules/CalculationsShouldNotOverflowTest.cs b/analyzers/tests/SonarAnalyzer.Test/Rules/CalculationsShouldNotOverflowTest.cs index 76051f2d7a8..ce640e047e3 100644 --- a/analyzers/tests/SonarAnalyzer.Test/Rules/CalculationsShouldNotOverflowTest.cs +++ b/analyzers/tests/SonarAnalyzer.Test/Rules/CalculationsShouldNotOverflowTest.cs @@ -47,7 +47,7 @@ public class CalculationsShouldNotOverflowTest [TestMethod] public void CalculationsShouldNotOverflow_CSharp8() => - builderCS.AddPaths("CalculationsShouldNotOverflow.CSharp8.cs").WithOptions(ParseOptionsHelper.FromCSharp8).VerifyNoIssues(); // switch exressions are not supported yet + builderCS.AddPaths("CalculationsShouldNotOverflow.CSharp8.cs").WithOptions(ParseOptionsHelper.FromCSharp8).VerifyNoIssues(); #if NET @@ -61,7 +61,7 @@ public class CalculationsShouldNotOverflowTest [TestMethod] public void CalculationsShouldNotOverflow_CSharp11() => - builderCS.AddPaths("CalculationsShouldNotOverflow.CSharp11.cs").WithOptions(ParseOptionsHelper.FromCSharp11).VerifyNoIssues(); // list patterns are not supported yet + builderCS.AddPaths("CalculationsShouldNotOverflow.CSharp11.cs").WithOptions(ParseOptionsHelper.FromCSharp11).VerifyNoIssues(); #endif } diff --git a/analyzers/tests/SonarAnalyzer.Test/Rules/CallerInformationParametersShouldBeLastTest.cs b/analyzers/tests/SonarAnalyzer.Test/Rules/CallerInformationParametersShouldBeLastTest.cs index 4451eeef893..2b98617e880 100644 --- a/analyzers/tests/SonarAnalyzer.Test/Rules/CallerInformationParametersShouldBeLastTest.cs +++ b/analyzers/tests/SonarAnalyzer.Test/Rules/CallerInformationParametersShouldBeLastTest.cs @@ -21,36 +21,35 @@ using Microsoft.CodeAnalysis.CSharp; using SonarAnalyzer.Rules.CSharp; -namespace SonarAnalyzer.Test.Rules +namespace SonarAnalyzer.Test.Rules; + +[TestClass] +public class CallerInformationParametersShouldBeLastTest { - [TestClass] - public class CallerInformationParametersShouldBeLastTest - { - private readonly VerifierBuilder builder = new VerifierBuilder(); + private readonly VerifierBuilder builder = new VerifierBuilder(); - [TestMethod] - public void CallerInformationParametersShouldBeLast() => - builder.AddPaths("CallerInformationParametersShouldBeLast.cs").Verify(); + [TestMethod] + public void CallerInformationParametersShouldBeLast() => + builder.AddPaths("CallerInformationParametersShouldBeLast.cs").Verify(); #if NET - [TestMethod] - public void CallerInformationParametersShouldBeLast_CSharp9() => - builder.AddPaths("CallerInformationParametersShouldBeLast.CSharp9.cs").WithTopLevelStatements().Verify(); + [TestMethod] + public void CallerInformationParametersShouldBeLast_CSharp9() => + builder.AddPaths("CallerInformationParametersShouldBeLast.CSharp9.cs").WithTopLevelStatements().Verify(); - [TestMethod] - public void CallerInformationParametersShouldBeLast_CSharp10() => - builder.AddPaths("CallerInformationParametersShouldBeLast.CSharp10.cs").WithOptions(ParseOptionsHelper.FromCSharp10).Verify(); + [TestMethod] + public void CallerInformationParametersShouldBeLast_CSharp10() => + builder.AddPaths("CallerInformationParametersShouldBeLast.CSharp10.cs").WithOptions(ParseOptionsHelper.FromCSharp10).Verify(); - [TestMethod] - public void CallerInformationParametersShouldBeLast_CSharp11() => - builder.AddPaths("CallerInformationParametersShouldBeLast.CSharp11.cs").WithOptions(ParseOptionsHelper.FromCSharp11) - .VerifyNoIssues(); // overriding an abstract default implementation is compliant + [TestMethod] + public void CallerInformationParametersShouldBeLast_CSharp11() => + builder.AddPaths("CallerInformationParametersShouldBeLast.CSharp11.cs").WithOptions(ParseOptionsHelper.FromCSharp11) + .VerifyNoIssues(); #endif - [TestMethod] - public void CallerInformationParametersShouldBeLastInvalidSyntax() => - builder.AddPaths("CallerInformationParametersShouldBeLastInvalidSyntax.cs").WithLanguageVersion(LanguageVersion.CSharp7).WithConcurrentAnalysis(false).Verify(); - } + [TestMethod] + public void CallerInformationParametersShouldBeLastInvalidSyntax() => + builder.AddPaths("CallerInformationParametersShouldBeLastInvalidSyntax.cs").WithLanguageVersion(LanguageVersion.CSharp7).WithConcurrentAnalysis(false).Verify(); } diff --git a/analyzers/tests/SonarAnalyzer.Test/Rules/ClassNamedExceptionTest.cs b/analyzers/tests/SonarAnalyzer.Test/Rules/ClassNamedExceptionTest.cs index 00452e89a8b..523f6245ce0 100644 --- a/analyzers/tests/SonarAnalyzer.Test/Rules/ClassNamedExceptionTest.cs +++ b/analyzers/tests/SonarAnalyzer.Test/Rules/ClassNamedExceptionTest.cs @@ -40,14 +40,14 @@ public class ClassNamedExceptionTest builderCS .AddPaths("ClassNamedException.CSharp9.cs") .WithOptions(ParseOptionsHelper.FromCSharp9) - .VerifyNoIssues(); // records are compliant + .VerifyNoIssues(); [TestMethod] public void ClassNamedException_FromCSharp10() => builderCS .AddPaths("ClassNamedException.CSharp10.cs") .WithOptions(ParseOptionsHelper.FromCSharp10) - .VerifyNoIssues(); // records are compliant + .VerifyNoIssues(); [TestMethod] public void ClassNamedException_VB() => diff --git a/analyzers/tests/SonarAnalyzer.Test/Rules/ClassWithOnlyStaticMemberTest.cs b/analyzers/tests/SonarAnalyzer.Test/Rules/ClassWithOnlyStaticMemberTest.cs index 24bb30bc549..db355c6a6f4 100644 --- a/analyzers/tests/SonarAnalyzer.Test/Rules/ClassWithOnlyStaticMemberTest.cs +++ b/analyzers/tests/SonarAnalyzer.Test/Rules/ClassWithOnlyStaticMemberTest.cs @@ -20,38 +20,37 @@ using SonarAnalyzer.Rules.CSharp; -namespace SonarAnalyzer.Test.Rules +namespace SonarAnalyzer.Test.Rules; + +[TestClass] +public class ClassWithOnlyStaticMemberTest { - [TestClass] - public class ClassWithOnlyStaticMemberTest - { - private readonly VerifierBuilder builder = new VerifierBuilder(); + private readonly VerifierBuilder builder = new VerifierBuilder(); - [TestMethod] - public void ClassWithOnlyStaticMember() => - builder.AddPaths("ClassWithOnlyStaticMember.cs").Verify(); + [TestMethod] + public void ClassWithOnlyStaticMember() => + builder.AddPaths("ClassWithOnlyStaticMember.cs").Verify(); #if NET - [TestMethod] - public void ClassWithOnlyStaticMember_CSharp9() => - builder.AddPaths("ClassWithOnlyStaticMember.CSharp9.cs") - .WithTopLevelStatements() - .VerifyNoIssues(); // records are compliant + [TestMethod] + public void ClassWithOnlyStaticMember_CSharp9() => + builder.AddPaths("ClassWithOnlyStaticMember.CSharp9.cs") + .WithTopLevelStatements() + .VerifyNoIssues(); - [TestMethod] - public void ClassWithOnlyStaticMember_CSharp11() => - builder.AddPaths("ClassWithOnlyStaticMember.CSharp11.cs") - .WithOptions(ParseOptionsHelper.FromCSharp11) - .VerifyNoIssues(); // inheriting from interfaces with default members is compliant + [TestMethod] + public void ClassWithOnlyStaticMember_CSharp11() => + builder.AddPaths("ClassWithOnlyStaticMember.CSharp11.cs") + .WithOptions(ParseOptionsHelper.FromCSharp11) + .VerifyNoIssues(); - [TestMethod] - public void ClassWithOnlyStaticMember_CSharp12() => - builder.AddPaths("ClassWithOnlyStaticMember.CSharp12.cs") - .WithOptions(ParseOptionsHelper.FromCSharp12) - .Verify(); + [TestMethod] + public void ClassWithOnlyStaticMember_CSharp12() => + builder.AddPaths("ClassWithOnlyStaticMember.CSharp12.cs") + .WithOptions(ParseOptionsHelper.FromCSharp12) + .Verify(); #endif - } } diff --git a/analyzers/tests/SonarAnalyzer.Test/Rules/DateAndTimeShouldNotBeUsedasTypeForPrimaryKeyTest.cs b/analyzers/tests/SonarAnalyzer.Test/Rules/DateAndTimeShouldNotBeUsedasTypeForPrimaryKeyTest.cs index 41617dcb845..deb2dfd32a3 100644 --- a/analyzers/tests/SonarAnalyzer.Test/Rules/DateAndTimeShouldNotBeUsedasTypeForPrimaryKeyTest.cs +++ b/analyzers/tests/SonarAnalyzer.Test/Rules/DateAndTimeShouldNotBeUsedasTypeForPrimaryKeyTest.cs @@ -54,7 +54,7 @@ public class DateAndTimeShouldNotBeUsedAsTypeForPrimaryKeyTest verifierCS .AddPaths("DateAndTimeShouldNotBeUsedAsTypeForPrimaryKey.CSharp9.cs") .WithOptions(ParseOptionsHelper.FromCSharp9) - .VerifyNoIssues(); // records are compliant + .VerifyNoIssues(); #if NET @@ -68,11 +68,11 @@ public class DateAndTimeShouldNotBeUsedAsTypeForPrimaryKeyTest [TestMethod] public void DateAndTimeShouldNotBeUsedAsTypeForPrimaryKey_FluentApi_CS() => - verifierCS.AddPaths("DateAndTimeShouldNotBeUsedAsTypeForPrimaryKey.FluentApi.cs").VerifyNoIssues(); // FN, Fluent API is not supported + verifierCS.AddPaths("DateAndTimeShouldNotBeUsedAsTypeForPrimaryKey.FluentApi.cs").VerifyNoIssues(); [TestMethod] public void DateAndTimeShouldNotBeUsedAsTypeForPrimaryKey_FluentApi_VB() => - verifierVB.AddPaths("DateAndTimeShouldNotBeUsedAsTypeForPrimaryKey.FluentApi.vb").VerifyNoIssues(); // FN, Fluent API is not supported + verifierVB.AddPaths("DateAndTimeShouldNotBeUsedAsTypeForPrimaryKey.FluentApi.vb").VerifyNoIssues(); #endif diff --git a/analyzers/tests/SonarAnalyzer.Test/Rules/DisposableNotDisposedTest.cs b/analyzers/tests/SonarAnalyzer.Test/Rules/DisposableNotDisposedTest.cs index ddd83063038..bf8fa2e2f18 100644 --- a/analyzers/tests/SonarAnalyzer.Test/Rules/DisposableNotDisposedTest.cs +++ b/analyzers/tests/SonarAnalyzer.Test/Rules/DisposableNotDisposedTest.cs @@ -38,7 +38,7 @@ public class DisposableNotDisposedTest public void DisposableNotDisposed_ILogger() => builder.AddPaths("DisposableNotDisposed.ILogger.cs") .AddReferences(NuGetMetadataReference.MicrosoftExtensionsLoggingPackages(Constants.NuGetLatestVersion).ToArray()) - .VerifyNoIssues(); // FN, ILogger is not supported + .VerifyNoIssues(); #if NET diff --git a/analyzers/tests/SonarAnalyzer.Test/Rules/DoNotCopyArraysInPropertiesTest.cs b/analyzers/tests/SonarAnalyzer.Test/Rules/DoNotCopyArraysInPropertiesTest.cs index f65b7e79a53..a9894770e8c 100644 --- a/analyzers/tests/SonarAnalyzer.Test/Rules/DoNotCopyArraysInPropertiesTest.cs +++ b/analyzers/tests/SonarAnalyzer.Test/Rules/DoNotCopyArraysInPropertiesTest.cs @@ -20,32 +20,31 @@ using SonarAnalyzer.Rules.CSharp; -namespace SonarAnalyzer.Test.Rules +namespace SonarAnalyzer.Test.Rules; + +[TestClass] +public class DoNotCopyArraysInPropertiesTest { - [TestClass] - public class DoNotCopyArraysInPropertiesTest - { - private readonly VerifierBuilder builder = new VerifierBuilder(); + private readonly VerifierBuilder builder = new VerifierBuilder(); - [TestMethod] - public void DoNotCopyArraysInProperties() => - builder.AddPaths("DoNotCopyArraysInProperties.cs").Verify(); + [TestMethod] + public void DoNotCopyArraysInProperties() => + builder.AddPaths("DoNotCopyArraysInProperties.cs").Verify(); #if NET - [TestMethod] - public void DoNotCopyArraysInProperties_CSharp9() => - builder.AddPaths("DoNotCopyArraysInProperties.CSharp9.cs") - .WithOptions(ParseOptionsHelper.FromCSharp9) - .Verify(); + [TestMethod] + public void DoNotCopyArraysInProperties_CSharp9() => + builder.AddPaths("DoNotCopyArraysInProperties.CSharp9.cs") + .WithOptions(ParseOptionsHelper.FromCSharp9) + .Verify(); - [TestMethod] - public void DoNotCopyArraysInProperties_CSharp12() => - builder.AddPaths("DoNotCopyArraysInProperties.CSharp12.cs") - .WithOptions(ParseOptionsHelper.FromCSharp12) - .VerifyNoIssues(); // FN, collection initializers are not supported + [TestMethod] + public void DoNotCopyArraysInProperties_CSharp12() => + builder.AddPaths("DoNotCopyArraysInProperties.CSharp12.cs") + .WithOptions(ParseOptionsHelper.FromCSharp12) + .VerifyNoIssues(); #endif - } } diff --git a/analyzers/tests/SonarAnalyzer.Test/Rules/DoNotDecreaseMemberVisibilityTest.cs b/analyzers/tests/SonarAnalyzer.Test/Rules/DoNotDecreaseMemberVisibilityTest.cs index 575e91c555b..dfdfa2b0a7d 100644 --- a/analyzers/tests/SonarAnalyzer.Test/Rules/DoNotDecreaseMemberVisibilityTest.cs +++ b/analyzers/tests/SonarAnalyzer.Test/Rules/DoNotDecreaseMemberVisibilityTest.cs @@ -46,7 +46,7 @@ public class DoNotDecreaseMemberVisibilityTest public void DoNotDecreaseMemberVisibility_CSharp11() => builder.AddPaths("DoNotDecreaseMemberVisibility.CSharp11.cs") .WithOptions(ParseOptionsHelper.FromCSharp11) - .VerifyNoIssues(); // static interface methods are compliant + .VerifyNoIssues(); #endif diff --git a/analyzers/tests/SonarAnalyzer.Test/Rules/DoNotHideBaseClassMethodsTest.cs b/analyzers/tests/SonarAnalyzer.Test/Rules/DoNotHideBaseClassMethodsTest.cs index 0fb624c14fb..eafc8ed6e04 100644 --- a/analyzers/tests/SonarAnalyzer.Test/Rules/DoNotHideBaseClassMethodsTest.cs +++ b/analyzers/tests/SonarAnalyzer.Test/Rules/DoNotHideBaseClassMethodsTest.cs @@ -20,35 +20,34 @@ using SonarAnalyzer.Rules.CSharp; -namespace SonarAnalyzer.Test.Rules +namespace SonarAnalyzer.Test.Rules; + +[TestClass] +public class DoNotHideBaseClassMethodsTest { - [TestClass] - public class DoNotHideBaseClassMethodsTest - { - private readonly VerifierBuilder builder = new VerifierBuilder(); + private readonly VerifierBuilder builder = new VerifierBuilder(); - [TestMethod] - public void DoNotHideBaseClassMethods() => - builder.AddPaths("DoNotHideBaseClassMethods.cs", "DoNotHideBaseClassMethods2.cs") - .WithAutogenerateConcurrentFiles(false) - .Verify(); + [TestMethod] + public void DoNotHideBaseClassMethods() => + builder.AddPaths("DoNotHideBaseClassMethods.cs", "DoNotHideBaseClassMethods2.cs") + .WithAutogenerateConcurrentFiles(false) + .Verify(); #if NET - [TestMethod] - public void DoNotHideBaseClassMethods_CSharp9() => - builder.AddPaths("DoNotHideBaseClassMethods.CSharp9.cs") - .WithOptions(ParseOptionsHelper.FromCSharp9) - .WithConcurrentAnalysis(false) - .Verify(); + [TestMethod] + public void DoNotHideBaseClassMethods_CSharp9() => + builder.AddPaths("DoNotHideBaseClassMethods.CSharp9.cs") + .WithOptions(ParseOptionsHelper.FromCSharp9) + .WithConcurrentAnalysis(false) + .Verify(); - [TestMethod] - public void DoNotHideBaseClassMethods_CSharp11() => - builder.AddPaths("DoNotHideBaseClassMethods.CSharp11.cs") - .WithOptions(ParseOptionsHelper.FromCSharp11) - .VerifyNoIssues(); // hiding static interface methods is compliant + [TestMethod] + public void DoNotHideBaseClassMethods_CSharp11() => + builder.AddPaths("DoNotHideBaseClassMethods.CSharp11.cs") + .WithOptions(ParseOptionsHelper.FromCSharp11) + .VerifyNoIssues(); #endif - } } diff --git a/analyzers/tests/SonarAnalyzer.Test/Rules/DoNotOverloadOperatorEqualTest.cs b/analyzers/tests/SonarAnalyzer.Test/Rules/DoNotOverloadOperatorEqualTest.cs index e74c91c637f..46371d34092 100644 --- a/analyzers/tests/SonarAnalyzer.Test/Rules/DoNotOverloadOperatorEqualTest.cs +++ b/analyzers/tests/SonarAnalyzer.Test/Rules/DoNotOverloadOperatorEqualTest.cs @@ -20,32 +20,31 @@ using SonarAnalyzer.Rules.CSharp; -namespace SonarAnalyzer.Test.Rules +namespace SonarAnalyzer.Test.Rules; + +[TestClass] +public class DoNotOverloadOperatorEqualTest { - [TestClass] - public class DoNotOverloadOperatorEqualTest - { - private readonly VerifierBuilder builder = new VerifierBuilder(); + private readonly VerifierBuilder builder = new VerifierBuilder(); - [TestMethod] - public void DoNotOverloadOperatorEqual() => - builder.AddPaths("DoNotOverloadOperatorEqual.cs").Verify(); + [TestMethod] + public void DoNotOverloadOperatorEqual() => + builder.AddPaths("DoNotOverloadOperatorEqual.cs").Verify(); #if NET - [TestMethod] - public void DoNotOverloadOperatorEqual_CSharp9() => - builder.AddPaths("DoNotOverloadOperatorEqual.CSharp9.cs") - .WithOptions(ParseOptionsHelper.FromCSharp9) - .Verify(); + [TestMethod] + public void DoNotOverloadOperatorEqual_CSharp9() => + builder.AddPaths("DoNotOverloadOperatorEqual.CSharp9.cs") + .WithOptions(ParseOptionsHelper.FromCSharp9) + .Verify(); - [TestMethod] - public void DoNotOverloadOperatorEqual_CSharp11() => - builder.AddPaths("DoNotOverloadOperatorEqual.CSharp11.cs") - .WithOptions(ParseOptionsHelper.FromCSharp11) - .VerifyNoIssues(); // overloading as a static interface method is compliant + [TestMethod] + public void DoNotOverloadOperatorEqual_CSharp11() => + builder.AddPaths("DoNotOverloadOperatorEqual.CSharp11.cs") + .WithOptions(ParseOptionsHelper.FromCSharp11) + .VerifyNoIssues(); #endif - } } diff --git a/analyzers/tests/SonarAnalyzer.Test/Rules/EmptyMethodTest.cs b/analyzers/tests/SonarAnalyzer.Test/Rules/EmptyMethodTest.cs index fd366c9d060..41c08650f30 100644 --- a/analyzers/tests/SonarAnalyzer.Test/Rules/EmptyMethodTest.cs +++ b/analyzers/tests/SonarAnalyzer.Test/Rules/EmptyMethodTest.cs @@ -21,104 +21,103 @@ using CS = SonarAnalyzer.Rules.CSharp; using VB = SonarAnalyzer.Rules.VisualBasic; -namespace SonarAnalyzer.Test.Rules +namespace SonarAnalyzer.Test.Rules; + +[TestClass] +public class EmptyMethodTest { - [TestClass] - public class EmptyMethodTest - { - private readonly VerifierBuilder builderCS = new VerifierBuilder(); - private readonly VerifierBuilder builderVB = new VerifierBuilder(); - - [TestMethod] - public void EmptyMethod() => - builderCS.AddPaths("EmptyMethod.cs") - .WithOptions(ParseOptionsHelper.FromCSharp8) - .AddReferences(MetadataReferenceFacade.NetStandard21) - .Verify(); + private readonly VerifierBuilder builderCS = new VerifierBuilder(); + private readonly VerifierBuilder builderVB = new VerifierBuilder(); + + [TestMethod] + public void EmptyMethod() => + builderCS.AddPaths("EmptyMethod.cs") + .WithOptions(ParseOptionsHelper.FromCSharp8) + .AddReferences(MetadataReferenceFacade.NetStandard21) + .Verify(); #if NET - [TestMethod] - public void EmptyMethod_CSharp9() => - builderCS.AddPaths("EmptyMethod.CSharp9.cs") - .WithTopLevelStatements() - .WithOptions(ParseOptionsHelper.FromCSharp9) - .Verify(); - - [TestMethod] - public void EmptyMethod_CSharp9_CodeFix_Throw() => - builderCS.WithCodeFix() - .AddPaths("EmptyMethod.CSharp9.cs") - .WithTopLevelStatements() - .WithCodeFixedPaths("EmptyMethod.CSharp9.Throw.Fixed.cs") - .WithCodeFixTitle(CS.EmptyMethodCodeFix.TitleThrow) - .VerifyCodeFix(); - - [TestMethod] - public void EmptyMethod_CSharp9_CodeFix_Comment() => - builderCS.WithCodeFix() - .AddPaths("EmptyMethod.CSharp9.cs") - .WithTopLevelStatements() - .WithCodeFixedPaths("EmptyMethod.CSharp9.Comment.Fixed.cs") - .WithCodeFixTitle(CS.EmptyMethodCodeFix.TitleComment) - .VerifyCodeFix(); - - [TestMethod] - public void EmptyMethod_CSharp10() => - builderCS.AddPaths("EmptyMethod.CSharp10.cs") - .WithOptions(ParseOptionsHelper.FromCSharp10) - .VerifyNoIssues(); // FN, parameterless struct constructors are not supported - - [TestMethod] - public void EmptyMethod_CSharp11() => - builderCS.AddPaths("EmptyMethod.CSharp11.cs") - .WithOptions(ParseOptionsHelper.FromCSharp11) - .Verify(); + [TestMethod] + public void EmptyMethod_CSharp9() => + builderCS.AddPaths("EmptyMethod.CSharp9.cs") + .WithTopLevelStatements() + .WithOptions(ParseOptionsHelper.FromCSharp9) + .Verify(); + + [TestMethod] + public void EmptyMethod_CSharp9_CodeFix_Throw() => + builderCS.WithCodeFix() + .AddPaths("EmptyMethod.CSharp9.cs") + .WithTopLevelStatements() + .WithCodeFixedPaths("EmptyMethod.CSharp9.Throw.Fixed.cs") + .WithCodeFixTitle(CS.EmptyMethodCodeFix.TitleThrow) + .VerifyCodeFix(); + + [TestMethod] + public void EmptyMethod_CSharp9_CodeFix_Comment() => + builderCS.WithCodeFix() + .AddPaths("EmptyMethod.CSharp9.cs") + .WithTopLevelStatements() + .WithCodeFixedPaths("EmptyMethod.CSharp9.Comment.Fixed.cs") + .WithCodeFixTitle(CS.EmptyMethodCodeFix.TitleComment) + .VerifyCodeFix(); + + [TestMethod] + public void EmptyMethod_CSharp10() => + builderCS.AddPaths("EmptyMethod.CSharp10.cs") + .WithOptions(ParseOptionsHelper.FromCSharp10) + .VerifyNoIssues(); + + [TestMethod] + public void EmptyMethod_CSharp11() => + builderCS.AddPaths("EmptyMethod.CSharp11.cs") + .WithOptions(ParseOptionsHelper.FromCSharp11) + .Verify(); #endif - [TestMethod] - public void EmptyMethod_CodeFix_Throw() => - builderCS.WithCodeFix() - .AddPaths("EmptyMethod.cs") - .WithCodeFixedPaths("EmptyMethod.Throw.Fixed.cs") - .WithCodeFixTitle(CS.EmptyMethodCodeFix.TitleThrow) - .VerifyCodeFix(); - - [TestMethod] - public void EmptyMethod_CodeFix_Comment() => - builderCS.WithCodeFix() - .AddPaths("EmptyMethod.cs") - .WithCodeFixedPaths("EmptyMethod.Comment.Fixed.cs") - .WithCodeFixTitle(CS.EmptyMethodCodeFix.TitleComment) - .VerifyCodeFix(); - - [TestMethod] - public void EmptyMethod_WithoutClosingBracket_CodeFix_Comment() => - builderCS.WithCodeFix() - .AddPaths("EmptyMethod.WithoutClosingBracket.cs") - .WithCodeFixedPaths("EmptyMethod.WithoutClosingBracket.Comment.Fixed.cs") - .WithCodeFixTitle(CS.EmptyMethodCodeFix.TitleComment) - .VerifyCodeFix(); - - [TestMethod] - public void EmptyMethod_VB() => - builderVB.AddPaths("EmptyMethod.vb").Verify(); - - [TestMethod] - public void EmptyMethod_WithVirtualOverride_RaisesIssueForMainProject_CS() => - builderCS.AddPaths("EmptyMethod.OverrideVirtual.cs").Verify(); - - [TestMethod] - public void EmptyMethod_WithVirtualOverride_DoesNotRaiseIssuesForTestProject_CS() => - builderCS.AddPaths("EmptyMethod.OverrideVirtual.cs").AddTestReference().VerifyNoIssues(); - - [TestMethod] - public void EmptyMethod_WithVirtualOverride_RaisesIssueForMainProject_VB() => - builderVB.AddPaths("EmptyMethod.OverrideVirtual.vb").Verify(); - - [TestMethod] - public void EmptyMethod_WithVirtualOverride_DoesNotRaiseIssuesForTestProject_VB() => - builderVB.AddPaths("EmptyMethod.OverrideVirtual.vb").AddTestReference().VerifyNoIssues(); - } + [TestMethod] + public void EmptyMethod_CodeFix_Throw() => + builderCS.WithCodeFix() + .AddPaths("EmptyMethod.cs") + .WithCodeFixedPaths("EmptyMethod.Throw.Fixed.cs") + .WithCodeFixTitle(CS.EmptyMethodCodeFix.TitleThrow) + .VerifyCodeFix(); + + [TestMethod] + public void EmptyMethod_CodeFix_Comment() => + builderCS.WithCodeFix() + .AddPaths("EmptyMethod.cs") + .WithCodeFixedPaths("EmptyMethod.Comment.Fixed.cs") + .WithCodeFixTitle(CS.EmptyMethodCodeFix.TitleComment) + .VerifyCodeFix(); + + [TestMethod] + public void EmptyMethod_WithoutClosingBracket_CodeFix_Comment() => + builderCS.WithCodeFix() + .AddPaths("EmptyMethod.WithoutClosingBracket.cs") + .WithCodeFixedPaths("EmptyMethod.WithoutClosingBracket.Comment.Fixed.cs") + .WithCodeFixTitle(CS.EmptyMethodCodeFix.TitleComment) + .VerifyCodeFix(); + + [TestMethod] + public void EmptyMethod_VB() => + builderVB.AddPaths("EmptyMethod.vb").Verify(); + + [TestMethod] + public void EmptyMethod_WithVirtualOverride_RaisesIssueForMainProject_CS() => + builderCS.AddPaths("EmptyMethod.OverrideVirtual.cs").Verify(); + + [TestMethod] + public void EmptyMethod_WithVirtualOverride_DoesNotRaiseIssuesForTestProject_CS() => + builderCS.AddPaths("EmptyMethod.OverrideVirtual.cs").AddTestReference().VerifyNoIssues(); + + [TestMethod] + public void EmptyMethod_WithVirtualOverride_RaisesIssueForMainProject_VB() => + builderVB.AddPaths("EmptyMethod.OverrideVirtual.vb").Verify(); + + [TestMethod] + public void EmptyMethod_WithVirtualOverride_DoesNotRaiseIssuesForTestProject_VB() => + builderVB.AddPaths("EmptyMethod.OverrideVirtual.vb").AddTestReference().VerifyNoIssues(); } diff --git a/analyzers/tests/SonarAnalyzer.Test/Rules/EmptyNestedBlockTest.cs b/analyzers/tests/SonarAnalyzer.Test/Rules/EmptyNestedBlockTest.cs index 653e4d98c94..e26de171799 100644 --- a/analyzers/tests/SonarAnalyzer.Test/Rules/EmptyNestedBlockTest.cs +++ b/analyzers/tests/SonarAnalyzer.Test/Rules/EmptyNestedBlockTest.cs @@ -21,31 +21,30 @@ using CS = SonarAnalyzer.Rules.CSharp; using VB = SonarAnalyzer.Rules.VisualBasic; -namespace SonarAnalyzer.Test.Rules +namespace SonarAnalyzer.Test.Rules; + +[TestClass] +public class EmptyNestedBlockTest { - [TestClass] - public class EmptyNestedBlockTest - { - private readonly VerifierBuilder builderCS = new VerifierBuilder(); + private readonly VerifierBuilder builderCS = new VerifierBuilder(); - [TestMethod] - public void EmptyNestedBlock_CS() => - builderCS.AddPaths("EmptyNestedBlock.cs", "EmptyNestedBlock2.cs") - .WithAutogenerateConcurrentFiles(false) - .Verify(); + [TestMethod] + public void EmptyNestedBlock_CS() => + builderCS.AddPaths("EmptyNestedBlock.cs", "EmptyNestedBlock2.cs") + .WithAutogenerateConcurrentFiles(false) + .Verify(); #if NET - [TestMethod] - public void EmptyNestedBlock_CSharp10() => - builderCS.AddPaths("EmptyNestedBlock.CSharp10.cs") - .WithOptions(ParseOptionsHelper.FromCSharp10) - .VerifyNoIssues(); // FN, parameterless struct constructors are not supported + [TestMethod] + public void EmptyNestedBlock_CSharp10() => + builderCS.AddPaths("EmptyNestedBlock.CSharp10.cs") + .WithOptions(ParseOptionsHelper.FromCSharp10) + .VerifyNoIssues(); #endif - [TestMethod] - public void EmptyNestedBlock_VB() => - new VerifierBuilder().AddPaths("EmptyNestedBlock.vb").Verify(); - } + [TestMethod] + public void EmptyNestedBlock_VB() => + new VerifierBuilder().AddPaths("EmptyNestedBlock.vb").Verify(); } diff --git a/analyzers/tests/SonarAnalyzer.Test/Rules/ForLoopCounterChangedTest.cs b/analyzers/tests/SonarAnalyzer.Test/Rules/ForLoopCounterChangedTest.cs index e905d3dbd49..b0947dfe6d0 100644 --- a/analyzers/tests/SonarAnalyzer.Test/Rules/ForLoopCounterChangedTest.cs +++ b/analyzers/tests/SonarAnalyzer.Test/Rules/ForLoopCounterChangedTest.cs @@ -20,32 +20,31 @@ using SonarAnalyzer.Rules.CSharp; -namespace SonarAnalyzer.Test.Rules +namespace SonarAnalyzer.Test.Rules; + +[TestClass] +public class ForLoopCounterChangedTest { - [TestClass] - public class ForLoopCounterChangedTest - { - private readonly VerifierBuilder builder = new VerifierBuilder(); + private readonly VerifierBuilder builder = new VerifierBuilder(); - [TestMethod] - public void ForLoopCounterChanged() => - builder.AddPaths("ForLoopCounterChanged.cs").Verify(); + [TestMethod] + public void ForLoopCounterChanged() => + builder.AddPaths("ForLoopCounterChanged.cs").Verify(); #if NET - [TestMethod] - public void ForLoopCounterChanged_CSharp10() => - builder.AddPaths("ForLoopCounterChanged.CSharp10.cs") - .WithOptions(ParseOptionsHelper.FromCSharp10) - .Verify(); + [TestMethod] + public void ForLoopCounterChanged_CSharp10() => + builder.AddPaths("ForLoopCounterChanged.CSharp10.cs") + .WithOptions(ParseOptionsHelper.FromCSharp10) + .Verify(); - [TestMethod] - public void ForLoopCounterChanged_CSharp11() => - builder.AddPaths("ForLoopCounterChanged.CSharp11.cs") - .WithOptions(ParseOptionsHelper.FromCSharp11) - .VerifyNoIssues(); // FN, compound assignments are not supported + [TestMethod] + public void ForLoopCounterChanged_CSharp11() => + builder.AddPaths("ForLoopCounterChanged.CSharp11.cs") + .WithOptions(ParseOptionsHelper.FromCSharp11) + .VerifyNoIssues(); #endif - } } diff --git a/analyzers/tests/SonarAnalyzer.Test/Rules/Hotspots/CreatingHashAlgorithmsTest.cs b/analyzers/tests/SonarAnalyzer.Test/Rules/Hotspots/CreatingHashAlgorithmsTest.cs index 313d5a0599e..6334ffaf170 100644 --- a/analyzers/tests/SonarAnalyzer.Test/Rules/Hotspots/CreatingHashAlgorithmsTest.cs +++ b/analyzers/tests/SonarAnalyzer.Test/Rules/Hotspots/CreatingHashAlgorithmsTest.cs @@ -21,57 +21,56 @@ using CS = SonarAnalyzer.Rules.CSharp; using VB = SonarAnalyzer.Rules.VisualBasic; -namespace SonarAnalyzer.Test.Rules +namespace SonarAnalyzer.Test.Rules; + +[TestClass] +public class CreatingHashAlgorithmsTest { - [TestClass] - public class CreatingHashAlgorithmsTest - { - private readonly VerifierBuilder builderCS = new VerifierBuilder().WithBasePath("Hotspots") - .AddReferences(MetadataReferenceFacade.SystemSecurityCryptography) - .AddAnalyzer(() => new CS.CreatingHashAlgorithms(AnalyzerConfiguration.AlwaysEnabled)); - private readonly VerifierBuilder builderVB = new VerifierBuilder().WithBasePath("Hotspots") - .AddReferences(MetadataReferenceFacade.SystemSecurityCryptography) - .AddAnalyzer(() => new VB.CreatingHashAlgorithms(AnalyzerConfiguration.AlwaysEnabled)); - - [TestMethod] - public void CreatingHashAlgorithms_CSharp8() => - builderCS.AddPaths("CreatingHashAlgorithms.cs") - .WithOptions(ParseOptionsHelper.FromCSharp8) - .Verify(); + private readonly VerifierBuilder builderCS = new VerifierBuilder().WithBasePath("Hotspots") + .AddReferences(MetadataReferenceFacade.SystemSecurityCryptography) + .AddAnalyzer(() => new CS.CreatingHashAlgorithms(AnalyzerConfiguration.AlwaysEnabled)); + private readonly VerifierBuilder builderVB = new VerifierBuilder().WithBasePath("Hotspots") + .AddReferences(MetadataReferenceFacade.SystemSecurityCryptography) + .AddAnalyzer(() => new VB.CreatingHashAlgorithms(AnalyzerConfiguration.AlwaysEnabled)); + + [TestMethod] + public void CreatingHashAlgorithms_CSharp8() => + builderCS.AddPaths("CreatingHashAlgorithms.cs") + .WithOptions(ParseOptionsHelper.FromCSharp8) + .Verify(); #if NETFRAMEWORK // HMACRIPEMD160, MD5Cng, RIPEMD160Managed and RIPEMD160 are available only for .Net Framework - [TestMethod] - public void CreatingHashAlgorithms_CS_NetFx() => - builderCS.AddPaths("CreatingHashAlgorithms.NetFramework.cs") - .WithOptions(ParseOptionsHelper.FromCSharp8) - .Verify(); + [TestMethod] + public void CreatingHashAlgorithms_CS_NetFx() => + builderCS.AddPaths("CreatingHashAlgorithms.NetFramework.cs") + .WithOptions(ParseOptionsHelper.FromCSharp8) + .Verify(); #endif - [TestMethod] - public void CreatingHashAlgorithms_VB() => - builderVB.AddPaths("CreatingHashAlgorithms.vb").Verify(); + [TestMethod] + public void CreatingHashAlgorithms_VB() => + builderVB.AddPaths("CreatingHashAlgorithms.vb").Verify(); #if NETFRAMEWORK // HMACRIPEMD160, MD5Cng, RIPEMD160Managed and RIPEMD160 are available only for .Net Framework - [TestMethod] - public void CreatingHashAlgorithms_VB_NetFx() => - builderVB.AddPaths("CreatingHashAlgorithms.NetFramework.vb").Verify(); + [TestMethod] + public void CreatingHashAlgorithms_VB_NetFx() => + builderVB.AddPaths("CreatingHashAlgorithms.NetFramework.vb").Verify(); #endif #if NET - [TestMethod] - public void CreatingHashAlgorithms_CSharp11() => - builderCS.AddPaths("CreatingHashAlgorithms.CSharp11.cs").WithOptions(ParseOptionsHelper.FromCSharp11).Verify(); + [TestMethod] + public void CreatingHashAlgorithms_CSharp11() => + builderCS.AddPaths("CreatingHashAlgorithms.CSharp11.cs").WithOptions(ParseOptionsHelper.FromCSharp11).Verify(); - [TestMethod] - public void CreatingHashAlgorithms_CSharp12() => - builderCS.AddPaths("CreatingHashAlgorithms.CSharp12.cs").WithOptions(ParseOptionsHelper.FromCSharp12).VerifyNoIssues(); // primary constructors are not supported yet + [TestMethod] + public void CreatingHashAlgorithms_CSharp12() => + builderCS.AddPaths("CreatingHashAlgorithms.CSharp12.cs").WithOptions(ParseOptionsHelper.FromCSharp12).VerifyNoIssues(); #endif - } } diff --git a/analyzers/tests/SonarAnalyzer.Test/Rules/MethodShouldNotOnlyReturnConstantTest.cs b/analyzers/tests/SonarAnalyzer.Test/Rules/MethodShouldNotOnlyReturnConstantTest.cs index 4b669d8af45..158e823a342 100644 --- a/analyzers/tests/SonarAnalyzer.Test/Rules/MethodShouldNotOnlyReturnConstantTest.cs +++ b/analyzers/tests/SonarAnalyzer.Test/Rules/MethodShouldNotOnlyReturnConstantTest.cs @@ -20,28 +20,27 @@ using SonarAnalyzer.Rules.CSharp; -namespace SonarAnalyzer.Test.Rules +namespace SonarAnalyzer.Test.Rules; + +[TestClass] +public class MethodShouldNotOnlyReturnConstantTest { - [TestClass] - public class MethodShouldNotOnlyReturnConstantTest - { - private readonly VerifierBuilder builder = new VerifierBuilder(); + private readonly VerifierBuilder builder = new VerifierBuilder(); - [TestMethod] - public void MethodShouldNotOnlyReturnConstant() => - builder.AddPaths("MethodShouldNotOnlyReturnConstant.cs").Verify(); + [TestMethod] + public void MethodShouldNotOnlyReturnConstant() => + builder.AddPaths("MethodShouldNotOnlyReturnConstant.cs").Verify(); #if NET - [TestMethod] - public void MethodShouldNotOnlyReturnConstant_CSharp8() => - builder.AddPaths("MethodShouldNotOnlyReturnConstant.CSharp8.cs").WithOptions(ParseOptionsHelper.FromCSharp8).VerifyNoIssues(); // default interface methods are compliant + [TestMethod] + public void MethodShouldNotOnlyReturnConstant_CSharp8() => + builder.AddPaths("MethodShouldNotOnlyReturnConstant.CSharp8.cs").WithOptions(ParseOptionsHelper.FromCSharp8).VerifyNoIssues(); - [TestMethod] - public void MethodShouldNotOnlyReturnConstant_CSharp11() => - builder.AddPaths("MethodShouldNotOnlyReturnConstant.CSharp11.cs").WithOptions(ParseOptionsHelper.FromCSharp11).Verify(); + [TestMethod] + public void MethodShouldNotOnlyReturnConstant_CSharp11() => + builder.AddPaths("MethodShouldNotOnlyReturnConstant.CSharp11.cs").WithOptions(ParseOptionsHelper.FromCSharp11).Verify(); #endif - } } diff --git a/analyzers/tests/SonarAnalyzer.Test/Rules/OperatorsShouldBeOverloadedConsistentlyTest.cs b/analyzers/tests/SonarAnalyzer.Test/Rules/OperatorsShouldBeOverloadedConsistentlyTest.cs index 329c6d039f4..a3785aa9b33 100644 --- a/analyzers/tests/SonarAnalyzer.Test/Rules/OperatorsShouldBeOverloadedConsistentlyTest.cs +++ b/analyzers/tests/SonarAnalyzer.Test/Rules/OperatorsShouldBeOverloadedConsistentlyTest.cs @@ -35,11 +35,11 @@ public class OperatorsShouldBeOverloadedConsistentlyTest [TestMethod] public void OperatorsShouldBeOverloadedConsistently_CSharp9() => - builder.AddPaths("OperatorsShouldBeOverloadedConsistently.CSharp9.cs").WithOptions(ParseOptionsHelper.FromCSharp9).VerifyNoIssues(); // records are compliant + builder.AddPaths("OperatorsShouldBeOverloadedConsistently.CSharp9.cs").WithOptions(ParseOptionsHelper.FromCSharp9).VerifyNoIssues(); [TestMethod] public void OperatorsShouldBeOverloadedConsistently_CSharp11() => - builder.AddPaths("OperatorsShouldBeOverloadedConsistently.CSharp11.cs").WithOptions(ParseOptionsHelper.FromCSharp11).VerifyNoIssues(); // static virtual interface methods are compliant + builder.AddPaths("OperatorsShouldBeOverloadedConsistently.CSharp11.cs").WithOptions(ParseOptionsHelper.FromCSharp11).VerifyNoIssues(); #endif diff --git a/analyzers/tests/SonarAnalyzer.Test/Rules/OptionalParameterTest.cs b/analyzers/tests/SonarAnalyzer.Test/Rules/OptionalParameterTest.cs index 2dad88f160a..0812df933be 100644 --- a/analyzers/tests/SonarAnalyzer.Test/Rules/OptionalParameterTest.cs +++ b/analyzers/tests/SonarAnalyzer.Test/Rules/OptionalParameterTest.cs @@ -21,33 +21,32 @@ using CS = SonarAnalyzer.Rules.CSharp; using VB = SonarAnalyzer.Rules.VisualBasic; -namespace SonarAnalyzer.Test.Rules +namespace SonarAnalyzer.Test.Rules; + +[TestClass] +public class OptionalParameterTest { - [TestClass] - public class OptionalParameterTest - { - private readonly VerifierBuilder builderCS = new VerifierBuilder(); - private readonly VerifierBuilder builderVB = new VerifierBuilder(); + private readonly VerifierBuilder builderCS = new VerifierBuilder(); + private readonly VerifierBuilder builderVB = new VerifierBuilder(); - [TestMethod] - public void OptionalParameter_CS() => - builderCS.AddPaths("OptionalParameter.cs").Verify(); + [TestMethod] + public void OptionalParameter_CS() => + builderCS.AddPaths("OptionalParameter.cs").Verify(); - [TestMethod] - public void OptionalParameter_VB() => - builderVB.AddPaths("OptionalParameter.vb").Verify(); + [TestMethod] + public void OptionalParameter_VB() => + builderVB.AddPaths("OptionalParameter.vb").Verify(); #if NET - [TestMethod] - public void OptionalParameter_CSharp10() => - builderCS.AddPaths("OptionalParameter.CSharp10.cs").WithOptions(ParseOptionsHelper.FromCSharp10).VerifyNoIssues(); // CallerArgumentExpression is compliant + [TestMethod] + public void OptionalParameter_CSharp10() => + builderCS.AddPaths("OptionalParameter.CSharp10.cs").WithOptions(ParseOptionsHelper.FromCSharp10).VerifyNoIssues(); - [TestMethod] - public void OptionalParameter_CSharp11() => - builderCS.AddPaths("OptionalParameter.CSharp11.cs").WithOptions(ParseOptionsHelper.FromCSharp11).Verify(); + [TestMethod] + public void OptionalParameter_CSharp11() => + builderCS.AddPaths("OptionalParameter.CSharp11.cs").WithOptions(ParseOptionsHelper.FromCSharp11).Verify(); #endif - } } diff --git a/analyzers/tests/SonarAnalyzer.Test/Rules/OverrideGetHashCodeOnOverridingEqualsTest.cs b/analyzers/tests/SonarAnalyzer.Test/Rules/OverrideGetHashCodeOnOverridingEqualsTest.cs index 86d8b6efa3d..c5517d34cff 100644 --- a/analyzers/tests/SonarAnalyzer.Test/Rules/OverrideGetHashCodeOnOverridingEqualsTest.cs +++ b/analyzers/tests/SonarAnalyzer.Test/Rules/OverrideGetHashCodeOnOverridingEqualsTest.cs @@ -20,24 +20,23 @@ using SonarAnalyzer.Rules.CSharp; -namespace SonarAnalyzer.Test.Rules +namespace SonarAnalyzer.Test.Rules; + +[TestClass] +public class OverrideGetHashCodeOnOverridingEqualsTest { - [TestClass] - public class OverrideGetHashCodeOnOverridingEqualsTest - { - private readonly VerifierBuilder builder = new VerifierBuilder(); + private readonly VerifierBuilder builder = new VerifierBuilder(); - [TestMethod] - public void OverrideGetHashCodeOnOverridingEquals() => - builder.AddPaths("OverrideGetHashCodeOnOverridingEquals.cs").Verify(); + [TestMethod] + public void OverrideGetHashCodeOnOverridingEquals() => + builder.AddPaths("OverrideGetHashCodeOnOverridingEquals.cs").Verify(); #if NET - [TestMethod] - public void OverrideGetHashCodeOnOverridingEquals_CSharp9() => - builder.AddPaths("OverrideGetHashCodeOnOverridingEquals.CSharp9.cs").WithOptions(ParseOptionsHelper.FromCSharp9).VerifyNoIssues(); // records are compliant + [TestMethod] + public void OverrideGetHashCodeOnOverridingEquals_CSharp9() => + builder.AddPaths("OverrideGetHashCodeOnOverridingEquals.CSharp9.cs").WithOptions(ParseOptionsHelper.FromCSharp9).VerifyNoIssues(); #endif - } } diff --git a/analyzers/tests/SonarAnalyzer.Test/Rules/StreamReadStatementTest.cs b/analyzers/tests/SonarAnalyzer.Test/Rules/StreamReadStatementTest.cs index 6d0c70c4028..7a993ff4f4f 100644 --- a/analyzers/tests/SonarAnalyzer.Test/Rules/StreamReadStatementTest.cs +++ b/analyzers/tests/SonarAnalyzer.Test/Rules/StreamReadStatementTest.cs @@ -20,28 +20,27 @@ using SonarAnalyzer.Rules.CSharp; -namespace SonarAnalyzer.Test.Rules +namespace SonarAnalyzer.Test.Rules; + +[TestClass] +public class StreamReadStatementTest { - [TestClass] - public class StreamReadStatementTest - { - private readonly VerifierBuilder builder = new VerifierBuilder(); + private readonly VerifierBuilder builder = new VerifierBuilder(); - [TestMethod] - public void StreamReadStatement() => - builder.AddPaths("StreamReadStatement.cs").Verify(); + [TestMethod] + public void StreamReadStatement() => + builder.AddPaths("StreamReadStatement.cs").Verify(); #if NET - [TestMethod] - public void StreamReadStatement_CSharp10() => - builder.AddPaths("StreamReadStatement.CSharp10.cs").WithOptions(ParseOptionsHelper.FromCSharp10).VerifyNoIssues(); // discards do not raise + [TestMethod] + public void StreamReadStatement_CSharp10() => + builder.AddPaths("StreamReadStatement.CSharp10.cs").WithOptions(ParseOptionsHelper.FromCSharp10).VerifyNoIssues(); - [TestMethod] - public void StreamReadStatement_CSharp11() => - builder.AddPaths("StreamReadStatement.CSharp11.cs").WithOptions(ParseOptionsHelper.FromCSharp11).Verify(); + [TestMethod] + public void StreamReadStatement_CSharp11() => + builder.AddPaths("StreamReadStatement.CSharp11.cs").WithOptions(ParseOptionsHelper.FromCSharp11).Verify(); #endif - } } diff --git a/analyzers/tests/SonarAnalyzer.Test/Rules/TypeMemberVisibilityTest.cs b/analyzers/tests/SonarAnalyzer.Test/Rules/TypeMemberVisibilityTest.cs index 44d006e7521..35661b846ad 100644 --- a/analyzers/tests/SonarAnalyzer.Test/Rules/TypeMemberVisibilityTest.cs +++ b/analyzers/tests/SonarAnalyzer.Test/Rules/TypeMemberVisibilityTest.cs @@ -20,32 +20,31 @@ using SonarAnalyzer.Rules.CSharp; -namespace SonarAnalyzer.Test.Rules +namespace SonarAnalyzer.Test.Rules; + +[TestClass] +public class TypeMemberVisibilityTest { - [TestClass] - public class TypeMemberVisibilityTest - { - private readonly VerifierBuilder builder = new VerifierBuilder(); + private readonly VerifierBuilder builder = new VerifierBuilder(); - [TestMethod] - public void TypeMemberVisibility_CS() => - builder.AddPaths("TypeMemberVisibility.cs").Verify(); + [TestMethod] + public void TypeMemberVisibility_CS() => + builder.AddPaths("TypeMemberVisibility.cs").Verify(); #if NET - [TestMethod] - public void TypeMemberVisibility_CSharp9() => - builder.AddPaths("TypeMemberVisibility.CSharp9.cs").WithOptions(ParseOptionsHelper.FromCSharp9).Verify(); + [TestMethod] + public void TypeMemberVisibility_CSharp9() => + builder.AddPaths("TypeMemberVisibility.CSharp9.cs").WithOptions(ParseOptionsHelper.FromCSharp9).Verify(); - [TestMethod] - public void TypeMemberVisibility_CSharp10() => - builder.AddPaths("TypeMemberVisibility.CSharp10.cs").WithOptions(ParseOptionsHelper.FromCSharp10).Verify(); + [TestMethod] + public void TypeMemberVisibility_CSharp10() => + builder.AddPaths("TypeMemberVisibility.CSharp10.cs").WithOptions(ParseOptionsHelper.FromCSharp10).Verify(); - [TestMethod] - public void TypeMemberVisibility_CSharp11() => - builder.AddPaths("TypeMemberVisibility.CSharp11.cs").WithOptions(ParseOptionsHelper.FromCSharp11).VerifyNoIssues(); // file-scoped types are compliant + [TestMethod] + public void TypeMemberVisibility_CSharp11() => + builder.AddPaths("TypeMemberVisibility.CSharp11.cs").WithOptions(ParseOptionsHelper.FromCSharp11).VerifyNoIssues(); #endif - } } diff --git a/analyzers/tests/SonarAnalyzer.Test/Rules/UnnecessaryUsingsTest.cs b/analyzers/tests/SonarAnalyzer.Test/Rules/UnnecessaryUsingsTest.cs index a3236cd7423..52b6157a309 100644 --- a/analyzers/tests/SonarAnalyzer.Test/Rules/UnnecessaryUsingsTest.cs +++ b/analyzers/tests/SonarAnalyzer.Test/Rules/UnnecessaryUsingsTest.cs @@ -122,7 +122,7 @@ public class UnnecessaryUsingsTest [TestMethod] public void UnnecessaryUsings_CSharp12() => - builder.AddPaths("UnnecessaryUsings.CSharp12.cs").WithOptions(ParseOptionsHelper.FromCSharp12).VerifyNoIssues(); // FN, C#12 features are not supported + builder.AddPaths("UnnecessaryUsings.CSharp12.cs").WithOptions(ParseOptionsHelper.FromCSharp12).VerifyNoIssues(); #elif NETFRAMEWORK diff --git a/analyzers/tests/SonarAnalyzer.Test/Rules/ValueTypeShouldImplementIEquatableTest.cs b/analyzers/tests/SonarAnalyzer.Test/Rules/ValueTypeShouldImplementIEquatableTest.cs index 052b37001e0..3a153da8091 100644 --- a/analyzers/tests/SonarAnalyzer.Test/Rules/ValueTypeShouldImplementIEquatableTest.cs +++ b/analyzers/tests/SonarAnalyzer.Test/Rules/ValueTypeShouldImplementIEquatableTest.cs @@ -37,7 +37,7 @@ public class ValueTypeShouldImplementIEquatableTest [TestMethod] public void ValueTypeShouldImplementIEquatable_CSharp10() => - builderCS.AddPaths("ValueTypeShouldImplementIEquatable.CSharp10.cs").WithOptions(ParseOptionsHelper.FromCSharp10).VerifyNoIssues(); // record structs are compliant + builderCS.AddPaths("ValueTypeShouldImplementIEquatable.CSharp10.cs").WithOptions(ParseOptionsHelper.FromCSharp10).VerifyNoIssues(); #endif