[unittest][DebugInfo/DWARF] Do not report skipped tests as passed

[ikudrin]

Summary

This is similar to what we have already done to some other tests. See D102643, D102710, D102754.

[dblaikie]

Looks like an acceptable incremental improvement, but perhaps it could be improved further if the generator be setup in the SetUp function and failing that function could implicitly skip tests covered by it, and similar for other tests/setup operations like initializing the MachineRegisterInfo, etc?

[ikudrin]

In D116108#3205038, @dblaikie wrote:

Looks like an acceptable incremental improvement, but perhaps it could be improved further if the generator be setup in the SetUp function and failing that function could implicitly skip tests covered by it, and similar for other tests/setup operations like initializing the MachineRegisterInfo, etc?

TBH, I do not see much profit in that change. Only DWARFExpressionCopyBytesTest and DWARFExpressionCompactPrinterTest can be easily updated, but they already have one common test method each, so moving the check into a setup method would not be a visible improvement. Other places pass custom parameters to the initializer, so reorganizing them requires much more effort, but the outcome would be elusive.

llvm/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp

 using ::testing::HasSubstr;
 
 namespace {
 
 template <uint16_t Version, class AddrType, class RefAddrType>
 void TestAllForms() {
   Triple Triple = getDefaultTargetTripleForAddrSize(sizeof(AddrType));
   if (!isConfigurationSupported(Triple))
-    return;
+    GTEST_SKIP();
 
   // Test that we can decode all DW_FORM values correctly.
   const AddrType AddrValue = (AddrType)0x0123456789abcdefULL;
   const uint8_t BlockData[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
   const uint32_t BlockSize = sizeof(BlockData);
   const RefAddrType RefAddr = 0x12345678;
   const uint8_t Data1 = 0x01U;
   const uint16_t Data2 = 0x2345U;
#endif
   // DW_FORM_ref_addr are 4 bytes in DWARF32 for version 3 and later
   typedef uint32_t RefAddrType;
   TestAllForms<5, AddrType, RefAddrType>();
 }
 
 template <uint16_t Version, class AddrType> void TestChildren() {
   Triple Triple = getDefaultTargetTripleForAddrSize(sizeof(AddrType));
   if (!isConfigurationSupported(Triple))
-    return;
+    GTEST_SKIP();
 
   // Test that we can decode DW_FORM_ref_addr values correctly in DWARF 2 with
   // 4 byte addresses. DW_FORM_ref_addr values should be 4 bytes when using
   // 8 byte addresses.
 
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
   ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
   dwarfgen::Generator *DG = ExpectedDG.get().get();
#endif
   // addresses.
   typedef uint64_t AddrType;
   TestChildren<4, AddrType>();
 }
 
 template <uint16_t Version, class AddrType> void TestReferences() {
   Triple Triple = getDefaultTargetTripleForAddrSize(sizeof(AddrType));
   if (!isConfigurationSupported(Triple))
-    return;
+    GTEST_SKIP();
 
   // Test that we can decode DW_FORM_refXXX values correctly in DWARF.
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
   ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
   dwarfgen::Generator *DG = ExpectedDG.get().get();
   dwarfgen::CompileUnit &CU1 = DG->addCompileUnit();
   dwarfgen::CompileUnit &CU2 = DG->addCompileUnit();
 
#endif
   // addresses.
   typedef uint64_t AddrType;
   TestReferences<4, AddrType>();
 }
 
 template <uint16_t Version, class AddrType> void TestAddresses() {
   Triple Triple = getDefaultTargetTripleForAddrSize(sizeof(AddrType));
   if (!isConfigurationSupported(Triple))
-    return;
+    GTEST_SKIP();
 
   // Test the DWARF APIs related to accessing the DW_AT_low_pc and
   // DW_AT_high_pc.
   const bool SupportsHighPCAsOffset = Version >= 4;
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
   ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
   dwarfgen::Generator *DG = ExpectedDG.get().get();
   dwarfgen::CompileUnit &CU = DG->addCompileUnit();

 
 #ifdef _AIX
 TEST(DWARFDebugInfo, DISABLED_TestStringOffsets) {
 #else
 TEST(DWARFDebugInfo, TestStringOffsets) {
 #endif
   Triple Triple = getNormalizedDefaultTargetTriple();
   if (!isConfigurationSupported(Triple))
-    return;
+    GTEST_SKIP();
 
   const char *String1 = "Hello";
   const char *String2 = "World";
 
   auto ExpectedDG = dwarfgen::Generator::create(Triple, 5);
   ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
   dwarfgen::Generator *DG = ExpectedDG.get().get();
   dwarfgen::CompileUnit &CU = DG->addCompileUnit();
#endif
   auto Extracted3 = toString(Form3);
   ASSERT_TRUE((bool)Extracted3);
   EXPECT_STREQ(String1, *Extracted3);
 }
 
 TEST(DWARFDebugInfo, TestEmptyStringOffsets) {
   Triple Triple = getNormalizedDefaultTargetTriple();
   if (!isConfigurationSupported(Triple))
-    return;
+    GTEST_SKIP();
 
   const char *String1 = "Hello";
 
   auto ExpectedDG = dwarfgen::Generator::create(Triple, 5);
   ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
   dwarfgen::Generator *DG = ExpectedDG.get().get();
   dwarfgen::CompileUnit &CU = DG->addCompileUnit();
   dwarfgen::DIE CUDie = CU.getUnitDIE();
TEST(DWARFDebugInfo, TestEmptyStringOffsets) {
   std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj);
   EXPECT_TRUE(
       DwarfContext->getDWARFObj().getStrOffsetsSection().Data.empty());
 }
 
 TEST(DWARFDebugInfo, TestRelations) {
   Triple Triple = getNormalizedDefaultTargetTriple();
   if (!isConfigurationSupported(Triple))
-    return;
+    GTEST_SKIP();
 
   // Test the DWARF APIs related to accessing the DW_AT_low_pc and
   // DW_AT_high_pc.
   uint16_t Version = 4;
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
   ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
   dwarfgen::Generator *DG = ExpectedDG.get().get();
   dwarfgen::CompileUnit &CU = DG->addCompileUnit();
TEST(DWARFDebugInfo, TestDWARFDie) {
   EXPECT_FALSE(DefaultDie.getParent().isValid());
   EXPECT_FALSE(DefaultDie.getFirstChild().isValid());
   EXPECT_FALSE(DefaultDie.getSibling().isValid());
 }
 
 TEST(DWARFDebugInfo, TestChildIterators) {
   Triple Triple = getNormalizedDefaultTargetTriple();
   if (!isConfigurationSupported(Triple))
-    return;
+    GTEST_SKIP();
 
   // Test the DWARF APIs related to iterating across the children of a DIE using
   // the DWARFDie::iterator class.
   uint16_t Version = 4;
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
   ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
   dwarfgen::Generator *DG = ExpectedDG.get().get();
   dwarfgen::CompileUnit &CU = DG->addCompileUnit();
TEST(DWARFDebugInfo, TestEmptyChildren) {
   // has begin and end iterators that are equal. We want to make sure we don't
   // see the Null DIEs during iteration.
   EXPECT_EQ(CUDie.begin(), CUDie.end());
 }
 
 TEST(DWARFDebugInfo, TestAttributeIterators) {
   Triple Triple = getNormalizedDefaultTargetTriple();
   if (!isConfigurationSupported(Triple))
-    return;
+    GTEST_SKIP();
 
   // Test the DWARF APIs related to iterating across all attribute values in a
   // a DWARFDie.
   uint16_t Version = 4;
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
   ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
   dwarfgen::Generator *DG = ExpectedDG.get().get();
   dwarfgen::CompileUnit &CU = DG->addCompileUnit();
TEST(DWARFDebugInfo, TestAttributeIterators) {
   EXPECT_EQ(CULowPC, *I->Value.getAsAddress());
 
   EXPECT_EQ(E, ++I);
 }
 
 TEST(DWARFDebugInfo, TestFindRecurse) {
   Triple Triple = getNormalizedDefaultTargetTriple();
   if (!isConfigurationSupported(Triple))
-    return;
+    GTEST_SKIP();
 
   uint16_t Version = 4;
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
   ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
   dwarfgen::Generator *DG = ExpectedDG.get().get();
   dwarfgen::CompileUnit &CU = DG->addCompileUnit();
 
   StringRef SpecDieName = "spec";
TEST(DWARFDebugInfo, TestDwarfToFunctions) {
   EXPECT_EQ(InvalidS64, toSigned(FormValOpt6, InvalidU64));
 
   // Test
 }
 
 TEST(DWARFDebugInfo, TestFindAttrs) {
   Triple Triple = getNormalizedDefaultTargetTriple();
   if (!isConfigurationSupported(Triple))
-    return;
+    GTEST_SKIP();
 
   // Test the DWARFDie::find() and DWARFDie::findRecursively() that take an
   // ArrayRef<dwarf::Attribute> value to make sure they work correctly.
   uint16_t Version = 4;
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
   ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
   dwarfgen::Generator *DG = ExpectedDG.get().get();
   dwarfgen::CompileUnit &CU = DG->addCompileUnit();
TEST(DWARFDebugInfo, TestFindAttrs) {
   auto NameOpt = FuncDie.findRecursively(Attrs);
   EXPECT_TRUE(NameOpt.hasValue());
   EXPECT_EQ(DieMangled, toString(NameOpt, ""));
 }
 
 TEST(DWARFDebugInfo, TestImplicitConstAbbrevs) {
   Triple Triple = getNormalizedDefaultTargetTriple();
   if (!isConfigurationSupported(Triple))
-    return;
+    GTEST_SKIP();
 
   uint16_t Version = 5;
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
   ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
   dwarfgen::Generator *DG = ExpectedDG.get().get();
   dwarfgen::CompileUnit &CU = DG->addCompileUnit();
   dwarfgen::DIE CUDie = CU.getUnitDIE();
   const dwarf::Attribute Attr = DW_AT_lo_user;
TEST(DWARFDebugInfo, TestImplicitConstAbbrevs) {
   for (auto it = Val1Range.first; it != Val1Range.second; ++it)
     EXPECT_EQ(it->second, AbbrevPtrVal1);
   EXPECT_EQ(DIEs.find(Val2)->second, AbbrevPtrVal2);
 }
 
 TEST(DWARFDebugInfo, TestErrorReporting) {
   Triple Triple("x86_64-pc-linux");
   if (!isConfigurationSupported(Triple))
-      return;
+    GTEST_SKIP();
 
   auto ExpectedDG = dwarfgen::Generator::create(Triple, 4 /*DwarfVersion*/);
   ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
   dwarfgen::Generator *DG = ExpectedDG.get().get();
   AsmPrinter *AP = DG->getAsmPrinter();
   MCContext *MC = DG->getMCContext();
 
   // Emit two compressed sections with broken headers.

llvm/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp

 }
 
 #ifdef _AIX
 TEST_F(DebugLineBasicFixture, DISABLED_GetOrParseLineTableAtInvalidOffset) {
 #else
 TEST_F(DebugLineBasicFixture, GetOrParseLineTableAtInvalidOffset) {
 #endif
   if (!setupGenerator())
-    return;
+    GTEST_SKIP();
   generate();
 
   EXPECT_THAT_EXPECTED(
       getOrParseLineTableFatalErrors(0),
       FailedWithMessage(
           "offset 0x00000000 is not a valid debug line section offset"));
   // Repeat to show that an error is reported each time.
   EXPECT_THAT_EXPECTED(

 
 #ifdef _AIX
 TEST_F(DebugLineBasicFixture,
        DISABLED_GetOrParseLineTableAtInvalidOffsetAfterData) {
 #else
 TEST_F(DebugLineBasicFixture, GetOrParseLineTableAtInvalidOffsetAfterData) {
 #endif
   if (!setupGenerator())
-    return;
+    GTEST_SKIP();
 
   LineTable &LT = Gen->addLineTable();
   LT.setCustomPrologue({{0, LineTable::Byte}});
 
   generate();
 
   EXPECT_THAT_EXPECTED(
       getOrParseLineTableFatalErrors(0),
       FailedWithMessage(
           "parsing line table prologue at offset 0x00000000: "
           "unexpected end of data at offset 0x1 while reading [0x0, 0x4)"));
 
   EXPECT_THAT_EXPECTED(
       getOrParseLineTableFatalErrors(1),
       FailedWithMessage(
           "offset 0x00000001 is not a valid debug line section offset"));
 }
 
 #ifdef _AIX
 TEST_P(DebugLineParameterisedFixture, DISABLED_PrologueGetLength) {
 #else
 TEST_P(DebugLineParameterisedFixture, PrologueGetLength) {
 #endif
   if (!setupGenerator(Version))
-    return;
+    GTEST_SKIP();
   LineTable &LT = Gen->addLineTable(Format);
   DWARFDebugLine::Prologue Prologue = LT.createBasicPrologue();
   LT.setPrologue(Prologue);
   generate();
 
   // + 10 for sizes of DWARF-32 unit length, version, prologue length.
   uint64_t ExpectedLength = Prologue.PrologueLength + 10;
   if (Version == 5)

 }
 
 #ifdef _AIX
 TEST_P(DebugLineParameterisedFixture, DISABLED_GetOrParseLineTableValidTable) {
 #else
 TEST_P(DebugLineParameterisedFixture, GetOrParseLineTableValidTable) {
 #endif
   if (!setupGenerator(Version))
-    return;
+    GTEST_SKIP();
 
   SCOPED_TRACE("Checking Version " + std::to_string(Version) + ", Format " +
                (Format == DWARF64 ? "DWARF64" : "DWARF32"));
 
   LineTable &LT = Gen->addLineTable(Format);
   LT.addExtendedOpcode(9, DW_LNE_set_address, {{0xadd4e55, LineTable::Quad}});
   LT.addStandardOpcode(DW_LNS_copy, {});
   LT.addByte(0xaa);

 }
 
 #ifdef _AIX
 TEST_F(DebugLineBasicFixture, DISABLED_ErrorForReservedLength) {
 #else
 TEST_F(DebugLineBasicFixture, ErrorForReservedLength) {
 #endif
   if (!setupGenerator())
-    return;
+    GTEST_SKIP();
 
   LineTable &LT = Gen->addLineTable();
   LT.setCustomPrologue({{0xfffffff0, LineTable::Long}});
 
   generate();
 
   EXPECT_THAT_EXPECTED(
       getOrParseLineTableFatalErrors(),

 
 #ifdef _AIX
 TEST_P(DebugLineUnsupportedVersionFixture,
        DISABLED_ErrorForUnsupportedVersion) {
 #else
 TEST_P(DebugLineUnsupportedVersionFixture, ErrorForUnsupportedVersion) {
 #endif
   if (!setupGenerator())
-    return;
+    GTEST_SKIP();
 
   LineTable &LT = Gen->addLineTable();
   LT.setCustomPrologue(
       {{LineTable::Half, LineTable::Long}, {Version, LineTable::Half}});
 
   generate();
 
   EXPECT_THAT_EXPECTED(
INSTANTIATE_TEST_SUITE_P(UnsupportedVersionTestParams,
                                 /* Maximum possible */ 0xffff));
 
 #ifdef _AIX
 TEST_F(DebugLineBasicFixture, DISABLED_ErrorForInvalidV5IncludeDirTable) {
 #else
 TEST_F(DebugLineBasicFixture, ErrorForInvalidV5IncludeDirTable) {
 #endif
   if (!setupGenerator(5))
-    return;
+    GTEST_SKIP();
 
   LineTable &LT = Gen->addLineTable();
   LT.setCustomPrologue({
       {19, LineTable::Long}, // unit length
       {5, LineTable::Half},  // version
       {8, LineTable::Byte},  // addr size
       {0, LineTable::Byte},  // segment selector size
       {11, LineTable::Long}, // prologue length

 }
 
 #ifdef _AIX
 TEST_P(DebugLineParameterisedFixture, DISABLED_ErrorForTooLargePrologueLength) {
 #else
 TEST_P(DebugLineParameterisedFixture, ErrorForTooLargePrologueLength) {
 #endif
   if (!setupGenerator(Version))
-    return;
+    GTEST_SKIP();
 
   SCOPED_TRACE("Checking Version " + std::to_string(Version) + ", Format " +
                (Format == DWARF64 ? "DWARF64" : "DWARF32"));
 
   LineTable &LT = Gen->addLineTable(Format);
   DWARFDebugLine::Prologue Prologue = LT.createBasicPrologue();
   ++Prologue.PrologueLength;
   LT.setPrologue(Prologue);

 }
 
 #ifdef _AIX
 TEST_P(DebugLineParameterisedFixture, DISABLED_ErrorForTooShortPrologueLength) {
 #else
 TEST_P(DebugLineParameterisedFixture, ErrorForTooShortPrologueLength) {
 #endif
   if (!setupGenerator(Version))
-    return;
+    GTEST_SKIP();
 
   SCOPED_TRACE("Checking Version " + std::to_string(Version) + ", Format " +
                (Format == DWARF64 ? "DWARF64" : "DWARF32"));
 
   LineTable &LT = Gen->addLineTable(Format);
   DWARFDebugLine::Prologue Prologue = LT.createBasicPrologue();
   Prologue.PrologueLength -= 2;
   LT.setPrologue(Prologue);

 
 #ifdef _AIX
 TEST_F(DebugLineBasicFixture,
        DISABLED_ErrorForExtendedOpcodeLengthSmallerThanExpected) {
 #else
 TEST_F(DebugLineBasicFixture, ErrorForExtendedOpcodeLengthSmallerThanExpected) {
 #endif
   if (!setupGenerator())
-    return;
+    GTEST_SKIP();
 
   LineTable &LT = Gen->addLineTable();
   LT.addByte(0xaa);
   // The Length should be 1 + sizeof(ULEB) for a set discriminator opcode.
   // The operand will be read for both the discriminator opcode and then parsed
   // again as DW_LNS_negate_stmt, to respect the claimed length.
   LT.addExtendedOpcode(1, DW_LNE_set_discriminator,
                        {{DW_LNS_negate_stmt, LineTable::ULEB}});

 
 #ifdef _AIX
 TEST_F(DebugLineBasicFixture,
        DISABLED_ErrorForExtendedOpcodeLengthLargerThanExpected) {
 #else
 TEST_F(DebugLineBasicFixture, ErrorForExtendedOpcodeLengthLargerThanExpected) {
 #endif
   if (!setupGenerator())
-    return;
+    GTEST_SKIP();
 
   LineTable &LT = Gen->addLineTable();
   LT.addByte(0xaa);
   LT.addStandardOpcode(DW_LNS_const_add_pc, {});
   // The Length should be 1 for an end sequence opcode.
   LT.addExtendedOpcode(2, DW_LNE_end_sequence, {});
   // The negate statement opcode will be skipped.
   LT.addStandardOpcode(DW_LNS_negate_stmt, {});

 }
 
 #ifdef _AIX
 TEST_F(DebugLineBasicFixture, DISABLED_ErrorForUnitLengthTooLarge) {
 #else
 TEST_F(DebugLineBasicFixture, ErrorForUnitLengthTooLarge) {
 #endif
   if (!setupGenerator())
-    return;
+    GTEST_SKIP();
 
   LineTable &Padding = Gen->addLineTable();
   // Add some padding to show that a non-zero offset is handled correctly.
   Padding.setCustomPrologue({{0, LineTable::Byte}});
   LineTable &LT = Gen->addLineTable();
   LT.addStandardOpcode(DW_LNS_copy, {});
   LT.addStandardOpcode(DW_LNS_const_add_pc, {});
   LT.addExtendedOpcode(1, DW_LNE_end_sequence, {});

 }
 
 #ifdef _AIX
 TEST_F(DebugLineBasicFixture, DISABLED_ErrorForMismatchedAddressSize) {
 #else
 TEST_F(DebugLineBasicFixture, ErrorForMismatchedAddressSize) {
 #endif
   if (!setupGenerator(4, 8))
-    return;
+    GTEST_SKIP();
 
   LineTable &LT = Gen->addLineTable();
   // The line data extractor expects size 8 (Quad) addresses.
   uint64_t Addr1 = 0x11223344;
   LT.addExtendedOpcode(5, DW_LNE_set_address, {{Addr1, LineTable::Long}});
   LT.addStandardOpcode(DW_LNS_copy, {});
   // Show that the expected address size is unchanged, so later valid lines
   // don't cause a problem.

 #ifdef _AIX
 TEST_F(DebugLineBasicFixture,
        DISABLED_ErrorForMismatchedAddressSizeUnsetInitialAddress) {
 #else
 TEST_F(DebugLineBasicFixture,
        ErrorForMismatchedAddressSizeUnsetInitialAddress) {
 #endif
   if (!setupGenerator(4, 0))
-    return;
+    GTEST_SKIP();
 
   LineTable &LT = Gen->addLineTable();
   uint64_t Addr1 = 0x11223344;
   LT.addExtendedOpcode(5, DW_LNE_set_address, {{Addr1, LineTable::Long}});
   LT.addStandardOpcode(DW_LNS_copy, {});
   uint64_t Addr2 = 0x1122334455667788;
   LT.addExtendedOpcode(9, DW_LNE_set_address, {{Addr2, LineTable::Quad}});
   LT.addExtendedOpcode(1, DW_LNE_end_sequence, {});
TEST_F(DebugLineBasicFixture,
        DISABLED_ErrorForUnsupportedAddressSizeInSetAddressLength) {
 #else
 TEST_F(DebugLineBasicFixture,
        ErrorForUnsupportedAddressSizeInSetAddressLength) {
 #endif
   // Use DWARF v4, and 0 for data extractor address size so that the address
   // size is derived from the opcode length.
   if (!setupGenerator(4, 0))
-    return;
+    GTEST_SKIP();
 
   LineTable &LT = Gen->addLineTable();
   // 4 == length of the extended opcode, i.e. 1 for the opcode itself and 3 for
   // the Half (2) + Byte (1) operand, representing the unsupported address size.
   LT.addExtendedOpcode(4, DW_LNE_set_address,
                        {{0x1234, LineTable::Half}, {0x56, LineTable::Byte}});
   LT.addStandardOpcode(DW_LNS_copy, {});
   // Special opcode to ensure the address has changed between the first and last

 #ifdef _AIX
 TEST_F(DebugLineBasicFixture, DISABLED_ErrorForAddressSizeGreaterThanByteSize) {
 #else
 TEST_F(DebugLineBasicFixture, ErrorForAddressSizeGreaterThanByteSize) {
 #endif
   // Use DWARF v4, and 0 for data extractor address size so that the address
   // size is derived from the opcode length.
   if (!setupGenerator(4, 0))
-    return;
+    GTEST_SKIP();
 
   LineTable &LT = Gen->addLineTable();
   // Specifically use an operand size that has a trailing byte of a supported
   // size (8), so that any potential truncation would result in a valid size.
   std::vector<LineTable::ValueAndLength> Operands(0x108);
   LT.addExtendedOpcode(Operands.size() + 1, DW_LNE_set_address, Operands);
   LT.addExtendedOpcode(1, DW_LNE_end_sequence, {});
 

 TEST_F(DebugLineBasicFixture,
        DISABLED_ErrorForUnsupportedAddressSizeDefinedInHeader) {
 #else
 TEST_F(DebugLineBasicFixture, ErrorForUnsupportedAddressSizeDefinedInHeader) {
 #endif
   // Use 0 for data extractor address size so that it does not clash with the
   // header address size.
   if (!setupGenerator(5, 0))
-    return;
+    GTEST_SKIP();
 
   LineTable &LT = Gen->addLineTable();
   // AddressSize + 1 == length of the extended opcode, i.e. 1 for the opcode
   // itself and 9 for the Quad (8) + Byte (1) operand representing the
   // unsupported address size.
   uint8_t AddressSize = 9;
   LT.addExtendedOpcode(AddressSize + 1, DW_LNE_set_address,
                        {{0x12345678, LineTable::Quad}, {0, LineTable::Byte}});

 }
 
 #ifdef _AIX
 TEST_F(DebugLineBasicFixture, DISABLED_CallbackUsedForUnterminatedSequence) {
 #else
 TEST_F(DebugLineBasicFixture, CallbackUsedForUnterminatedSequence) {
 #endif
   if (!setupGenerator())
-    return;
+    GTEST_SKIP();
 
   LineTable &LT = Gen->addLineTable();
   LT.addExtendedOpcode(9, DW_LNE_set_address,
                        {{0x1122334455667788, LineTable::Quad}});
   LT.addStandardOpcode(DW_LNS_copy, {});
   LT.addByte(0xaa);
   LT.addExtendedOpcode(1, DW_LNE_end_sequence, {});
   LT.addExtendedOpcode(9, DW_LNE_set_address,
if (!IsErrorExpected) {
                              ExpectedHex + ", " + MsgSuffix)
                                 .str()));
     }
     return ExpectedTable;
   }
 
   void runTest(bool CheckAdvancePC, Twine MsgSuffix) {
     if (!setupGenerator(Version))
-      return;
+      GTEST_SKIP();
 
     setupTables(/*AddAdvancePCFirstTable=*/CheckAdvancePC);
 
     generate();
 
     auto ExpectedNoProblem = Line.getOrParseLineTable(
         LineData, NoProblemOffset, *Context, nullptr, RecordRecoverable);
     EXPECT_THAT_ERROR(std::move(Recoverable), Succeeded());
Values(std::make_tuple(0, true),    // Test zero value (error).
            std::make_tuple(1, false))); // Test non-zero value (no error).
 
 #ifdef _AIX
 TEST_F(DebugLineBasicFixture, DISABLED_ParserParsesCorrectly) {
 #else
 TEST_F(DebugLineBasicFixture, ParserParsesCorrectly) {
 #endif
   if (!setupGenerator())
-    return;
+    GTEST_SKIP();
 
   DWARFDebugLine::SectionParser Parser = setupParser();
 
   EXPECT_EQ(Parser.getOffset(), 0u);
   ASSERT_FALSE(Parser.done());
 
   DWARFDebugLine::LineTable Parsed =
       Parser.parseNext(RecordRecoverable, RecordUnrecoverable);

 }
 
 #ifdef _AIX
 TEST_F(DebugLineBasicFixture, DISABLED_ParserSkipsCorrectly) {
 #else
 TEST_F(DebugLineBasicFixture, ParserSkipsCorrectly) {
 #endif
   if (!setupGenerator())
-    return;
+    GTEST_SKIP();
 
   DWARFDebugLine::SectionParser Parser = setupParser();
 
   EXPECT_EQ(Parser.getOffset(), 0u);
   ASSERT_FALSE(Parser.done());
 
   Parser.skip(RecordRecoverable, RecordUnrecoverable);
   EXPECT_EQ(Parser.getOffset(), 62u);
   ASSERT_FALSE(Parser.done());
 
   Parser.skip(RecordRecoverable, RecordUnrecoverable);
   EXPECT_EQ(Parser.getOffset(), 136u);
   EXPECT_TRUE(Parser.done());
 
   EXPECT_FALSE(Recoverable);
   EXPECT_FALSE(Unrecoverable);
 }
 
 #ifdef _AIX
 TEST_F(DebugLineBasicFixture, DISABLED_ParserAlwaysDoneForEmptySection) {
 #else
 TEST_F(DebugLineBasicFixture, ParserAlwaysDoneForEmptySection) {
 #endif
   if (!setupGenerator())
-    return;
+    GTEST_SKIP();
 
   generate();
   DWARFDebugLine::SectionParser Parser(LineData, *Context, Units);
 
   EXPECT_TRUE(Parser.done());
 }
 
 #ifdef _AIX
 TEST_F(DebugLineBasicFixture,
        DISABLED_ParserMarkedAsDoneForBadLengthWhenParsing) {
 #else
 TEST_F(DebugLineBasicFixture, ParserMarkedAsDoneForBadLengthWhenParsing) {
 #endif
   if (!setupGenerator())
-    return;
+    GTEST_SKIP();
 
   LineTable &LT = Gen->addLineTable();
   LT.setCustomPrologue({{0xfffffff0, LineTable::Long}});
   Gen->addLineTable();
   generate();
 
   DWARFDebugLine::SectionParser Parser(LineData, *Context, Units);
   Parser.parseNext(RecordRecoverable, RecordUnrecoverable);

 
 #ifdef _AIX
 TEST_F(DebugLineBasicFixture,
        DISABLED_ParserMarkedAsDoneForBadLengthWhenSkipping) {
 #else
 TEST_F(DebugLineBasicFixture, ParserMarkedAsDoneForBadLengthWhenSkipping) {
 #endif
   if (!setupGenerator())
-    return;
+    GTEST_SKIP();
 
   LineTable &LT = Gen->addLineTable();
   LT.setCustomPrologue({{0xfffffff0, LineTable::Long}});
   Gen->addLineTable();
   generate();
 
   DWARFDebugLine::SectionParser Parser(LineData, *Context, Units);
   Parser.skip(RecordRecoverable, RecordUnrecoverable);

 
 #ifdef _AIX
 TEST_F(DebugLineBasicFixture,
        DISABLED_ParserReportsFirstErrorInEachTableWhenParsing) {
 #else
 TEST_F(DebugLineBasicFixture, ParserReportsFirstErrorInEachTableWhenParsing) {
 #endif
   if (!setupGenerator())
-    return;
+    GTEST_SKIP();
 
   LineTable &LT = Gen->addLineTable(DWARF32);
   LT.setCustomPrologue({{2, LineTable::Long}, {0, LineTable::Half}});
   LineTable &LT2 = Gen->addLineTable(DWARF32);
   LT2.setCustomPrologue({{2, LineTable::Long}, {1, LineTable::Half}});
   generate();
 
   DWARFDebugLine::SectionParser Parser(LineData, *Context, Units);

 
 #ifdef _AIX
 TEST_F(DebugLineBasicFixture,
        DISABLED_ParserReportsNonPrologueProblemsWhenParsing) {
 #else
 TEST_F(DebugLineBasicFixture, ParserReportsNonPrologueProblemsWhenParsing) {
 #endif
   if (!setupGenerator())
-    return;
+    GTEST_SKIP();
 
   LineTable &LT = Gen->addLineTable(DWARF32);
   LT.addExtendedOpcode(0x42, DW_LNE_end_sequence, {});
   LineTable &LT2 = Gen->addLineTable(DWARF32);
   LT2.addExtendedOpcode(9, DW_LNE_set_address,
                         {{0x1234567890abcdef, LineTable::Quad}});
   LT2.addStandardOpcode(DW_LNS_copy, {});
   LT2.addByte(0xbb);

 #ifdef _AIX
 TEST_F(DebugLineBasicFixture,
        DISABLED_ParserReportsPrologueErrorsInEachTableWhenSkipping) {
 #else
 TEST_F(DebugLineBasicFixture,
        ParserReportsPrologueErrorsInEachTableWhenSkipping) {
 #endif
   if (!setupGenerator())
-    return;
+    GTEST_SKIP();
 
   LineTable &LT = Gen->addLineTable(DWARF32);
   LT.setCustomPrologue({{2, LineTable::Long}, {0, LineTable::Half}});
   LineTable &LT2 = Gen->addLineTable(DWARF32);
   LT2.setCustomPrologue({{2, LineTable::Long}, {1, LineTable::Half}});
   generate();
 
   DWARFDebugLine::SectionParser Parser(LineData, *Context, Units);

 
 #ifdef _AIX
 TEST_F(DebugLineBasicFixture,
        DISABLED_ParserIgnoresNonPrologueErrorsWhenSkipping) {
 #else
 TEST_F(DebugLineBasicFixture, ParserIgnoresNonPrologueErrorsWhenSkipping) {
 #endif
   if (!setupGenerator())
-    return;
+    GTEST_SKIP();
 
   LineTable &LT = Gen->addLineTable(DWARF32);
   LT.addExtendedOpcode(42, DW_LNE_end_sequence, {});
   generate();
 
   DWARFDebugLine::SectionParser Parser(LineData, *Context, Units);
   Parser.skip(RecordRecoverable, RecordUnrecoverable);
 
   EXPECT_TRUE(Parser.done());
   EXPECT_FALSE(Recoverable);
   EXPECT_FALSE(Unrecoverable);
 }
 
 #ifdef _AIX
 TEST_F(DebugLineBasicFixture, DISABLED_VerboseOutput) {
 #else
 TEST_F(DebugLineBasicFixture, VerboseOutput) {
 #endif
   if (!setupGenerator(5))
-    return;
+    GTEST_SKIP();
 
   LineTable &LT = Gen->addLineTable();
   LT.addByte(0); // Extended opcode with zero length.
   LT.addByte(0);
   // Zero-value extended opcode.
   LT.addExtendedOpcode(2, 0, {{1, LineTable::Byte}});
   // Unknown extended opcode.
   LT.addExtendedOpcode(2, 0x42, {{1, LineTable::Byte}});

 };
 
 #ifdef _AIX
 TEST_P(TruncatedPrologueFixture, DISABLED_ErrorForTruncatedPrologue) {
 #else
 TEST_P(TruncatedPrologueFixture, ErrorForTruncatedPrologue) {
 #endif
   if (!setupGenerator(Version))
-    return;
+    GTEST_SKIP();
 
   LineTable &Padding = Gen->addLineTable();
   // Add some padding to show that a non-zero offset is handled correctly.
   Padding.setCustomPrologue({{0, LineTable::Byte}});
 
   // Add a table with only two standard opcodes - we don't need to test the full
   // set.
   LineTable &Table = Gen->addLineTable(Format);

 
 #ifdef _AIX
 TEST_P(TruncatedExtendedOpcodeFixture,
        DISABLED_ErrorForTruncatedExtendedOpcode) {
 #else
 TEST_P(TruncatedExtendedOpcodeFixture, ErrorForTruncatedExtendedOpcode) {
 #endif
   if (!setupGenerator())
-    return;
+    GTEST_SKIP();
   LineTable &LT = setupTable();
   LT.addExtendedOpcode(OpcodeLength, Opcode, Operands);
   runTest(0);
   EXPECT_THAT_ERROR(std::move(Recoverable),
                     FailedWithMessage(ExpectedErr.str()));
 }
 
 INSTANTIATE_TEST_SUITE_P(

 
 #ifdef _AIX
 TEST_P(TruncatedStandardOpcodeFixture,
        DISABLED_ErrorForTruncatedStandardOpcode) {
 #else
 TEST_P(TruncatedStandardOpcodeFixture, ErrorForTruncatedStandardOpcode) {
 #endif
   if (!setupGenerator())
-    return;
+    GTEST_SKIP();
   LineTable &LT = setupTable();
   LT.addStandardOpcode(Opcode, Operands);
   runTest(Opcode);
   EXPECT_THAT_ERROR(std::move(Unrecoverable),
                     FailedWithMessage(ExpectedErr.str()));
 }
 
 INSTANTIATE_TEST_SUITE_P(
Values(
             "malformed uleb128, extends past end")));
 
 #ifdef _AIX
 TEST_F(DebugLineBasicFixture, DISABLED_PrintPathsProperly) {
 #else
 TEST_F(DebugLineBasicFixture, PrintPathsProperly) {
 #endif
   if (!setupGenerator(5))
-    return;
+    GTEST_SKIP();
 
   LineTable &LT = Gen->addLineTable();
   DWARFDebugLine::Prologue P = LT.createBasicPrologue();
   P.IncludeDirectories.push_back(
       DWARFFormValue::createFromPValue(DW_FORM_string, "b dir"));
   P.FileNames.push_back(DWARFDebugLine::FileNameEntry());
   P.FileNames.back().Name =
       DWARFFormValue::createFromPValue(DW_FORM_string, "b file");

llvm/unittests/DebugInfo/DWARF/DWARFDieManualExtractTest.cpp

 
 namespace {
 
 TEST(DWARFDie, manualExtractDump) {
   typedef uint32_t AddrType;
   uint16_t Version = 4;
   Triple Triple = getDefaultTargetTripleForAddrSize(sizeof(AddrType));
   if (!isConfigurationSupported(Triple))
-    return;
+    GTEST_SKIP();
 
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
   ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
   dwarfgen::Generator *DG = ExpectedDG.get().get();
   dwarfgen::CompileUnit &DGCU = DG->addCompileUnit();
   dwarfgen::DIE CUDie = DGCU.getUnitDIE();
 
   CUDie.addAttribute(DW_AT_name, DW_FORM_strp, "/tmp/main.c");

llvm/unittests/DebugInfo/DWARF/DWARFExpressionCompactPrinterTest.cpp

public:
   void TestExprPrinter(ArrayRef<uint8_t> ExprData, StringRef Expected);
 };
 } // namespace
 
 void DWARFExpressionCompactPrinterTest::TestExprPrinter(
     ArrayRef<uint8_t> ExprData, StringRef Expected) {
   // If we didn't build ARM, do not run the test.
   if (!MRI)
-    return;
+    GTEST_SKIP();
 
   // Print the expression, passing in the subprogram DIE, and check that the
   // result is as expected.
   std::string Result;
   raw_string_ostream OS(Result);
   DataExtractor DE(ExprData, true, 8);
   DWARFExpression Expr(DE, 8);
   Expr.printCompact(OS, *MRI);

llvm/unittests/DebugInfo/DWARF/DWARFExpressionCopyBytesTest.cpp

void DWARFExpressionCopyBytesTest::readAndCheckObjFile(
   if (auto *E = dyn_cast<llvm::object::ELFObjectFileBase>(&*Bin)) {
     parseCFIsAndCheckExpression(*E, Expected);
   }
 }
 
 void DWARFExpressionCopyBytesTest::testExpr(ArrayRef<uint8_t> ExprData) {
   // If we didn't build x86, do not run the test.
   if (!MRI)
-    return;
+    GTEST_SKIP();
 
   DataExtractor DE(ExprData, true, 8);
   DWARFExpression Expr(DE, 8);
 
   // Copy this expression into the CFI of a binary and check that we are able to
   // get it back correctly from this binary.
   const SmallString<0> EmittedBinContents = emitObjFile(Expr.getData());
   readAndCheckObjFile(EmittedBinContents.str(), ExprData);