[Coverage] Update testing methods to support more than two files.

[vsk]

Thanks! Lgtm with a few nits.

llvm/trunk/unittests/ProfileData/CoverageMappingTest.cpp

207

ISTM that these asserts could be tightened, e.g ASSERT_EQ(I, OutputCMRs[I].FileID).

209

Is there a reason to prefer OutputCMRs[I].LineStart over OutputCMRs[I].FileID on this line?

231

I think this would be easier to read as EXPECT_TRUE(!Data.empty()).

[ikudrin]

llvm/trunk/unittests/ProfileData/CoverageMappingTest.cpp

207

IMHO the test shouldn't be more tighter than necessary. This test only checks that all regions are bound to the correct files and not intended to check the exact order of loaded regions as regions could be rearranged by writer.

209

The same as above, the test shouldn't rely on any specific sorting order of regions.

231

You are right, I'll change it.

[vsk]

Thanks, lgtm with the one nit.

llvm/trunk/unittests/ProfileData/CoverageMappingTest.cpp

209

I see.

llvm/trunk/unittests/ProfileData/CoverageMappingTest.cpp

std::error_code readNextRecord(CoverageMappingRecord &Record) override {
     Record.Expressions = {};
     Record.MappingRegions = Regions;
     return instrprof_error::success;
   }
 };
 
 struct CoverageMappingTest : ::testing::Test {
   StringMap<unsigned> Files;
-  unsigned NextFile;
   std::vector<CounterMappingRegion> InputCMRs;
 
   std::vector<StringRef> OutputFiles;
   std::vector<CounterExpression> OutputExpressions;
   std::vector<CounterMappingRegion> OutputCMRs;
 
   InstrProfWriter ProfileWriter;
   std::unique_ptr<IndexedInstrProfReader> ProfileReader;
 
   std::unique_ptr<CoverageMapping> LoadedCoverage;
 
   void SetUp() override {
-    NextFile = 0;
     ProfileWriter.setOutputSparse(false);
   }
 
   unsigned getFile(StringRef Name) {
     auto R = Files.find(Name);
     if (R != Files.end())
       return R->second;
-    Files[Name] = NextFile;
-    return NextFile++;
+    unsigned Index = Files.size();
+    Files.emplace_second(Name, Index);
+    return Index;
   }
 
   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));
   }
 
   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));
   }
 
   std::string writeCoverageRegions() {
-    SmallVector<unsigned, 8> FileIDs;
-    for (const auto &E : Files)
-      FileIDs.push_back(E.getValue());
+    SmallVector<unsigned, 8> FileIDs(Files.size());
+    for (unsigned I = 0; I < FileIDs.size(); ++I)
+      FileIDs[I] = I;
     std::string Coverage;
     llvm::raw_string_ostream OS(Coverage);
     CoverageMappingWriter(FileIDs, None, InputCMRs).write(OS);
     return OS.str();
   }
 
   void readCoverageRegions(std::string Coverage) {
-    SmallVector<StringRef, 8> Filenames;
+    SmallVector<StringRef, 8> Filenames(Files.size());
     for (const auto &E : Files)
-      Filenames.push_back(E.getKey());
+      Filenames[E.getValue()] = E.getKey();
     RawCoverageMappingReader Reader(Coverage, Filenames, OutputFiles,
                                     OutputExpressions, OutputCMRs);
     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)
+    if (EmitFilenames) {
+      Filenames.resize(Files.size());
       for (const auto &E : Files)
-        Filenames.push_back(E.getKey());
+        Filenames[E.getValue()] = E.getKey();
+    }
     OneFunctionCoverageReader CovReader(FuncName, Hash, Filenames, OutputCMRs);
     auto CoverageOrErr = CoverageMapping::load(CovReader, *ProfileReader);
     ASSERT_TRUE(NoError(CoverageOrErr.getError()));
     LoadedCoverage = std::move(CoverageOrErr.get());
   }
 };
 
 struct MaybeSparseCoverageMappingTest
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);
   }
 }
 
+TEST_P(MaybeSparseCoverageMappingTest,
+       correct_deserialize_for_more_than_two_files) {
+  const char *FileNames[] = {"bar", "baz", "foo"};
+  static const unsigned N = array_lengthof(FileNames);
+
+  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);
+
+  ASSERT_EQ(N, OutputCMRs.size());
+  ASSERT_EQ(N, OutputFiles.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]);
+  }
+}
+
+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);
+
+  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);
+
+  for (unsigned I = 0; I < N; ++I) {
+    CoverageData Data = LoadedCoverage->getCoverageForFile(FileNames[I]);
+    ASSERT_TRUE(!Data.empty());
+    EXPECT_EQ(I, Data.begin()->Line);
+  }
+}
+
 TEST_P(MaybeSparseCoverageMappingTest, expansion_gets_first_counter) {
   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);