[llvm][TextAPI/MachO] Extend TBD_V4 unittest to verify writing

[JDevlieghere]

Summary

Same as D73328 but for TBD_V4. One notable tidbit is that the swift abi version for swift 1 & 2 is emitted as a float which is considered invalid input.

[merge_guards_bot]

Unit tests: fail. 62152 tests passed, 5 failed and 811 were skipped.

failed: libc++.std/language_support/cmp/cmp_partialord/partialord.pass.cpp
failed: libc++.std/language_support/cmp/cmp_strongeq/cmp.strongeq.pass.cpp
failed: libc++.std/language_support/cmp/cmp_strongord/strongord.pass.cpp
failed: libc++.std/language_support/cmp/cmp_weakeq/cmp.weakeq.pass.cpp
failed: libc++.std/language_support/cmp/cmp_weakord/weakord.pass.cpp

clang-tidy: fail. clang-tidy found 0 errors and 2 warnings. 0 of them are added as review comments below (why?).

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[cishida]

LGTM

llvm/unittests/TextAPI/TextStubV4Tests.cpp

inline bool operator<(const ExampleSymbol &LHS, const ExampleSymbol &RHS) {
   return std::tie(LHS.Kind, LHS.Name) < std::tie(RHS.Kind, RHS.Name);
 }
 
 inline bool operator==(const ExampleSymbol &LHS, const ExampleSymbol &RHS) {
   return std::tie(LHS.Kind, LHS.Name, LHS.WeakDefined, LHS.ThreadLocalValue) ==
          std::tie(RHS.Kind, RHS.Name, RHS.WeakDefined, RHS.ThreadLocalValue);
 }
 
