[lldb][testsuite] Create a SBDebugger instance for each test

[tatyana-krasnukha]

Summary

Some tests set settings and don't clean them up, this leads to side effects in other tests.
The patch removes a global debugger instance with a per-test debugger to avoid such effects.

From what I see, lldb.DBG was needed to determine the platform before a test is run, lldb.selected_platform is used for this purpose now. Though, this required adding a new function to the SBPlatform interface.

[teemperor]

I'm kinda curious how much we actually support this? I know we do a lot of random fiddling with settings and what not, but I feel if we anyway say that each test needs to have a clean setup, can't we just create like a new SBDebugger instance or something like that at test start? That would solve all the cleanup issues and cover all the hidden settings that LLDB supports (e.g. the amazing platform settings command and all that).

[tatyana-krasnukha]

I like this idea and ready to implement, but I'm not aware of the reasons why the current implementation was chosen. Suppose that initializing the Debugger for each test will slow down the test-suite significantly.

[labath]

We (mostly me and @jingham) discussed that idea (very) briefly a couple of weeks ago, and my impression was that this (reinitializing SBDebugger for every test) would be a good way to go. There are just too many things that can leak from one session into another, and since none of the default bots run in the monolithic mode, I am frankly surprised that this mode is still even remotely usable.

One thing to be aware of is that SBDebuggers are not perfectly isolated either -- some settings will leak from one debugger into another and so one still has to be careful when setting those...

[tatyana-krasnukha]

As Pavel wrote, there are global properties that all debuggers share. That's why this approach doesn't work for me.
I'm going to add settings clear mode without arguments that will revert all the settings to their default values.

[tatyana-krasnukha]

Clear all settings during a test's setUp

[labath]

Overall, I don't have any big issues with this patch, but overall I see at least two distinct issues being handled here: a) changing how the platform selection works; and b) auto-clearing of settings. Please split those up into separate patches.

[tatyana-krasnukha]

Moved settings clearing to the separate patch D75537

[labath]

This is a great cleanup.

I don't believe the addition of the new SBPlatform interface is an issue, but I've added @jingham just in case he has any thoughts on that. Please give him a chance to comment on this.

[jingham]

Seems great to me. Getting the host platform is a generally useful thing to be able to do, and I can't think of anything you would want to add to this, so that is fine to.

lldb/bindings/interface/SBPlatform.i

 public:
 
     SBPlatform ();
 
     SBPlatform (const char *);
 
     ~SBPlatform();
 
+    static SBPlatform GetHostPlatform();
+
     bool
     IsValid () const;
 
     explicit operator bool() const;
 
     void
     Clear ();
 

lldb/include/lldb/API/SBPlatform.h

public:
   SBPlatform(const char *platform_name);
 
   SBPlatform(const SBPlatform &rhs);
 
   SBPlatform &operator=(const SBPlatform &rhs);
 
   ~SBPlatform();
 
+  static SBPlatform GetHostPlatform();
+
   explicit operator bool() const;
 
   bool IsValid() const;
 
   void Clear();
 
   const char *GetWorkingDirectory();
 

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

