[unittests] Split DWARF tests out of PDB, fix standalone build

[mgorny]

Summary

Split the PDB tests into DWARF test and actual PDB tests, the latter
requiring DIA SDK. Use the new LLVMConfig.cmake LLVM_ENABLE_DIA_SDK
symbol to enable the PDB tests rather than relying on
llvm/Config/config.h private include file that is not available when
building standalone.

[zturner]

Is this necessary because of a standalone build, or for some other reason? If this is to get Standalone build working, then it seems like this isn't really a complete solution, because standalone build still wouldn't work on Windows since it would still be trying to include the private header. What about making a separate unittest file called SymbolFilePDBDIATests.cpp and excluding it at the CMake level?

[mgorny]

In D26249#585869, @zturner wrote:

Is this necessary because of a standalone build, or for some other reason? If this is to get Standalone build working, then it seems like this isn't really a complete solution, because standalone build still wouldn't work on Windows since it would still be trying to include the private header.

Yes, it is. However, since I don't have a Windows environment, I can't really test any Windows solution. With the very limited support for stand-alone builds right now, I see this as a feasible improvement to make tests work on Gentoo ;-).

What about making a separate unittest file called SymbolFilePDBDIATests.cpp and excluding it at the CMake level?

I don't mind doing that; however, it won't fix the issue in question. CMake doesn't know the state of HAVE_DIA either since it is available only during LLVM build. If we want to have Windows support there, we probably need to copy the check result to the public LLVMConfig.h.

[zturner]

What if we added a function to llvm/DebugInfo/PDB/PDB.h called isDiaSupported(), and in the implementation it returns true if the definition is present and false otherwise. Then instead of using the pre-processor to decide whether to run the test, we run all of them but just return true if isDiaSupported() returns false?

[mgorny]

I can't say it wouldn't work but I think exposing that as part of public API would be ugly-ish. So I'd rather go for either exposing it in llvm-config.h, or LLVMConfig.cmake (and then redeclaring inside LLDB) -- with preference on the former as requiring least work.

[zturner]

That sounds reasonable.

[mgorny]

Here's an updated patch. I've decided to go for the initial idea of splitting the tests, combined with LLVMConfig update.

D26255 updates LLVM to include LLVM_ENABLE_DIA_SDK in LLVMConfig.cmake (it already provides similar variables). The variable is also still used to set HAVE_DIA_SDK in config.h, so old versions of LLDB will continue to build fine in-tree.

This one splits the previous test into DWARF and actual PDB tests. The DWARF test is run unconditionally, while the other is run only when DIA SDK is available. As I said, I don't have Windows handy, so I wasn't able to test the latter part. However, unless I failed at syntax when modifying it, it should work (I only removed the include, the DWARF test and file, and removed the DIA SDK magic).

[zturner]

looks good, sorry for the delay was busy with the LLVM dev conference.

unittests/SymbolFile/DWARF/SymbolFileDWARFTests.cpp

33–36 ↗

