private static ExtractInterfaceModel RetrieveModel(string code, Selection selection)
{
var vbe = MockVbeBuilder.BuildFromSingleModule(code, ComponentType.ClassModule, out _, selection);
using (var state = MockParser.CreateAndParse(vbe.Object))
{
var target = state.DeclarationFinder
.UserDeclarations(DeclarationType.ClassModule)
.OfType <ClassModuleDeclaration>()
.First();
return(new ExtractInterfaceModel(state, target, CreateCodeBuilder()));
}
}
public void Test_RPS_SuspendParser_IncompatibleState()
{
var result = SuspensionOutcome.Pending;
var wasSuspended = false;
var vbe = MockVbeBuilder.BuildFromSingleModule("", ComponentType.StandardModule, out var _);
using (var state = MockParser.CreateAndParse(vbe.Object))
{
result = state.OnSuspendParser(this, new [] { ParserState.Pending }, () => throw new OperationCanceledException()).Outcome;
}
Assert.IsFalse(wasSuspended);
Assert.AreEqual(SuspensionOutcome.IncompatibleState, result);
}
public void EmptyUserForm_DoesNotReturnResult()
{
const string inputCode = "";
var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.Document, out _);
using (var state = MockParser.CreateAndParse(vbe.Object))
{
var inspection = new EmptyModuleInspection(state);
var inspectionResults = inspection.GetInspectionResults(CancellationToken.None);
Assert.IsFalse(inspectionResults.Any());
}
}
public void ExtractInterface_CanExecute_PropertyLet()
{
var input =
@"Property Let foo(value)
End Property";
IVBComponent component;
var vbe = MockVbeBuilder.BuildFromSingleModule(input, ComponentType.ClassModule, out component, Selection.Home);
var state = MockParser.CreateAndParse(vbe.Object);
var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null);
Assert.IsTrue(extractInterfaceCommand.CanExecute(null));
}
public void ExtractInterfaceRefactoring_PassTargetIn()
{
//Input
const string inputCode =
@"Public Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String)
End Sub";
var selection = new Selection(1, 23, 1, 27);
//Expectation
const string expectedCode =
@"Implements ITestModule1
Public Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String)
End Sub
Private Sub ITestModule1_Foo(ByVal arg1 As Integer, ByVal arg2 As String)
Err.Raise 5 'TODO implement interface member
End Sub
";
const string expectedInterfaceCode =
@"Option Explicit
Public Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String)
End Sub
";
IVBComponent component;
var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out component, selection);
using (var state = MockParser.CreateAndParse(vbe.Object))
{
var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection);
//Specify Params to remove
var model = new ExtractInterfaceModel(state, qualifiedSelection);
model.Members.ElementAt(0).IsSelected = true;
//SetupFactory
var factory = SetupFactory(model);
var refactoring = new ExtractInterfaceRefactoring(vbe.Object, null, factory.Object);
refactoring.Refactor(state.AllUserDeclarations.Single(s => s.DeclarationType == DeclarationType.ClassModule));
Assert.AreEqual(expectedInterfaceCode, component.Collection[1].CodeModule.Content());
Assert.AreEqual(expectedCode, component.CodeModule.Content());
}
}
public void PreviewWrapMember_EditPropertyIdentifier()
{
var inputCode =
$@"Option Explicit
Private Type T{MockVbeBuilder.TestModuleName}
FirstValue As Long
End Type
Private Type B{MockVbeBuilder.TestModuleName}
FirstValue As Long
End Type
Public mTest As Long
Private tType As T{MockVbeBuilder.TestModuleName}
Private bType As B{MockVbeBuilder.TestModuleName}
";
var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.StandardModule, out _);
(RubberduckParserState state, IRewritingManager rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);
using (state)
{
var target = state.DeclarationFinder.MatchName("mTest").First();
var resolver = Support.SetupResolver(state, rewritingManager, null);
var modelfactory = resolver.Resolve <IEncapsulateFieldModelFactory>();
var model = modelfactory.Create(target);
var field = model["mTest"];
field.PropertyIdentifier = "ATest";
model.EncapsulateFieldStrategy = EncapsulateFieldStrategy.ConvertFieldsToUDTMembers;
var test = model.ObjectStateUDTCandidates;
Assert.AreEqual(3, test.Count());
var previewProvider = resolver.Resolve <EncapsulateFieldPreviewProvider>();
var firstPreview = previewProvider.Preview(model);
StringAssert.Contains("Property Get ATest", firstPreview);
field.PropertyIdentifier = "BTest";
var secondPreview = previewProvider.Preview(model);
StringAssert.Contains("Property Get BTest", secondPreview);
StringAssert.DoesNotContain("Property Get ATest", secondPreview);
}
}
public void ExtractInterface_CanExecute_PropertySet()
{
var input =
@"Property Set foo(value)
End Property";
var vbe = MockVbeBuilder.BuildFromSingleModule(input, ComponentType.ClassModule, out _, Selection.Home);
var(state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);
using (state)
{
var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null, rewritingManager);
Assert.IsTrue(extractInterfaceCommand.CanExecute(null));
}
}
public void UnassignedVariableUsage_NoResultIfNoReferences()
{
const string inputCode =
@"Sub DoSomething()
Dim foo
End Sub";
var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out _);
var state = MockParser.CreateAndParse(vbe.Object);
var inspection = new UnassignedVariableUsageInspection(state);
var inspectionResults = inspection.GetInspectionResults();
Assert.IsFalse(inspectionResults.Any());
}
public void ExtractInterface_CanExecute_Function()
{
var input =
@"Function foo() As Integer
End Function";
var vbe = MockVbeBuilder.BuildFromSingleModule(input, ComponentType.ClassModule, out _, Selection.Home);
var(state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);
using (state)
{
var extractInterfaceCommand = TestRefactorExtractInterfaceCommand(vbe.Object, state, rewritingManager);
Assert.IsTrue(extractInterfaceCommand.CanExecute(null));
}
}
public void ExtractInterface_CanExecute_Function()
{
var input =
@"Function foo() As Integer
End Function";
IVBComponent component;
var vbe = MockVbeBuilder.BuildFromSingleModule(input, ComponentType.ClassModule, out component, Selection.Home);
using (var state = MockParser.CreateAndParse(vbe.Object))
{
var extractInterfaceCommand = new RefactorExtractInterfaceCommand(vbe.Object, state, null);
Assert.IsTrue(extractInterfaceCommand.CanExecute(null));
}
}
public void ProcedureNotUsed_NoResultForCasedClassTerminate()
{
//Input
const string inputCode =
@"Private Sub class_terminate()
End Sub";
var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out _);
var state = MockParser.CreateAndParse(vbe.Object);
var inspection = new ProcedureNotUsedInspection(state);
var inspectionResults = inspection.GetInspectionResults();
Assert.AreEqual(0, inspectionResults.Count());
}
public void Test_RPS_SuspendParser_Canceled()
{
SuspensionResult result;
var vbe = MockVbeBuilder.BuildFromSingleModule("", ComponentType.StandardModule, out var _);
using (var state = MockParser.CreateAndParse(vbe.Object))
{
result = state.OnSuspendParser(this, AllowedRunStates, () => throw new OperationCanceledException());
}
Assert.IsNotNull(result.EncounteredException);
Assert.AreEqual(typeof(OperationCanceledException), result.EncounteredException.GetType());
Assert.AreEqual(SuspensionOutcome.Canceled, result.Outcome);
}
public void BasicExample_Property()
{
const string inputCode =
@"Public Property Get Test_This_Out() As Integer
End Property";
var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out _);
using (var state = MockParser.CreateAndParse(vbe.Object))
{
var inspection = new UnderscoreInPublicClassModuleMemberInspection(state);
var inspector = InspectionsHelper.GetInspector(inspection);
var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
Assert.AreEqual(1, inspectionResults.Count());
}
}
public void ProcedureNotUsed_NoResultForClassInitialize()
{
//Input
const string inputCode =
@"Private Sub Class_Initialize()
End Sub";
IVBComponent component;
var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out component);
var state = MockParser.CreateAndParse(vbe.Object);
var inspection = new ProcedureNotUsedInspection(state, new Mock <IMessageBox>().Object);
var inspectionResults = inspection.GetInspectionResults();
Assert.AreEqual(0, inspectionResults.Count());
}
public void Factory_NoMembersInTarget_ReturnsNull()
{
//Input
const string inputCode =
@"Private Sub Foo()
End Sub";
var selection = new Selection(1, 15, 1, 15);
IVBComponent component;
var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out component, selection);
var state = MockParser.CreateAndParse(vbe.Object);
var factory = new ExtractInterfacePresenterFactory(vbe.Object, state, null);
Assert.AreEqual(null, factory.Create());
}
public void NoUnderscore()
{
const string inputCode =
@"Public Sub Foo()
End Sub";
var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out _);
using (var state = MockParser.CreateAndParse(vbe.Object))
{
var inspection = new UnderscoreInPublicClassModuleMemberInspection(state);
var inspector = InspectionsHelper.GetInspector(inspection);
var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
Assert.AreEqual(0, inspectionResults.Count());
}
}
public void ExtractInterfaceRefactoring_NullModel_NoChanges()
{
//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);
//Arrange
var builder = new MockVbeBuilder();
VBComponent component;
var vbe = builder.BuildFromSingleModule(inputCode, vbext_ComponentType.vbext_ct_ClassModule, out component, selection);
var project = vbe.Object.VBProjects.Item(0);
var mockHost = new Mock <IHostApplication>();
mockHost.SetupAllProperties();
var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock <ISinks>().Object));
parser.Parse(new CancellationTokenSource());
if (parser.State.Status >= ParserState.Error)
{
Assert.Inconclusive("Parser Error");
}
var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection);
//Specify Params to remove
var model = new ExtractInterfaceModel(parser.State, qualifiedSelection);
var presenter = new Mock <IExtractInterfacePresenter>();
presenter.Setup(p => p.Show()).Returns(value: null);
//SetupFactory
var factory = SetupFactory(model);
factory.Setup(f => f.Create()).Returns(presenter.Object);
//Act
var refactoring = new ExtractInterfaceRefactoring(vbe.Object, parser.State, null, factory.Object);
refactoring.Refactor();
//Assert
Assert.AreEqual(1, project.VBComponents.Cast <VBComponent>().Count()); // somehow, the VBComponents Count mock isn't working
Assert.AreEqual(inputCode, project.VBComponents.Item(0).CodeModule.Lines());
}
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);
}
public void ModuleWithPropertyLet_DoesNotReturnResult()
{
const string inputCode =
@"Public Property Let Foo(rhs As Variant)
End Property
";
var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.UserForm, out _);
using (var state = MockParser.CreateAndParse(vbe.Object))
{
var inspection = new EmptyModuleInspection(state);
var inspectionResults = inspection.GetInspectionResults(CancellationToken.None);
Assert.IsFalse(inspectionResults.Any());
}
}
public void ProcedureNotUsed_NoResultForClassInitialize()
{
//Input
const string inputCode =
@"Private Sub Class_Initialize()
End Sub";
var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out _);
using (var state = MockParser.CreateAndParse(vbe.Object))
{
var inspection = new ProcedureNotUsedInspection(state);
var inspectionResults = inspection.GetInspectionResults(CancellationToken.None);
Assert.AreEqual(0, inspectionResults.Count());
}
}
public void Factory_NullSelectionNullReturnsNullPresenter()
{
//Input
const string inputCode =
@"Private Sub Foo()
End Sub";
IVBComponent component;
var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out component);
var state = MockParser.CreateAndParse(vbe.Object);
vbe.Setup(v => v.ActiveCodePane).Returns((ICodePane)null);
var factory = new ExtractInterfacePresenterFactory(vbe.Object, state, null);
Assert.AreEqual(null, factory.Create());
}
public void UnassignedVariableUsage_ReturnsResult()
{
const string inputCode =
@"Sub Foo()
Dim b As Boolean
Dim bb As Boolean
bb = b
End Sub";
var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out _);
var state = MockParser.CreateAndParse(vbe.Object);
var inspection = new UnassignedVariableUsageInspection(state);
var inspectionResults = inspection.GetInspectionResults();
Assert.AreEqual(1, inspectionResults.Count());
}
public void Test_RPS_SuspendParser_Interrupted_Deadlock()
{
var wasSuspended = false;
var result = SuspensionOutcome.Pending;
var vbe = MockVbeBuilder.BuildFromSingleModule("", ComponentType.StandardModule, out var _);
using (var state = MockParser.CreateAndParse(vbe.Object))
{
// The cancellation token exists primarily to prevent
// unwanted inlining of the tasks.
// See: https://stackoverflow.com/questions/12245935/is-task-factory-startnew-guaranteed-to-use-another-thread-than-the-calling-thr
var source = new CancellationTokenSource();
var token = source.Token;
Task result2 = null;
state.StateChanged += (o, e) =>
{
if (e.State == ParserState.Started)
{
result2 = Task.Run(() =>
{
result =
state.OnSuspendParser(this, AllowedRunStates,
() => { wasSuspended = state.Status == ParserState.Busy; },
20)
.Outcome;
}, token);
result2.Wait(token);
}
};
var result1 = Task.Run(() =>
{
state.OnParseRequested(this);
}, token);
result1.Wait(token);
while (result2 == null)
{
Thread.Sleep(1);
}
result2.Wait(token);
}
Assert.IsFalse(wasSuspended, "wasSuspended was set to true");
Assert.AreEqual(SuspensionOutcome.TimedOut, result);
}
public void MultipleFolderAnnotations_NoIgnoreQuickFix()
{
const string inputCode =
@"'@Folder ""Foo.Bar""
'@Folder ""Biz.Buz""
Public Sub Foo()
Const const1 As Integer = 9
End Sub";
IVBComponent component;
var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out component);
var state = MockParser.CreateAndParse(vbe.Object);
var inspection = new MultipleFolderAnnotationsInspection(state);
var inspectionResults = inspection.GetInspectionResults();
Assert.IsFalse(inspectionResults.ElementAt(0).QuickFixes.Any(q => q is IgnoreOnceQuickFix));
}
public void Test_RPS_SuspendParser_Interrupted_IsQueued()
{
var reparseAfterBusy = 0;
var vbe = MockVbeBuilder.BuildFromSingleModule("", ComponentType.StandardModule, out var _);
using (var state = MockParser.CreateAndParse(vbe.Object))
{
var wasBusy = false;
Task result = null;
state.StateChanged += (o, e) =>
{
if (e.State == ParserState.Started)
{
if (result == null)
{
result = Task.Run(() =>
{
state.OnSuspendParser(this, AllowedRunStates, () =>
{
wasBusy = state.Status == ParserState.Busy;
});
});
wasBusy = false;
}
}
if (e.State == ParserState.Ready && wasBusy)
{
reparseAfterBusy++;
}
};
state.OnParseRequested(this);
while (result == null)
{
Thread.Sleep(1);
}
result.Wait();
}
Assert.AreEqual(1, reparseAfterBusy);
}
public void ExtractInterfaceRefactoring_IgnoresField()
{
//Input
const string inputCode =
@"Public Fizz As Boolean";
var selection = new Selection(1, 23, 1, 27);
var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out _, selection);
using (var state = MockParser.CreateAndParse(vbe.Object))
{
var target = state.DeclarationFinder.UserDeclarations(DeclarationType.ClassModule).First();
//Specify Params to remove
var model = new ExtractInterfaceModel(state, target);
Assert.AreEqual(0, model.Members.Count);
}
}
public void ExtractInterfaceRefactoring_IgnoresField()
{
//Input
const string inputCode =
@"Public Fizz As Boolean";
var selection = new Selection(1, 23, 1, 27);
IVBComponent component;
var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out component, selection);
var state = MockParser.CreateAndParse(vbe.Object);
var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection);
//Specify Params to remove
var model = new ExtractInterfaceModel(state, qualifiedSelection);
Assert.AreEqual(0, model.Members.Count());
}
public void UnassignedVariableUsage_DoesNotReturnResult()
{
const string inputCode =
@"Sub Foo()
Dim b As Boolean
Dim bb As Boolean
b = True
bb = b
End Sub";
IVBComponent component;
var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out component);
var state = MockParser.CreateAndParse(vbe.Object);
var inspection = new UnassignedVariableUsageInspection(state);
var inspectionResults = inspection.GetInspectionResults();
Assert.IsFalse(inspectionResults.Any());
}
public void Test_RPS_SuspendParser_NonReadyState_IsQueued()
{
var wasSuspended = false;
var vbe = MockVbeBuilder.BuildFromSingleModule("", ComponentType.StandardModule, out var _);
using (var state = MockParser.CreateAndParse(vbe.Object))
{
var allowedRunStates = new[] { ParserState.Pending, ParserState.Ready };
state.SetStatusAndFireStateChanged(this, ParserState.Pending, CancellationToken.None);
state.OnSuspendParser(this, allowedRunStates, () =>
{
wasSuspended = true;
});
}
Assert.IsTrue(wasSuspended);
}
public void ExtractInterfaceRefactoring_NullModel_NoChanges()
{
//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);
var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out var component, selection);
var(state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);
using (state)
{
var refactoring = TestRefactoring(vbe.Object, rewritingManager, state, model: null);
refactoring.Refactor();
Assert.AreEqual(1, vbe.Object.ActiveVBProject.VBComponents.Count());
Assert.AreEqual(inputCode, component.CodeModule.Content());
}
}