|
public BuildFromSingleStandardModule ( string content, VBComponent &component ) : Mock |
||
| content | string | The VBA code associated to the component. |
| component | VBComponent | The created |
| return | Mock |
|
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 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 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 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 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 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 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 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 ObsoleteLetStatement_ReturnsResult_MultipleLets()
{
const string inputCode =
@"Public Sub Foo()
Dim var1 As Integer
Dim var2 As Integer
Let var2 = var1
Let var1 = var2
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(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 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 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 ObsoleteCommentSyntax_ReturnsMultipleResults()
{
const string inputCode =
@"Rem test1
Rem test2";
//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 ObsoleteCommentSyntaxInspection(parser.State);
var inspectionResults = inspection.GetInspectionResults();
Assert.AreEqual(2, 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());
}
public void VariableTypeNotDeclared_ReturnsResult_QuickFixWorks_Variable()
{
const string inputCode =
@"Sub Foo()
Dim var1
End Sub";
const string expectedCode =
@"Sub Foo()
Dim var1 As Variant
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 VariableTypeNotDeclaredInspection(parser.State);
inspection.GetInspectionResults().First().QuickFixes.First().Fix();
Assert.AreEqual(expectedCode, module.Lines());
}
public void VariableTypeNotDeclared_ReturnsResult_SomeTypesNotDeclared_Variables()
{
const string inputCode =
@"Sub Foo()
Dim var1
Dim var2 As Date
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 VariableTypeNotDeclaredInspection(parser.State);
var inspectionResults = inspection.GetInspectionResults();
Assert.AreEqual(1, inspectionResults.Count());
}
public void ObsoleteGlobal_ReturnsResult_SomeConstantsUsed()
{
const string inputCode =
@"Public var1 As Integer
Global var2 As Date";
//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(1, inspectionResults.Count());
}
public void IntroduceFieldRefactoring_PassInTarget_Nonvariable()
{
//Input
const string inputCode =
@"Private bar As Boolean
Private Sub Foo()
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 messageBox = new Mock<IMessageBox>();
messageBox.Setup(m => m.Show(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<MessageBoxButtons>(), It.IsAny<MessageBoxIcon>()))
.Returns(DialogResult.OK);
//Act
var refactoring = new MoveCloserToUsageRefactoring(parser.State, new ActiveCodePaneEditor(vbe.Object, codePaneFactory), messageBox.Object);
//Assert
try
{
refactoring.Refactor(parser.State.AllUserDeclarations.First(d => d.DeclarationType != DeclarationType.Variable));
}
catch (ArgumentException e)
{
Assert.AreEqual("Invalid Argument. DeclarationType must be 'Variable'\r\nParameter name: target", e.Message);
Assert.AreEqual(inputCode, module.Lines());
messageBox.Verify(m =>
m.Show(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<MessageBoxButtons>(),
It.IsAny<MessageBoxIcon>()), Times.Once);
return;
}
Assert.Fail();
}
public void MoveCloserToUsageRefactoring_ReferenceIsSeparatedWithColon()
{
//Input
const string inputCode =
@"Private bar As Boolean
Private Sub Foo(): Baz True, True, bar: End Sub
Private Sub Baz(ByVal bat As Boolean, ByVal bas As Boolean, ByVal bac As Boolean): End Sub";
var selection = new Selection(1, 1, 1, 1);
// Yeah, this code is a mess. That is why we got the SmartIndenter
const string expectedCode =
@"Private Sub Foo()
Dim bar As Boolean
Baz True, True, bar
End Sub
Private Sub Baz(ByVal bat As Boolean, ByVal bas As Boolean, ByVal bac As Boolean): 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 MoveCloserToUsageRefactoring_MultipleVariablesOneStatement_MoveLast()
{
//Input
const string inputCode =
@"Private Sub Foo()
Dim bar As Integer, _
bat As Boolean, _
bay As Date
bar = 4
bay = #1/13/2004#
End Sub";
var selection = new Selection(4, 16, 4, 16);
//Expectation
const string expectedCode =
@"Private Sub Foo()
Dim bar As Integer, bat As Boolean
bar = 4
Dim bay As Date
bay = #1/13/2004#
End Sub"; // note: VBE will remove extra spaces
//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 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 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 IntroduceFieldRefactoring_InvalidSelection()
{
//Input
const string inputCode =
@"Private bar As Boolean
Private Sub Foo()
bar = True
End Sub";
var selection = new Selection(2, 15, 2, 15);
//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 messageBox = new Mock<IMessageBox>();
messageBox.Setup(m => m.Show(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<MessageBoxButtons>(), It.IsAny<MessageBoxIcon>()))
.Returns(DialogResult.OK);
var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection);
//Act
var refactoring = new MoveCloserToUsageRefactoring(parser.State, new ActiveCodePaneEditor(vbe.Object, codePaneFactory), messageBox.Object);
refactoring.Refactor(qualifiedSelection);
messageBox.Verify(m =>
m.Show(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<MessageBoxButtons>(),
It.IsAny<MessageBoxIcon>()), Times.Once);
Assert.AreEqual(inputCode, module.Lines());
}
