*** This commit represents a complete reformatting of the LLDB source code

*** to conform to clang-format’s LLVM style.  This kind of mass change has
*** two obvious implications:

Firstly, merging this particular commit into a downstream fork may be a huge
effort.  Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit.  The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):

    find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
    find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;

The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.

Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit.  There are alternatives available that will attempt
to look through this change and find the appropriate prior commit.  YMMV.

llvm-svn: 280751

1 files changed, 109 insertions, 54 deletions

diff --git a/lldb/packages/Python/lldbsuite/test/functionalities/inferior-assert/TestInferiorAssert.py b/lldb/packages/Python/lldbsuite/test/functionalities/inferior-assert/TestInferiorAssert.py
index ceeb2eadaf4..7b048fedebb 100644
--- a/lldb/packages/Python/lldbsuite/test/functionalities/inferior-assert/TestInferiorAssert.py
+++ b/lldb/packages/Python/lldbsuite/test/functionalities/inferior-assert/TestInferiorAssert.py
@@ -3,79 +3,117 @@
 from __future__ import print_function
 
 
-
-import os, time
+import os
+import time
 import lldb
 from lldbsuite.test import lldbutil
 from lldbsuite.test import lldbplatformutil
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 
+
 class AssertingInferiorTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
-    @expectedFailureAll(oslist=["linux"], archs=["arm"], bugnumber="llvm.org/pr25338")
-    @expectedFailureAll(bugnumber="llvm.org/pr26592", triple = '^mips')
+    @expectedFailureAll(
+        oslist=["windows"],
+        bugnumber="llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
+    @expectedFailureAll(
+        oslist=["linux"],
+        archs=["arm"],
+        bugnumber="llvm.org/pr25338")
+    @expectedFailureAll(bugnumber="llvm.org/pr26592", triple='^mips')
     def test_inferior_asserting(self):
         """Test that lldb reliably catches the inferior asserting (command)."""
         self.build()
         self.inferior_asserting()
 
-    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
-    @expectedFailureAndroid(api_levels=list(range(16 + 1))) # b.android.com/179836
+    @expectedFailureAll(
+        oslist=["windows"],
+        bugnumber="llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
+    @expectedFailureAndroid(
+        api_levels=list(
+            range(
+                16 +
+                1)))  # b.android.com/179836
     def test_inferior_asserting_register(self):
         """Test that lldb reliably reads registers from the inferior after asserting (command)."""
         self.build()
         self.inferior_asserting_registers()
 
-    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
-    @expectedFailureAll(oslist=["linux"], archs=["aarch64", "arm"], bugnumber="llvm.org/pr25338")
-    @expectedFailureAll(bugnumber="llvm.org/pr26592", triple = '^mips')
+    @expectedFailureAll(
+        oslist=["windows"],
+        bugnumber="llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
+    @expectedFailureAll(
+        oslist=["linux"],
+        archs=[
+            "aarch64",
+            "arm"],
+        bugnumber="llvm.org/pr25338")
+    @expectedFailureAll(bugnumber="llvm.org/pr26592", triple='^mips')
     def test_inferior_asserting_disassemble(self):
         """Test that lldb reliably disassembles frames after asserting (command)."""
         self.build()
         self.inferior_asserting_disassemble()
 
     @add_test_categories(['pyapi'])
-    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
+    @expectedFailureAll(
+        oslist=["windows"],
+        bugnumber="llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
     def test_inferior_asserting_python(self):
         """Test that lldb reliably catches the inferior asserting (Python API)."""
         self.build()
         self.inferior_asserting_python()
 
-    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
-    @expectedFailureAll(oslist=["linux"], archs=["aarch64", "arm"], bugnumber="llvm.org/pr25338")
-    @expectedFailureAll(bugnumber="llvm.org/pr26592", triple = '^mips')
+    @expectedFailureAll(
+        oslist=["windows"],
+        bugnumber="llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
+    @expectedFailureAll(
+        oslist=["linux"],
+        archs=[
+            "aarch64",
+            "arm"],
+        bugnumber="llvm.org/pr25338")
+    @expectedFailureAll(bugnumber="llvm.org/pr26592", triple='^mips')
     def test_inferior_asserting_expr(self):
         """Test that the lldb expression interpreter can read from the inferior after asserting (command)."""
         self.build()
         self.inferior_asserting_expr()
 
-    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
-    @expectedFailureAll(oslist=["linux"], archs=["aarch64", "arm"], bugnumber="llvm.org/pr25338")
-    @expectedFailureAll(bugnumber="llvm.org/pr26592", triple = '^mips')
+    @expectedFailureAll(
+        oslist=["windows"],
+        bugnumber="llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
+    @expectedFailureAll(
+        oslist=["linux"],
+        archs=[
+            "aarch64",
+            "arm"],
+        bugnumber="llvm.org/pr25338")
+    @expectedFailureAll(bugnumber="llvm.org/pr26592", triple='^mips')
     def test_inferior_asserting_step(self):
         """Test that lldb functions correctly after stepping through a call to assert()."""
         self.build()
         self.inferior_asserting_step()
 
     def set_breakpoint(self, line):
-        lldbutil.run_break_set_by_file_and_line (self, "main.c", line, num_expected_locations=1, loc_exact=True)
+        lldbutil.run_break_set_by_file_and_line(
+            self, "main.c", line, num_expected_locations=1, loc_exact=True)
 
     def check_stop_reason(self):
-        matched = lldbplatformutil.match_android_device(self.getArchitecture(), valid_api_levels=list(range(1, 16+1)))
+        matched = lldbplatformutil.match_android_device(
+            self.getArchitecture(), valid_api_levels=list(range(1, 16 + 1)))
         if matched:
-            # On android until API-16 the abort() call ended in a sigsegv instead of in a sigabrt
+            # On android until API-16 the abort() call ended in a sigsegv
+            # instead of in a sigabrt
             stop_reason = 'stop reason = signal SIGSEGV'
         else:
             stop_reason = 'stop reason = signal SIGABRT'
 
         # The stop reason of the thread should be an abort signal or exception.
         self.expect("thread list", STOPPED_DUE_TO_ASSERT,
-            substrs = ['stopped',
-                       stop_reason])
+                    substrs=['stopped',
+                             stop_reason])
 
         return stop_reason
 
@@ -95,12 +133,12 @@ class AssertingInferiorTestCase(TestBase):
 
         # And it should report a backtrace that includes the assert site.
         self.expect("thread backtrace all",
-            substrs = [stop_reason, 'main', 'argc', 'argv'])
+                    substrs=[stop_reason, 'main', 'argc', 'argv'])
 
         # And it should report the correct line number.
         self.expect("thread backtrace all",
-            substrs = [stop_reason,
-                       'main.c:%d' % self.line])
+                    substrs=[stop_reason,
+                             'main.c:%d' % self.line])
 
     def inferior_asserting_python(self):
         """Inferior asserts upon launching; lldb should catch the event and stop."""
@@ -111,7 +149,8 @@ class AssertingInferiorTestCase(TestBase):
 
         # Now launch the process, and do not stop at entry point.
         # Both argv and envp are null.
-        process = target.LaunchSimple (None, None, self.get_process_working_directory())
+        process = target.LaunchSimple(
+            None, None, self.get_process_working_directory())
 
         if process.GetState() != lldb.eStateStopped:
             self.fail("Process should be in the 'stopped' state, "
@@ -133,7 +172,8 @@ class AssertingInferiorTestCase(TestBase):
         self.runCmd("run", RUN_SUCCEEDED)
         self.check_stop_reason()
 
-        # lldb should be able to read from registers from the inferior after asserting.
+        # lldb should be able to read from registers from the inferior after
+        # asserting.
         lldbplatformutil.check_first_register_readable(self)
 
     def inferior_asserting_disassemble(self):
@@ -145,7 +185,7 @@ class AssertingInferiorTestCase(TestBase):
         self.assertTrue(target, VALID_TARGET)
 
         # Launch the process, and do not stop at the entry point.
-        target.LaunchSimple (None, None, self.get_process_working_directory())
+        target.LaunchSimple(None, None, self.get_process_working_directory())
         self.check_stop_reason()
 
         process = target.GetProcess()
@@ -154,17 +194,20 @@ class AssertingInferiorTestCase(TestBase):
         thread = process.GetThreadAtIndex(0)
         self.assertTrue(thread.IsValid(), "current thread is valid")
 
-        lastframeID = thread.GetFrameAtIndex(thread.GetNumFrames() - 1).GetFrameID()
+        lastframeID = thread.GetFrameAtIndex(
+            thread.GetNumFrames() - 1).GetFrameID()
 
         isi386Arch = False
         if "i386" in self.getArchitecture():
             isi386Arch = True
 
-        # lldb should be able to disassemble frames from the inferior after asserting.
+        # lldb should be able to disassemble frames from the inferior after
+        # asserting.
         for frame in thread:
             self.assertTrue(frame.IsValid(), "current frame is valid")
 
-            self.runCmd("frame select " + str(frame.GetFrameID()), RUN_SUCCEEDED)
+            self.runCmd("frame select " +
+                        str(frame.GetFrameID()), RUN_SUCCEEDED)
 
             # Don't expect the function name to be in the disassembly as the assert
             # function might be a no-return function where the PC is past the end
@@ -174,11 +217,14 @@ class AssertingInferiorTestCase(TestBase):
             pc_backup_offset = 1
             if frame.GetFrameID() == 0:
                 pc_backup_offset = 0
-            if isi386Arch == True:
+            if isi386Arch:
                 if lastframeID == frame.GetFrameID():
                     pc_backup_offset = 0
-            self.expect("disassemble -a %s" % (frame.GetPC() - pc_backup_offset),
-                    substrs = ['<+0>: '])
+            self.expect(
+                "disassemble -a %s" %
+                (frame.GetPC() -
+                 pc_backup_offset),
+                substrs=['<+0>: '])
 
     def check_expr_in_main(self, thread):
         depth = thread.GetNumFrames()
@@ -186,17 +232,19 @@ class AssertingInferiorTestCase(TestBase):
             frame = thread.GetFrameAtIndex(i)
             self.assertTrue(frame.IsValid(), "current frame is valid")
             if self.TraceOn():
-                print("Checking if function %s is main" % frame.GetFunctionName())
+                print(
+                    "Checking if function %s is main" %
+                    frame.GetFunctionName())
 
             if 'main' == frame.GetFunctionName():
                 frame_id = frame.GetFrameID()
                 self.runCmd("frame select " + str(frame_id), RUN_SUCCEEDED)
-                self.expect("p argc", substrs = ['(int)', ' = 1'])
-                self.expect("p hello_world", substrs = ['Hello'])
-                self.expect("p argv[0]", substrs = ['a.out'])
-                self.expect("p null_ptr", substrs = ['= 0x0'])
-                return True 
-        return False 
+                self.expect("p argc", substrs=['(int)', ' = 1'])
+                self.expect("p hello_world", substrs=['Hello'])
+                self.expect("p argv[0]", substrs=['a.out'])
+                self.expect("p null_ptr", substrs=['= 0x0'])
+                return True
+        return False
 
     def inferior_asserting_expr(self):
         """Test that the lldb expression interpreter can read symbols after asserting."""
@@ -207,7 +255,7 @@ class AssertingInferiorTestCase(TestBase):
         self.assertTrue(target, VALID_TARGET)
 
         # Launch the process, and do not stop at the entry point.
-        target.LaunchSimple (None, None, self.get_process_working_directory())
+        target.LaunchSimple(None, None, self.get_process_working_directory())
         self.check_stop_reason()
 
         process = target.GetProcess()
@@ -216,8 +264,11 @@ class AssertingInferiorTestCase(TestBase):
         thread = process.GetThreadAtIndex(0)
         self.assertTrue(thread.IsValid(), "current thread is valid")
 
-        # The lldb expression interpreter should be able to read from addresses of the inferior after a call to assert().
-        self.assertTrue(self.check_expr_in_main(thread), "cannot find 'main' in the backtrace")
+        # The lldb expression interpreter should be able to read from addresses
+        # of the inferior after a call to assert().
+        self.assertTrue(
+            self.check_expr_in_main(thread),
+            "cannot find 'main' in the backtrace")
 
     def inferior_asserting_step(self):
         """Test that lldb functions correctly after stepping through a call to assert()."""
@@ -229,20 +280,21 @@ class AssertingInferiorTestCase(TestBase):
 
         # Launch the process, and do not stop at the entry point.
         self.set_breakpoint(self.line)
-        target.LaunchSimple (None, None, self.get_process_working_directory())
+        target.LaunchSimple(None, None, self.get_process_working_directory())
 
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
-            substrs = ['main.c:%d' % self.line,
-                       'stop reason = breakpoint'])
+                    substrs=['main.c:%d' % self.line,
+                             'stop reason = breakpoint'])
 
         self.runCmd("next")
         stop_reason = self.check_stop_reason()
 
-        # lldb should be able to read from registers from the inferior after asserting.
+        # lldb should be able to read from registers from the inferior after
+        # asserting.
         if "x86_64" in self.getArchitecture():
-            self.expect("register read rbp", substrs = ['rbp = 0x'])
+            self.expect("register read rbp", substrs=['rbp = 0x'])
         if "i386" in self.getArchitecture():
-            self.expect("register read ebp", substrs = ['ebp = 0x'])
+            self.expect("register read ebp", substrs=['ebp = 0x'])
 
         process = target.GetProcess()
         self.assertTrue(process.IsValid(), "current process is valid")
@@ -250,10 +302,13 @@ class AssertingInferiorTestCase(TestBase):
         thread = process.GetThreadAtIndex(0)
         self.assertTrue(thread.IsValid(), "current thread is valid")
 
-        # The lldb expression interpreter should be able to read from addresses of the inferior after a call to assert().
-        self.assertTrue(self.check_expr_in_main(thread), "cannot find 'main' in the backtrace")
+        # The lldb expression interpreter should be able to read from addresses
+        # of the inferior after a call to assert().
+        self.assertTrue(
+            self.check_expr_in_main(thread),
+            "cannot find 'main' in the backtrace")
 
         # And it should report the correct line number.
         self.expect("thread backtrace all",
-            substrs = [stop_reason,
-                       'main.c:%d' % self.line])
+                    substrs=[stop_reason,
+                             'main.c:%d' % self.line])