line numbers changed

Author: tonyhallett

FineCodeCoverageTests/Editor/DynamicCoverage/BufferLineCoverage_Tests.cs

@@ -243,7 +243,9 @@ public void Should_Update_TrackedLines_When_Text_Buffer_ChangedOnBackground(bool
 
             var newSpan = new Span(1, 2);
             var mockTrackedLines = new Mock<ITrackedLines>();
-            mockTrackedLines.Setup(trackedLines => trackedLines.Changed(afterSnapshot, new List<Span> { newSpan })).Returns(textLinesChanged);
+            var changedLineNumbers = textLinesChanged ? new List<int> { 1, 2 } : new List<int>();
+            mockTrackedLines.Setup(trackedLines => trackedLines.GetChangedLineNumbers(afterSnapshot, new List<Span> { newSpan }))
+                .Returns(changedLineNumbers);
             autoMoqer.Setup<ITrackedLinesFactory, ITrackedLines>(trackedLinesFactory => trackedLinesFactory.Create(It.IsAny<List<ILine>>(), It.IsAny<ITextSnapshot>(), It.IsAny<Language>()))
                 .Returns(mockTrackedLines.Object);
 
@@ -254,7 +256,7 @@ public void Should_Update_TrackedLines_When_Text_Buffer_ChangedOnBackground(bool
 
             autoMoqer.Verify<IEventAggregator>(
                         eventAggregator => eventAggregator.SendMessage(
-                            It.Is<CoverageChangedMessage>(message => message.AppliesTo == "filepath" && message.CoverageLines == bufferLineCoverage)
+                            It.Is<CoverageChangedMessage>(message => message.AppliesTo == "filepath" && message.CoverageLines == bufferLineCoverage && message.ChangedLineNumbers == changedLineNumbers)
                             , null
                         ), Times.Exactly(textLinesChanged ? 1 : 0));
 

FineCodeCoverageTests/Editor/DynamicCoverage/CoverageCodeTracker_Tests.cs

@@ -32,18 +32,23 @@ public void Should_Return_Lines_From_TrackedCoverageLines_When_No_DirtyLine()
 
         }
 
+        private static IDynamicLine CreateDynamicLine(int lineNumber)
+        {
+            var mockDynamicLine = new Mock<IDynamicLine>();
+            mockDynamicLine.SetupGet(dynamicLine => dynamicLine.Number).Returns(lineNumber);
+            return mockDynamicLine.Object;
+        }
+
         [TestCase(true,true)]
         [TestCase(true, false)]
         [TestCase(false, true)]
         [TestCase(false,false)]
-        public void Should_Create_The_DirtyLine_And_Be_Changed_When_Text_Changed_And_Intersected(bool textChanged, bool intersected)
+        public void Should_Create_The_DirtyLine_When_Text_Changed_And_Intersected(bool textChanged, bool intersected)
         {
             var expectedCreatedDirtyLine = textChanged && intersected;
             var textSnapshot = new Mock<ITextSnapshot>().Object;
             var newSpanAndLineRanges = new List<SpanAndLineRange> { new SpanAndLineRange(new Span(1, 2), 0, 1) };
             var autoMoqer = new AutoMoqer();
-            var containgCodeTrackerProcessResult = new Mock<IContainingCodeTrackerProcessResult>().Object;
-
 
             var mockTrackingSpanRange = new Mock<ITrackingSpanRange>();
             var firstTrackingSpan = new Mock<ITrackingSpan>().Object;
@@ -65,9 +70,7 @@ public void Should_Create_The_DirtyLine_And_Be_Changed_When_Text_Changed_And_Int
                     false,
                     textChanged
             );
-            var updated = coverageCodeTracker.Update(trackingSpanRangeProcessResult, textSnapshot, newSpanAndLineRanges);
-
-            Assert.That(updated, Is.EqualTo(expectedCreatedDirtyLine));
+            coverageCodeTracker.GetUpdatedLineNumbers(trackingSpanRangeProcessResult, textSnapshot, newSpanAndLineRanges);
 
             mockDirtyLineFactory.Verify(
                 dirtyLineFactory => dirtyLineFactory.Create(firstTrackingSpan, textSnapshot),
@@ -84,15 +87,49 @@ public void Should_Create_The_DirtyLine_And_Be_Changed_When_Text_Changed_And_Int
             }
         }
 