+inline std::string stripWhitespace(std::string s) {
+  s.erase(std::remove_if(s.begin(), s.end(), ::isspace), s.end());
+  return s;
+}
+
 static ExampleSymbol TBDv4ExportedSymbols[] = {
     {SymbolKind::GlobalSymbol, "_symA", false, false},
     {SymbolKind::GlobalSymbol, "_symAB", false, false},
     {SymbolKind::GlobalSymbol, "_symB", false, false},
 };
 
 static ExampleSymbol TBDv4ReexportedSymbols[] = {
     {SymbolKind::GlobalSymbol, "_symC", false, false},
TEST(TBDv4, MultipleTargets) {
   Platforms.insert(PlatformKind::tvOS);
   Platforms.insert(PlatformKind::iOS);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(AK_x86_64 | AK_arm64 | AK_i386, File->getArchitectures());
   EXPECT_EQ(Platforms.size(), File->getPlatforms().size());
   for (auto Platform : File->getPlatforms())
     EXPECT_EQ(Platforms.count(Platform), 1U);
+
+  SmallString<4096> Buffer;
+  raw_svector_ostream OS(Buffer);
+  auto WriteResult = TextAPIWriter::writeToStream(OS, *File);
+  EXPECT_TRUE(!WriteResult);
+  EXPECT_EQ(stripWhitespace(tbd_multiple_targets),
+            stripWhitespace(Buffer.c_str()));
 }
 
 TEST(TBDv4, MultipleTargetsSameArch) {
   static const char tbd_targets_same_arch[] =
       "--- !tapi-tbd\n"
       "tbd-version: 4\n"
-      "targets: [ x86_64-maccatalyst, x86_64-tvos ]\n"
+      "targets: [ x86_64-tvos , x86_64-maccatalyst ]\n"
       "install-name: Test.dylib\n"
       "...\n";
 
   auto Result =
       TextAPIReader::get(MemoryBufferRef(tbd_targets_same_arch, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   PlatformSet Platforms;
   Platforms.insert(PlatformKind::tvOS);
   Platforms.insert(PlatformKind::macCatalyst);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(ArchitectureSet(AK_x86_64), File->getArchitectures());
   EXPECT_EQ(Platforms.size(), File->getPlatforms().size());
   for (auto Platform : File->getPlatforms())
     EXPECT_EQ(Platforms.count(Platform), 1U);
+
+  SmallString<4096> Buffer;
+  raw_svector_ostream OS(Buffer);
+  auto WriteResult = TextAPIWriter::writeToStream(OS, *File);
+  EXPECT_TRUE(!WriteResult);
+  EXPECT_EQ(stripWhitespace(tbd_targets_same_arch),
+            stripWhitespace(Buffer.c_str()));
 }
 
 TEST(TBDv4, MultipleTargetsSamePlatform) {
   static const char tbd_multiple_targets_same_platform[] =
       "--- !tapi-tbd\n"
       "tbd-version: 4\n"
-      "targets: [ arm64-ios, armv7k-ios ]\n"
+      "targets: [ armv7k-ios , arm64-ios]\n"
       "install-name: Test.dylib\n"
       "...\n";
 
   auto Result = TextAPIReader::get(
       MemoryBufferRef(tbd_multiple_targets_same_platform, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(AK_arm64 | AK_armv7k, File->getArchitectures());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(PlatformKind::iOS, *File->getPlatforms().begin());
+
+  SmallString<4096> Buffer;
+  raw_svector_ostream OS(Buffer);
+  auto WriteResult = TextAPIWriter::writeToStream(OS, *File);
+  EXPECT_TRUE(!WriteResult);
+  EXPECT_EQ(stripWhitespace(tbd_multiple_targets_same_platform),
+            stripWhitespace(Buffer.c_str()));
 }
 
 TEST(TBDv4, Target_maccatalyst) {
   static const char tbd_target_maccatalyst[] =
       "--- !tapi-tbd\n"
       "tbd-version: 4\n"
       "targets: [  x86_64-maccatalyst ]\n"
       "install-name: Test.dylib\n"
       "...\n";
 
   auto Result =
       TextAPIReader::get(MemoryBufferRef(tbd_target_maccatalyst, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(ArchitectureSet(AK_x86_64), File->getArchitectures());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(PlatformKind::macCatalyst, *File->getPlatforms().begin());
+
+  SmallString<4096> Buffer;
+  raw_svector_ostream OS(Buffer);
+  auto WriteResult = TextAPIWriter::writeToStream(OS, *File);
+  EXPECT_TRUE(!WriteResult);
+  EXPECT_EQ(stripWhitespace(tbd_target_maccatalyst),
+            stripWhitespace(Buffer.c_str()));
 }
 
 TEST(TBDv4, Target_x86_ios) {
   static const char tbd_target_x86_ios[] = "--- !tapi-tbd\n"
                                            "tbd-version: 4\n"
                                            "targets: [  x86_64-ios ]\n"
                                            "install-name: Test.dylib\n"
                                            "...\n";
 
   auto Result =
       TextAPIReader::get(MemoryBufferRef(tbd_target_x86_ios, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(ArchitectureSet(AK_x86_64), File->getArchitectures());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(PlatformKind::iOS, *File->getPlatforms().begin());
+
+  SmallString<4096> Buffer;
+  raw_svector_ostream OS(Buffer);
+  auto WriteResult = TextAPIWriter::writeToStream(OS, *File);
+  EXPECT_TRUE(!WriteResult);
+  EXPECT_EQ(stripWhitespace(tbd_target_x86_ios),
+            stripWhitespace(Buffer.c_str()));
 }
 
 TEST(TBDv4, Target_arm_bridgeOS) {
   static const char tbd_platform_bridgeos[] = "--- !tapi-tbd\n"
                                               "tbd-version: 4\n"
                                               "targets: [  armv7k-bridgeos ]\n"
                                               "install-name: Test.dylib\n"
                                               "...\n";
 
   auto Result =
       TextAPIReader::get(MemoryBufferRef(tbd_platform_bridgeos, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(PlatformKind::bridgeOS, *File->getPlatforms().begin());
   EXPECT_EQ(ArchitectureSet(AK_armv7k), File->getArchitectures());
+
+  SmallString<4096> Buffer;
+  raw_svector_ostream OS(Buffer);
+  auto WriteResult = TextAPIWriter::writeToStream(OS, *File);
+  EXPECT_TRUE(!WriteResult);
+  EXPECT_EQ(stripWhitespace(tbd_platform_bridgeos),
+            stripWhitespace(Buffer.c_str()));
 }
 
 TEST(TBDv4, Target_x86_macos) {
   static const char tbd_x86_macos[] = "--- !tapi-tbd\n"
                                       "tbd-version: 4\n"
                                       "targets: [  x86_64-macos ]\n"
                                       "install-name: Test.dylib\n"
                                       "...\n";
 
   auto Result = TextAPIReader::get(MemoryBufferRef(tbd_x86_macos, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(ArchitectureSet(AK_x86_64), File->getArchitectures());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(PlatformKind::macOS, *File->getPlatforms().begin());
+
+  SmallString<4096> Buffer;
+  raw_svector_ostream OS(Buffer);
+  auto WriteResult = TextAPIWriter::writeToStream(OS, *File);
+  EXPECT_TRUE(!WriteResult);
+  EXPECT_EQ(stripWhitespace(tbd_x86_macos), stripWhitespace(Buffer.c_str()));
 }
 
 TEST(TBDv4, Target_x86_ios_simulator) {
   static const char tbd_x86_ios_sim[] = "--- !tapi-tbd\n"
                                         "tbd-version: 4\n"
                                         "targets: [  x86_64-ios-simulator  ]\n"
                                         "install-name: Test.dylib\n"
                                         "...\n";
 
   auto Result =
       TextAPIReader::get(MemoryBufferRef(tbd_x86_ios_sim, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(ArchitectureSet(AK_x86_64), File->getArchitectures());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(PlatformKind::iOSSimulator, *File->getPlatforms().begin());
+
+  SmallString<4096> Buffer;
+  raw_svector_ostream OS(Buffer);
+  auto WriteResult = TextAPIWriter::writeToStream(OS, *File);
+  EXPECT_TRUE(!WriteResult);
+  EXPECT_EQ(stripWhitespace(tbd_x86_ios_sim), stripWhitespace(Buffer.c_str()));
 }
 
 TEST(TBDv4, Target_x86_tvos_simulator) {
   static const char tbd_x86_tvos_sim[] =
       "--- !tapi-tbd\n"
       "tbd-version: 4\n"
       "targets: [  x86_64-tvos-simulator  ]\n"
       "install-name: Test.dylib\n"
       "...\n";
 
   auto Result =
       TextAPIReader::get(MemoryBufferRef(tbd_x86_tvos_sim, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(ArchitectureSet(AK_x86_64), File->getArchitectures());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(PlatformKind::tvOSSimulator, *File->getPlatforms().begin());
+
+  SmallString<4096> Buffer;
+  raw_svector_ostream OS(Buffer);
+  auto WriteResult = TextAPIWriter::writeToStream(OS, *File);
+  EXPECT_TRUE(!WriteResult);
+  EXPECT_EQ(stripWhitespace(tbd_x86_tvos_sim), stripWhitespace(Buffer.c_str()));
 }
 
 TEST(TBDv4, Target_i386_watchos_simulator) {
   static const char tbd_i386_watchos_sim[] =
       "--- !tapi-tbd\n"
       "tbd-version: 4\n"
       "targets: [  i386-watchos-simulator  ]\n"
       "install-name: Test.dylib\n"
       "...\n";
 
   auto Result =
       TextAPIReader::get(MemoryBufferRef(tbd_i386_watchos_sim, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(ArchitectureSet(AK_i386), File->getArchitectures());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(PlatformKind::watchOSSimulator, *File->getPlatforms().begin());
+
+  SmallString<4096> Buffer;
+  raw_svector_ostream OS(Buffer);
+  auto WriteResult = TextAPIWriter::writeToStream(OS, *File);
+  EXPECT_TRUE(!WriteResult);
+  EXPECT_EQ(stripWhitespace(tbd_i386_watchos_sim),
+            stripWhitespace(Buffer.c_str()));
 }
 
 TEST(TBDv4, Swift_1) {
   static const char tbd_swift_1[] = "--- !tapi-tbd\n"
                                     "tbd-version: 4\n"
                                     "targets: [  x86_64-macos ]\n"
                                     "install-name: Test.dylib\n"
                                     "swift-abi-version: 1\n"
                                     "...\n";
 
   auto Result = TextAPIReader::get(MemoryBufferRef(tbd_swift_1, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(1U, File->getSwiftABIVersion());
+
+  // No writer test because we emit "swift-abi-version:1.0".
 }
 
 TEST(TBDv4, Swift_2) {
   static const char tbd_v4_swift_2[] = "--- !tapi-tbd\n"
                                        "tbd-version: 4\n"
                                        "targets: [  x86_64-macos ]\n"
                                        "install-name: Test.dylib\n"
                                        "swift-abi-version: 2\n"
                                        "...\n";
 
   auto Result = TextAPIReader::get(MemoryBufferRef(tbd_v4_swift_2, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(2U, File->getSwiftABIVersion());
+
+  // No writer test because we emit "swift-abi-version:2.0".
 }
 
 TEST(TBDv4, Swift_5) {
   static const char tbd_swift_5[] = "--- !tapi-tbd\n"
                                     "tbd-version: 4\n"
                                     "targets: [  x86_64-macos ]\n"
                                     "install-name: Test.dylib\n"
                                     "swift-abi-version: 5\n"
                                     "...\n";
 
   auto Result = TextAPIReader::get(MemoryBufferRef(tbd_swift_5, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(5U, File->getSwiftABIVersion());
+
+  SmallString<4096> Buffer;
+  raw_svector_ostream OS(Buffer);
+  auto WriteResult = TextAPIWriter::writeToStream(OS, *File);
+  EXPECT_TRUE(!WriteResult);
+  EXPECT_EQ(stripWhitespace(tbd_swift_5), stripWhitespace(Buffer.c_str()));
 }
 
 TEST(TBDv4, Swift_99) {
   static const char tbd_swift_99[] = "--- !tapi-tbd\n"
                                      "tbd-version: 4\n"
                                      "targets: [  x86_64-macos ]\n"
                                      "install-name: Test.dylib\n"
                                      "swift-abi-version: 99\n"
                                      "...\n";
 
   auto Result = TextAPIReader::get(MemoryBufferRef(tbd_swift_99, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(99U, File->getSwiftABIVersion());
+
+  SmallString<4096> Buffer;
+  raw_svector_ostream OS(Buffer);
+  auto WriteResult = TextAPIWriter::writeToStream(OS, *File);
+  EXPECT_TRUE(!WriteResult);
+  EXPECT_EQ(stripWhitespace(tbd_swift_99), stripWhitespace(Buffer.c_str()));
 }
 
 TEST(TBDv4, InvalidArchitecture) {
   static const char tbd_file_unknown_architecture[] =
       "--- !tapi-tbd\n"
       "tbd-version: 4\n"
       "targets: [ foo-macos ]\n"
       "install-name: Test.dylib\n"