(On Diff #76766)

This can go away, along with all the other preprocessor definitions. (only for the dwarf-specific test file).

lldb/trunk/unittests/SymbolFile/CMakeLists.txt

+add_subdirectory(DWARF)
+if (LLVM_ENABLE_DIA_SDK)
   add_subdirectory(PDB)
+endif()

lldb/trunk/unittests/SymbolFile/DWARF/CMakeLists.txt

+add_lldb_unittest(SymbolFileDWARFTests
+  SymbolFileDWARFTests.cpp
+  )
+
+set(test_inputs
+   test-dwarf.exe)
+
+add_unittest_inputs(SymbolFileDWARFTests "${test_inputs}")

lldb/trunk/unittests/SymbolFile/DWARF/Inputs/test-dwarf.cpp

+// Compile with "cl /c /Zi /GR- test.cpp"
+// Link with "link test.obj /debug /nodefaultlib /entry:main /out:test.exe"
+
+int __cdecl _purecall(void) { return 0; }
+
+int main(int argc, char **argv) { return 0; }

lldb/trunk/unittests/SymbolFile/DWARF/SymbolFileDWARFTests.cpp

+//===-- PythonDataObjectsTests.cpp ------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "gtest/gtest.h"
+
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/DebugInfo/PDB/PDBSymbolData.h"
+#include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Path.h"
+
+#include "lldb/Core/Address.h"
+#include "lldb/Core/ArchSpec.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Core/ModuleSpec.h"
+#include "lldb/Host/FileSpec.h"
+#include "lldb/Host/HostInfo.h"
+#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/CompileUnit.h"
+#include "lldb/Symbol/LineTable.h"
+#include "lldb/Symbol/SymbolVendor.h"
+
+#include "Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h"
+#include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
+#include "Plugins/SymbolFile/PDB/SymbolFilePDB.h"
+
+extern const char *TestMainArgv0;
+
+using namespace lldb_private;
+
+class SymbolFileDWARFTests : public testing::Test {
+public:
+  void SetUp() override {
+// Initialize and TearDown the plugin every time, so we get a brand new
+// AST every time so that modifications to the AST from each test don't
+// leak into the next test.
+    HostInfo::Initialize();
+    ObjectFilePECOFF::Initialize();
+    SymbolFileDWARF::Initialize();
+    ClangASTContext::Initialize();
+    SymbolFilePDB::Initialize();
+
+    llvm::StringRef exe_folder = llvm::sys::path::parent_path(TestMainArgv0);
+    llvm::SmallString<128> inputs_folder = exe_folder;
+    llvm::sys::path::append(inputs_folder, "Inputs");
+
+    m_dwarf_test_exe = inputs_folder;
+    llvm::sys::path::append(m_dwarf_test_exe, "test-dwarf.exe");
+  }
+
+  void TearDown() override {
+    SymbolFilePDB::Terminate();
+    ClangASTContext::Initialize();
+    SymbolFileDWARF::Terminate();
+    ObjectFilePECOFF::Terminate();
+    HostInfo::Terminate();
+  }
+
+protected:
+  llvm::SmallString<128> m_dwarf_test_exe;
+};
+
+TEST_F(SymbolFileDWARFTests, TestAbilitiesForDWARF) {
+  // Test that when we have Dwarf debug info, SymbolFileDWARF is used.
+  FileSpec fspec(m_dwarf_test_exe.c_str(), false);
+  ArchSpec aspec("i686-pc-windows");
+  lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
+
+  SymbolVendor *plugin = module->GetSymbolVendor();
+  EXPECT_NE(nullptr, plugin);
+  SymbolFile *symfile = plugin->GetSymbolFile();
+  EXPECT_NE(nullptr, symfile);
+  EXPECT_EQ(symfile->GetPluginName(), SymbolFileDWARF::GetPluginNameStatic());
+
+  uint32_t expected_abilities = SymbolFile::kAllAbilities;
+  EXPECT_EQ(expected_abilities, symfile->CalculateAbilities());
+}

lldb/trunk/unittests/SymbolFile/PDB/CMakeLists.txt

 add_lldb_unittest(SymbolFilePDBTests
   SymbolFilePDBTests.cpp
   )
 
 set(test_inputs
    test-pdb.exe
    test-pdb.pdb
-   test-dwarf.exe
    test-pdb-types.exe
    test-pdb-types.pdb)
 
-add_unittest_inputs(SymbolFilePDBTests "${test_inputs}")  
+add_unittest_inputs(SymbolFilePDBTests "${test_inputs}")

lldb/trunk/unittests/SymbolFile/PDB/Inputs/test-dwarf.cpp

-// Compile with "cl /c /Zi /GR- test.cpp"
-// Link with "link test.obj /debug /nodefaultlib /entry:main /out:test.exe"
-
-int __cdecl _purecall(void) { return 0; }
-
-int main(int argc, char **argv) { return 0; }

lldb/trunk/unittests/SymbolFile/PDB/SymbolFilePDBTests.cpp

 //===-- PythonDataObjectsTests.cpp ------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "gtest/gtest.h"
 
 #include "llvm/ADT/STLExtras.h"
-#include "llvm/Config/config.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolData.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/Module.h"
#endif
     ClangASTContext::Initialize();
     SymbolFilePDB::Initialize();
 
     llvm::StringRef exe_folder = llvm::sys::path::parent_path(TestMainArgv0);
     llvm::SmallString<128> inputs_folder = exe_folder;
     llvm::sys::path::append(inputs_folder, "Inputs");
 
     m_pdb_test_exe = inputs_folder;
-    m_dwarf_test_exe = inputs_folder;
     m_types_test_exe = inputs_folder;
     llvm::sys::path::append(m_pdb_test_exe, "test-pdb.exe");
-    llvm::sys::path::append(m_dwarf_test_exe, "test-dwarf.exe");
     llvm::sys::path::append(m_types_test_exe, "test-pdb-types.exe");
   }
 
   void TearDown() override {
     SymbolFilePDB::Terminate();
     ClangASTContext::Initialize();
     SymbolFileDWARF::Terminate();
     ObjectFilePECOFF::Terminate();
     HostInfo::Terminate();
 
 #if defined(_MSC_VER)
     ::CoUninitialize();
 #endif
   }
 
 protected:
   llvm::SmallString<128> m_pdb_test_exe;