+        [Test]
+        public void Should_Return_The_Dirty_Line_Number_And_All_Tracked_Line_Numbers_When_Create_Dirty_Line()
+        {
+            var textSnapshot = new Mock<ITextSnapshot>().Object;
+            
+            var autoMoqer = new AutoMoqer();
+            var coverageLines = new List<IDynamicLine> { CreateDynamicLine(1), CreateDynamicLine(2) };
+            autoMoqer.Setup<ITrackedCoverageLines, IEnumerable<IDynamicLine>>(
+                trackedCoverageLines => trackedCoverageLines.Lines
+                ).Returns(coverageLines);
+            var mockDirtyLineFactory = autoMoqer.GetMock<IDirtyLineFactory>();
+            var mockDirtyLine = new Mock<ITrackingLine>();
+            mockDirtyLine.SetupGet(dirtyLine => dirtyLine.Line.Number).Returns(10);
+            mockDirtyLineFactory.Setup(
+                dirtyLineFactory => dirtyLineFactory.Create(It.IsAny<ITrackingSpan>(), textSnapshot)
+            ).Returns(mockDirtyLine.Object);
+
+            var coverageCodeTracker = autoMoqer.Create<CoverageCodeTracker>();
+
+            var trackingSpanRangeProcessResult = new TrackingSpanRangeProcessResult(
+                    new Mock<ITrackingSpanRange>().Object,
+                    new List<SpanAndLineRange>(),
+                    false,
+                    true
+            );
+            
+            var updatedLineNumbers = coverageCodeTracker.GetUpdatedLineNumbers(
+                trackingSpanRangeProcessResult, 
+                textSnapshot, 
+                new List<SpanAndLineRange> { new SpanAndLineRange(new Span(1, 2), 0, 1) });
+
+            Assert.That(updatedLineNumbers, Is.EqualTo(new List<int> { 10, 1, 2 }));
+        }
 
