[Coverage] Support for making test data for more than one function.

[ikudrin]

Summary

It is required for creating more complex unit tests.

[vsk]

Could you explain the difference between global file indices and an index in a function?

llvm/trunk/unittests/ProfileData/CoverageMappingTest.cpp

86

Please add a comment explaining the what the map contains. Also, would an llvm::SmallDenseMap work here?

[ikudrin]

In D18758#393415, @vsk wrote:

Could you explain the difference between global file indices and an index in a function?

This is intended to be closer to the serialization format of coverage mapping. All functions share the same array of file names, but each function has its own set of files and maps its local indices to global ones. See RawCoverageMappingReader::read().

[davidxl]

llvm/trunk/unittests/ProfileData/CoverageMappingTest.cpp

56

Is this field needed? It can be a local variable.

174

Split this function into two methods:

1. writeAndReadCoverageRegions
2. loadCoverageMapping

loadCoverageMapping calls 1) followed by call to CoverageMapping::load

Calls to readProfCount can also be folded into 2).

Function 1) can be called in many other places as well.

[ikudrin]

• Rebased on the top commit.
• Made Expressions local.
• Added a comment for ReverseVirtualFileMapping and changed its type to llvm::SmallDenseMap.
• Extracted writeAndReadCoverageRegions from loadCoverageMapping.
• Added a call to readProfCount into loadCoverageMapping.

[davidxl]

nice cleanup!

llvm/trunk/unittests/ProfileData/CoverageMappingTest.cpp

86

an --> the

88

Is this mapping strictly needed? Can global file index be used without creating function level file index?

[davidxl]

lgtm.

llvm/trunk/unittests/ProfileData/CoverageMappingTest.cpp

88

It is needed. The virtual FileId for each function record is the index to the array of region sub-arrays in the coverage mapping.

Perhaps you can add more comments to clarify.

118

Add a comment to this method. Something in the line of ..

Returns the file index of file 'Name' for the current function. It also computes the global file index
for the file and maps the global index to the local index that is returned (ReverseVirtualFileMapping).
The ReverseVirtualFileMapping is used to create the virtual file mapping (from local fileId to global Index)
in the head of the per-function coverage mapping data.

[ikudrin]

Thanks a lot for the comments!

llvm/trunk/unittests/ProfileData/CoverageMappingTest.cpp

