From c8b4f48a20accd0e37ff2f5b07d1366d9581f8de Mon Sep 17 00:00:00 2001 From: Antonio Aversa Date: Mon, 27 Feb 2023 14:30:00 +0100 Subject: [PATCH] Update UTs after change of messages in rspec --- .../Rules/LockedFieldShouldBeReadonly.cs | 10 ++++---- .../TestCases/LockedFieldShouldBeReadonly.cs | 24 +++++++++---------- 2 files changed, 17 insertions(+), 17 deletions(-) diff --git a/analyzers/src/SonarAnalyzer.CSharp/Rules/LockedFieldShouldBeReadonly.cs b/analyzers/src/SonarAnalyzer.CSharp/Rules/LockedFieldShouldBeReadonly.cs index 4f1f07a76fa..1eecffa3b58 100644 --- a/analyzers/src/SonarAnalyzer.CSharp/Rules/LockedFieldShouldBeReadonly.cs +++ b/analyzers/src/SonarAnalyzer.CSharp/Rules/LockedFieldShouldBeReadonly.cs @@ -25,7 +25,7 @@ public sealed class LockedFieldShouldBeReadonly : SonarDiagnosticAnalyzer { private const string DiagnosticId = "S2445"; - private static readonly DiagnosticDescriptor Rule = DescriptorFactory.Create(DiagnosticId, "{0}"); + private static readonly DiagnosticDescriptor Rule = DescriptorFactory.Create(DiagnosticId, "Do not lock on {0}, use a readonly field instead."); public override ImmutableArray SupportedDiagnostics => ImmutableArray.Create(Rule); @@ -37,22 +37,22 @@ private static void CheckLockStatement(SonarSyntaxNodeReportingContext context) var expression = ((LockStatementSyntax)context.Node).Expression?.RemoveParentheses(); if (IsCreation(expression)) { - ReportIssue("Locking on a new instance is a no-op, use a 'readonly' field instead."); + ReportIssue("a new instance because is a no-op"); } else { var lazySymbol = new Lazy(() => context.SemanticModel.GetSymbolInfo(expression).Symbol); if (IsOfTypeString(expression, lazySymbol)) { - ReportIssue("Strings can be interned, and should not be used for locking. Use a 'readonly' field instead."); + ReportIssue("strings as they can be interned"); } else if (expression is IdentifierNameSyntax && lazySymbol.Value is ILocalSymbol lockedSymbol) { - ReportIssue($"Do not lock on local variable '{lockedSymbol.Name}', use a 'readonly' field instead."); + ReportIssue($"local variable '{lockedSymbol.Name}'"); } else if (FieldNotReadonly(expression, lazySymbol) is { } lockedField) { - ReportIssue($"Do not lock on non-'readonly' field '{lockedField.Name}', use a 'readonly' field instead."); + ReportIssue($"writable field '{lockedField.Name}'"); } } diff --git a/analyzers/tests/SonarAnalyzer.UnitTest/TestCases/LockedFieldShouldBeReadonly.cs b/analyzers/tests/SonarAnalyzer.UnitTest/TestCases/LockedFieldShouldBeReadonly.cs index e56c1163dd9..e7b99e929c1 100644 --- a/analyzers/tests/SonarAnalyzer.UnitTest/TestCases/LockedFieldShouldBeReadonly.cs +++ b/analyzers/tests/SonarAnalyzer.UnitTest/TestCases/LockedFieldShouldBeReadonly.cs @@ -19,37 +19,37 @@ class Test void OnAStaticField() { lock (staticReadonlyField) { } - lock (staticReadWriteField) { } // Noncompliant {{Do not lock on non-'readonly' field 'staticReadWriteField', use a 'readonly' field instead.}} + lock (staticReadWriteField) { } // Noncompliant {{Do not lock on writable field 'staticReadWriteField', use a readonly field instead.}} // ^^^^^^^^^^^^^^^^^^^^ lock (Test.staticReadonlyField) { } - lock (Test.staticReadWriteField) { } // Noncompliant {{Do not lock on non-'readonly' field 'staticReadWriteField', use a 'readonly' field instead.}} + lock (Test.staticReadWriteField) { } // Noncompliant {{Do not lock on writable field 'staticReadWriteField', use a readonly field instead.}} // ^^^^^^^^^^^^^^^^^^^^^^^^^ lock (AnotherClass.staticReadonlyField) { } - lock (AnotherClass.staticReadWriteField) { } // Noncompliant {{Do not lock on non-'readonly' field 'staticReadWriteField', use a 'readonly' field instead.}} + lock (AnotherClass.staticReadWriteField) { } // Noncompliant {{Do not lock on writable field 'staticReadWriteField', use a readonly field instead.}} // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ } void OnAFieldOfSameInstance() { lock (readonlyField) { } - lock (readonlyStringField) { } // Noncompliant {{Strings can be interned, and should not be used for locking. Use a 'readonly' field instead.}} - lock (readWriteField) { } // Noncompliant {{Do not lock on non-'readonly' field 'readWriteField', use a 'readonly' field instead.}} + lock (readonlyStringField) { } // Noncompliant {{Do not lock on strings as they can be interned, use a readonly field instead.}} + lock (readWriteField) { } // Noncompliant {{Do not lock on writable field 'readWriteField', use a readonly field instead.}} lock (this.readonlyField) { } - lock (this.readWriteField) { } // Noncompliant {{Do not lock on non-'readonly' field 'readWriteField', use a 'readonly' field instead.}} + lock (this.readWriteField) { } // Noncompliant {{Do not lock on writable field 'readWriteField', use a readonly field instead.}} } void OnParenthesizedExpressions() { lock ((readonlyField)) { } - lock ((readWriteField)) { } // Noncompliant {{Do not lock on non-'readonly' field 'readWriteField', use a 'readonly' field instead.}} - lock ((this.readWriteField)) { } // Noncompliant {{Do not lock on non-'readonly' field 'readWriteField', use a 'readonly' field instead.}} + lock ((readWriteField)) { } // Noncompliant {{Do not lock on writable field 'readWriteField', use a readonly field instead.}} + lock ((this.readWriteField)) { } // Noncompliant {{Do not lock on writable field 'readWriteField', use a readonly field instead.}} } void OnAFieldOfDifferentInstance() { var anotherInstance = new Test(); lock (anotherInstance.readonlyField) { } - lock (anotherInstance.readWriteField) { } // Noncompliant {{Do not lock on non-'readonly' field 'readWriteField', use a 'readonly' field instead.}} + lock (anotherInstance.readWriteField) { } // Noncompliant {{Do not lock on writable field 'readWriteField', use a readonly field instead.}} lock (anotherInstance.readonlyField) { } lock (anotherInstance?.readWriteField) { } // FN: ?. not supported } @@ -57,7 +57,7 @@ void OnAFieldOfDifferentInstance() void OnALocalVariable() { object localVarNull = null; - lock (localVarNull) { } // Noncompliant {{Do not lock on local variable 'localVarNull', use a 'readonly' field instead.}} + lock (localVarNull) { } // Noncompliant {{Do not lock on local variable 'localVarNull', use a readonly field instead.}} object localVarReadonlyField = readonlyField; lock (localVarReadonlyField) { } // Noncompliant, while the local variable references a readonly field, the local variable itself can mutate object localVarReadWriteField = readWriteField; @@ -66,7 +66,7 @@ void OnALocalVariable() void OnANewInstance() { - lock (new object()) { } // Noncompliant {{Locking on a new instance is a no-op, use a 'readonly' field instead.}} + lock (new object()) { } // Noncompliant {{Do not lock on a new instance because is a no-op, use a readonly field instead.}} lock (new ANamespace.AClass()) { } // Noncompliant lock (new Test[] { }) { } // Noncompliant lock (new[] { readonlyField }) { } // Noncompliant @@ -86,7 +86,7 @@ void OnANewInstance() void OnAStringInstance() { - lock ("a string") { } // Noncompliant {{Strings can be interned, and should not be used for locking. Use a 'readonly' field instead.}} + lock ("a string") { } // Noncompliant {{Do not lock on strings as they can be interned, use a readonly field instead.}} lock ($"an interpolated {"string"}") { } // Noncompliant lock ("a" + "string") { } // Noncompliant lock (MethodReturningString()) { } // Noncompliant