-        [TestCase(true)]
-        [TestCase(false)]
-        public void Should_Update_TrackedCoverageLines_When_Do_Not_Create_DirtyLine(bool trackedCoverageLinesChanged)
+        [Test]
+        public void Should_Update_TrackedCoverageLines_When_Do_Not_Create_DirtyLine()
         {
             var textSnapshot = new Mock<ITextSnapshot>().Object;
             var autoMoqer = new AutoMoqer();
             var mockTrackedCoverageLines = autoMoqer.GetMock<ITrackedCoverageLines>();
-            mockTrackedCoverageLines.Setup(trackedCoverageLines => trackedCoverageLines.Update(textSnapshot)).Returns(trackedCoverageLinesChanged);
+            var trackedCoverageLinesUpdatedLineNumbers = new List<int> { 1, 2 };
+            mockTrackedCoverageLines.Setup(trackedCoverageLines => trackedCoverageLines.GetUpdatedLineNumbers(textSnapshot))
+                .Returns(trackedCoverageLinesUpdatedLineNumbers);
             var newSpanAndLineRanges = new List<SpanAndLineRange> { new SpanAndLineRange(new Span(1, 2), 0, 1) };
             var trackingSpanRangeProcessResult = new TrackingSpanRangeProcessResult(
                 new Mock<ITrackingSpanRange>().Object,
@@ -103,21 +140,22 @@ public void Should_Update_TrackedCoverageLines_When_Do_Not_Create_DirtyLine(bool
 
             var coverageCodeTracker = autoMoqer.Create<CoverageCodeTracker>();
 
-            var updated = coverageCodeTracker.Update(trackingSpanRangeProcessResult, textSnapshot, newSpanAndLineRanges);
+            var updatedLineNumbers = coverageCodeTracker.GetUpdatedLineNumbers(trackingSpanRangeProcessResult, textSnapshot, newSpanAndLineRanges);
 
-            Assert.That(updated, Is.EqualTo(trackedCoverageLinesChanged));
+            Assert.That(updatedLineNumbers, Is.SameAs(trackedCoverageLinesUpdatedLineNumbers));
         }
 
-        [TestCase(true)]
-        [TestCase(false)]
-        public void Should_Update_DirtyLine_When_DirtyLine(bool dirtyLineChanged)
+        [Test]
+        public void Should_Update_DirtyLine_When_DirtyLine()
         {
             var textSnapshot2 = new Mock<ITextSnapshot>().Object;
             var spanAndLineRange2 = new List<SpanAndLineRange>() { new SpanAndLineRange(new Span(1, 3), 0, 0) };
             var autoMoqer = new AutoMoqer();
             var mockDirtyLineFactory = autoMoqer.GetMock<IDirtyLineFactory>();
             var mockDirtyLine = new Mock<ITrackingLine>();
-            mockDirtyLine.Setup(dirtyLine => dirtyLine.Update(textSnapshot2)).Returns(dirtyLineChanged);
+            mockDirtyLine.SetupGet(dirtyLine => dirtyLine.Line.Number).Returns(10);
+            var dirtyLineUpdatedLineNumbers =new List<int> { 10, 20 };
+            mockDirtyLine.Setup(dirtyLine => dirtyLine.Update(textSnapshot2)).Returns(dirtyLineUpdatedLineNumbers);
             mockDirtyLineFactory.Setup(dirtyLineFactory => dirtyLineFactory.Create(It.IsAny<ITrackingSpan>(), It.IsAny<ITextSnapshot>())).Returns(mockDirtyLine.Object);
 
             var coverageCodeTracker = autoMoqer.Create<CoverageCodeTracker>();
@@ -128,7 +166,7 @@ public void Should_Update_DirtyLine_When_DirtyLine(bool dirtyLineChanged)
                 false,
                 true
             );
-            coverageCodeTracker.Update(trackingSpanRangeProcessResult1, new Mock<ITextSnapshot>().Object, new List<SpanAndLineRange>() { new SpanAndLineRange(new Span(1, 2), 0, 0) });
+            coverageCodeTracker.GetUpdatedLineNumbers(trackingSpanRangeProcessResult1, new Mock<ITextSnapshot>().Object, new List<SpanAndLineRange>() { new SpanAndLineRange(new Span(1, 2), 0, 0) });
 
             var trackingSpanRangeProcessResult2 = new TrackingSpanRangeProcessResult(
                 new Mock<ITrackingSpanRange>().Object,
@@ -137,9 +175,11 @@ public void Should_Update_DirtyLine_When_DirtyLine(bool dirtyLineChanged)
                 true
             );
 
-            var updated = coverageCodeTracker.Update(trackingSpanRangeProcessResult2, textSnapshot2, spanAndLineRange2);
+            var updatedLineNumbers = coverageCodeTracker.GetUpdatedLineNumbers(
+                trackingSpanRangeProcessResult2, textSnapshot2, spanAndLineRange2);
+
+            Assert.That(updatedLineNumbers, Is.EqualTo(dirtyLineUpdatedLineNumbers));
 
-            Assert.That(dirtyLineChanged, Is.EqualTo(updated));
         }
 
     }

FineCodeCoverageTests/Editor/DynamicCoverage/CoverageLine_Tests.cs

@@ -1,4 +1,6 @@
-using FineCodeCoverage.Editor.DynamicCoverage;
+using System.Collections.Generic;
+using System.Linq;
+using FineCodeCoverage.Editor.DynamicCoverage;
 using FineCodeCoverage.Engine.Model;
 using Microsoft.VisualStudio.Text;
 using Moq;
@@ -39,9 +41,9 @@ public void Should_Be_Updated_If_The_Line_Number_Changes(bool updateLineNumber)
                 .Returns(updatedLineNumber);
             var coverageLine = new CoverageLine(trackingSpan, mockLine.Object, mockLineTracker.Object);
 
-            var updated = coverageLine.Update(currentTextSnapshot);
+            var updatedLineNumbers = coverageLine.Update(currentTextSnapshot);
 
-            Assert.That(updated, Is.EqualTo(updateLineNumber));
+            Assert.That(updatedLineNumbers, Is.EqualTo(updateLineNumber ? new List<int> { 0, 10 } : Enumerable.Empty<int>()));
 
             Assert.That(coverageLine.Line.Number, Is.EqualTo(updatedLineNumber));
         }