diff options
| author | Dimitry Andric <dim@FreeBSD.org> | 2017-01-02 19:26:05 +0000 |
|---|---|---|
| committer | Dimitry Andric <dim@FreeBSD.org> | 2017-01-02 19:26:05 +0000 |
| commit | 14f1b3e8826ce43b978db93a62d1166055db5394 (patch) | |
| tree | 0a00ad8d3498783fe0193f3b656bca17c4c8697d /packages/Python/lldbsuite/test/expression_command | |
| parent | 4ee8c119c71a06dcad1e0fecc8c675e480e59337 (diff) | |
Notes
Diffstat (limited to 'packages/Python/lldbsuite/test/expression_command')
39 files changed, 1123 insertions, 579 deletions
diff --git a/packages/Python/lldbsuite/test/expression_command/anonymous-struct/TestCallUserAnonTypedef.py b/packages/Python/lldbsuite/test/expression_command/anonymous-struct/TestCallUserAnonTypedef.py index e1a53305a0d0..2d4504f7ba42 100644 --- a/packages/Python/lldbsuite/test/expression_command/anonymous-struct/TestCallUserAnonTypedef.py +++ b/packages/Python/lldbsuite/test/expression_command/anonymous-struct/TestCallUserAnonTypedef.py @@ -24,7 +24,10 @@ class TestExprLookupAnonStructTypedef(TestBase): self.line = line_number('main.cpp', '// lldb testsuite break') @expectedFailureAll(oslist=["windows"]) - @expectedFailureAll(oslist=['linux'], archs=['arm'], bugnumber="llvm.org/pr27868") + @expectedFailureAll( + oslist=['linux'], + archs=['arm'], + bugnumber="llvm.org/pr27868") def test(self): """Test typedeffed untagged struct arguments for function call expressions""" self.build() diff --git a/packages/Python/lldbsuite/test/expression_command/calculator_mode/TestCalculatorMode.py b/packages/Python/lldbsuite/test/expression_command/calculator_mode/TestCalculatorMode.py new file mode 100644 index 000000000000..46ea111bf031 --- /dev/null +++ b/packages/Python/lldbsuite/test/expression_command/calculator_mode/TestCalculatorMode.py @@ -0,0 +1,27 @@ +""" +Test calling an expression without a target. +""" + +from __future__ import print_function + + +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class TestCalculatorMode(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + + def test__calculator_mode(self): + """Test calling expressions in the dummy target.""" + self.expect("expression 11 + 22", "11 + 22 didn't get the expected result", substrs=["33"]) + # Now try it with a specific language: + self.expect("expression -l c -- 11 + 22", "11 + 22 didn't get the expected result", substrs=["33"]) + diff --git a/packages/Python/lldbsuite/test/expression_command/call-function/TestCallStdStringFunction.py b/packages/Python/lldbsuite/test/expression_command/call-function/TestCallStdStringFunction.py index 61702ee88033..6645692f93ee 100644 --- a/packages/Python/lldbsuite/test/expression_command/call-function/TestCallStdStringFunction.py +++ b/packages/Python/lldbsuite/test/expression_command/call-function/TestCallStdStringFunction.py @@ -5,12 +5,12 @@ Test calling std::String member functions. from __future__ import print_function - import lldb from lldbsuite.test.decorators import * from lldbsuite.test.lldbtest import * from lldbsuite.test import lldbutil + class ExprCommandCallFunctionTestCase(TestBase): mydir = TestBase.compute_mydir(__file__) @@ -19,26 +19,33 @@ class ExprCommandCallFunctionTestCase(TestBase): # Call super's setUp(). TestBase.setUp(self) # Find the line number to break for main.c. - self.line = line_number('main.cpp', - '// Please test these expressions while stopped at this line:') - - @expectedFailureAll(compiler="icc", bugnumber="llvm.org/pr14437, fails with ICC 13.1") - @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr17807 Fails on FreeBSD buildbot') + self.line = line_number( + 'main.cpp', + '// Please test these expressions while stopped at this line:') + + @expectedFailureAll( + compiler="icc", + bugnumber="llvm.org/pr14437, fails with ICC 13.1") + @expectedFailureAll( + oslist=['freebsd'], + bugnumber='llvm.org/pr17807 Fails on FreeBSD buildbot') @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765") def test_with(self): """Test calling std::String member function.""" self.build() self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) - # Some versions of GCC encode two locations for the 'return' statement in main.cpp - lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1, loc_exact=True) + # Some versions of GCC encode two locations for the 'return' statement + # in main.cpp + lldbutil.run_break_set_by_file_and_line( + self, "main.cpp", self.line, num_expected_locations=-1, loc_exact=True) self.runCmd("run", RUN_SUCCEEDED) self.expect("print str", - substrs = ['Hello world']) + substrs=['Hello world']) # Calling this function now succeeds, but we follow the typedef return type through to # const char *, and thus don't invoke the Summary formatter. self.expect("print str.c_str()", - substrs = ['Hello world']) + substrs=['Hello world']) diff --git a/packages/Python/lldbsuite/test/expression_command/call-function/TestCallStopAndContinue.py b/packages/Python/lldbsuite/test/expression_command/call-function/TestCallStopAndContinue.py index 4d18cfc980f2..a48a38aaf92c 100644 --- a/packages/Python/lldbsuite/test/expression_command/call-function/TestCallStopAndContinue.py +++ b/packages/Python/lldbsuite/test/expression_command/call-function/TestCallStopAndContinue.py @@ -5,12 +5,12 @@ Test calling a function, stopping in the call, continue and gather the result on from __future__ import print_function - import lldb from lldbsuite.test.decorators import * from lldbsuite.test.lldbtest import * from lldbsuite.test import lldbutil + class ExprCommandCallStopContinueTestCase(TestBase): mydir = TestBase.compute_mydir(__file__) @@ -19,29 +19,40 @@ class ExprCommandCallStopContinueTestCase(TestBase): # Call super's setUp(). TestBase.setUp(self) # Find the line number to break for main.c. - self.line = line_number('main.cpp', - '// Please test these expressions while stopped at this line:') - self.func_line = line_number ('main.cpp', - '{ 5, "five" }') + self.line = line_number( + 'main.cpp', + '// Please test these expressions while stopped at this line:') + self.func_line = line_number('main.cpp', '{5, "five"}') @expectedFlakeyDarwin("llvm.org/pr20274") - @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489: Name lookup not working correctly on Windows") + @expectedFailureAll( + oslist=["windows"], + bugnumber="llvm.org/pr24489: Name lookup not working correctly on Windows") def test(self): """Test gathering result from interrupted function call.""" self.build() self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) - # Some versions of GCC encode two locations for the 'return' statement in main.cpp - lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1, loc_exact=True) + # Some versions of GCC encode two locations for the 'return' statement + # in main.cpp + lldbutil.run_break_set_by_file_and_line( + self, "main.cpp", self.line, num_expected_locations=-1, loc_exact=True) self.runCmd("run", RUN_SUCCEEDED) - lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.func_line, num_expected_locations=-1, loc_exact=True) - + lldbutil.run_break_set_by_file_and_line( + self, + "main.cpp", + self.func_line, + num_expected_locations=-1, + loc_exact=True) + self.expect("expr -i false -- returnsFive()", error=True, - substrs = ['Execution was interrupted, reason: breakpoint']) + substrs=['Execution was interrupted, reason: breakpoint']) self.runCmd("continue", "Continue completed") - self.expect ("thread list", - substrs = ['stop reason = User Expression thread plan', - r'Completed expression: (Five) $0 = (number = 5, name = "five")']) + self.expect( + "thread list", + substrs=[ + 'stop reason = User Expression thread plan', + r'Completed expression: (Five) $0 = (number = 5, name = "five")']) diff --git a/packages/Python/lldbsuite/test/expression_command/call-function/TestCallUserDefinedFunction.py b/packages/Python/lldbsuite/test/expression_command/call-function/TestCallUserDefinedFunction.py index c0727a84fc02..fda81ae8c365 100644 --- a/packages/Python/lldbsuite/test/expression_command/call-function/TestCallUserDefinedFunction.py +++ b/packages/Python/lldbsuite/test/expression_command/call-function/TestCallUserDefinedFunction.py @@ -10,12 +10,12 @@ Note: from __future__ import print_function - import lldb from lldbsuite.test.decorators import * from lldbsuite.test.lldbtest import * from lldbsuite.test import lldbutil + class ExprCommandCallUserDefinedFunction(TestBase): mydir = TestBase.compute_mydir(__file__) @@ -24,30 +24,39 @@ class ExprCommandCallUserDefinedFunction(TestBase): # Call super's setUp(). TestBase.setUp(self) # Find the line number to break for main.c. - self.line = line_number('main.cpp', - '// Please test these expressions while stopped at this line:') + self.line = line_number( + 'main.cpp', + '// Please test these expressions while stopped at this line:') + @expectedFlakeyDsym("llvm.org/pr20274") - @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489: Name lookup not working correctly on Windows") + @expectedFailureAll( + oslist=["windows"], + bugnumber="llvm.org/pr24489: Name lookup not working correctly on Windows") def test(self): """Test return values of user defined function calls.""" self.build() # Set breakpoint in main and run exe self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) - lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1, loc_exact=True) + lldbutil.run_break_set_by_file_and_line( + self, "main.cpp", self.line, num_expected_locations=-1, loc_exact=True) self.runCmd("run", RUN_SUCCEEDED) # Test recursive function call. - self.expect("expr fib(5)", substrs = ['$0 = 5']) + self.expect("expr fib(5)", substrs=['$0 = 5']) # Test function with more than one paramter - self.expect("expr add(4,8)", substrs = ['$1 = 12']) + self.expect("expr add(4,8)", substrs=['$1 = 12']) # Test nesting function calls in function paramters - self.expect("expr add(add(5,2),add(3,4))", substrs = ['$2 = 14']) - self.expect("expr add(add(5,2),fib(5))", substrs = ['$3 = 12']) + self.expect("expr add(add(5,2),add(3,4))", substrs=['$2 = 14']) + self.expect("expr add(add(5,2),fib(5))", substrs=['$3 = 12']) # Test function with pointer paramter - self.expect("exp stringCompare((const char*) \"Hello world\")", substrs = ['$4 = true']) - self.expect("exp stringCompare((const char*) \"Hellworld\")", substrs = ['$5 = false']) + self.expect( + "exp stringCompare((const char*) \"Hello world\")", + substrs=['$4 = true']) + self.expect( + "exp stringCompare((const char*) \"Hellworld\")", + substrs=['$5 = false']) diff --git a/packages/Python/lldbsuite/test/expression_command/call-function/main.cpp b/packages/Python/lldbsuite/test/expression_command/call-function/main.cpp index 9b494c712bcc..cc5f52dbf567 100644 --- a/packages/Python/lldbsuite/test/expression_command/call-function/main.cpp +++ b/packages/Python/lldbsuite/test/expression_command/call-function/main.cpp @@ -11,7 +11,7 @@ struct Five Five returnsFive() { - Five my_five = { 5, "five" }; + Five my_five = {5, "five"}; return my_five; } diff --git a/packages/Python/lldbsuite/test/expression_command/call-restarts/TestCallThatRestarts.py b/packages/Python/lldbsuite/test/expression_command/call-restarts/TestCallThatRestarts.py index 6b754a76878b..bef4be1eb5f8 100644 --- a/packages/Python/lldbsuite/test/expression_command/call-restarts/TestCallThatRestarts.py +++ b/packages/Python/lldbsuite/test/expression_command/call-restarts/TestCallThatRestarts.py @@ -5,12 +5,12 @@ Test calling a function that hits a signal set to auto-restart, make sure the ca from __future__ import print_function - import lldb from lldbsuite.test.decorators import * from lldbsuite.test.lldbtest import * from lldbsuite.test import lldbutil + class ExprCommandThatRestartsTestCase(TestBase): mydir = TestBase.compute_mydir(__file__) @@ -20,24 +20,30 @@ class ExprCommandThatRestartsTestCase(TestBase): TestBase.setUp(self) self.main_source = "lotta-signals.c" - self.main_source_spec = lldb.SBFileSpec (self.main_source) + self.main_source_spec = lldb.SBFileSpec(self.main_source) - @skipIfFreeBSD # llvm.org/pr19246: intermittent failure - @skipIfDarwin # llvm.org/pr19246: intermittent failure - @skipIfWindows # Test relies on signals, unsupported on Windows + @skipIfFreeBSD # llvm.org/pr19246: intermittent failure + @skipIfDarwin # llvm.org/pr19246: intermittent failure + @skipIfWindows # Test relies on signals, unsupported on Windows def test(self): """Test calling function that hits a signal and restarts.""" self.build() self.call_function() - def check_after_call (self, num_sigchld): + def check_after_call(self, num_sigchld): after_call = self.sigchld_no.GetValueAsSigned(-1) - self.assertTrue (after_call - self.start_sigchld_no == num_sigchld, "Really got %d SIGCHLD signals through the call."%(num_sigchld)) + self.assertTrue( + after_call - + self.start_sigchld_no == num_sigchld, + "Really got %d SIGCHLD signals through the call." % + (num_sigchld)) self.start_sigchld_no = after_call # Check that we are back where we were before: frame = self.thread.GetFrameAtIndex(0) - self.assertTrue (self.orig_frame_pc == frame.GetPC(), "Restored the zeroth frame correctly") + self.assertTrue( + self.orig_frame_pc == frame.GetPC(), + "Restored the zeroth frame correctly") def call_function(self): exe_name = "a.out" @@ -46,95 +52,133 @@ class ExprCommandThatRestartsTestCase(TestBase): target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) empty = lldb.SBFileSpec() - breakpoint = target.BreakpointCreateBySourceRegex('Stop here in main.',self.main_source_spec) + breakpoint = target.BreakpointCreateBySourceRegex( + 'Stop here in main.', self.main_source_spec) self.assertTrue(breakpoint.GetNumLocations() > 0, VALID_BREAKPOINT) # Launch the process, and do not stop at the entry point. - process = target.LaunchSimple (None, None, self.get_process_working_directory()) + process = target.LaunchSimple( + None, None, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) # Frame #0 should be at our breakpoint. - threads = lldbutil.get_threads_stopped_at_breakpoint (process, breakpoint) - + threads = lldbutil.get_threads_stopped_at_breakpoint( + process, breakpoint) + self.assertTrue(len(threads) == 1) self.thread = threads[0] - + # Make sure the SIGCHLD behavior is pass/no-stop/no-notify: return_obj = lldb.SBCommandReturnObject() - self.dbg.GetCommandInterpreter().HandleCommand("process handle SIGCHLD -s 0 -p 1 -n 0", return_obj) - self.assertTrue (return_obj.Succeeded() == True, "Set SIGCHLD to pass, no-stop") + self.dbg.GetCommandInterpreter().HandleCommand( + "process handle SIGCHLD -s 0 -p 1 -n 0", return_obj) + self.assertTrue(return_obj.Succeeded(), "Set SIGCHLD to pass, no-stop") # The sigchld_no variable should be 0 at this point. self.sigchld_no = target.FindFirstGlobalVariable("sigchld_no") - self.assertTrue (self.sigchld_no.IsValid(), "Got a value for sigchld_no") + self.assertTrue( + self.sigchld_no.IsValid(), + "Got a value for sigchld_no") - self.start_sigchld_no = self.sigchld_no.GetValueAsSigned (-1) - self.assertTrue (self.start_sigchld_no != -1, "Got an actual value for sigchld_no") + self.start_sigchld_no = self.sigchld_no.GetValueAsSigned(-1) + self.assertTrue( + self.start_sigchld_no != -1, + "Got an actual value for sigchld_no") options = lldb.SBExpressionOptions() - # processing 30 signals takes a while, increase the expression timeout a bit - options.SetTimeoutInMicroSeconds(3000000) # 3s + # processing 30 signals takes a while, increase the expression timeout + # a bit + options.SetTimeoutInMicroSeconds(3000000) # 3s options.SetUnwindOnError(True) frame = self.thread.GetFrameAtIndex(0) - # Store away the PC to check that the functions unwind to the right place after calls + # Store away the PC to check that the functions unwind to the right + # place after calls self.orig_frame_pc = frame.GetPC() num_sigchld = 30 - value = frame.EvaluateExpression ("call_me (%d)"%(num_sigchld), options) - self.assertTrue (value.IsValid()) - self.assertTrue (value.GetError().Success() == True) - self.assertTrue (value.GetValueAsSigned(-1) == num_sigchld) + value = frame.EvaluateExpression( + "call_me (%d)" % + (num_sigchld), options) + self.assertTrue(value.IsValid()) + self.assertTrue(value.GetError().Success()) + self.assertTrue(value.GetValueAsSigned(-1) == num_sigchld) self.check_after_call(num_sigchld) # Okay, now try with a breakpoint in the called code in the case where # we are ignoring breakpoint hits. - handler_bkpt = target.BreakpointCreateBySourceRegex("Got sigchld %d.", self.main_source_spec) - self.assertTrue (handler_bkpt.GetNumLocations() > 0) + handler_bkpt = target.BreakpointCreateBySourceRegex( + "Got sigchld %d.", self.main_source_spec) + self.assertTrue(handler_bkpt.GetNumLocations() > 0) options.SetIgnoreBreakpoints(True) options.SetUnwindOnError(True) - value = frame.EvaluateExpression("call_me (%d)"%(num_sigchld), options) + value = frame.EvaluateExpression( + "call_me (%d)" % + (num_sigchld), options) - self.assertTrue (value.IsValid() and value.GetError().Success() == True) - self.assertTrue (value.GetValueAsSigned(-1) == num_sigchld) + self.assertTrue(value.IsValid() and value.GetError().Success()) + self.assertTrue(value.GetValueAsSigned(-1) == num_sigchld) self.check_after_call(num_sigchld) - # Now set the signal to print but not stop and make sure that calling still works: - self.dbg.GetCommandInterpreter().HandleCommand("process handle SIGCHLD -s 0 -p 1 -n 1", return_obj) - self.assertTrue (return_obj.Succeeded() == True, "Set SIGCHLD to pass, no-stop, notify") + # Now set the signal to print but not stop and make sure that calling + # still works: + self.dbg.GetCommandInterpreter().HandleCommand( + "process handle SIGCHLD -s 0 -p 1 -n 1", return_obj) + self.assertTrue( + return_obj.Succeeded(), + "Set SIGCHLD to pass, no-stop, notify") - value = frame.EvaluateExpression("call_me (%d)"%(num_sigchld), options) + value = frame.EvaluateExpression( + "call_me (%d)" % + (num_sigchld), options) - self.assertTrue (value.IsValid() and value.GetError().Success() == True) - self.assertTrue (value.GetValueAsSigned(-1) == num_sigchld) + self.assertTrue(value.IsValid() and value.GetError().Success()) + self.assertTrue(value.GetValueAsSigned(-1) == num_sigchld) self.check_after_call(num_sigchld) - # Now set this unwind on error to false, and make sure that we still complete the call: + # Now set this unwind on error to false, and make sure that we still + # complete the call: options.SetUnwindOnError(False) - value = frame.EvaluateExpression("call_me (%d)"%(num_sigchld), options) + value = frame.EvaluateExpression( + "call_me (%d)" % + (num_sigchld), options) - self.assertTrue (value.IsValid() and value.GetError().Success() == True) - self.assertTrue (value.GetValueAsSigned(-1) == num_sigchld) + self.assertTrue(value.IsValid() and value.GetError().Success()) + self.assertTrue(value.GetValueAsSigned(-1) == num_sigchld) self.check_after_call(num_sigchld) # Okay, now set UnwindOnError to true, and then make the signal behavior to stop # and see that now we do stop at the signal point: - - self.dbg.GetCommandInterpreter().HandleCommand("process handle SIGCHLD -s 1 -p 1 -n 1", return_obj) - self.assertTrue (return_obj.Succeeded() == True, "Set SIGCHLD to pass, stop, notify") - - value = frame.EvaluateExpression("call_me (%d)"%(num_sigchld), options) - self.assertTrue (value.IsValid() and value.GetError().Success() == False) - - # Set signal handling back to no-stop, and continue and we should end up back in out starting frame: - self.dbg.GetCommandInterpreter().HandleCommand("process handle SIGCHLD -s 0 -p 1 -n 1", return_obj) - self.assertTrue (return_obj.Succeeded() == True, "Set SIGCHLD to pass, no-stop, notify") + + self.dbg.GetCommandInterpreter().HandleCommand( + "process handle SIGCHLD -s 1 -p 1 -n 1", return_obj) + self.assertTrue( + return_obj.Succeeded(), + "Set SIGCHLD to pass, stop, notify") + + value = frame.EvaluateExpression( + "call_me (%d)" % + (num_sigchld), options) + self.assertTrue( + value.IsValid() and value.GetError().Success() == False) + + # Set signal handling back to no-stop, and continue and we should end + # up back in out starting frame: + self.dbg.GetCommandInterpreter().HandleCommand( + "process handle SIGCHLD -s 0 -p 1 -n 1", return_obj) + self.assertTrue( + return_obj.Succeeded(), + "Set SIGCHLD to pass, no-stop, notify") error = process.Continue() - self.assertTrue (error.Success(), "Continuing after stopping for signal succeeds.") - + self.assertTrue( + error.Success(), + "Continuing after stopping for signal succeeds.") + frame = self.thread.GetFrameAtIndex(0) - self.assertTrue (frame.GetPC() == self.orig_frame_pc, "Continuing returned to the place we started.") + self.assertTrue( + frame.GetPC() == self.orig_frame_pc, + "Continuing returned to the place we started.") diff --git a/packages/Python/lldbsuite/test/expression_command/call-throws/TestCallThatThrows.py b/packages/Python/lldbsuite/test/expression_command/call-throws/TestCallThatThrows.py index a6eb1bddc005..e5162609dfa6 100644 --- a/packages/Python/lldbsuite/test/expression_command/call-throws/TestCallThatThrows.py +++ b/packages/Python/lldbsuite/test/expression_command/call-throws/TestCallThatThrows.py @@ -5,12 +5,12 @@ Test calling a function that throws an ObjC exception, make sure that it doesn't from __future__ import print_function - import lldb from lldbsuite.test.decorators import * from lldbsuite.test.lldbtest import * from lldbsuite.test import lldbutil + class ExprCommandWithThrowTestCase(TestBase): mydir = TestBase.compute_mydir(__file__) @@ -20,7 +20,7 @@ class ExprCommandWithThrowTestCase(TestBase): TestBase.setUp(self) self.main_source = "call-throws.m" - self.main_source_spec = lldb.SBFileSpec (self.main_source) + self.main_source_spec = lldb.SBFileSpec(self.main_source) @skipUnlessDarwin def test(self): @@ -28,12 +28,13 @@ class ExprCommandWithThrowTestCase(TestBase): self.build() self.call_function() - def check_after_call (self): + def check_after_call(self): # Check that we are back where we were before: frame = self.thread.GetFrameAtIndex(0) - self.assertTrue (self.orig_frame_pc == frame.GetPC(), "Restored the zeroth frame correctly") + self.assertTrue( + self.orig_frame_pc == frame.GetPC(), + "Restored the zeroth frame correctly") - def call_function(self): """Test calling function that throws.""" exe_name = "a.out" @@ -42,72 +43,82 @@ class ExprCommandWithThrowTestCase(TestBase): target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) - breakpoint = target.BreakpointCreateBySourceRegex('I am about to throw.',self.main_source_spec) + breakpoint = target.BreakpointCreateBySourceRegex( + 'I am about to throw.', self.main_source_spec) self.assertTrue(breakpoint.GetNumLocations() > 0, VALID_BREAKPOINT) # Launch the process, and do not stop at the entry point. - process = target.LaunchSimple (None, None, self.get_process_working_directory()) + process = target.LaunchSimple( + None, None, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) # Frame #0 should be at our breakpoint. - threads = lldbutil.get_threads_stopped_at_breakpoint (process, breakpoint) - + threads = lldbutil.get_threads_stopped_at_breakpoint( + process, breakpoint) + self.assertTrue(len(threads) == 1) self.thread = threads[0] - + options = lldb.SBExpressionOptions() options.SetUnwindOnError(True) frame = self.thread.GetFrameAtIndex(0) - # Store away the PC to check that the functions unwind to the right place after calls + # Store away the PC to check that the functions unwind to the right + # place after calls self.orig_frame_pc = frame.GetPC() - value = frame.EvaluateExpression ("[my_class callMeIThrow]", options) - self.assertTrue (value.IsValid()) - self.assertTrue (value.GetError().Success() == False) + value = frame.EvaluateExpression("[my_class callMeIThrow]", options) + self.assertTrue(value.IsValid()) + self.assertTrue(value.GetError().Success() == False) self.check_after_call() # Okay, now try with a breakpoint in the called code in the case where # we are ignoring breakpoint hits. - handler_bkpt = target.BreakpointCreateBySourceRegex("I felt like it", self.main_source_spec) - self.assertTrue (handler_bkpt.GetNumLocations() > 0) + handler_bkpt = target.BreakpointCreateBySourceRegex( + "I felt like it", self.main_source_spec) + self.assertTrue(handler_bkpt.GetNumLocations() > 0) options.SetIgnoreBreakpoints(True) options.SetUnwindOnError(True) - value = frame.EvaluateExpression ("[my_class callMeIThrow]", options) + value = frame.EvaluateExpression("[my_class callMeIThrow]", options) - self.assertTrue (value.IsValid() and value.GetError().Success() == False) + self.assertTrue( + value.IsValid() and value.GetError().Success() == False) self.check_after_call() - # Now set the ObjC language breakpoint and make sure that doesn't interfere with the call: - exception_bkpt = target.BreakpointCreateForException (lldb.eLanguageTypeObjC, False, True) + # Now set the ObjC language breakpoint and make sure that doesn't + # interfere with the call: + exception_bkpt = target.BreakpointCreateForException( + lldb.eLanguageTypeObjC, False, True) self.assertTrue(exception_bkpt.GetNumLocations() > 0) options.SetIgnoreBreakpoints(True) options.SetUnwindOnError(True) - value = frame.EvaluateExpression ("[my_class callMeIThrow]", options) + value = frame.EvaluateExpression("[my_class callMeIThrow]", options) - self.assertTrue (value.IsValid() and value.GetError().Success() == False) + self.assertTrue( + value.IsValid() and value.GetError().Success() == False) self.check_after_call() - # Now turn off exception trapping, and call a function that catches the exceptions, - # and make sure the function actually completes, and we get the right value: + # and make sure the function actually completes, and we get the right + # value: options.SetTrapExceptions(False) - value = frame.EvaluateExpression ("[my_class iCatchMyself]", options) - self.assertTrue (value.IsValid()) - self.assertTrue (value.GetError().Success() == True) - self.assertTrue (value.GetValueAsUnsigned() == 57) + value = frame.EvaluateExpression("[my_class iCatchMyself]", options) + self.assertTrue(value.IsValid()) + self.assertTrue(value.GetError().Success()) + self.assertTrue(value.GetValueAsUnsigned() == 57) self.check_after_call() options.SetTrapExceptions(True) - # Now set this unwind on error to false, and make sure that we stop where the exception was thrown + # Now set this unwind on error to false, and make sure that we stop + # where the exception was thrown options.SetUnwindOnError(False) - value = frame.EvaluateExpression ("[my_class callMeIThrow]", options) - + value = frame.EvaluateExpression("[my_class callMeIThrow]", options) - self.assertTrue (value.IsValid() and value.GetError().Success() == False) + self.assertTrue( + value.IsValid() and value.GetError().Success() == False) self.check_after_call() diff --git a/packages/Python/lldbsuite/test/expression_command/char/TestExprsChar.py b/packages/Python/lldbsuite/test/expression_command/char/TestExprsChar.py index 66fa69cdfff2..a771e7004c94 100644 --- a/packages/Python/lldbsuite/test/expression_command/char/TestExprsChar.py +++ b/packages/Python/lldbsuite/test/expression_command/char/TestExprsChar.py @@ -1,12 +1,12 @@ from __future__ import print_function - import lldb from lldbsuite.test.decorators import * from lldbsuite.test.lldbtest import * from lldbsuite.test import lldbutil + class ExprCharTestCase(TestBase): mydir = TestBase.compute_mydir(__file__) @@ -16,24 +16,27 @@ class ExprCharTestCase(TestBase): TestBase.setUp(self) self.main_source = "main.cpp" - self.main_source_spec = lldb.SBFileSpec (self.main_source) + self.main_source_spec = lldb.SBFileSpec(self.main_source) self.exe = os.path.join(os.getcwd(), "a.out") def do_test(self, dictionary=None): """These basic expression commands should work as expected.""" - self.build(dictionary = dictionary) + self.build(dictionary=dictionary) target = self.dbg.CreateTarget(self.exe) self.assertTrue(target) - breakpoint = target.BreakpointCreateBySourceRegex('// Break here', self.main_source_spec) + breakpoint = target.BreakpointCreateBySourceRegex( + '// Break here', self.main_source_spec) self.assertTrue(breakpoint) # Launch the process, and do not stop at the entry point. - process = target.LaunchSimple(None, None, self.get_process_working_directory()) + process = target.LaunchSimple( + None, None, self.get_process_working_directory()) self.assertTrue(process) - threads = lldbutil.get_threads_stopped_at_breakpoint(process, breakpoint) + threads = lldbutil.get_threads_stopped_at_breakpoint( + process, breakpoint) self.assertEqual(len(threads), 1) frame = threads[0].GetFrameAtIndex(0) @@ -57,13 +60,22 @@ class ExprCharTestCase(TestBase): def test_default_char(self): self.do_test() - @expectedFailureAll(archs=["arm", "aarch64", "s390x"], bugnumber="llvm.org/pr23069") + @expectedFailureAll( + archs=[ + "arm", + "aarch64", + "s390x"], + bugnumber="llvm.org/pr23069") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765") def test_signed_char(self): self.do_test(dictionary={'CFLAGS_EXTRAS': '-fsigned-char'}) - @expectedFailureAll(archs=["i[3-6]86", "x86_64"], bugnumber="llvm.org/pr23069") + @expectedFailureAll( + archs=[ + "i[3-6]86", + "x86_64"], + bugnumber="llvm.org/pr23069, <rdar://problem/28721938>") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765") - @expectedFailureAll(triple = 'mips*', bugnumber="llvm.org/pr23069") + @expectedFailureAll(triple='mips*', bugnumber="llvm.org/pr23069") def test_unsigned_char(self): self.do_test(dictionary={'CFLAGS_EXTRAS': '-funsigned-char'}) diff --git a/packages/Python/lldbsuite/test/expression_command/expr-in-syscall/TestExpressionInSyscall.py b/packages/Python/lldbsuite/test/expression_command/expr-in-syscall/TestExpressionInSyscall.py index a715ee31e5fa..dcfb648ada50 100644 --- a/packages/Python/lldbsuite/test/expression_command/expr-in-syscall/TestExpressionInSyscall.py +++ b/packages/Python/lldbsuite/test/expression_command/expr-in-syscall/TestExpressionInSyscall.py @@ -3,7 +3,6 @@ from __future__ import print_function - import os import lldb from lldbsuite.test.decorators import * @@ -15,7 +14,9 @@ class ExprSyscallTestCase(TestBase): mydir = TestBase.compute_mydir(__file__) - @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765, getpid() does not exist on Windows") + @expectedFailureAll( + oslist=["windows"], + bugnumber="llvm.org/pr21765, getpid() does not exist on Windows") def test_setpgid(self): self.build() self.expr_syscall() @@ -32,16 +33,16 @@ class ExprSyscallTestCase(TestBase): # launch the inferior and don't wait for it to stop self.dbg.SetAsync(True) error = lldb.SBError() - process = target.Launch (listener, - None, # argv - None, # envp - None, # stdin_path - None, # stdout_path - None, # stderr_path - None, # working directory - 0, # launch flags - False, # Stop at entry - error) # error + process = target.Launch(listener, + None, # argv + None, # envp + None, # stdin_path + None, # stdout_path + None, # stderr_path + None, # working directory + 0, # launch flags + False, # Stop at entry + error) # error self.assertTrue(process and process.IsValid(), PROCESS_IS_VALID) @@ -54,7 +55,10 @@ class ExprSyscallTestCase(TestBase): pass # now the process should be running (blocked in the syscall) - self.assertEqual(process.GetState(), lldb.eStateRunning, "Process is running") + self.assertEqual( + process.GetState(), + lldb.eStateRunning, + "Process is running") # send the process a signal process.SendAsyncInterrupt() @@ -62,13 +66,18 @@ class ExprSyscallTestCase(TestBase): pass # as a result the process should stop - # in all likelihood we have stopped in the middle of the sleep() syscall - self.assertEqual(process.GetState(), lldb.eStateStopped, PROCESS_STOPPED) + # in all likelihood we have stopped in the middle of the sleep() + # syscall + self.assertEqual( + process.GetState(), + lldb.eStateStopped, + PROCESS_STOPPED) thread = process.GetSelectedThread() # try evaluating a couple of expressions in this state - self.expect("expr release_flag = 1", substrs = [" = 1"]) - self.expect("print (int)getpid()", substrs = [str(process.GetProcessID())]) + self.expect("expr release_flag = 1", substrs=[" = 1"]) + self.expect("print (int)getpid()", + substrs=[str(process.GetProcessID())]) # and run the process to completion process.Continue() diff --git a/packages/Python/lldbsuite/test/expression_command/fixits/TestFixIts.py b/packages/Python/lldbsuite/test/expression_command/fixits/TestFixIts.py index 7e11f2b201f2..418c5325ad08 100644 --- a/packages/Python/lldbsuite/test/expression_command/fixits/TestFixIts.py +++ b/packages/Python/lldbsuite/test/expression_command/fixits/TestFixIts.py @@ -5,12 +5,12 @@ Test calling an expression with errors that a FixIt can fix. from __future__ import print_function - import lldb from lldbsuite.test.decorators import * from lldbsuite.test.lldbtest import * from lldbsuite.test import lldbutil + class ExprCommandWithFixits(TestBase): mydir = TestBase.compute_mydir(__file__) @@ -20,14 +20,21 @@ class ExprCommandWithFixits(TestBase): TestBase.setUp(self) self.main_source = "main.cpp" - self.main_source_spec = lldb.SBFileSpec (self.main_source) + self.main_source_spec = lldb.SBFileSpec(self.main_source) @skipUnlessDarwin - def test(self): - """Test calling a function that throws and ObjC exception.""" + def test_with_target(self): + """Test calling expressions with errors that can be fixed by the FixIts.""" self.build() self.try_expressions() + def test_with_dummy_target(self): + """Test calling expressions in the dummy target with errors that can be fixed by the FixIts.""" + ret_val = lldb.SBCommandReturnObject() + result = self.dbg.GetCommandInterpreter().HandleCommand("expression ((1 << 16) - 1))", ret_val) + self.assertEqual(result, lldb.eReturnStatusSuccessFinishResult, "The expression was successful.") + self.assertTrue("Fix-it applied" in ret_val.GetError(), "Found the applied FixIt.") + def try_expressions(self): """Test calling expressions with errors that can be fixed by the FixIts.""" exe_name = "a.out" @@ -36,20 +43,23 @@ class ExprCommandWithFixits(TestBase): target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) - breakpoint = target.BreakpointCreateBySourceRegex('Stop here to evaluate expressions',self.main_source_spec) + breakpoint = target.BreakpointCreateBySourceRegex( + 'Stop here to evaluate expressions', self.main_source_spec) self.assertTrue(breakpoint.GetNumLocations() > 0, VALID_BREAKPOINT) # Launch the process, and do not stop at the entry point. - process = target.LaunchSimple (None, None, self.get_process_working_directory()) + process = target.LaunchSimple( + None, None, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) # Frame #0 should be at our breakpoint. - threads = lldbutil.get_threads_stopped_at_breakpoint (process, breakpoint) - + threads = lldbutil.get_threads_stopped_at_breakpoint( + process, breakpoint) + self.assertTrue(len(threads) == 1) self.thread = threads[0] - + options = lldb.SBExpressionOptions() options.SetAutoApplyFixIts(True) @@ -60,7 +70,7 @@ class ExprCommandWithFixits(TestBase): self.assertTrue(value.IsValid()) self.assertTrue(value.GetError().Success()) self.assertTrue(value.GetValueAsUnsigned() == 10) - + # Try with two errors: two_error_expression = "my_pointer.second->a" value = frame.EvaluateExpression(two_error_expression, options) @@ -74,8 +84,9 @@ class ExprCommandWithFixits(TestBase): self.assertTrue(value.IsValid()) self.assertTrue(value.GetError().Fail()) error_string = value.GetError().GetCString() - self.assertTrue(error_string.find("fixed expression suggested:") != -1, "Fix was suggested") - self.assertTrue(error_string.find("my_pointer->second.a") != -1, "Fix was right") - - - + self.assertTrue( + error_string.find("fixed expression suggested:") != -1, + "Fix was suggested") + self.assertTrue( + error_string.find("my_pointer->second.a") != -1, + "Fix was right") diff --git a/packages/Python/lldbsuite/test/expression_command/formatters/TestFormatters.py b/packages/Python/lldbsuite/test/expression_command/formatters/TestFormatters.py index 4a99dc479019..c4126a329686 100644 --- a/packages/Python/lldbsuite/test/expression_command/formatters/TestFormatters.py +++ b/packages/Python/lldbsuite/test/expression_command/formatters/TestFormatters.py @@ -5,12 +5,12 @@ Test using LLDB data formatters with frozen objects coming from the expression p from __future__ import print_function - import lldb from lldbsuite.test.decorators import * from lldbsuite.test.lldbtest import * from lldbsuite.test import lldbutil + class ExprFormattersTestCase(TestBase): mydir = TestBase.compute_mydir(__file__) @@ -22,11 +22,13 @@ class ExprFormattersTestCase(TestBase): self.line = line_number('main.cpp', '// Stop here') - @skipIfFreeBSD # llvm.org/pr24691 skipping to avoid crashing the test runner - @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr19011 Newer Clang omits C1 complete object constructor') + @skipIfFreeBSD # llvm.org/pr24691 skipping to avoid crashing the test runner + @expectedFailureAll( + oslist=['freebsd'], + bugnumber='llvm.org/pr19011 Newer Clang omits C1 complete object constructor') @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765") - @skipIfTargetAndroid() # skipping to avoid crashing the test runner - @expectedFailureAndroid('llvm.org/pr24691') # we hit an assertion in clang + @skipIfTargetAndroid() # skipping to avoid crashing the test runner + @expectedFailureAndroid('llvm.org/pr24691') # we hit an assertion in clang def test(self): """Test expr + formatters for good interoperability.""" self.build() @@ -36,64 +38,117 @@ class ExprFormattersTestCase(TestBase): def cleanup(): self.runCmd('type summary clear', check=False) self.runCmd('type synthetic clear', check=False) - + # Execute the cleanup function during test case tear down. self.addTearDownHook(cleanup) """Test expr + formatters for good interoperability.""" self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) - lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, loc_exact=True) + lldbutil.run_break_set_by_file_and_line( + self, "main.cpp", self.line, loc_exact=True) self.runCmd("run", RUN_SUCCEEDED) self.runCmd("command script import formatters.py") self.runCmd("command script import foosynth.py") - + if self.TraceOn(): self.runCmd("frame variable foo1 --show-types") self.runCmd("frame variable foo1.b --show-types") self.runCmd("frame variable foo1.b.b_ref --show-types") - self.expect("expression --show-types -- *(new foo(47))", - substrs = ['(int) a = 47', '(bar) b = {', '(int) i = 94', '(baz) b = {', '(int) k = 99']) + self.expect( + "expression --show-types -- *(new foo(47))", + substrs=[ + '(int) a = 47', + '(bar) b = {', + '(int) i = 94', + '(baz) b = {', + '(int) k = 99']) self.runCmd("type summary add -F formatters.foo_SummaryProvider foo") self.expect("expression new int(12)", - substrs = ['(int *) $', ' = 0x']) + substrs=['(int *) $', ' = 0x']) - self.runCmd("type summary add -s \"${var%pointer} -> ${*var%decimal}\" \"int *\"") + self.runCmd( + "type summary add -s \"${var%pointer} -> ${*var%decimal}\" \"int *\"") self.expect("expression new int(12)", - substrs = ['(int *) $', '= 0x', ' -> 12']) + substrs=['(int *) $', '= 0x', ' -> 12']) self.expect("expression foo1.a_ptr", - substrs = ['(int *) $', '= 0x', ' -> 13']) - - self.expect("expression foo1", - substrs = ['(foo) $', ' a = 12', 'a_ptr = ', ' -> 13','i = 24','i_ptr = ', ' -> 25']) - - self.expect("expression --ptr-depth=1 -- new foo(47)", - substrs = ['(foo *) $', 'a = 47','a_ptr = ', ' -> 48','i = 94','i_ptr = ', ' -> 95']) - - self.expect("expression foo2", - substrs = ['(foo) $', 'a = 121','a_ptr = ', ' -> 122','i = 242','i_ptr = ', ' -> 243']) + substrs=['(int *) $', '= 0x', ' -> 13']) + + self.expect( + "expression foo1", + substrs=[ + '(foo) $', + ' a = 12', + 'a_ptr = ', + ' -> 13', + 'i = 24', + 'i_ptr = ', + ' -> 25']) + + self.expect( + "expression --ptr-depth=1 -- new foo(47)", + substrs=[ + '(foo *) $', + 'a = 47', + 'a_ptr = ', + ' -> 48', + 'i = 94', + 'i_ptr = ', + ' -> 95']) + + self.expect( + "expression foo2", + substrs=[ + '(foo) $', + 'a = 121', + 'a_ptr = ', + ' -> 122', + 'i = 242', + 'i_ptr = ', + ' -> 243']) object_name = self.res.GetOutput() object_name = object_name[7:] object_name = object_name[0:object_name.find(' =')] - self.expect("frame variable foo2", - substrs = ['(foo)', 'foo2', 'a = 121','a_ptr = ', ' -> 122','i = 242','i_ptr = ', ' -> 243']) - - self.expect("expression $" + object_name, - substrs = ['(foo) $', 'a = 121','a_ptr = ', ' -> 122','i = 242','i_ptr = ', ' -> 243', 'h = 245','k = 247']) + self.expect( + "frame variable foo2", + substrs=[ + '(foo)', + 'foo2', + 'a = 121', + 'a_ptr = ', + ' -> 122', + 'i = 242', + 'i_ptr = ', + ' -> 243']) + + self.expect( + "expression $" + + object_name, + substrs=[ + '(foo) $', + 'a = 121', + 'a_ptr = ', + ' -> 122', + 'i = 242', + 'i_ptr = ', + ' -> 243', + 'h = 245', + 'k = 247']) self.runCmd("type summary delete foo") - self.runCmd("type synthetic add --python-class foosynth.FooSyntheticProvider foo") + self.runCmd( + "type synthetic add --python-class foosynth.FooSyntheticProvider foo") self.expect("expression --show-types -- $" + object_name, - substrs = ['(foo) $', ' = {', '(int) *i_ptr = 243']) + substrs=['(foo) $', ' = {', '(int) *i_ptr = 243']) self.runCmd("n") self.runCmd("n") @@ -101,31 +156,61 @@ class ExprFormattersTestCase(TestBase): self.runCmd("type synthetic delete foo") self.runCmd("type summary add -F formatters.foo_SummaryProvider foo") - self.expect("expression foo2", - substrs = ['(foo) $', 'a = 7777','a_ptr = ', ' -> 122','i = 242','i_ptr = ', ' -> 8888']) + self.expect( + "expression foo2", + substrs=[ + '(foo) $', + 'a = 7777', + 'a_ptr = ', + ' -> 122', + 'i = 242', + 'i_ptr = ', + ' -> 8888']) self.expect("expression $" + object_name + '.a', - substrs = ['7777']) + substrs=['7777']) self.expect("expression *$" + object_name + '.b.i_ptr', - substrs = ['8888']) - - self.expect("expression $" + object_name, - substrs = ['(foo) $', 'a = 121', 'a_ptr = ', ' -> 122', 'i = 242', 'i_ptr = ', ' -> 8888', 'h = 245','k = 247']) + substrs=['8888']) + + self.expect( + "expression $" + + object_name, + substrs=[ + '(foo) $', + 'a = 121', + 'a_ptr = ', + ' -> 122', + 'i = 242', + 'i_ptr = ', + ' -> 8888', + 'h = 245', + 'k = 247']) self.runCmd("type summary delete foo") - self.runCmd("type synthetic add --python-class foosynth.FooSyntheticProvider foo") + self.runCmd( + "type synthetic add --python-class foosynth.FooSyntheticProvider foo") self.expect("expression --show-types -- $" + object_name, - substrs = ['(foo) $', ' = {', '(int) *i_ptr = 8888']) + substrs=['(foo) $', ' = {', '(int) *i_ptr = 8888']) self.runCmd("n") self.runCmd("type synthetic delete foo") self.runCmd("type summary add -F formatters.foo_SummaryProvider foo") - self.expect("expression $" + object_name, - substrs = ['(foo) $', 'a = 121','a_ptr = ', ' -> 122','i = 242', 'i_ptr = ', ' -> 8888','k = 247']) + self.expect( + "expression $" + + object_name, + substrs=[ + '(foo) $', + 'a = 121', + 'a_ptr = ', + ' -> 122', + 'i = 242', + 'i_ptr = ', + ' -> 8888', + 'k = 247']) process = self.dbg.GetSelectedTarget().GetProcess() thread = process.GetThreadAtIndex(0) @@ -136,32 +221,78 @@ class ExprFormattersTestCase(TestBase): a_data = frozen.GetPointeeData() error = lldb.SBError() - self.assertTrue(a_data.GetUnsignedInt32(error, 0) == 122, '*a_ptr = 122') + self.assertTrue( + a_data.GetUnsignedInt32( + error, + 0) == 122, + '*a_ptr = 122') - self.runCmd("n");self.runCmd("n");self.runCmd("n"); + self.runCmd("n") + self.runCmd("n") + self.runCmd("n") self.expect("frame variable numbers", - substrs = ['1','2','3','4','5']) + substrs=['1', '2', '3', '4', '5']) self.expect("expression numbers", - substrs = ['1','2','3','4','5']) + substrs=['1', '2', '3', '4', '5']) frozen = frame.EvaluateExpression("&numbers") a_data = frozen.GetPointeeData(0, 1) - self.assertTrue(a_data.GetUnsignedInt32(error, 0) == 1, 'numbers[0] == 1') - self.assertTrue(a_data.GetUnsignedInt32(error, 4) == 2, 'numbers[1] == 2') - self.assertTrue(a_data.GetUnsignedInt32(error, 8) == 3, 'numbers[2] == 3') - self.assertTrue(a_data.GetUnsignedInt32(error, 12) == 4, 'numbers[3] == 4') - self.assertTrue(a_data.GetUnsignedInt32(error, 16) == 5, 'numbers[4] == 5') + self.assertTrue( + a_data.GetUnsignedInt32( + error, + 0) == 1, + 'numbers[0] == 1') + self.assertTrue( + a_data.GetUnsignedInt32( + error, + 4) == 2, + 'numbers[1] == 2') + self.assertTrue( + a_data.GetUnsignedInt32( + error, + 8) == 3, + 'numbers[2] == 3') + self.assertTrue( + a_data.GetUnsignedInt32( + error, + 12) == 4, + 'numbers[3] == 4') + self.assertTrue( + a_data.GetUnsignedInt32( + error, + 16) == 5, + 'numbers[4] == 5') frozen = frame.EvaluateExpression("numbers") a_data = frozen.GetData() - self.assertTrue(a_data.GetUnsignedInt32(error, 0) == 1, 'numbers[0] == 1') - self.assertTrue(a_data.GetUnsignedInt32(error, 4) == 2, 'numbers[1] == 2') - self.assertTrue(a_data.GetUnsignedInt32(error, 8) == 3, 'numbers[2] == 3') - self.assertTrue(a_data.GetUnsignedInt32(error, 12) == 4, 'numbers[3] == 4') - self.assertTrue(a_data.GetUnsignedInt32(error, 16) == 5, 'numbers[4] == 5') + self.assertTrue( + a_data.GetUnsignedInt32( + error, + 0) == 1, + 'numbers[0] == 1') + self.assertTrue( + a_data.GetUnsignedInt32( + error, + 4) == 2, + 'numbers[1] == 2') + self.assertTrue( + a_data.GetUnsignedInt32( + error, + 8) == 3, + 'numbers[2] == 3') + self.assertTrue( + a_data.GetUnsignedInt32( + error, + 12) == 4, + 'numbers[3] == 4') + self.assertTrue( + a_data.GetUnsignedInt32( + error, + 16) == 5, + 'numbers[4] == 5') diff --git a/packages/Python/lldbsuite/test/expression_command/formatters/foosynth.py b/packages/Python/lldbsuite/test/expression_command/formatters/foosynth.py index 91c4d4a84c62..7b1284d2a769 100644 --- a/packages/Python/lldbsuite/test/expression_command/formatters/foosynth.py +++ b/packages/Python/lldbsuite/test/expression_command/formatters/foosynth.py @@ -1,29 +1,33 @@ import lldb + class FooSyntheticProvider: - def __init__(self,valobj,dict): - self.valobj = valobj; - self.update(); - - def update(self): - self.adjust_for_architecture() - - def num_children(self): - return 1; - - def get_child_at_index(self,index): - if index != 0: - return None; - return self.i_ptr.Dereference(); - - def get_child_index(self,name): - if name == "*i_ptr": - return 0; - return None; - - def adjust_for_architecture(self): - self.lp64 = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8) - self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle) - self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize() - self.bar = self.valobj.GetChildMemberWithName('b'); - self.i_ptr = self.bar.GetChildMemberWithName('i_ptr');
\ No newline at end of file + + def __init__(self, valobj, dict): + self.valobj = valobj + self.update() + + def update(self): + self.adjust_for_architecture() + + def num_children(self): + return 1 + + def get_child_at_index(self, index): + if index != 0: + return None + return self.i_ptr.Dereference() + + def get_child_index(self, name): + if name == "*i_ptr": + return 0 + return None + + def adjust_for_architecture(self): + self.lp64 = ( + self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8) + self.is_little = (self.valobj.GetTarget().GetProcess( + ).GetByteOrder() == lldb.eByteOrderLittle) + self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize() + self.bar = self.valobj.GetChildMemberWithName('b') + self.i_ptr = self.bar.GetChildMemberWithName('i_ptr') diff --git a/packages/Python/lldbsuite/test/expression_command/formatters/formatters.py b/packages/Python/lldbsuite/test/expression_command/formatters/formatters.py index ce922a8f911d..dae84988af9e 100644 --- a/packages/Python/lldbsuite/test/expression_command/formatters/formatters.py +++ b/packages/Python/lldbsuite/test/expression_command/formatters/formatters.py @@ -1,17 +1,17 @@ -def foo_SummaryProvider (valobj,dict): - a = valobj.GetChildMemberWithName('a'); - a_ptr = valobj.GetChildMemberWithName('a_ptr'); - bar = valobj.GetChildMemberWithName('b'); - i = bar.GetChildMemberWithName('i'); - i_ptr = bar.GetChildMemberWithName('i_ptr'); - b_ref = bar.GetChildMemberWithName('b_ref'); - b_ref_ptr = b_ref.AddressOf() - b_ref = b_ref_ptr.Dereference() - h = b_ref.GetChildMemberWithName('h'); - k = b_ref.GetChildMemberWithName('k'); - return 'a = ' + str(a.GetValueAsUnsigned(0)) + ', a_ptr = ' + \ - str(a_ptr.GetValueAsUnsigned(0)) + ' -> ' + str(a_ptr.Dereference().GetValueAsUnsigned(0)) + \ - ', i = ' + str(i.GetValueAsUnsigned(0)) + \ - ', i_ptr = ' + str(i_ptr.GetValueAsUnsigned(0)) + ' -> ' + str(i_ptr.Dereference().GetValueAsUnsigned(0)) + \ - ', b_ref = ' + str(b_ref.GetValueAsUnsigned(0)) + \ - ', h = ' + str(h.GetValueAsUnsigned(0)) + ' , k = ' + str(k.GetValueAsUnsigned(0))
\ No newline at end of file +def foo_SummaryProvider(valobj, dict): + a = valobj.GetChildMemberWithName('a') + a_ptr = valobj.GetChildMemberWithName('a_ptr') + bar = valobj.GetChildMemberWithName('b') + i = bar.GetChildMemberWithName('i') + i_ptr = bar.GetChildMemberWithName('i_ptr') + b_ref = bar.GetChildMemberWithName('b_ref') + b_ref_ptr = b_ref.AddressOf() + b_ref = b_ref_ptr.Dereference() + h = b_ref.GetChildMemberWithName('h') + k = b_ref.GetChildMemberWithName('k') + return 'a = ' + str(a.GetValueAsUnsigned(0)) + ', a_ptr = ' + \ + str(a_ptr.GetValueAsUnsigned(0)) + ' -> ' + str(a_ptr.Dereference().GetValueAsUnsigned(0)) + \ + ', i = ' + str(i.GetValueAsUnsigned(0)) + \ + ', i_ptr = ' + str(i_ptr.GetValueAsUnsigned(0)) + ' -> ' + str(i_ptr.Dereference().GetValueAsUnsigned(0)) + \ + ', b_ref = ' + str(b_ref.GetValueAsUnsigned(0)) + \ + ', h = ' + str(h.GetValueAsUnsigned(0)) + ' , k = ' + str(k.GetValueAsUnsigned(0)) diff --git a/packages/Python/lldbsuite/test/expression_command/ir-interpreter-phi-nodes/TestIRInterpreterPHINodes.py b/packages/Python/lldbsuite/test/expression_command/ir-interpreter-phi-nodes/TestIRInterpreterPHINodes.py index c4f176703225..894d0bfaa86e 100644 --- a/packages/Python/lldbsuite/test/expression_command/ir-interpreter-phi-nodes/TestIRInterpreterPHINodes.py +++ b/packages/Python/lldbsuite/test/expression_command/ir-interpreter-phi-nodes/TestIRInterpreterPHINodes.py @@ -2,38 +2,41 @@ Test PHI nodes work in the IR interpreter. """ -import os, os.path +import os +import os.path import lldb from lldbsuite.test.lldbtest import * import lldbsuite.test.lldbutil as lldbutil + class IRInterpreterPHINodesTestCase(TestBase): mydir = TestBase.compute_mydir(__file__) def test_phi_node_support(self): """Test support for PHI nodes in the IR interpreter.""" - + self.build() exe = os.path.join(os.getcwd(), 'a.out') self.runCmd('file ' + exe, CURRENT_EXECUTABLE_SET) - + # Break on the first assignment to i line = line_number('main.cpp', 'i = 5') - lldbutil.run_break_set_by_file_and_line(self, 'main.cpp', line, num_expected_locations=1, loc_exact=True) - + lldbutil.run_break_set_by_file_and_line( + self, 'main.cpp', line, num_expected_locations=1, loc_exact=True) + 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']) - + substrs=['stopped', 'stop reason = breakpoint']) + self.runCmd('s') - + # The logical 'or' causes a PHI node to be generated. Execute without JIT # to test that the interpreter can handle this self.expect('expr -j 0 -- i == 3 || i == 5', substrs=['true']) - + self.runCmd('s') self.expect('expr -j 0 -- i == 3 || i == 5', substrs=['false']) self.runCmd('s') diff --git a/packages/Python/lldbsuite/test/expression_command/ir-interpreter/TestIRInterpreter.py b/packages/Python/lldbsuite/test/expression_command/ir-interpreter/TestIRInterpreter.py index 2a21d0473715..5c5110b69945 100644 --- a/packages/Python/lldbsuite/test/expression_command/ir-interpreter/TestIRInterpreter.py +++ b/packages/Python/lldbsuite/test/expression_command/ir-interpreter/TestIRInterpreter.py @@ -6,12 +6,14 @@ from __future__ import print_function import unittest2 -import os, time +import os +import time import lldb from lldbsuite.test.decorators import * from lldbsuite.test.lldbtest import * from lldbsuite.test import lldbutil + class IRInterpreterTestCase(TestBase): mydir = TestBase.compute_mydir(__file__) @@ -25,7 +27,8 @@ class IRInterpreterTestCase(TestBase): # Disable confirmation prompt to avoid infinite wait self.runCmd("settings set auto-confirm true") - self.addTearDownHook(lambda: self.runCmd("settings clear auto-confirm")) + self.addTearDownHook( + lambda: self.runCmd("settings clear auto-confirm")) def build_and_run(self): """Test the IR interpreter""" @@ -33,13 +36,20 @@ class IRInterpreterTestCase(TestBase): self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) - lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, num_expected_locations=1, loc_exact=False) + lldbutil.run_break_set_by_file_and_line( + self, "main.c", self.line, num_expected_locations=1, loc_exact=False) self.runCmd("run", RUN_SUCCEEDED) @add_test_categories(['pyapi']) - @expectedFailureAll(oslist=['windows'], bugnumber="http://llvm.org/pr21765") # getpid() is POSIX, among other problems, see bug - @expectedFailureAll(oslist=['linux'], archs=['arm'], bugnumber="llvm.org/pr27868") + # getpid() is POSIX, among other problems, see bug + @expectedFailureAll( + oslist=['windows'], + bugnumber="http://llvm.org/pr21765") + @expectedFailureAll( + oslist=['linux'], + archs=['arm'], + bugnumber="llvm.org/pr27868") def test_ir_interpreter(self): self.build_and_run() @@ -62,11 +72,16 @@ class IRInterpreterTestCase(TestBase): self.frame().EvaluateExpression(expression, options) for expression in expressions: - interp_expression = expression - jit_expression = "(int)getpid(); " + expression - - interp_result = self.frame().EvaluateExpression(interp_expression, options).GetValueAsSigned() - jit_result = self.frame().EvaluateExpression(jit_expression, options).GetValueAsSigned() - - self.assertEqual(interp_result, jit_result, "While evaluating " + expression) - + interp_expression = expression + jit_expression = "(int)getpid(); " + expression + + interp_result = self.frame().EvaluateExpression( + interp_expression, options).GetValueAsSigned() + jit_result = self.frame().EvaluateExpression( + jit_expression, options).GetValueAsSigned() + + self.assertEqual( + interp_result, + jit_result, + "While evaluating " + + expression) diff --git a/packages/Python/lldbsuite/test/expression_command/issue_11588/Test11588.py b/packages/Python/lldbsuite/test/expression_command/issue_11588/Test11588.py index 2d0b23b4e5ba..afb497e04b5b 100644 --- a/packages/Python/lldbsuite/test/expression_command/issue_11588/Test11588.py +++ b/packages/Python/lldbsuite/test/expression_command/issue_11588/Test11588.py @@ -7,13 +7,14 @@ expected in a SyntheticChildrenProvider from __future__ import print_function - -import os, time +import os +import time import lldb from lldbsuite.test.decorators import * from lldbsuite.test.lldbtest import * from lldbsuite.test import lldbutil + class Issue11581TestCase(TestBase): mydir = TestBase.compute_mydir(__file__) @@ -25,54 +26,61 @@ class Issue11581TestCase(TestBase): def cleanup(): self.runCmd('type synthetic clear', check=False) - # Execute the cleanup function during test case tear down. self.addTearDownHook(cleanup) """valobj.AddressOf() should return correct values.""" self.build() - + exe = os.path.join(os.getcwd(), "a.out") - + target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) - breakpoint = target.BreakpointCreateBySourceRegex('Set breakpoint here.',lldb.SBFileSpec ("main.cpp", False)) - - process = target.LaunchSimple (None, None, self.get_process_working_directory()) - self.assertTrue (process, "Created a process.") - self.assertTrue (process.GetState() == lldb.eStateStopped, "Stopped it too.") + breakpoint = target.BreakpointCreateBySourceRegex( + 'Set breakpoint here.', lldb.SBFileSpec("main.cpp", False)) + + process = target.LaunchSimple( + None, None, self.get_process_working_directory()) + self.assertTrue(process, "Created a process.") + self.assertTrue( + process.GetState() == lldb.eStateStopped, + "Stopped it too.") - thread_list = lldbutil.get_threads_stopped_at_breakpoint (process, breakpoint) - self.assertTrue (len(thread_list) == 1) + thread_list = lldbutil.get_threads_stopped_at_breakpoint( + process, breakpoint) + self.assertTrue(len(thread_list) == 1) thread = thread_list[0] self.runCmd("command script import --allow-reload s11588.py") - self.runCmd("type synthetic add --python-class s11588.Issue11581SyntheticProvider StgClosure") + self.runCmd( + "type synthetic add --python-class s11588.Issue11581SyntheticProvider StgClosure") self.expect("expr --show-types -- *((StgClosure*)(r14-1))", - substrs = ["(StgClosure) $", - "(StgClosure *) &$","0x", - "addr = ", - "load_address = "]) + substrs=["(StgClosure) $", + "(StgClosure *) &$", "0x", + "addr = ", + "load_address = "]) # register r14 is an x86_64 extension let's skip this part of the test # if we are on a different architecture if self.getArchitecture() == 'x86_64': - target = lldb.debugger.GetSelectedTarget() - process = target.GetProcess() - frame = process.GetSelectedThread().GetSelectedFrame() - pointer = frame.FindVariable("r14") - addr = pointer.GetValueAsUnsigned(0) - self.assertTrue(addr != 0, "could not read pointer to StgClosure") - addr = addr - 1 - self.runCmd("register write r14 %d" % addr) - self.expect("register read r14", - substrs = ["0x",hex(addr)[2:].rstrip("L")]) # Remove trailing 'L' if it exists - self.expect("expr --show-types -- *(StgClosure*)$r14", - substrs = ["(StgClosure) $", - "(StgClosure *) &$","0x", - "addr = ", - "load_address = ", - hex(addr)[2:].rstrip("L"), - str(addr)]) + target = lldb.debugger.GetSelectedTarget() + process = target.GetProcess() + frame = process.GetSelectedThread().GetSelectedFrame() + pointer = frame.FindVariable("r14") + addr = pointer.GetValueAsUnsigned(0) + self.assertTrue(addr != 0, "could not read pointer to StgClosure") + addr = addr - 1 + self.runCmd("register write r14 %d" % addr) + self.expect( + "register read r14", substrs=[ + "0x", hex(addr)[ + 2:].rstrip("L")]) # Remove trailing 'L' if it exists + self.expect("expr --show-types -- *(StgClosure*)$r14", + substrs=["(StgClosure) $", + "(StgClosure *) &$", "0x", + "addr = ", + "load_address = ", + hex(addr)[2:].rstrip("L"), + str(addr)]) diff --git a/packages/Python/lldbsuite/test/expression_command/issue_11588/s11588.py b/packages/Python/lldbsuite/test/expression_command/issue_11588/s11588.py index 01bb09a1b0d6..51c20423ed36 100644 --- a/packages/Python/lldbsuite/test/expression_command/issue_11588/s11588.py +++ b/packages/Python/lldbsuite/test/expression_command/issue_11588/s11588.py @@ -1,26 +1,28 @@ class Issue11581SyntheticProvider(object): - def __init__(self, valobj, dict): - self.valobj = valobj - self.addrOf = valobj.AddressOf() - self.addr = valobj.GetAddress() - self.load_address = valobj.GetLoadAddress() - def num_children(self): - return 3; + def __init__(self, valobj, dict): + self.valobj = valobj + self.addrOf = valobj.AddressOf() + self.addr = valobj.GetAddress() + self.load_address = valobj.GetLoadAddress() - def get_child_at_index(self, index): - if index == 0: - return self.addrOf - if index == 1: - return self.valobj.CreateValueFromExpression("addr", str(self.addr)) - if index == 2: - return self.valobj.CreateValueFromExpression("load_address", str(self.load_address)) + def num_children(self): + return 3 - def get_child_index(self, name): - if name == "addrOf": - return 0 - if name == "addr": - return 1 - if name == "load_address": - return 2 + def get_child_at_index(self, index): + if index == 0: + return self.addrOf + if index == 1: + return self.valobj.CreateValueFromExpression( + "addr", str(self.addr)) + if index == 2: + return self.valobj.CreateValueFromExpression( + "load_address", str(self.load_address)) + def get_child_index(self, name): + if name == "addrOf": + return 0 + if name == "addr": + return 1 + if name == "load_address": + return 2 diff --git a/packages/Python/lldbsuite/test/expression_command/macros/TestMacros.py b/packages/Python/lldbsuite/test/expression_command/macros/TestMacros.py index 939d2e45d7d5..70b862bf4867 100644 --- a/packages/Python/lldbsuite/test/expression_command/macros/TestMacros.py +++ b/packages/Python/lldbsuite/test/expression_command/macros/TestMacros.py @@ -6,13 +6,21 @@ from lldbsuite.test.decorators import * from lldbsuite.test.lldbtest import * from lldbsuite.test import lldbutil + class TestMacros(TestBase): mydir = TestBase.compute_mydir(__file__) - @expectedFailureAll(compiler="clang", bugnumber="clang does not emit .debug_macro[.dwo] sections.") - @expectedFailureAll(debug_info="dwo", bugnumber="GCC produces multiple .debug_macro.dwo sections and the spec is unclear as to what it means") - @expectedFailureAll(hostoslist=["windows"], compiler="gcc", triple='.*-android') + @expectedFailureAll( + compiler="clang", + bugnumber="clang does not emit .debug_macro[.dwo] sections.") + @expectedFailureAll( + debug_info="dwo", + bugnumber="GCC produces multiple .debug_macro.dwo sections and the spec is unclear as to what it means") + @expectedFailureAll( + hostoslist=["windows"], + compiler="gcc", + triple='.*-android') def test_expr_with_macros(self): self.build() @@ -25,7 +33,7 @@ class TestMacros(TestBase): # Get the path of the executable cwd = os.getcwd() exe_file = "a.out" - exe_path = os.path.join(cwd, exe_file) + exe_path = os.path.join(cwd, exe_file) # Load the executable target = self.dbg.CreateTarget(exe_path) @@ -33,51 +41,78 @@ class TestMacros(TestBase): # Set breakpoints bp1 = target.BreakpointCreateBySourceRegex("Break here", src_file_spec) - self.assertTrue(bp1.IsValid() and bp1.GetNumLocations() >= 1, VALID_BREAKPOINT) + self.assertTrue( + bp1.IsValid() and bp1.GetNumLocations() >= 1, + VALID_BREAKPOINT) # Launch the process - process = target.LaunchSimple(None, None, self.get_process_working_directory()) + process = target.LaunchSimple( + None, None, self.get_process_working_directory()) self.assertTrue(process.IsValid(), PROCESS_IS_VALID) # Get the thread of the process - self.assertTrue(process.GetState() == lldb.eStateStopped, PROCESS_STOPPED) - thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint) + self.assertTrue( + process.GetState() == lldb.eStateStopped, + PROCESS_STOPPED) + thread = lldbutil.get_stopped_thread( + process, lldb.eStopReasonBreakpoint) # Get frame for current thread frame = thread.GetSelectedFrame() result = frame.EvaluateExpression("MACRO_1") - self.assertTrue(result.IsValid() and result.GetValue() == "100", "MACRO_1 = 100") + self.assertTrue( + result.IsValid() and result.GetValue() == "100", + "MACRO_1 = 100") result = frame.EvaluateExpression("MACRO_2") - self.assertTrue(result.IsValid() and result.GetValue() == "200", "MACRO_2 = 200") + self.assertTrue( + result.IsValid() and result.GetValue() == "200", + "MACRO_2 = 200") result = frame.EvaluateExpression("ONE") - self.assertTrue(result.IsValid() and result.GetValue() == "1", "ONE = 1") + self.assertTrue( + result.IsValid() and result.GetValue() == "1", + "ONE = 1") result = frame.EvaluateExpression("TWO") - self.assertTrue(result.IsValid() and result.GetValue() == "2", "TWO = 2") + self.assertTrue( + result.IsValid() and result.GetValue() == "2", + "TWO = 2") result = frame.EvaluateExpression("THREE") - self.assertTrue(result.IsValid() and result.GetValue() == "3", "THREE = 3") + self.assertTrue( + result.IsValid() and result.GetValue() == "3", + "THREE = 3") result = frame.EvaluateExpression("FOUR") - self.assertTrue(result.IsValid() and result.GetValue() == "4", "FOUR = 4") + self.assertTrue( + result.IsValid() and result.GetValue() == "4", + "FOUR = 4") result = frame.EvaluateExpression("HUNDRED") - self.assertTrue(result.IsValid() and result.GetValue() == "100", "HUNDRED = 100") + self.assertTrue( + result.IsValid() and result.GetValue() == "100", + "HUNDRED = 100") result = frame.EvaluateExpression("THOUSAND") - self.assertTrue(result.IsValid() and result.GetValue() == "1000", "THOUSAND = 1000") + self.assertTrue( + result.IsValid() and result.GetValue() == "1000", + "THOUSAND = 1000") result = frame.EvaluateExpression("MILLION") - self.assertTrue(result.IsValid() and result.GetValue() == "1000000", "MILLION = 1000000") + self.assertTrue(result.IsValid() and result.GetValue() + == "1000000", "MILLION = 1000000") result = frame.EvaluateExpression("MAX(ONE, TWO)") - self.assertTrue(result.IsValid() and result.GetValue() == "2", "MAX(ONE, TWO) = 2") + self.assertTrue( + result.IsValid() and result.GetValue() == "2", + "MAX(ONE, TWO) = 2") result = frame.EvaluateExpression("MAX(THREE, TWO)") - self.assertTrue(result.IsValid() and result.GetValue() == "3", "MAX(THREE, TWO) = 3") + self.assertTrue( + result.IsValid() and result.GetValue() == "3", + "MAX(THREE, TWO) = 3") # Get the thread of the process thread.StepOver() @@ -86,10 +121,14 @@ class TestMacros(TestBase): frame = thread.GetSelectedFrame() result = frame.EvaluateExpression("MACRO_2") - self.assertTrue(result.GetError().Fail(), "Printing MACRO_2 fails in the mail file") + self.assertTrue( + result.GetError().Fail(), + "Printing MACRO_2 fails in the mail file") result = frame.EvaluateExpression("FOUR") - self.assertTrue(result.GetError().Fail(), "Printing FOUR fails in the main file") + self.assertTrue( + result.GetError().Fail(), + "Printing FOUR fails in the main file") thread.StepInto() @@ -97,14 +136,20 @@ class TestMacros(TestBase): frame = thread.GetSelectedFrame() result = frame.EvaluateExpression("ONE") - self.assertTrue(result.IsValid() and result.GetValue() == "1", "ONE = 1") + self.assertTrue( + result.IsValid() and result.GetValue() == "1", + "ONE = 1") result = frame.EvaluateExpression("MAX(ONE, TWO)") - self.assertTrue(result.IsValid() and result.GetValue() == "2", "MAX(ONE, TWO) = 2") + self.assertTrue( + result.IsValid() and result.GetValue() == "2", + "MAX(ONE, TWO) = 2") # This time, MACRO_1 and MACRO_2 are not visible. result = frame.EvaluateExpression("MACRO_1") - self.assertTrue(result.GetError().Fail(), "Printing MACRO_1 fails in the header file") + self.assertTrue(result.GetError().Fail(), + "Printing MACRO_1 fails in the header file") result = frame.EvaluateExpression("MACRO_2") - self.assertTrue(result.GetError().Fail(), "Printing MACRO_2 fails in the header file") + self.assertTrue(result.GetError().Fail(), + "Printing MACRO_2 fails in the header file") diff --git a/packages/Python/lldbsuite/test/expression_command/multiline/TestMultilineExpressions.py b/packages/Python/lldbsuite/test/expression_command/multiline/TestMultilineExpressions.py index 0691a866743b..b1b5cbe677c4 100644 --- a/packages/Python/lldbsuite/test/expression_command/multiline/TestMultilineExpressions.py +++ b/packages/Python/lldbsuite/test/expression_command/multiline/TestMultilineExpressions.py @@ -8,6 +8,7 @@ from lldbsuite.test.decorators import * from lldbsuite.test.lldbtest import * from lldbsuite.test import lldbutil + class MultilineExpressionsTestCase(TestBase): mydir = TestBase.compute_mydir(__file__) @@ -19,7 +20,9 @@ class MultilineExpressionsTestCase(TestBase): self.line = line_number('main.c', 'break') @skipIfRemote - @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows") + @expectedFailureAll( + oslist=["windows"], + bugnumber="llvm.org/pr22274: need a pexpect replacement for windows") def test_with_run_commands(self): """Test that multiline expressions work correctly""" self.build() @@ -28,7 +31,9 @@ class MultilineExpressionsTestCase(TestBase): prompt = "(lldb) " # So that the child gets torn down after the test. - self.child = pexpect.spawn('%s %s %s' % (lldbtest_config.lldbExec, self.lldbOption, exe)) + self.child = pexpect.spawn( + '%s %s %s' % + (lldbtest_config.lldbExec, self.lldbOption, exe)) child = self.child # Turn on logging for what the child sends back. if self.TraceOn(): @@ -54,4 +59,4 @@ class MultilineExpressionsTestCase(TestBase): child.sendline('') child.expect_exact(prompt) self.expect(child.before, exe=False, - patterns = ['= 5']) + patterns=['= 5']) diff --git a/packages/Python/lldbsuite/test/expression_command/options/TestExprOptions.py b/packages/Python/lldbsuite/test/expression_command/options/TestExprOptions.py index 00c34820eef3..0d1a17352a3f 100644 --- a/packages/Python/lldbsuite/test/expression_command/options/TestExprOptions.py +++ b/packages/Python/lldbsuite/test/expression_command/options/TestExprOptions.py @@ -10,12 +10,13 @@ o test_expr_options: from __future__ import print_function - -import os, time +import os +import time import lldb import lldbsuite.test.lldbutil as lldbutil from lldbsuite.test.lldbtest import * + class ExprOptionsTestCase(TestBase): mydir = TestBase.compute_mydir(__file__) @@ -25,7 +26,7 @@ class ExprOptionsTestCase(TestBase): TestBase.setUp(self) self.main_source = "main.cpp" - self.main_source_spec = lldb.SBFileSpec (self.main_source) + self.main_source_spec = lldb.SBFileSpec(self.main_source) self.line = line_number('main.cpp', '// breakpoint_in_main') self.exe = os.path.join(os.getcwd(), "a.out") @@ -41,14 +42,17 @@ class ExprOptionsTestCase(TestBase): self.assertTrue(target, VALID_TARGET) # Set breakpoints inside main. - breakpoint = target.BreakpointCreateBySourceRegex('// breakpoint_in_main', self.main_source_spec) + breakpoint = target.BreakpointCreateBySourceRegex( + '// breakpoint_in_main', self.main_source_spec) self.assertTrue(breakpoint) # Now launch the process, and do not stop at entry point. - process = target.LaunchSimple(None, None, self.get_process_working_directory()) + process = target.LaunchSimple( + None, None, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) - threads = lldbutil.get_threads_stopped_at_breakpoint(process, breakpoint) + threads = lldbutil.get_threads_stopped_at_breakpoint( + process, breakpoint) self.assertEqual(len(threads), 1) frame = threads[0].GetFrameAtIndex(0) diff --git a/packages/Python/lldbsuite/test/expression_command/persist_objc_pointeetype/TestPersistObjCPointeeType.py b/packages/Python/lldbsuite/test/expression_command/persist_objc_pointeetype/TestPersistObjCPointeeType.py index d3ce10d8f2ab..b99fb727e8a5 100644 --- a/packages/Python/lldbsuite/test/expression_command/persist_objc_pointeetype/TestPersistObjCPointeeType.py +++ b/packages/Python/lldbsuite/test/expression_command/persist_objc_pointeetype/TestPersistObjCPointeeType.py @@ -5,12 +5,12 @@ Test that we can p *objcObject from __future__ import print_function - import lldb from lldbsuite.test.decorators import * from lldbsuite.test.lldbtest import * from lldbsuite.test import lldbutil + class PersistObjCPointeeType(TestBase): mydir = TestBase.compute_mydir(__file__) @@ -19,12 +19,13 @@ class PersistObjCPointeeType(TestBase): # Call super's setUp(). TestBase.setUp(self) # Find the line number to break for main.cpp. - self.line = line_number('main.m','// break here') + self.line = line_number('main.m', '// break here') @skipUnlessDarwin @expectedFailureAll( bugnumber='http://llvm.org/pr23504', oslist=['macosx'], compiler='clang', compiler_version=['<', '7.0.0']) + @skipIf(archs=["i386", "i686"]) def test_with(self): """Test that we can p *objcObject""" self.build() @@ -37,15 +38,16 @@ class PersistObjCPointeeType(TestBase): self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) - lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, loc_exact=True) + lldbutil.run_break_set_by_file_and_line( + self, "main.m", self.line, loc_exact=True) self.runCmd("run", RUN_SUCCEEDED) - + self.expect("p *self", substrs=['_sc_name = nil', - '_sc_name2 = nil', - '_sc_name3 = nil', - '_sc_name4 = nil', - '_sc_name5 = nil', - '_sc_name6 = nil', - '_sc_name7 = nil', - '_sc_name8 = nil']) + '_sc_name2 = nil', + '_sc_name3 = nil', + '_sc_name4 = nil', + '_sc_name5 = nil', + '_sc_name6 = nil', + '_sc_name7 = nil', + '_sc_name8 = nil']) diff --git a/packages/Python/lldbsuite/test/expression_command/persistent_ptr_update/TestPersistentPtrUpdate.py b/packages/Python/lldbsuite/test/expression_command/persistent_ptr_update/TestPersistentPtrUpdate.py index 9d7359fb2d45..118b9f32c4bd 100644 --- a/packages/Python/lldbsuite/test/expression_command/persistent_ptr_update/TestPersistentPtrUpdate.py +++ b/packages/Python/lldbsuite/test/expression_command/persistent_ptr_update/TestPersistentPtrUpdate.py @@ -5,11 +5,11 @@ Test that we can have persistent pointer variables from __future__ import print_function - import lldb import lldbsuite.test.lldbutil as lldbutil from lldbsuite.test.lldbtest import * + class PersistentPtrUpdateTestCase(TestBase): mydir = TestBase.compute_mydir(__file__) @@ -24,18 +24,18 @@ class PersistentPtrUpdateTestCase(TestBase): def cleanup(): pass - + # Execute the cleanup function during test case tear down. self.addTearDownHook(cleanup) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) - + self.runCmd('break set -p here') self.runCmd("run", RUN_SUCCEEDED) - + self.runCmd("expr void* $foo = 0") - + self.runCmd("continue") - - self.expect("expr $foo", substrs=['$foo','0x0']) + + self.expect("expr $foo", substrs=['$foo', '0x0']) diff --git a/packages/Python/lldbsuite/test/expression_command/persistent_types/TestNestedPersistentTypes.py b/packages/Python/lldbsuite/test/expression_command/persistent_types/TestNestedPersistentTypes.py index 9099ae1806e3..12452a963772 100644 --- a/packages/Python/lldbsuite/test/expression_command/persistent_types/TestNestedPersistentTypes.py +++ b/packages/Python/lldbsuite/test/expression_command/persistent_types/TestNestedPersistentTypes.py @@ -5,13 +5,14 @@ Test that nested persistent types work. from __future__ import print_function - -import os, time +import os +import time import lldb from lldbsuite.test.decorators import * from lldbsuite.test.lldbtest import * from lldbsuite.test import lldbutil + class NestedPersistentTypesTestCase(TestBase): mydir = TestBase.compute_mydir(__file__) @@ -29,15 +30,16 @@ class NestedPersistentTypesTestCase(TestBase): self.runCmd("expression struct $foo { int a; int b; };") - self.runCmd("expression struct $bar { struct $foo start; struct $foo end; };") + self.runCmd( + "expression struct $bar { struct $foo start; struct $foo end; };") self.runCmd("expression struct $bar $my_bar = {{ 2, 3 }, { 4, 5 }};") self.expect("expression $my_bar", - substrs = ['a = 2', 'b = 3', 'a = 4', 'b = 5']) + substrs=['a = 2', 'b = 3', 'a = 4', 'b = 5']) self.expect("expression $my_bar.start.b", - substrs = ['(int)', '3']) + substrs=['(int)', '3']) self.expect("expression $my_bar.end.b", - substrs = ['(int)', '5']) + substrs=['(int)', '5']) diff --git a/packages/Python/lldbsuite/test/expression_command/persistent_types/TestPersistentTypes.py b/packages/Python/lldbsuite/test/expression_command/persistent_types/TestPersistentTypes.py index 59e0f0b84f69..3d4df307d1b0 100644 --- a/packages/Python/lldbsuite/test/expression_command/persistent_types/TestPersistentTypes.py +++ b/packages/Python/lldbsuite/test/expression_command/persistent_types/TestPersistentTypes.py @@ -5,13 +5,14 @@ Test that lldb persistent types works correctly. from __future__ import print_function - -import os, time +import os +import time import lldb from lldbsuite.test.decorators import * from lldbsuite.test.lldbtest import * from lldbsuite.test import lldbutil + class PersistenttypesTestCase(TestBase): mydir = TestBase.compute_mydir(__file__) @@ -29,31 +30,57 @@ class PersistenttypesTestCase(TestBase): self.runCmd("expression struct $foo { int a; int b; };") - self.expect("expression struct $foo $my_foo; $my_foo.a = 2; $my_foo.b = 3;", - startstr = "(int) $0 = 3") + self.expect( + "expression struct $foo $my_foo; $my_foo.a = 2; $my_foo.b = 3;", + startstr="(int) $0 = 3") self.expect("expression $my_foo", - substrs = ['a = 2', 'b = 3']) + substrs=['a = 2', 'b = 3']) self.runCmd("expression typedef int $bar") self.expect("expression $bar i = 5; i", - startstr = "($bar) $1 = 5") + startstr="($bar) $1 = 5") - self.runCmd("expression struct $foobar { char a; char b; char c; char d; };") + self.runCmd( + "expression struct $foobar { char a; char b; char c; char d; };") self.runCmd("next") - self.expect("memory read foo -t $foobar", - substrs = ['($foobar) 0x', ' = ', "a = 'H'","b = 'e'","c = 'l'","d = 'l'"]) # persistent types are OK to use for memory read - - self.expect("memory read foo -t foobar", - substrs = ['($foobar) 0x', ' = ', "a = 'H'","b = 'e'","c = 'l'","d = 'l'"],matching=False,error=True) # the type name is $foobar, make sure we settle for nothing less + self.expect( + "memory read foo -t $foobar", + substrs=[ + '($foobar) 0x', + ' = ', + "a = 'H'", + "b = 'e'", + "c = 'l'", + "d = 'l'"]) # persistent types are OK to use for memory read + + self.expect( + "memory read foo -t foobar", + substrs=[ + '($foobar) 0x', + ' = ', + "a = 'H'", + "b = 'e'", + "c = 'l'", + "d = 'l'"], + matching=False, + error=True) # the type name is $foobar, make sure we settle for nothing less self.expect("expression struct { int a; int b; } x = { 2, 3 }; x", - substrs = ['a = 2', 'b = 3']) - - self.expect("expression struct { int x; int y; int z; } object; object.y = 1; object.z = 3; object.x = 2; object", - substrs = ['x = 2', 'y = 1', 'z = 3']) - - self.expect("expression struct A { int x; int y; }; struct { struct A a; int z; } object; object.a.y = 1; object.z = 3; object.a.x = 2; object", - substrs = ['x = 2', 'y = 1', 'z = 3']) + substrs=['a = 2', 'b = 3']) + + self.expect( + "expression struct { int x; int y; int z; } object; object.y = 1; object.z = 3; object.x = 2; object", + substrs=[ + 'x = 2', + 'y = 1', + 'z = 3']) + + self.expect( + "expression struct A { int x; int y; }; struct { struct A a; int z; } object; object.a.y = 1; object.z = 3; object.a.x = 2; object", + substrs=[ + 'x = 2', + 'y = 1', + 'z = 3']) diff --git a/packages/Python/lldbsuite/test/expression_command/persistent_variables/TestPersistentVariables.py b/packages/Python/lldbsuite/test/expression_command/persistent_variables/TestPersistentVariables.py index e148fcd89599..b6f027964bab 100644 --- a/packages/Python/lldbsuite/test/expression_command/persistent_variables/TestPersistentVariables.py +++ b/packages/Python/lldbsuite/test/expression_command/persistent_variables/TestPersistentVariables.py @@ -5,11 +5,12 @@ Test that lldb persistent variables works correctly. from __future__ import print_function - -import os, time +import os +import time import lldb from lldbsuite.test.lldbtest import * + class PersistentVariablesTestCase(TestBase): mydir = TestBase.compute_mydir(__file__) @@ -27,28 +28,28 @@ class PersistentVariablesTestCase(TestBase): self.runCmd("expression int $i = i") self.expect("expression $i == i", - startstr = "(bool) $0 = true") + startstr="(bool) $0 = true") self.expect("expression $i + 1", - startstr = "(int) $1 = 6") + startstr="(int) $1 = 6") self.expect("expression $i + 3", - startstr = "(int) $2 = 8") + startstr="(int) $2 = 8") self.expect("expression $2 + $1", - startstr = "(int) $3 = 14") + startstr="(int) $3 = 14") self.expect("expression $3", - startstr = "(int) $3 = 14") + startstr="(int) $3 = 14") self.expect("expression $2", - startstr = "(int) $2 = 8") + startstr="(int) $2 = 8") self.expect("expression (int)-2", - startstr = "(int) $4 = -2") + startstr="(int) $4 = -2") self.expect("expression $4 > (int)31", - startstr = "(bool) $5 = false") + startstr="(bool) $5 = false") self.expect("expression (long)$4", - startstr = "(long) $6 = -2") + startstr="(long) $6 = -2") diff --git a/packages/Python/lldbsuite/test/expression_command/po_verbosity/TestPoVerbosity.py b/packages/Python/lldbsuite/test/expression_command/po_verbosity/TestPoVerbosity.py index da87bcee9cfc..13f8f58564e8 100644 --- a/packages/Python/lldbsuite/test/expression_command/po_verbosity/TestPoVerbosity.py +++ b/packages/Python/lldbsuite/test/expression_command/po_verbosity/TestPoVerbosity.py @@ -5,12 +5,12 @@ Test that the po command acts correctly. from __future__ import print_function - import lldb from lldbsuite.test.decorators import * from lldbsuite.test.lldbtest import * from lldbsuite.test import lldbutil + class PoVerbosityTestCase(TestBase): mydir = TestBase.compute_mydir(__file__) @@ -26,37 +26,38 @@ class PoVerbosityTestCase(TestBase): def test(self): """Test that the po command acts correctly.""" self.build() - + # This is the function to remove the custom formats in order to have a # clean slate for the next test case. def cleanup(): self.runCmd('type summary clear', check=False) self.runCmd('type synthetic clear', check=False) - + # Execute the cleanup function during test case tear down. self.addTearDownHook(cleanup) """Test expr + formatters for good interoperability.""" self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) - lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, loc_exact=True) + lldbutil.run_break_set_by_file_and_line( + self, "main.m", self.line, loc_exact=True) self.runCmd("run", RUN_SUCCEEDED) - + self.expect("expr -O -v -- foo", - substrs = ['(id) $',' = 0x', '1 = 2','2 = 3;']) + substrs=['(id) $', ' = 0x', '1 = 2', '2 = 3;']) self.expect("expr -O -vfull -- foo", - substrs = ['(id) $',' = 0x', '1 = 2','2 = 3;']) - self.expect("expr -O -- foo",matching=False, - substrs = ['(id) $']) + substrs=['(id) $', ' = 0x', '1 = 2', '2 = 3;']) + self.expect("expr -O -- foo", matching=False, + substrs=['(id) $']) - self.expect("expr -O -- 22",matching=False, - substrs = ['(int) $']) + self.expect("expr -O -- 22", matching=False, + substrs=['(int) $']) self.expect("expr -O -- 22", - substrs = ['22']) + substrs=['22']) self.expect("expr -O -vfull -- 22", - substrs = ['(int) $', ' = 22']) + substrs=['(int) $', ' = 22']) self.expect("expr -O -v -- 22", - substrs = ['(int) $', ' = 22']) + substrs=['(int) $', ' = 22']) diff --git a/packages/Python/lldbsuite/test/expression_command/radar_8638051/Test8638051.py b/packages/Python/lldbsuite/test/expression_command/radar_8638051/Test8638051.py index 302b14b7360e..ca43585616e5 100644 --- a/packages/Python/lldbsuite/test/expression_command/radar_8638051/Test8638051.py +++ b/packages/Python/lldbsuite/test/expression_command/radar_8638051/Test8638051.py @@ -5,11 +5,12 @@ Test the robustness of lldb expression parser. from __future__ import print_function - -import os, time +import os +import time import lldb from lldbsuite.test.lldbtest import * + class Radar8638051TestCase(TestBase): mydir = TestBase.compute_mydir(__file__) @@ -25,15 +26,15 @@ class Radar8638051TestCase(TestBase): self.runCmd("run", RUN_SUCCEEDED) self.expect("expression val", - startstr = "(int) $0 = 1") + startstr="(int) $0 = 1") # (int) $0 = 1 self.expect("expression *(&val)", - startstr = "(int) $1 = 1") + startstr="(int) $1 = 1") # (int) $1 = 1 # rdar://problem/8638051 # lldb expression command: Could this crash be avoided self.expect("expression &val", - startstr = "(int *) $2 = ") + startstr="(int *) $2 = ") # (int *) $2 = 0x.... diff --git a/packages/Python/lldbsuite/test/expression_command/radar_9531204/TestPrintfAfterUp.py b/packages/Python/lldbsuite/test/expression_command/radar_9531204/TestPrintfAfterUp.py index e0b219dbe2b9..c4d899cfc1e0 100644 --- a/packages/Python/lldbsuite/test/expression_command/radar_9531204/TestPrintfAfterUp.py +++ b/packages/Python/lldbsuite/test/expression_command/radar_9531204/TestPrintfAfterUp.py @@ -5,13 +5,14 @@ The evaluating printf(...) after break stop and then up a stack frame. from __future__ import print_function - -import os, time +import os +import time import lldb from lldbsuite.test.decorators import * from lldbsuite.test.lldbtest import * from lldbsuite.test import lldbutil + class Radar9531204TestCase(TestBase): mydir = TestBase.compute_mydir(__file__) @@ -24,7 +25,8 @@ class Radar9531204TestCase(TestBase): self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) - lldbutil.run_break_set_by_symbol (self, 'foo', sym_exact=True, num_expected_locations=1) + lldbutil.run_break_set_by_symbol( + self, 'foo', sym_exact=True, num_expected_locations=1) self.runCmd("run", RUN_SUCCEEDED) @@ -35,7 +37,7 @@ class Radar9531204TestCase(TestBase): # rdar://problem/9531204 # "Error dematerializing struct" error when evaluating expressions "up" on the stack - self.runCmd('up') # frame select -r 1 + self.runCmd('up') # frame select -r 1 self.runCmd("frame variable") diff --git a/packages/Python/lldbsuite/test/expression_command/radar_9673664/TestExprHelpExamples.py b/packages/Python/lldbsuite/test/expression_command/radar_9673664/TestExprHelpExamples.py index a1505b08c508..a6c0c050c468 100644 --- a/packages/Python/lldbsuite/test/expression_command/radar_9673664/TestExprHelpExamples.py +++ b/packages/Python/lldbsuite/test/expression_command/radar_9673664/TestExprHelpExamples.py @@ -5,13 +5,14 @@ Test example snippets from the lldb 'help expression' output. from __future__ import print_function - -import os, time +import os +import time import lldb from lldbsuite.test.decorators import * from lldbsuite.test.lldbtest import * from lldbsuite.test import lldbutil + class Radar9673644TestCase(TestBase): mydir = TestBase.compute_mydir(__file__) @@ -30,13 +31,18 @@ class Radar9673644TestCase(TestBase): self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) - lldbutil.run_break_set_by_file_and_line (self, self.main_source, self.line, num_expected_locations=1, loc_exact=True) + lldbutil.run_break_set_by_file_and_line( + self, + self.main_source, + self.line, + num_expected_locations=1, + loc_exact=True) self.runCmd("run", RUN_SUCCEEDED) # rdar://problem/9673664 lldb expression evaluation problem self.expect('expr char c[] = "foo"; c[0]', - substrs = ["'f'"]) + substrs=["'f'"]) # runCmd: expr char c[] = "foo"; c[0] # output: (char) $0 = 'f' diff --git a/packages/Python/lldbsuite/test/expression_command/save_jit_objects/Makefile b/packages/Python/lldbsuite/test/expression_command/save_jit_objects/Makefile new file mode 100644 index 000000000000..0d70f2595019 --- /dev/null +++ b/packages/Python/lldbsuite/test/expression_command/save_jit_objects/Makefile @@ -0,0 +1,5 @@ +LEVEL = ../../make + +C_SOURCES := main.c + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/expression_command/save_jit_objects/TestSaveJITObjects.py b/packages/Python/lldbsuite/test/expression_command/save_jit_objects/TestSaveJITObjects.py new file mode 100644 index 000000000000..7f796971d0ed --- /dev/null +++ b/packages/Python/lldbsuite/test/expression_command/save_jit_objects/TestSaveJITObjects.py @@ -0,0 +1,58 @@ +""" +Test that LLDB can emit JIT objects when the appropriate setting is enabled +""" + +from __future__ import print_function + +import os +import time +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + +def enumerateJITFiles(): + return [f for f in os.listdir(os.getcwd()) if f.startswith("jit")] + +def countJITFiles(): + return len(enumerateJITFiles()) + +def cleanJITFiles(): + for j in enumerateJITFiles(): + os.remove(j) + return + +class SaveJITObjectsTestCase(TestBase): + mydir = TestBase.compute_mydir(__file__) + + @expectedFailureAll(oslist=["windows"]) + def test_save_jit_objects(self): + self.build() + src_file = "main.c" + src_file_spec = lldb.SBFileSpec(src_file) + + exe_path = os.path.join(os.getcwd(), "a.out") + target = self.dbg.CreateTarget(exe_path) + + breakpoint = target.BreakpointCreateBySourceRegex( + "break", src_file_spec) + + process = target.LaunchSimple(None, None, + self.get_process_working_directory()) + + thread = process.GetSelectedThread() + frame = thread.GetSelectedFrame() + + cleanJITFiles() + frame.EvaluateExpression("(void*)malloc(0x1)") + self.assertTrue(countJITFiles() == 0, + "No files emitted with save-jit-objects=false") + + self.runCmd("settings set target.save-jit-objects true") + frame.EvaluateExpression("(void*)malloc(0x1)") + jit_files_count = countJITFiles() + cleanJITFiles() + self.assertTrue(jit_files_count != 0, + "At least one file emitted with save-jit-objects=true") + + process.Kill() diff --git a/packages/Python/lldbsuite/test/expression_command/save_jit_objects/main.c b/packages/Python/lldbsuite/test/expression_command/save_jit_objects/main.c new file mode 100644 index 000000000000..ec4c943dfe39 --- /dev/null +++ b/packages/Python/lldbsuite/test/expression_command/save_jit_objects/main.c @@ -0,0 +1,14 @@ +//===-- main.c --------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +int main (int argc, char const *argv[]) +{ + const char* foo = "Hello world"; // break here + return 0; +} diff --git a/packages/Python/lldbsuite/test/expression_command/test/TestExprs.py b/packages/Python/lldbsuite/test/expression_command/test/TestExprs.py index 8c9a9a5a27e7..1cd11a8c2759 100644 --- a/packages/Python/lldbsuite/test/expression_command/test/TestExprs.py +++ b/packages/Python/lldbsuite/test/expression_command/test/TestExprs.py @@ -14,15 +14,16 @@ o test_expr_commands_can_handle_quotes: from __future__ import print_function - import unittest2 -import os, time +import os +import time import lldb from lldbsuite.test.decorators import * from lldbsuite.test.lldbtest import * from lldbsuite.test import lldbutil + class BasicExprCommandsTestCase(TestBase): mydir = TestBase.compute_mydir(__file__) @@ -31,13 +32,14 @@ class BasicExprCommandsTestCase(TestBase): # Call super's setUp(). TestBase.setUp(self) # Find the line number to break for main.c. - self.line = line_number('main.cpp', - '// Please test many expressions while stopped at this line:') + self.line = line_number( + 'main.cpp', + '// Please test many expressions while stopped at this line:') # Disable confirmation prompt to avoid infinite wait self.runCmd("settings set auto-confirm true") - self.addTearDownHook(lambda: self.runCmd("settings clear auto-confirm")) - + self.addTearDownHook( + lambda: self.runCmd("settings clear auto-confirm")) def build_and_run(self): """These basic expression commands should work as expected.""" @@ -45,56 +47,58 @@ class BasicExprCommandsTestCase(TestBase): self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) - lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=False) + lldbutil.run_break_set_by_file_and_line( + self, "main.cpp", self.line, num_expected_locations=1, loc_exact=False) self.runCmd("run", RUN_SUCCEEDED) - @unittest2.expectedFailure("llvm.org/pr17135 <rdar://problem/14874559> APFloat::toString does not identify the correct (i.e. least) precision.") + @unittest2.expectedFailure( + "llvm.org/pr17135 <rdar://problem/14874559> APFloat::toString does not identify the correct (i.e. least) precision.") def test_floating_point_expr_commands(self): self.build_and_run() self.expect("expression 2.234f", - patterns = ["\(float\) \$.* = 2\.234"]) + patterns=["\(float\) \$.* = 2\.234"]) # (float) $2 = 2.234 def test_many_expr_commands(self): self.build_and_run() self.expect("expression 2", - patterns = ["\(int\) \$.* = 2"]) + patterns=["\(int\) \$.* = 2"]) # (int) $0 = 1 self.expect("expression 2ull", - patterns = ["\(unsigned long long\) \$.* = 2"]) + patterns=["\(unsigned long long\) \$.* = 2"]) # (unsigned long long) $1 = 2 self.expect("expression 0.5f", - patterns = ["\(float\) \$.* = 0\.5"]) + patterns=["\(float\) \$.* = 0\.5"]) # (float) $2 = 0.5 self.expect("expression 2.234", - patterns = ["\(double\) \$.* = 2\.234"]) + patterns=["\(double\) \$.* = 2\.234"]) # (double) $3 = 2.234 self.expect("expression 2+3", - patterns = ["\(int\) \$.* = 5"]) + patterns=["\(int\) \$.* = 5"]) # (int) $4 = 5 self.expect("expression argc", - patterns = ["\(int\) \$.* = 1"]) + patterns=["\(int\) \$.* = 1"]) # (int) $5 = 1 self.expect("expression argc + 22", - patterns = ["\(int\) \$.* = 23"]) + patterns=["\(int\) \$.* = 23"]) # (int) $6 = 23 self.expect("expression argv", - patterns = ["\(const char \*\*\) \$.* = 0x"]) + patterns=["\(const char \*\*\) \$.* = 0x"]) # (const char *) $7 = ... self.expect("expression argv[0]", - substrs = ["(const char *)", - "a.out"]) + substrs=["(const char *)", + "a.out"]) # (const char *) $8 = 0x... "/Volumes/data/lldb/svn/trunk/test/expression_command/test/a.out" @add_test_categories(['pyapi']) @@ -115,12 +119,13 @@ class BasicExprCommandsTestCase(TestBase): # Verify the breakpoint just created. self.expect(str(breakpoint), BREAKPOINT_CREATED, exe=False, - substrs = ['main.cpp', - str(self.line)]) + substrs=['main.cpp', + str(self.line)]) # Launch the process, and do not stop at the entry point. # Pass 'X Y Z' as the args, which makes argc == 4. - process = target.LaunchSimple (['X', 'Y', 'Z'], None, self.get_process_working_directory()) + process = target.LaunchSimple( + ['X', 'Y', 'Z'], None, self.get_process_working_directory()) if not process: self.fail("SBTarget.LaunchProcess() failed") @@ -130,16 +135,18 @@ class BasicExprCommandsTestCase(TestBase): "instead the actual state is: '%s'" % lldbutil.state_type_to_str(process.GetState())) - thread = lldbutil.get_one_thread_stopped_at_breakpoint(process, breakpoint) - self.assertIsNotNone(thread, "Expected one thread to be stopped at the breakpoint") + thread = lldbutil.get_one_thread_stopped_at_breakpoint( + process, breakpoint) + self.assertIsNotNone( + thread, "Expected one thread to be stopped at the breakpoint") # The filename of frame #0 should be 'main.cpp' and function is main. self.expect(lldbutil.get_filenames(thread)[0], "Break correctly at main.cpp", exe=False, - startstr = "main.cpp") + startstr="main.cpp") self.expect(lldbutil.get_function_names(thread)[0], "Break correctly at main()", exe=False, - startstr = "main") + startstr="main") # We should be stopped on the breakpoint with a hit count of 1. self.assertTrue(breakpoint.GetHitCount() == 1, BREAKPOINT_HIT_ONCE) @@ -151,49 +158,51 @@ class BasicExprCommandsTestCase(TestBase): val = frame.EvaluateExpression("2.234") self.expect(val.GetValue(), "2.345 evaluated correctly", exe=False, - startstr = "2.234") + startstr="2.234") self.expect(val.GetTypeName(), "2.345 evaluated correctly", exe=False, - startstr = "double") + startstr="double") self.DebugSBValue(val) val = frame.EvaluateExpression("argc") self.expect(val.GetValue(), "Argc evaluated correctly", exe=False, - startstr = "4") + startstr="4") self.DebugSBValue(val) val = frame.EvaluateExpression("*argv[1]") self.expect(val.GetValue(), "Argv[1] evaluated correctly", exe=False, - startstr = "'X'") + startstr="'X'") self.DebugSBValue(val) val = frame.EvaluateExpression("*argv[2]") self.expect(val.GetValue(), "Argv[2] evaluated correctly", exe=False, - startstr = "'Y'") + startstr="'Y'") self.DebugSBValue(val) val = frame.EvaluateExpression("*argv[3]") self.expect(val.GetValue(), "Argv[3] evaluated correctly", exe=False, - startstr = "'Z'") + startstr="'Z'") self.DebugSBValue(val) - callee_break = target.BreakpointCreateByName ("a_function_to_call", None) + callee_break = target.BreakpointCreateByName( + "a_function_to_call", None) self.assertTrue(callee_break.GetNumLocations() > 0) # Make sure ignoring breakpoints works from the command line: self.expect("expression -i true -- a_function_to_call()", - substrs = ['(int) $', ' 1']) - self.assertTrue (callee_break.GetHitCount() == 1) + substrs=['(int) $', ' 1']) + self.assertTrue(callee_break.GetHitCount() == 1) # Now try ignoring breakpoints using the SB API's: options = lldb.SBExpressionOptions() options.SetIgnoreBreakpoints(True) value = frame.EvaluateExpression('a_function_to_call()', options) - self.assertTrue (value.IsValid()) - self.assertTrue (value.GetValueAsSigned(0) == 2) - self.assertTrue (callee_break.GetHitCount() == 2) + self.assertTrue(value.IsValid()) + self.assertTrue(value.GetValueAsSigned(0) == 2) + self.assertTrue(callee_break.GetHitCount() == 2) # rdar://problem/8686536 - # CommandInterpreter::HandleCommand is stripping \'s from input for WantsRawCommand commands + # CommandInterpreter::HandleCommand is stripping \'s from input for + # WantsRawCommand commands @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765") def test_expr_commands_can_handle_quotes(self): """Throw some expression commands with quotes at lldb.""" @@ -201,44 +210,46 @@ class BasicExprCommandsTestCase(TestBase): self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) - lldbutil.run_break_set_by_file_and_line(self, "main.cpp", self.line, num_expected_locations=1,loc_exact=False) + lldbutil.run_break_set_by_file_and_line( + self, "main.cpp", self.line, num_expected_locations=1, loc_exact=False) self.runCmd("run", RUN_SUCCEEDED) # runCmd: expression 'a' # output: (char) $0 = 'a' self.expect("expression 'a'", - substrs = ['(char) $', - "'a'"]) + substrs=['(char) $', + "'a'"]) # runCmd: expression (int) printf ("\n\n\tHello there!\n") # output: (int) $1 = 16 self.expect(r'''expression (int) printf ("\n\n\tHello there!\n")''', - substrs = ['(int) $', - '16']) + substrs=['(int) $', + '16']) # runCmd: expression (int) printf("\t\x68\n") # output: (int) $2 = 3 self.expect(r'''expression (int) printf("\t\x68\n")''', - substrs = ['(int) $', - '3']) + substrs=['(int) $', + '3']) # runCmd: expression (int) printf("\"\n") # output: (int) $3 = 2 self.expect(r'''expression (int) printf("\"\n")''', - substrs = ['(int) $', - '2']) + substrs=['(int) $', + '2']) # runCmd: expression (int) printf("'\n") # output: (int) $4 = 2 self.expect(r'''expression (int) printf("'\n")''', - substrs = ['(int) $', - '2']) + substrs=['(int) $', + '2']) # runCmd: command alias print_hi expression (int) printf ("\n\tHi!\n") - # output: - self.runCmd(r'''command alias print_hi expression (int) printf ("\n\tHi!\n")''') + # output: + self.runCmd( + r'''command alias print_hi expression (int) printf ("\n\tHi!\n")''') # This fails currently. self.expect('print_hi', - substrs = ['(int) $', - '6']) + substrs=['(int) $', + '6']) diff --git a/packages/Python/lldbsuite/test/expression_command/test/TestExprs2.py b/packages/Python/lldbsuite/test/expression_command/test/TestExprs2.py index 523ee51a9f18..35ac151a3908 100644 --- a/packages/Python/lldbsuite/test/expression_command/test/TestExprs2.py +++ b/packages/Python/lldbsuite/test/expression_command/test/TestExprs2.py @@ -5,13 +5,13 @@ Test some more expression commands. from __future__ import print_function - import os import lldb from lldbsuite.test.decorators import * from lldbsuite.test.lldbtest import * from lldbsuite.test import lldbutil + class ExprCommands2TestCase(TestBase): mydir = TestBase.compute_mydir(__file__) @@ -20,42 +20,46 @@ class ExprCommands2TestCase(TestBase): # Call super's setUp(). TestBase.setUp(self) # Find the line number to break for main.c. - self.line = line_number('main.cpp', - '// Please test many expressions while stopped at this line:') + self.line = line_number( + 'main.cpp', + '// Please test many expressions while stopped at this line:') - @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489: Name lookup not working correctly on Windows") + @expectedFailureAll( + oslist=["windows"], + bugnumber="llvm.org/pr24489: Name lookup not working correctly on Windows") def test_more_expr_commands(self): """Test some more expression commands.""" self.build() self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) - lldbutil.run_break_set_by_file_and_line(self, "main.cpp", self.line, num_expected_locations=1,loc_exact=False) + lldbutil.run_break_set_by_file_and_line( + self, "main.cpp", self.line, num_expected_locations=1, loc_exact=False) self.runCmd("run", RUN_SUCCEEDED) # Does static casting work? self.expect("expression (int*)argv", - startstr = "(int *) $0 = 0x") + startstr="(int *) $0 = 0x") # (int *) $0 = 0x00007fff5fbff258 # Do anonymous symbols work? self.expect("expression ((char**)environ)[0]", - startstr = "(char *) $1 = 0x") + startstr="(char *) $1 = 0x") # (char *) $1 = 0x00007fff5fbff298 "Apple_PubSub_Socket_Render=/tmp/launch-7AEsUD/Render" # Do return values containing the contents of expression locals work? self.expect("expression int i = 5; i", - startstr = "(int) $2 = 5") + startstr="(int) $2 = 5") # (int) $2 = 5 self.expect("expression $2 + 1", - startstr = "(int) $3 = 6") + startstr="(int) $3 = 6") # (int) $3 = 6 # Do return values containing the results of static expressions work? self.expect("expression 20 + 3", - startstr = "(int) $4 = 23") + startstr="(int) $4 = 23") # (int) $4 = 5 self.expect("expression $4 + 1", - startstr = "(int) $5 = 24") + startstr="(int) $5 = 24") # (int) $5 = 6 diff --git a/packages/Python/lldbsuite/test/expression_command/timeout/TestCallWithTimeout.py b/packages/Python/lldbsuite/test/expression_command/timeout/TestCallWithTimeout.py index 7cb4a647efb4..29c03b1d7ef9 100644 --- a/packages/Python/lldbsuite/test/expression_command/timeout/TestCallWithTimeout.py +++ b/packages/Python/lldbsuite/test/expression_command/timeout/TestCallWithTimeout.py @@ -5,12 +5,12 @@ Test calling a function that waits a while, and make sure the timeout option to from __future__ import print_function - import lldb from lldbsuite.test.decorators import * from lldbsuite.test.lldbtest import * from lldbsuite.test import lldbutil + class ExprCommandWithTimeoutsTestCase(TestBase): mydir = TestBase.compute_mydir(__file__) @@ -20,11 +20,14 @@ class ExprCommandWithTimeoutsTestCase(TestBase): TestBase.setUp(self) self.main_source = "wait-a-while.cpp" - self.main_source_spec = lldb.SBFileSpec (self.main_source) - + self.main_source_spec = lldb.SBFileSpec(self.main_source) @expectedFlakeyFreeBSD("llvm.org/pr19605") - @expectedFailureAll(oslist=["windows", "macosx"], bugnumber="llvm.org/pr21765") + @expectedFailureAll( + oslist=[ + "windows", + "macosx"], + bugnumber="llvm.org/pr21765") def test(self): """Test calling std::String member function.""" self.build() @@ -35,58 +38,65 @@ class ExprCommandWithTimeoutsTestCase(TestBase): target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) - breakpoint = target.BreakpointCreateBySourceRegex('stop here in main.',self.main_source_spec) + breakpoint = target.BreakpointCreateBySourceRegex( + 'stop here in main.', self.main_source_spec) self.assertTrue(breakpoint, VALID_BREAKPOINT) self.runCmd("breakpoint list") # Launch the process, and do not stop at the entry point. - process = target.LaunchSimple (None, None, self.get_process_working_directory()) + process = target.LaunchSimple( + None, None, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) # Frame #0 should be on self.step_out_of_malloc. - threads = lldbutil.get_threads_stopped_at_breakpoint (process, breakpoint) - + threads = lldbutil.get_threads_stopped_at_breakpoint( + process, breakpoint) + self.assertTrue(len(threads) == 1) thread = threads[0] - + # First set the timeout too short, and make sure we fail. options = lldb.SBExpressionOptions() options.SetTimeoutInMicroSeconds(10) options.SetUnwindOnError(True) frame = thread.GetFrameAtIndex(0) - - value = frame.EvaluateExpression("wait_a_while(300000)", options) - self.assertTrue (value.IsValid()) - self.assertFalse (value.GetError().Success()) - # Now do the same thing with the command line command, and make sure it works too. + value = frame.EvaluateExpression("wait_a_while(1000000)", options) + self.assertTrue(value.IsValid()) + self.assertFalse(value.GetError().Success()) + + # Now do the same thing with the command line command, and make sure it + # works too. interp = self.dbg.GetCommandInterpreter() result = lldb.SBCommandReturnObject() - return_value = interp.HandleCommand("expr -t 100 -u true -- wait_a_while(300000)", result) - self.assertTrue (return_value == lldb.eReturnStatusFailed) + return_value = interp.HandleCommand( + "expr -t 100 -u true -- wait_a_while(1000000)", result) + self.assertTrue(return_value == lldb.eReturnStatusFailed) # Okay, now do it again with long enough time outs: options.SetTimeoutInMicroSeconds(1000000) - value = frame.EvaluateExpression ("wait_a_while (1000)", options) + value = frame.EvaluateExpression("wait_a_while (1000)", options) self.assertTrue(value.IsValid()) - self.assertTrue (value.GetError().Success() == True) - - # Now do the same thingwith the command line command, and make sure it works too. + self.assertTrue(value.GetError().Success()) + + # Now do the same thingwith the command line command, and make sure it + # works too. interp = self.dbg.GetCommandInterpreter() result = lldb.SBCommandReturnObject() - return_value = interp.HandleCommand ("expr -t 1000000 -u true -- wait_a_while(1000)", result) + return_value = interp.HandleCommand( + "expr -t 1000000 -u true -- wait_a_while(1000)", result) self.assertTrue(return_value == lldb.eReturnStatusSuccessFinishResult) - - # Finally set the one thread timeout and make sure that doesn't change things much: + # Finally set the one thread timeout and make sure that doesn't change + # things much: options.SetTimeoutInMicroSeconds(1000000) options.SetOneThreadTimeoutInMicroSeconds(500000) - value = frame.EvaluateExpression ("wait_a_while (1000)", options) + value = frame.EvaluateExpression("wait_a_while (1000)", options) self.assertTrue(value.IsValid()) - self.assertTrue (value.GetError().Success() == True) + self.assertTrue(value.GetError().Success()) diff --git a/packages/Python/lldbsuite/test/expression_command/top-level/TestTopLevelExprs.py b/packages/Python/lldbsuite/test/expression_command/top-level/TestTopLevelExprs.py index 9a17624cb8e6..137c40398870 100644 --- a/packages/Python/lldbsuite/test/expression_command/top-level/TestTopLevelExprs.py +++ b/packages/Python/lldbsuite/test/expression_command/top-level/TestTopLevelExprs.py @@ -5,15 +5,16 @@ Test top-level expressions. from __future__ import print_function - import unittest2 -import os, time +import os +import time import lldb from lldbsuite.test.decorators import * from lldbsuite.test.lldbtest import * from lldbsuite.test import lldbutil + class TopLevelExpressionsTestCase(TestBase): mydir = TestBase.compute_mydir(__file__) @@ -29,8 +30,8 @@ class TopLevelExpressionsTestCase(TestBase): # Disable confirmation prompt to avoid infinite wait self.runCmd("settings set auto-confirm true") - self.addTearDownHook(lambda: self.runCmd("settings clear auto-confirm")) - + self.addTearDownHook( + lambda: self.runCmd("settings clear auto-confirm")) def build_and_run(self): """Test top-level expressions.""" @@ -38,23 +39,43 @@ class TopLevelExpressionsTestCase(TestBase): self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) - lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=False) + lldbutil.run_break_set_by_file_and_line( + self, "main.cpp", self.line, num_expected_locations=1, loc_exact=False) self.runCmd("run", RUN_SUCCEEDED) def run_dummy(self): self.runCmd("file dummy", CURRENT_EXECUTABLE_SET) - lldbutil.run_break_set_by_file_and_line (self, "dummy.cpp", self.dummy_line, num_expected_locations=1, loc_exact=False) + lldbutil.run_break_set_by_file_and_line( + self, + "dummy.cpp", + self.dummy_line, + num_expected_locations=1, + loc_exact=False) self.runCmd("run", RUN_SUCCEEDED) @add_test_categories(['pyapi']) @expectedFailureAndroid(api_levels=[21, 22], bugnumber="llvm.org/pr27787") - @expectedFailureAll(oslist=["linux"], archs=["arm", "aarch64"], bugnumber="llvm.org/pr27787") - @expectedFailureAll(bugnumber="llvm.org/pr28353", oslist=["linux"], archs=["i386", "x86_64"], compiler="gcc", compiler_version=["<", "4.9"]) - @skipIf(debug_info="gmodules") # not relevant - @skipIf(oslist=["windows"]) # Error in record layout on Windows + @expectedFailureAll( + oslist=["linux"], + archs=[ + "arm", + "aarch64"], + bugnumber="llvm.org/pr27787") + @expectedFailureAll( + bugnumber="llvm.org/pr28353", + oslist=["linux"], + archs=[ + "i386", + "x86_64"], + compiler="gcc", + compiler_version=[ + "<", + "4.9"]) + @skipIf(debug_info="gmodules") # not relevant + @skipIf(oslist=["windows"]) # Error in record layout on Windows def test_top_level_expressions(self): self.build_and_run() @@ -86,4 +107,6 @@ class TopLevelExpressionsTestCase(TestBase): resultFromTopLevel = self.frame().EvaluateExpression("doTest()") self.assertTrue(resultFromTopLevel.IsValid()) - self.assertEqual(resultFromCode, resultFromTopLevel.GetValueAsUnsigned()) + self.assertEqual( + resultFromCode, + resultFromTopLevel.GetValueAsUnsigned()) diff --git a/packages/Python/lldbsuite/test/expression_command/two-files/TestObjCTypeQueryFromOtherCompileUnit.py b/packages/Python/lldbsuite/test/expression_command/two-files/TestObjCTypeQueryFromOtherCompileUnit.py index 2b37faad807b..1ce75144017e 100644 --- a/packages/Python/lldbsuite/test/expression_command/two-files/TestObjCTypeQueryFromOtherCompileUnit.py +++ b/packages/Python/lldbsuite/test/expression_command/two-files/TestObjCTypeQueryFromOtherCompileUnit.py @@ -7,12 +7,12 @@ The expression parser's type search only looks in the current compilation unit f from __future__ import print_function - import lldb from lldbsuite.test.decorators import * from lldbsuite.test.lldbtest import * from lldbsuite.test import lldbutil + class ObjCTypeQueryTestCase(TestBase): mydir = TestBase.compute_mydir(__file__) @@ -21,8 +21,8 @@ class ObjCTypeQueryTestCase(TestBase): # Call super's setUp(). TestBase.setUp(self) # Find the line number to break for main.m. - self.line = line_number('main.m', - "// Set breakpoint here, then do 'expr (NSArray*)array_token'.") + self.line = line_number( + 'main.m', "// Set breakpoint here, then do 'expr (NSArray*)array_token'.") @skipUnlessDarwin def test(self): @@ -30,11 +30,12 @@ class ObjCTypeQueryTestCase(TestBase): self.build() self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) - lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True) + lldbutil.run_break_set_by_file_and_line( + self, "main.m", self.line, num_expected_locations=1, loc_exact=True) self.runCmd("run", RUN_SUCCEEDED) # Now do a NSArry type query from the 'main.m' compile uint. self.expect("expression (NSArray*)array_token", - substrs = ['(NSArray *) $0 = 0x']) + substrs=['(NSArray *) $0 = 0x']) # (NSArray *) $0 = 0x00007fff70118398 diff --git a/packages/Python/lldbsuite/test/expression_command/unwind_expression/TestUnwindExpression.py b/packages/Python/lldbsuite/test/expression_command/unwind_expression/TestUnwindExpression.py index 6e9af641d038..bfd6f4642c6c 100644 --- a/packages/Python/lldbsuite/test/expression_command/unwind_expression/TestUnwindExpression.py +++ b/packages/Python/lldbsuite/test/expression_command/unwind_expression/TestUnwindExpression.py @@ -5,15 +5,16 @@ Test stopping at a breakpoint in an expression, and unwinding from there. from __future__ import print_function - import unittest2 -import os, time +import os +import time import lldb from lldbsuite.test.decorators import * from lldbsuite.test.lldbtest import * from lldbsuite.test import lldbutil + class UnwindFromExpressionTest(TestBase): mydir = TestBase.compute_mydir(__file__) @@ -23,7 +24,7 @@ class UnwindFromExpressionTest(TestBase): TestBase.setUp(self) @add_test_categories(['pyapi']) - + @expectedFailureAll(oslist=["windows"]) def test_unwind_expression(self): """Test unwinding from an expression.""" self.build() @@ -35,11 +36,13 @@ class UnwindFromExpressionTest(TestBase): # Create the breakpoint. main_spec = lldb.SBFileSpec("main.cpp", False) - breakpoint = target.BreakpointCreateBySourceRegex("// Set a breakpoint here to get started", main_spec) + breakpoint = target.BreakpointCreateBySourceRegex( + "// Set a breakpoint here to get started", main_spec) self.assertTrue(breakpoint, VALID_BREAKPOINT) # Launch the process, and do not stop at the entry point. - process = target.LaunchSimple (None, None, self.get_process_working_directory()) + process = target.LaunchSimple( + None, None, self.get_process_working_directory()) if not process: self.fail("SBTarget.LaunchProcess() failed") @@ -49,17 +52,20 @@ class UnwindFromExpressionTest(TestBase): "instead the actual state is: '%s'" % lldbutil.state_type_to_str(process.GetState())) - thread = lldbutil.get_one_thread_stopped_at_breakpoint(process, breakpoint) - self.assertIsNotNone(thread, "Expected one thread to be stopped at the breakpoint") + thread = lldbutil.get_one_thread_stopped_at_breakpoint( + process, breakpoint) + self.assertIsNotNone( + thread, "Expected one thread to be stopped at the breakpoint") # # Use Python API to evaluate expressions while stopped in a stack frame. # main_frame = thread.GetFrameAtIndex(0) - # Next set a breakpoint in this function, set up Expression options to stop on + # Next set a breakpoint in this function, set up Expression options to stop on # breakpoint hits, and call the function. - fun_bkpt = target.BreakpointCreateBySourceRegex("// Stop inside the function here.", main_spec) + fun_bkpt = target.BreakpointCreateBySourceRegex( + "// Stop inside the function here.", main_spec) self.assertTrue(fun_bkpt, VALID_BREAKPOINT) options = lldb.SBExpressionOptions() options.SetIgnoreBreakpoints(False) @@ -67,17 +73,26 @@ class UnwindFromExpressionTest(TestBase): val = main_frame.EvaluateExpression("a_function_to_call()", options) - self.assertTrue(val.GetError().Fail(), "We did not complete the execution.") + self.assertTrue( + val.GetError().Fail(), + "We did not complete the execution.") error_str = val.GetError().GetCString() - self.assertTrue("Execution was interrupted, reason: breakpoint" in error_str, "And the reason was right.") - - thread = lldbutil.get_one_thread_stopped_at_breakpoint(process, fun_bkpt) - self.assertTrue(thread.IsValid(), "We are indeed stopped at our breakpoint") - - # Now unwind the expression, and make sure we got back to where we started. + self.assertTrue( + "Execution was interrupted, reason: breakpoint" in error_str, + "And the reason was right.") + + thread = lldbutil.get_one_thread_stopped_at_breakpoint( + process, fun_bkpt) + self.assertTrue( + thread.IsValid(), + "We are indeed stopped at our breakpoint") + + # Now unwind the expression, and make sure we got back to where we + # started. error = thread.UnwindInnermostExpression() self.assertTrue(error.Success(), "We succeeded in unwinding") - - cur_frame = thread.GetFrameAtIndex(0) - self.assertTrue(cur_frame.IsEqual(main_frame), "We got back to the main frame.") + cur_frame = thread.GetFrameAtIndex(0) + self.assertTrue( + cur_frame.IsEqual(main_frame), + "We got back to the main frame.") |