diff --git a/Rubberduck.Inspections/Concrete/EmptyConditionBlockInspection.cs b/Rubberduck.Inspections/Concrete/EmptyConditionBlockInspection.cs new file mode 100644 index 0000000000..1cd5b41dbd --- /dev/null +++ b/Rubberduck.Inspections/Concrete/EmptyConditionBlockInspection.cs @@ -0,0 +1,94 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using Rubberduck.Inspections.Abstract; +using Rubberduck.Parsing.Inspections.Abstract; +using Rubberduck.Parsing.Inspections.Resources; +using Antlr4.Runtime; +using Antlr4.Runtime.Misc; +using Rubberduck.Parsing.Grammar; +using Rubberduck.Parsing; +using Rubberduck.Parsing.VBA; +using Rubberduck.Inspections.Results; + +namespace Rubberduck.Inspections.Concrete +{ + [Flags] + public enum ConditionBlockToInspect + { + NA = 0x0, + If = 0x1, + ElseIf = 0x2, + Else = 0x4, + All = If | ElseIf | Else + } + + internal class EmptyConditionBlockInspection : ParseTreeInspectionBase + { + public EmptyConditionBlockInspection(RubberduckParserState state, + ConditionBlockToInspect BlockToInspect) + : base(state, CodeInspectionSeverity.Suggestion) + { + _blockToInspect = BlockToInspect; + _listener = new EmptyConditionBlockListener(BlockToInspect); + } + + public static ConditionBlockToInspect _blockToInspect { get; private set; } + + public override Type Type => typeof(EmptyConditionBlockInspection); + + public override IEnumerable GetInspectionResults() + { + return Listener.Contexts + .Where(result => !IsIgnoringInspectionResultFor(result.ModuleName, result.Context.Start.Line)) + .Select(result => new QualifiedContextInspectionResult(this, + InspectionsUI.EmptyConditionBlockInspectionsResultFormat, + result)); + } + + private IInspectionListener _listener; + public override IInspectionListener Listener { get { return _listener; } } + + public class EmptyConditionBlockListener : EmptyBlockInspectionListenerBase + { + ConditionBlockToInspect _blockToInspect; + + public EmptyConditionBlockListener(ConditionBlockToInspect blockToInspect) + { + _blockToInspect = blockToInspect; + } + + public override void EnterIfStmt([NotNull] VBAParser.IfStmtContext context) + { + if (_blockToInspect.HasFlag(ConditionBlockToInspect.If)) + { + InspectBlockForExecutableStatements(context.block(), context); + } + } + + public override void EnterElseIfBlock([NotNull] VBAParser.ElseIfBlockContext context) + { + if (_blockToInspect.HasFlag(ConditionBlockToInspect.ElseIf)) + { + InspectBlockForExecutableStatements(context.block(), context); + } + } + + public override void EnterSingleLineIfStmt([NotNull] VBAParser.SingleLineIfStmtContext context) + { + if (context.ifWithEmptyThen() != null & _blockToInspect.HasFlag(ConditionBlockToInspect.If)) + { + AddResult(new QualifiedContext(CurrentModuleName, context.ifWithEmptyThen())); + } + } + + public override void EnterElseBlock([NotNull] VBAParser.ElseBlockContext context) + { + if (_blockToInspect.HasFlag(ConditionBlockToInspect.Else)) + { + InspectBlockForExecutableStatements(context.block(), context); + } + } + } + } +} \ No newline at end of file diff --git a/Rubberduck.Inspections/Concrete/EmptyElseBlockInspection.cs b/Rubberduck.Inspections/Concrete/EmptyElseBlockInspection.cs deleted file mode 100644 index 036c3f48ac..0000000000 --- a/Rubberduck.Inspections/Concrete/EmptyElseBlockInspection.cs +++ /dev/null @@ -1,43 +0,0 @@ -using Antlr4.Runtime.Misc; -using Rubberduck.Inspections.Abstract; -using Rubberduck.Inspections.Results; -using Rubberduck.Parsing.Grammar; -using Rubberduck.Parsing.Inspections.Abstract; -using Rubberduck.Parsing.Inspections.Resources; -using Rubberduck.Parsing.VBA; -using System; -using System.Collections.Generic; -using System.Linq; - -namespace Rubberduck.Inspections.Concrete -{ - internal class EmptyElseBlockInspection : ParseTreeInspectionBase - { - public EmptyElseBlockInspection(RubberduckParserState state) - : base(state, CodeInspectionSeverity.Suggestion) { } - - public override Type Type => typeof(EmptyElseBlockInspection); - - public override CodeInspectionType InspectionType => CodeInspectionType.CodeQualityIssues; - - public override IEnumerable GetInspectionResults() - { - return Listener.Contexts - .Where(result => !IsIgnoringInspectionResultFor(result.ModuleName, result.Context.Start.Line)) - .Select(result => new QualifiedContextInspectionResult(this, - InspectionsUI.EmptyElseBlockInspectionResultFormat, - result)); - } - - public override IInspectionListener Listener { get; } - = new EmptyElseBlockListener(); - - public class EmptyElseBlockListener : EmptyBlockInspectionListenerBase - { - public override void EnterElseBlock([NotNull] VBAParser.ElseBlockContext context) - { - InspectBlockForExecutableStatements(context.block(), context); - } - } - } -} \ No newline at end of file diff --git a/Rubberduck.Inspections/Concrete/EmptyIfBlockInspection.cs b/Rubberduck.Inspections/Concrete/EmptyIfBlockInspection.cs deleted file mode 100644 index 09e8d0284a..0000000000 --- a/Rubberduck.Inspections/Concrete/EmptyIfBlockInspection.cs +++ /dev/null @@ -1,58 +0,0 @@ -using Antlr4.Runtime; -using Antlr4.Runtime.Misc; -using Rubberduck.Inspections.Abstract; -using Rubberduck.Inspections.Results; -using Rubberduck.Parsing; -using Rubberduck.Parsing.Grammar; -using Rubberduck.Parsing.Inspections.Abstract; -using Rubberduck.Parsing.Inspections.Resources; -using Rubberduck.Parsing.VBA; -using System; -using System.Collections.Generic; -using System.Linq; - -namespace Rubberduck.Inspections.Concrete -{ - internal class EmptyIfBlockInspection : ParseTreeInspectionBase - { - public EmptyIfBlockInspection(RubberduckParserState state) - : base(state, CodeInspectionSeverity.Suggestion) { } - - public override Type Type => typeof(EmptyIfBlockInspection); - - public override CodeInspectionType InspectionType => CodeInspectionType.CodeQualityIssues; - - public override IEnumerable GetInspectionResults() - { - return Listener.Contexts - .Where(result => !IsIgnoringInspectionResultFor(result.ModuleName, result.Context.Start.Line)) - .Select(result => new QualifiedContextInspectionResult(this, - InspectionsUI.EmptyIfBlockInspectionResultFormat, - result)); - } - - public override IInspectionListener Listener { get; } = - new EmptyIfBlockListener(); - - public class EmptyIfBlockListener : EmptyBlockInspectionListenerBase - { - public override void EnterIfStmt([NotNull] VBAParser.IfStmtContext context) - { - InspectBlockForExecutableStatements(context.block(), context); - } - - public override void EnterElseIfBlock([NotNull] VBAParser.ElseIfBlockContext context) - { - InspectBlockForExecutableStatements(context.block(), context); - } - - public override void EnterSingleLineIfStmt([NotNull] VBAParser.SingleLineIfStmtContext context) - { - if (context.ifWithEmptyThen() != null) - { - AddResult(new QualifiedContext(CurrentModuleName, context.ifWithEmptyThen())); - } - } - } - } -} diff --git a/Rubberduck.Inspections/QuickFixes/RemoveEmptyIfBlockQuickFix.cs b/Rubberduck.Inspections/QuickFixes/RemoveEmptyConditionBlockQuickFix.cs similarity index 91% rename from Rubberduck.Inspections/QuickFixes/RemoveEmptyIfBlockQuickFix.cs rename to Rubberduck.Inspections/QuickFixes/RemoveEmptyConditionBlockQuickFix.cs index f96a9118b8..10f21d1936 100644 --- a/Rubberduck.Inspections/QuickFixes/RemoveEmptyIfBlockQuickFix.cs +++ b/Rubberduck.Inspections/QuickFixes/RemoveEmptyConditionBlockQuickFix.cs @@ -1,23 +1,23 @@ using System; using System.Collections.Generic; -using System.Diagnostics; using System.Linq; -using Antlr4.Runtime; using Rubberduck.Inspections.Concrete; -using Rubberduck.Parsing.Grammar; +using Rubberduck.Parsing.VBA; using Rubberduck.Parsing.Inspections.Abstract; -using Rubberduck.Parsing.Inspections.Resources; +using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.VBA; +using Antlr4.Runtime; +using Rubberduck.Parsing.Inspections.Resources; +using System.Diagnostics; namespace Rubberduck.Inspections.QuickFixes { - internal sealed class RemoveEmptyIfBlockQuickFix : IQuickFix + internal sealed class RemoveEmptyConditionBlockQuickFix : IQuickFix { - private static readonly HashSet _supportedInspections = new HashSet { typeof(EmptyIfBlockInspection) }; + private static readonly HashSet _supportedInspections = new HashSet { typeof(EmptyConditionBlockInspection) }; private readonly RubberduckParserState _state; - public RemoveEmptyIfBlockQuickFix(RubberduckParserState state) + public RemoveEmptyConditionBlockQuickFix(RubberduckParserState state) { _state = state; } @@ -92,6 +92,16 @@ private void UpdateContext(VBAParser.ElseIfBlockContext context, IModuleRewriter rewriter.Remove(context); } + private void UpdateContext(VBAParser.ElseBlockContext context, IModuleRewriter rewriter) + { + var elseBlock = context.block(); + + if (elseBlock.ChildCount == 0) + { + rewriter.Remove(context); + } + } + private void UpdateCondition(VBAParser.RelationalOpContext condition, IModuleRewriter rewriter) { if (condition.EQ() != null) @@ -178,7 +188,7 @@ private bool FirstBlockStmntHasLabel(VBAParser.BlockContext block) public string Description(IInspectionResult result) { - return InspectionsUI.RemoveEmptyIfBlockQuickFix; + return InspectionsUI.RemoveEmptyConditionBlockQuickFix; } public bool CanFixInProcedure { get; } = false; diff --git a/Rubberduck.Inspections/QuickFixes/RemoveEmptyElseBlockQuickFix.cs b/Rubberduck.Inspections/QuickFixes/RemoveEmptyElseBlockQuickFix.cs deleted file mode 100644 index e799a78188..0000000000 --- a/Rubberduck.Inspections/QuickFixes/RemoveEmptyElseBlockQuickFix.cs +++ /dev/null @@ -1,71 +0,0 @@ -using Antlr4.Runtime.Tree; -using Antlr4.Runtime; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; -using Rubberduck.Inspections.Concrete; -using Rubberduck.Parsing.Inspections.Abstract; -using Rubberduck.Parsing.Inspections.Resources; -using Rubberduck.Parsing.Grammar; -using Rubberduck.Parsing.Rewriter; -using Rubberduck.Parsing.VBA; - - -namespace Rubberduck.Inspections.QuickFixes -{ - class RemoveEmptyElseBlockQuickFix : IQuickFix - { - private static readonly HashSet _supportedInspections = new HashSet { typeof(EmptyElseBlockInspection) }; - private readonly RubberduckParserState _state; - - public IReadOnlyCollection SupportedInspections => _supportedInspections.ToList(); - - public RemoveEmptyElseBlockQuickFix(RubberduckParserState state) - { - _state = state; - } - - public void Fix(IInspectionResult result) - { - IModuleRewriter rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName); - - //dynamic used since it's not known at run-time - UpdateContext((dynamic)result.Context, rewriter); - } - - private void UpdateContext(VBAParser.ElseBlockContext context, IModuleRewriter rewriter) - { - VBAParser.BlockContext elseBlock = context.block(); - - if (elseBlock.ChildCount == 0 ) - { - //string rewrittenBlock = AdjustedBlockText(context.block()); - //rewriter.InsertBefore(context.start.StartIndex, rewrittenBlock); - rewriter.Remove(context); - } - /* - * There isn't any need to invert the condition since its - * only the else block thats empty. IE: it doesn't affect - * the TRUE portion that preceeds it. - */ - } - - //private bool FirstBlockStmntHasLabel(VBAParser.BlockContext block) - // => block.blockStmt()?.FirstOrDefault()?.statementLabelDefinition() != null; - - //private bool BlockHasDeclaration(VBAParser.BlockContext block) - // => block.blockStmt()?.Any() ?? false; - - - public string Description(IInspectionResult result) - { - return InspectionsUI.RemoveEmptyElseBlockQuickFix; - } - - public bool CanFixInProcedure { get; } = false; - public bool CanFixInModule { get; } = false; - public bool CanFixInProject { get; } = false; - } -} diff --git a/Rubberduck.Inspections/Rubberduck.Inspections.csproj b/Rubberduck.Inspections/Rubberduck.Inspections.csproj index e294601812..a766db0bc1 100644 --- a/Rubberduck.Inspections/Rubberduck.Inspections.csproj +++ b/Rubberduck.Inspections/Rubberduck.Inspections.csproj @@ -62,6 +62,7 @@ + @@ -73,7 +74,6 @@ - @@ -90,7 +90,6 @@ - @@ -118,6 +117,7 @@ + @@ -132,8 +132,6 @@ - - diff --git a/Rubberduck.Parsing/Inspections/Resources/InspectionsUI.resx b/Rubberduck.Parsing/Inspections/Resources/InspectionsUI.resx index 0c48011688..fa3a266c6d 100644 --- a/Rubberduck.Parsing/Inspections/Resources/InspectionsUI.resx +++ b/Rubberduck.Parsing/Inspections/Resources/InspectionsUI.resx @@ -692,18 +692,6 @@ If the parameter can be null, ignore this inspection result; passing a null valu Synchronize attributes/annotations in module - - An If block should have executable statements - - - Empty If block - - - If block has no executable statements - - - Remove empty If block - Being the default/implicit setting for this option, this instruction can be safely omitted. @@ -766,18 +754,6 @@ If the parameter can be null, ignore this inspection result; passing a null valu Warning - - Else block has no executable statements - - - An Else block should have executable statements - - - Empty Else block - - - Remove empty Else block - The maximum value of a 16-bit signed integer is 32,767 - using a 32-bit (Long) integer data type where possible can help prevent 'Overflow' run-time errors, and is better handled by modern CPUs. @@ -846,7 +822,22 @@ If the parameter can be null, ignore this inspection result; passing a null valu A Loop block should have executable statements - Empty While-Wend block + Empty While ... Wend block + + + A conditional block should contain executable statements in a clean code base. Empty blocks can be confusing about the intent of the author. + + + Empty conditional block + + + Remove empty block + + + + + + Remove empty conditional block Two declarations are in scope and have the same identifier name. This means that only one of them will be available to use. diff --git a/Rubberduck.Parsing/Inspections/Resources/InspectionsUI1.Designer.cs b/Rubberduck.Parsing/Inspections/Resources/InspectionsUI1.Designer.cs index 91f9f5c4a3..49b3054a39 100644 --- a/Rubberduck.Parsing/Inspections/Resources/InspectionsUI1.Designer.cs +++ b/Rubberduck.Parsing/Inspections/Resources/InspectionsUI1.Designer.cs @@ -340,56 +340,65 @@ public static string EmptyCaseBlockInspectionResultFormat { } /// - /// Looks up a localized string similar to A Loop block should have executable statements. + /// Looks up a localized string similar to A conditional block should contain executable statements in a clean code base. Empty blocks can be confusing about the intent of the author.. /// - public static string EmptyDoWhileBlockInspectionMeta { + public static string EmptyConditionBlockInspectionsMeta { get { - return ResourceManager.GetString("EmptyDoWhileBlockInspectionMeta", resourceCulture); + return ResourceManager.GetString("EmptyConditionBlockInspectionsMeta", resourceCulture); } } /// - /// Looks up a localized string similar to Empty Do-While Loop. + /// Looks up a localized string similar to Empty conditional block. /// - public static string EmptyDoWhileBlockInspectionName { + public static string EmptyConditionBlockInspectionsName { get { - return ResourceManager.GetString("EmptyDoWhileBlockInspectionName", resourceCulture); + return ResourceManager.GetString("EmptyConditionBlockInspectionsName", resourceCulture); } } /// - /// Looks up a localized string similar to Do-While Loop has no executable statements. + /// Looks up a localized string similar to Remove empty block. /// - public static string EmptyDoWhileBlockInspectionResultFormat { + public static string EmptyConditionBlockInspectionsQuickFix { get { - return ResourceManager.GetString("EmptyDoWhileBlockInspectionResultFormat", resourceCulture); + return ResourceManager.GetString("EmptyConditionBlockInspectionsQuickFix", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to . + /// + public static string EmptyConditionBlockInspectionsResultFormat { + get { + return ResourceManager.GetString("EmptyConditionBlockInspectionsResultFormat", resourceCulture); } } /// - /// Looks up a localized string similar to An Else block should have executable statements. + /// Looks up a localized string similar to A Loop block should have executable statements. /// - public static string EmptyElseBlockInspectionMeta { + public static string EmptyDoWhileBlockInspectionMeta { get { - return ResourceManager.GetString("EmptyElseBlockInspectionMeta", resourceCulture); + return ResourceManager.GetString("EmptyDoWhileBlockInspectionMeta", resourceCulture); } } /// - /// Looks up a localized string similar to Empty Else block. + /// Looks up a localized string similar to Empty Do-While Loop. /// - public static string EmptyElseBlockInspectionName { + public static string EmptyDoWhileBlockInspectionName { get { - return ResourceManager.GetString("EmptyElseBlockInspectionName", resourceCulture); + return ResourceManager.GetString("EmptyDoWhileBlockInspectionName", resourceCulture); } } /// - /// Looks up a localized string similar to Else block has no executable statements. + /// Looks up a localized string similar to Do-While Loop has no executable statements. /// - public static string EmptyElseBlockInspectionResultFormat { + public static string EmptyDoWhileBlockInspectionResultFormat { get { - return ResourceManager.GetString("EmptyElseBlockInspectionResultFormat", resourceCulture); + return ResourceManager.GetString("EmptyDoWhileBlockInspectionResultFormat", resourceCulture); } } @@ -447,33 +456,6 @@ public static string EmptyForLoopBlockInspectionResultFormat { } } - /// - /// Looks up a localized string similar to An If block should have executable statements. - /// - public static string EmptyIfBlockInspectionMeta { - get { - return ResourceManager.GetString("EmptyIfBlockInspectionMeta", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Empty If block. - /// - public static string EmptyIfBlockInspectionName { - get { - return ResourceManager.GetString("EmptyIfBlockInspectionName", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to If block has no executable statements. - /// - public static string EmptyIfBlockInspectionResultFormat { - get { - return ResourceManager.GetString("EmptyIfBlockInspectionResultFormat", resourceCulture); - } - } - /// /// Looks up a localized string similar to Prefer 'vbNullString' to an empty string literal. /// @@ -529,7 +511,7 @@ public static string EmptyWhileWendBlockInspectionMeta { } /// - /// Looks up a localized string similar to Empty While-Wend block. + /// Looks up a localized string similar to Empty While ... Wend block. /// public static string EmptyWhileWendBlockInspectionName { get { @@ -1798,20 +1780,11 @@ public static string RemoveCommentQuickFix { } /// - /// Looks up a localized string similar to Remove empty Else block. - /// - public static string RemoveEmptyElseBlockQuickFix { - get { - return ResourceManager.GetString("RemoveEmptyElseBlockQuickFix", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Remove empty If block. + /// Looks up a localized string similar to Remove empty conditional block. /// - public static string RemoveEmptyIfBlockQuickFix { + public static string RemoveEmptyConditionBlockQuickFix { get { - return ResourceManager.GetString("RemoveEmptyIfBlockQuickFix", resourceCulture); + return ResourceManager.GetString("RemoveEmptyConditionBlockQuickFix", resourceCulture); } } diff --git a/Rubberduck.sln b/Rubberduck.sln index a22cbcc4fd..b1ccc81985 100644 --- a/Rubberduck.sln +++ b/Rubberduck.sln @@ -153,4 +153,7 @@ Global GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {9EFDE29C-B445-4B80-AF3D-3B085A8F12ED} + EndGlobalSection EndGlobal diff --git a/RubberduckTests/Inspections/EmptyConditionBlockInspectionTests.cs b/RubberduckTests/Inspections/EmptyConditionBlockInspectionTests.cs new file mode 100644 index 0000000000..a6b7c743f6 --- /dev/null +++ b/RubberduckTests/Inspections/EmptyConditionBlockInspectionTests.cs @@ -0,0 +1,693 @@ +using System.Linq; +using System.Threading; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using Rubberduck.VBEditor.SafeComWrappers.Abstract; +using RubberduckTests.Mocks; +using Rubberduck.Inspections.Concrete; +using Rubberduck.Parsing.Inspections.Resources; +using Rubberduck.Inspections.QuickFixes; + +namespace RubberduckTests.Inspections +{ + [TestClass] + public class EmptyConditionBlockInspectionTests + { + [TestMethod] + [TestCategory("Inspections")] + public void InspectionType() + { + var inspection = new EmptyConditionBlockInspection(null, ConditionBlockToInspect.NA); + Assert.AreEqual(CodeInspectionType.CodeQualityIssues, inspection.InspectionType); + } + + [TestMethod] + [TestCategory("Inspections")] + public void InspectionName() + { + const string inspectionName = nameof(EmptyConditionBlockInspection); + + var inspection = new EmptyConditionBlockInspection(null, ConditionBlockToInspect.NA); + + Assert.AreEqual(inspectionName, inspection.Name); + } + + [TestMethod] + [TestCategory("Inspections")] + public void EmptyIfBlock_FiresOnEmptyIfBlock() + { + const string inputCode = +@"Sub Foo() + If True Then + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _ ); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + Assert.AreEqual(1, inspectionResults.Count()); + } + + [TestMethod] + [TestCategory("Inspections")] + public void EmptyIfBlock_FiresOnEmptyElseIfBlock() + { + const string inputCode = +@"Sub Foo() + If True Then + ElseIf False Then + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _ ); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.ElseIf); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + Assert.AreEqual(1, inspectionResults.Count()); + } + + [TestMethod] + [TestCategory("Inspections")] + public void EmptyIfBlock_FiresOnEmptyIfBlock_ElseBlock() + { + const string inputCode = +@"Sub Foo() + If True Then + Dim a as Long + a = 0 + Else + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _ ); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + Assert.AreEqual(1, inspectionResults.Count()); + } + + [TestMethod] + [TestCategory("Inspections")] + public void EmptyIfBlock_FiresOnEmptySingleLineIfStmt() + { + const string inputCode = +@"Sub Foo() + If True Then Else Bar +End Sub + +Sub Bar() +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _ ); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + Assert.AreEqual(1, inspectionResults.Count()); + } + + [TestMethod] + [TestCategory("Inspections")] + public void EmptyIfBlock_FiresOnEmptyIfBlock_HasNonEmptyElseBlock() + { + const string inputCode = +@"Sub Foo() + If True Then + Else + Dim d + d = 0 + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _ ); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + Assert.AreEqual(1, inspectionResults.Count()); + } + + [TestMethod] + [TestCategory("Inspections")] + public void EmptyIfBlock_FiresOnEmptyIfBlock_HasQuoteComment() + { + const string inputCode = +@"Sub Foo() + If True Then + ' Im a comment + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _ ); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + Assert.AreEqual(1, inspectionResults.Count()); + } + + [TestMethod] + [TestCategory("Inspections")] + public void EmptyIfBlock_FiresOnEmptyIfBlock_HasRemComment() + { + const string inputCode = +@"Sub Foo() + If True Then + Rem Im a comment + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _ ); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state,ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + Assert.AreEqual(1, inspectionResults.Count()); + } + + [TestMethod] + [TestCategory("Inspections")] + public void EmptyIfBlock_FiresOnEmptyIfBlock_HasVariableDeclaration() + { + const string inputCode = +@"Sub Foo() + If True Then + Dim d + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _ ); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + Assert.AreEqual(1, inspectionResults.Count()); + } + + [TestMethod] + [TestCategory("Inspections")] + public void EmptyIfBlock_FiresOnEmptyIfBlock_HasConstDeclaration() + { + const string inputCode = +@"Sub Foo() + If True Then + Const c = 0 + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _ ); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + Assert.AreEqual(1, inspectionResults.Count()); + } + + [TestMethod] + [TestCategory("Inspections")] + public void EmptyIfBlock_FiresOnEmptyIfBlock_HasWhitespace() + { + const string inputCode = +@"Sub Foo() + If True Then + + + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _ ); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + Assert.AreEqual(1, inspectionResults.Count()); + } + + [TestMethod] + [TestCategory("Inspections")] + public void EmptyIfBlock_IfBlockHasExecutableStatement() + { + const string inputCode = +@"Sub Foo() + If True Then + Dim d + d = 0 + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _ ); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + Assert.IsFalse(inspectionResults.Any()); + } + + [TestMethod] + [TestCategory("Inspections")] + public void EmptyIfBlock_SingleLineIfBlockHasExecutableStatement() + { + const string inputCode = +@"Sub Foo() + If True Then Bar +End Sub + +Sub Bar() +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _ ); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state,ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + Assert.IsFalse(inspectionResults.Any()); + } + + [TestMethod] + [TestCategory("Inspections")] + public void EmptyIfBlock_IfAndElseIfBlockHaveExecutableStatement() + { + const string inputCode = +@"Sub Foo() + If True Then + Dim d + d = 0 + ElseIf False Then + Dim b + b = 0 + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _ ); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + Assert.IsFalse(inspectionResults.Any()); + } + + [TestMethod] + [TestCategory("Inspections")] + public void EmptyElseBlock_FiresOnEmptyIfBlock() + { + const string inputcode = +@"Sub Foo() + If True Then + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputcode, out _ ); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var actualResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + const int expectedCount = 1; + + Assert.AreEqual(expectedCount, actualResults.Count()); + } + + [TestMethod] + [TestCategory("Inspections")] + public void EmptyElseBlock_HasNoContent() + { + const string inputcode = +@"Sub Foo() + If True Then + Dim a as Long + a = 0 + Else + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputcode, out _ ); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var actualResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + const int expectedCount = 1; + + Assert.AreEqual(expectedCount, actualResults.Count()); + } + + [TestMethod] + [TestCategory("Inspections")] + public void EmptyElseBlock_HasQuoteComment() + { + const string inputCode = +@"Sub Foo() + If True Then + Dim a as Long + a = 0 + Else + 'Some Comment + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _ ); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var actualResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + const int expectedCount = 1; + + Assert.AreEqual(expectedCount, actualResults.Count()); + } + + [TestMethod] + [TestCategory("Inspections")] + public void EmptyElseBlock_HasRemComment() + { + const string inputCode = +@"Sub Foo() + If True Then + Dim a as Long + a = 0 + Else + Rem Some Comment + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _ ); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var actualResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + const int expectedCount = 1; + + Assert.AreEqual(expectedCount, actualResults.Count()); + } + + [TestMethod] + [TestCategory("Inspections")] + public void EmptyElseBlock_HasVariableDeclaration() + { + const string inputCode = +@"Sub Foo() + If True Then + Dim a as Long + a = 0 + Else + Dim d + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _ ); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var actualResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + const int expectedCount = 1; + + Assert.AreEqual(expectedCount, actualResults.Count()); + } + + [TestMethod] + [TestCategory("Inspections")] + public void EmptyElseBlock_HasConstDeclaration() + { + const string inputCode = +@"Sub Foo() + If True Then + Dim a as Long + a = 0 + Else + Const c = 0 + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _ ); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state,ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var actualResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + const int expectedCount = 1; + + Assert.AreEqual(expectedCount, actualResults.Count()); + } + + [TestMethod] + [TestCategory("Inspections")] + public void EmptyElseBlock_HasWhitespace() + { + const string inputcode = +@"Sub Foo() + If True Then + Dim a as Long + a = 0 + Else + + + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputcode, out _ ); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state,ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var actualResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + const int expectedCount = 1; + + Assert.AreEqual(expectedCount, actualResults.Count()); + } + + [TestMethod] + [TestCategory("Inspections")] + public void EmptyElseBlock_HasDeclarationStatement() + { + const string inputCode = +@"Sub Foo() + If True Then + Dim a as Long + a = 0 + Else + Dim d + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _ ); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var actualResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + const int expectedCount = 1; + + Assert.AreEqual(expectedCount, actualResults.Count()); + } + + [TestMethod] + [TestCategory("Inspections")] + public void EmptyElseBlock_HasExecutableStatement() + { + const string inputCode = +@"Sub Foo() + If True Then + Else + Dim d + d = 0 + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _ ); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state,ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var actualResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + const int expectedCount = 1; + + Assert.AreEqual(expectedCount, actualResults.Count()); + } + + [TestMethod] + [TestCategory("Inspections")] + public void EmptyElseBlock_QuickFixRemovesElse() + { + const string inputCode = +@"Sub Foo() + If True Then + Else + End If +End Sub"; + + const string expectedCode = +@"Sub Foo() + If True Then + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state,ConditionBlockToInspect.Else); + var inspector = InspectionsHelper.GetInspector(inspection); + var actualResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + new RemoveEmptyConditionBlockQuickFix(state).Fix(actualResults.First()); + var actualCode = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedCode, actualCode); + } + + [TestMethod] + [TestCategory("Inspections")] + public void EmptyElseBlock_QuickFixRemoveInLineIfThenElse() + { + const string inputCode = +@"Sub Foo() + If True Then Else +End Sub"; + + const string expectedCode = +@"Sub Foo() + If Not True Then +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state,ConditionBlockToInspect.If); + var inspector = InspectionsHelper.GetInspector(inspection); + var actualResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + var inspectionToFix = actualResults.First(); + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionToFix); + + var actualCode = state.GetRewriter(component).GetText(); + Assert.AreEqual(expectedCode, actualCode); + } + + [TestMethod] + [TestCategory("Inspections")] + public void NonEmptyIfBlock_FindsNoResults() + { + const string inputcode = +@"Sub Foo() + If True Then + Dim a as String + a = ""a"" + End If +End Sub"; + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputcode, out _); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var actualResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + Assert.IsFalse(actualResults.Any()); + } + + [TestMethod] + [TestCategory("Inspections")] + public void NonEmptyIAndElseifBlock_FindsNoResults() + { + const string inputcode = +@"Sub Foo() + If True Then + Dim a as String + a = ""a"" + ElseIf True Then + Dim b as String + b = ""b"" + End If +End Sub"; + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputcode, out _); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var actualResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + Assert.IsFalse(actualResults.Any()); + } + + [TestMethod] + [TestCategory("Inspections")] + public void NonEmptyIfAndElseBlock_FindsNoResults() + { + const string inputcode = +@"Sub Foo() + If True Then + Dim a as String + a = ""a"" + Else + Dim b as String + b = ""b"" + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputcode, out _ ); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var actualResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + Assert.IsFalse(actualResults.Any()); + } + + [TestMethod] + [TestCategory("Inspections")] + public void NonEmptyIfElseifElseBlock_FindsNoResults() + { + const string inputCode = +@"Sub Foo() + If True Then + Dim a as String + a = ""a"" + ElseIf True Then + Dim b as String + b = ""b"" + Else + Dim c as String + c = ""c"" + End If +End Sub"; + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var actualResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + Assert.IsFalse(actualResults.Any()); + } + } +} diff --git a/RubberduckTests/Inspections/EmptyElseBlockInspectionTests.cs b/RubberduckTests/Inspections/EmptyElseBlockInspectionTests.cs deleted file mode 100644 index 1cebaf18cb..0000000000 --- a/RubberduckTests/Inspections/EmptyElseBlockInspectionTests.cs +++ /dev/null @@ -1,247 +0,0 @@ -using System.Linq; -using System.Threading; -using Microsoft.VisualStudio.TestTools.UnitTesting; -using Rubberduck.VBEditor.SafeComWrappers.Abstract; -using RubberduckTests.Mocks; -using Rubberduck.Inspections.Concrete; -using Rubberduck.Parsing.Inspections.Resources; - -namespace RubberduckTests.Inspections -{ - [TestClass] - public class EmptyElseBlockInspectionTests - { - [TestMethod] - [TestCategory("Inspections")] - public void InspectionType() - { - var inspection = new EmptyElseBlockInspection(null); - var expectedInspection = CodeInspectionType.CodeQualityIssues; - - Assert.AreEqual(expectedInspection, inspection.InspectionType); - } - - [TestMethod] - [TestCategory("Inspections")] - public void InspectionName() - { - const string expectedName = nameof(EmptyElseBlockInspection); - var inspection = new EmptyElseBlockInspection(null); - - Assert.AreEqual(expectedName, inspection.Name); - } - - [TestMethod] - [TestCategory("Inspections")] - public void EmptyElseBlock_DoesntFireOnEmptyIfBlock() - { - const string inputcode = -@"Sub Foo() - If True Then - EndIf -End Sub"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputcode, out component); - var state = MockParser.CreateAndParse(vbe.Object); - - var inspection = new EmptyElseBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var actualResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - const int expectedCount = 0; - - Assert.AreEqual(expectedCount, actualResults.Count()); - } - - [TestMethod] - [TestCategory("Inspections")] - public void EmptyElseBlock_HasNoContent() - { - const string inputcode = -@"Sub Foo() - If True Then - Else - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputcode, out component); - var state = MockParser.CreateAndParse(vbe.Object); - - var inspection = new EmptyElseBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var actualResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - const int expectedCount = 1; - - Assert.AreEqual(expectedCount, actualResults.Count()); - } - - [TestMethod] - [TestCategory("Inspections")] - public void EmptyElseBlock_HasQuoteComment() - { - const string inputCode = -@"Sub Foo() - If True Then - Else - 'Some Comment - End If -End Sub"; - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var state = MockParser.CreateAndParse(vbe.Object); - - var inspection = new EmptyElseBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var actualResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - const int expectedCount = 1; - - Assert.AreEqual(expectedCount, actualResults.Count()); - } - - [TestMethod] - [TestCategory("Inspections")] - public void EmptyElseBlock_HasRemComment() - { - const string inputCode = -@"Sub Foo() - If True Then - Else - Rem Some Comment - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var state = MockParser.CreateAndParse(vbe.Object); - - var inspection = new EmptyElseBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var actualResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - const int expectedCount = 1; - - Assert.AreEqual(expectedCount, actualResults.Count()); - } - - [TestMethod] - [TestCategory("Inspections")] - public void EmptyElseBlock_HasVariableDeclaration() - { - const string inputCode = -@"Sub Foo() - If True Then - Else - Dim d - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var state = MockParser.CreateAndParse(vbe.Object); - - var inspection = new EmptyElseBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var actualResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - const int expectedCount = 1; - - Assert.AreEqual(expectedCount, actualResults.Count()); - } - - [TestMethod] - [TestCategory("Inspections")] - public void EmptyElseBlock_HasConstDeclaration() - { - const string inputCode = -@"Sub Foo() - If True Then - Else - Const c = 0 - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var state = MockParser.CreateAndParse(vbe.Object); - - var inspection = new EmptyElseBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var actualResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - const int expectedCount = 1; - - Assert.AreEqual(expectedCount, actualResults.Count()); - } - - [TestMethod] - [TestCategory("Inspections")] - public void EmptyElseBlock_HasWhitespace() - { - const string inputcode = -@"Sub Foo() - If True Then - Else - - - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputcode, out component); - var state = MockParser.CreateAndParse(vbe.Object); - - var inspection = new EmptyElseBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var actualResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - const int expectedCount = 1; - - Assert.AreEqual(expectedCount, actualResults.Count()); - } - - [TestMethod] - [TestCategory("Inspections")] - public void EmptyElseBlock_HasDeclarationStatement() - { - const string inputCode = -@"Sub Foo() - If True Then - Else - Dim d - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var state = MockParser.CreateAndParse(vbe.Object); - - var inspection = new EmptyElseBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var actualResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - const int expectedCount = 1; - - Assert.AreEqual(expectedCount, actualResults.Count()); - } - - [TestMethod] - [TestCategory("Inspections")] - public void EmptyElseBlock_HasExecutableStatement() - { - const string inputCode = -@"Sub Foo() - If True Then - Else - Dim d - d = 0 - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var state = MockParser.CreateAndParse(vbe.Object); - - var inspection = new EmptyElseBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var actualResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - const int expectedCount = 0; - - Assert.AreEqual(expectedCount, actualResults.Count()); - } - } -} \ No newline at end of file diff --git a/RubberduckTests/Inspections/EmptyIfBlockInspectionTests.cs b/RubberduckTests/Inspections/EmptyIfBlockInspectionTests.cs deleted file mode 100644 index 7e257234e8..0000000000 --- a/RubberduckTests/Inspections/EmptyIfBlockInspectionTests.cs +++ /dev/null @@ -1,327 +0,0 @@ -using System.Linq; -using System.Threading; -using Microsoft.VisualStudio.TestTools.UnitTesting; -using Rubberduck.Inspections.Concrete; -using Rubberduck.Parsing.Inspections.Resources; -using Rubberduck.VBEditor.SafeComWrappers.Abstract; -using RubberduckTests.Mocks; - -namespace RubberduckTests.Inspections -{ - [TestClass] - public class EmptyIfBlockInspectionTests - { - [TestMethod] - [TestCategory("Inspections")] - public void EmptyIfBlock_FiresOnEmptyIfBlock() - { - const string inputCode = -@"Sub Foo() - If True Then - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var state = MockParser.CreateAndParse(vbe.Object); - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - Assert.AreEqual(1, inspectionResults.Count()); - } - - [TestMethod] - [TestCategory("Inspections")] - public void EmptyIfBlock_FiresOnEmptyElseIfBlock() - { - const string inputCode = -@"Sub Foo() - If True Then - ElseIf False Then - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var state = MockParser.CreateAndParse(vbe.Object); - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - Assert.AreEqual(2, inspectionResults.Count()); - } - - [TestMethod] - [TestCategory("Inspections")] - public void EmptyIfBlock_FiresOnEmptyIfBlock_ElseBlock() - { - const string inputCode = -@"Sub Foo() - If True Then - Else - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var state = MockParser.CreateAndParse(vbe.Object); - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - Assert.AreEqual(1, inspectionResults.Count()); - } - - [TestMethod] - [TestCategory("Inspections")] - public void EmptyIfBlock_FiresOnEmptySingleLineIfStmt() - { - const string inputCode = -@"Sub Foo() - If True Then Else Bar -End Sub - -Sub Bar() -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var state = MockParser.CreateAndParse(vbe.Object); - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - Assert.AreEqual(1, inspectionResults.Count()); - } - - [TestMethod] - [TestCategory("Inspections")] - public void EmptyIfBlock_FiresOnEmptyIfBlock_HasNonEmptyElseBlock() - { - const string inputCode = -@"Sub Foo() - If True Then - Else - Dim d - d = 0 - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var state = MockParser.CreateAndParse(vbe.Object); - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - Assert.AreEqual(1, inspectionResults.Count()); - } - - [TestMethod] - [TestCategory("Inspections")] - public void EmptyIfBlock_FiresOnEmptyIfBlock_HasQuoteComment() - { - const string inputCode = -@"Sub Foo() - If True Then - ' Im a comment - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var state = MockParser.CreateAndParse(vbe.Object); - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - Assert.AreEqual(1, inspectionResults.Count()); - } - - [TestMethod] - [TestCategory("Inspections")] - public void EmptyIfBlock_FiresOnEmptyIfBlock_HasRemComment() - { - const string inputCode = -@"Sub Foo() - If True Then - Rem Im a comment - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var state = MockParser.CreateAndParse(vbe.Object); - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - Assert.AreEqual(1, inspectionResults.Count()); - } - - [TestMethod] - [TestCategory("Inspections")] - public void EmptyIfBlock_FiresOnEmptyIfBlock_HasVariableDeclaration() - { - const string inputCode = -@"Sub Foo() - If True Then - Dim d - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var state = MockParser.CreateAndParse(vbe.Object); - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - Assert.AreEqual(1, inspectionResults.Count()); - } - - [TestMethod] - [TestCategory("Inspections")] - public void EmptyIfBlock_FiresOnEmptyIfBlock_HasConstDeclaration() - { - const string inputCode = -@"Sub Foo() - If True Then - Const c = 0 - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var state = MockParser.CreateAndParse(vbe.Object); - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - Assert.AreEqual(1, inspectionResults.Count()); - } - - [TestMethod] - [TestCategory("Inspections")] - public void EmptyIfBlock_FiresOnEmptyIfBlock_HasWhitespace() - { - const string inputCode = -@"Sub Foo() - If True Then - - - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var state = MockParser.CreateAndParse(vbe.Object); - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - Assert.AreEqual(1, inspectionResults.Count()); - } - - [TestMethod] - [TestCategory("Inspections")] - public void EmptyIfBlock_IfBlockHasExecutableStatement() - { - const string inputCode = -@"Sub Foo() - If True Then - Dim d - d = 0 - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var state = MockParser.CreateAndParse(vbe.Object); - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - Assert.IsFalse(inspectionResults.Any()); - } - - [TestMethod] - [TestCategory("Inspections")] - public void EmptyIfBlock_SingleLineIfBlockHasExecutableStatement() - { - const string inputCode = -@"Sub Foo() - If True Then Bar -End Sub - -Sub Bar() -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var state = MockParser.CreateAndParse(vbe.Object); - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - Assert.IsFalse(inspectionResults.Any()); - } - - [TestMethod] - [TestCategory("Inspections")] - public void EmptyIfBlock_IfAndElseIfBlockHaveExecutableStatement() - { - const string inputCode = -@"Sub Foo() - If True Then - Dim d - d = 0 - ElseIf False Then - Dim b - b = 0 - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var state = MockParser.CreateAndParse(vbe.Object); - - var inspection = new EmptyIfBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - Assert.IsFalse(inspectionResults.Any()); - } - - [TestMethod] - [TestCategory("Inspections")] - public void InspectionType() - { - var inspection = new EmptyIfBlockInspection(null); - Assert.AreEqual(CodeInspectionType.CodeQualityIssues, inspection.InspectionType); - } - - [TestMethod] - [TestCategory("Inspections")] - public void InspectionName() - { - const string inspectionName = nameof(EmptyIfBlockInspection); - var inspection = new EmptyIfBlockInspection(null); - - Assert.AreEqual(inspectionName, inspection.Name); - } - } -} diff --git a/RubberduckTests/QuickFixes/RemoveEmptyConditionBlockQuickFixTests.cs b/RubberduckTests/QuickFixes/RemoveEmptyConditionBlockQuickFixTests.cs new file mode 100644 index 0000000000..e1294aa234 --- /dev/null +++ b/RubberduckTests/QuickFixes/RemoveEmptyConditionBlockQuickFixTests.cs @@ -0,0 +1,1421 @@ +using System.Linq; +using System.Threading; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using Rubberduck.VBEditor.SafeComWrappers.Abstract; +using RubberduckTests.Mocks; +using Rubberduck.Inspections.Concrete; +using RubberduckTests.Inspections; +using Rubberduck.Inspections.QuickFixes; + +namespace RubberduckTests.QuickFixes +{ + [TestClass] + public class RemoveEmptyConditionBlockQuickFixTests + { + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyIfBlock_QuickFixRemovesLoneIf() + { + const string inputCode = +@"Sub Foo() + If True Then + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state,ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionResults.First()); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyIfBlock_QuickFixRemovesSingleLineIf() + { + const string inputCode = +@"Sub Foo() + If True Then Else Bar +End Sub + +Sub Bar() +End Sub"; + + const string expectedRewrite = +@"Sub Foo() + If Not True Then Bar +End Sub + +Sub Bar() +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.If); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionResults.First()); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyIfBlock_QuickFixRemovesLoneIf_WithComment() + { + const string inputCode = +@"Sub Foo() + If True Then + ' Im a comment + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state,ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionResults.First()); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyIfBlock_QuickFixRemovesIf_WithElseIfAndElse() + { + const string inputCode = +@"Sub Foo() + If True Then + ElseIf False Then + Dim d + d = 0 + Else + Dim b + b = 0 + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If False Then + Dim d + d = 0 + Else + Dim b + b = 0 + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state,ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionResults.First()); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyIfBlock_QuickFixRemovesElseIf() + { + const string inputCode = +@"Sub Foo() + If True Then + Dim d + d = 0 + ElseIf False Then + Else + Dim b + b = 0 + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If True Then + Dim d + d = 0 + Else + Dim b + b = 0 + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state,ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionResults.First()); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyIfBlock_QuickFixRemovesElseIf_HasComment() + { + const string inputCode = +@"Sub Foo() + If True Then + Dim d + d = 0 + ElseIf False Then + ' Im a comment + Else + Dim b + b = 0 + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If True Then + Dim d + d = 0 + Else + Dim b + b = 0 + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionResults.First()); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyIfBlock_QuickFixRemovesIf_HasVariable() + { + const string inputCode = +@"Sub Foo() + If True Then + Dim d + Else + Dim b + b = 0 + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + Dim d + If Not True Then + + Dim b + b = 0 + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state,ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionResults.First()); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyIfBlock_QuickFixRemovesIf_HasVariable_WithComment() + { + const string inputCode = +@"Sub Foo() + If True Then + ' comment + Dim d + Else + Dim b + b = 0 + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + Dim d + If Not True Then + ' comment + + Dim b + b = 0 + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionResults.First()); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + 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 expectedRewrite = +@"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); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionResults.First()); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyIfBlock_QuickFixRemovesIf_HasConst() + { + const string inputCode = +@"Sub Foo() + If True Then + Const d = 0 + Else + Dim b + b = 0 + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + Const d = 0 + If Not True Then + + Dim b + b = 0 + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionResults.First()); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyIfBlock_QuickFixRemovesElseIf_HasVariable() + { + const string inputCode = +@"Sub Foo() + If True Then + Dim d + d = 0 + ElseIf True Then + Dim b + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + Dim b + If True Then + Dim d + d = 0 + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionResults.First()); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyIfBlock_QuickFixRemovesElseIf_HasConst() + { + const string inputCode = +@"Sub Foo() + If True Then + Dim b + b = 0 + ElseIf True Then + Const d = 0 + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + Const d = 0 + If True Then + Dim b + b = 0 + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionResults.First()); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyIfBlock_QuickFixRemovesIf_UpdatesElseIf() + { + const string inputCode = +@"Sub Foo() + If True Then + ElseIf False Then + Dim d + d = 0 + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If False Then + Dim d + d = 0 + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.All); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionResults.First()); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyIfBlock_QuickFixRemovesIf_InvertsIf_SimpleCondition() + { + const string inputCode = +@"Sub Foo() + If True Then + Else + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If Not True Then + + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.If); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + var inspectionToFix = inspectionResults.First(); + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionToFix); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyElseBlock_QuickFixRemovesElse_Equals() + { + const string inputCode = +@"Sub Foo() + If True = True Then + Else + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If True = True Then + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.Else); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + var inspectionToFix = inspectionResults.First(); + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionToFix); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyIfBlock_QuickFixRemovesIf_InvertsIf_Equals() + { + const string inputCode = +@"Sub Foo() + If True = True Then + Else + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If True <> True Then + + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.If); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + var inspectionToFix = inspectionResults.First(); + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionToFix); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyElseBlock_QuickFixRemovesElse_NotEquals() + { + const string inputCode = +@"Sub Foo() + If True <> True Then + Else + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If True <> True Then + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.Else); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + var inspectionToFix = inspectionResults.First(); + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionToFix); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyIfBlock_QuickFixRemovesIf_InvertsIf_NotEquals() + { + const string inputCode = +@"Sub Foo() + If True <> True Then + Else + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If True = True Then + + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.If); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + var inspectionToFix = inspectionResults.First(); + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionToFix); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyElseBlock_QuickFixRemovesElse_LessThan() + { + const string inputCode = +@"Sub Foo() + If True < True Then + Else + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If True < True Then + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.Else); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + var inspectionToFix = inspectionResults.First(); + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionToFix); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyIfBlock_QuickFixRemovesIf_InvertsIf_LessThan() + { + const string inputCode = +@"Sub Foo() + If True < True Then + Else + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If True >= True Then + + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.If); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + var inspectionToFix = inspectionResults.First(); + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionToFix); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyElseBlock_QuickFixRemovesElse_LessThanEquals() + { + const string inputCode = +@"Sub Foo() + If True <= True Then + Else + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If True <= True Then + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.Else); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + var inspectionToFix = inspectionResults.First(); + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionToFix); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyIfBlock_QuickFixRemovesIf_InvertsIf_LessThanEquals() + { + const string inputCode = +@"Sub Foo() + If True <= True Then + Else + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If True > True Then + + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.If); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + var inspectionToFix = inspectionResults.First(); + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionToFix); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyElseBlock_QuickFixRemovesElse_GreaterThan() + { + const string inputCode = +@"Sub Foo() + If True > True Then + Else + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If True > True Then + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.Else); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + var inspectionToFix = inspectionResults.First(); + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionToFix); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyIfBlock_QuickFixRemovesIf_InvertsIf_GreaterThan() + { + const string inputCode = +@"Sub Foo() + If True > True Then + Else + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If True <= True Then + + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.If); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + var inspectionToFix = inspectionResults.First(); + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionToFix); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyElseBlock_QuickFixRemovesElse_GreaterThanEquals() + { + const string inputCode = +@"Sub Foo() + If True >= True Then + Else + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If True >= True Then + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.Else); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + var inspectionToFix = inspectionResults.First(); + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionToFix); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyIfBlock_QuickFixRemovesIf_InvertsIf_GreaterThanEquals() + { + const string inputCode = +@"Sub Foo() + If True >= True Then + Else + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If True < True Then + + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.If); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + var inspectionToFix = inspectionResults.First(); + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionToFix); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyElseBlock_QuickFixRemovesElse_Not() + { + const string inputCode = +@"Sub Foo() + If Not True Then + Else + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If Not True Then + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.Else); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + var inspectionToFix = inspectionResults.First(); + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionToFix); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyIfBlock_QuickFixRemovesIf_InvertsIf_Not() + { + const string inputCode = +@"Sub Foo() + If Not True Then + Else + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If True Then + + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.If); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + var inspectionToFix = inspectionResults.First(); + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionToFix); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyElseBlock_QuickFixRemovesElse_Not_NoWhitespace() + { + const string inputCode = +@"Sub Foo() + If Not(True) Then + Else + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If Not(True) Then + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.Else); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + var inspectionToFix = inspectionResults.First(); + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionToFix); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyIfBlock_QuickFixRemovesIf_InvertsIf_Not_NoWhitespace() + { + const string inputCode = +@"Sub Foo() + If Not(True) Then + Else + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If (True) Then + + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.If); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + var inspectionToFix = inspectionResults.First(); + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionToFix); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyElseBlock_QuickFixRemovesElse_And() + { + const string inputCode = +@"Sub Foo() + If True And True Then + Else + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If True And True Then + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.Else); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + var inspectionToFix = inspectionResults.First(); + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionToFix); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyIfBlock_QuickFixRemovesIf_InvertsIf_And() + { + const string inputCode = +@"Sub Foo() + If True And True Then + Else + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If True Or True Then + + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.If); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + var inspectionToFix = inspectionResults.First(); + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionToFix); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyElseBlock_QuickFixRemovesElse_InvertsIf_Or() + { + const string inputCode = +@"Sub Foo() + If True Or True Then + Else + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If True Or True Then + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.Else); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + var inspectionToFix = inspectionResults.First(); + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionToFix); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyIfBlock_QuickFixRemovesIf_InvertsIf_Or() + { + const string inputCode = +@"Sub Foo() + If True Or True Then + Else + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If True And True Then + + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.If); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + var inspectionToFix = inspectionResults.First(); + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionToFix); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyElseBlock_QuickFixRemovesElse_Xor() + { + const string inputCode = +@"Sub Foo() + If True Xor True Then + Else + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If True Xor True Then + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.Else); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + var inspectionToFix = inspectionResults.First(); + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionToFix); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyIfBlock_QuickFixRemovesIf_InvertsIf_Xor() + { + const string inputCode = +@"Sub Foo() + If True Xor True Then + Else + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If Not (True Xor True) Then + + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.If); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + var inspectionToFix = inspectionResults.First(); + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionToFix); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyElseBlock_QuickFixRemovesElse_ComplexCondition() + { + const string inputCode = +@"Sub Foo() + If True Or True And True Or True Then + Else + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If True Or True And True Or True Then + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.Else); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + var inspectionToFix = inspectionResults.First(); + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionToFix); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyIfBlock_QuickFixRemovesIf_InvertsIf_ComplexCondition() + { + const string inputCode = +@"Sub Foo() + If True Or True And True Or True Then + Else + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If True Or True And True And True Then + + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.If); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + var inspectionToFix = inspectionResults.First(); + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionToFix); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyElseBlock_QuickFixRemovesElse_ComplexCondition1() + { + const string inputCode = +@"Sub Foo() + If True And True Or True And True Then + Else + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If True And True Or True And True Then + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.Else); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + var inspectionToFix = inspectionResults.First(); + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionToFix); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyIfBlock_QuickFixRemovesIf_InvertsIf_ComplexCondition1() + { + const string inputCode = +@"Sub Foo() + If True And True Or True And True Then + Else + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If True And True And True And True Then + + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.If); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + var inspectionToFix = inspectionResults.First(); + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionToFix); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyElseBlock_QuickFixRemovesElse_ComplexCondition_WithParentheses() + { + const string inputCode = +@"Sub Foo() + If (True Or True) And (True Or True) Then + Else + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If (True Or True) And (True Or True) Then + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.Else); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + var inspectionToFix = inspectionResults.First(); + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionToFix); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyIfBlock_QuickFixRemovesIf_InvertsIf_ComplexCondition_WithParentheses() + { + const string inputCode = +@"Sub Foo() + If (True Or True) And (True Or True) Then + Else + End If +End Sub"; + const string expectedRewrite = +@"Sub Foo() + If (True Or True) Or (True Or True) Then + + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.If); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + var inspectionToFix = inspectionResults.First(); + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionToFix); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyElseBlock_QuickFixRemovesElse_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 expectedRewrite = +@"Sub Foo() + If 1 > 2 And 3 = 3 Or 4 <> 5 And 8 - 6 = 2 Then + End If +End Sub"; + + var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.Else); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + var inspectionToFix = inspectionResults.First(); + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionToFix); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + + [TestMethod] + [TestCategory("QuickFixes")] + public void EmptyIfBlock_QuickFixRemovesIf_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 expectedRewrite = +@"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); + var state = MockParser.CreateAndParse(vbe.Object); + + var inspection = new EmptyConditionBlockInspection(state, ConditionBlockToInspect.If); + var inspector = InspectionsHelper.GetInspector(inspection); + var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; + + var inspectionToFix = inspectionResults.First(); + new RemoveEmptyConditionBlockQuickFix(state).Fix(inspectionToFix); + var actualRewrite = state.GetRewriter(component).GetText(); + + Assert.AreEqual(expectedRewrite, actualRewrite); + } + } +} diff --git a/RubberduckTests/QuickFixes/RemoveEmptyElseBlockQuickFixTests.cs b/RubberduckTests/QuickFixes/RemoveEmptyElseBlockQuickFixTests.cs deleted file mode 100644 index c08a7bed0c..0000000000 --- a/RubberduckTests/QuickFixes/RemoveEmptyElseBlockQuickFixTests.cs +++ /dev/null @@ -1,47 +0,0 @@ -using System.Linq; -using System.Threading; -using Microsoft.VisualStudio.TestTools.UnitTesting; -using Rubberduck.VBEditor.SafeComWrappers.Abstract; -using RubberduckTests.Mocks; -using Rubberduck.Inspections.Concrete; -using Rubberduck.Inspections.QuickFixes; -using RubberduckTests.Inspections; - -namespace RubberduckTests.QuickFixes -{ - [TestClass] - public class RemoveEmptyElseBlockQuickFixTests - { - [TestMethod] - [TestCategory("QuickFixes")] - public void EmptyElseBlock_QuickFixRemovesElse() - { - const string inputCode = -@"Sub Foo() - If True Then - Else - End If -End Sub"; - - const string expectedCode = -@"Sub Foo() - If True Then - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - var state = MockParser.CreateAndParse(vbe.Object); - - var inspection = new EmptyElseBlockInspection(state); - var inspector = InspectionsHelper.GetInspector(inspection); - var actualResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result; - - new RemoveEmptyElseBlockQuickFix(state).Fix(actualResults.First()); - - string actualRewrite = state.GetRewriter(component).GetText(); - - Assert.AreEqual(expectedCode, actualRewrite); - } - } -} diff --git a/RubberduckTests/QuickFixes/RemoveEmptyIfBlockQuickFixTests.cs b/RubberduckTests/QuickFixes/RemoveEmptyIfBlockQuickFixTests.cs deleted file mode 100644 index 67685f9247..0000000000 --- a/RubberduckTests/QuickFixes/RemoveEmptyIfBlockQuickFixTests.cs +++ /dev/null @@ -1,958 +0,0 @@ -using System.Linq; -using System.Threading; -using Microsoft.VisualStudio.TestTools.UnitTesting; -using Rubberduck.Inspections.Concrete; -using Rubberduck.Inspections.QuickFixes; -using Rubberduck.Parsing.Inspections.Resources; -using Rubberduck.VBEditor.SafeComWrappers.Abstract; -using RubberduckTests.Mocks; -using RubberduckTests.Inspections; - -namespace RubberduckTests.QuickFixes -{ - [TestClass] - public class RemoveEmptyIfBlockQuickFixTests - { - [TestMethod] - [TestCategory("QuickFixes")] - public void EmptyIfBlock_QuickFixRemovesLoneIf() - { - const string inputCode = -@"Sub Foo() - If True Then - End If -End Sub"; - const string expectedCode = -@"Sub Foo() - -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - 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()); - } - - [TestMethod] - [TestCategory("QuickFixes")] - public void EmptyIfBlock_QuickFixRemovesSingleLineIf() - { - const string inputCode = -@"Sub Foo() - If True Then Else Bar -End Sub - -Sub Bar() -End Sub"; - - const string expectedCode = -@"Sub Foo() - If Not True Then Bar -End Sub - -Sub Bar() -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - 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()); - } - - [TestMethod] - [TestCategory("QuickFixes")] - 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"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - 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()); - } - - [TestMethod] - [TestCategory("QuickFixes")] - public void EmptyIfBlock_QuickFixRemovesIf_WithElseIfAndElse() - { - const string inputCode = -@"Sub Foo() - If True Then - ElseIf False Then - Dim d - d = 0 - Else - Dim b - b = 0 - End If -End Sub"; - const string expectedCode = -@"Sub Foo() - If False Then - Dim d - d = 0 - Else - Dim b - b = 0 - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - 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()); - } - - [TestMethod] - [TestCategory("QuickFixes")] - public void EmptyIfBlock_QuickFixRemovesElseIf() - { - const string inputCode = -@"Sub Foo() - If True Then - Dim d - d = 0 - ElseIf False Then - Else - Dim b - b = 0 - End If -End Sub"; - const string expectedCode = -@"Sub Foo() - If True Then - Dim d - d = 0 - Else - Dim b - b = 0 - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - 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()); - } - - [TestMethod] - [TestCategory("QuickFixes")] - public void EmptyIfBlock_QuickFixRemovesElseIf_HasComment() - { - const string inputCode = -@"Sub Foo() - If True Then - Dim d - d = 0 - ElseIf False Then - ' Im a comment - Else - Dim b - b = 0 - End If -End Sub"; - const string expectedCode = -@"Sub Foo() - If True Then - Dim d - d = 0 - Else - Dim b - b = 0 - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - 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()); - } - - [TestMethod] - [TestCategory("QuickFixes")] - public void EmptyIfBlock_QuickFixRemovesIf_HasVariable() - { - const string inputCode = -@"Sub Foo() - If True Then - Dim d - Else - Dim b - b = 0 - End If -End Sub"; - const string expectedCode = -@"Sub Foo() - Dim d - If Not True Then - - Dim b - b = 0 - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - 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()); - } - - [TestMethod] - [TestCategory("QuickFixes")] - public void EmptyIfBlock_QuickFixRemovesIf_HasVariable_WithComment() - { - const string inputCode = -@"Sub Foo() - If True Then - ' comment - Dim d - Else - Dim b - b = 0 - End If -End Sub"; - const string expectedCode = -@"Sub Foo() - Dim d - If Not True Then - ' comment - - Dim b - b = 0 - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - 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()); - } - - [TestMethod] - [TestCategory("QuickFixes")] - 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"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - 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); - } - - [TestMethod] - [TestCategory("QuickFixes")] - public void EmptyIfBlock_QuickFixRemovesIf_HasConst() - { - const string inputCode = -@"Sub Foo() - If True Then - Const d = 0 - Else - Dim b - b = 0 - End If -End Sub"; - const string expectedCode = -@"Sub Foo() - Const d = 0 - If Not True Then - - Dim b - b = 0 - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - 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); - } - - [TestMethod] - [TestCategory("QuickFixes")] - public void EmptyIfBlock_QuickFixRemovesElseIf_HasVariable() - { - const string inputCode = -@"Sub Foo() - If True Then - Dim d - d = 0 - ElseIf True Then - Dim b - End If -End Sub"; - const string expectedCode = -@"Sub Foo() - Dim b - If True Then - Dim d - d = 0 - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - 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()); - } - - [TestMethod] - [TestCategory("QuickFixes")] - public void EmptyIfBlock_QuickFixRemovesElseIf_HasConst() - { - const string inputCode = -@"Sub Foo() - If True Then - Dim b - b = 0 - ElseIf True Then - Const d = 0 - End If -End Sub"; - const string expectedCode = -@"Sub Foo() - Const d = 0 - If True Then - Dim b - b = 0 - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - 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()); - } - - [TestMethod] - [TestCategory("QuickFixes")] - public void EmptyIfBlock_QuickFixRemovesIf_UpdatesElseIf() - { - const string inputCode = -@"Sub Foo() - If True Then - ElseIf False Then - Dim d - d = 0 - End If -End Sub"; - const string expectedCode = -@"Sub Foo() - If False Then - Dim d - d = 0 - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - 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()); - } - - [TestMethod] - [TestCategory("QuickFixes")] - public void EmptyIfBlock_QuickFixRemovesElse_InvertsIf_SimpleCondition() - { - const string inputCode = -@"Sub Foo() - If True Then - Else - End If -End Sub"; - const string expectedCode = -@"Sub Foo() - If Not True Then - - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - 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()); - } - - [TestMethod] - [TestCategory("QuickFixes")] - public void EmptyIfBlock_QuickFixRemovesElse_InvertsIf_Equals() - { - const string inputCode = -@"Sub Foo() - If True = True Then - Else - End If -End Sub"; - const string expectedCode = -@"Sub Foo() - If True <> True Then - - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - 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()); - } - - [TestMethod] - [TestCategory("QuickFixes")] - public void EmptyIfBlock_QuickFixRemovesElse_InvertsIf_NotEquals() - { - const string inputCode = -@"Sub Foo() - If True <> True Then - Else - End If -End Sub"; - const string expectedCode = -@"Sub Foo() - If True = True Then - - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - 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()); - } - - [TestMethod] - [TestCategory("QuickFixes")] - public void EmptyIfBlock_QuickFixRemovesElse_InvertsIf_LessThan() - { - const string inputCode = -@"Sub Foo() - If True < True Then - Else - End If -End Sub"; - const string expectedCode = -@"Sub Foo() - If True >= True Then - - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - 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()); - } - - [TestMethod] - [TestCategory("QuickFixes")] - public void EmptyIfBlock_QuickFixRemovesElse_InvertsIf_LessThanEquals() - { - const string inputCode = -@"Sub Foo() - If True <= True Then - Else - End If -End Sub"; - const string expectedCode = -@"Sub Foo() - If True > True Then - - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - 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()); - } - - [TestMethod] - [TestCategory("QuickFixes")] - public void EmptyIfBlock_QuickFixRemovesElse_InvertsIf_GreaterThan() - { - const string inputCode = -@"Sub Foo() - If True > True Then - Else - End If -End Sub"; - const string expectedCode = -@"Sub Foo() - If True <= True Then - - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - 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()); - } - - [TestMethod] - [TestCategory("QuickFixes")] - public void EmptyIfBlock_QuickFixRemovesElse_InvertsIf_GreaterThanEquals() - { - const string inputCode = -@"Sub Foo() - If True >= True Then - Else - End If -End Sub"; - const string expectedCode = -@"Sub Foo() - If True < True Then - - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - 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()); - } - - [TestMethod] - [TestCategory("QuickFixes")] - public void EmptyIfBlock_QuickFixRemovesElse_InvertsIf_Not() - { - const string inputCode = -@"Sub Foo() - If Not True Then - Else - End If -End Sub"; - const string expectedCode = -@"Sub Foo() - If True Then - - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - 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()); - } - - [TestMethod] - [TestCategory("QuickFixes")] - public void EmptyIfBlock_QuickFixRemovesElse_InvertsIf_Not_NoWhitespace() - { - const string inputCode = -@"Sub Foo() - If Not(True) Then - Else - End If -End Sub"; - const string expectedCode = -@"Sub Foo() - If (True) Then - - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - 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()); - } - - [TestMethod] - [TestCategory("QuickFixes")] - public void EmptyIfBlock_QuickFixRemovesElse_InvertsIf_And() - { - const string inputCode = -@"Sub Foo() - If True And True Then - Else - End If -End Sub"; - const string expectedCode = -@"Sub Foo() - If True Or True Then - - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - 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()); - } - - [TestMethod] - [TestCategory("QuickFixes")] - public void EmptyIfBlock_QuickFixRemovesElse_InvertsIf_Or() - { - const string inputCode = -@"Sub Foo() - If True Or True Then - Else - End If -End Sub"; - const string expectedCode = -@"Sub Foo() - If True And True Then - - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - 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()); - } - - [TestMethod] - [TestCategory("QuickFixes")] - public void EmptyIfBlock_QuickFixRemovesElse_InvertsIf_Xor() - { - const string inputCode = -@"Sub Foo() - If True Xor True Then - Else - End If -End Sub"; - const string expectedCode = -@"Sub Foo() - If Not (True Xor True) Then - - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - 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()); - } - - [TestMethod] - [TestCategory("QuickFixes")] - public void EmptyIfBlock_QuickFixRemovesElse_InvertsIf_ComplexCondition() - { - const string inputCode = -@"Sub Foo() - If True Or True And True Or True Then - Else - End If -End Sub"; - const string expectedCode = -@"Sub Foo() - If True Or True And True And True Then - - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - 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()); - } - - [TestMethod] - [TestCategory("QuickFixes")] - public void EmptyIfBlock_QuickFixRemovesElse_InvertsIf_ComplexCondition1() - { - const string inputCode = -@"Sub Foo() - If True And True Or True And True Then - Else - End If -End Sub"; - const string expectedCode = -@"Sub Foo() - If True And True And True And True Then - - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - 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()); - } - - [TestMethod] - [TestCategory("QuickFixes")] - public void EmptyIfBlock_QuickFixRemovesElse_InvertsIf_ComplexCondition_WithParentheses() - { - const string inputCode = -@"Sub Foo() - If (True Or True) And (True Or True) Then - Else - End If -End Sub"; - const string expectedCode = -@"Sub Foo() - If (True Or True) Or (True Or True) Then - - End If -End Sub"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - 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()); - } - - [TestMethod] - [TestCategory("QuickFixes")] - 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"; - - IVBComponent component; - var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component); - 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()); - } - } -} diff --git a/RubberduckTests/RubberduckTests.csproj b/RubberduckTests/RubberduckTests.csproj index 2777d1bdaa..9b2d96ef3e 100644 --- a/RubberduckTests/RubberduckTests.csproj +++ b/RubberduckTests/RubberduckTests.csproj @@ -99,11 +99,10 @@ + - - @@ -122,6 +121,7 @@ + @@ -142,8 +142,6 @@ - -