[DWARFYAML][unittest] Refactor parseDWARFYAML().

[Higuoxing]

Summary

In this change, parseDWARFYAML() is refactored to be able to parse
YAML decription into different data structures. We don't have to craft
the whole DWARF structure for a small test in the future.

[Higuoxing]

Update.

[jhenderson]

Makes sense. LGTM.

llvm/unittests/ObjectYAML/DWARFYAMLTest.cpp

 #include "llvm/Support/Error.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 
-static Expected<DWARFYAML::Data> parseDWARFYAML(StringRef Yaml,
-                                                bool IsLittleEndian = false,
-                                                bool Is64bit = true) {
-  DWARFYAML::Data Data;
-  Data.IsLittleEndian = IsLittleEndian;
-  Data.Is64bit = Is64bit;
-
+template <class T> static Error parseDWARFYAML(StringRef Yaml, T &Data) {
   SMDiagnostic GenerateDiag;
   yaml::Input YIn(
       Yaml, /*Ctxt=*/nullptr,
       [](const SMDiagnostic &Diag, void *DiagContext) {
         *static_cast<SMDiagnostic *>(DiagContext) = Diag;
       },
       &GenerateDiag);
 
   YIn >> Data;
   if (YIn.error())
     return createStringError(YIn.error(), GenerateDiag.getMessage());
 
-  return Data;
+  return Error::success();
 }
 
 TEST(DebugAddrSection, TestParseDebugAddrYAML) {
   StringRef Yaml = R"(
 debug_addr:
   - Format:  DWARF64
     Length:  0x1234
     Version: 5
 )";
-  auto DWARFOrErr = parseDWARFYAML(Yaml);
-  EXPECT_THAT_EXPECTED(DWARFOrErr, Succeeded());
+  DWARFYAML::Data Data;
+  EXPECT_THAT_ERROR(parseDWARFYAML(Yaml, Data), Succeeded());
 }
 
 TEST(DebugAddrSection, TestMissingVersion) {
   StringRef Yaml = R"(
-debug_addr:
-  - Format: DWARF64
-    Length: 0x1234
+Format: DWARF64
 )";
-  auto DWARFOrErr = parseDWARFYAML(Yaml);
-  EXPECT_THAT_ERROR(DWARFOrErr.takeError(),
+  DWARFYAML::AddrTableEntry AddrTableEntry;
+  EXPECT_THAT_ERROR(parseDWARFYAML(Yaml, AddrTableEntry),
                     FailedWithMessage("missing required key 'Version'"));
 }
 
 TEST(DebugAddrSection, TestUnexpectedKey) {
   StringRef Yaml = R"(
 debug_addr:
   - Format:  DWARF64
     Length:  0x1234
     Version: 5
     Blah:    unexpected
 )";
-  auto DWARFOrErr = parseDWARFYAML(Yaml);
-  EXPECT_THAT_ERROR(DWARFOrErr.takeError(),
+  DWARFYAML::Data Data;
+  EXPECT_THAT_ERROR(parseDWARFYAML(Yaml, Data),
                     FailedWithMessage("unknown key 'Blah'"));
 }
 
 TEST(DebugPubSection, TestDebugPubSection) {
   StringRef Yaml = R"(
 debug_pubnames:
   Length:
     TotalLength: 0x1234
debug_pubtypes:
   UnitOffset:    0x4321
   UnitSize:      0x00
   Entries:
     - DieOffset:  0x1234
       Name:       abc
     - DieOffset:  0x4321
       Name:       def
 )";
-  auto DWARFOrErr = parseDWARFYAML(Yaml);
-  ASSERT_THAT_EXPECTED(DWARFOrErr, Succeeded());
+  DWARFYAML::Data Data;
+  ASSERT_THAT_ERROR(parseDWARFYAML(Yaml, Data), Succeeded());
 
-  ASSERT_TRUE(DWARFOrErr->PubNames.hasValue());
-  DWARFYAML::PubSection PubNames = DWARFOrErr->PubNames.getValue();
+  ASSERT_TRUE(Data.PubNames.hasValue());
+  DWARFYAML::PubSection PubNames = Data.PubNames.getValue();
 
   ASSERT_EQ(PubNames.Entries.size(), 2u);
   EXPECT_EQ((uint32_t)PubNames.Entries[0].DieOffset, 0x1234u);
   EXPECT_EQ(PubNames.Entries[0].Name, "abc");
   EXPECT_EQ((uint32_t)PubNames.Entries[1].DieOffset, 0x4321u);
   EXPECT_EQ(PubNames.Entries[1].Name, "def");
 