if (S.HasCount)
     *os << S.Count << ", ";
   *os << (S.IsRegionEntry ? "true" : "false") << ")";
 }
 }
 }
 
 namespace {
 
-struct OneFunctionCoverageReader : CoverageMappingReader {
+struct OutputFunctionCoverageData {
   StringRef Name;
   uint64_t Hash;
   std::vector<StringRef> Filenames;
-  ArrayRef<CounterMappingRegion> Regions;
-  bool Done;
-
-  OneFunctionCoverageReader(StringRef Name, uint64_t Hash,
-                            ArrayRef<StringRef> Filenames,
-                            ArrayRef<CounterMappingRegion> Regions)
-      : Name(Name), Hash(Hash), Filenames(Filenames), Regions(Regions),
-        Done(false) {}
-
-  std::error_code readNextRecord(CoverageMappingRecord &Record) override {
-    if (Done)
-      return instrprof_error::eof;
-    Done = true;
+  std::vector<CounterExpression> Expressions;
+  std::vector<CounterMappingRegion> Regions;
 
+  void fillCoverageMappingRecord(CoverageMappingRecord &Record) const {
     Record.FunctionName = Name;
     Record.FunctionHash = Hash;
     Record.Filenames = Filenames;
-    Record.Expressions = {};
+    Record.Expressions = Expressions;
     Record.MappingRegions = Regions;
+  }
+};
+
+struct CoverageMappingReaderMock : CoverageMappingReader {
+  ArrayRef<OutputFunctionCoverageData> Functions;
+
+  CoverageMappingReaderMock(ArrayRef<OutputFunctionCoverageData> Functions)
+      : Functions(Functions) {}
+
+  std::error_code readNextRecord(CoverageMappingRecord &Record) override {
+    if (Functions.empty())
+      return instrprof_error::eof;
+
+    Functions.front().fillCoverageMappingRecord(Record);
+    Functions = Functions.slice(1);
+
     return instrprof_error::success;
   }
 };
 
+struct InputFunctionCoverageData {
+  std::map<unsigned, unsigned> ReverseVirtualFileMapping;
+  std::string Name;
+  uint64_t Hash;
+  std::vector<CounterMappingRegion> Regions;
+
+  InputFunctionCoverageData(std::string Name, uint64_t Hash)
+      : Name(std::move(Name)), Hash(Hash) {}
+};
+
 struct CoverageMappingTest : ::testing::Test {
   StringMap<unsigned> Files;
-  std::vector<CounterMappingRegion> InputCMRs;
-
-  std::vector<StringRef> OutputFiles;
-  std::vector<CounterExpression> OutputExpressions;
-  std::vector<CounterMappingRegion> OutputCMRs;
+  std::vector<InputFunctionCoverageData> InputFunctions;
+  std::vector<OutputFunctionCoverageData> OutputFunctions;
 
   InstrProfWriter ProfileWriter;
   std::unique_ptr<IndexedInstrProfReader> ProfileReader;
 
   std::unique_ptr<CoverageMapping> LoadedCoverage;
 
   void SetUp() override {
     ProfileWriter.setOutputSparse(false);
   }
 
-  unsigned getFile(StringRef Name) {
+  unsigned getGlobalFileIndex(StringRef Name) {
     auto R = Files.find(Name);
     if (R != Files.end())
       return R->second;
     unsigned Index = Files.size();
     Files.emplace_second(Name, Index);
     return Index;
   }
 
+  unsigned getFileIndexForFunction(StringRef Name) {
+    unsigned GlobalIndex = getGlobalFileIndex(Name);
+    auto &CurrentFunctionFileMapping =
+        InputFunctions.back().ReverseVirtualFileMapping;
+    auto R = CurrentFunctionFileMapping.find(GlobalIndex);
+    if (R != CurrentFunctionFileMapping.end())
+      return R->second;
+    unsigned IndexInFunction = CurrentFunctionFileMapping.size();
+    CurrentFunctionFileMapping.emplace(GlobalIndex, IndexInFunction);
+    return IndexInFunction;
+  }
+
+  void startFunction(StringRef FuncName, uint64_t Hash) {
+    InputFunctions.emplace_back(FuncName.str(), Hash);
+  }
+
   void addCMR(Counter C, StringRef File, unsigned LS, unsigned CS, unsigned LE,
               unsigned CE) {
-    InputCMRs.push_back(
-        CounterMappingRegion::makeRegion(C, getFile(File), LS, CS, LE, CE));
+    InputFunctions.back().Regions.push_back(CounterMappingRegion::makeRegion(
+        C, getFileIndexForFunction(File), LS, CS, LE, CE));
   }
 
   void addExpansionCMR(StringRef File, StringRef ExpandedFile, unsigned LS,
                        unsigned CS, unsigned LE, unsigned CE) {
-    InputCMRs.push_back(CounterMappingRegion::makeExpansion(
-        getFile(File), getFile(ExpandedFile), LS, CS, LE, CE));
+    InputFunctions.back().Regions.push_back(CounterMappingRegion::makeExpansion(
+        getFileIndexForFunction(File), getFileIndexForFunction(ExpandedFile),
+        LS, CS, LE, CE));
   }
 
-  std::string writeCoverageRegions() {
-    SmallVector<unsigned, 8> FileIDs(Files.size());
-    for (unsigned I = 0; I < FileIDs.size(); ++I)
-      FileIDs[I] = I;
+  std::string writeCoverageRegions(InputFunctionCoverageData &Data) {
+    SmallVector<unsigned, 8> FileIDs(Data.ReverseVirtualFileMapping.size());
+    for (const auto &E : Data.ReverseVirtualFileMapping)
+      FileIDs[E.second] = E.first;
     std::string Coverage;
     llvm::raw_string_ostream OS(Coverage);
-    CoverageMappingWriter(FileIDs, None, InputCMRs).write(OS);
+    CoverageMappingWriter(FileIDs, None, Data.Regions).write(OS);
     return OS.str();
   }
 
-  void readCoverageRegions(std::string Coverage) {
+  void readCoverageRegions(std::string Coverage,
+                           OutputFunctionCoverageData &Data) {
     SmallVector<StringRef, 8> Filenames(Files.size());
     for (const auto &E : Files)
       Filenames[E.getValue()] = E.getKey();
-    RawCoverageMappingReader Reader(Coverage, Filenames, OutputFiles,
-                                    OutputExpressions, OutputCMRs);
+    RawCoverageMappingReader Reader(Coverage, Filenames, Data.Filenames,
+                                    Data.Expressions, Data.Regions);
     ASSERT_TRUE(NoError(Reader.read()));
   }
 
   void readProfCounts() {
     auto Profile = ProfileWriter.writeBuffer();
     auto ReaderOrErr = IndexedInstrProfReader::create(std::move(Profile));
     ASSERT_TRUE(NoError(ReaderOrErr.getError()));
     ProfileReader = std::move(ReaderOrErr.get());
   }
 
-  void loadCoverageMapping(StringRef FuncName, uint64_t Hash,
-                           bool EmitFilenames = true) {
-    std::string Regions = writeCoverageRegions();
-    readCoverageRegions(Regions);
-
-    SmallVector<StringRef, 8> Filenames;
-    if (EmitFilenames) {
-      Filenames.resize(Files.size());
-      for (const auto &E : Files)
-        Filenames[E.getValue()] = E.getKey();
+  void loadCoverageMapping(bool EmitFilenames = true) {
+    OutputFunctions.resize(InputFunctions.size());
+    for (unsigned I = 0; I < InputFunctions.size(); ++I) {
+      std::string Regions = writeCoverageRegions(InputFunctions[I]);
+      readCoverageRegions(Regions, OutputFunctions[I]);
+      OutputFunctions[I].Name = InputFunctions[I].Name;
+      OutputFunctions[I].Hash = InputFunctions[I].Hash;
+      if (!EmitFilenames)
+        OutputFunctions[I].Filenames.clear();
     }
-    OneFunctionCoverageReader CovReader(FuncName, Hash, Filenames, OutputCMRs);
+
+    CoverageMappingReaderMock CovReader(OutputFunctions);
     auto CoverageOrErr = CoverageMapping::load(CovReader, *ProfileReader);
     ASSERT_TRUE(NoError(CoverageOrErr.getError()));
     LoadedCoverage = std::move(CoverageOrErr.get());
   }
 };
 
 struct MaybeSparseCoverageMappingTest
     : public CoverageMappingTest,
       public ::testing::WithParamInterface<bool> {
   void SetUp() {
     CoverageMappingTest::SetUp();
     ProfileWriter.setOutputSparse(GetParam());
   }
 };
 
 TEST_P(MaybeSparseCoverageMappingTest, basic_write_read) {
+  startFunction("func", 0x1234);
   addCMR(Counter::getCounter(0), "foo", 1, 1, 1, 1);
   addCMR(Counter::getCounter(1), "foo", 2, 1, 2, 2);
   addCMR(Counter::getZero(),     "foo", 3, 1, 3, 4);
   addCMR(Counter::getCounter(2), "foo", 4, 1, 4, 8);
   addCMR(Counter::getCounter(3), "bar", 1, 2, 3, 4);
-  std::string Coverage = writeCoverageRegions();
-  readCoverageRegions(Coverage);
+  InputFunctionCoverageData &Input = InputFunctions.back();
+  std::string Coverage = writeCoverageRegions(Input);
+  OutputFunctionCoverageData Output;
+  readCoverageRegions(Coverage, Output);
 
-  size_t N = makeArrayRef(InputCMRs).size();
-  ASSERT_EQ(N, OutputCMRs.size());
+  size_t N = makeArrayRef(Input.Regions).size();
+  ASSERT_EQ(N, Output.Regions.size());
   for (size_t I = 0; I < N; ++I) {
-    ASSERT_EQ(InputCMRs[I].Count,      OutputCMRs[I].Count);
-    ASSERT_EQ(InputCMRs[I].FileID,     OutputCMRs[I].FileID);
-    ASSERT_EQ(InputCMRs[I].startLoc(), OutputCMRs[I].startLoc());
-    ASSERT_EQ(InputCMRs[I].endLoc(),   OutputCMRs[I].endLoc());
-    ASSERT_EQ(InputCMRs[I].Kind,       OutputCMRs[I].Kind);
+    ASSERT_EQ(Input.Regions[I].Count, Output.Regions[I].Count);
+    ASSERT_EQ(Input.Regions[I].FileID, Output.Regions[I].FileID);
+    ASSERT_EQ(Input.Regions[I].startLoc(), Output.Regions[I].startLoc());
+    ASSERT_EQ(Input.Regions[I].endLoc(), Output.Regions[I].endLoc());
+    ASSERT_EQ(Input.Regions[I].Kind, Output.Regions[I].Kind);
   }
 }
 
 TEST_P(MaybeSparseCoverageMappingTest,
        correct_deserialize_for_more_than_two_files) {
   const char *FileNames[] = {"bar", "baz", "foo"};
   static const unsigned N = array_lengthof(FileNames);
 
+  startFunction("func", 0x1234);
   for (unsigned I = 0; I < N; ++I)
     // Use LineStart to hold the index of the file name
     // in order to preserve that information during possible sorting of CMRs.
     addCMR(Counter::getCounter(0), FileNames[I], I, 1, I, 1);
 
-  std::string Coverage = writeCoverageRegions();
-  readCoverageRegions(Coverage);
+  InputFunctionCoverageData &Input = InputFunctions.back();
+  std::string Coverage = writeCoverageRegions(Input);
+  OutputFunctionCoverageData Output;
+  readCoverageRegions(Coverage, Output);
 
-  ASSERT_EQ(N, OutputCMRs.size());
-  ASSERT_EQ(N, OutputFiles.size());
+  ASSERT_EQ(N, Output.Regions.size());
+  ASSERT_EQ(N, Output.Filenames.size());
 
   for (unsigned I = 0; I < N; ++I) {
-    ASSERT_GT(N, OutputCMRs[I].FileID);
-    ASSERT_GT(N, OutputCMRs[I].LineStart);
-    EXPECT_EQ(FileNames[OutputCMRs[I].LineStart],
-              OutputFiles[OutputCMRs[I].FileID]);
+    ASSERT_GT(N, Output.Regions[I].FileID);
+    ASSERT_GT(N, Output.Regions[I].LineStart);
+    EXPECT_EQ(FileNames[Output.Regions[I].LineStart],
+              Output.Filenames[Output.Regions[I].FileID]);
   }
 }
 
 TEST_P(MaybeSparseCoverageMappingTest, load_coverage_for_more_than_two_files) {
   InstrProfRecord Record("func", 0x1234, {0});
   ProfileWriter.addRecord(std::move(Record));
   readProfCounts();
 
   const char *FileNames[] = {"bar", "baz", "foo"};
   static const unsigned N = array_lengthof(FileNames);
 
+  startFunction("func", 0x1234);
   for (unsigned I = 0; I < N; ++I)
     // Use LineStart to hold the index of the file name
     // in order to preserve that information during possible sorting of CMRs.
     addCMR(Counter::getCounter(0), FileNames[I], I, 1, I, 1);
 
-  loadCoverageMapping("func", 0x1234);
+  loadCoverageMapping();
 
   for (unsigned I = 0; I < N; ++I) {
     CoverageData Data = LoadedCoverage->getCoverageForFile(FileNames[I]);
     ASSERT_LE(1, std::distance(Data.begin(), Data.end()));
     EXPECT_EQ(I, Data.begin()->Line);
   }
 }
 
+TEST_P(MaybeSparseCoverageMappingTest, load_coverage_for_several_functions) {
+  InstrProfRecord RecordFunc1("func1", 0x1234, {10});
+  ProfileWriter.addRecord(std::move(RecordFunc1));
+  InstrProfRecord RecordFunc2("func2", 0x2345, {20});
+  ProfileWriter.addRecord(std::move(RecordFunc2));
+  readProfCounts();
+
+  startFunction("func1", 0x1234);
+  addCMR(Counter::getCounter(0), "foo", 1, 1, 5, 5);
+
+  startFunction("func2", 0x2345);
+  addCMR(Counter::getCounter(0), "bar", 2, 2, 6, 6);
+
+  loadCoverageMapping();
+
+  const auto FunctionRecords = LoadedCoverage->getCoveredFunctions();
+  EXPECT_EQ(2U, std::distance(FunctionRecords.begin(), FunctionRecords.end()));
+  for (const auto &FunctionRecord : FunctionRecords) {
+    CoverageData Data = LoadedCoverage->getCoverageForFunction(FunctionRecord);
+    std::vector<CoverageSegment> Segments(Data.begin(), Data.end());
+    ASSERT_EQ(2U, Segments.size());
+    if (FunctionRecord.Name == "func1") {
+      EXPECT_EQ(CoverageSegment(1, 1, 10, true), Segments[0]);
+      EXPECT_EQ(CoverageSegment(5, 5, false), Segments[1]);
+    } else {
+      ASSERT_EQ("func2", FunctionRecord.Name);
+      EXPECT_EQ(CoverageSegment(2, 2, 20, true), Segments[0]);
+      EXPECT_EQ(CoverageSegment(6, 6, false), Segments[1]);
+    }
+  }
+}
+
 TEST_P(MaybeSparseCoverageMappingTest, expansion_gets_first_counter) {
+  startFunction("func", 0x1234);
   addCMR(Counter::getCounter(1), "foo", 10, 1, 10, 2);
   // This starts earlier in "foo", so the expansion should get its counter.
   addCMR(Counter::getCounter(2), "foo", 1, 1, 20, 1);
   addExpansionCMR("bar", "foo", 3, 3, 3, 3);
-  std::string Coverage = writeCoverageRegions();
-  readCoverageRegions(Coverage);
 
-  ASSERT_EQ(CounterMappingRegion::ExpansionRegion, OutputCMRs[2].Kind);
-  ASSERT_EQ(Counter::getCounter(2), OutputCMRs[2].Count);
-  ASSERT_EQ(3U, OutputCMRs[2].LineStart);
+  InputFunctionCoverageData &Input = InputFunctions.back();
+  std::string Coverage = writeCoverageRegions(Input);
+  OutputFunctionCoverageData Output;
+  readCoverageRegions(Coverage, Output);
+
+  ASSERT_EQ(CounterMappingRegion::ExpansionRegion, Output.Regions[2].Kind);
+  ASSERT_EQ(Counter::getCounter(2), Output.Regions[2].Count);
+  ASSERT_EQ(3U, Output.Regions[2].LineStart);
 }
 
 TEST_P(MaybeSparseCoverageMappingTest, basic_coverage_iteration) {
   InstrProfRecord Record("func", 0x1234, {30, 20, 10, 0});
   ProfileWriter.addRecord(std::move(Record));
   readProfCounts();
 
+  startFunction("func", 0x1234);
   addCMR(Counter::getCounter(0), "file1", 1, 1, 9, 9);
   addCMR(Counter::getCounter(1), "file1", 1, 1, 4, 7);
   addCMR(Counter::getCounter(2), "file1", 5, 8, 9, 1);
   addCMR(Counter::getCounter(3), "file1", 10, 10, 11, 11);
-  loadCoverageMapping("func", 0x1234);
+  loadCoverageMapping();
 
   CoverageData Data = LoadedCoverage->getCoverageForFile("file1");
   std::vector<CoverageSegment> Segments(Data.begin(), Data.end());
   ASSERT_EQ(7U, Segments.size());
   ASSERT_EQ(CoverageSegment(1, 1, 20, true),  Segments[0]);
   ASSERT_EQ(CoverageSegment(4, 7, 30, false), Segments[1]);
   ASSERT_EQ(CoverageSegment(5, 8, 10, true),  Segments[2]);
   ASSERT_EQ(CoverageSegment(9, 1, 30, false), Segments[3]);
   ASSERT_EQ(CoverageSegment(9, 9, false),     Segments[4]);
   ASSERT_EQ(CoverageSegment(10, 10, 0, true), Segments[5]);
   ASSERT_EQ(CoverageSegment(11, 11, false),   Segments[6]);
 }
 
 TEST_P(MaybeSparseCoverageMappingTest, uncovered_function) {
   readProfCounts();
 
+  startFunction("func", 0x1234);
   addCMR(Counter::getZero(), "file1", 1, 2, 3, 4);
-  loadCoverageMapping("func", 0x1234);
+  loadCoverageMapping();
 
   CoverageData Data = LoadedCoverage->getCoverageForFile("file1");
   std::vector<CoverageSegment> Segments(Data.begin(), Data.end());
   ASSERT_EQ(2U, Segments.size());
   ASSERT_EQ(CoverageSegment(1, 2, 0, true), Segments[0]);
   ASSERT_EQ(CoverageSegment(3, 4, false),   Segments[1]);
 }
 
 TEST_P(MaybeSparseCoverageMappingTest, uncovered_function_with_mapping) {
   readProfCounts();
 
+  startFunction("func", 0x1234);
   addCMR(Counter::getCounter(0), "file1", 1, 1, 9, 9);
   addCMR(Counter::getCounter(1), "file1", 1, 1, 4, 7);
-  loadCoverageMapping("func", 0x1234);
+  loadCoverageMapping();
 
   CoverageData Data = LoadedCoverage->getCoverageForFile("file1");
   std::vector<CoverageSegment> Segments(Data.begin(), Data.end());
   ASSERT_EQ(3U, Segments.size());
   ASSERT_EQ(CoverageSegment(1, 1, 0, true),  Segments[0]);
   ASSERT_EQ(CoverageSegment(4, 7, 0, false), Segments[1]);
   ASSERT_EQ(CoverageSegment(9, 9, false),    Segments[2]);
 }
 
 TEST_P(MaybeSparseCoverageMappingTest, combine_regions) {
   InstrProfRecord Record("func", 0x1234, {10, 20, 30});
   ProfileWriter.addRecord(std::move(Record));
   readProfCounts();
 
+  startFunction("func", 0x1234);
   addCMR(Counter::getCounter(0), "file1", 1, 1, 9, 9);
   addCMR(Counter::getCounter(1), "file1", 3, 3, 4, 4);
   addCMR(Counter::getCounter(2), "file1", 3, 3, 4, 4);
-  loadCoverageMapping("func", 0x1234);
+  loadCoverageMapping();
 
   CoverageData Data = LoadedCoverage->getCoverageForFile("file1");
   std::vector<CoverageSegment> Segments(Data.begin(), Data.end());
   ASSERT_EQ(4U, Segments.size());
   ASSERT_EQ(CoverageSegment(1, 1, 10, true), Segments[0]);
   ASSERT_EQ(CoverageSegment(3, 3, 50, true), Segments[1]);
   ASSERT_EQ(CoverageSegment(4, 4, 10, false), Segments[2]);
   ASSERT_EQ(CoverageSegment(9, 9, false), Segments[3]);
 }
 
 TEST_P(MaybeSparseCoverageMappingTest, dont_combine_expansions) {
   InstrProfRecord Record1("func", 0x1234, {10, 20});
   InstrProfRecord Record2("func", 0x1234, {0, 0});
   ProfileWriter.addRecord(std::move(Record1));
   ProfileWriter.addRecord(std::move(Record2));
   readProfCounts();
 
+  startFunction("func", 0x1234);
   addCMR(Counter::getCounter(0), "file1", 1, 1, 9, 9);
   addCMR(Counter::getCounter(1), "file1", 3, 3, 4, 4);
   addCMR(Counter::getCounter(1), "include1", 6, 6, 7, 7);
   addExpansionCMR("file1", "include1", 3, 3, 4, 4);
-  loadCoverageMapping("func", 0x1234);
+  loadCoverageMapping();
 
   CoverageData Data = LoadedCoverage->getCoverageForFile("file1");
   std::vector<CoverageSegment> Segments(Data.begin(), Data.end());
   ASSERT_EQ(4U, Segments.size());
   ASSERT_EQ(CoverageSegment(1, 1, 10, true), Segments[0]);
   ASSERT_EQ(CoverageSegment(3, 3, 20, true), Segments[1]);
   ASSERT_EQ(CoverageSegment(4, 4, 10, false), Segments[2]);
   ASSERT_EQ(CoverageSegment(9, 9, false), Segments[3]);
 }
 
 TEST_P(MaybeSparseCoverageMappingTest, strip_filename_prefix) {
   InstrProfRecord Record("file1:func", 0x1234, {0});
   ProfileWriter.addRecord(std::move(Record));
   readProfCounts();
 
+  startFunction("file1:func", 0x1234);
   addCMR(Counter::getCounter(0), "file1", 1, 1, 9, 9);
-  loadCoverageMapping("file1:func", 0x1234);
+  loadCoverageMapping();
 
   std::vector<std::string> Names;
   for (const auto &Func : LoadedCoverage->getCoveredFunctions())
     Names.push_back(Func.Name);
   ASSERT_EQ(1U, Names.size());
   ASSERT_EQ("func", Names[0]);
 }
 
 TEST_P(MaybeSparseCoverageMappingTest, strip_unknown_filename_prefix) {
   InstrProfRecord Record("<unknown>:func", 0x1234, {0});
   ProfileWriter.addRecord(std::move(Record));
   readProfCounts();
 
+  startFunction("<unknown>:func", 0x1234);
   addCMR(Counter::getCounter(0), "", 1, 1, 9, 9);
-  loadCoverageMapping("<unknown>:func", 0x1234, /*EmitFilenames=*/false);
+  loadCoverageMapping(/*EmitFilenames=*/false);
 
   std::vector<std::string> Names;
   for (const auto &Func : LoadedCoverage->getCoveredFunctions())
     Names.push_back(Func.Name);
   ASSERT_EQ(1U, Names.size());
   ASSERT_EQ("func", Names[0]);
 }
 
 INSTANTIATE_TEST_CASE_P(MaybeSparse, MaybeSparseCoverageMappingTest,
                         ::testing::Bool());
 
 } // end anonymous namespace