[lldb] Reduce code duplication around inferior building

[labath]

Summary

We had two sets of build<flavour> methods, whose bodies were largely
identical. This makes any kind of modification in their vicinity
repetitive and error-prone.

Replace each set with a single method taking an optional debug_info
parameter.

[labath]

Adjust for TestStandardUnwind removal (the patch fixes it sufficiently to make it litter the source tree with build artifacts).

[teemperor]

LGTM, thanks!

lldb/docs/testsuite/a-detailed-walkthrough.txt

method as such:
     def test_set_output_path(self):
 
 See http://pypi.python.org/pypi/unittest2 for more details.
 
 Now let's look inside the test method:
 
     def test_set_output_path(self):
         """Test that setting target.process.output-path for the launched process works."""
-        self.buildDefault()
+        self.build()
 
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Set the output-path and verify it is set.
         self.runCmd("settings set target.process.output-path 'stdout.txt'")
         self.expect("settings show target.process.output-path",
             startstr = "target.process.output-path (string) = 'stdout.txt'")
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The 'stdout.txt' file should now exist.
         self.assertTrue(os.path.isfile("stdout.txt"),
                         "'stdout.txt' exists due to target.process.output-path.")
 
         # Read the output file produced by running the program.
         with open('stdout.txt', 'r') as f:
             output = f.read()
 
         self.expect(output, exe=False,
             startstr = "This message should go to standard out.")
 
-The self.buildDefault() statement is used to build a default binary for this
-test instance.  For this particular test case, since we don't really care what
-debugging format is used, we instruct the build subsystem to build the default
-binary for us.  The base class TestBase has defined three instance methods:
-
-    def buildDefault(self, architecture=None, compiler=None, dictionary=None):
-        """Platform specific way to build the default binaries."""
-        module = __import__(sys.platform)
-        if not module.buildDefault(self, architecture, compiler, dictionary):
-            raise Exception("Don't know how to build default binary")
-
-    def buildDsym(self, architecture=None, compiler=None, dictionary=None):
-        """Platform specific way to build binaries with dsym info."""
-        module = __import__(sys.platform)
-        if not module.buildDsym(self, architecture, compiler, dictionary):
-            raise Exception("Don't know how to build binary with dsym")
-
-    def buildDwarf(self, architecture=None, compiler=None, dictionary=None):
-        """Platform specific way to build binaries with dwarf maps."""
-        module = __import__(sys.platform)
-        if not module.buildDwarf(self, architecture, compiler, dictionary):
-            raise Exception("Don't know how to build binary with dwarf")
-
-And the test/plugins/darwin.py provides the implementation for all three build
-methods using the makefile mechanism.  We envision that linux plugin can use a
-similar approach to accomplish the task of building the binaries.
-
-macOS provides an additional way to manipulate archived DWARF debug symbol
-files and produces dSYM files.  The buildDsym() instance method is used by the
-test method to build the binary with dsym info.  For an example of this,
-see test/array_types/TestArrayTypes.py:
-
-    @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
-    def test_with_dsym_and_run_command(self):
-        """Test 'frame variable var_name' on some variables with array types."""
-        self.buildDsym()
-        self.array_types()
-
-This method is decorated with a skipUnless decorator so that it will only gets
-included into the test suite if the platform it is running on is 'darwin', a.k.a.
-macOS.
-
-Type 'man dsymutil' for more details. 
+The self.build() statement is used to build a binary for this
+test instance. This will build the binary for the current debug info format. If
+we wanted to avoid running the test for every supported debug info format we
+could annotate it with @no_debug_info_test. The test would then only be run for
+the default format.  The logic for building a test binary resides in the builder
+modules (packages/Python/lldbsuite/test/builders/builder.py)
 
 After the binary is built, it is time to specify the file to be used as the main
 executable by lldb:
 
         # Construct the path to a file "a.out" inside the test's build folder.
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 

lldb/packages/Python/lldbsuite/test/README-TestSuite

- make directory
   based rules to build binaries for the inferiors.
 
   By default, the built executable name is a.out, which can be overwritten by
   specifying your EXE make variable, via the Makefile under the specific test
   directory or via supplying a Python dictionary to the build method in your
   Python test script.  An example of the latter can be found in
   test/lang/objc/radar-9691614/TestObjCMethodReturningBOOL.py, where:
 
-    def test_method_ret_BOOL_with_dsym(self):
+    def test_method_ret_BOOL(self):
         """Test that objective-c method returning BOOL works correctly."""
         d = {'EXE': self.exe_name}
