public void shouldProvideThePositionForTheNewMethod()
{
QualifiedModuleName qualifiedModuleName;
RubberduckParserState state;
MockParser.ParseString(inputCode, out qualifiedModuleName, out state);
var declarations = state.AllDeclarations;
var selection = new Selection(10, 1, 12, 17);
QualifiedSelection?qSelection = new QualifiedSelection(qualifiedModuleName, selection);
var emr = new Mock <IExtractMethodRule>();
var extractedMethod = new Mock <IExtractedMethod>();
var extractedMethodProc = new Mock <IExtractMethodProc>();
var paramClassify = new Mock <IExtractMethodParameterClassification>();
var SUT = new ExtractMethodModel(extractedMethod.Object, paramClassify.Object);
//Act
SUT.extract(declarations, qSelection.Value, selectedCode);
//Assert
var expected = new Selection(18, 1, 18, 1);
var actual = SUT.PositionForNewMethod;
Assert.AreEqual(expected, actual, "Call should have been at row " + expected + " but is at " + actual);
}
public void shouldUseEachRuleInRulesCollectionToCheckEachReference()
{
QualifiedModuleName qualifiedModuleName;
var state = MockParser.ParseString(codeSnippet, out qualifiedModuleName);
var declaration = state.AllUserDeclarations.Where(decl => decl.IdentifierName == "x").First();
var selection = new Selection(5, 1, 7, 20);
var qSelection = new QualifiedSelection(qualifiedModuleName, selection);
var emRule = new Mock <IExtractMethodRule>();
emRule.Setup(emr => emr.setValidFlag(It.IsAny <IdentifierReference>(), It.IsAny <Selection>())).Returns(2);
var emRules = new List <IExtractMethodRule>()
{
emRule.Object, emRule.Object
};
var sut = new ExtractMethodParameterClassification(emRules);
//Act
sut.classifyDeclarations(qSelection, declaration);
//Assert
// 2 rules on 2 references = 4 validation checks
var expectedToVerify = 4;
emRule.Verify(emr => emr.setValidFlag(It.IsAny <IdentifierReference>(), selection),
Times.Exactly(expectedToVerify));
}
public void shouldIncludeByRefParams()
{
QualifiedModuleName qualifiedModuleName;
var state = MockParser.ParseString(codeSnippet, out qualifiedModuleName);
var declaration = state.AllUserDeclarations.Where(decl => decl.IdentifierName == "x").First();
var selection = new Selection(5, 1, 7, 20);
var qSelection = new QualifiedSelection(qualifiedModuleName, selection);
// Above setup is headache from lack of ability to extract declarations simply.
// exact declaration and qSelection are irrelevant for this test and could be mocked.
var emByRefRule = new Mock <IExtractMethodRule>();
emByRefRule.Setup(em => em.setValidFlag(It.IsAny <IdentifierReference>(), It.IsAny <Selection>())).Returns(10);
var emRules = new List <IExtractMethodRule>()
{
emByRefRule.Object
};
var SUT = new ExtractMethodParameterClassification(emRules);
//Act
SUT.classifyDeclarations(qSelection, declaration);
var extractedParameter = SUT.ExtractedParameters.First();
Assert.IsTrue(SUT.ExtractedParameters.Count() > 0);
//Assert
Assert.AreEqual(extractedParameter.Passed, ExtractedParameter.PassedBy.ByRef);
}
public void shouldReturnFalse()
{
var inputCode = @"
Option Explicit
Private Sub Foo(byval a as long, _
byval b as long)
Dim x As Integer
x = 1 + 2
End Sub
Private Sub NewMethod
End Sub";
QualifiedModuleName qualifiedModuleName;
using (var state = MockParser.ParseString(inputCode, out qualifiedModuleName))
{
var declarations = state.AllDeclarations;
var selection = new Selection(4, 4, 7, 14);
QualifiedSelection?qSelection = new QualifiedSelection(qualifiedModuleName, selection);
var SUT = new ExtractMethodSelectionValidation(declarations);
var actual = SUT.withinSingleProcedure(qSelection.Value);
var expected = false;
Assert.AreEqual(expected, actual);
}
}
public void ShouldSplitTheCodeAroundTheDefinition()
{
#region inputCode
var inputCode = @"
Option explicit
Public Sub CodeWithDeclaration()
Dim x as long
Dim y as long
x = 1 + 2
DebugPrint x '8
y = x + 1
Dim z as long '10
z = x
DebugPrint z '12
x = 2
DebugPrint y
End Sub
Public Sub DebugPrint(byval g as long)
End Sub
";
#endregion
#region whatItShouldLookLike
/*
* public sub NewMethod(ByVal x as long, ByRef y as long)
* Dim z as long
* DebugPrint x
* y = x + 1
* z = x
* DebugPrint z
* end sub
*/
#endregion
using (var state = MockParser.ParseString(inputCode, out QualifiedModuleName qualifiedModuleName))
{
var declarations = state.AllDeclarations;
var selection = new Selection(8, 1, 12, 50);
QualifiedSelection?qSelection = new QualifiedSelection(qualifiedModuleName, selection);
var extractedMethod = new Mock <IExtractedMethod>();
var paramClassify = new Mock <IExtractMethodParameterClassification>();
var yDecl = declarations.Where(decl => decl.IdentifierName.Equals("z"));
var SUT = new ExtractMethodModel(extractedMethod.Object, paramClassify.Object);
//Act
var actual = SUT.SplitSelection(selection, declarations);
//Assert
var selection1 = new Selection(8, 1, 9, 1);
var selection2 = new Selection(11, 1, 12, 1);
Assert.AreEqual(selection1, actual.First(), "Top selection does not match");
Assert.AreEqual(selection2, actual.Skip(1).First(), "Bottom selection does not match");
}
}
public void shouldReturnAnIncrementedMethodName()
{
QualifiedModuleName qualifiedModuleName;
RubberduckParserState state;
#region inputCode
var inputCode = @"
Option Explicit
Private Sub Foo()
Dim x As Integer
x = 1 + 2
End Sub
Private Sub NewMethod
dim a as string
Debug.Print a
End Sub";
#endregion inputCode
MockParser.ParseString(inputCode, out qualifiedModuleName, out state);
var declarations = state.AllDeclarations;
var SUT = new ExtractedMethod();
var expected = "NewMethod1";
//Act
var actual = SUT.getNewMethodName(declarations);
//Assert
Assert.AreEqual(expected, actual);
}
public void shouldReturnNewMethod()
{
var inputCode = @"
Option Explicit
Private Sub Foo()
Dim x As Integer
x = 1 + 2
End Sub";
QualifiedModuleName qualifiedModuleName;
using (var state = MockParser.ParseString(inputCode, out qualifiedModuleName))
{
var declarations = state.AllDeclarations;
var SUT = new ExtractedMethod();
var expected = "NewMethod";
//Act
var actual = SUT.getNewMethodName(declarations);
//Assert
Assert.AreEqual(expected, actual);
}
}
public void ShouldProvideTheSelectionOfLinesOfToRemove()
{
using (var state = MockParser.ParseString(inputCode, out QualifiedModuleName qualifiedModuleName))
{
var declarations = state.AllDeclarations;
var selection = new Selection(10, 2, 12, 17);
QualifiedSelection?qSelection = new QualifiedSelection(qualifiedModuleName, selection);
var emr = new Mock <IExtractMethodRule>();
var extractedMethod = new Mock <IExtractedMethod>();
var paramClassify = new Mock <IExtractMethodParameterClassification>();
var extractDecl = declarations.Where(x => x.IdentifierName.Equals("y"));
paramClassify.Setup(pc => pc.DeclarationsToMove).Returns(extractDecl);
var extractedMethodModel = new ExtractMethodModel(extractedMethod.Object, paramClassify.Object);
//Act
extractedMethodModel.extract(declarations, qSelection.Value, selectedCode);
//Assert
var actual = extractedMethodModel.RowsToRemove;
var yDimSelection = new Selection(5, 9, 5, 10);
var expected = new[] { selection, yDimSelection }
.Select(x => new Selection(x.StartLine, 1, x.EndLine, 1));
var missing = expected.Except(actual);
var extra = actual.Except(expected);
missing.ToList().ForEach(x => Trace.WriteLine(string.Format("missing item {0}", x)));
extra.ToList().ForEach(x => Trace.WriteLine(string.Format("extra item {0}", x)));
Assert.AreEqual(expected.Count(), actual.Count(), "Selection To Remove doesn't have the right number of members");
expected.ToList().ForEach(s => Assert.IsTrue(actual.Contains(s), string.Format("selection {0} missing from actual SelectionToRemove", s)));
}
}
public void EmptyModule_HasMetricsZeroed()
{
var code = @"";
var state = MockParser.ParseString(code, out var qmn);
var metrics = cut.ModuleMetrics(state).First();
Assert.AreEqual(new CodeMetricsResult(), metrics.Result);
}
public void ShouldExcludeVariableInSignature()
{
#region inputCode
var inputCode = @"
Option explicit
Public Sub CodeWithDeclaration()
Dim x as long
Dim y as long
Dim z as long
x = 1 + 2
DebugPrint x
y = x + 1
x = 2
DebugPrint y
z = x
DebugPrint z
End Sub
Public Sub DebugPrint(byval g as long)
End Sub
";
var selectedCode = @"
y = x + 1
x = 2
Debug.Print y";
#endregion
using (var state = MockParser.ParseString(inputCode, out QualifiedModuleName qualifiedModuleName))
{
var declarations = state.AllDeclarations;
var selection = new Selection(10, 1, 12, 17);
QualifiedSelection?qSelection = new QualifiedSelection(qualifiedModuleName, selection);
var extractedMethod = new Mock <IExtractedMethod>();
extractedMethod.Setup(em => em.NewMethodCall())
.Returns("NewMethod x");
var paramClassify = new Mock <IExtractMethodParameterClassification>();
var SUT = new ExtractMethodModel(extractedMethod.Object, paramClassify.Object);
//Act
SUT.extract(declarations, qSelection.Value, selectedCode);
//Assert
var actual = SUT.Method.NewMethodCall();
var expected = "NewMethod x";
Assert.AreEqual(expected, actual);
}
}
public void EmptyModule_HasNoMemberMetricResults()
{
var code = @"";
using (var state = MockParser.ParseString(code, out var qmn))
{
var metrics = analyst.GetMetrics(state).ToList();
Assert.AreEqual(0, metrics.Count);
}
}
public void EmptyModule_HasMetricsZeroed()
{
var code = @"";
using (var state = MockParser.ParseString(code, out var _))
{
var metricResult = analyst.GetMetrics(state).First();
Assert.AreEqual("0", metricResult.Value);
}
}
public void EmtpyModule_HasNoNestingLevelMetrics()
{
var code = @"";
using (var state = MockParser.ParseString(code, out var _))
{
var metrics = analyst.GetMetrics(state).ToList();
Assert.AreEqual(0, metrics.Count);
}
}
public void EmptySub_HasCyclomaticComplexity_One()
{
var code = @"
Sub NoCode()
End Sub
";
var state = MockParser.ParseString(code, out var _);
var metrics = cut.ModuleMetrics(state).First();
Assert.AreEqual(1, metrics.Result.CyclomaticComplexity);
}
public void PropertyGet_HasCyclomaticComplexity_One()
{
var code = @"
Public Property Get Complexity() As Long
Complexity = 1
End Property
";
var state = MockParser.ParseString(code, out var _);
var metrics = cut.ModuleMetrics(state).First();
Assert.AreEqual(1, metrics.Result.CyclomaticComplexity);
}
public void EmptyFunction_HasCyclomaticComplexit_One()
{
var code = @"
Function NoCode()
End Function
";
using (var state = MockParser.ParseString(code, out var _))
{
var metric = analyst.GetMetrics(state).First();
Assert.AreEqual("1", metric.Value);
}
}
public void SingleIfStatement_HasCyclomaticComplexity_2()
{
var code = @"
Sub IfStatement()
If True Then
End If
End Sub
";
var state = MockParser.ParseString(code, out var _);
var metrics = cut.ModuleMetrics(state).First();
Assert.AreEqual(2, metrics.Result.CyclomaticComplexity);
}
public void CaseOnlyElse_HasCyclomaticComplexity_1()
{
var code = @"
Sub CaseOnlyElse(ByVal number As Long)
Select Case number
Case Else
End Select
End Sub
";
var state = MockParser.ParseString(code, out var _);
var metrics = cut.ModuleMetrics(state).First();
Assert.AreEqual(1, metrics.Result.CyclomaticComplexity);
}
public void ForeachLoop_HasCyclomaticComplexity_2()
{
var code = @"
Sub ForeachLoop(ByRef iterable As Object)
Dim stuff As Variant
For Each stuff In iterable
Next stuff
End Sub
";
var state = MockParser.ParseString(code, out var _);
var metrics = cut.ModuleMetrics(state).First();
Assert.AreEqual(2, metrics.Result.CyclomaticComplexity);
}
public void PropertyGet_HasCyclomaticComplexity_One()
{
var code = @"
Public Property Get Complexity() As Long
Complexity = 1
End Property
";
using (var state = MockParser.ParseString(code, out var _))
{
var metricResult = analyst.GetMetrics(state).First();
Assert.AreEqual("1", metricResult.Value);
}
}
public void ForToNextLoop_HasCyclomaticComplexity_2()
{
var code = @"
Sub ForToNextLoop(ByVal ubound As Long)
Dim i As Long
For i = 0 To ubound Step 1
' nothing
Next i
End Sub
";
var state = MockParser.ParseString(code, out var _);
var metrics = cut.ModuleMetrics(state).First();
Assert.AreEqual(2, metrics.Result.CyclomaticComplexity);
}
public void SingleIfStatement_HasCyclomaticComplexity_2()
{
var code = @"
Sub IfStatement()
If True Then
End If
End Sub
";
using (var state = MockParser.ParseString(code, out var _))
{
var metricResult = analyst.GetMetrics(state).First();
Assert.AreEqual("2", metricResult.Value);
}
}
public void ModuleHas_AsManyLines_AsPhysicalLines()
{
foreach (var lineCount in new int[] { 0, 10, 15, 200, 1020 })
{
var builder = new StringBuilder();
for (int i = 0; i < lineCount; i++)
{
builder.Append(Environment.NewLine);
}
var code = builder.ToString();
var state = MockParser.ParseString(code, out var _);
var metric = cut.ModuleMetrics(state).First();
Assert.AreEqual(lineCount, metric.Result.Lines);
}
}
public void ForeachLoop_HasCyclomaticComplexity_2()
{
var code = @"
Sub ForeachLoop(ByRef iterable As Object)
Dim stuff As Variant
For Each stuff In iterable
Next stuff
End Sub
";
using (var state = MockParser.ParseString(code, out var _))
{
var metricResult = analyst.GetMetrics(state).First();
Assert.AreEqual("2", metricResult.Value);
}
}
public void SimpleSub_HasNestingLevel_One()
{
var code = @"
Option Explicit
Public Sub SimpleSub()
'preceding comment just to check
Debug.Print ""this is a test""
End Sub
";
var state = MockParser.ParseString(code, out var _);
var metrics = cut.ModuleMetrics(state).First();
Assert.AreEqual(1, metrics.Result.MaximumNesting);
}
public void PropertySet_HasCyclomaticComplexity_One()
{
var code = @"
Option Explicit
Private mComplexity As Object
Public Property Set Complexity(ByRef complexity As Object)
mComplexity = complexity
End Property
";
var state = MockParser.ParseString(code, out var _);
var metrics = cut.ModuleMetrics(state).First();
Assert.AreEqual(1, metrics.Result.CyclomaticComplexity);
}
public void CaseOnlyElse_HasCyclomaticComplexity_1()
{
var code = @"
Sub CaseOnlyElse(ByVal number As Long)
Select Case number
Case Else
End Select
End Sub
";
using (var state = MockParser.ParseString(code, out var _))
{
var metricResult = analyst.GetMetrics(state).First();
Assert.AreEqual("1", metricResult.Value);
}
}
public void EmptySub_HasCyclomaticComplexity_One()
{
var code = @"
Sub NoCode()
End Sub
";
using (var state = MockParser.ParseString(code, out var _))
{
var metrics = analyst.GetMetrics(state).ToList();
Assert.AreEqual(1, metrics.Count);
Assert.AreEqual("1", metrics[0].Value);
Assert.AreEqual(state.DeclarationFinder.UserDeclarations(Rubberduck.Parsing.Symbols.DeclarationType.Procedure).First()
, metrics[0].Declaration);
}
}
public void ShouldThrowAnException()
{
using (var state = MockParser.ParseString(inputCode, out QualifiedModuleName qualifiedModuleName))
{
var declarations = state.AllDeclarations;
var selection = new Selection(21, 1, 22, 17);
QualifiedSelection?qSelection = new QualifiedSelection(qualifiedModuleName, selection);
var extractedMethod = new Mock <IExtractedMethod>();
var paramClassify = new Mock <IExtractMethodParameterClassification>();
var SUT = new ExtractMethodModel(extractedMethod.Object, paramClassify.Object);
//Act - Assert
Assert.Catch <InvalidOperationException>(() => SUT.extract(declarations, qSelection.Value, selectedCode));
}
}
public void ForToNextLoop_HasCyclomaticComplexity_2()
{
var code = @"
Sub ForToNextLoop(ByVal ubound As Long)
Dim i As Long
For i = 0 To ubound Step 1
' nothing
Next i
End Sub
";
using (var state = MockParser.ParseString(code, out var _))
{
var metricResult = analyst.GetMetrics(state).First();
Assert.AreEqual("2", metricResult.Value);
}
}