def fn(self):
             lldbplatformutil.getHostPlatform())
         skip_for_compiler = _match_decorator_property(
             compiler, self.getCompiler()) and self.expectedCompilerVersion(compiler_version)
         skip_for_arch = _match_decorator_property(
             archs, self.getArchitecture())
         skip_for_debug_info = _match_decorator_property(
             debug_info, self.getDebugInfo())
         skip_for_triple = _match_decorator_property(
-            triple, lldb.DBG.GetSelectedPlatform().GetTriple())
+            triple, lldb.selected_platform.GetTriple())
         skip_for_remote = _match_decorator_property(
             remote, lldb.remote_platform is not None)
 
         skip_for_swig_version = (
             swig_version is None) or (
             not hasattr(
                 lldb,
                 'swig_version')) or (

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

for name in python_test_files:
 
                 # Generate the test event.
                 configuration.results_formatter_object.handle_event(
                     EventBuilder.event_for_job_test_add_error(
                         test_filename, ex, backtrace))
             raise
 
 
-def setSetting(setting, value):
-    import lldb
-    ci = lldb.DBG.GetCommandInterpreter()
-    res = lldb.SBCommandReturnObject()
-    cmd = 'setting set %s %s'%(setting, value)
-    print(cmd)
-    ci.HandleCommand(cmd, res, False)
-    if not res.Succeeded():
-        raise Exception('failed to run "%s"'%cmd)
-
 # ======================================== #
 #                                          #
 # Execution of the test driver starts here #
 #                                          #
 # ======================================== #
 
 
 def checkDsymForUUIDIsNotOn():
if "DBGFileMappedPaths = " in output_str:
         print(output_str)
         print(
             "Disable automatic lookup and caching of dSYMs before running the test suite!")
         print("Exiting...")
         sys.exit(0)
 
 
 def exitTestSuite(exitCode=None):
+    # lldb.py does SBDebugger.Initialize().
+    # Call SBDebugger.Terminate() on exit.
     import lldb
     lldb.SBDebugger.Terminate()
     if exitCode:
         sys.exit(exitCode)
 
 
 def getVersionForSDK(sdk):
     sdk = str.lower(sdk)
def checkWatchpointSupport():
     if "watchpoint" in configuration.categories_list:
         return # watchpoint category explicitly requested, let it run.
     print("watchpoint tests will not be run because: " + reason)
     configuration.skip_categories.append("watchpoint")
 
 def checkDebugInfoSupport():
     import lldb
 
-    platform = lldb.DBG.GetSelectedPlatform().GetTriple().split('-')[2]
+    platform = lldb.selected_platform.GetTriple().split('-')[2]
     compiler = configuration.compiler
     skipped = []
     for cat in test_categories.debug_info_categories:
         if cat in configuration.categories_list:
             continue # Category explicitly requested, let it run.
         if test_categories.is_supported_on_platform(cat, platform, compiler):
             continue
         configuration.skip_categories.append(cat)
def run_suite():
     #
     parseOptionsAndInitTestdirs()
 
     # Setup test results (test results formatter and output handling).
     setupTestResults()
 
     setupSysPath()
 
-
-    # For the time being, let's bracket the test runner within the
-    # lldb.SBDebugger.Initialize()/Terminate() pair.
     import lldb
+    # Use host platform by default.
+    lldb.selected_platform = lldb.SBPlatform.GetHostPlatform()
 
     # Now we can also import lldbutil
     from lldbsuite.test import lldbutil
 
-    # Create a singleton SBDebugger in the lldb namespace.
-    lldb.DBG = lldb.SBDebugger.Create()
-
     if configuration.lldb_platform_name:
         print("Setting up remote platform '%s'" %
               (configuration.lldb_platform_name))
         lldb.remote_platform = lldb.SBPlatform(
             configuration.lldb_platform_name)
         if not lldb.remote_platform.IsValid():
             print(
                 "error: unable to create the LLDB platform named '%s'." %
if configuration.lldb_platform_working_dir:
             configuration.lldb_platform_working_dir, 448)  # 448 = 0o700
         if error.Fail():
             raise Exception("making remote directory '%s': %s" % (
                 configuration.lldb_platform_working_dir, error))
 
         if not lldb.remote_platform.SetWorkingDirectory(
                 configuration.lldb_platform_working_dir):
             raise Exception("failed to set working directory '%s'" % configuration.lldb_platform_working_dir)
-        lldb.DBG.SetSelectedPlatform(lldb.remote_platform)
+        lldb.selected_platform = lldb.remote_platform
     else:
         lldb.remote_platform = None
         configuration.lldb_platform_working_dir = None
         configuration.lldb_platform_url = None
 
     # Set up the working directory.
     # Note that it's not dotest's job to clean this directory.
     build_dir = configuration.test_build_dir
     lldbutil.mkdir_p(build_dir)
 
-    target_platform = lldb.DBG.GetSelectedPlatform().GetTriple().split('-')[2]
+    target_platform = lldb.selected_platform.GetTriple().split('-')[2]
 
     checkLibcxxSupport()
     checkLibstdcxxSupport()
     checkWatchpointSupport()
     checkDebugInfoSupport()
 
     # Don't do debugserver tests on anything except OS X.
     configuration.dont_do_debugserver_test = (
def run_suite():
     for testdir in configuration.testdirs:
         for (dirpath, dirnames, filenames) in os.walk(testdir):
             visit('Test', dirpath, filenames)
 
     #
     # Now that we have loaded all the test cases, run the whole test suite.
     #
 
-    # Set any user-overridden settings.
-    for key, value in configuration.settings:
-        setSetting(key, value)
-
     # Install the control-c handler.
     unittest2.signals.installHandler()
 
     lldbutil.mkdir_p(configuration.sdir_name)
     os.environ["LLDB_SESSION_DIRNAME"] = configuration.sdir_name
 
     sys.stderr.write(
         "\nSession logs for test failures/errors/unexpected successes"

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

p = subprocess.Popen(
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE)
     stdout, stderr = p.communicate()
     return p.returncode, stdout, stderr
 
 
 def target_is_android():
     if not hasattr(target_is_android, 'result'):
-        triple = lldb.DBG.GetSelectedPlatform().GetTriple()
+        triple = lldb.selected_platform.GetTriple()
         match = re.match(".*-.*-.*-android", triple)
         target_is_android.result = match is not None
     return target_is_android.result
 
 
 def android_device_api():
     if not hasattr(android_device_api, 'result'):
         assert configuration.lldb_platform_url is not None

 
 
 def getDarwinOSTriples():
     return ['darwin', 'macosx', 'ios', 'watchos', 'tvos', 'bridgeos']
 
 
 def getPlatform():
     """Returns the target platform which the tests are running on."""
-    triple = lldb.DBG.GetSelectedPlatform().GetTriple()
+    triple = lldb.selected_platform.GetTriple()
     if triple is None:
       # It might be an unconnected remote platform.
       return ''
 
     platform = triple.split('-')[2]
     if platform.startswith('freebsd'):
         platform = 'freebsd'
     elif platform.startswith('netbsd'):

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

def setUpCommands(cls):
 
             # Testsuite runs in parallel and the host can have also other load.
             "settings set plugin.process.gdb-remote.packet-timeout 60",
 
             'settings set symbols.clang-modules-cache-path "{}"'.format(
                 configuration.lldb_module_cache_dir),
             "settings set use-color false",
         ]
+
+        # Set any user-overridden settings.
+        for setting, value in configuration.settings:
+            commands.append('setting set %s %s'%(setting, value))
+
         # Make sure that a sanitizer LLDB's environment doesn't get passed on.
         if cls.platformContext and cls.platformContext.shlib_environment_var in os.environ:
             commands.append('settings set target.env-vars {}='.format(
                 cls.platformContext.shlib_environment_var))
 
         # Set environment variables for the inferior.
         if lldbtest_config.inferior_env:
             commands.append('settings set target.env-vars {}'.format(
def setUp(self):
 
         # See HideStdout(self).
         self.sys_stdout_hidden = False
 
         if self.platformContext:
             # set environment variable names for finding shared libraries
             self.dylibPath = self.platformContext.shlib_environment_var
 
-        # Create the debugger instance if necessary.
-        try:
-            self.dbg = lldb.DBG
-        except AttributeError:
-            self.dbg = lldb.SBDebugger.Create()
+        # Create the debugger instance.
+        # Copy selected platform from a global instance if it exists.
+        if lldb.selected_platform is not None:
+            self.dbg.SetSelectedPlatform(lldb.selected_platform)
 
         if not self.dbg:
             raise Exception('Invalid debugger instance')
 
         # Retrieve the associated command interpreter instance.
         self.ci = self.dbg.GetCommandInterpreter()
         if not self.ci:
             raise Exception('Could not get the command interpreter')
def tearDown(self):
             self.cleanup(dictionary=self.dict)
 
         # In rare cases where there are multiple teardown cleanups added.
         if doCleanup and self.doTearDownCleanups:
             if self.dicts:
                 for dict in reversed(self.dicts):
                     self.cleanup(dictionary=dict)
 
+        # This must be the last statement, otherwise teardown hooks or other
+        # lines might depend on this still being active.
+        lldb.SBDebugger.Destroy(self.dbg)
+        del self.dbg
+
     # =========================================================
     # Various callbacks to allow introspection of test progress
     # =========================================================
 
     def markError(self):
         """Callback invoked when an error (unexpected exception) errored."""
         self.__errored__ = True
         with recording(self, False) as sbuf:
def tearDown(self):
                     rc = self.invoke(process, "Kill")
                     self.assertTrue(rc.Success(), PROCESS_KILLED)
         for target in targets:
             self.dbg.DeleteTarget(target)
 
         # Do this last, to make sure it's in reverse order from how we setup.
         Base.tearDown(self)
 
-        # This must be the last statement, otherwise teardown hooks or other
-        # lines might depend on this still being active.
-        del self.dbg
-
     def switch_to_thread_with_stop_reason(self, stop_reason):
         """
         Run the 'thread list' command, and select the thread with stop reason as
         'stop_reason'.  If no such thread exists, no select action is done.
         """
         from .lldbutil import stop_reason_to_str
         self.runCmd('thread list')
         output = self.res.GetOutput()

lldb/source/API/SBPlatform.cpp

LLDB_RECORD_METHOD(SBPlatform &,
                      SBPlatform, operator=,(const lldb::SBPlatform &), rhs);
 
   m_opaque_sp = rhs.m_opaque_sp;
   return LLDB_RECORD_RESULT(*this);
 }
 
 SBPlatform::~SBPlatform() = default;
 
+SBPlatform SBPlatform::GetHostPlatform() {
+  SBPlatform host_platform;
+  host_platform.m_opaque_sp = Platform::GetHostPlatform();
+  return host_platform;
+}
+
 bool SBPlatform::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBPlatform, IsValid);
   return this->operator bool();
 }
 SBPlatform::operator bool() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBPlatform, operator bool);
 
   return m_opaque_sp.get() != nullptr;

lldb/test/API/commands/target/auto-install-main-executable/TestAutoInstallMainExecutable.py

 """
 Test target commands: target.auto-install-main-executable.
 """
 
 import time
 import gdbremote_testcase
 
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestAutoInstallMainExecutable(gdbremote_testcase.GdbRemoteTestCaseBase):
     mydir = TestBase.compute_mydir(__file__)
 
-    def setUp(self):
-        super(TestAutoInstallMainExecutable, self).setUp()
-        self._initial_platform = lldb.DBG.GetSelectedPlatform()
-
-    def tearDown(self):
-        lldb.DBG.SetSelectedPlatform(self._initial_platform)
-        super(TestAutoInstallMainExecutable, self).tearDown()
-
     @llgs_test
     @no_debug_info_test
     @skipIf(remote=False)
     @expectedFailureAll(hostoslist=["windows"], triple='.*-android')
     def test_target_auto_install_main_executable(self):
         self.build()
         self.init_llgs_test(False)
 
def test_target_auto_install_main_executable(self):
             self.debug_monitor_exe,
             commandline_args,
             install_remote=False)
         self.addTearDownHook(self.cleanupSubprocesses)
 
         # Wait for the new process gets ready.
         time.sleep(0.1)
 
-        new_debugger = lldb.SBDebugger.Create()
-        new_debugger.SetAsync(False)
-
-        def del_debugger(new_debugger=new_debugger):
-            del new_debugger
-        self.addTearDownHook(del_debugger)
+        self.dbg.SetAsync(False)
 
         new_platform = lldb.SBPlatform(lldb.remote_platform.GetName())
-        new_debugger.SetSelectedPlatform(new_platform)
-        new_interpreter = new_debugger.GetCommandInterpreter()
+        self.dbg.SetSelectedPlatform(new_platform)
+        interpreter = self.dbg.GetCommandInterpreter()
 
         connect_url = "%s://%s:%s" % (protocol, hostname, str(hostport+1))
 
         command = "platform connect %s" % (connect_url)
 
         result = lldb.SBCommandReturnObject()
 
         # Test the default setting.
