public void ObsoleteLetStatement_QuickFixWorks()
{
const string inputCode =
@"Public Sub Foo()
Dim var1 As Integer
Dim var2 As Integer
Let var2 = var1
End Sub";
const string expectedCode =
@"Public Sub Foo()
Dim var1 As Integer
Dim var2 As Integer
var2 = var1
End Sub";
var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component);
using (var state = MockParser.CreateAndParse(vbe.Object))
{
var inspection = new ObsoleteLetStatementInspection(state);
var inspector = InspectionsHelper.GetInspector(inspection);
var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
new RemoveExplicitLetStatementQuickFix(state).Fix(inspectionResults.First());
Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText());
}
}
public void EmptyIfBlock_QuickFixRemovesLoneIf_WithComment()
{
const string inputCode =
@"Sub Foo()
If True Then
' Im a comment
End If
End Sub";
const string expectedCode =
@"Sub Foo()
End Sub";
var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component);
using (var state = MockParser.CreateAndParse(vbe.Object))
{
var inspection = new EmptyIfBlockInspection(state);
var inspector = InspectionsHelper.GetInspector(inspection);
var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
new RemoveEmptyIfBlockQuickFix(state).Fix(inspectionResults.First());
Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText());
}
}
public void EmptyIfBlock_QuickFixRemovesElse_InvertsIf_ComplexCondition2()
{
const string inputCode =
@"Sub Foo()
If 1 > 2 And 3 = 3 Or 4 <> 5 And 8 - 6 = 2 Then
Else
End If
End Sub";
const string expectedCode =
@"Sub Foo()
If 1 > 2 And 3 = 3 And 4 <> 5 And 8 - 6 = 2 Then
End If
End Sub";
var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component);
using (var state = MockParser.CreateAndParse(vbe.Object))
{
var inspection = new EmptyIfBlockInspection(state);
var inspector = InspectionsHelper.GetInspector(inspection);
var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
new RemoveEmptyIfBlockQuickFix(state).Fix(inspectionResults.First());
Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText());
}
}
public void ImplicitByRefModifier_QuickFixWorks_LineContinuation()
{
const string inputCode =
@"Sub Foo(bar _
As Byte)
bar = 1
End Sub";
const string expectedCode =
@"Sub Foo(ByRef bar _
As Byte)
bar = 1
End Sub";
var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component);
var state = MockParser.CreateAndParse(vbe.Object);
var inspection = new ImplicitByRefModifierInspection(state);
var inspector = InspectionsHelper.GetInspector(inspection);
var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
new SpecifyExplicitByRefModifierQuickFix(state).Fix(inspectionResults.First());
Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText());
}
public void ProcedureShouldBeFunction_QuickFixWorks_DoesNotInterfereWithBody()
{
const string inputCode =
@"Private Sub Foo(ByRef arg1 As Integer)
arg1 = 6
Goo arg1
End Sub
Sub Goo(ByVal a As Integer)
End Sub";
const string expectedCode =
@"Private Function Foo(ByVal arg1 As Integer) As Integer
arg1 = 6
Goo arg1
Foo = arg1
End Function
Sub Goo(ByVal a As Integer)
End Sub";
var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component);
using (var state = MockParser.CreateAndParse(vbe.Object))
{
var inspection = new ProcedureCanBeWrittenAsFunctionInspection(state);
var inspector = InspectionsHelper.GetInspector(inspection);
var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
new ChangeProcedureToFunctionQuickFix(state).Fix(inspectionResults.First());
Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText());
}
}
public void RedundantByRefModifier_IgnoredQuickFixWorks()
{
const string inputCode =
@"Sub Foo(ByRef arg1 As Integer)
End Sub";
const string expectedCode =
@"'@Ignore RedundantByRefModifier
Sub Foo(ByRef arg1 As Integer)
End Sub";
var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component);
var state = MockParser.CreateAndParse(vbe.Object);
var inspection = new RedundantByRefModifierInspection(state)
{
Severity = CodeInspectionSeverity.Hint
};
var inspector = InspectionsHelper.GetInspector(inspection);
var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First());
Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText());
}
public void MultilineParameter_IgnoreQuickFixWorks()
{
const string inputCode =
@"Public Sub Foo( _
ByVal _
Var1 _
As _
Integer)
End Sub";
const string expectedCode =
@"'@Ignore MultilineParameter
Public Sub Foo( _
ByVal _
Var1 _
As _
Integer)
End Sub";
var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component);
var state = MockParser.CreateAndParse(vbe.Object);
var inspection = new MultilineParameterInspection(state);
var inspector = InspectionsHelper.GetInspector(inspection);
var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First());
Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText());
}
public void ObsoleteCommentSyntax_QuickFixWorks_ProcNamedError()
{
const string inputCode =
@"Sub Error(val as Integer)
End Sub
Sub Foo()
Error 91
End Sub";
const string expectedCode =
@"Sub Error(val as Integer)
End Sub
Sub Foo()
Err.Raise 91
End Sub";
var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component);
var state = MockParser.CreateAndParse(vbe.Object);
var inspection = new ObsoleteErrorSyntaxInspection(state);
var inspector = InspectionsHelper.GetInspector(inspection);
var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
new ReplaceObsoleteErrorStatementQuickFix(state).Fix(inspectionResults.First());
Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText());
}
private IEnumerable <IInspectionResult> InspectionResults(IInspection inspection, RubberduckParserState state)
{
if (inspection is IParseTreeInspection)
{
var inspector = InspectionsHelper.GetInspector(inspection);
return(inspector.FindIssuesAsync(state, CancellationToken.None).Result);
}
return(inspection.GetInspectionResults(CancellationToken.None));
}
public void RedundantByRefModifier_QuickFixWorks_InterfaceImplementationWithMultipleParameters()
{
const string inputCode1 =
@"Sub Foo(ByRef arg1 As Integer, ByRef arg2 as Integer)
End Sub";
const string inputCode2 =
@"Implements IClass1
Sub IClass1_Foo(ByRef arg1 As Integer, ByRef arg2 as Integer)
End Sub";
const string expectedCode1 =
@"Sub Foo(arg1 As Integer, ByRef arg2 as Integer)
End Sub";
const string expectedCode2 =
@"Implements IClass1
Sub IClass1_Foo(arg1 As Integer, ByRef arg2 as Integer)
End Sub";
var builder = new MockVbeBuilder();
var vbe = builder.ProjectBuilder("TestProject1", ProjectProtection.Unprotected)
.AddComponent("IClass1", ComponentType.ClassModule, inputCode1)
.AddComponent("Class1", ComponentType.ClassModule, inputCode2)
.AddProjectToVbeBuilder()
.Build();
using (var state = MockParser.CreateAndParse(vbe.Object))
{
var inspection = new RedundantByRefModifierInspection(state)
{
Severity = CodeInspectionSeverity.Hint
};
var inspector = InspectionsHelper.GetInspector(inspection);
var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
new RemoveExplicitByRefModifierQuickFix(state).Fix(
inspectionResults.First(
result =>
((VBAParser.ArgContext)result.Context).unrestrictedIdentifier()
.identifier()
.untypedIdentifier()
.identifierValue()
.GetText() == "arg1"));
var project = vbe.Object.VBProjects[0];
var interfaceComponent = project.VBComponents[0];
var implementationComponent = project.VBComponents[1];
Assert.AreEqual(expectedCode1, state.GetRewriter(interfaceComponent).GetText(), "Wrong code in interface");
Assert.AreEqual(expectedCode2, state.GetRewriter(implementationComponent).GetText(), "Wrong code in implementation");
}
}
private static void ThunderCatsGo(Func <RubberduckParserState, IInspection> inspectionFunction, string inputCode, int expectedCount)
{
var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component);
using (var state = MockParser.CreateAndParse(vbe.Object))
{
var inspection = inspectionFunction(state);
var inspector = InspectionsHelper.GetInspector(inspection);
var actualResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
Assert.AreEqual(expectedCount, actualResults.Count());
}
}
public void AddsMissingExposedAttribute()
{
const string testModuleName = "Test";
const string inputCode = @"
VERSION 1.0 CLASS
BEGIN
MultiUse = -1 'True
END
Attribute VB_Name = """ + testModuleName + @"""
Attribute VB_GlobalNameSpace = False
Attribute VB_Creatable = False
Attribute VB_PredeclaredId = False
Attribute VB_Exposed = False
Option Explicit
'@Exposed
";
const string expectedCode = @"
VERSION 1.0 CLASS
BEGIN
MultiUse = -1 'True
END
Attribute VB_Name = """ + testModuleName + @"""
Attribute VB_GlobalNameSpace = False
Attribute VB_Creatable = False
Attribute VB_PredeclaredId = False
Attribute VB_Exposed = True
Option Explicit
'@Exposed
";
var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, testModuleName, ComponentType.ClassModule, out _);
var state = MockParser.CreateAndParse(vbe.Object);
var inspection = new MissingAttributeInspection(state);
var inspector = InspectionsHelper.GetInspector(inspection);
var result = inspector.FindIssuesAsync(state, CancellationToken.None).Result?.SingleOrDefault();
if (result?.Context.GetType() != typeof(VBAParser.AnnotationContext))
{
Assert.Inconclusive("Inspection failed to return a result.");
}
var fix = new SynchronizeAttributesQuickFix(state);
fix.Fix(result);
var rewriter = state.GetAttributeRewriter(result.QualifiedSelection.QualifiedName);
var actual = rewriter.GetText();
Assert.AreEqual(expectedCode, actual);
}
public void UnhandledOnErrorResumeNext_QuickFixWorks_SameLabelInMultipleProcedures()
{
const string inputCode =
@"Sub Foo()
On Error Resume Next
End Sub
Sub Bar()
On Error Resume Next
End Sub";
const string expectedCode =
@"Sub Foo()
On Error GoTo ErrorHandler
Exit Sub
ErrorHandler:
If Err.Number > 0 Then 'TODO: handle specific error
Err.Clear
Resume Next
End If
End Sub
Sub Bar()
On Error GoTo ErrorHandler
Exit Sub
ErrorHandler:
If Err.Number > 0 Then 'TODO: handle specific error
Err.Clear
Resume Next
End If
End Sub";
var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component);
using (var state = MockParser.CreateAndParse(vbe.Object))
{
var inspection = new UnhandledOnErrorResumeNextInspection(state);
var inspector = InspectionsHelper.GetInspector(inspection);
var quickFix = new RestoreErrorHandlingQuickFix(state);
foreach (var result in inspector.FindIssuesAsync(state, CancellationToken.None).Result)
{
quickFix.Fix(result);
}
Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText());
}
}
public void OptionBaseZeroStatement_QuickFixWorks_RemoveStatement()
{
var inputCode = "Option Base 0";
var expectedCode = string.Empty;
var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component);
var state = MockParser.CreateAndParse(vbe.Object);
var inspection = new RedundantOptionInspection(state);
var inspector = InspectionsHelper.GetInspector(inspection);
var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
new RemoveOptionBaseStatementQuickFix(state).Fix(inspectionResults.First());
Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText());
}
private void TestStepOneQuickFix(string expectedCode, string inputCode)
{
var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component);
var state = MockParser.CreateAndParse(vbe.Object);
var inspection = new StepOneIsRedundantInspection(state)
{
Severity = CodeInspectionSeverity.Warning
};
var inspector = InspectionsHelper.GetInspector(inspection);
var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
new RemoveStepOneQuickFix(state).Fix(inspectionResults.First());
Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText());
}
public void StopKeyword_QuickFixWorks_RemoveKeyword_InstructionSeparator()
{
var inputCode = "Sub Foo(): Stop: End Sub";
var expectedCode = "Sub Foo(): : End Sub";
var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component);
var state = MockParser.CreateAndParse(vbe.Object);
var inspection = new StopKeywordInspection(state);
var inspector = InspectionsHelper.GetInspector(inspection);
var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
new RemoveStopKeywordQuickFix(state).Fix(inspectionResults.First());
Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText());
}
public void AddsMissingDescriptionAnnotation()
{
const string testModuleName = "Test";
const string inputCode = @"
VERSION 1.0 CLASS
BEGIN
MultiUse = -1 'True
END
Attribute VB_Name = """ + testModuleName + @""" ' (ignored)
Option Explicit
Sub DoSomething()
Attribute DoSomething.VB_Description = ""Does something""
End Sub";
const string expectedCode = @"
VERSION 1.0 CLASS
BEGIN
MultiUse = -1 'True
END
Attribute VB_Name = """ + testModuleName + @""" ' (ignored)
Option Explicit
'@Description(""Does something"")
Sub DoSomething()
Attribute DoSomething.VB_Description = ""Does something""
End Sub";
var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, testModuleName, ComponentType.ClassModule, out _);
var state = MockParser.CreateAndParse(vbe.Object);
var inspection = new MissingAnnotationInspection(state);
var inspector = InspectionsHelper.GetInspector(inspection);
var result = inspector.FindIssuesAsync(state, CancellationToken.None).Result?.SingleOrDefault();
if (result?.Context.GetType() != typeof(VBAParser.AttributeStmtContext))
{
Assert.Inconclusive("Inspection failed to return a result.");
}
var fix = new SynchronizeAttributesQuickFix(state);
fix.Fix(result);
var rewriter = state.GetRewriter(result.QualifiedSelection.QualifiedName);
var actual = rewriter.GetText();
Assert.AreEqual(expectedCode, actual);
}
private void TestInsertLocalVariableQuickFix(string expectedCode, string inputCode)
{
var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component);
var state = MockParser.CreateAndParse(vbe.Object);
var inspection = new UndeclaredVariableInspection(state)
{
Severity = CodeInspectionSeverity.Warning
};
var inspector = InspectionsHelper.GetInspector(inspection);
var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
new IntroduceLocalVariableQuickFix(state).Fix(inspectionResults.First());
var actualCode = state.GetRewriter(component).GetText();
Assert.AreEqual(expectedCode, actualCode);
}
public void ImplicitByRefModifier_QuickFixWorks_InterfaceImplementationDifferentParameterName()
{
const string inputCode1 =
@"Sub Foo(arg1 As Integer)
End Sub";
const string inputCode2 =
@"Implements IClass1
Sub IClass1_Foo(arg2 As Integer)
End Sub";
const string expectedCode1 =
@"Sub Foo(ByRef arg1 As Integer)
End Sub";
const string expectedCode2 =
@"Implements IClass1
Sub IClass1_Foo(ByRef arg2 As Integer)
End Sub";
var builder = new MockVbeBuilder();
var vbe = builder.ProjectBuilder("TestProject1", ProjectProtection.Unprotected)
.AddComponent("IClass1", ComponentType.ClassModule, inputCode1)
.AddComponent("Class1", ComponentType.ClassModule, inputCode2)
.AddProjectToVbeBuilder()
.Build();
using (var state = MockParser.CreateAndParse(vbe.Object))
{
var inspection = new ImplicitByRefModifierInspection(state);
var inspector = InspectionsHelper.GetInspector(inspection);
var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
new SpecifyExplicitByRefModifierQuickFix(state).Fix(inspectionResults.First());
var project = vbe.Object.VBProjects[0];
var interfaceComponent = project.VBComponents[0];
var implementationComponent = project.VBComponents[1];
Assert.AreEqual(expectedCode1, state.GetRewriter(interfaceComponent).GetText(), "Wrong code in interface");
Assert.AreEqual(expectedCode2, state.GetRewriter(implementationComponent).GetText(), "Wrong code in implementation");
}
}
public void NotAlreadySpecified_QuickFixWorks()
{
const string inputCode = "";
const string expectedCode =
@"Option Explicit
";
var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component);
var state = MockParser.CreateAndParse(vbe.Object);
var inspection = new OptionExplicitInspection(state);
var inspector = InspectionsHelper.GetInspector(inspection);
var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
new OptionExplicitQuickFix(state).Fix(inspectionResults.First());
Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText());
}
public void ObsoleteCommentSyntax_QuickFixWorks_UpdateComment()
{
const string inputCode =
@"Rem test1";
const string expectedCode =
@"' test1";
var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component);
var state = MockParser.CreateAndParse(vbe.Object);
var inspection = new ObsoleteCommentSyntaxInspection(state);
var inspector = InspectionsHelper.GetInspector(inspection);
var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
new ReplaceObsoleteCommentMarkerQuickFix(state).Fix(inspectionResults.First());
Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText());
}
public void ModuleScopeDimKeyword_QuickFixWorks()
{
const string inputCode =
@"Dim foo As String";
const string expectedCode =
@"Private foo As String";
var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component);
var state = MockParser.CreateAndParse(vbe.Object);
var inspection = new ModuleScopeDimKeywordInspection(state);
var inspector = InspectionsHelper.GetInspector(inspection);
var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
new ChangeDimToPrivateQuickFix(state).Fix(inspectionResults.First());
Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText());
}
public void ObsoleteCommentSyntax_QuickFixWorks_RemoveComment_LineHasCode()
{
const string inputCode =
@"Dim Foo As Integer: Rem This is a comment";
const string expectedCode =
@"Dim Foo As Integer: ";
var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component);
var state = MockParser.CreateAndParse(vbe.Object);
var inspection = new ObsoleteCommentSyntaxInspection(state);
var inspector = InspectionsHelper.GetInspector(inspection);
var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
new RemoveCommentQuickFix(state).Fix(inspectionResults.First());
Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText());
}
public void ProviderKnowsAboutInspection()
{
const string inputCode =
@"Public Sub Foo()
Dim str As String
str = """"
End Sub";
var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _);
var state = MockParser.CreateAndParse(vbe.Object);
var inspection = new EmptyStringLiteralInspection(state);
var inspector = InspectionsHelper.GetInspector(inspection);
var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
var quickFixProvider = new QuickFixProvider(state, new IQuickFix[] { new ReplaceEmptyStringLiteralStatementQuickFix(state) });
Assert.AreEqual(1, quickFixProvider.QuickFixes(inspectionResults.First()).Count());
}
public void BooleanAssignedInIfElseInspection_IgnoreQuickFixWorks()
{
const string inputCode =
@"Sub Foo()
Dim d As Boolean
If True Then
d = True
Else
d = False
EndIf
End Sub";
const string expectedCode =
@"Sub Foo()
Dim d As Boolean
'@Ignore BooleanAssignedInIfElse
If True Then
d = True
Else
d = False
EndIf
End Sub";
var builder = new MockVbeBuilder();
var project = builder.ProjectBuilder("VBAProject", ProjectProtection.Unprotected)
.AddComponent("MyClass", ComponentType.ClassModule, inputCode)
.Build();
var component = project.Object.VBComponents[0];
var vbe = builder.AddProject(project).Build();
using (var state = MockParser.CreateAndParse(vbe.Object))
{
var inspection = new BooleanAssignedInIfElseInspection(state);
var inspector = InspectionsHelper.GetInspector(inspection);
var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First());
Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText());
}
}
public void ProcedureShouldBeFunction_QuickFixWorks_NoAsTypeClauseInParam()
{
const string inputCode =
@"Private Sub Foo(ByRef arg1)
End Sub";
const string expectedCode =
@"Private Function Foo(ByVal arg1) As Variant
Foo = arg1
End Function";
var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component);
var state = MockParser.CreateAndParse(vbe.Object);
var inspection = new ProcedureCanBeWrittenAsFunctionInspection(state);
var inspector = InspectionsHelper.GetInspector(inspection);
var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
new ChangeProcedureToFunctionQuickFix(state).Fix(inspectionResults.First());
Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText());
}
public void ProcedureShouldBeFunction_IgnoreQuickFixWorks()
{
const string inputCode =
@"Private Sub Foo(ByRef arg1 As Integer)
End Sub";
const string expectedCode =
@"'@Ignore ProcedureCanBeWrittenAsFunction
Private Sub Foo(ByRef arg1 As Integer)
End Sub";
var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component);
var state = MockParser.CreateAndParse(vbe.Object);
var inspection = new ProcedureCanBeWrittenAsFunctionInspection(state);
var inspector = InspectionsHelper.GetInspector(inspection);
var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First());
Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText());
}
public void OptionBaseOneSpecified_IgnoreQuickFixWorks()
{
const string inputCode =
@"Option Base 1";
const string expectedCode =
@"'@Ignore OptionBase
Option Base 1";
var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component);
using (var state = MockParser.CreateAndParse(vbe.Object))
{
var inspection = new OptionBaseInspection(state);
var inspector = InspectionsHelper.GetInspector(inspection);
var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
new IgnoreOnceQuickFix(state, new[] { inspection }).Fix(inspectionResults.First());
Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText());
}
}
public void EmptyIfBlock_QuickFixRemovesIf_HasVariable_WithLabel()
{
const string inputCode =
@"Sub Foo()
If True Then
5 Dim d
a: Dim e
15 b: Dim f
Else
Dim b
b = 0
End If
End Sub";
const string expectedCode =
@"Sub Foo()
5 Dim d
a: Dim e
15 b: Dim f
If Not True Then
Dim b
b = 0
End If
End Sub";
var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component);
using (var state = MockParser.CreateAndParse(vbe.Object))
{
var inspection = new EmptyIfBlockInspection(state);
var inspector = InspectionsHelper.GetInspector(inspection);
var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
new RemoveEmptyIfBlockQuickFix(state).Fix(inspectionResults.First());
var rewrittenCode = state.GetRewriter(component).GetText();
Assert.AreEqual(expectedCode, rewrittenCode);
}
}
public void ObsoleteCallStatement_IgnoreQuickFixWorks()
{
const string inputCode =
@"Sub Foo()
Call Goo(1, ""test"")
End Sub
Sub Goo(arg1 As Integer, arg1 As String)
Call Foo
End Sub";
const string expectedCode =
@"Sub Foo()
'@Ignore ObsoleteCallStatement
Call Goo(1, ""test"")
End Sub
Sub Goo(arg1 As Integer, arg1 As String)
'@Ignore ObsoleteCallStatement
Call Foo
End Sub";
var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component);
using (var state = MockParser.CreateAndParse(vbe.Object))
{
var inspection = new ObsoleteCallStatementInspection(state);
var inspector = InspectionsHelper.GetInspector(inspection);
var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
var fix = new IgnoreOnceQuickFix(state, new[] { inspection });
foreach (var result in inspectionResults)
{
fix.Fix(result);
}
Assert.AreEqual(expectedCode, state.GetRewriter(component).GetText());
}
}