public void ProcedureShouldBeFunction_ReturnsResult_MultipleSubs()
{
const string inputCode =
@"Private Sub Foo(ByRef foo As Boolean)
End Sub
Private Sub Goo(ByRef foo As Integer)
End Sub";
//Arrange
var builder = new MockVbeBuilder();
VBComponent component;
var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);
var mockHost = new Mock<IHostApplication>();
mockHost.SetupAllProperties();
var parser = MockParser.Create(vbe.Object, new RubberduckParserState());
parser.Parse();
if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); }
var inspection = new ProcedureCanBeWrittenAsFunctionInspection(parser.State);
var inspectionResults = inspection.GetInspectionResults();
Assert.AreEqual(2, inspectionResults.Count());
}
public void ObsoleteCallStatement_ReturnsMultipleResults()
{
const string inputCode =
@"Sub Foo()
Call Goo(1, ""test"")
End Sub
Sub Goo(arg1 As Integer, arg1 As String)
Call Foo
End Sub";
//Arrange
var builder = new MockVbeBuilder();
VBComponent component;
var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);
var mockHost = new Mock<IHostApplication>();
mockHost.SetupAllProperties();
var parser = MockParser.Create(vbe.Object, new RubberduckParserState());
parser.Parse();
if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); }
var inspection = new ObsoleteCallStatementInspection(parser.State);
var inspectionResults = inspection.GetInspectionResults();
Assert.AreEqual(2, inspectionResults.Count());
}
public void FunctionReturnValueNotUsed_ReturnsResult_AddressOf()
{
const string inputCode =
@"Public Function Foo(ByVal bar As String) As Integer
Foo = 42
End Function
Public Sub Bar()
Bar AddressOf Foo
End Sub";
//Arrange
var builder = new MockVbeBuilder();
VBComponent component;
var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);
var mockHost = new Mock<IHostApplication>();
mockHost.SetupAllProperties();
var parser = MockParser.Create(vbe.Object, new RubberduckParserState());
parser.Parse();
if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); }
var inspection = new FunctionReturnValueNotUsedInspection(parser.State);
var inspectionResults = inspection.GetInspectionResults();
Assert.AreEqual(1, inspectionResults.Count());
}
public Task<PartialViewResult> GetInspectionResults(string code)
{
//Arrange
var builder = new MockVbeBuilder();
VBComponent component;
// ensure line endings are \r\n
code = code.Replace("\r\n", "\n").Replace("\n", "\r\n");
var vbe = builder.BuildFromSingleStandardModule(code, out component);
var mockHost = new Mock<IHostApplication>();
mockHost.SetupAllProperties();
var parser = MockParser.Create(vbe.Object, _state);
Task.Run(() => parser.Parse(new System.Threading.CancellationTokenSource())).Wait();
if (parser.State.Status >= ParserState.Error)
{
throw new ArgumentException(parser.State.Status.ToString());
}
var results = _inspector.Inspect(parser.State);
if (results.Any())
{
return Task.FromResult(PartialView("~/Views/Home/InspectionResults.cshtml", results));
}
return Task.FromResult(PartialView("~/Views/Home/NoInspectionResults.cshtml", results));
}
public void EmptyStringLiteral_ReturnsResult_PassToProcedure()
{
const string inputCode =
@"Public Sub Bar()
Foo """"
End Sub
Public Sub Foo(ByRef arg1 As String)
End Sub";
//Arrange
var builder = new MockVbeBuilder();
VBComponent component;
var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);
var mockHost = new Mock<IHostApplication>();
mockHost.SetupAllProperties();
var parser = MockParser.Create(vbe.Object, new RubberduckParserState());
parser.Parse();
if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); }
var inspection = new EmptyStringLiteralInspection(parser.State);
var inspectionResults = inspection.GetInspectionResults();
Assert.AreEqual(1, inspectionResults.Count());
}
public void UnassignedVariable_DoesNotReturnResult()
{
const string inputCode =
@"Function Foo() As Boolean
Dim var1 as String
var1 = ""test""
Goo var1
End Function
Sub Goo(ByVal arg1 As String)
End Sub";
//Arrange
var builder = new MockVbeBuilder();
VBComponent component;
var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);
var mockHost = new Mock<IHostApplication>();
mockHost.SetupAllProperties();
var parser = MockParser.Create(vbe.Object, new RubberduckParserState());
parser.Parse();
if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); }
var inspection = new VariableNotUsedInspection(parser.State);
var inspectionResults = inspection.GetInspectionResults();
Assert.AreEqual(0, inspectionResults.Count());
}
public void ObsoleteLetStatement_DoesNotReturnResult()
{
const string inputCode =
@"Public Sub Foo()
Dim var1 As Integer
Dim var2 As Integer
var2 = var1
End Sub";
//Arrange
var builder = new MockVbeBuilder();
VBComponent component;
var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);
var mockHost = new Mock<IHostApplication>();
mockHost.SetupAllProperties();
var parser = MockParser.Create(vbe.Object, new RubberduckParserState());
parser.Parse();
if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); }
var inspection = new ObsoleteLetStatementInspection(parser.State);
var inspectionResults = inspection.GetInspectionResults();
Assert.AreEqual(0, inspectionResults.Count());
}
public void ProcedureUsed_DoesNotReturnResult()
{
const string inputCode =
@"Private Sub Foo()
Goo
End Sub
Private Sub Goo()
Foo
End Sub";
//Arrange
var builder = new MockVbeBuilder();
VBComponent component;
var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);
var mockHost = new Mock<IHostApplication>();
mockHost.SetupAllProperties();
var parser = MockParser.Create(vbe.Object, new RubberduckParserState());
parser.Parse();
if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); }
var inspection = new ProcedureNotUsedInspection(parser.State);
var inspectionResults = inspection.GetInspectionResults();
Assert.AreEqual(0, inspectionResults.Count());
}
public void UseMeaningfulName_ReturnsResult_NameEndsWithDigit()
{
const string inputCode =
@"Sub Foo1()
End Sub";
//Arrange
var builder = new MockVbeBuilder();
var project = builder.ProjectBuilder("VBAProject", vbext_ProjectProtection.vbext_pp_none)
.AddComponent("MyClass", vbext_ComponentType.vbext_ct_ClassModule, inputCode)
.Build();
var vbe = builder.AddProject(project).Build();
var mockHost = new Mock<IHostApplication>();
mockHost.SetupAllProperties();
var parser = MockParser.Create(vbe.Object, new RubberduckParserState());
parser.Parse();
if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); }
var inspection = new UseMeaningfulNameInspection(null, parser.State);
var inspectionResults = inspection.GetInspectionResults();
Assert.AreEqual(1, inspectionResults.Count());
}
public void ObjectVariableNotSet_GivenObjectVariableNotSet_ReturnsResult()
{
const string inputCode = @"
Private Sub Workbook_Open()
Dim target As Range
target = Range(""A1"")
target.Value = ""forgot something?""
End Sub";
//Arrange
var builder = new MockVbeBuilder();
VBComponent component;
var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);
var mockHost = new Mock<IHostApplication>();
mockHost.SetupAllProperties();
var parser = MockParser.Create(vbe.Object, new RubberduckParserState());
parser.Parse();
if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); }
var inspection = new ObjectVariableNotSetInspection(parser.State);
var inspectionResults = inspection.GetInspectionResults();
Assert.AreEqual(1, inspectionResults.Count());
}
public void MoveFieldCloserToUsage_DoesNotReturnsResult_MultipleReferenceInDifferentScope()
{
const string inputCode =
@"Private bar As String
Public Sub Foo()
Let bar = ""test""
End Sub
Public Sub For()
Let bar = ""test""
End Sub";
//Arrange
var builder = new MockVbeBuilder();
VBComponent component;
var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);
var mockHost = new Mock<IHostApplication>();
mockHost.SetupAllProperties();
var parser = MockParser.Create(vbe.Object, new RubberduckParserState());
parser.Parse();
if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); }
var inspection = new MoveFieldCloserToUsageInspection(parser.State);
var inspectionResults = inspection.GetInspectionResults();
Assert.AreEqual(0, inspectionResults.Count());
}
public void ImplicitPublicMember_ReturnsResult_MultipleSubs()
{
const string inputCode =
@"Sub Foo()
End Sub
Sub Goo()
End Sub";
//Arrange
var builder = new MockVbeBuilder();
VBComponent component;
var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);
var mockHost = new Mock<IHostApplication>();
mockHost.SetupAllProperties();
var parser = MockParser.Create(vbe.Object, new RubberduckParserState());
parser.Parse();
if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); }
var inspection = new ImplicitPublicMemberInspection(parser.State);
var inspectionResults = inspection.GetInspectionResults();
Assert.AreEqual(2, inspectionResults.Count());
}
public void EncapsulatePublicField_WithLetter()
{
//Input
const string inputCode =
@"Public fizz As Integer";
var selection = new Selection(1, 1, 1, 1);
//Expectation
const string expectedCode =
@"Private fizz As Integer
Public Property Get Name() As Integer
Name = fizz
End Property
Public Property Let Name(ByVal value As Integer)
fizz = value
End Property
";
//Arrange
var builder = new MockVbeBuilder();
VBComponent component;
var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);
var project = vbe.Object.VBProjects.Item(0);
var module = project.VBComponents.Item(0).CodeModule;
var codePaneFactory = new CodePaneWrapperFactory();
var mockHost = new Mock<IHostApplication>();
mockHost.SetupAllProperties();
var parser = MockParser.Create(vbe.Object, new RubberduckParserState());
parser.Parse();
if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); }
var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection);
var model = new EncapsulateFieldModel(parser.State, qualifiedSelection)
{
ImplementLetSetterType = true,
ImplementSetSetterType = false,
ParameterName = "value",
PropertyName = "Name"
};
//SetupFactory
var factory = SetupFactory(model);
//Act
var refactoring = new EncapsulateFieldRefactoring(factory.Object, new ActiveCodePaneEditor(vbe.Object, codePaneFactory));
refactoring.Refactor(qualifiedSelection);
//Assert
Assert.AreEqual(expectedCode, module.Lines());
}
public void ExtractMethod_PrivateFunction()
{
const string inputCode = @"
Private Sub Foo()
Dim x As Integer
x = 1 + 2
End Sub";
const string expectedCode = @"
Private Sub Foo()
x = Bar()
End Sub
Private Function Bar() As Integer
Dim x As Integer
x = 1 + 2
Bar = x
End Function
";
var codePaneFactory = new CodePaneWrapperFactory();
var builder = new MockVbeBuilder();
VBComponent component;
var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);
var module = component.CodeModule;
var mockHost = new Mock<IHostApplication>();
mockHost.SetupAllProperties();
var editor = new ActiveCodePaneEditor(module.VBE, codePaneFactory);
var parser = MockParser.Create(vbe.Object, new RubberduckParserState());
parser.Parse();
if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); }
var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(module.Parent), new Selection(4, 1, 4, 20));
var model = new ExtractMethodModel(editor, parser.State.AllDeclarations, qualifiedSelection);
model.Method.Accessibility = Accessibility.Private;
model.Method.MethodName = "Bar";
model.Method.ReturnValue = new ExtractedParameter("Integer", ExtractedParameter.PassedBy.ByVal, "x");
model.Method.Parameters = new List<ExtractedParameter>();
var factory = SetupFactory(model);
//act
var refactoring = new ExtractMethodRefactoring(factory.Object, editor);
refactoring.Refactor(qualifiedSelection);
//assert
Assert.AreEqual(expectedCode, module.Lines());
}
private RubberduckParserState Resolve(string code, vbext_ComponentType moduleType = vbext_ComponentType.vbext_ct_StdModule)
{
var builder = new MockVbeBuilder();
VBComponent component;
var vbe = builder.BuildFromSingleModule(code, moduleType, out component);
var parser = MockParser.Create(vbe.Object, new RubberduckParserState());
parser.Parse();
if (parser.State.Status != ParserState.Ready)
{
Assert.Inconclusive("Parser state should be 'Ready', but returns '{0}'.", parser.State.Status);
}
return parser.State;
}
public MockProjectBuilder(string name, vbext_ProjectProtection protection, Func<VBE> getVbe, MockVbeBuilder mockVbeBuilder)
{
_getVbe = getVbe;
_mockVbeBuilder = mockVbeBuilder;
_project = CreateProjectMock(name, protection);
_project.SetupProperty(m => m.HelpFile);
_vbComponents = CreateComponentsMock();
_project.SetupGet(m => m.VBComponents).Returns(_vbComponents.Object);
_vbReferences = CreateReferencesMock();
_project.SetupGet(m => m.References).Returns(_vbReferences.Object);
}
private string Parse(string code)
{
var builder = new MockVbeBuilder();
VBComponent component;
var vbe = builder.BuildFromSingleStandardModule(code, out component);
var mockHost = new Mock<IHostApplication>();
mockHost.SetupAllProperties();
var state = new RubberduckParserState();
var parser = MockParser.Create(vbe.Object, state);
parser.Parse();
if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); }
var tree = state.GetParseTree(component);
var parsed = tree.GetText();
var withoutEOF = parsed.Substring(0, parsed.Length - 5);
return withoutEOF;
}
public void RenameRefactoring_RenameVariable()
{
//Input
const string inputCode =
@"Private Sub Foo()
Dim val1 As Integer
End Sub";
var selection = new Selection(2, 12, 2, 12);
//Expectation
const string expectedCode =
@"Private Sub Foo()
Dim val2 As Integer
End Sub";
//Arrange
var builder = new MockVbeBuilder();
VBComponent component;
var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);
var project = vbe.Object.VBProjects.Item(0);
var module = project.VBComponents.Item(0).CodeModule;
var codePaneFactory = new CodePaneWrapperFactory();
var mockHost = new Mock<IHostApplication>();
mockHost.SetupAllProperties();
var parser = MockParser.Create(vbe.Object, new RubberduckParserState());
parser.Parse();
if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); }
var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection);
var model = new RenameModel(vbe.Object, parser.State, qualifiedSelection, null) { NewName = "val2" };
//SetupFactory
var factory = SetupFactory(model);
//Act
var refactoring = new RenameRefactoring(factory.Object, new ActiveCodePaneEditor(vbe.Object, codePaneFactory), null, parser.State);
refactoring.Refactor(qualifiedSelection);
//Assert
Assert.AreEqual(expectedCode, module.Lines());
}
public void ReorderParams_RefactorDeclaration()
{
//Input
const string inputCode =
@"Private Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String)
End Sub";
var selection = new Selection(1, 23, 1, 27);
//Expectation
const string expectedCode =
@"Private Sub Foo(ByVal arg2 As String, ByVal arg1 As Integer)
End Sub";
//Arrange
var builder = new MockVbeBuilder();
VBComponent component;
var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);
var project = vbe.Object.VBProjects.Item(0);
var module = project.VBComponents.Item(0).CodeModule;
var codePaneFactory = new CodePaneWrapperFactory();
var mockHost = new Mock<IHostApplication>();
mockHost.SetupAllProperties();
var parser = MockParser.Create(vbe.Object, new RubberduckParserState());
parser.Parse();
if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); }
var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection);
//set up model
var model = new ReorderParametersModel(parser.State, qualifiedSelection, null);
model.Parameters.Reverse();
var factory = SetupFactory(model);
//act
var refactoring = new ReorderParametersRefactoring(factory.Object, new ActiveCodePaneEditor(vbe.Object, codePaneFactory), null);
refactoring.Refactor(model.TargetDeclaration);
//assert
Assert.AreEqual(expectedCode, module.Lines());
}
public void NotAlreadySpecified_ReturnsResult()
{
const string inputCode = @"";
//Arrange
var builder = new MockVbeBuilder();
VBComponent component;
var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);
var mockHost = new Mock<IHostApplication>();
mockHost.SetupAllProperties();
var parser = MockParser.Create(vbe.Object, new RubberduckParserState());
parser.Parse();
if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); }
var inspection = new OptionExplicitInspection(parser.State);
var inspectionResults = inspection.GetInspectionResults();
Assert.AreEqual(1, inspectionResults.Count());
}
public void MoveCloserToUsageRefactoring_Field()
{
//Input
const string inputCode =
@"Private bar As Boolean
Private Sub Foo()
bar = True
End Sub";
var selection = new Selection(1, 1, 1, 1);
//Expectation
const string expectedCode =
@"Private Sub Foo()
Dim bar As Boolean
bar = True
End Sub";
//Arrange
var builder = new MockVbeBuilder();
VBComponent component;
var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);
var project = vbe.Object.VBProjects.Item(0);
var module = project.VBComponents.Item(0).CodeModule;
var codePaneFactory = new CodePaneWrapperFactory();
var mockHost = new Mock<IHostApplication>();
mockHost.SetupAllProperties();
var parser = MockParser.Create(vbe.Object, new RubberduckParserState());
parser.Parse();
if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); }
var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection);
//Act
var refactoring = new MoveCloserToUsageRefactoring(parser.State, new ActiveCodePaneEditor(vbe.Object, codePaneFactory), null);
refactoring.Refactor(qualifiedSelection);
//Assert
Assert.AreEqual(expectedCode, module.Lines());
}
public void ObsoleteCallStatement_FieldWithDoubleTypeHintReturnsResult()
{
const string inputCode =
@"Public Foo#";
//Arrange
var builder = new MockVbeBuilder();
VBComponent component;
var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);
var mockHost = new Mock<IHostApplication>();
mockHost.SetupAllProperties();
var parser = MockParser.Create(vbe.Object, new RubberduckParserState());
parser.Parse();
if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); }
var inspection = new ObsoleteTypeHintInspection(parser.State);
var inspectionResults = inspection.GetInspectionResults();
Assert.AreEqual(1, inspectionResults.Count());
}
public void ObsoleteGlobal_ReturnsResult_MultipleGlobals()
{
const string inputCode =
@"Global var1 As Integer
Global var2 As String";
//Arrange
var builder = new MockVbeBuilder();
VBComponent component;
var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);
var mockHost = new Mock<IHostApplication>();
mockHost.SetupAllProperties();
var parser = MockParser.Create(vbe.Object, new RubberduckParserState());
parser.Parse();
if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); }
var inspection = new ObsoleteGlobalInspection(parser.State);
var inspectionResults = inspection.GetInspectionResults();
Assert.AreEqual(2, inspectionResults.Count());
}
public void ParameterCanByByVal_ReturnsResult_PassedByNotSpecified()
{
const string inputCode =
@"Sub Foo(arg1 As String)
End Sub";
//Arrange
var builder = new MockVbeBuilder();
VBComponent component;
var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);
var mockHost = new Mock<IHostApplication>();
mockHost.SetupAllProperties();
var parser = MockParser.Create(vbe.Object, new RubberduckParserState());
parser.Parse();
if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); }
var inspection = new ParameterCanBeByValInspection(parser.State);
var inspectionResults = inspection.GetInspectionResults();
Assert.AreEqual(1, inspectionResults.Count());
}
public void AssignedByValParameter_ReturnsResult_Function()
{
const string inputCode =
@"Function Foo(ByVal arg1 As Integer) As Boolean
Let arg1 = 9
End Function";
//Arrange
var builder = new MockVbeBuilder();
VBComponent component;
var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);
var mockHost = new Mock<IHostApplication>();
mockHost.SetupAllProperties();
var parser = MockParser.Create(vbe.Object, new RubberduckParserState());
parser.Parse();
if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); }
var inspection = new AssignedByValParameterInspection(parser.State);
var inspectionResults = inspection.GetInspectionResults();
Assert.AreEqual(1, inspectionResults.Count());
}
private RubberduckParserState Resolve(params Tuple<string,vbext_ComponentType>[] components)
{
var builder = new MockVbeBuilder();
var projectBuilder = builder.ProjectBuilder("TestProject", vbext_ProjectProtection.vbext_pp_none);
for (var i = 0; i < components.Length; i++)
{
projectBuilder.AddComponent("Component" + (i + 1), components[i].Item2, components[i].Item1);
}
var project = projectBuilder.Build();
builder.AddProject(project);
var vbe = builder.Build();
var parser = MockParser.Create(vbe.Object, new RubberduckParserState());
parser.Parse();
if (parser.State.Status != ParserState.Ready)
{
Assert.Inconclusive("Parser state should be 'Ready', but returns '{0}'.", parser.State.Status);
}
return parser.State;
}
public void DefaultProjectName_DoesNotReturnResult()
{
const string inputCode = @"";
//Arrange
var builder = new MockVbeBuilder();
var project = builder.ProjectBuilder("TestProject", vbext_ProjectProtection.vbext_pp_none)
.AddComponent("Class1", vbext_ComponentType.vbext_ct_ClassModule, inputCode)
.Build();
var vbe = builder.AddProject(project).Build();
var mockHost = new Mock<IHostApplication>();
mockHost.SetupAllProperties();
var parser = MockParser.Create(vbe.Object, new RubberduckParserState());
parser.Parse();
if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); }
var inspection = new DefaultProjectNameInspection(parser.State);
var inspectionResults = inspection.GetInspectionResults();
Assert.AreEqual(0, inspectionResults.Count());
}
public void MultipleDeclarations_ReturnsResult_Constants()
{
const string inputCode =
@"Public Sub Foo()
Const var1 As Integer = 9, var2 As String = ""test""
End Sub";
//Arrange
var builder = new MockVbeBuilder();
VBComponent component;
var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);
var mockHost = new Mock<IHostApplication>();
mockHost.SetupAllProperties();
var parser = MockParser.Create(vbe.Object, new RubberduckParserState());
parser.Parse();
if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); }
var inspection = new MultipleDeclarationsInspection(parser.State);
var inspectionResults = inspection.GetInspectionResults();
Assert.AreEqual(1, inspectionResults.Count());
}
public static Mock <IVBE> BuildFromSingleModule(string content, string name, ComponentType type, out IVBComponent component, Selection selection = default(Selection), bool referenceStdLibs = false)
{
var vbeBuilder = new MockVbeBuilder();
var builder = vbeBuilder.ProjectBuilder(TestProjectName, ProjectProtection.Unprotected);
builder.AddComponent(name, type, content, selection);
if (referenceStdLibs)
{
builder.AddReference("VBA", LibraryPathVBA, 4, 1, true);
}
var project = builder.Build();
var vbe = vbeBuilder.AddProject(project).Build();
component = project.Object.VBComponents[0];
vbe.Object.ActiveVBProject = project.Object;
vbe.Object.ActiveCodePane = component.CodeModule.CodePane;
return(vbe);
}
public void ImplicitByRefParameter_QuickFixWorks_ParamArrayIsIgnored()
{
const string inputCode =
@"Sub Foo(ParamArray arg1 As Integer)
End Sub";
//Arrange
var builder = new MockVbeBuilder();
VBComponent component;
var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);
var mockHost = new Mock<IHostApplication>();
mockHost.SetupAllProperties();
var parser = MockParser.Create(vbe.Object, new RubberduckParserState());
parser.Parse();
if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); }
var inspection = new ImplicitByRefParameterInspection(parser.State);
var inspectionResults = inspection.GetInspectionResults();
Assert.AreEqual(0, inspectionResults.Count());
}
public void ImplicitByRefParameter_QuickFixWorks_PassByRef()
{
const string inputCode =
@"Sub Foo(arg1 As Integer)
End Sub";
const string expectedCode =
@"Sub Foo(ByRef arg1 As Integer)
End Sub";
//Arrange
var builder = new MockVbeBuilder();
VBComponent component;
var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);
var project = vbe.Object.VBProjects.Item(0);
var module = project.VBComponents.Item(0).CodeModule;
var mockHost = new Mock<IHostApplication>();
mockHost.SetupAllProperties();
var parser = MockParser.Create(vbe.Object, new RubberduckParserState());
parser.Parse();
if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); }
var inspection = new ImplicitByRefParameterInspection(parser.State);
var inspectionResults = inspection.GetInspectionResults();
inspectionResults.First().QuickFixes.First().Fix();
Assert.AreEqual(expectedCode, module.Lines());
}
public MockProjectBuilder(string name, string filename, string projectId, ProjectProtection protection, ProjectType projectType, Func <IVBE> getVbe, MockVbeBuilder mockVbeBuilder)
{
_getVbe = getVbe;
_mockVbeBuilder = mockVbeBuilder;
_projectType = projectType;
_project = CreateProjectMock(name, filename, protection);
_project.SetupProperty(m => m.HelpFile);
_project.SetupGet(m => m.ProjectId).Returns(() => _project.Object.HelpFile);
_project.SetupGet(m => m.Type).Returns(_projectType);
_project.Setup(m => m.AssignProjectId())
.Callback(() => _project.Object.HelpFile = projectId);
_vbComponents = CreateComponentsMock();
_project.SetupGet(m => m.VBComponents).Returns(_vbComponents.Object);
_vbReferences = CreateReferencesMock();
_project.SetupGet(m => m.References).Returns(_vbReferences.Object);
}
public MockProjectBuilder(string name, string filename, ProjectProtection protection, ProjectType projectType, Func <IVBE> getVbe, MockVbeBuilder mockVbeBuilder)
: this(
name,
filename,
Guid.NewGuid().ToString(),
protection,
projectType,
getVbe,
mockVbeBuilder
)
{
}
public MockProjectBuilder(string name, string filename, vbext_ProjectProtection protection, Func <VBE> getVbe, MockVbeBuilder mockVbeBuilder)
{
_getVbe = getVbe;
_mockVbeBuilder = mockVbeBuilder;
_project = CreateProjectMock(name, filename, protection);
_project.SetupProperty(m => m.HelpFile);
_vbComponents = CreateComponentsMock();
_project.SetupGet(m => m.VBComponents).Returns(_vbComponents.Object);
_vbReferences = CreateReferencesMock();
_project.SetupGet(m => m.References).Returns(_vbReferences.Object);
}