From 33671ba388bd51f0118c47f4a1543a8f9562c2fc Mon Sep 17 00:00:00 2001 From: Vedant Kumar Date: Fri, 8 Sep 2017 18:44:50 +0000 Subject: [PATCH] [Coverage] Build sorted and unique segments A coverage segment contains a starting line and column, an execution count, and some other metadata. Clients of the coverage library use segments to prepare line-oriented reports. Users of the coverage library depend on segments being unique and sorted in source order. Currently this is not guaranteed (this is why the clang change which introduced deferred regions was reverted). This commit documents the "unique and sorted" condition and asserts that it holds. It also fixes the SegmentBuilder so that it produces correct output in some edge cases. Testing: I've added unit tests for some edge cases. I've also checked that the new SegmentBuilder implementation is fully covered. Apart from running check-profile and the llvm-cov tests, I've successfully used a stage1 llvm-cov to prepare a coverage report for an instrumented clang binary. Differential Revision: https://reviews.llvm.org/D36813 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@312817 91177308-0d34-0410-b5e6-96231b3b80d8 --- .../ProfileData/Coverage/CoverageMapping.h | 2 + lib/ProfileData/Coverage/CoverageMapping.cpp | 184 +++++++++---- test/tools/llvm-cov/deferred-region.cpp | 4 +- test/tools/llvm-cov/showHighlightedRanges.cpp | 2 +- unittests/ProfileData/CoverageMappingTest.cpp | 241 +++++++++++++++++- 5 files changed, 380 insertions(+), 53 deletions(-) diff --git a/include/llvm/ProfileData/Coverage/CoverageMapping.h b/include/llvm/ProfileData/Coverage/CoverageMapping.h index dfcacd2cf11..eb560d9c3df 100644 --- a/include/llvm/ProfileData/Coverage/CoverageMapping.h +++ b/include/llvm/ProfileData/Coverage/CoverageMapping.h @@ -470,6 +470,8 @@ public: /// Get the name of the file this data covers. StringRef getFilename() const { return Filename; } + /// Get an iterator over the coverage segments for this object. The segments + /// are guaranteed to be uniqued and sorted by location. std::vector::const_iterator begin() const { return Segments.begin(); } diff --git a/lib/ProfileData/Coverage/CoverageMapping.cpp b/lib/ProfileData/Coverage/CoverageMapping.cpp index e8431d70047..81e1c6bc645 100644 --- a/lib/ProfileData/Coverage/CoverageMapping.cpp +++ b/lib/ProfileData/Coverage/CoverageMapping.cpp @@ -318,59 +318,130 @@ class SegmentBuilder { SegmentBuilder(std::vector &Segments) : Segments(Segments) {} - /// Start a segment with no count specified. - void startSegment(unsigned Line, unsigned Col) { - DEBUG(dbgs() << "Top level segment at " << Line << ":" << Col << "\n"); - Segments.emplace_back(Line, Col, /*IsRegionEntry=*/false); - } + /// Emit a segment with the count from \p Region starting at \p StartLoc. + // + /// \p IsRegionEntry: The segment is at the start of a new region. + /// \p EmitSkippedRegion: The segment must be emitted as a skipped region. + void startSegment(const CountedRegion &Region, LineColPair StartLoc, + bool IsRegionEntry, bool EmitSkippedRegion = false) { + bool HasCount = !EmitSkippedRegion && + (Region.Kind != CounterMappingRegion::SkippedRegion); + + // If the new segment wouldn't affect coverage rendering, skip it. + if (!Segments.empty() && !IsRegionEntry && !EmitSkippedRegion) { + const auto &Last = Segments.back(); + if (Last.HasCount == HasCount && Last.Count == Region.ExecutionCount && + !Last.IsRegionEntry) + return; + } - /// Start a segment with the given Region's count. - void startSegment(unsigned Line, unsigned Col, bool IsRegionEntry, - const CountedRegion &Region) { - // Avoid creating empty regions. - if (!Segments.empty() && Segments.back().Line == Line && - Segments.back().Col == Col) - Segments.pop_back(); - DEBUG(dbgs() << "Segment at " << Line << ":" << Col); - // Set this region's count. - if (Region.Kind != CounterMappingRegion::SkippedRegion) { - DEBUG(dbgs() << " with count " << Region.ExecutionCount); - Segments.emplace_back(Line, Col, Region.ExecutionCount, IsRegionEntry); - } else - Segments.emplace_back(Line, Col, IsRegionEntry); - DEBUG(dbgs() << "\n"); + if (HasCount) + Segments.emplace_back(StartLoc.first, StartLoc.second, + Region.ExecutionCount, IsRegionEntry); + else + Segments.emplace_back(StartLoc.first, StartLoc.second, IsRegionEntry); + + DEBUG({ + const auto &Last = Segments.back(); + dbgs() << "Segment at " << Last.Line << ":" << Last.Col + << " (count = " << Last.Count << ")" + << (Last.IsRegionEntry ? ", RegionEntry" : "") + << (!Last.HasCount ? ", Skipped" : "") << "\n"; + }); } - /// Start a segment for the given region. - void startSegment(const CountedRegion &Region) { - startSegment(Region.LineStart, Region.ColumnStart, true, Region); - } + /// Emit segments for active regions which end before \p Loc. + /// + /// \p Loc: The start location of the next region. If None, all active + /// regions are completed. + /// \p FirstCompletedRegion: Index of the first completed region. + void completeRegionsUntil(Optional Loc, + unsigned FirstCompletedRegion) { + // Sort the completed regions by end location. This makes it simple to + // emit closing segments in sorted order. + auto CompletedRegionsIt = ActiveRegions.begin() + FirstCompletedRegion; + std::stable_sort(CompletedRegionsIt, ActiveRegions.end(), + [](const CountedRegion *L, const CountedRegion *R) { + return L->endLoc() < R->endLoc(); + }); + + // Emit segments for all completed regions. + for (unsigned I = FirstCompletedRegion + 1, E = ActiveRegions.size(); I < E; + ++I) { + const auto *CompletedRegion = ActiveRegions[I]; + assert((!Loc || CompletedRegion->endLoc() <= *Loc) && + "Completed region ends after start of new region"); + + const auto *PrevCompletedRegion = ActiveRegions[I - 1]; + auto CompletedSegmentLoc = PrevCompletedRegion->endLoc(); + + // Don't emit any more segments if they start where the new region begins. + if (Loc && CompletedSegmentLoc == *Loc) + break; + + // Don't emit a segment if the next completed region ends at the same + // location as this one. + if (CompletedSegmentLoc == CompletedRegion->endLoc()) + continue; - /// Pop the top region off of the active stack, starting a new segment with - /// the containing Region's count. - void popRegion() { - const CountedRegion *Active = ActiveRegions.back(); - unsigned Line = Active->LineEnd, Col = Active->ColumnEnd; - ActiveRegions.pop_back(); - if (ActiveRegions.empty()) - startSegment(Line, Col); - else - startSegment(Line, Col, false, *ActiveRegions.back()); + startSegment(*CompletedRegion, CompletedSegmentLoc, false); + } + + auto Last = ActiveRegions.back(); + if (FirstCompletedRegion && Last->endLoc() != *Loc) { + // If there's a gap after the end of the last completed region and the + // start of the new region, use the last active region to fill the gap. + startSegment(*ActiveRegions[FirstCompletedRegion - 1], Last->endLoc(), + false); + } else if (!FirstCompletedRegion && (!Loc || *Loc != Last->endLoc())) { + // Emit a skipped segment if there are no more active regions. This + // ensures that gaps between functions are marked correctly. + startSegment(*Last, Last->endLoc(), false, true); + } + + // Pop the completed regions. + ActiveRegions.erase(CompletedRegionsIt, ActiveRegions.end()); } void buildSegmentsImpl(ArrayRef Regions) { - for (const auto &Region : Regions) { - // Pop any regions that end before this one starts. - while (!ActiveRegions.empty() && - ActiveRegions.back()->endLoc() <= Region.startLoc()) - popRegion(); - // Add this region to the stack. - ActiveRegions.push_back(&Region); - startSegment(Region); + for (const auto &CR : enumerate(Regions)) { + auto CurStartLoc = CR.value().startLoc(); + + // Active regions which end before the current region need to be popped. + auto CompletedRegions = + std::stable_partition(ActiveRegions.begin(), ActiveRegions.end(), + [&](const CountedRegion *Region) { + return !(Region->endLoc() <= CurStartLoc); + }); + if (CompletedRegions != ActiveRegions.end()) { + unsigned FirstCompletedRegion = + std::distance(ActiveRegions.begin(), CompletedRegions); + completeRegionsUntil(CurStartLoc, FirstCompletedRegion); + } + + // Try to emit a segment for the current region. + if (CurStartLoc == CR.value().endLoc()) { + // Avoid making zero-length regions active. If it's the last region, + // emit a skipped segment. Otherwise use its predecessor's count. + const bool Skipped = (CR.index() + 1) == Regions.size(); + startSegment(ActiveRegions.empty() ? CR.value() : *ActiveRegions.back(), + CurStartLoc, true, Skipped); + continue; + } + if (CR.index() + 1 == Regions.size() || + CurStartLoc != Regions[CR.index() + 1].startLoc()) { + // Emit a segment if the next region doesn't start at the same location + // as this one. + startSegment(CR.value(), CurStartLoc, true); + } + + // This region is active (i.e not completed). + ActiveRegions.push_back(&CR.value()); } - // Pop any regions that are left in the stack. - while (!ActiveRegions.empty()) - popRegion(); + + // Complete any remaining active regions. + if (!ActiveRegions.empty()) + completeRegionsUntil(None, 0); } /// Sort a nested sequence of regions from a single file. @@ -431,7 +502,7 @@ class SegmentBuilder { } public: - /// Build a list of CoverageSegments from a list of Regions. + /// Build a sorted list of CoverageSegments from a list of Regions. static std::vector buildSegments(MutableArrayRef Regions) { std::vector Segments; @@ -440,7 +511,28 @@ public: sortNestedRegions(Regions); ArrayRef CombinedRegions = combineRegions(Regions); + DEBUG({ + dbgs() << "Combined regions:\n"; + for (const auto &CR : CombinedRegions) + dbgs() << " " << CR.LineStart << ":" << CR.ColumnStart << " -> " + << CR.LineEnd << ":" << CR.ColumnEnd + << " (count=" << CR.ExecutionCount << ")\n"; + }); + Builder.buildSegmentsImpl(CombinedRegions); + +#ifndef NDEBUG + for (unsigned I = 1, E = Segments.size(); I < E; ++I) { + const auto &L = Segments[I - 1]; + const auto &R = Segments[I]; + if (!(L.Line < R.Line) && !(L.Line == R.Line && L.Col < R.Col)) { + DEBUG(dbgs() << " ! Segment " << L.Line << ":" << L.Col + << " followed by " << R.Line << ":" << R.Col << "\n"); + assert(false && "Coverage segments not unique or sorted"); + } + } +#endif + return Segments; } }; diff --git a/test/tools/llvm-cov/deferred-region.cpp b/test/tools/llvm-cov/deferred-region.cpp index 905c78b1c8e..2868e1f0c89 100644 --- a/test/tools/llvm-cov/deferred-region.cpp +++ b/test/tools/llvm-cov/deferred-region.cpp @@ -5,7 +5,7 @@ void foo(int x) { return; // CHECK: [[@LINE]]|{{ +}}1| } -} // CHECK: [[@LINE]]|{{ +}}2| +} // CHECK: [[@LINE]]|{{ +}}1| void bar() { return; @@ -103,11 +103,9 @@ int main() { // MARKER-NEXT: Highlighted line 47, 14 -> 21 // MARKER-NEXT: Highlighted line 47, 21 -> 23 // MARKER-NEXT: Highlighted line 47, 23 -> 25 -// MARKER-NEXT: Highlighted line 47, 25 -> ? // MARKER-NEXT: Marker at 47:7 = 0 // MARKER-NEXT: Marker at 47:14 = 0 // MARKER-NEXT: Marker at 47:23 = 0 -// MARKER-NEXT: Highlighted line 48, 1 -> 6 // MARKER-NEXT: Highlighted line 51, 7 -> 20 // MARKER-NEXT: Marker at 51:7 = 0 // MARKER-NEXT: Marker at 53:5 = 1 diff --git a/test/tools/llvm-cov/showHighlightedRanges.cpp b/test/tools/llvm-cov/showHighlightedRanges.cpp index 3b457faccd2..bfcdf76f4ad 100644 --- a/test/tools/llvm-cov/showHighlightedRanges.cpp +++ b/test/tools/llvm-cov/showHighlightedRanges.cpp @@ -10,7 +10,7 @@ void func2(int x) { while(x >= 9) { return; --x; // SHARED: Highlighted line [[@LINE]], 7 -> - } // SHARED: Highlighted line [[@LINE]], 1 -> 6 + } int i = 0; // SHARED: Highlighted line [[@LINE]], 5 -> } // SHARED: Highlighted line [[@LINE]], 1 -> 4 } diff --git a/unittests/ProfileData/CoverageMappingTest.cpp b/unittests/ProfileData/CoverageMappingTest.cpp index 7b3abf79d33..f5c2bd78fe5 100644 --- a/unittests/ProfileData/CoverageMappingTest.cpp +++ b/unittests/ProfileData/CoverageMappingTest.cpp @@ -174,9 +174,12 @@ struct CoverageMappingTest : ::testing::TestWithParam> { } void addCMR(Counter C, StringRef File, unsigned LS, unsigned CS, unsigned LE, - unsigned CE) { - InputFunctions.back().Regions.push_back(CounterMappingRegion::makeRegion( - C, getFileIndexForFunction(File), LS, CS, LE, CE)); + unsigned CE, bool Skipped = false) { + auto &Regions = InputFunctions.back().Regions; + unsigned FileID = getFileIndexForFunction(File); + Regions.push_back( + Skipped ? CounterMappingRegion::makeSkipped(FileID, LS, CS, LE, CE) + : CounterMappingRegion::makeRegion(C, FileID, LS, CS, LE, CE)); } void addExpansionCMR(StringRef File, StringRef ExpandedFile, unsigned LS, @@ -362,6 +365,238 @@ TEST_P(CoverageMappingTest, load_coverage_for_several_functions) { } } +TEST_P(CoverageMappingTest, create_combined_regions) { + ProfileWriter.addRecord({"func1", 0x1234, {1, 2, 3}}, Err); + startFunction("func1", 0x1234); + + // Given regions which start at the same location, emit a segment for the + // last region. + addCMR(Counter::getCounter(0), "file1", 1, 1, 2, 2); + addCMR(Counter::getCounter(1), "file1", 1, 1, 2, 2); + addCMR(Counter::getCounter(2), "file1", 1, 1, 2, 2); + + EXPECT_THAT_ERROR(loadCoverageMapping(), Succeeded()); + const auto FunctionRecords = LoadedCoverage->getCoveredFunctions(); + const auto &FunctionRecord = *FunctionRecords.begin(); + CoverageData Data = LoadedCoverage->getCoverageForFunction(FunctionRecord); + std::vector Segments(Data.begin(), Data.end()); + + ASSERT_EQ(2U, Segments.size()); + EXPECT_EQ(CoverageSegment(1, 1, 6, true), Segments[0]); + EXPECT_EQ(CoverageSegment(2, 2, false), Segments[1]); +} + +TEST_P(CoverageMappingTest, skipped_segments_have_no_count) { + ProfileWriter.addRecord({"func1", 0x1234, {1}}, Err); + startFunction("func1", 0x1234); + + addCMR(Counter::getCounter(0), "file1", 1, 1, 5, 5); + addCMR(Counter::getCounter(0), "file1", 5, 1, 5, 5, /*Skipped=*/true); + + EXPECT_THAT_ERROR(loadCoverageMapping(), Succeeded()); + const auto FunctionRecords = LoadedCoverage->getCoveredFunctions(); + const auto &FunctionRecord = *FunctionRecords.begin(); + CoverageData Data = LoadedCoverage->getCoverageForFunction(FunctionRecord); + std::vector Segments(Data.begin(), Data.end()); + + ASSERT_EQ(3U, Segments.size()); + EXPECT_EQ(CoverageSegment(1, 1, 1, true), Segments[0]); + EXPECT_EQ(CoverageSegment(5, 1, true), Segments[1]); + EXPECT_EQ(CoverageSegment(5, 5, false), Segments[2]); +} + +TEST_P(CoverageMappingTest, multiple_regions_end_after_parent_ends) { + ProfileWriter.addRecord({"func1", 0x1234, {1, 0}}, Err); + startFunction("func1", 0x1234); + + // 1| F{ a{ + // 2| + // 3| a} b{ c{ + // 4| + // 5| b} + // 6| + // 7| c} d{ e{ + // 8| + // 9| d} e} F} + addCMR(Counter::getCounter(0), "file1", 1, 1, 9, 9); //< F + addCMR(Counter::getCounter(0), "file1", 1, 1, 3, 5); //< a + addCMR(Counter::getCounter(0), "file1", 3, 5, 5, 4); //< b + addCMR(Counter::getCounter(1), "file1", 3, 5, 7, 3); //< c + addCMR(Counter::getCounter(1), "file1", 7, 3, 9, 2); //< d + addCMR(Counter::getCounter(1), "file1", 7, 7, 9, 7); //< e + + EXPECT_THAT_ERROR(loadCoverageMapping(), Succeeded()); + const auto FunctionRecords = LoadedCoverage->getCoveredFunctions(); + const auto &FunctionRecord = *FunctionRecords.begin(); + CoverageData Data = LoadedCoverage->getCoverageForFunction(FunctionRecord); + std::vector Segments(Data.begin(), Data.end()); + + // Old output (not sorted or unique): + // Segment at 1:1 with count 1 + // Segment at 1:1 with count 1 + // Segment at 3:5 with count 1 + // Segment at 3:5 with count 0 + // Segment at 3:5 with count 1 + // Segment at 5:4 with count 0 + // Segment at 7:3 with count 1 + // Segment at 7:3 with count 0 + // Segment at 7:7 with count 0 + // Segment at 9:7 with count 0 + // Segment at 9:2 with count 1 + // Top level segment at 9:9 + + // New output (sorted and unique): + // Segment at 1:1 (count = 1), RegionEntry + // Segment at 3:5 (count = 1), RegionEntry + // Segment at 5:4 (count = 0) + // Segment at 7:3 (count = 0), RegionEntry + // Segment at 7:7 (count = 0), RegionEntry + // Segment at 9:2 (count = 0) + // Segment at 9:7 (count = 1) + // Segment at 9:9 (count = 0), Skipped + + ASSERT_EQ(8U, Segments.size()); + EXPECT_EQ(CoverageSegment(1, 1, 1, true), Segments[0]); + EXPECT_EQ(CoverageSegment(3, 5, 1, true), Segments[1]); + EXPECT_EQ(CoverageSegment(5, 4, 0, false), Segments[2]); + EXPECT_EQ(CoverageSegment(7, 3, 0, true), Segments[3]); + EXPECT_EQ(CoverageSegment(7, 7, 0, true), Segments[4]); + EXPECT_EQ(CoverageSegment(9, 2, 0, false), Segments[5]); + EXPECT_EQ(CoverageSegment(9, 7, 1, false), Segments[6]); + EXPECT_EQ(CoverageSegment(9, 9, false), Segments[7]); +} + +TEST_P(CoverageMappingTest, dont_emit_redundant_segments) { + ProfileWriter.addRecord({"func1", 0x1234, {1, 1}}, Err); + startFunction("func1", 0x1234); + + addCMR(Counter::getCounter(0), "file1", 1, 1, 4, 4); + addCMR(Counter::getCounter(1), "file1", 2, 2, 5, 5); + addCMR(Counter::getCounter(0), "file1", 3, 3, 6, 6); + + EXPECT_THAT_ERROR(loadCoverageMapping(), Succeeded()); + const auto FunctionRecords = LoadedCoverage->getCoveredFunctions(); + const auto &FunctionRecord = *FunctionRecords.begin(); + CoverageData Data = LoadedCoverage->getCoverageForFunction(FunctionRecord); + std::vector Segments(Data.begin(), Data.end()); + + ASSERT_EQ(5U, Segments.size()); + EXPECT_EQ(CoverageSegment(1, 1, 1, true), Segments[0]); + EXPECT_EQ(CoverageSegment(2, 2, 1, true), Segments[1]); + EXPECT_EQ(CoverageSegment(3, 3, 1, true), Segments[2]); + EXPECT_EQ(CoverageSegment(4, 4, 1, false), Segments[3]); + // A closing segment starting at 5:5 would be redundant: it would have the + // same count as the segment starting at 4:4, and has all the same metadata. + EXPECT_EQ(CoverageSegment(6, 6, false), Segments[4]); +} + +TEST_P(CoverageMappingTest, dont_emit_closing_segment_at_new_region_start) { + ProfileWriter.addRecord({"func1", 0x1234, {1}}, Err); + startFunction("func1", 0x1234); + + addCMR(Counter::getCounter(0), "file1", 1, 1, 6, 5); + addCMR(Counter::getCounter(0), "file1", 2, 2, 6, 5); + addCMR(Counter::getCounter(0), "file1", 3, 3, 6, 5); + addCMR(Counter::getCounter(0), "file1", 6, 5, 7, 7); + + EXPECT_THAT_ERROR(loadCoverageMapping(), Succeeded()); + const auto FunctionRecords = LoadedCoverage->getCoveredFunctions(); + const auto &FunctionRecord = *FunctionRecords.begin(); + CoverageData Data = LoadedCoverage->getCoverageForFunction(FunctionRecord); + std::vector Segments(Data.begin(), Data.end()); + + ASSERT_EQ(5U, Segments.size()); + EXPECT_EQ(CoverageSegment(1, 1, 1, true), Segments[0]); + EXPECT_EQ(CoverageSegment(2, 2, 1, true), Segments[1]); + EXPECT_EQ(CoverageSegment(3, 3, 1, true), Segments[2]); + EXPECT_EQ(CoverageSegment(6, 5, 1, true), Segments[3]); + // The old segment builder would get this wrong by emitting multiple segments + // which start at 6:5 (a few of which were skipped segments). We should just + // get a segment for the region entry. + EXPECT_EQ(CoverageSegment(7, 7, false), Segments[4]); +} + +TEST_P(CoverageMappingTest, handle_consecutive_regions_with_zero_length) { + ProfileWriter.addRecord({"func1", 0x1234, {1, 2}}, Err); + startFunction("func1", 0x1234); + + addCMR(Counter::getCounter(0), "file1", 1, 1, 1, 1); + addCMR(Counter::getCounter(1), "file1", 1, 1, 1, 1); + addCMR(Counter::getCounter(0), "file1", 1, 1, 1, 1); + addCMR(Counter::getCounter(1), "file1", 1, 1, 1, 1); + addCMR(Counter::getCounter(0), "file1", 1, 1, 1, 1); + + EXPECT_THAT_ERROR(loadCoverageMapping(), Succeeded()); + const auto FunctionRecords = LoadedCoverage->getCoveredFunctions(); + const auto &FunctionRecord = *FunctionRecords.begin(); + CoverageData Data = LoadedCoverage->getCoverageForFunction(FunctionRecord); + std::vector Segments(Data.begin(), Data.end()); + + ASSERT_EQ(1U, Segments.size()); + EXPECT_EQ(CoverageSegment(1, 1, true), Segments[0]); + // We need to get a skipped segment starting at 1:1. In this case there is + // also a region entry at 1:1. +} + +TEST_P(CoverageMappingTest, handle_sandwiched_zero_length_region) { + ProfileWriter.addRecord({"func1", 0x1234, {2, 1}}, Err); + startFunction("func1", 0x1234); + + addCMR(Counter::getCounter(0), "file1", 1, 5, 4, 4); + addCMR(Counter::getCounter(1), "file1", 1, 9, 1, 50); + addCMR(Counter::getCounter(1), "file1", 2, 7, 2, 34); + addCMR(Counter::getCounter(1), "file1", 3, 5, 3, 21); + addCMR(Counter::getCounter(1), "file1", 3, 21, 3, 21); + addCMR(Counter::getCounter(1), "file1", 4, 12, 4, 17); + + EXPECT_THAT_ERROR(loadCoverageMapping(), Succeeded()); + const auto FunctionRecords = LoadedCoverage->getCoveredFunctions(); + const auto &FunctionRecord = *FunctionRecords.begin(); + CoverageData Data = LoadedCoverage->getCoverageForFunction(FunctionRecord); + std::vector Segments(Data.begin(), Data.end()); + + ASSERT_EQ(10U, Segments.size()); + EXPECT_EQ(CoverageSegment(1, 5, 2, true), Segments[0]); + EXPECT_EQ(CoverageSegment(1, 9, 1, true), Segments[1]); + EXPECT_EQ(CoverageSegment(1, 50, 2, false), Segments[2]); + EXPECT_EQ(CoverageSegment(2, 7, 1, true), Segments[3]); + EXPECT_EQ(CoverageSegment(2, 34, 2, false), Segments[4]); + EXPECT_EQ(CoverageSegment(3, 5, 1, true), Segments[5]); + EXPECT_EQ(CoverageSegment(3, 21, 2, true), Segments[6]); + // Handle the zero-length region by creating a segment with its predecessor's + // count (i.e the count from 1:5 -> 4:4). + EXPECT_EQ(CoverageSegment(4, 4, false), Segments[7]); + // The area between 4:4 and 4:12 is skipped. + EXPECT_EQ(CoverageSegment(4, 12, 1, true), Segments[8]); + EXPECT_EQ(CoverageSegment(4, 17, false), Segments[9]); +} + +TEST_P(CoverageMappingTest, handle_last_completed_region) { + ProfileWriter.addRecord({"func1", 0x1234, {1, 2, 3, 4}}, Err); + startFunction("func1", 0x1234); + + addCMR(Counter::getCounter(0), "file1", 1, 1, 8, 8); + addCMR(Counter::getCounter(1), "file1", 2, 2, 5, 5); + addCMR(Counter::getCounter(2), "file1", 3, 3, 4, 4); + addCMR(Counter::getCounter(3), "file1", 6, 6, 7, 7); + + EXPECT_THAT_ERROR(loadCoverageMapping(), Succeeded()); + const auto FunctionRecords = LoadedCoverage->getCoveredFunctions(); + const auto &FunctionRecord = *FunctionRecords.begin(); + CoverageData Data = LoadedCoverage->getCoverageForFunction(FunctionRecord); + std::vector Segments(Data.begin(), Data.end()); + + ASSERT_EQ(8U, Segments.size()); + EXPECT_EQ(CoverageSegment(1, 1, 1, true), Segments[0]); + EXPECT_EQ(CoverageSegment(2, 2, 2, true), Segments[1]); + EXPECT_EQ(CoverageSegment(3, 3, 3, true), Segments[2]); + EXPECT_EQ(CoverageSegment(4, 4, 2, false), Segments[3]); + EXPECT_EQ(CoverageSegment(5, 5, 1, false), Segments[4]); + EXPECT_EQ(CoverageSegment(6, 6, 4, true), Segments[5]); + EXPECT_EQ(CoverageSegment(7, 7, 1, false), Segments[6]); + EXPECT_EQ(CoverageSegment(8, 8, false), Segments[7]); +} + TEST_P(CoverageMappingTest, expansion_gets_first_counter) { startFunction("func", 0x1234); addCMR(Counter::getCounter(1), "foo", 10, 1, 10, 2); -- 2.50.1