-  llvm::SmallString<128> m_dwarf_test_exe;
   llvm::SmallString<128> m_types_test_exe;
 
   bool FileSpecMatchesAsBaseOrFull(const FileSpec &left,
                                    const FileSpec &right) const {
     // If the filenames don't match, the paths can't be equal
     if (!left.FileEquals(right))
       return false;
     // If BOTH have a directory, also compare the directories.
uint64_t GetGlobalConstantInteger(const llvm::pdb::IPDBSession &session,
     case llvm::pdb::PDB_VariantType::UInt32:
       return value.Value.UInt32;
     default:
       return 0;
     }
   }
 };
 
-#if HAVE_DIA_SDK
-#define REQUIRES_DIA_SDK(TestName) TestName
-#else
-#define REQUIRES_DIA_SDK(TestName) DISABLED_##TestName
-#endif
-
-TEST_F(SymbolFilePDBTests, TestAbilitiesForDWARF) {
-  // Test that when we have Dwarf debug info, SymbolFileDWARF is used.
-  FileSpec fspec(m_dwarf_test_exe.c_str(), false);
-  ArchSpec aspec("i686-pc-windows");
-  lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
-
-  SymbolVendor *plugin = module->GetSymbolVendor();
-  EXPECT_NE(nullptr, plugin);
-  SymbolFile *symfile = plugin->GetSymbolFile();
-  EXPECT_NE(nullptr, symfile);
-  EXPECT_EQ(symfile->GetPluginName(), SymbolFileDWARF::GetPluginNameStatic());
-
-  uint32_t expected_abilities = SymbolFile::kAllAbilities;
-  EXPECT_EQ(expected_abilities, symfile->CalculateAbilities());
-}
-
-TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestAbilitiesForPDB)) {
+TEST_F(SymbolFilePDBTests, TestAbilitiesForPDB) {
   // Test that when we have PDB debug info, SymbolFilePDB is used.
   FileSpec fspec(m_pdb_test_exe.c_str(), false);
   ArchSpec aspec("i686-pc-windows");
   lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
 
   SymbolVendor *plugin = module->GetSymbolVendor();
   EXPECT_NE(nullptr, plugin);
   SymbolFile *symfile = plugin->GetSymbolFile();
   EXPECT_NE(nullptr, symfile);
   EXPECT_EQ(symfile->GetPluginName(), SymbolFilePDB::GetPluginNameStatic());
 
   uint32_t expected_abilities =
       SymbolFile::CompileUnits | SymbolFile::LineTables;
   EXPECT_EQ(expected_abilities, symfile->CalculateAbilities());
 }
 
-TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestResolveSymbolContextBasename)) {
+TEST_F(SymbolFilePDBTests, TestResolveSymbolContextBasename) {
   // Test that attempting to call ResolveSymbolContext with only a basename
   // finds all full paths
   // with the same basename
   FileSpec fspec(m_pdb_test_exe.c_str(), false);
   ArchSpec aspec("i686-pc-windows");
   lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
 
   SymbolVendor *plugin = module->GetSymbolVendor();
   EXPECT_NE(nullptr, plugin);
   SymbolFile *symfile = plugin->GetSymbolFile();
 
   FileSpec header_spec("test-pdb.cpp", false);
   SymbolContextList sc_list;
   uint32_t result_count = symfile->ResolveSymbolContext(
       header_spec, 0, false, lldb::eSymbolContextCompUnit, sc_list);
   EXPECT_EQ(1u, result_count);
   EXPECT_TRUE(ContainsCompileUnit(sc_list, header_spec));
 }
 
-TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestResolveSymbolContextFullPath)) {
+TEST_F(SymbolFilePDBTests, TestResolveSymbolContextFullPath) {
   // Test that attempting to call ResolveSymbolContext with a full path only
   // finds the one source
   // file that matches the full path.
   FileSpec fspec(m_pdb_test_exe.c_str(), false);
   ArchSpec aspec("i686-pc-windows");
   lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
 
   SymbolVendor *plugin = module->GetSymbolVendor();
   EXPECT_NE(nullptr, plugin);
   SymbolFile *symfile = plugin->GetSymbolFile();
 
   FileSpec header_spec(
       R"spec(D:\src\llvm\tools\lldb\unittests\SymbolFile\PDB\Inputs\test-pdb.cpp)spec",
       false);
   SymbolContextList sc_list;
   uint32_t result_count = symfile->ResolveSymbolContext(
       header_spec, 0, false, lldb::eSymbolContextCompUnit, sc_list);
   EXPECT_GE(1u, result_count);
   EXPECT_TRUE(ContainsCompileUnit(sc_list, header_spec));
 }
 
 TEST_F(SymbolFilePDBTests,
-       REQUIRES_DIA_SDK(TestLookupOfHeaderFileWithInlines)) {
+       TestLookupOfHeaderFileWithInlines) {
   // Test that when looking up a header file via ResolveSymbolContext (i.e. a
   // file that was not by itself
   // compiled, but only contributes to the combined code of other source files),
   // a SymbolContext is returned
   // for each compiland which has line contributions from the requested header.
   FileSpec fspec(m_pdb_test_exe.c_str(), false);
   ArchSpec aspec("i686-pc-windows");
   lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
for (const auto &hspec : header_specs) {
     uint32_t result_count = symfile->ResolveSymbolContext(
         hspec, 0, true, lldb::eSymbolContextCompUnit, sc_list);
     EXPECT_EQ(2u, result_count);
     EXPECT_TRUE(ContainsCompileUnit(sc_list, main_cpp_spec));
     EXPECT_TRUE(ContainsCompileUnit(sc_list, alt_cpp_spec));
   }
 }
 
-TEST_F(SymbolFilePDBTests,
-       REQUIRES_DIA_SDK(TestLookupOfHeaderFileWithNoInlines)) {
+TEST_F(SymbolFilePDBTests, TestLookupOfHeaderFileWithNoInlines) {
   // Test that when looking up a header file via ResolveSymbolContext (i.e. a
   // file that was not by itself
   // compiled, but only contributes to the combined code of other source files),
   // that if check_inlines
   // is false, no SymbolContexts are returned.
   FileSpec fspec(m_pdb_test_exe.c_str(), false);
   ArchSpec aspec("i686-pc-windows");
   lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
 
   SymbolVendor *plugin = module->GetSymbolVendor();
   EXPECT_NE(nullptr, plugin);
   SymbolFile *symfile = plugin->GetSymbolFile();
 
   FileSpec header_specs[] = {FileSpec("test-pdb.h", false),
                              FileSpec("test-pdb-nested.h", false)};
   for (const auto &hspec : header_specs) {
     SymbolContextList sc_list;
     uint32_t result_count = symfile->ResolveSymbolContext(
         hspec, 0, false, lldb::eSymbolContextCompUnit, sc_list);
     EXPECT_EQ(0u, result_count);
   }
 }
 
-TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestLineTablesMatchAll)) {
+TEST_F(SymbolFilePDBTests, TestLineTablesMatchAll) {
   // Test that when calling ResolveSymbolContext with a line number of 0, all
   // line entries from
   // the specified files are returned.
   FileSpec fspec(m_pdb_test_exe.c_str(), false);
   ArchSpec aspec("i686-pc-windows");
   lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
 
   SymbolVendor *plugin = module->GetSymbolVendor();
TEST_F(SymbolFilePDBTests, TestLineTablesMatchAll) {
   VerifyLineEntry(module, sc, header1, *lt, 10, 0x401093);
   VerifyLineEntry(module, sc, header1, *lt, 11, 0x4010a2);
 
   VerifyLineEntry(module, sc, header2, *lt, 5, 0x401080);
   VerifyLineEntry(module, sc, header2, *lt, 6, 0x401083);
   VerifyLineEntry(module, sc, header2, *lt, 7, 0x401089);
 }
 
-TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestLineTablesMatchSpecific)) {
+TEST_F(SymbolFilePDBTests, TestLineTablesMatchSpecific) {
   // Test that when calling ResolveSymbolContext with a specific line number,
   // only line entries
   // which match the requested line are returned.
   FileSpec fspec(m_pdb_test_exe.c_str(), false);
   ArchSpec aspec("i686-pc-windows");
   lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
 
   SymbolVendor *plugin = module->GetSymbolVendor();
TEST_F(SymbolFilePDBTests, TestLineTablesMatchSpecific) {
   count = lt->GetSize();
   // We expect one extra entry for termination
   EXPECT_EQ(3u, count);
 
   VerifyLineEntry(module, sc, source_file, *lt, 9, 0x401045);
   VerifyLineEntry(module, sc, header1, *lt, 9, 0x401090);
 }
 
-TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestSimpleClassTypes)) {
+TEST_F(SymbolFilePDBTests, TestSimpleClassTypes) {
   FileSpec fspec(m_types_test_exe.c_str(), false);
   ArchSpec aspec("i686-pc-windows");
   lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
 
   SymbolVendor *plugin = module->GetSymbolVendor();
   SymbolFilePDB *symfile =
       static_cast<SymbolFilePDB *>(plugin->GetSymbolFile());
   const llvm::pdb::IPDBSession &session = symfile->GetPDBSession();
   SymbolContext sc;
   llvm::DenseSet<SymbolFile *> searched_files;
   TypeMap results;
   EXPECT_EQ(1u, symfile->FindTypes(sc, ConstString("Class"), nullptr, false, 0,
                                    searched_files, results));
   EXPECT_EQ(1u, results.GetSize());
   lldb::TypeSP udt_type = results.GetTypeAtIndex(0);
   EXPECT_EQ(ConstString("Class"), udt_type->GetName());
   CompilerType compiler_type = udt_type->GetForwardCompilerType();
   EXPECT_TRUE(ClangASTContext::IsClassType(compiler_type.GetOpaqueQualType()));
   EXPECT_EQ(GetGlobalConstantInteger(session, "sizeof_Class"),
             udt_type->GetByteSize());
 }
 
-TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestNestedClassTypes)) {
+TEST_F(SymbolFilePDBTests, TestNestedClassTypes) {
   FileSpec fspec(m_types_test_exe.c_str(), false);
   ArchSpec aspec("i686-pc-windows");
   lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
 
   SymbolVendor *plugin = module->GetSymbolVendor();
   SymbolFilePDB *symfile =
       static_cast<SymbolFilePDB *>(plugin->GetSymbolFile());
   const llvm::pdb::IPDBSession &session = symfile->GetPDBSession();
   SymbolContext sc;
   llvm::DenseSet<SymbolFile *> searched_files;
   TypeMap results;
   EXPECT_EQ(1u, symfile->FindTypes(sc, ConstString("Class::NestedClass"),
                                    nullptr, false, 0, searched_files, results));
   EXPECT_EQ(1u, results.GetSize());
   lldb::TypeSP udt_type = results.GetTypeAtIndex(0);
   EXPECT_EQ(ConstString("Class::NestedClass"), udt_type->GetName());
   CompilerType compiler_type = udt_type->GetForwardCompilerType();
   EXPECT_TRUE(ClangASTContext::IsClassType(compiler_type.GetOpaqueQualType()));
   EXPECT_EQ(GetGlobalConstantInteger(session, "sizeof_NestedClass"),
             udt_type->GetByteSize());
 }
 
-TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestClassInNamespace)) {
+TEST_F(SymbolFilePDBTests, TestClassInNamespace) {
   FileSpec fspec(m_types_test_exe.c_str(), false);
   ArchSpec aspec("i686-pc-windows");
   lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
 
   SymbolVendor *plugin = module->GetSymbolVendor();
   SymbolFilePDB *symfile =
       static_cast<SymbolFilePDB *>(plugin->GetSymbolFile());
   const llvm::pdb::IPDBSession &session = symfile->GetPDBSession();
   SymbolContext sc;
   llvm::DenseSet<SymbolFile *> searched_files;
   TypeMap results;
   EXPECT_EQ(1u, symfile->FindTypes(sc, ConstString("NS::NSClass"), nullptr,
                                    false, 0, searched_files, results));
   EXPECT_EQ(1u, results.GetSize());
   lldb::TypeSP udt_type = results.GetTypeAtIndex(0);
   EXPECT_EQ(ConstString("NS::NSClass"), udt_type->GetName());
   CompilerType compiler_type = udt_type->GetForwardCompilerType();
   EXPECT_TRUE(ClangASTContext::IsClassType(compiler_type.GetOpaqueQualType()));
   EXPECT_EQ(GetGlobalConstantInteger(session, "sizeof_NSClass"),
             udt_type->GetByteSize());
 }
 
-TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestEnumTypes)) {
+TEST_F(SymbolFilePDBTests, TestEnumTypes) {
   FileSpec fspec(m_types_test_exe.c_str(), false);
   ArchSpec aspec("i686-pc-windows");
   lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
 
   SymbolVendor *plugin = module->GetSymbolVendor();
   SymbolFilePDB *symfile =
       static_cast<SymbolFilePDB *>(plugin->GetSymbolFile());
   const llvm::pdb::IPDBSession &session = symfile->GetPDBSession();
for (auto Enum : EnumsToCheck) {
 
     std::string sizeof_var = "sizeof_";
     sizeof_var.append(Enum);
     EXPECT_EQ(GetGlobalConstantInteger(session, sizeof_var),
               enum_type->GetByteSize());
   }
 }
 
-TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestArrayTypes)) {
+TEST_F(SymbolFilePDBTests, TestArrayTypes) {
   // In order to get this test working, we need to support lookup by symbol
   // name.  Because array
   // types themselves do not have names, only the symbols have names (i.e. the
   // name of the array).
 }
 
-TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestFunctionTypes)) {
+TEST_F(SymbolFilePDBTests, TestFunctionTypes) {
   // In order to get this test working, we need to support lookup by symbol
   // name.  Because array
   // types themselves do not have names, only the symbols have names (i.e. the
   // name of the array).
 }
 
-TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestTypedefs)) {
+TEST_F(SymbolFilePDBTests, TestTypedefs) {
   FileSpec fspec(m_types_test_exe.c_str(), false);
   ArchSpec aspec("i686-pc-windows");
   lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
 
   SymbolVendor *plugin = module->GetSymbolVendor();
   SymbolFilePDB *symfile =
       static_cast<SymbolFilePDB *>(plugin->GetSymbolFile());
   const llvm::pdb::IPDBSession &session = symfile->GetPDBSession();
for (auto Typedef : TypedefsToCheck) {
 
     std::string sizeof_var = "sizeof_";
     sizeof_var.append(Typedef);
     EXPECT_EQ(GetGlobalConstantInteger(session, sizeof_var),
               typedef_type->GetByteSize());
   }
 }
 
-TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestRegexNameMatch)) {
+TEST_F(SymbolFilePDBTests, TestRegexNameMatch) {
   FileSpec fspec(m_types_test_exe.c_str(), false);
   ArchSpec aspec("i686-pc-windows");
   lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
 
   SymbolVendor *plugin = module->GetSymbolVendor();
   SymbolFilePDB *symfile =
       static_cast<SymbolFilePDB *>(plugin->GetSymbolFile());
   SymbolContext sc;
   llvm::DenseSet<SymbolFile *> searched_files;
   TypeMap results;
   uint32_t num_results = symfile->FindTypes(sc, ConstString(".*"), nullptr,
                                             false, 0, searched_files, results);
   EXPECT_GT(num_results, 1u);
   EXPECT_EQ(num_results, results.GetSize());
 }
 
-TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestMaxMatches)) {
+TEST_F(SymbolFilePDBTests, TestMaxMatches) {
   FileSpec fspec(m_types_test_exe.c_str(), false);
   ArchSpec aspec("i686-pc-windows");
   lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
 
   SymbolVendor *plugin = module->GetSymbolVendor();
   SymbolFilePDB *symfile =
       static_cast<SymbolFilePDB *>(plugin->GetSymbolFile());
   SymbolContext sc;
TEST_F(SymbolFilePDBTests, TestMaxMatches) {
   for (uint32_t i = 1; i <= iterations; ++i) {
     uint32_t num_limited_results = symfile->FindTypes(
         sc, ConstString(".*"), nullptr, false, i, searched_files, results);
     EXPECT_EQ(i, num_limited_results);
     EXPECT_EQ(num_limited_results, results.GetSize());
   }
 }
 
-TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestNullName)) {
+TEST_F(SymbolFilePDBTests, TestNullName) {
   FileSpec fspec(m_types_test_exe.c_str(), false);
   ArchSpec aspec("i686-pc-windows");
   lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
 
   SymbolVendor *plugin = module->GetSymbolVendor();
   SymbolFilePDB *symfile =
       static_cast<SymbolFilePDB *>(plugin->GetSymbolFile());
   SymbolContext sc;
   llvm::DenseSet<SymbolFile *> searched_files;
   TypeMap results;
   uint32_t num_results = symfile->FindTypes(sc, ConstString(), nullptr, false,
                                             0, searched_files, results);
   EXPECT_EQ(0u, num_results);
   EXPECT_EQ(0u, results.GetSize());
 }