-  ASSERT_TRUE(DWARFOrErr->PubTypes.hasValue());
-  DWARFYAML::PubSection PubTypes = DWARFOrErr->PubTypes.getValue();
+  ASSERT_TRUE(Data.PubTypes.hasValue());
+  DWARFYAML::PubSection PubTypes = Data.PubTypes.getValue();
 
   ASSERT_EQ(PubTypes.Entries.size(), 2u);
   EXPECT_EQ((uint32_t)PubTypes.Entries[0].DieOffset, 0x1234u);
   EXPECT_EQ(PubTypes.Entries[0].Name, "abc");
   EXPECT_EQ((uint32_t)PubTypes.Entries[1].DieOffset, 0x4321u);
   EXPECT_EQ(PubTypes.Entries[1].Name, "def");
 }
 
 TEST(DebugPubSection, TestUnexpectedDescriptor) {
   StringRef Yaml = R"(
 debug_pubnames:
   Length:
     TotalLength: 0x1234
   Version:       2
   UnitOffset:    0x4321
   UnitSize:      0x00
   Entries:
     - DieOffset:  0x1234
       Descriptor: 0x12
       Name:       abcd
 )";
-  auto DWARFOrErr = parseDWARFYAML(Yaml);
-  EXPECT_THAT_ERROR(DWARFOrErr.takeError(),
+
+  DWARFYAML::Data Data;
+  EXPECT_THAT_ERROR(parseDWARFYAML(Yaml, Data),
                     FailedWithMessage("unknown key 'Descriptor'"));
 }
 
 TEST(DebugGNUPubSection, TestDebugGNUPubSections) {
   StringRef Yaml = R"(
 debug_gnu_pubnames:
   Length:
     TotalLength: 0x1234
debug_gnu_pubtypes:
   Entries:
     - DieOffset:  0x1234
       Descriptor: 0x12
       Name:       abc
     - DieOffset:  0x4321
       Descriptor: 0x34
       Name:       def
 )";
-  auto DWARFOrErr = parseDWARFYAML(Yaml);
-  ASSERT_THAT_EXPECTED(DWARFOrErr, Succeeded());
+  DWARFYAML::Data Data;
+  ASSERT_THAT_ERROR(parseDWARFYAML(Yaml, Data), Succeeded());
 
-  ASSERT_TRUE(DWARFOrErr->GNUPubNames.hasValue());
-  DWARFYAML::PubSection GNUPubNames = DWARFOrErr->GNUPubNames.getValue();
+  ASSERT_TRUE(Data.GNUPubNames.hasValue());
+  DWARFYAML::PubSection GNUPubNames = Data.GNUPubNames.getValue();
 
   ASSERT_EQ(GNUPubNames.Entries.size(), 2u);
   EXPECT_EQ((uint32_t)GNUPubNames.Entries[0].DieOffset, 0x1234u);
   EXPECT_EQ((uint8_t)GNUPubNames.Entries[0].Descriptor, 0x12);
   EXPECT_EQ(GNUPubNames.Entries[0].Name, "abc");
   EXPECT_EQ((uint32_t)GNUPubNames.Entries[1].DieOffset, 0x4321u);
   EXPECT_EQ((uint8_t)GNUPubNames.Entries[1].Descriptor, 0x34);
   EXPECT_EQ(GNUPubNames.Entries[1].Name, "def");
 
-  ASSERT_TRUE(DWARFOrErr->GNUPubTypes.hasValue());
-  DWARFYAML::PubSection GNUPubTypes = DWARFOrErr->GNUPubTypes.getValue();
+  ASSERT_TRUE(Data.GNUPubTypes.hasValue());
+  DWARFYAML::PubSection GNUPubTypes = Data.GNUPubTypes.getValue();
 
   ASSERT_EQ(GNUPubTypes.Entries.size(), 2u);
   EXPECT_EQ((uint32_t)GNUPubTypes.Entries[0].DieOffset, 0x1234u);
   EXPECT_EQ((uint8_t)GNUPubTypes.Entries[0].Descriptor, 0x12);
   EXPECT_EQ(GNUPubTypes.Entries[0].Name, "abc");
   EXPECT_EQ((uint32_t)GNUPubTypes.Entries[1].DieOffset, 0x4321u);
   EXPECT_EQ((uint8_t)GNUPubTypes.Entries[1].Descriptor, 0x34);
   EXPECT_EQ(GNUPubTypes.Entries[1].Name, "def");
 }
 
 TEST(DebugGNUPubSection, TestMissingDescriptor) {
   StringRef Yaml = R"(
 debug_gnu_pubnames:
   Length:
     TotalLength: 0x1234
   Version:       2
   UnitOffset:    0x4321
   UnitSize:      0x00
   Entries:
     - DieOffset: 0x1234
       Name:      abcd
 )";
-  auto DWARFOrErr = parseDWARFYAML(Yaml);
-  EXPECT_THAT_ERROR(DWARFOrErr.takeError(),
+  DWARFYAML::Data Data;
+  EXPECT_THAT_ERROR(parseDWARFYAML(Yaml, Data),
                     FailedWithMessage("missing required key 'Descriptor'"));
 }