public void Dispose_ResetsValueToDefault()
{
IDisposableSource<string> disposableSource = new DisposableSource<string>(source);
disposableSource.Dispose();
Assert.Null(source.Value);
}
public void Dispose_ResetsValueToDefault()
{
IDisposableSource <string> disposableSource = new DisposableSource <string>(source);
disposableSource.Dispose();
Assert.Null(source.Value);
}
private CustomAnalysisContext(SyntaxNodeAnalysisContext context, SyntaxNode node, SyntaxNode originalNode,
DisposableSource source, INamedTypeSymbol type, IDetector detector, IConfiguration configuration)
{
Context = context;
Source = source;
Type = type;
Detector = detector;
Configuration = configuration;
Node = node;
OriginalNode = originalNode;
}
public void Dispose_CallsAction()
{
bool called = false;
IDisposableSource<string> disposableSource = new DisposableSource<string>(source, () => called = true);
Assert.False(called);
disposableSource.Dispose();
Assert.True(called);
}
public void Dispose_CallsAction()
{
bool called = false;
IDisposableSource <string> disposableSource = new DisposableSource <string>(source, () => called = true);
Assert.False(called);
disposableSource.Dispose();
Assert.True(called);
}
public void DontTouchWaveSourceTest()
{
using (var source = new DisposableSource(GetWaveSource()))
{
_soundOut.Initialize(source);
_soundOut.Play();
Thread.Sleep(100);
Assert.AreEqual(PlaybackState.Playing, _soundOut.PlaybackState);
_soundOut.Dispose();
Assert.IsFalse(source.IsDisposed);
}
}
private static void AnalyseNodeInArgumentList(SyntaxNodeAnalysisContext context,
SyntaxNode node, DisposableSource source)
{
var objectCreation = node.Parent.Parent.Parent as ObjectCreationExpressionSyntax;
var t = context.SemanticModel.GetReturnTypeOf(objectCreation);
if (t == null)
{
return; //return type could not be determind
}
if (Detector.IsTrackedType(t, objectCreation, context.SemanticModel))
{
return;
}
context.ReportNotDisposedAnonymousObject(source);
}
private static void AnalyseNodeWithinVariableDeclarator(SyntaxNodeAnalysisContext context,
SyntaxNode node, DisposableSource source)
{
var identifier = node.GetIdentifierIfIsPartOfVariableDeclarator();//getIdentifier
if (identifier == null)
{
return;
}
if (node.IsLocalDeclaration()) //var m = new MemoryStream();
{
AnalyseNodeWithinLocalDeclaration(context, node, identifier);
}
else if (node.IsFieldDeclaration()) //_field = new MemoryStream();
{
AnalyseNodeInFieldDeclaration(context, node, identifier, source);
}
}
public void SoundOutBehaviour()
{
using (var source = new DisposableSource(GetLoopingWaveSource()))
{
Assert.AreEqual(PlaybackState.Stopped, _soundOut.PlaybackState);
_soundOut.Initialize(source);
Assert.AreEqual(PlaybackState.Stopped, _soundOut.PlaybackState);
_soundOut.Play();
Assert.AreEqual(PlaybackState.Playing, _soundOut.PlaybackState);
Thread.Sleep(20);
_soundOut.Pause();
Assert.AreEqual(PlaybackState.Paused, _soundOut.PlaybackState);
Thread.Sleep(20);
_soundOut.Resume();
Assert.AreEqual(PlaybackState.Playing, _soundOut.PlaybackState);
Thread.Sleep(20);
_soundOut.Dispose();
Assert.IsFalse(source.IsDisposed, "{0} disposed source.", _soundOut.GetType().FullName);
}
}
private static void AnalyseNodeInFieldDeclaration(SyntaxNodeAnalysisContext context,
SyntaxNode node, string identifier, DisposableSource source)
{
var disposeMethod = node.FindContainingClass().DescendantNodes <MethodDeclarationSyntax>()
.FirstOrDefault(method => method.Identifier.Text == DisposeMethod);
if (disposeMethod == null)
{
//there is no dispose method in this class
context.ReportNotDisposedField(source);
return;
}
var isDisposed = disposeMethod.DescendantNodes <InvocationExpressionSyntax>()
.Select(invo => invo.Expression as MemberAccessExpressionSyntax)
.Any(invo =>
{
var id = invo.Expression as IdentifierNameSyntax;
var member = id?.Identifier.Text == identifier;
var callToDispose = invo.Name.Identifier.Text == DisposeMethod;
return(member && callToDispose);
});
if (isDisposed)
{
return;
}
//there is a dispose method in this class, but ObjectCreation is not disposed
context.ReportNotDisposedField(source);
}
public static void ReportNotDisposedProperty(this SyntaxNodeAnalysisContext context, string variableName, DisposableSource source)
{
var location = context.Node.GetLocation();
var properties = ImmutableDictionary.CreateBuilder <string, string>();
properties.Add(Constants.Variablename, variableName);
context.ReportDiagnostic(source == DisposableSource.InvokationExpression
? Diagnostic.Create(AssignmendFromMethodInvocationToPropertyNotDisposedDescriptor, location, properties.ToImmutable())
: Diagnostic.Create(AssignmendFromObjectCreationToPropertyNotDisposedDescriptor, location, properties.ToImmutable())
);
}
public void Value()
{
IDisposableSource <string> disposableSource = new DisposableSource <string>(source);
Assert.Equal("A", disposableSource.Value);
}
public static void ReportNotDisposedAnonymousObject(this SyntaxNodeAnalysisContext context, DisposableSource source)
{
var location = context.Node.GetLocation();
context.ReportDiagnostic(source == DisposableSource.InvokationExpression
? Diagnostic.Create(AnonymousObjectFromMethodInvokationDescriptor, location)
: Diagnostic.Create(AnonymousObjectFromObjectCreationDescriptor, location));
}
public static void ReportNotDisposedAssignmentToFieldOrProperty(this SyntaxNodeAnalysisContext context, DisposableSource source)
{
var location = context.Node.GetLocation();
context.ReportDiagnostic(Diagnostic.Create(NotDisposedDescriptor, location));
}
public void Value()
{
IDisposableSource<string> disposableSource = new DisposableSource<string>(source);
Assert.Equal("A", disposableSource.Value);
}
private static void AnalyseNodeInFieldDeclaration(SyntaxNodeAnalysisContext context,
SyntaxNode node, string variableName, DisposableSource source)
{
if (node.IsDisposedInDisposingMethod(variableName, Configuration, context.SemanticModel))
{
return;
}
context.ReportNotDisposedField(variableName, source);
}
public static void ReportNotDisposedProperty(this SyntaxNodeAnalysisContext context, DiagnosticDescriptor rule, string variableName, DisposableSource source)
{
var location = context.Node.GetLocation();
var properties = ImmutableDictionary.CreateBuilder<string, string>();
properties.Add(Constants.Variablename, variableName);
context.ReportDiagnostic(Diagnostic.Create(rule, location, properties.ToImmutable()));
}
private void AnalyseNodeInReturnStatementOfProperty(SyntaxNodeAnalysisContext context, SyntaxNode node, DisposableSource source)
{
var propertyDeclaration = node.Parent.Parent.Parent.Parent.Parent as PropertyDeclarationSyntax;
if (propertyDeclaration == null)
{
return; // should not happen => we cke this before
}
if (node.IsDisposedInDisposingMethod(propertyDeclaration.Identifier.Text, Configuration, context.SemanticModel))
{
return;
}
var rule = GetRule(DiagnosticId, CurrentSeverity);
context.ReportNotDisposedProperty(rule, propertyDeclaration.Identifier.Text, source);
}
private void AnalyseNodeInAssignmentExpression(SyntaxNodeAnalysisContext context,
SyntaxNode node, DisposableSource source)
{
//is local or global variable
var assignmentExrepssion = node.Parent as AssignmentExpressionSyntax;
var variableName = (assignmentExrepssion?.Left as IdentifierNameSyntax)?.Identifier.Text;
var rule = GetRule(DiagnosticId, CurrentSeverity);
MethodDeclarationSyntax containingMethod;
if (node.TryFindContainingMethod(out containingMethod))
{
if (containingMethod.ContainsDisposeCallFor(variableName, context.SemanticModel, Configuration))
{
return;
}
if (containingMethod.HasDecendentVariableDeclaratorFor(variableName))
{
//local declaration in method
if (containingMethod.Returns(variableName))
{
return;
}
if (node.IsDescendantOfUsingHeader())
{
return;
}
if (node.IsArgumentInObjectCreation())
{
AnalyseNodeInArgumentList(context, node, source);
return;
}
//is part of tracking call
context.ReportNotDisposedLocalVariable(rule);
return;
}
if (node.IsDisposedInDisposingMethod(variableName, Configuration, context.SemanticModel))
{
return;
}
if (node.IsArgumentInObjectCreation())
{
AnalyseNodeInArgumentList(context, node, source);
return;
}
//assignment to field or property
var containingClass = node.FindContainingClass();
if (containingClass == null)
{
return;
}
if (containingClass.FindFieldNamed(variableName) != null)
{
context.ReportNotDisposedField(rule, variableName, source);
}
else
{
context.ReportNotDisposedProperty(rule, variableName, source);
}
return;
}
ConstructorDeclarationSyntax ctor;
if (node.TryFindContainingCtor(out ctor))
{
if (ctor.HasDecendentVariableDeclaratorFor(variableName))
{
//local variable in ctor
if (node.IsDescendantOfUsingHeader())
{
return;
}
if (node.IsArgumentInObjectCreation())
{
AnalyseNodeInArgumentList(context, node, source);
return;
}
if (ctor.ContainsDisposeCallFor(variableName, context.SemanticModel, Configuration))
{
return;
}
context.ReportNotDisposedLocalVariable(rule);
}
else //field or property
{
if (node.IsDisposedInDisposingMethod(variableName, Configuration, context.SemanticModel))
{
return;
}
if (node.IsAssignmentToProperty(variableName))
{
context.ReportNotDisposedProperty(rule, variableName, source);
}
else
{
context.ReportNotDisposedField(rule, variableName, source);
}
}
}
}
private void AnalyseNodeInFieldDeclaration(SyntaxNodeAnalysisContext context,
SyntaxNode node, string variableName, DisposableSource source)
{
if (node.IsDisposedInDisposingMethod(variableName, Configuration, context.SemanticModel))
{
return;
}
var rule = GetRule(DiagnosticId, CurrentSeverity);
context.ReportNotDisposedField(rule, variableName, source);
}
private void CheckIfObjectCreationTracksNode(SyntaxNodeAnalysisContext context, ObjectCreationExpressionSyntax objectCreation, DisposableSource source)
{
var t = context.SemanticModel.GetReturnTypeOf(objectCreation);
if (t == null)
{
return; //return type could not be determind
}
if (Detector.IsTrackedType(t, objectCreation, context.SemanticModel))
{
return;
}
var rule = GetRule(DiagnosticId, CurrentSeverity);
context.ReportNotDisposedAnonymousObject(rule, source);
}
public static CustomAnalysisContext WithOriginalNode(SyntaxNodeAnalysisContext context, DisposableSource source,
INamedTypeSymbol type, IDetector detector, IConfiguration configuration)
{
return(new CustomAnalysisContext(context, context.Node, context.Node, source, type, detector, configuration));
}
private static void AnalyseNodeInAssignmentExpression(SyntaxNodeAnalysisContext context,
SyntaxNode node, DisposableSource source)
{
//is local or global variable
var assignmentExrepssion = node.Parent as AssignmentExpressionSyntax;
var variableName = (assignmentExrepssion?.Left as IdentifierNameSyntax)?.Identifier.Text;
MethodDeclarationSyntax containingMethod;
if (node.TryFindContainingMethod(out containingMethod))
{
if (containingMethod.ContainsDisposeCallFor(variableName))
{
return;
}
if (containingMethod.HasDecendentVariableDeclaratorFor(variableName))
{
//local declaration in method
if (containingMethod.Returns(variableName))
{
return;
}
if (node.IsDescendantOfUsingHeader())
{
return;
}
if (node.IsArgumentInObjectCreation())
{
AnalyseNodeInArgumentList(context, node, source);
return;
}
//is part of tracking call
context.ReportNotDisposedLocalDeclaration();
return;
}
//field declaration
if (node.IsDisposedInDisposedMethod(variableName))
{
return;
}
if (node.IsArgumentInObjectCreation())
{
AnalyseNodeInArgumentList(context, node, source);
return;
}
context.ReportNotDisposedField(source);
return;
}
ConstructorDeclarationSyntax ctor;
if (node.TryFindContainingCtor(out ctor))
{
if (ctor.HasDecendentVariableDeclaratorFor(variableName))
{
//local variable in ctor
if (node.IsDescendantOfUsingHeader())
{
return;
}
if (node.IsArgumentInObjectCreation())
{
AnalyseNodeInArgumentList(context, node, source);
return;
}
if (ctor.ContainsDisposeCallFor(variableName))
{
return;
}
context.ReportNotDisposedLocalDeclaration();
}
else //field
{
if (node.IsDisposedInDisposedMethod(variableName))
{
return;
}
context.ReportNotDisposedField(source);
return;
}
}
//part of a property?
}
public static void ReportNotDisposedAnonymousObject(this SyntaxNodeAnalysisContext context, DiagnosticDescriptor rule, DisposableSource source)
{
var location = context.Node.GetLocation();
context.ReportDiagnostic(Diagnostic.Create(rule, location));
}
private static void AnalyseNodeInAutoPropertyOrPropertyExpressionBody(SyntaxNodeAnalysisContext context, SyntaxNode node, DisposableSource source)
{
var propertyDeclaration = node.Parent.Parent as PropertyDeclarationSyntax;
if (propertyDeclaration == null)
{
return; // should not happen => we cke this before
}
if (node.IsDisposedInDisposingMethod(propertyDeclaration.Identifier.Text, Configuration, context.SemanticModel))
{
return;
}
context.ReportNotDisposedProperty(propertyDeclaration.Identifier.Text, source);
}
