Skip to content

Commit

Permalink
Update UTs after change of messages in rspec
Browse files Browse the repository at this point in the history
  • Loading branch information
@antonioaversa
antonioaversa committed Feb 27, 2023
1 parent 1f3ce9d commit c8b4f48
Show file tree
Hide file tree
Showing 2 changed files with 17 additions and 17 deletions.
10 changes: 5 additions & 5 deletions analyzers/src/SonarAnalyzer.CSharp/Rules/LockedFieldShouldBeReadonly.cs
View file
Expand Up @@ -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<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);

Expand All @@ -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<ISymbol>(() => 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}'");
}
}

Expand Down
24 changes: 12 additions & 12 deletions analyzers/tests/SonarAnalyzer.UnitTest/TestCases/LockedFieldShouldBeReadonly.cs
View file
Expand Up @@ -19,45 +19,45 @@ 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
}

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;
Expand All @@ -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
Expand All @@ -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
Expand Down

0 comments on commit c8b4f48

Please sign in to comment.