Skip to content

Commit ac1650c

Browse files
tonyhalletttonyhallett
committed
backup
1 parent 2ad2d3f commit ac1650c

27 files changed

+361
-232
lines changed

‎FineCodeCoverageTests/Editor/DynamicCoverage/BlazorCoverageContentType_Tests.cs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
using FineCodeCoverage.Editor.DynamicCoverage.ContentTypes;
1+
using FineCodeCoverage.Editor.DynamicCoverage.ContentTypes.Blazor;
22
using NUnit.Framework;
33

44
namespace FineCodeCoverageTests.Editor.DynamicCoverage
@@ -10,7 +10,7 @@ internal class BlazorCoverageContentType_Tests
1010
[TestCase("path.vbhtml", true)]
1111
public void Should_Include_Razor_Component_Files(string filePath, bool expectedExclude)
1212
{
13-
Assert.That(new BlazorCoverageContentType().Exclude(filePath), Is.EqualTo(expectedExclude));
13+
Assert.That(new BlazorCoverageContentType(null).Exclude(filePath), Is.EqualTo(expectedExclude));
1414
}
1515
}
1616
}

‎FineCodeCoverageTests/Editor/DynamicCoverage/ContainingCodeTrackedLinesBuilder_Tests.cs‎

Lines changed: 138 additions & 92 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,7 @@
22
using FineCodeCoverage.Core.Utilities;
33
using FineCodeCoverage.Core.Utilities.VsThreading;
44
using FineCodeCoverage.Editor.DynamicCoverage;
5+
using FineCodeCoverage.Editor.DynamicCoverage.TrackedLinesImpl.Construction;
56
using FineCodeCoverage.Editor.Roslyn;
67
using FineCodeCoverage.Editor.Tagging.Base;
78
using FineCodeCoverage.Engine.Model;
@@ -20,6 +21,9 @@ namespace FineCodeCoverageTests.Editor.DynamicCoverage
2021
{
2122
class Line : ILine
2223
{
24+
public Line(int number):this(number, CoverageType.Covered)
25+
{
26+
}
2327
public Line(int number, CoverageType coverageType)
2428
{
2529
Number = number;
@@ -52,103 +56,145 @@ public static CodeSpanRange CodeSpanRangeFromLine(ILine line)
5256
return CodeSpanRange.SingleLine(line.Number - 1);
5357
}
5458
}
55-
internal class ContainingCodeTrackedLinesBuilder_CPP_Tests
59+
60+
internal class ContainingCodeTrackedLinesBuilder_ContentType_No_FileLineCoverageService_Tests
5661
{
5762
[Test]
58-
public void Should_Create_ContainingCodeTracker_For_Each_Line_When_CPP()
63+
public void Should_Create_CoverageLines_ContainingCodeTracker_For_Each_Line()
5964
{
60-
throw new System.NotImplementedException();
61-
// var autoMoqer = new AutoMoqer();
62-
63-
// var textSnapshot = new Mock<ITextSnapshot>().Object;
64-
// var lines = new List<ILine>
65-
// {
66-
// new Mock<ILine>().Object,
67-
// new Mock<ILine>().Object
68-
// };
69-
// var containingCodeTrackers = new List<IContainingCodeTracker>
70-
// {
71-
// new Mock<IContainingCodeTracker>().Object,
72-
// new Mock<IContainingCodeTracker>().Object
73-
// };
74-
// var firstLine = lines[0];
75-
// var firstCodeSpanRange = TestHelper.CodeSpanRangeFromLine(firstLine);
76-
// var secondLine = lines[1];
77-
// var secondCodeSpanRange = TestHelper.CodeSpanRangeFromLine(secondLine);
78-
// var mockContainingCodeTrackerFactory = autoMoqer.GetMock<ICodeSpanRangeContainingCodeTrackerFactory>();
79-
// mockContainingCodeTrackerFactory.Setup(containingCodeTrackerFactory =>
80-
// containingCodeTrackerFactory.CreateCoverageLines(textSnapshot, new List<ILine> { firstLine }, firstCodeSpanRange, SpanTrackingMode.EdgeExclusive)
81-
// ).Returns(containingCodeTrackers[0]);
82-
// mockContainingCodeTrackerFactory.Setup(containingCodeTrackerFactory =>
83-
// containingCodeTrackerFactory.CreateCoverageLines(textSnapshot, new List<ILine> { secondLine }, secondCodeSpanRange, SpanTrackingMode.EdgeExclusive)
84-
//).Returns(containingCodeTrackers[1]);
85-
86-
// var expectedTrackedLines = new TrackedLines(null, null, null);
87-
// var mockContainingCodeTrackedLinesFactory = autoMoqer.GetMock<IContainingCodeTrackedLinesFactory>();
88-
// mockContainingCodeTrackedLinesFactory.Setup(containingCodeTrackedLinesFactory => containingCodeTrackedLinesFactory.Create(containingCodeTrackers, null, null)
89-
// ).Returns(expectedTrackedLines);
90-
91-
// var containingCodeTrackedLinesBuilder = autoMoqer.Create<ContainingCodeTrackedLinesBuilder>();
92-
// var trackedLines = containingCodeTrackedLinesBuilder.Create(lines, textSnapshot, Language.CPP);
93-
94-
// Assert.That(trackedLines, Is.EqualTo(expectedTrackedLines));
95-
96-
}
97-
98-
[Test]
99-
public void Should_Use_CPP_Deserialized_When_CodeSpanRange_Within_Total_Lines()
100-
{
101-
throw new System.NotImplementedException();
102-
//var mockTextSnapshot = new Mock<ITextSnapshot>();
103-
//mockTextSnapshot.SetupGet(textSnapshot => textSnapshot.LineCount).Returns(40);
104-
//var autoMoqer = new AutoMoqer();
105-
//var mockCodeSpanRangeContainingCodeTrackerFactory = autoMoqer.GetMock<ICodeSpanRangeContainingCodeTrackerFactory>();
106-
//var coverageLineTracker = new Mock<IContainingCodeTracker>().Object;
107-
//mockCodeSpanRangeContainingCodeTrackerFactory.Setup(
108-
// codeSpanRangeContainingCodeTrackerFactory => codeSpanRangeContainingCodeTrackerFactory.CreateCoverageLines(
109-
// mockTextSnapshot.Object,
110-
// new List<ILine> { new Line(1, CoverageType.Covered) },
111-
// new CodeSpanRange(10, 20),
112-
// SpanTrackingMode.EdgeExclusive
113-
// )
114-
//).Returns(coverageLineTracker);
115-
//var dirtyLineTracker = new Mock<IContainingCodeTracker>().Object;
116-
//mockCodeSpanRangeContainingCodeTrackerFactory.Setup(
117-
// codeSpanRangeContainingCodeTrackerFactory => codeSpanRangeContainingCodeTrackerFactory.CreateDirty(
118-
// mockTextSnapshot.Object,
119-
// new CodeSpanRange(25, 30),
120-
// SpanTrackingMode.EdgeExclusive
121-
// )
122-
//).Returns(dirtyLineTracker);
123-
//var mockJsonConvertService = autoMoqer.GetMock<IJsonConvertService>();
124-
//var serializedState = new SerializedState(new CodeSpanRange(10, 20), ContainingCodeTrackerType.CoverageLines, new List<DynamicLine>
125-
//{
126-
// new DynamicLine(0, DynamicCoverageType.Covered)
127-
//});
128-
//var serializedState2 = new SerializedState(new CodeSpanRange(25, 30), ContainingCodeTrackerType.CoverageLines, new List<DynamicLine>
129-
//{
130-
// new DynamicLine(3, DynamicCoverageType.Dirty)
131-
//});
132-
//var serializedState3 = new SerializedState(new CodeSpanRange(50, 60), ContainingCodeTrackerType.CoverageLines, new List<DynamicLine>());
133-
//mockJsonConvertService.Setup(jsonConvertService => jsonConvertService.DeserializeObject<List<SerializedState>>("serializedState"))
134-
// .Returns(new List<SerializedState> { serializedState, serializedState2, serializedState3 });
135-
136-
//var expectedTrackedLines = new TrackedLines(null, null, null);
137-
//autoMoqer.Setup<IContainingCodeTrackedLinesFactory, TrackedLines>(
138-
// containingCodeTrackedLinesFactory => containingCodeTrackedLinesFactory.Create(
139-
// new List<IContainingCodeTracker> { coverageLineTracker, dirtyLineTracker },
140-
// null,
141-
// null
142-
// )).Returns(expectedTrackedLines);
143-
144-
145-
//var containingCodeTrackedLinesBuilder = autoMoqer.Create<ContainingCodeTrackedLinesBuilder>();
146-
147-
//var trackedLines = containingCodeTrackedLinesBuilder.Create("serializedState", mockTextSnapshot.Object, Language.CPP);
148-
149-
//Assert.That(expectedTrackedLines, Is.SameAs(trackedLines));
65+
var line1 = new Line(1);
66+
var line2 = new Line(2);
67+
68+
var mockTextSnapshot = new Mock<ITextSnapshot>();
69+
mockTextSnapshot.SetupGet(textSnapshot => textSnapshot.ContentType.TypeName).Returns("contenttypename");
70+
71+
var autoMoqer = new AutoMoqer();
72+
var mockCodeSpanRangeContainingCodeTrackerFactory = autoMoqer.GetMock<ICodeSpanRangeContainingCodeTrackerFactory>();
73+
var containingCodeTracker1 = new Mock<IContainingCodeTracker>().Object;
74+
var containingCodeTracker2 = new Mock<IContainingCodeTracker>().Object;
75+
mockCodeSpanRangeContainingCodeTrackerFactory.Setup(
76+
codeSpanRangeContainingCodeTrackerFactory => codeSpanRangeContainingCodeTrackerFactory.CreateCoverageLines(
77+
mockTextSnapshot.Object, new List<ILine> { line1 }, TestHelper.CodeSpanRangeFromLine(line1), SpanTrackingMode.EdgeExclusive)
78+
).Returns(containingCodeTracker1);
79+
mockCodeSpanRangeContainingCodeTrackerFactory.Setup(
80+
codeSpanRangeContainingCodeTrackerFactory => codeSpanRangeContainingCodeTrackerFactory.CreateCoverageLines(
81+
mockTextSnapshot.Object, new List<ILine> { line2 }, TestHelper.CodeSpanRangeFromLine(line2), SpanTrackingMode.EdgeExclusive)
82+
).Returns(containingCodeTracker2);
83+
var mockContainingCodeTrackedLinesFactory = autoMoqer.GetMock<IContainingCodeTrackedLinesFactory>();
84+
var trackedLinesFromFactory = new TrackedLines(null, null, null);
85+
86+
mockContainingCodeTrackedLinesFactory.Setup(containingCodeTrackedLinesFactory => containingCodeTrackedLinesFactory.Create(
87+
new List<IContainingCodeTracker> { containingCodeTracker1, containingCodeTracker2 },
88+
It.IsAny<INewCodeTracker>(),
89+
It.IsAny<IFileCodeSpanRangeService>()
90+
)).Returns(trackedLinesFromFactory);
91+
var mockCoverageContentType = new Mock<ICoverageContentType>();
92+
mockCoverageContentType.Setup(coverageContentType => coverageContentType.ContentTypeName).Returns("contenttypename");
93+
autoMoqer.SetInstance(new ICoverageContentType[] { mockCoverageContentType .Object});
94+
95+
var containingCodeTrackedLinesBuilder = autoMoqer.Create<ContainingCodeTrackedLinesBuilder>();
96+
97+
var trackedLines = containingCodeTrackedLinesBuilder.Create(new List<ILine> { line1, line2 }, mockTextSnapshot.Object);
98+
99+
Assert.That(trackedLines, Is.SameAs(trackedLinesFromFactory));
150100
}
151101
}
102+
103+
//internal class ContainingCodeTrackedLinesBuilder_CPP_Tests
104+
//{
105+
// [Test]
106+
// public void Should_Create_ContainingCodeTracker_For_Each_Line_When_CPP()
107+
// {
108+
// var autoMoqer = new AutoMoqer();
109+
110+
// var textSnapshot = new Mock<ITextSnapshot>().Object;
111+
// var lines = new List<ILine>
112+
// {
113+
// new Mock<ILine>().Object,
114+
// new Mock<ILine>().Object
115+
// };
116+
// var containingCodeTrackers = new List<IContainingCodeTracker>
117+
// {
118+
// new Mock<IContainingCodeTracker>().Object,
119+
// new Mock<IContainingCodeTracker>().Object
120+
// };
121+
// var firstLine = lines[0];
122+
// var firstCodeSpanRange = TestHelper.CodeSpanRangeFromLine(firstLine);
123+
// var secondLine = lines[1];
124+
// var secondCodeSpanRange = TestHelper.CodeSpanRangeFromLine(secondLine);
125+
// var mockContainingCodeTrackerFactory = autoMoqer.GetMock<ICodeSpanRangeContainingCodeTrackerFactory>();
126+
// mockContainingCodeTrackerFactory.Setup(containingCodeTrackerFactory =>
127+
// containingCodeTrackerFactory.CreateCoverageLines(textSnapshot, new List<ILine> { firstLine }, firstCodeSpanRange, SpanTrackingMode.EdgeExclusive)
128+
// ).Returns(containingCodeTrackers[0]);
129+
// mockContainingCodeTrackerFactory.Setup(containingCodeTrackerFactory =>
130+
// containingCodeTrackerFactory.CreateCoverageLines(textSnapshot, new List<ILine> { secondLine }, secondCodeSpanRange, SpanTrackingMode.EdgeExclusive)
131+
// ).Returns(containingCodeTrackers[1]);
132+
133+
// var expectedTrackedLines = new TrackedLines(null, null, null);
134+
// var mockContainingCodeTrackedLinesFactory = autoMoqer.GetMock<IContainingCodeTrackedLinesFactory>();
135+
// mockContainingCodeTrackedLinesFactory.Setup(containingCodeTrackedLinesFactory => containingCodeTrackedLinesFactory.Create(containingCodeTrackers, null, null)
136+
// ).Returns(expectedTrackedLines);
137+
138+
// var containingCodeTrackedLinesBuilder = autoMoqer.Create<ContainingCodeTrackedLinesBuilder>();
139+
// var trackedLines = containingCodeTrackedLinesBuilder.Create(lines, textSnapshot, Language.CPP);
140+
141+
// Assert.That(trackedLines, Is.EqualTo(expectedTrackedLines));
142+
143+
// }
144+
145+
// [Test]
146+
// public void Should_Use_CPP_Deserialized_When_CodeSpanRange_Within_Total_Lines()
147+
// {
148+
// //var mockTextSnapshot = new Mock<ITextSnapshot>();
149+
// //mockTextSnapshot.SetupGet(textSnapshot => textSnapshot.LineCount).Returns(40);
150+
// //var autoMoqer = new AutoMoqer();
151+
// //var mockCodeSpanRangeContainingCodeTrackerFactory = autoMoqer.GetMock<ICodeSpanRangeContainingCodeTrackerFactory>();
152+
// //var coverageLineTracker = new Mock<IContainingCodeTracker>().Object;
153+
// //mockCodeSpanRangeContainingCodeTrackerFactory.Setup(
154+
// // codeSpanRangeContainingCodeTrackerFactory => codeSpanRangeContainingCodeTrackerFactory.CreateCoverageLines(
155+
// // mockTextSnapshot.Object,
156+
// // new List<ILine> { new Line(1, CoverageType.Covered) },
157+
// // new CodeSpanRange(10, 20),
158+
// // SpanTrackingMode.EdgeExclusive
159+
// // )
160+
// //).Returns(coverageLineTracker);
161+
// //var dirtyLineTracker = new Mock<IContainingCodeTracker>().Object;
162+
// //mockCodeSpanRangeContainingCodeTrackerFactory.Setup(
163+
// // codeSpanRangeContainingCodeTrackerFactory => codeSpanRangeContainingCodeTrackerFactory.CreateDirty(
164+
// // mockTextSnapshot.Object,
165+
// // new CodeSpanRange(25, 30),
166+
// // SpanTrackingMode.EdgeExclusive
167+
// // )
168+
// //).Returns(dirtyLineTracker);
169+
// //var mockJsonConvertService = autoMoqer.GetMock<IJsonConvertService>();
170+
// //var serializedState = new SerializedState(new CodeSpanRange(10, 20), ContainingCodeTrackerType.CoverageLines, new List<DynamicLine>
171+
// //{
172+
// // new DynamicLine(0, DynamicCoverageType.Covered)
173+
// //});
174+
// //var serializedState2 = new SerializedState(new CodeSpanRange(25, 30), ContainingCodeTrackerType.CoverageLines, new List<DynamicLine>
175+
// //{
176+
// // new DynamicLine(3, DynamicCoverageType.Dirty)
177+
// //});
178+
// //var serializedState3 = new SerializedState(new CodeSpanRange(50, 60), ContainingCodeTrackerType.CoverageLines, new List<DynamicLine>());
179+
// //mockJsonConvertService.Setup(jsonConvertService => jsonConvertService.DeserializeObject<List<SerializedState>>("serializedState"))
180+
// // .Returns(new List<SerializedState> { serializedState, serializedState2, serializedState3 });
181+
182+
// //var expectedTrackedLines = new TrackedLines(null, null, null);
183+
// //autoMoqer.Setup<IContainingCodeTrackedLinesFactory, TrackedLines>(
184+
// // containingCodeTrackedLinesFactory => containingCodeTrackedLinesFactory.Create(
185+
// // new List<IContainingCodeTracker> { coverageLineTracker, dirtyLineTracker },
186+
// // null,
187+
// // null
188+
// // )).Returns(expectedTrackedLines);
189+
190+
191+
// //var containingCodeTrackedLinesBuilder = autoMoqer.Create<ContainingCodeTrackedLinesBuilder>();
192+
193+
// //var trackedLines = containingCodeTrackedLinesBuilder.Create("serializedState", mockTextSnapshot.Object, Language.CPP);
194+
195+
// //Assert.That(expectedTrackedLines, Is.SameAs(trackedLines));
196+
// }
197+
//}
152198

153199
// [TestFixture(true)]
154200
// [TestFixture(false)]

‎FineCodeCoverageTests/Editor/DynamicCoverage/LineExcluder_Tests.cs‎

Lines changed: 6 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -5,20 +5,13 @@ namespace FineCodeCoverageTests.Editor.DynamicCoverage
55
{
66
internal class LineExcluder_Tests
77
{
8-
[TestCase(true, " ", true)]
9-
[TestCase(true, " //", true)]
10-
[TestCase(true, " #pragma", true)]
11-
[TestCase(true, " using", true)]
12-
[TestCase(true, " not excluded", false)]
13-
[TestCase(false, " ", true)]
14-
[TestCase(false, " '", true)]
15-
[TestCase(false, " REM", true)]
16-
[TestCase(false, " #pragma", true)]
17-
[TestCase(true, " not excluded", false)]
18-
public void Should_Exclude_If_Not_Code(bool isCSharp, string text, bool expectedExclude)
8+
[TestCase(new string[0]," ", true)]
9+
[TestCase(new string[0], " x", false)]
10+
[TestCase(new string[] { "y", "x"}, " x", true)]
11+
public void Should_Exclude_If_Not_Code(string[] exclusions, string text, bool expectedExclude)
1912
{
20-
var codeLineExcluder = new LineExcluder();
21-
var exclude = codeLineExcluder.ExcludeIfNotCode(text, isCSharp);
13+
var codeLineExcluder = new LineExcluder(exclusions);
14+
var exclude = codeLineExcluder.ExcludeIfNotCode(text);
2215
Assert.That(exclude, Is.EqualTo(expectedExclude));
2316
}
2417
}

0 commit comments

Comments
 (0)