-        self.buildDsym(dictionary=d)
+        self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
-        self.objc_method_ret_BOOL(self.exe_name)
-
-    def test_method_ret_BOOL_with_dwarf(self):
-        """Test that objective-c method returning BOOL works correctly."""
-        d = {'EXE': self.exe_name}
-        self.buildDwarf(dictionary=d)
-        self.setTearDownCleanup(dictionary=d)
-        self.objc_method_ret_BOOL(self.exe_name)
+        ...
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # We'll use the test method name as the exe_name.
         self.exe_name = self.testMethodName
         # Find the line number to break inside main().
         self.main_source = "main.m"

lldb/packages/Python/lldbsuite/test/builders/builder.py

def getModuleCacheSpec(self):
         Helper function to return the key-value string to specify the clang
         module cache used for the make system.
         """
         if configuration.clang_module_cache_dir:
             return "CLANG_MODULE_CACHE_DIR={}".format(
                 configuration.clang_module_cache_dir)
         return ""
 
-    def buildDefault(self,
-                     sender=None,
-                     architecture=None,
-                     compiler=None,
-                     dictionary=None,
-                     testdir=None,
-                     testname=None):
-        """Build the binaries the default way."""
-        commands = []
-        commands.append(
-            self.getMake(testdir, testname) + [
-                "all",
-                self.getArchCFlags(architecture),
-                self.getArchSpec(architecture),
-                self.getCCSpec(compiler),
-                self.getExtraMakeArgs(),
-                self.getSDKRootSpec(),
-                self.getModuleCacheSpec(),
-                self.getCmdLine(dictionary)
-            ])
+    def _getDebugInfoArgs(self, debug_info):
+        if debug_info is None:
+            return []
+        if debug_info == "dwarf":
+            return ["MAKE_DSYM=NO"]
+        if debug_info == "dwo":
+            return ["MAKE_DSYM=NO", "MAKE_DWO=YES"]
+        if debug_info == "gmodules":
+            return ["MAKE_DSYM=NO", "MAKE_GMODULES=YES"]
+        return None
+
+    def build(self, debug_info, sender=None, architecture=None, compiler=None,
+            dictionary=None, testdir=None, testname=None):
+        debug_info_args = self._getDebugInfoArgs(debug_info)
+        if debug_info_args is None:
+            return False;
 
-        self.runBuildCommands(commands, sender=sender)
-
-        # True signifies that we can handle building default.
-        return True
-
-    def buildDwarf(self,
-                   sender=None,
-                   architecture=None,
-                   compiler=None,
-                   dictionary=None,
-                   testdir=None,
-                   testname=None):
-        """Build the binaries with dwarf debug info."""
         commands = []
         commands.append(
-            self.getMake(testdir, testname) + [
-                "MAKE_DSYM=NO",
-                self.getArchCFlags(architecture),
-                self.getArchSpec(architecture),
-                self.getCCSpec(compiler),
-                self.getExtraMakeArgs(),
-                self.getSDKRootSpec(),
-                self.getModuleCacheSpec(),
-                self.getCmdLine(dictionary)
-            ])
-
-        self.runBuildCommands(commands, sender=sender)
-        # True signifies that we can handle building dwarf.
-        return True
-
-    def buildDwo(self,
-                 sender=None,
-                 architecture=None,
-                 compiler=None,
-                 dictionary=None,
-                 testdir=None,
-                 testname=None):
-        """Build the binaries with dwarf debug info."""
-        commands = []
-        commands.append(
-            self.getMake(testdir, testname) + [
-                "MAKE_DSYM=NO", "MAKE_DWO=YES",
-                self.getArchCFlags(architecture),
-                self.getArchSpec(architecture),
-                self.getCCSpec(compiler),
-                self.getExtraMakeArgs(),
-                self.getSDKRootSpec(),
-                self.getModuleCacheSpec(),
-                self.getCmdLine(dictionary)
-            ])
-
-        self.runBuildCommands(commands, sender=sender)
-        # True signifies that we can handle building dwo.
-        return True
-
-    def buildGModules(self,
-                      sender=None,
-                      architecture=None,
-                      compiler=None,
-                      dictionary=None,
-                      testdir=None,
-                      testname=None):
-        """Build the binaries with dwarf debug info."""
-        commands = []
-        commands.append(
-            self.getMake(testdir, testname) + [
-                "MAKE_DSYM=NO", "MAKE_GMODULES=YES",
+            self.getMake(testdir, testname) + debug_info_args + [
+                "all",
                 self.getArchCFlags(architecture),
                 self.getArchSpec(architecture),
                 self.getCCSpec(compiler),
                 self.getExtraMakeArgs(),
                 self.getSDKRootSpec(),
                 self.getModuleCacheSpec(),
                 self.getCmdLine(dictionary)
             ])
 
         self.runBuildCommands(commands, sender=sender)
-        # True signifies that we can handle building with gmodules.
         return True
 
-    def buildDsym(self,
-                  sender=None,
-                  architecture=None,
-                  compiler=None,
-                  dictionary=None,
-                  testdir=None,
-                  testname=None):
-        # False signifies that we cannot handle building with dSYM.
-        return False
-
     def cleanup(self, sender=None, dictionary=None):
         """Perform a platform-specific cleanup after the test."""
         return True

lldb/packages/Python/lldbsuite/test/builders/darwin.py

def getArchCFlags(self, arch):
         version_min = ""
         if env == "simulator":
             version_min = "-m{}-simulator-version-min={}".format(os, version)
         elif os == "macosx":
             version_min = "-m{}-version-min={}".format(os, version)
 
         return "ARCH_CFLAGS=\"-target {} {}\"".format(triple, version_min)
 
-    def buildDsym(self,
-                  sender=None,
-                  architecture=None,
-                  compiler=None,
-                  dictionary=None,
-                  testdir=None,
-                  testname=None):
-        """Build the binaries with dsym debug info."""
-        commands = []
-        commands.append(
-            self.getMake(testdir, testname) + [
-                "MAKE_DSYM=YES",
-                self.getArchCFlags(architecture),
-                self.getArchSpec(architecture),
-                self.getCCSpec(compiler),
-                self.getExtraMakeArgs(),
-                self.getSDKRootSpec(),
-                self.getModuleCacheSpec(), "all",
-                self.getCmdLine(dictionary)
-            ])
-
-        self.runBuildCommands(commands, sender=sender)
-
-        # True signifies that we can handle building dsym.
-        return True
+    def _getDebugInfoArgs(self, debug_info):
+        if debug_info == "dsym":
+            return ["MAKE_DSYM=YES"]
+        return super(BuilderDarwin, self)._getDebugInfoArgs(debug_info)

lldb/packages/Python/lldbsuite/test/lldbtest.py

def getRunOptions(self):
         if comp:
             option_str += " -C " + comp
         return option_str
 
     def getDebugInfo(self):
         method = getattr(self, self.testMethodName)
         return getattr(method, "debug_info", None)
 
+    def build(
+            self,
+            debug_info=None,
+            architecture=None,
+            compiler=None,
+            dictionary=None):
+        """Platform specific way to build binaries."""
+        if not architecture and configuration.arch:
+            architecture = configuration.arch
+
+        if debug_info is None:
+            debug_info = self.getDebugInfo()
+
+        dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
+
+        testdir = self.mydir
+        testname = self.getBuildDirBasename()
+
+        module = builder_module()
+        if not module.build(debug_info, self, architecture, compiler,
+                                   dictionary, testdir, testname):
+            raise Exception("Don't know how to build binary")
+
     # ==================================================
     # Build methods supported through a plugin interface
     # ==================================================
 
     def getstdlibFlag(self):
         """ Returns the proper -stdlib flag, or empty if not required."""
         if self.platformIsDarwin() or self.getPlatform() == "freebsd" or self.getPlatform() == "openbsd":
             stdlibflag = "-stdlib=libc++"
def buildDriver(self, sources, exe_name):
                                                      os.environ["LLDB_SRC"],
                                                      "include")),
                 'LD_EXTRAS': "-L%s -llldb -Wl,-rpath,%s" % (lib_dir, lib_dir)}
         if self.TraceOn():
             print(
                 "Building LLDB Driver (%s) from sources %s" %
                 (exe_name, sources))
 
-        self.buildDefault(dictionary=d)
+        self.build(dictionary=d)
 
     def buildLibrary(self, sources, lib_name):
         """Platform specific way to build a default library. """
 
         stdflag = self.getstdFlag()
 
         lib_dir = configuration.lldb_libs_dir
         if self.hasDarwinFramework():
def buildLibrary(self, sources, lib_name):
                                                         os.environ["LLDB_SRC"],
                                                         "include")),
                 'LD_EXTRAS': "-shared -L%s -llldb -Wl,-rpath,%s" % (lib_dir, lib_dir)}
         if self.TraceOn():
             print(
                 "Building LLDB Library (%s) from sources %s" %
                 (lib_name, sources))
 
-        self.buildDefault(dictionary=d)
+        self.build(dictionary=d)
 
     def buildProgram(self, sources, exe_name):
         """ Platform specific way to build an executable from C/C++ sources. """
         d = {'CXX_SOURCES': sources,
              'EXE': exe_name}
-        self.buildDefault(dictionary=d)
-
-    def buildDefault(
-            self,
-            architecture=None,
-            compiler=None,
-            dictionary=None):
-        """Platform specific way to build the default binaries."""
-        testdir = self.mydir
-        testname = self.getBuildDirBasename()
-
-        if not architecture and configuration.arch:
-            architecture = configuration.arch
-
-        if self.getDebugInfo():
-            raise Exception("buildDefault tests must set NO_DEBUG_INFO_TESTCASE")
-        module = builder_module()
-        dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
-        if not module.buildDefault(self, architecture, compiler,
-                                   dictionary, testdir, testname):
-            raise Exception("Don't know how to build default binary")
-
-    def buildDsym(
-            self,
-            architecture=None,
-            compiler=None,
-            dictionary=None):
-        """Platform specific way to build binaries with dsym info."""
-        testdir = self.mydir
-        testname = self.getBuildDirBasename()
-        if self.getDebugInfo() != "dsym":
-            raise Exception("NO_DEBUG_INFO_TESTCASE must build with buildDefault")
-
-        module = builder_module()
-        dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
-        if not module.buildDsym(self, architecture, compiler,
-                                dictionary, testdir, testname):
-            raise Exception("Don't know how to build binary with dsym")
-
-    def buildDwarf(
-            self,
-            architecture=None,
-            compiler=None,
-            dictionary=None):
-        """Platform specific way to build binaries with dwarf maps."""
-        testdir = self.mydir
-        testname = self.getBuildDirBasename()
-        if self.getDebugInfo() != "dwarf":
-            raise Exception("NO_DEBUG_INFO_TESTCASE must build with buildDefault")
-
-        module = builder_module()
-        dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
-        if not module.buildDwarf(self, architecture, compiler,
-                                   dictionary, testdir, testname):
-            raise Exception("Don't know how to build binary with dwarf")
-
-    def buildDwo(
-            self,
-            architecture=None,
-            compiler=None,
-            dictionary=None):
-        """Platform specific way to build binaries with dwarf maps."""
-        testdir = self.mydir
-        testname = self.getBuildDirBasename()
-        if self.getDebugInfo() != "dwo":
-            raise Exception("NO_DEBUG_INFO_TESTCASE must build with buildDefault")
-
-        module = builder_module()
-        dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
-        if not module.buildDwo(self, architecture, compiler,
-                                   dictionary, testdir, testname):
-            raise Exception("Don't know how to build binary with dwo")
-
-    def buildGModules(
-            self,
-            architecture=None,
-            compiler=None,
-            dictionary=None):
-        """Platform specific way to build binaries with gmodules info."""
-        testdir = self.mydir
-        testname = self.getBuildDirBasename()
-        if self.getDebugInfo() != "gmodules":
-            raise Exception("NO_DEBUG_INFO_TESTCASE must build with buildDefault")
-
-        module = builder_module()
-        dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
-        if not module.buildGModules(self, architecture, compiler,
-                                    dictionary, testdir, testname):
-            raise Exception("Don't know how to build binary with gmodules")
+        self.build(dictionary=d)
 
     def signBinary(self, binary_path):
         if sys.platform.startswith("darwin"):
             codesign_cmd = "codesign --force --sign \"%s\" %s" % (
                 lldbtest_config.codesign_identity, binary_path)
             call(codesign_cmd, shell=True)
 
     def findBuiltClang(self):
Important things for test class writers:
           classmethod classCleanup(cls) to perform special class cleanup action.
 
         - The instance methods runCmd and expect are used heavily by existing
           test cases to send a command to the command interpreter and to perform
           string/pattern matching on the output of such command execution.  The
           expect method also provides a mode to peform string/pattern matching
           without running a command.
 
-        - The build methods buildDefault, buildDsym, and buildDwarf are used to
-          build the binaries used during a particular test scenario.  A plugin
-          should be provided for the sys.platform running the test suite.  The
-          Mac OS X implementation is located in builders/darwin.py.
+        - The build method is used to build the binaries used during a
+          particular test scenario.  A plugin should be provided for the
+          sys.platform running the test suite.  The Mac OS X implementation is
+          located in builders/darwin.py.
     """
 
     # Subclasses can set this to true (if they don't depend on debug info) to avoid running the
     # test multiple times with various debug info types.
     NO_DEBUG_INFO_TESTCASE = False
 
     # Maximum allowed attempts when launching the inferior process.
     # Can be overridden by the LLDB_MAX_LAUNCH_COUNT environment variable.