-        new_interpreter.HandleCommand("settings show target.auto-install-main-executable", result)
+        interpreter.HandleCommand("settings show target.auto-install-main-executable", result)
         self.assertTrue(
             result.Succeeded() and
             "target.auto-install-main-executable (boolean) = true" in result.GetOutput(),
             "Default settings for target.auto-install-main-executable failed.: %s - %s" %
             (result.GetOutput(), result.GetError()))
 
         # Disable the auto install.
-        new_interpreter.HandleCommand("settings set target.auto-install-main-executable false", result)
-        new_interpreter.HandleCommand("settings show target.auto-install-main-executable", result)
+        interpreter.HandleCommand("settings set target.auto-install-main-executable false", result)
+        interpreter.HandleCommand("settings show target.auto-install-main-executable", result)
         self.assertTrue(
             result.Succeeded() and
             "target.auto-install-main-executable (boolean) = false" in result.GetOutput(),
             "Default settings for target.auto-install-main-executable failed.: %s - %s" %
             (result.GetOutput(), result.GetError()))
 
-        new_interpreter.HandleCommand("platform select %s"%configuration.lldb_platform_name, result)
-        new_interpreter.HandleCommand(command, result)
+        interpreter.HandleCommand("platform select %s"%configuration.lldb_platform_name, result)
+        interpreter.HandleCommand(command, result)
 
         self.assertTrue(
             result.Succeeded(),
             "platform process connect failed: %s - %s" %
             (result.GetOutput(),result.GetError()))
 
         # Create the target with the original file.
