Merge pull request #6915 from apple/jdevlieghere/5.9/python-reformatting

[lldb] Reformat LLDB tests with black (NFC)

Author: JDevlieghere

lldb/test/API/android/platform/TestDefaultCacheLineSize.py

@@ -3,7 +3,6 @@
 """
 
 
-
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
@@ -20,23 +19,17 @@ def test_cache_line_size(self):
         self.assertTrue(target and target.IsValid(), "Target is valid")
 
         breakpoint = target.BreakpointCreateByName("main")
-        self.assertTrue(
-            breakpoint and breakpoint.IsValid(),
-            "Breakpoint is valid")
+        self.assertTrue(breakpoint and breakpoint.IsValid(), "Breakpoint is valid")
 
         # Run the program.
-        process = target.LaunchSimple(
-            None, None, self.get_process_working_directory())
+        process = target.LaunchSimple(None, None, self.get_process_working_directory())
         self.assertTrue(process and process.IsValid(), PROCESS_IS_VALID)
-        self.assertEqual(
-            process.GetState(),
-            lldb.eStateStopped,
-            PROCESS_STOPPED)
+        self.assertEqual(process.GetState(), lldb.eStateStopped, PROCESS_STOPPED)
 
         # check the setting value
         self.expect(
-            "settings show target.process.memory-cache-line-size",
-            patterns=[" = 2048"])
+            "settings show target.process.memory-cache-line-size", patterns=[" = 2048"]
+        )
 
         # Run to completion.
         process.Continue()

lldb/test/API/api/check_public_api_headers/TestPublicAPIHeaders.py

@@ -13,7 +13,7 @@ class SBDirCheckerCase(TestBase):
 
     def setUp(self):
         TestBase.setUp(self)
-        self.source = 'main.cpp'
+        self.source = "main.cpp"
         self.generateSource(self.source)
 
     @skipIfNoSBHeaders
@@ -24,8 +24,7 @@ def test_sb_api_directory(self):
         if not (self.platformIsDarwin() and self.getArchitecture() == "x86_64"):
             self.skipTest("This test is only for LLDB.framework built 64-bit")
         if self.getArchitecture() == "i386":
-            self.skipTest(
-                "LLDB is 64-bit and cannot be linked to 32-bit test program.")
+            self.skipTest("LLDB is 64-bit and cannot be linked to 32-bit test program.")
 
         exe_name = self.getBuildArtifact("a.out")
         self.buildDriver(self.source, exe_name)
@@ -39,26 +38,33 @@ def sanity_check_executable(self, exe_name):
 
         # This test uses a generated source file, so it's in the build directory.
         self.line_to_break = line_number(
-            self.getBuildArtifact(self.source), '// Set breakpoint here.')
+            self.getBuildArtifact(self.source), "// Set breakpoint here."
+        )
 
         env_cmd = "settings set target.env-vars %s=%s" % (
-            self.dylibPath, self.getLLDBLibraryEnvVal())
+            self.dylibPath,
+            self.getLLDBLibraryEnvVal(),
+        )
         if self.TraceOn():
             print("Set environment to: ", env_cmd)
         self.runCmd(env_cmd)
         self.addTearDownHook(
             lambda: self.dbg.HandleCommand(
-                "settings remove target.env-vars %s" %
-                self.dylibPath))
+                "settings remove target.env-vars %s" % self.dylibPath
+            )
+        )
 
         lldbutil.run_break_set_by_file_and_line(
-            self, self.source, self.line_to_break, num_expected_locations=-1)
+            self, self.source, self.line_to_break, num_expected_locations=-1
+        )
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
-        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
-                    substrs=['stopped',
-                             'stop reason = breakpoint'])
+        self.expect(
+            "thread list",
+            STOPPED_DUE_TO_BREAKPOINT,
+            substrs=["stopped", "stop reason = breakpoint"],
+        )
 
-        self.runCmd('frame variable')
+        self.runCmd("frame variable")

lldb/test/API/api/command-return-object/TestSBCommandReturnObject.py

@@ -10,20 +10,24 @@ class TestSBCommandReturnObject(TestBase):
 
     @skipIfNoSBHeaders
     @expectedFailureAll(
-        oslist=["windows"], archs=["i[3-6]86", "x86_64"],
-        bugnumber="llvm.org/pr43570")
+        oslist=["windows"], archs=["i[3-6]86", "x86_64"], bugnumber="llvm.org/pr43570"
+    )
     def test_sb_command_return_object(self):
         env = {self.dylibPath: self.getLLDBLibraryEnvVal()}
 
         self.driver_exe = self.getBuildArtifact("command-return-object")
-        self.buildDriver('main.cpp', self.driver_exe)
+        self.buildDriver("main.cpp", self.driver_exe)
         self.addTearDownHook(lambda: os.remove(self.driver_exe))
         self.signBinary(self.driver_exe)
 
         if self.TraceOn():
             print("Running test %s" % self.driver_exe)
             check_call([self.driver_exe, self.driver_exe], env=env)
         else:
-            with open(os.devnull, 'w') as fnull:
-                check_call([self.driver_exe, self.driver_exe],
-                           env=env, stdout=fnull, stderr=fnull)
+            with open(os.devnull, "w") as fnull:
+                check_call(
+                    [self.driver_exe, self.driver_exe],
+                    env=env,
+                    stdout=fnull,
+                    stderr=fnull,
+                )

lldb/test/API/api/listeners/TestListener.py

@@ -7,7 +7,8 @@
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
-class ListenToModuleLoadedEvents (TestBase):
+
+class ListenToModuleLoadedEvents(TestBase):
     NO_DEBUG_INFO_TESTCASE = True
 
     def test_clearing_listener(self):
@@ -21,15 +22,18 @@ def test_clearing_listener(self):
         my_listener.StartListeningForEventClass(
             self.dbg,
             lldb.SBTarget.GetBroadcasterClassName(),
-            lldb.SBTarget.eBroadcastBitBreakpointChanged)
+            lldb.SBTarget.eBroadcastBitBreakpointChanged,
+        )
         my_first_listener.StartListeningForEventClass(
             self.dbg,
             lldb.SBTarget.GetBroadcasterClassName(),
-            lldb.SBTarget.eBroadcastBitWatchpointChanged)
+            lldb.SBTarget.eBroadcastBitWatchpointChanged,
+        )
         my_third_listener.StartListeningForEventClass(
             self.dbg,
             lldb.SBTarget.GetBroadcasterClassName(),
-            lldb.SBTarget.eBroadcastBitModulesUnloaded)
+            lldb.SBTarget.eBroadcastBitModulesUnloaded,
+        )
 
         my_listener.Clear()
 
@@ -39,8 +43,10 @@ def test_clearing_listener(self):
 
         event = lldb.SBEvent()
         my_listener.WaitForEvent(1, event)
-        self.assertTrue(not event.IsValid(), "We don't get events we aren't listening to.")
-        
+        self.assertTrue(
+            not event.IsValid(), "We don't get events we aren't listening to."
+        )
+
     def test_receiving_breakpoint_added_from_debugger(self):
         """Test that we get breakpoint added events, waiting on event classes on the debugger"""
         self.build()
@@ -50,7 +56,8 @@ def test_receiving_breakpoint_added_from_debugger(self):
         my_listener.StartListeningForEventClass(
             self.dbg,
             lldb.SBTarget.GetBroadcasterClassName(),
-            lldb.SBTarget.eBroadcastBitBreakpointChanged)
+            lldb.SBTarget.eBroadcastBitBreakpointChanged,
+        )
 
         target = self.createTestTarget()
 
@@ -61,26 +68,34 @@ def test_receiving_breakpoint_added_from_debugger(self):
 
         self.assertTrue(event.IsValid(), "Got a valid event.")
         self.assertTrue(
-            lldb.SBBreakpoint.EventIsBreakpointEvent(event),
-            "It is a breakpoint event.")
-        self.assertTrue(lldb.SBBreakpoint.GetBreakpointEventTypeFromEvent(
-            event) == lldb.eBreakpointEventTypeAdded, "It is a breakpoint added event.")
+            lldb.SBBreakpoint.EventIsBreakpointEvent(event), "It is a breakpoint event."
+        )
+        self.assertTrue(
+            lldb.SBBreakpoint.GetBreakpointEventTypeFromEvent(event)
+            == lldb.eBreakpointEventTypeAdded,
+            "It is a breakpoint added event.",
+        )
         self.assertEqual(
-            bkpt, lldb.SBBreakpoint.GetBreakpointFromEvent(event),
-            "It is our breakpoint.")
+            bkpt,
+            lldb.SBBreakpoint.GetBreakpointFromEvent(event),
+            "It is our breakpoint.",
+        )
 
         # Now make sure if we stop listening for events we don't get them:
         my_listener.StopListeningForEventClass(
             self.dbg,
             lldb.SBTarget.GetBroadcasterClassName(),
-            lldb.SBTarget.eBroadcastBitBreakpointChanged)
+            lldb.SBTarget.eBroadcastBitBreakpointChanged,
+        )
         my_listener.StopListeningForEvents(
-            target.GetBroadcaster(),
-            lldb.SBTarget.eBroadcastBitBreakpointChanged)
-            
+            target.GetBroadcaster(), lldb.SBTarget.eBroadcastBitBreakpointChanged
+        )
+
         bkpt2 = target.BreakpointCreateByName("main")
         my_listener.WaitForEvent(1, event)
-        self.assertTrue(not event.IsValid(), "We don't get events we aren't listening to.")
+        self.assertTrue(
+            not event.IsValid(), "We don't get events we aren't listening to."
+        )
 
     def test_recieving_breakpoint_added_from_target(self):
         """Test that we get breakpoint added events, waiting on event classes on the debugger"""
@@ -90,12 +105,16 @@ def test_recieving_breakpoint_added_from_target(self):
         my_listener.StartListeningForEventClass(
             self.dbg,
             lldb.SBTarget.GetBroadcasterClassName(),
-            lldb.SBTarget.eBroadcastBitBreakpointChanged)
+            lldb.SBTarget.eBroadcastBitBreakpointChanged,
+        )
 
         target = self.createTestTarget()
-        result = target.GetBroadcaster().AddListener(my_listener,
-                                                     lldb.SBTarget.eBroadcastBitBreakpointChanged)
-        self.assertEqual(result, lldb.SBTarget.eBroadcastBitBreakpointChanged,"Got our bit")
+        result = target.GetBroadcaster().AddListener(
+            my_listener, lldb.SBTarget.eBroadcastBitBreakpointChanged
+        )
+        self.assertEqual(
+            result, lldb.SBTarget.eBroadcastBitBreakpointChanged, "Got our bit"
+        )
 
         bkpt = target.BreakpointCreateByName("main")
 
@@ -104,18 +123,24 @@ def test_recieving_breakpoint_added_from_target(self):
 
         self.assertTrue(event.IsValid(), "Got a valid event.")
         self.assertTrue(
-            lldb.SBBreakpoint.EventIsBreakpointEvent(event),
-            "It is a breakpoint event.")
-        self.assertTrue(lldb.SBBreakpoint.GetBreakpointEventTypeFromEvent(
-            event) == lldb.eBreakpointEventTypeAdded, "It is a breakpoint added event.")
+            lldb.SBBreakpoint.EventIsBreakpointEvent(event), "It is a breakpoint event."
+        )
+        self.assertTrue(
+            lldb.SBBreakpoint.GetBreakpointEventTypeFromEvent(event)
+            == lldb.eBreakpointEventTypeAdded,
+            "It is a breakpoint added event.",
+        )
         self.assertEqual(
-            bkpt, lldb.SBBreakpoint.GetBreakpointFromEvent(event),
-            "It is our breakpoint.")
+            bkpt,
+            lldb.SBBreakpoint.GetBreakpointFromEvent(event),
+            "It is our breakpoint.",
+        )
 
         # Now make sure if we stop listening for events we don't get them:
         target.GetBroadcaster().RemoveListener(my_listener)
-            
+
         bkpt2 = target.BreakpointCreateByName("main")
         my_listener.WaitForEvent(1, event)
-        self.assertTrue(not event.IsValid(), "We don't get events we aren't listening to.")
- 
+        self.assertTrue(
+            not event.IsValid(), "We don't get events we aren't listening to."
+        )

lldb/test/API/api/log/TestAPILog.py

@@ -10,7 +10,6 @@
 
 
 class APILogTestCase(TestBase):
-
     NO_DEBUG_INFO_TESTCASE = True
 
     def test_api_log(self):
@@ -24,21 +23,35 @@ def test_api_log(self):
         target = self.dbg.CreateTarget(None)
 
         self.assertTrue(os.path.isfile(logfile))
-        with open(logfile, 'r') as f:
+        with open(logfile, "r") as f:
             log = f.read()
 
         # Find the SBDebugger's address.
         debugger_addr = re.findall(
-            r"lldb::SBDebugger::GetScriptingLanguage\([^)]*\) \(0x([0-9a-fA-F]+),",
-            log)
+            r"lldb::SBDebugger::GetScriptingLanguage\([^)]*\) \(0x([0-9a-fA-F]+),", log
+        )
 
         # Make sure we've found a match.
         self.assertTrue(debugger_addr, log)
 
         # Make sure the GetScriptingLanguage matches.
-        self.assertTrue(re.search(r'lldb::SBDebugger::GetScriptingLanguage\([^)]*\) \(0x{}, ""\)'.format(
-            debugger_addr[0]), log), log)
+        self.assertTrue(
+            re.search(
+                r'lldb::SBDebugger::GetScriptingLanguage\([^)]*\) \(0x{}, ""\)'.format(
+                    debugger_addr[0]
+                ),
+                log,
+            ),
+            log,
+        )
 
         # Make sure the address matches.
-        self.assertTrue(re.search(r'lldb::SBDebugger::CreateTarget\([^)]*\) \(0x{}, ""\)'.format(
-            debugger_addr[0]), log), log)
+        self.assertTrue(
+            re.search(
+                r'lldb::SBDebugger::CreateTarget\([^)]*\) \(0x{}, ""\)'.format(
+                    debugger_addr[0]
+                ),
+                log,
+            ),
+            log,
+        )

lldb/test/API/api/multiple-debuggers/TestMultipleDebuggers.py

@@ -9,7 +9,6 @@
 
 
 class TestMultipleSimultaneousDebuggers(TestBase):
-
     NO_DEBUG_INFO_TESTCASE = True
 
     @skipIfNoSBHeaders
@@ -18,17 +17,17 @@ def test_multiple_debuggers(self):
         env = {self.dylibPath: self.getLLDBLibraryEnvVal()}
 
         # We need this in order to run under ASAN, in case only LLDB is ASANified.
-        asan_options = os.getenv('ASAN_OPTIONS', None)
-        if (asan_options is not None):
-            env['ASAN_OPTIONS'] = asan_options
+        asan_options = os.getenv("ASAN_OPTIONS", None)
+        if asan_options is not None:
+            env["ASAN_OPTIONS"] = asan_options
 
         self.driver_exe = self.getBuildArtifact("multi-process-driver")
-        self.buildDriver('multi-process-driver.cpp', self.driver_exe)
+        self.buildDriver("multi-process-driver.cpp", self.driver_exe)
         self.addTearDownHook(lambda: os.remove(self.driver_exe))
         self.signBinary(self.driver_exe)
 
         self.inferior_exe = self.getBuildArtifact("testprog")
-        self.buildDriver('testprog.cpp', self.inferior_exe)
+        self.buildDriver("testprog.cpp", self.inferior_exe)
         self.addTearDownHook(lambda: os.remove(self.inferior_exe))
 
         # check_call will raise a CalledProcessError if multi-process-driver
@@ -39,6 +38,10 @@ def test_multiple_debuggers(self):
             print("Running test %s" % self.driver_exe)
             check_call([self.driver_exe, self.inferior_exe], env=env)
         else:
-            with open(os.devnull, 'w') as fnull:
-                check_call([self.driver_exe, self.inferior_exe],
-                           env=env, stdout=fnull, stderr=fnull)
+            with open(os.devnull, "w") as fnull:
+                check_call(
+                    [self.driver_exe, self.inferior_exe],
+                    env=env,
+                    stdout=fnull,
+                    stderr=fnull,
+                )