Index: llvm/trunk/include/llvm/ProfileData/Coverage/CoverageMapping.h =================================================================== --- llvm/trunk/include/llvm/ProfileData/Coverage/CoverageMapping.h +++ llvm/trunk/include/llvm/ProfileData/Coverage/CoverageMapping.h @@ -470,6 +470,8 @@ /// 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(); } Index: llvm/trunk/lib/ProfileData/Coverage/CoverageMapping.cpp =================================================================== --- llvm/trunk/lib/ProfileData/Coverage/CoverageMapping.cpp +++ llvm/trunk/lib/ProfileData/Coverage/CoverageMapping.cpp @@ -318,59 +318,130 @@ 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); - } - - /// 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"); - } - - /// Start a segment for the given region. - void startSegment(const CountedRegion &Region) { - startSegment(Region.LineStart, Region.ColumnStart, true, Region); - } - - /// 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); + /// 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; + } + + if (HasCount) + Segments.emplace_back(StartLoc.first, StartLoc.second, + Region.ExecutionCount, IsRegionEntry); else - startSegment(Line, Col, false, *ActiveRegions.back()); + 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"; + }); + } + + /// 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; + + 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); - } - // Pop any regions that are left in the stack. - while (!ActiveRegions.empty()) - popRegion(); + 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()); + } + + // 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 @@ } 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 @@ 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; } }; Index: llvm/trunk/test/tools/llvm-cov/deferred-region.cpp =================================================================== --- llvm/trunk/test/tools/llvm-cov/deferred-region.cpp +++ llvm/trunk/test/tools/llvm-cov/deferred-region.cpp @@ -5,7 +5,7 @@ return; // CHECK: [[@LINE]]|{{ +}}1| } -} // CHECK: [[@LINE]]|{{ +}}2| +} // CHECK: [[@LINE]]|{{ +}}1| void bar() { return; @@ -103,11 +103,9 @@ // 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 Index: llvm/trunk/test/tools/llvm-cov/showHighlightedRanges.cpp =================================================================== --- llvm/trunk/test/tools/llvm-cov/showHighlightedRanges.cpp +++ llvm/trunk/test/tools/llvm-cov/showHighlightedRanges.cpp @@ -10,7 +10,7 @@ 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 } Index: llvm/trunk/unittests/ProfileData/CoverageMappingTest.cpp =================================================================== --- llvm/trunk/unittests/ProfileData/CoverageMappingTest.cpp +++ llvm/trunk/unittests/ProfileData/CoverageMappingTest.cpp @@ -174,9 +174,12 @@ } 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, 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);