def expect_var_path(
         frame = self.frame()
         eval_result = frame.GetValueForVariablePath(var_path)
 
         value_check = ValueCheck(type=type, value=value,
                                  summary=summary, children=children)
         value_check.check_value(self, eval_result, str(eval_result))
         return eval_result
 
-    def build(
-            self,
-            architecture=None,
-            compiler=None,
-            dictionary=None):
-        """Platform specific way to build the default binaries."""
-        module = builder_module()
-
-        if not architecture and configuration.arch:
-            architecture = configuration.arch
-
-        dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
-        if self.getDebugInfo() is None:
-            return self.buildDefault(architecture, compiler, dictionary)
-        elif self.getDebugInfo() == "dsym":
-            return self.buildDsym(architecture, compiler, dictionary)
-        elif self.getDebugInfo() == "dwarf":
-            return self.buildDwarf(architecture, compiler, dictionary)
-        elif self.getDebugInfo() == "dwo":
-            return self.buildDwo(architecture, compiler, dictionary)
-        elif self.getDebugInfo() == "gmodules":
-            return self.buildGModules(architecture, compiler, dictionary)
-        else:
-            self.fail("Can't build for debug info: %s" % self.getDebugInfo())
-
     """Assert that an lldb.SBError is in the "success" state."""
     def assertSuccess(self, obj, msg=None):
         if not obj.Success():
             error = obj.GetCString()
             self.fail(self._formatMessage(msg,
                 "'{}' is not success".format(error)))
 
     def createTestTarget(self, file_path=None, msg=None):

lldb/packages/Python/lldbsuite/test/tools/lldb-server/gdbremote_testcase.py

def setUp(self):
         else:
             self._init_llgs_test()
 
     def tearDown(self):
         self.logger.removeHandler(self._verbose_log_handler)
         self._verbose_log_handler = None
         TestBase.tearDown(self)
 
-    def build(self, *args, **kwargs):
-        self.buildDefault(*args, **kwargs)
-
     def getLocalServerLogFile(self):
         return self.getLogBasenameForCurrentTest() + "-server.log"
 
     def setUpServerLogging(self, is_llgs):
         if len(lldbtest_config.channels) == 0:
             return  # No logging requested
 
         if lldb.remote_platform:

lldb/test/API/commands/add-dsym/uuid/TestAddDsymCommand.py

def setUp(self):
         self.teardown_hook_added = False
 
     @no_debug_info_test
     def test_add_dsym_command_with_error(self):
         """Test that the 'add-dsym' command informs the user about failures."""
 
         # Call the program generator to produce main.cpp, version 1.
         self.generate_main_cpp(version=1)
-        self.buildDefault(dictionary={'MAKE_DSYM':'YES'})
+        self.build(debug_info="dsym")
 
         # Insert some delay and then call the program generator to produce
         # main.cpp, version 2.
         time.sleep(5)
         self.generate_main_cpp(version=101)
         # Now call make again, but this time don't generate the dSYM.
-        self.buildDefault(dictionary={'MAKE_DSYM':'NO'})
+        self.build(debug_info="dwarf")
 
         self.exe_name = 'a.out'
         self.do_add_dsym_with_error(self.exe_name)
 
     @no_debug_info_test
     def test_add_dsym_command_with_success(self):
         """Test that the 'add-dsym' command informs the user about success."""
 
         # Call the program generator to produce main.cpp, version 1.
         self.generate_main_cpp(version=1)
-        self.buildDefault(dictionary={'MAKE_DSYM':'YES'})
+        self.build(debug_info="dsym")
 
         self.exe_name = 'a.out'
         self.do_add_dsym_with_success(self.exe_name)
 
     @no_debug_info_test
     def test_add_dsym_with_dSYM_bundle(self):
         """Test that the 'add-dsym' command informs the user about success."""
 
         # Call the program generator to produce main.cpp, version 1.
         self.generate_main_cpp(version=1)
-        self.buildDefault(dictionary={'MAKE_DSYM':'YES'})
+        self.build(debug_info="dsym")
 
         self.exe_name = 'a.out'
         self.do_add_dsym_with_dSYM_bundle(self.exe_name)
 
     def generate_main_cpp(self, version=0):
         """Generate main.cpp from main.cpp.template."""
         temp = os.path.join(self.getSourceDir(), self.template)
         with open(temp, 'r') as f:

lldb/test/API/functionalities/breakpoint/comp_dir_symlink/TestCompDirSymLink.py

def create_src_symlink(self):
         pwd_symlink = self.getBuildArtifact('pwd_symlink')
         if os.path.exists(pwd_symlink):
             os.unlink(pwd_symlink)
         os.symlink(self.getBuildDir(), pwd_symlink)
         self.addTearDownHook(lambda: os.remove(pwd_symlink))
         return pwd_symlink
 
     def doBuild(self, pwd_symlink, setting_value):
-        self.build(None, None, {'PWD': pwd_symlink})
+        self.build(dictionary={'PWD': pwd_symlink})
 
         if setting_value:
             cmd = "settings set %s '%s'" % (_COMP_DIR_SYM_LINK_PROP, setting_value)
         else:
             cmd = "settings clear %s"%_COMP_DIR_SYM_LINK_PROP
         self.runCmd(cmd)
 
         exe = self.getBuildArtifact(_EXE_NAME)
         self.runCmd('file ' + exe, CURRENT_EXECUTABLE_SET)

lldb/test/API/functionalities/unwind/standard/TestStandardUnwind.py

if f.endswith(".cpp") or f.endswith(".c"):
                 d = {'CXX_SOURCES': f}
             elif f.endswith(".c"):
                 d = {'C_SOURCES': f}
 
             # If we can't compile the inferior just skip the test instead of failing it.
             # It makes the test suit more robust when testing on several different architecture
             # avoid the hassle of skipping tests manually.
             try:
-                self.buildDwarf(dictionary=d)
+                self.build(dictionary=d)
                 self.setTearDownCleanup(d)
             except:
                 if self.TraceOn():
                     print(sys.exc_info()[0])
                 self.skipTest("Inferior not supported")
             self.standard_unwind_tests()
 
         test_name = "test_unwind_" + str(os.path.basename(f))
         for c in ".=()/\\":
             test_name = test_name.replace(c, '_')
 
         test_function_dwarf.__name__ = test_name
         setattr(
             StandardUnwindTest,
             test_function_dwarf.__name__,
             test_function_dwarf)

lldb/test/API/macosx/add-dsym/TestAddDsymDownload.py

def setUp(self):
         self.source = 'main.c'
         self.exe = self.getBuildArtifact("a.out")
         self.dsym = os.path.join(
             self.getBuildDir(),
             "hide.app/Contents/a.out.dSYM/Contents/Resources/DWARF/",
             os.path.basename(self.exe))
         self.dsym_for_uuid = self.getBuildArtifact("dsym-for-uuid.sh")
 
-        self.buildDefault(dictionary={'MAKE_DSYM': 'YES'})
+        self.build(debug_info="dsym")
         self.assertTrue(os.path.exists(self.exe))
         self.assertTrue(os.path.exists(self.dsym))
 
         self.uuid = self.get_uuid()
         self.assertNotEqual(self.uuid, None, "Could not get uuid for a.out")
 
         self.create_dsym_for_uuid()
 

lldb/test/API/macosx/add-dsym/TestAddDsymMidExecutionCommand.py

class AddDsymMidExecutionCommandCase(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         self.source = 'main.c'
 
     @no_debug_info_test  # Prevent the genaration of the dwarf version of this test
     def test_add_dsym_mid_execution(self):
         """Test that add-dsym mid-execution loads the symbols at the right place for a slid binary."""
-        self.buildDefault(dictionary={'MAKE_DSYM':'YES'})
+        self.build(debug_info="dsym")
         exe = self.getBuildArtifact("a.out")
 
         self.target = self.dbg.CreateTarget(exe)
         self.assertTrue(self.target, VALID_TARGET)
 
         main_bp = self.target.BreakpointCreateByName("main", "a.out")
         self.assertTrue(main_bp, VALID_BREAKPOINT)