-        new_interpreter.HandleCommand("target create --remote-file %s %s "%
+        interpreter.HandleCommand("target create --remote-file %s %s "%
                                         (os.path.join(working_dir,dest.GetFilename()), self.getBuildArtifact("a.out")),
                                       result)
         self.assertTrue(
             result.Succeeded(),
             "platform create failed: %s - %s" %
             (result.GetOutput(),result.GetError()))
 
         target = new_debugger.GetSelectedTarget()
         breakpoint = target.BreakpointCreateByName("main")
 
         launch_info = lldb.SBLaunchInfo(None)
         error = lldb.SBError()
         process = target.Launch(launch_info, error)
         self.assertTrue(process, PROCESS_IS_VALID)
 
         thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
         self.assertTrue(
             thread.IsValid(),
             "There should be a thread stopped due to breakpoint")
 
         frame = thread.GetFrameAtIndex(0)
         self.assertEqual(frame.GetFunction().GetName(), "main")
 
-        new_interpreter.HandleCommand("target variable build", result)
+        interpreter.HandleCommand("target variable build", result)
         self.assertTrue(
             result.Succeeded() and
             '"device"' in result.GetOutput(),
             "Magic in the binary is wrong: %s " % result.GetOutput())
 
         process.Continue()

lldb/test/API/functionalities/breakpoint/breakpoint_in_delayslot/TestAvoidBreakpointInDelaySlot.py

def function(self, function, target):
                 bpaddr = location.GetLoadAddress()
 
                 # Breakpoint address should be adjusted to the address of
                 # branch instruction.
                 self.assertTrue(branchinstaddress == bpaddr)
                 i += 1
             else:
                 i += 1
-
-if __name__ == '__main__':
-    import atexit
-    lldb.SBDebugger.Initialize()
-    atexit.register(lambda: lldb.SBDebugger.Terminate())
-    unittest2.main()

lldb/test/API/functionalities/breakpoint/step_over_breakpoint/TestStepOverBreakpoint.py

def test_step_instruction(self):
                 break
 
         # Run the process until termination
         self.process.Continue()
         self.assertEquals(self.process.GetState(), lldb.eStateExited)
 
     @skipIf(bugnumber="llvm.org/pr31972", hostoslist=["windows"])
     def test_step_over(self):
-        #lldb.DBG.EnableLog("lldb", ["step","breakpoint"])
 
         self.thread.StepOver()
         # We should be stopped at the breakpoint_2 line with stop plan complete reason
         self.assertEquals(self.process.GetState(), lldb.eStateStopped)
         self.assertEquals(self.thread.GetStopReason(), lldb.eStopReasonPlanComplete)
 
         self.thread.StepOver()
         # We should be stopped at the breakpoint_3 line with stop plan complete reason

lldb/test/API/functionalities/gdb_remote_client/TestGDBRemoteClient.py

 import lldb
 import binascii
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
 from gdbclientutils import *
 
 
 class TestGDBRemoteClient(GDBRemoteTestBase):
 
     class gPacketResponder(MockGDBServerResponder):
         def readRegisters(self):
             return '0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000'
 
-    def setUp(self):
-        super(TestGDBRemoteClient, self).setUp()
-        self._initial_platform = lldb.DBG.GetSelectedPlatform()
-
-    def tearDown(self):
-        lldb.DBG.SetSelectedPlatform(self._initial_platform)
-        super(TestGDBRemoteClient, self).tearDown()
-
     def test_connect(self):
         """Test connecting to a remote gdb server"""
         target = self.createTarget("a.yaml")
         process = self.connect(target)
         self.assertPacketLogContains(["qProcessInfo", "qfThreadInfo"])
 
     def test_attach_fail(self):
         error_msg = "mock-error-msg"

lldb/test/API/functionalities/gdb_remote_client/TestGDBRemoteLoad.py

 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
 from gdbclientutils import *
 
 
 class TestGDBRemoteLoad(GDBRemoteTestBase):
 
-    def setUp(self):
-        super(TestGDBRemoteLoad, self).setUp()
-        self._initial_platform = lldb.DBG.GetSelectedPlatform()
-
-    def tearDown(self):
-        lldb.DBG.SetSelectedPlatform(self._initial_platform)
-        super(TestGDBRemoteLoad, self).tearDown()
-
     def test_module_load_address(self):
         """Test that setting the load address of a module uses virtual addresses"""
         target = self.createTarget("a.yaml")
         process = self.connect(target)
         module = target.GetModuleAtIndex(0)
         self.assertTrue(module.IsValid())
         self.assertTrue(target.SetModuleLoadAddress(module, 0).Success())
         address = target.ResolveLoadAddress(0x2001)

lldb/test/API/functionalities/gdb_remote_client/TestWasm.py

def readMemory(self, addr, length):
             for i in range(addr_from, addr_to):
                 result += format(file_content[i], '02x')
             file.close()
         return result
 
 
 class TestWasm(GDBRemoteTestBase):
 
-    def setUp(self):
-        super(TestWasm, self).setUp()
-        self._initial_platform = lldb.DBG.GetSelectedPlatform()
-
-    def tearDown(self):
-        lldb.DBG.SetSelectedPlatform(self._initial_platform)
-        super(TestWasm, self).tearDown()
-
     @skipIfAsan
     @skipIfXmlSupportMissing
     def test_load_module_with_embedded_symbols_from_remote(self):
         """Test connecting to a WebAssembly engine via GDB-remote and loading a Wasm module with embedded DWARF symbols"""
 
         yaml_path = "test_wasm_embedded_debug_sections.yaml"
         yaml_base, ext = os.path.splitext(yaml_path)
         obj_path = self.getBuildArtifact(yaml_base)

lldb/test/API/functionalities/gdb_remote_client/TestWriteMemory.py

 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
 from gdbclientutils import *
 
 
 class TestWriteMemory(GDBRemoteTestBase):
 
-    def setUp(self):
-        super(TestWriteMemory, self).setUp()
-        self._initial_platform = lldb.DBG.GetSelectedPlatform()
-
-    def tearDown(self):
-        lldb.DBG.SetSelectedPlatform(self._initial_platform)
-        super(TestWriteMemory, self).tearDown()
-
-
     def test(self):
 
         class MyResponder(MockGDBServerResponder):
             def setBreakpoint(self, packet):
                 return "OK"
 
         self.server.responder = MyResponder()
         target = self.dbg.CreateTargetWithFileAndTargetTriple('', 'x86_64-pc-linux')

lldb/test/API/functionalities/gdb_remote_client/TestqOffsets.py

 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
 from gdbclientutils import *
 
 
 class TestqOffsets(GDBRemoteTestBase):
 
     class Responder(MockGDBServerResponder):
         def qOffsets(self):
             return 'Text=470000;Data=470000'
 
-    def setUp(self):
-        super(TestqOffsets, self).setUp()
-        self._initial_platform = lldb.DBG.GetSelectedPlatform()
-
-    def tearDown(self):
-        lldb.DBG.SetSelectedPlatform(self._initial_platform)
-        super(TestqOffsets, self).tearDown()
-
     def test(self):
         self.server.responder = TestqOffsets.Responder()
         target = self.createTarget("qOffsets.yaml")
         text = target.modules[0].FindSection(".text")
         self.assertEquals(text.GetLoadAddress(target), lldb.LLDB_INVALID_ADDRESS)
 
         process = self.connect(target)
         self.assertEquals(text.GetLoadAddress(target), 0x471000)

lldb/test/API/functionalities/plugins/command_plugin/TestPluginCommands.py

def test_load_plugin(self):
         if sys.platform.startswith("darwin"):
             plugin_lib_name = "lib%s.dylib" % plugin_name
         else:
             plugin_lib_name = "lib%s.so" % plugin_name
 
         # Invoke the library build rule.
         self.buildLibrary("plugin.cpp", plugin_name)
 
-        debugger = lldb.SBDebugger.Create()
-
         retobj = lldb.SBCommandReturnObject()
 
-        retval = debugger.GetCommandInterpreter().HandleCommand(
+        retval = self.dbg.GetCommandInterpreter().HandleCommand(
             "plugin load %s" % self.getBuildArtifact(plugin_lib_name), retobj)
 
         retobj.Clear()
 
-        retval = debugger.GetCommandInterpreter().HandleCommand(
+        retval = self.dbg.GetCommandInterpreter().HandleCommand(
             "plugin_loaded_command child abc def ghi", retobj)
 
         if self.TraceOn():
             print(retobj.GetOutput())
 
         self.expect(retobj, substrs=['abc def ghi'], exe=False)
 
         retobj.Clear()
 
         # check that abbreviations work correctly in plugin commands.
-        retval = debugger.GetCommandInterpreter().HandleCommand(
+        retval = self.dbg.GetCommandInterpreter().HandleCommand(
             "plugin_loaded_ ch abc def ghi", retobj)
 
         if self.TraceOn():
             print(retobj.GetOutput())
 
         self.expect(retobj, substrs=['abc def ghi'], exe=False)
 
     @no_debug_info_test

lldb/test/API/functionalities/postmortem/elf-core/TestLinuxCore.py

class LinuxCoreTestCase(TestBase):
     _ppc64le_pid = 28147
 
     _i386_regions = 4
     _x86_64_regions = 5
     _s390x_regions = 2
     _mips_regions = 5
     _ppc64le_regions = 2
 
-    def setUp(self):
-        super(LinuxCoreTestCase, self).setUp()
-        self._initial_platform = lldb.DBG.GetSelectedPlatform()
-
-    def tearDown(self):
-        lldb.DBG.SetSelectedPlatform(self._initial_platform)
-        super(LinuxCoreTestCase, self).tearDown()
-
     @skipIf(triple='^mips')
     @skipIfLLVMTargetMissing("X86")
     def test_i386(self):
         """Test that lldb can read the process information from an i386 linux core file."""
         self.do_test("linux-i386", self._i386_pid, self._i386_regions, "a.out")
 
     @skipIfLLVMTargetMissing("Mips")
     def test_mips_o32(self):

lldb/test/API/functionalities/postmortem/elf-core/gcore/TestGCore.py

 """
 Test signal reporting when debugging with linux core files.
 """
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class GCoreTestCase(TestBase):
     NO_DEBUG_INFO_TESTCASE = True
 
     mydir = TestBase.compute_mydir(__file__)
-    def setUp(self):
-        super(GCoreTestCase, self).setUp()
-        self._initial_platform = lldb.DBG.GetSelectedPlatform()
-
-    def tearDown(self):
-        lldb.DBG.SetSelectedPlatform(self._initial_platform)
-        super(GCoreTestCase, self).tearDown()
 
     _i386_pid = 5586
     _x86_64_pid = 5669
 
     @skipIf(oslist=['windows'])
     @skipIf(triple='^mips')
     def test_i386(self):
         """Test that lldb can read the process information from an i386 linux core file."""

lldb/test/API/functionalities/postmortem/elf-core/thread_crash/TestLinuxCoreThreads.py

 from lldbsuite.test import lldbutil
 
 
 class LinuxCoreThreadsTestCase(TestBase):
     NO_DEBUG_INFO_TESTCASE = True
 
     mydir = TestBase.compute_mydir(__file__)
 
-    def setUp(self):
-        super(LinuxCoreThreadsTestCase, self).setUp()
-        self._initial_platform = lldb.DBG.GetSelectedPlatform()
-
-    def tearDown(self):
-        lldb.DBG.SetSelectedPlatform(self._initial_platform)
-        super(LinuxCoreThreadsTestCase, self).tearDown()
-
     _i386_pid = 5193
     _x86_64_pid = 5222
 
     # Thread id for the failing thread.
     _i386_tid = 5195
     _x86_64_tid = 5250
 
     @skipIf(oslist=['windows'])

lldb/test/API/functionalities/postmortem/mach-core/TestMachCore.py

 from lldbsuite.test import lldbutil
 
 
 class MachCoreTestCase(TestBase):
     NO_DEBUG_INFO_TESTCASE = True
 
     mydir = TestBase.compute_mydir(__file__)
 
-    def setUp(self):
-        super(MachCoreTestCase, self).setUp()
-        self._initial_platform = lldb.DBG.GetSelectedPlatform()
-
-    def tearDown(self):
-        lldb.DBG.SetSelectedPlatform(self._initial_platform)
-        super(MachCoreTestCase, self).tearDown()
-
     # This was originally marked as expected failure on Windows, but it has
     # started timing out instead, so the expectedFailure attribute no longer
     # correctly tracks it: llvm.org/pr37371
     @skipIfWindows
     def test_selected_thread(self):
         """Test that the right thread is selected after a core is loaded."""
         # Create core form YAML.
         self.yaml2obj("test.core.yaml", self.getBuildArtifact("test.core"))

lldb/test/API/functionalities/postmortem/minidump-new/TestMiniDumpNew.py

class MiniDumpNewTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     NO_DEBUG_INFO_TESTCASE = True
 
     _linux_x86_64_pid = 29917
     _linux_x86_64_not_crashed_pid = 29939
     _linux_x86_64_not_crashed_pid_offset = 0xD967
 
-    def setUp(self):
-        super(MiniDumpNewTestCase, self).setUp()
-        self._initial_platform = lldb.DBG.GetSelectedPlatform()
-
-    def tearDown(self):
-        lldb.DBG.SetSelectedPlatform(self._initial_platform)
-        super(MiniDumpNewTestCase, self).tearDown()
-
     def process_from_yaml(self, yaml_file):
         minidump_path = self.getBuildArtifact(os.path.basename(yaml_file) + ".dmp")
         self.yaml2obj(yaml_file, minidump_path)
         self.target = self.dbg.CreateTarget(None)
         self.process = self.target.LoadCore(minidump_path)
         return self.process
 
     def check_state(self):

lldb/test/API/functionalities/postmortem/minidump-new/TestMiniDumpUUID.py

 
 
 class MiniDumpUUIDTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     NO_DEBUG_INFO_TESTCASE = True
 
-    def setUp(self):
-        super(MiniDumpUUIDTestCase, self).setUp()
-        self._initial_platform = lldb.DBG.GetSelectedPlatform()
-
-    def tearDown(self):
-        lldb.DBG.SetSelectedPlatform(self._initial_platform)
-        super(MiniDumpUUIDTestCase, self).tearDown()
-
     def verify_module(self, module, verify_path, verify_uuid):
         uuid = module.GetUUIDString()
         self.assertEqual(verify_path, module.GetFileSpec().fullpath)
         self.assertEqual(verify_uuid, uuid)
 
     def get_minidump_modules(self, yaml_file):
         minidump_path = self.getBuildArtifact(os.path.basename(yaml_file) + ".dmp")
         self.yaml2obj(yaml_file, minidump_path)

lldb/test/API/functionalities/postmortem/netbsd-core/TestNetBSDCore.py

 from lldbsuite.test import lldbutil
 
 
 class NetBSDCoreCommonTestCase(TestBase):
     NO_DEBUG_INFO_TESTCASE = True
 
     mydir = TestBase.compute_mydir(__file__)
 
-    def setUp(self):
-        super(NetBSDCoreCommonTestCase, self).setUp()
-        self._initial_platform = lldb.DBG.GetSelectedPlatform()
-
-    def tearDown(self):
-        lldb.DBG.SetSelectedPlatform(self._initial_platform)
-        super(NetBSDCoreCommonTestCase, self).tearDown()
-
     def check_memory_regions(self, process, region_count):
         region_list = process.GetMemoryRegions()
         self.assertEqual(region_list.GetSize(), region_count)
 
         region = lldb.SBMemoryRegionInfo()
 
         # Check we have the right number of regions.
         self.assertEqual(region_list.GetSize(), region_count)

lldb/test/API/functionalities/thread/backtrace_all/TestBacktraceAll.py

def test(self):
                              'stop reason = breakpoint'])
 
         # This should not result in a segmentation fault
         self.expect("thread backtrace all", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=["stop reason = breakpoint 1."])
 
         # Run to completion
         self.runCmd("continue")
-
-if __name__ == '__main__':
-    import atexit
-    lldb.SBDebugger.Initialize()
-    atexit.register(lambda: lldb.SBDebugger.Terminate())
-    unittest2.main()

lldb/test/API/functionalities/unwind/noreturn/module-end/TestNoReturnModuleEnd.py

 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestNoreturnModuleEnd(TestBase):
     NO_DEBUG_INFO_TESTCASE = True
     mydir = TestBase.compute_mydir(__file__)
 
-    def setUp(self):
-        super(TestNoreturnModuleEnd, self).setUp()
-        self._initial_platform = lldb.DBG.GetSelectedPlatform()
-
-    def tearDown(self):
-        lldb.DBG.SetSelectedPlatform(self._initial_platform)
-        super(TestNoreturnModuleEnd, self).tearDown()
-
     def test(self):
         target = self.dbg.CreateTarget("test.out")
         process = target.LoadCore("test.core")
         self.assertTrue(process.IsValid(), PROCESS_IS_VALID)
         self.assertEqual(process.GetNumThreads(), 1)
 
         thread = process.GetSelectedThread()
         self.assertTrue(thread.IsValid())

lldb/test/API/macosx/load-kext/TestLoadKext.py

 from lldbsuite.test import lldbutil
 
 
 class LoadKextTestCase(TestBase):
     NO_DEBUG_INFO_TESTCASE = True
 
     mydir = TestBase.compute_mydir(__file__)
 
-    def setUp(self):
-        TestBase.setUp(self)
-        #super(LoadKextTestCase, self).setUp()
-        #self._initial_platform = lldb.DBG.GetSelectedPlatform()
-
     def test_load_kext(self):
         """Test that lldb can load a kext binary."""
 
         # Create kext from YAML.
         self.yaml2obj("mykext.yaml", self.getBuildArtifact("mykext"))
 
         target = self.dbg.CreateTarget(self.getBuildArtifact("mykext"))
 
         self.assertTrue(target.IsValid())
 
         self.assertEqual(target.GetNumModules(), 1)
         mod = target.GetModuleAtIndex(0)
         self.assertEqual(mod.GetFileSpec().GetFilename(), "mykext")

lldb/test/API/python_api/file_handle/TestFileHandle.py

def readStrippedLines(f):
     return list(i())
 
 
 class FileHandleTestCase(lldbtest.TestBase):
 
     NO_DEBUG_INFO_TESTCASE = True
     mydir = lldbtest.Base.compute_mydir(__file__)
 
-    # The way this class interacts with the debugger is different
-    # than normal.   Most of these test cases will mess with the
-    # debugger I/O streams, so we want a fresh debugger for each
-    # test so those mutations don't interfere with each other.
-    #
-    # Also, the way normal tests evaluate debugger commands is
+    # The way normal tests evaluate debugger commands is
     # by using a SBCommandInterpreter directly, which captures
     # the output in a result object.   For many of tests tests
     # we want the debugger to write the  output directly to
     # its I/O streams like it would have done interactively.
     #
     # For this reason we also define handleCmd() here, even though
     # it is similar to runCmd().
 
     def setUp(self):
         super(FileHandleTestCase, self).setUp()
-        self.debugger = lldb.SBDebugger.Create()
         self.out_filename = self.getBuildArtifact('output')
         self.in_filename = self.getBuildArtifact('input')
 
     def tearDown(self):
-        lldb.SBDebugger.Destroy(self.debugger)
         super(FileHandleTestCase, self).tearDown()
         for name in (self.out_filename, self.in_filename):
             if os.path.exists(name):
                 os.unlink(name)
 
-    # Similar to runCmd(), but this uses the per-test debugger, and it
-    # supports, letting the debugger just print the results instead
-    # of collecting them.
+    # Similar to runCmd(), but letting the debugger just print the results
+    # instead of collecting them.
     def handleCmd(self, cmd, check=True, collect_result=True):
         assert not check or collect_result
         ret = lldb.SBCommandReturnObject()
         if collect_result:
-            interpreter = self.debugger.GetCommandInterpreter()
+            interpreter = self.dbg.GetCommandInterpreter()
             interpreter.HandleCommand(cmd, ret)
         else:
-            self.debugger.HandleCommand(cmd)
-        self.debugger.GetOutputFile().Flush()
-        self.debugger.GetErrorFile().Flush()
+            self.dbg.HandleCommand(cmd)
+        self.dbg.GetOutputFile().Flush()
+        self.dbg.GetErrorFile().Flush()
         if collect_result and check:
             self.assertTrue(ret.Succeeded())
         return ret.GetOutput()
 
 
     @add_test_categories(['pyapi'])
     def test_legacy_file_out_script(self):
         with open(self.out_filename, 'w') as f:
-            self.debugger.SetOutputFileHandle(f, False)
+            self.dbg.SetOutputFileHandle(f, False)
             # scripts print to output even if you capture the results
             # I'm not sure I love that behavior, but that's the way
             # it's been for a long time.  That's why this test works
             # even with collect_result=True.
             self.handleCmd('script 1+1')
-            self.debugger.GetOutputFileHandle().write('FOO\n')
-        lldb.SBDebugger.Destroy(self.debugger)
+            self.dbg.GetOutputFileHandle().write('FOO\n')
         with open(self.out_filename, 'r') as f:
             self.assertEqual(readStrippedLines(f), ['2', 'FOO'])
 
 
     @add_test_categories(['pyapi'])
     def test_legacy_file_out(self):
         with open(self.out_filename, 'w') as f:
-            self.debugger.SetOutputFileHandle(f, False)
+            self.dbg.SetOutputFileHandle(f, False)
             self.handleCmd('p/x 3735928559', collect_result=False, check=False)
-        lldb.SBDebugger.Destroy(self.debugger)
         with open(self.out_filename, 'r') as f:
             self.assertIn('deadbeef', f.read())
 
     @add_test_categories(['pyapi'])
     def test_legacy_file_err_with_get(self):
         with open(self.out_filename, 'w') as f:
-            self.debugger.SetErrorFileHandle(f, False)
+            self.dbg.SetErrorFileHandle(f, False)
             self.handleCmd('lolwut', check=False, collect_result=False)
-            f2 = self.debugger.GetErrorFileHandle()
+            f2 = self.dbg.GetErrorFileHandle()
             f2.write('FOOBAR\n')
             f2.flush()
-        lldb.SBDebugger.Destroy(self.debugger)
         with open(self.out_filename, 'r') as f:
             errors = f.read()
             self.assertTrue(re.search(r'error:.*lolwut', errors))
             self.assertTrue(re.search(r'FOOBAR', errors))
 
 
     @add_test_categories(['pyapi'])
     def test_legacy_file_err(self):
         with open(self.out_filename, 'w') as f:
-            self.debugger.SetErrorFileHandle(f, False)
+            self.dbg.SetErrorFileHandle(f, False)
             self.handleCmd('lol', check=False, collect_result=False)
-        lldb.SBDebugger.Destroy(self.debugger)
         with open(self.out_filename, 'r') as f:
             self.assertIn("is not a valid command", f.read())
 
 
     @add_test_categories(['pyapi'])
     def test_legacy_file_error(self):
-        debugger = self.debugger
         with open(self.out_filename, 'w') as f:
-            debugger.SetErrorFileHandle(f, False)
+            self.dbg.SetErrorFileHandle(f, False)
             self.handleCmd('lolwut', check=False, collect_result=False)
         with open(self.out_filename, 'r') as f:
             errors = f.read()
             self.assertTrue(re.search(r'error:.*lolwut', errors))
 
     @add_test_categories(['pyapi'])
     def test_sbfile_type_errors(self):
         sbf = lldb.SBFile()
def test_sbfile_read(self):
             sbf.Close()
             self.assertTrue(f.closed)
 
 
     @add_test_categories(['pyapi'])
     def test_fileno_out(self):
         with open(self.out_filename, 'w') as f:
             sbf = lldb.SBFile(f.fileno(), "w", False)
-            status = self.debugger.SetOutputFile(sbf)
+            status = self.dbg.SetOutputFile(sbf)
             self.assertTrue(status.Success())
             self.handleCmd('script 1+2')
-            self.debugger.GetOutputFile().Write(b'quux')
+            self.dbg.GetOutputFile().Write(b'quux')
 
         with open(self.out_filename, 'r') as f:
             self.assertEqual(readStrippedLines(f), ['3', 'quux'])
 
 
     @add_test_categories(['pyapi'])
     def test_fileno_help(self):
         with open(self.out_filename, 'w') as f:
             sbf = lldb.SBFile(f.fileno(), "w", False)
-            status = self.debugger.SetOutputFile(sbf)
+            status = self.dbg.SetOutputFile(sbf)
             self.assertTrue(status.Success())
             self.handleCmd("help help", collect_result=False, check=False)
         with open(self.out_filename, 'r') as f:
             self.assertTrue(re.search(r'Show a list of all debugger commands', f.read()))
 
 
     @add_test_categories(['pyapi'])
     def test_help(self):
-        debugger = self.debugger
         with open(self.out_filename, 'w') as f:
-            status = debugger.SetOutputFile(lldb.SBFile(f))
+            status = self.dbg.SetOutputFile(lldb.SBFile(f))
             self.assertTrue(status.Success())
             self.handleCmd("help help", check=False, collect_result=False)
         with open(self.out_filename, 'r') as f:
             self.assertIn('Show a list of all debugger commands', f.read())
 
 
     @add_test_categories(['pyapi'])
     def test_immediate(self):
         with open(self.out_filename, 'w') as f:
             ret = lldb.SBCommandReturnObject()
             ret.SetImmediateOutputFile(f)
-            interpreter = self.debugger.GetCommandInterpreter()
+            interpreter = self.dbg.GetCommandInterpreter()
             interpreter.HandleCommand("help help", ret)
             # make sure the file wasn't closed early.
             f.write("\nQUUX\n")
         ret = None # call destructor and flush streams
         with open(self.out_filename, 'r') as f:
             output = f.read()
             self.assertTrue(re.search(r'Show a list of all debugger commands', output))
             self.assertTrue(re.search(r'QUUX', output))
 
 
     @add_test_categories(['pyapi'])
     @skipIf(py_version=['<', (3,)])
     def test_immediate_string(self):
         f = io.StringIO()
         ret = lldb.SBCommandReturnObject()
         ret.SetImmediateOutputFile(f)
-        interpreter = self.debugger.GetCommandInterpreter()
+        interpreter = self.dbg.GetCommandInterpreter()
         interpreter.HandleCommand("help help", ret)
         # make sure the file wasn't closed early.
         f.write("\nQUUX\n")
         ret = None # call destructor and flush streams
         output = f.getvalue()
         self.assertTrue(re.search(r'Show a list of all debugger commands', output))
         self.assertTrue(re.search(r'QUUX', output))
 
 
     @add_test_categories(['pyapi'])
     @skipIf(py_version=['<', (3,)])
     def test_immediate_sbfile_string(self):
         f = io.StringIO()
         ret = lldb.SBCommandReturnObject()
         ret.SetImmediateOutputFile(lldb.SBFile(f))
-        interpreter = self.debugger.GetCommandInterpreter()
+        interpreter = self.dbg.GetCommandInterpreter()
         interpreter.HandleCommand("help help", ret)
         output = f.getvalue()
         ret = None # call destructor and flush streams
         # sbfile default constructor doesn't borrow the file
         self.assertTrue(f.closed)
         self.assertTrue(re.search(r'Show a list of all debugger commands', output))
 
 
     @add_test_categories(['pyapi'])
     def test_fileno_inout(self):
         with open(self.in_filename, 'w') as f:
             f.write("help help\n")
 
         with open(self.out_filename, 'w') as outf, open(self.in_filename, 'r') as inf:
 
             outsbf = lldb.SBFile(outf.fileno(), "w", False)
-            status = self.debugger.SetOutputFile(outsbf)
+            status = self.dbg.SetOutputFile(outsbf)
             self.assertTrue(status.Success())
 
             insbf = lldb.SBFile(inf.fileno(), "r", False)
-            status = self.debugger.SetInputFile(insbf)
+            status = self.dbg.SetInputFile(insbf)
             self.assertTrue(status.Success())
 
             opts = lldb.SBCommandInterpreterRunOptions()
-            self.debugger.RunCommandInterpreter(True, False, opts, 0, False, False)
-            self.debugger.GetOutputFile().Flush()
+            self.dbg.RunCommandInterpreter(True, False, opts, 0, False, False)
+            self.dbg.GetOutputFile().Flush()
 
         with open(self.out_filename, 'r') as f:
             self.assertTrue(re.search(r'Show a list of all debugger commands', f.read()))
 
 
     @add_test_categories(['pyapi'])
     def test_inout(self):
         with open(self.in_filename, 'w') as f:
             f.write("help help\n")
         with  open(self.out_filename, 'w') as outf, \
               open(self.in_filename, 'r') as inf:
-            status = self.debugger.SetOutputFile(lldb.SBFile(outf))
+            status = self.dbg.SetOutputFile(lldb.SBFile(outf))
             self.assertTrue(status.Success())
-            status = self.debugger.SetInputFile(lldb.SBFile(inf))
+            status = self.dbg.SetInputFile(lldb.SBFile(inf))
             self.assertTrue(status.Success())
             opts = lldb.SBCommandInterpreterRunOptions()
-            self.debugger.RunCommandInterpreter(True, False, opts, 0, False, False)
-            self.debugger.GetOutputFile().Flush()
+            self.dbg.RunCommandInterpreter(True, False, opts, 0, False, False)
+            self.dbg.GetOutputFile().Flush()
         with open(self.out_filename, 'r') as f:
             output = f.read()
             self.assertIn('Show a list of all debugger commands', output)
 
 
     @add_test_categories(['pyapi'])
     def test_binary_inout(self):
-        debugger = self.debugger
         with open(self.in_filename, 'w') as f:
             f.write("help help\n")
         with  open(self.out_filename, 'wb') as outf, \
               open(self.in_filename, 'rb') as inf:
-            status = debugger.SetOutputFile(lldb.SBFile(outf))
+            status = self.dbg.SetOutputFile(lldb.SBFile(outf))
             self.assertTrue(status.Success())
-            status = debugger.SetInputFile(lldb.SBFile(inf))
+            status = self.dbg.SetInputFile(lldb.SBFile(inf))
             self.assertTrue(status.Success())
             opts = lldb.SBCommandInterpreterRunOptions()
-            debugger.RunCommandInterpreter(True, False, opts, 0, False, False)
-            debugger.GetOutputFile().Flush()
+            self.dbg.RunCommandInterpreter(True, False, opts, 0, False, False)
+            self.dbg.GetOutputFile().Flush()
         with open(self.out_filename, 'r') as f:
             output = f.read()
             self.assertIn('Show a list of all debugger commands', output)
 
 
     @add_test_categories(['pyapi'])
     @skipIf(py_version=['<', (3,)])
     def test_string_inout(self):
         inf = io.StringIO("help help\np/x ~0\n")
         outf = io.StringIO()
-        status = self.debugger.SetOutputFile(lldb.SBFile(outf))
+        status = self.dbg.SetOutputFile(lldb.SBFile(outf))
         self.assertTrue(status.Success())
-        status = self.debugger.SetInputFile(lldb.SBFile(inf))
+        status = self.dbg.SetInputFile(lldb.SBFile(inf))
         self.assertTrue(status.Success())
         opts = lldb.SBCommandInterpreterRunOptions()
-        self.debugger.RunCommandInterpreter(True, False, opts, 0, False, False)
-        self.debugger.GetOutputFile().Flush()
+        self.dbg.RunCommandInterpreter(True, False, opts, 0, False, False)
+        self.dbg.GetOutputFile().Flush()
         output = outf.getvalue()
         self.assertIn('Show a list of all debugger commands', output)
         self.assertIn('0xfff', output)
 
 
     @add_test_categories(['pyapi'])
     @skipIf(py_version=['<', (3,)])
     def test_bytes_inout(self):
         inf = io.BytesIO(b"help help\nhelp b\n")
         outf = io.BytesIO()
-        status = self.debugger.SetOutputFile(lldb.SBFile(outf))
+        status = self.dbg.SetOutputFile(lldb.SBFile(outf))
         self.assertTrue(status.Success())
-        status = self.debugger.SetInputFile(lldb.SBFile(inf))
+        status = self.dbg.SetInputFile(lldb.SBFile(inf))
         self.assertTrue(status.Success())
         opts = lldb.SBCommandInterpreterRunOptions()
-        self.debugger.RunCommandInterpreter(True, False, opts, 0, False, False)
-        self.debugger.GetOutputFile().Flush()
+        self.dbg.RunCommandInterpreter(True, False, opts, 0, False, False)
+        self.dbg.GetOutputFile().Flush()
         output = outf.getvalue()
         self.assertIn(b'Show a list of all debugger commands', output)
         self.assertIn(b'Set a breakpoint', output)
 
 
     @add_test_categories(['pyapi'])
     def test_fileno_error(self):
         with open(self.out_filename, 'w') as f:
 
             sbf = lldb.SBFile(f.fileno(), 'w', False)
-            status = self.debugger.SetErrorFile(sbf)
+            status = self.dbg.SetErrorFile(sbf)
             self.assertTrue(status.Success())
 
             self.handleCmd('lolwut', check=False, collect_result=False)
 
-            self.debugger.GetErrorFile().Write(b'\nzork\n')
+            self.dbg.GetErrorFile().Write(b'\nzork\n')
 
         with open(self.out_filename, 'r') as f:
             errors = f.read()
             self.assertTrue(re.search(r'error:.*lolwut', errors))
             self.assertTrue(re.search(r'zork', errors))
 
 
     @add_test_categories(['pyapi'])
     def test_replace_stdout(self):
         f = io.StringIO()
         with replace_stdout(f):
             self.assertEqual(sys.stdout, f)
             self.handleCmd('script sys.stdout.write("lol")',
                 collect_result=False, check=False)
             self.assertEqual(sys.stdout, f)
 
 
     @add_test_categories(['pyapi'])
     def test_replace_stdout_with_nonfile(self):
-        debugger = self.debugger
         f = io.StringIO()
         with replace_stdout(f):
             class Nothing():
                 pass
             with replace_stdout(Nothing):
                 self.assertEqual(sys.stdout, Nothing)
                 self.handleCmd('script sys.stdout.write("lol")',
                     check=False, collect_result=False)
def test_sbfile_write_string(self):
         sbf.Close()
         self.assertTrue(f.closed)
 
 
     @add_test_categories(['pyapi'])
     @skipIf(py_version=['<', (3,)])
     def test_string_out(self):
         f = io.StringIO()
-        status = self.debugger.SetOutputFile(f)
+        status = self.dbg.SetOutputFile(f)
         self.assertTrue(status.Success())
         self.handleCmd("script 'foobar'")
         self.assertEqual(f.getvalue().strip(), "'foobar'")
 
 
     @add_test_categories(['pyapi'])
     @skipIf(py_version=['<', (3,)])
     def test_string_error(self):
         f = io.StringIO()
-        debugger = self.debugger
-        status = debugger.SetErrorFile(f)
+        status = self.dbg.SetErrorFile(f)
         self.assertTrue(status.Success())
         self.handleCmd('lolwut', check=False, collect_result=False)
         errors = f.getvalue()
         self.assertTrue(re.search(r'error:.*lolwut', errors))
 
 
     @add_test_categories(['pyapi'])
     @skipIf(py_version=['<', (3,)])
def test_sbfile_read_bytes(self):
         self.assertEqual(buf[:n], b'zork')
 
 
     @add_test_categories(['pyapi'])
     @skipIf(py_version=['<', (3,)])
     def test_sbfile_out(self):
         with open(self.out_filename, 'w') as f:
             sbf = lldb.SBFile(f)
-            status = self.debugger.SetOutputFile(sbf)
+            status = self.dbg.SetOutputFile(sbf)
             self.assertTrue(status.Success())
             self.handleCmd('script 2+2')
         with open(self.out_filename, 'r') as f:
             self.assertEqual(f.read().strip(), '4')
 
 
     @add_test_categories(['pyapi'])
     @skipIf(py_version=['<', (3,)])
     def test_file_out(self):
         with open(self.out_filename, 'w') as f:
-            status = self.debugger.SetOutputFile(f)
+            status = self.dbg.SetOutputFile(f)
             self.assertTrue(status.Success())
             self.handleCmd('script 2+2')
         with open(self.out_filename, 'r') as f:
             self.assertEqual(f.read().strip(), '4')
 
 
     @add_test_categories(['pyapi'])
     def test_sbfile_error(self):
         with open(self.out_filename, 'w') as f:
             sbf = lldb.SBFile(f)
-            status = self.debugger.SetErrorFile(sbf)
+            status = self.dbg.SetErrorFile(sbf)
             self.assertTrue(status.Success())
             self.handleCmd('lolwut', check=False, collect_result=False)
         with open(self.out_filename, 'r') as f:
             errors = f.read()
             self.assertTrue(re.search(r'error:.*lolwut', errors))
 
 
     @add_test_categories(['pyapi'])
     def test_file_error(self):
         with open(self.out_filename, 'w') as f:
-            status = self.debugger.SetErrorFile(f)
+            status = self.dbg.SetErrorFile(f)
             self.assertTrue(status.Success())
             self.handleCmd('lolwut', check=False, collect_result=False)
         with open(self.out_filename, 'r') as f:
             errors = f.read()
             self.assertTrue(re.search(r'error:.*lolwut', errors))
 
 
     @add_test_categories(['pyapi'])
def test_exceptions(self):
             self.assertTrue(error.Fail())
             self.assertIn('OH NOE', error.GetCString())
 
 
     @add_test_categories(['pyapi'])
     @skipIf(py_version=['<', (3,)])
     def test_exceptions_logged(self):
         messages = list()
-        self.debugger.SetLoggingCallback(messages.append)
+        self.dbg.SetLoggingCallback(messages.append)
         self.handleCmd('log enable lldb script')
-        self.debugger.SetOutputFile(lldb.SBFile(BadIO()))
+        self.dbg.SetOutputFile(lldb.SBFile(BadIO()))
         self.handleCmd('script 1+1')
         self.assertTrue(any('OH NOE' in msg for msg in messages))
 
 
     @add_test_categories(['pyapi'])
     @skipIf(py_version=['<', (3,)])
     def test_flush(self):
         flushed = MutableBool(False)
def test_fileno_flush(self):
             sbf = None
             self.assertFalse(f.closed)
             f.seek(0)
             self.assertEqual(f.read(), 'foobar')
 
 
     @add_test_categories(['pyapi'])
     def test_close(self):
-        debugger = self.debugger
         with open(self.out_filename, 'w') as f:
-            status = debugger.SetOutputFile(f)
+            status = self.dbg.SetOutputFile(f)
             self.assertTrue(status.Success())
             self.handleCmd("help help", check=False, collect_result=False)
             # make sure the file wasn't closed early.
             f.write("\nZAP\n")
-            lldb.SBDebugger.Destroy(debugger)
+            lldb.SBDebugger.Destroy(self.dbg)
             # check that output file was closed when debugger was destroyed.
             with self.assertRaises(ValueError):
                 f.write("\nQUUX\n")
         with open(self.out_filename, 'r') as f:
             output = f.read()
             self.assertTrue(re.search(r'Show a list of all debugger commands', output))
             self.assertTrue(re.search(r'ZAP', output))
 
 
     @add_test_categories(['pyapi'])
     @skipIf(py_version=['<', (3,)])
     def test_stdout(self):
         f = io.StringIO()
-        status = self.debugger.SetOutputFile(f)
+        status = self.dbg.SetOutputFile(f)
         self.assertTrue(status.Success())
         self.handleCmd(r"script sys.stdout.write('foobar\n')")
         self.assertEqual(f.getvalue().strip().split(), ["foobar", "7"])
 
 
     @add_test_categories(['pyapi'])
     def test_stdout_file(self):
         with open(self.out_filename, 'w') as f:
-            status = self.debugger.SetOutputFile(f)
+            status = self.dbg.SetOutputFile(f)
             self.assertTrue(status.Success())
             self.handleCmd(r"script sys.stdout.write('foobar\n')")
         with open(self.out_filename, 'r') as f:
             # In python2 sys.stdout.write() returns None, which
             # the REPL will ignore, but in python3 it will
             # return the number of bytes written, which the REPL
             # will print out.
             lines = [x for x in f.read().strip().split() if x != "7"]
def test_back_and_forth(self):
                     sbf.Write(str(i).encode('ascii') + b"\n")
             files = list(i(sbf))
         with open(self.out_filename, 'r') as f:
             self.assertEqual(list(range(10)), list(map(int, f.read().strip().split())))
 
 
     @add_test_categories(['pyapi'])
     def test_set_filehandle_none(self):
-        self.assertRaises(Exception, self.debugger.SetOutputFile, None)
-        self.assertRaises(Exception, self.debugger.SetOutputFile, "ham sandwich")
-        self.assertRaises(Exception, self.debugger.SetOutputFileHandle, "ham sandwich")
-        self.assertRaises(Exception, self.debugger.SetInputFile, None)
-        self.assertRaises(Exception, self.debugger.SetInputFile, "ham sandwich")
-        self.assertRaises(Exception, self.debugger.SetInputFileHandle, "ham sandwich")
-        self.assertRaises(Exception, self.debugger.SetErrorFile, None)
-        self.assertRaises(Exception, self.debugger.SetErrorFile, "ham sandwich")
-        self.assertRaises(Exception, self.debugger.SetErrorFileHandle, "ham sandwich")
-
-        with open(self.out_filename, 'w') as f:
-            status = self.debugger.SetOutputFile(f)
-            self.assertTrue(status.Success())
-            status = self.debugger.SetErrorFile(f)
-            self.assertTrue(status.Success())
-            self.debugger.SetOutputFileHandle(None, False)
-            self.debugger.SetErrorFileHandle(None, False)
-            sbf = self.debugger.GetOutputFile()
+        self.assertRaises(Exception, self.dbg.SetOutputFile, None)
+        self.assertRaises(Exception, self.dbg.SetOutputFile, "ham sandwich")
+        self.assertRaises(Exception, self.dbg.SetOutputFileHandle, "ham sandwich")
+        self.assertRaises(Exception, self.dbg.SetInputFile, None)
+        self.assertRaises(Exception, self.dbg.SetInputFile, "ham sandwich")
+        self.assertRaises(Exception, self.dbg.SetInputFileHandle, "ham sandwich")
+        self.assertRaises(Exception, self.dbg.SetErrorFile, None)
+        self.assertRaises(Exception, self.dbg.SetErrorFile, "ham sandwich")
+        self.assertRaises(Exception, self.dbg.SetErrorFileHandle, "ham sandwich")
+
+        with open(self.out_filename, 'w') as f:
+            status = self.dbg.SetOutputFile(f)
+            self.assertTrue(status.Success())
+            status = self.dbg.SetErrorFile(f)
+            self.assertTrue(status.Success())
+            self.dbg.SetOutputFileHandle(None, False)
+            self.dbg.SetErrorFileHandle(None, False)
+            sbf = self.dbg.GetOutputFile()
             if sys.version_info.major >= 3:
                 # python 2 lacks PyFile_FromFd, so GetFile() will
                 # have to duplicate the file descriptor and make a FILE*
                 # in order to convert a NativeFile it back to a python
                 # file.
                 self.assertEqual(sbf.GetFile().fileno(), 1)
-            sbf = self.debugger.GetErrorFile()
+            sbf = self.dbg.GetErrorFile()
             if sys.version_info.major >= 3:
                 self.assertEqual(sbf.GetFile().fileno(), 2)
         with open(self.out_filename, 'r') as f:
-            status = self.debugger.SetInputFile(f)
+            status = self.dbg.SetInputFile(f)
             self.assertTrue(status.Success())
-            self.debugger.SetInputFileHandle(None, False)
-            sbf = self.debugger.GetInputFile()
+            self.dbg.SetInputFileHandle(None, False)
+            sbf = self.dbg.GetInputFile()
             if sys.version_info.major >= 3:
                 self.assertEqual(sbf.GetFile().fileno(), 0)
 
 
     @add_test_categories(['pyapi'])
     def test_sbstream(self):
 
         with open(self.out_filename, 'w') as f:

lldb/test/API/tools/lldb-server/platform-process-connect/TestPlatformProcessConnect.py

 
 import time
 
 import gdbremote_testcase
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestPlatformProcessConnect(gdbremote_testcase.GdbRemoteTestCaseBase):
     mydir = TestBase.compute_mydir(__file__)
 
-    def setUp(self):
-        super(TestPlatformProcessConnect, self).setUp()
-        self._initial_platform = lldb.DBG.GetSelectedPlatform()
-
-    def tearDown(self):
-        lldb.DBG.SetSelectedPlatform(self._initial_platform)
-        super(TestPlatformProcessConnect, self).tearDown()
-
     @llgs_test
     @no_debug_info_test
     @skipIf(remote=False)
     @expectedFailureAll(hostoslist=["windows"], triple='.*-android')
     def test_platform_process_connect(self):
         self.build()
         self.init_llgs_test(False)
 
def test_platform_process_connect(self):
         self.spawnSubprocess(
             self.debug_monitor_exe,
             commandline_args,
             install_remote=False)
         self.addTearDownHook(self.cleanupSubprocesses)
 
         socket_id = lldbutil.wait_for_file_on_target(self, port_file)
 
-        new_debugger = lldb.SBDebugger.Create()
-        new_debugger.SetAsync(False)
-
-        def del_debugger(new_debugger=new_debugger):
-            del new_debugger
-        self.addTearDownHook(del_debugger)
+        self.dbg.SetAsync(False)
 
         new_platform = lldb.SBPlatform(lldb.remote_platform.GetName())
-        new_debugger.SetSelectedPlatform(new_platform)
-        new_interpreter = new_debugger.GetCommandInterpreter()
+        self.dbg.SetSelectedPlatform(new_platform)
 
         if unix_protocol:
             connect_url = "%s://%s%s" % (protocol, hostname, socket_id)
         else:
             connect_url = "%s://%s:%s" % (protocol, hostname, socket_id)
 
         command = "platform connect %s" % (connect_url)
         result = lldb.SBCommandReturnObject()
-        new_interpreter.HandleCommand(command, result)
+        self.dbg.GetCommandInterpreter().HandleCommand(command, result)
         self.assertTrue(
             result.Succeeded(),
             "platform process connect failed: %s" %
             result.GetOutput())
 
-        target = new_debugger.GetSelectedTarget()
+        target = self.dbg.GetSelectedTarget()
         process = target.GetProcess()
         thread = process.GetThreadAtIndex(0)
 
         breakpoint = target.BreakpointCreateByName("main")
         process.Continue()
 
         frame = thread.GetFrameAtIndex(0)
         self.assertEqual(frame.GetFunction().GetName(), "main")
         self.assertEqual(frame.FindVariable("argc").GetValueAsSigned(), 2)
         process.Continue()