This is an archive of the discontinued LLVM Phabricator instance.

Differential D95899

[lldb] Convert more assertTrue to assertEqual (NFC)
ClosedPublic

Authored by kastiglione on Feb 2 2021, 3:07 PM.

Details

Reviewers
JDevlieghere
teemperor
Commits
rG0ed758b26041: [lldb] Convert more assertTrue to assertEqual (NFC)
Summary

Follow up to D95813, this converts multiline assertTrue to assertEqual.

Diff Detail

Event Timeline

kastiglione requested review of this revision.Feb 2 2021, 3:07 PM
kastiglione created this revision.
Herald added a project: Restricted Project. · View Herald TranscriptFeb 2 2021, 3:07 PM
Herald added a subscriber: lldb-commits. · View Herald Transcript
Harbormaster completed remote builds in B87592: Diff 320920.Feb 3 2021, 3:33 AM
JDevlieghere accepted this revision.Feb 3 2021, 7:49 PM

LGTM

This revision is now accepted and ready to land.Feb 3 2021, 7:49 PM
Closed by commit rG0ed758b26041: [lldb] Convert more assertTrue to assertEqual (NFC) (authored by kastiglione). · Explain WhyFeb 3 2021, 9:15 PM
This revision was automatically updated to reflect the committed changes.
kastiglione added a commit: rG0ed758b26041: [lldb] Convert more assertTrue to assertEqual (NFC).

Revision Contents

PathSize
lldb/
test/
API/
api/
listeners/
8 lines
commands/
disassemble/
basic/
4 lines
expression/
call-restarts/
8 lines
call-throws/
4 lines
frame/
language/
4 lines
var/
4 lines
process/
launch-with-shellexpand/
12 lines
register/
register/
register_command/
4 lines
watchpoints/
watchpoint_events/
4 lines
functionalities/
avoids-fd-leak/
20 lines
breakpoint/
address_breakpoints/
8 lines
breakpoint_hit_count/
8 lines
breakpoint_language/
32 lines
breakpoint_names/
2 lines
source_regexp/
16 lines
data-formatter/
data-formatter-stl/
libcxx/
atomic/
8 lines
list/
8 lines
format-propagation/
12 lines
synthupdate/
16 lines
dynamic_value_child_count/
4 lines
exec/
8 lines
inline-stepping/
12 lines
memory/
read/
9 lines
plugins/
python_os_plugin/
16 lines
signal/
4 lines
step-avoids-no-debug/
4 lines
target-new-solib-notifications/
4 lines
thread/
break_after_join/
4 lines
create_after_attach/
4 lines
create_during_step/
12 lines
exit_during_break/
4 lines
multi_break/
4 lines
thread_specific_break_plus_condition/
4 lines
lang/
c/
array_types/
4 lines
bitfields/
8 lines
stepping/
32 lines
unions/
4 lines
cpp/
breakpoint-commands/
4 lines
class_static/
8 lines
diamond/
4 lines
exceptions/
20 lines
global_operators/
4 lines
gmodules/
16 lines
limit-debug-info/
4 lines
member-and-local-vars-with-same-name/
32 lines
nsimport/
8 lines
template/
32 lines
objc/
blocks/
20 lines
foundation/
4 lines
global_ptrs/
4 lines
objc-baseclass-sbtype/
8 lines
objc-dyn-sbtype/
40 lines
objc-ivar-offsets/
4 lines
objc-ivar-stripped/
4 lines
objc-static-method-stripped/
12 lines
objc-static-method/
12 lines
objc-stepping/
4 lines
single-entry-dictionary/
16 lines
macosx/
indirect_symbol/
20 lines
queues/
32 lines
safe-to-func-call/
4 lines
thread-names/
4 lines
python_api/
event/
4 lines
formatters/
52 lines
frame/
8 lines
lldbutil/
iter/
4 lines
objc_type/
12 lines
sbdata/
40 lines
sbvalue_persist/
16 lines
signals/
8 lines
target/
12 lines
thread/
7 lines
value/
8 lines
change_values/
8 lines
watchpoint/
4 lines
4 lines

Diff 320920

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

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Lines def test_receiving_breakpoint_added_from_debugger(self):
my_listener.WaitForEvent(1, event) my_listener.WaitForEvent(1, event)
self.assertTrue(event.IsValid(), "Got a valid event.") self.assertTrue(event.IsValid(), "Got a valid event.")
self.assertTrue( self.assertTrue(
lldb.SBBreakpoint.EventIsBreakpointEvent(event), lldb.SBBreakpoint.EventIsBreakpointEvent(event),
"It is a breakpoint event.") "It is a breakpoint event.")
self.assertTrue(lldb.SBBreakpoint.GetBreakpointEventTypeFromEvent( self.assertTrue(lldb.SBBreakpoint.GetBreakpointEventTypeFromEvent(
event) == lldb.eBreakpointEventTypeAdded, "It is a breakpoint added event.") event) == lldb.eBreakpointEventTypeAdded, "It is a breakpoint added event.")
self.assertTrue( self.assertEqual(
bkpt == lldb.SBBreakpoint.GetBreakpointFromEvent(event), bkpt, lldb.SBBreakpoint.GetBreakpointFromEvent(event),
"It is our breakpoint.") "It is our breakpoint.")
# Now make sure if we stop listening for events we don't get them: # Now make sure if we stop listening for events we don't get them:
my_listener.StopListeningForEventClass( my_listener.StopListeningForEventClass(
self.dbg, self.dbg,
lldb.SBTarget.GetBroadcasterClassName(), lldb.SBTarget.GetBroadcasterClassName(),
lldb.SBTarget.eBroadcastBitBreakpointChanged) lldb.SBTarget.eBroadcastBitBreakpointChanged)
my_listener.StopListeningForEvents( my_listener.StopListeningForEvents(
Show All 27 Lines def test_recieving_breakpoint_added_from_target(self):
my_listener.WaitForEvent(1, event) my_listener.WaitForEvent(1, event)
self.assertTrue(event.IsValid(), "Got a valid event.") self.assertTrue(event.IsValid(), "Got a valid event.")
self.assertTrue( self.assertTrue(
lldb.SBBreakpoint.EventIsBreakpointEvent(event), lldb.SBBreakpoint.EventIsBreakpointEvent(event),
"It is a breakpoint event.") "It is a breakpoint event.")
self.assertTrue(lldb.SBBreakpoint.GetBreakpointEventTypeFromEvent( self.assertTrue(lldb.SBBreakpoint.GetBreakpointEventTypeFromEvent(
event) == lldb.eBreakpointEventTypeAdded, "It is a breakpoint added event.") event) == lldb.eBreakpointEventTypeAdded, "It is a breakpoint added event.")
self.assertTrue( self.assertEqual(
bkpt == lldb.SBBreakpoint.GetBreakpointFromEvent(event), bkpt, lldb.SBBreakpoint.GetBreakpointFromEvent(event),
"It is our breakpoint.") "It is our breakpoint.")
# Now make sure if we stop listening for events we don't get them: # Now make sure if we stop listening for events we don't get them:
target.GetBroadcaster().RemoveListener(my_listener) target.GetBroadcaster().RemoveListener(my_listener)
bkpt2 = target.BreakpointCreateByName("main") bkpt2 = target.BreakpointCreateByName("main")
my_listener.WaitForEvent(1, event) my_listener.WaitForEvent(1, event)
self.assertTrue(not event.IsValid(), "We don't get events we aren't listening to.") self.assertTrue(not event.IsValid(), "We don't get events we aren't listening to.")

lldb/test/API/commands/disassemble/basic/TestFrameDisassemble.py

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Lines def frame_disassemble_test(self):
launch_info = target.GetLaunchInfo() launch_info = target.GetLaunchInfo()
process = target.Launch(launch_info, error) process = target.Launch(launch_info, error)
self.assertTrue(process, PROCESS_IS_VALID) self.assertTrue(process, PROCESS_IS_VALID)
# Did we hit our breakpoint? # Did we hit our breakpoint?
from lldbsuite.test.lldbutil import get_threads_stopped_at_breakpoint from lldbsuite.test.lldbutil import get_threads_stopped_at_breakpoint
threads = get_threads_stopped_at_breakpoint(process, breakpoint) threads = get_threads_stopped_at_breakpoint(process, breakpoint)
self.assertTrue( self.assertEqual(
len(threads) == 1, len(threads), 1,
"There should be a thread stopped at our breakpoint") "There should be a thread stopped at our breakpoint")
# The hit count for the breakpoint should be 1. # The hit count for the breakpoint should be 1.
self.assertEquals(breakpoint.GetHitCount(), 1) self.assertEquals(breakpoint.GetHitCount(), 1)
frame = threads[0].GetFrameAtIndex(0) frame = threads[0].GetFrameAtIndex(0)
disassembly = frame.Disassemble() disassembly = frame.Disassemble()
self.assertNotEqual(disassembly, "") self.assertNotEqual(disassembly, "")
self.assertNotIn("error", disassembly) self.assertNotIn("error", disassembly)
self.assertIn(": nop", disassembly) self.assertIn(": nop", disassembly)

lldb/test/API/commands/expression/call-restarts/TestCallThatRestarts.py

Show All 36 Lines def check_after_call(self, num_sigchld):
after_call - after_call -
self.start_sigchld_no == num_sigchld, self.start_sigchld_no == num_sigchld,
"Really got %d SIGCHLD signals through the call." % "Really got %d SIGCHLD signals through the call." %
(num_sigchld)) (num_sigchld))
self.start_sigchld_no = after_call self.start_sigchld_no = after_call
# Check that we are back where we were before: # Check that we are back where we were before:
frame = self.thread.GetFrameAtIndex(0) frame = self.thread.GetFrameAtIndex(0)
self.assertTrue( self.assertEqual(
self.orig_frame_pc == frame.GetPC(), self.orig_frame_pc, frame.GetPC(),
"Restored the zeroth frame correctly") "Restored the zeroth frame correctly")
def call_function(self): def call_function(self):
(target, process, self.thread, bkpt) = lldbutil.run_to_source_breakpoint(self, (target, process, self.thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
'Stop here in main.', self.main_source_spec) 'Stop here in main.', self.main_source_spec)
# Make sure the SIGCHLD behavior is pass/no-stop/no-notify: # Make sure the SIGCHLD behavior is pass/no-stop/no-notify:
self.runCmd("process handle SIGCHLD -s 0 -p 1 -n 0") self.runCmd("process handle SIGCHLD -s 0 -p 1 -n 0")
▲ Show 20 Lines • Show All 87 Lines • ▼ Show 20 Lines def call_function(self):
# up back in out starting frame: # up back in out starting frame:
self.runCmd("process handle SIGCHLD -s 0 -p 1 -n 1") self.runCmd("process handle SIGCHLD -s 0 -p 1 -n 1")
error = process.Continue() error = process.Continue()
self.assertSuccess(error, self.assertSuccess(error,
"Continuing after stopping for signal succeeds.") "Continuing after stopping for signal succeeds.")
frame = self.thread.GetFrameAtIndex(0) frame = self.thread.GetFrameAtIndex(0)
self.assertTrue( self.assertEqual(
frame.GetPC() == self.orig_frame_pc, frame.GetPC(), self.orig_frame_pc,
"Continuing returned to the place we started.") "Continuing returned to the place we started.")

lldb/test/API/commands/expression/call-throws/TestCallThatThrows.py

Show All 24 Linesclass ExprCommandWithThrowTestCase(TestBase):
def test(self): def test(self):
"""Test calling a function that throws and ObjC exception.""" """Test calling a function that throws and ObjC exception."""
self.build() self.build()
self.call_function() self.call_function()
def check_after_call(self): def check_after_call(self):
# Check that we are back where we were before: # Check that we are back where we were before:
frame = self.thread.GetFrameAtIndex(0) frame = self.thread.GetFrameAtIndex(0)
self.assertTrue( self.assertEqual(
self.orig_frame_pc == frame.GetPC(), self.orig_frame_pc, frame.GetPC(),
"Restored the zeroth frame correctly") "Restored the zeroth frame correctly")
def call_function(self): def call_function(self):
"""Test calling function that throws.""" """Test calling function that throws."""
(target, process, self.thread, bkpt) = lldbutil.run_to_source_breakpoint(self, (target, process, self.thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
'I am about to throw.', self.main_source_spec) 'I am about to throw.', self.main_source_spec)
options = lldb.SBExpressionOptions() options = lldb.SBExpressionOptions()
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

lldb/test/API/commands/frame/language/TestGuessLanguage.py

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Lines def do_test(self):
launch_info = target.GetLaunchInfo() launch_info = target.GetLaunchInfo()
process = target.Launch(launch_info, error) process = target.Launch(launch_info, error)
self.assertTrue(process, PROCESS_IS_VALID) self.assertTrue(process, PROCESS_IS_VALID)
# Did we hit our breakpoint? # Did we hit our breakpoint?
from lldbsuite.test.lldbutil import get_threads_stopped_at_breakpoint from lldbsuite.test.lldbutil import get_threads_stopped_at_breakpoint
threads = get_threads_stopped_at_breakpoint(process, breakpoint) threads = get_threads_stopped_at_breakpoint(process, breakpoint)
self.assertTrue( self.assertEqual(
len(threads) == 1, len(threads), 1,
"There should be a thread stopped at our breakpoint") "There should be a thread stopped at our breakpoint")
# The hit count for the breakpoint should be 1. # The hit count for the breakpoint should be 1.
self.assertEquals(breakpoint.GetHitCount(), 1) self.assertEquals(breakpoint.GetHitCount(), 1)
thread = threads[0] thread = threads[0]
c_frame_language = lldb.eLanguageTypeC99 c_frame_language = lldb.eLanguageTypeC99
Show All 12 Lines

lldb/test/API/commands/frame/var/TestFrameVar.py

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines def do_test(self):
launch_info = target.GetLaunchInfo() launch_info = target.GetLaunchInfo()
process = target.Launch(launch_info, error) process = target.Launch(launch_info, error)
self.assertTrue(process, PROCESS_IS_VALID) self.assertTrue(process, PROCESS_IS_VALID)
# Did we hit our breakpoint? # Did we hit our breakpoint?
from lldbsuite.test.lldbutil import get_threads_stopped_at_breakpoint from lldbsuite.test.lldbutil import get_threads_stopped_at_breakpoint
threads = get_threads_stopped_at_breakpoint(process, breakpoint) threads = get_threads_stopped_at_breakpoint(process, breakpoint)
self.assertTrue( self.assertEqual(
len(threads) == 1, len(threads), 1,
"There should be a thread stopped at our breakpoint") "There should be a thread stopped at our breakpoint")
# The hit count for the breakpoint should be 1. # The hit count for the breakpoint should be 1.
self.assertEquals(breakpoint.GetHitCount(), 1) self.assertEquals(breakpoint.GetHitCount(), 1)
frame = threads[0].GetFrameAtIndex(0) frame = threads[0].GetFrameAtIndex(0)
command_result = lldb.SBCommandReturnObject() command_result = lldb.SBCommandReturnObject()
interp = self.dbg.GetCommandInterpreter() interp = self.dbg.GetCommandInterpreter()
Show All 30 Lines

lldb/test/API/commands/process/launch-with-shellexpand/TestLaunchWithShellExpand.py

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines def test(self):
thread = process.GetThreadAtIndex(0) thread = process.GetThreadAtIndex(0)
self.assertTrue(thread.IsValid(), self.assertTrue(thread.IsValid(),
"Process stopped at 'main' should have a valid thread") "Process stopped at 'main' should have a valid thread")
stop_reason = thread.GetStopReason() stop_reason = thread.GetStopReason()
self.assertTrue( self.assertEqual(
stop_reason == lldb.eStopReasonBreakpoint, stop_reason, lldb.eStopReasonBreakpoint,
"Thread in process stopped in 'main' should have a stop reason of eStopReasonBreakpoint") "Thread in process stopped in 'main' should have a stop reason of eStopReasonBreakpoint")
self.expect_var_path("argv[1]", summary='"file1.txt"') self.expect_var_path("argv[1]", summary='"file1.txt"')
self.expect_var_path("argv[2]", summary='"file2.txt"') self.expect_var_path("argv[2]", summary='"file2.txt"')
self.expect_var_path("argv[3]", summary='"file3.txt"') self.expect_var_path("argv[3]", summary='"file3.txt"')
self.expect_var_path("argv[4]", summary='"file4.txy"') self.expect_var_path("argv[4]", summary='"file4.txy"')
self.expect_var_path("argv[5]", summary='"()"') self.expect_var_path("argv[5]", summary='"()"')
self.expect_var_path("argv[6]", summary='">"') self.expect_var_path("argv[6]", summary='">"')
Show All 13 Lines def test(self):
thread = process.GetThreadAtIndex(0) thread = process.GetThreadAtIndex(0)
self.assertTrue(thread.IsValid(), self.assertTrue(thread.IsValid(),
"Process stopped at 'main' should have a valid thread") "Process stopped at 'main' should have a valid thread")
stop_reason = thread.GetStopReason() stop_reason = thread.GetStopReason()
self.assertTrue( self.assertEqual(
stop_reason == lldb.eStopReasonBreakpoint, stop_reason, lldb.eStopReasonBreakpoint,
"Thread in process stopped in 'main' should have a stop reason of eStopReasonBreakpoint") "Thread in process stopped in 'main' should have a stop reason of eStopReasonBreakpoint")
self.expect("frame variable argv[1]", substrs=['foo bar']) self.expect("frame variable argv[1]", substrs=['foo bar'])
self.runCmd("process kill") self.runCmd("process kill")
self.runCmd('process launch -X true -w %s -- foo\ bar' self.runCmd('process launch -X true -w %s -- foo\ bar'
% (self.getBuildDir())) % (self.getBuildDir()))
process = self.process() process = self.process()
self.assertEquals(process.GetState(), lldb.eStateStopped, self.assertEquals(process.GetState(), lldb.eStateStopped,
STOPPED_DUE_TO_BREAKPOINT) STOPPED_DUE_TO_BREAKPOINT)
thread = process.GetThreadAtIndex(0) thread = process.GetThreadAtIndex(0)
self.assertTrue(thread.IsValid(), self.assertTrue(thread.IsValid(),
"Process stopped at 'main' should have a valid thread") "Process stopped at 'main' should have a valid thread")
stop_reason = thread.GetStopReason() stop_reason = thread.GetStopReason()
self.assertTrue( self.assertEqual(
stop_reason == lldb.eStopReasonBreakpoint, stop_reason, lldb.eStopReasonBreakpoint,
"Thread in process stopped in 'main' should have a stop reason of eStopReasonBreakpoint") "Thread in process stopped in 'main' should have a stop reason of eStopReasonBreakpoint")
self.expect("frame variable argv[1]", substrs=['foo bar']) self.expect("frame variable argv[1]", substrs=['foo bar'])

lldb/test/API/commands/register/register/register_command/TestRegisters.py

Show First 20 Lines • Show All 291 Lines • ▼ Show 20 Lines def fp_register_write(self):
None, None, # argv, envp None, None, # argv, envp
None, None, None, # stdin/out/err None, None, None, # stdin/out/err
self.get_process_working_directory(), self.get_process_working_directory(),
flags, # launch flags flags, # launch flags
True, # stop at entry True, # stop at entry
error) error)
self.assertSuccess(error, "Launch succeeds") self.assertSuccess(error, "Launch succeeds")
self.assertTrue( self.assertEqual(
process.GetState() == lldb.eStateStopped, process.GetState(), lldb.eStateStopped,
PROCESS_STOPPED) PROCESS_STOPPED)
thread = process.GetThreadAtIndex(0) thread = process.GetThreadAtIndex(0)
self.assertTrue(thread.IsValid(), "current thread is valid") self.assertTrue(thread.IsValid(), "current thread is valid")
currentFrame = thread.GetFrameAtIndex(0) currentFrame = thread.GetFrameAtIndex(0)
self.assertTrue(currentFrame.IsValid(), "current frame is valid") self.assertTrue(currentFrame.IsValid(), "current frame is valid")
▲ Show 20 Lines • Show All 202 Lines • Show Last 20 Lines

lldb/test/API/commands/watchpoints/watchpoint_events/TestWatchpointEvents.py

Show First 20 Lines • Show All 90 Lines • ▼ Show 20 Lines def GetWatchpointEvent(self, event_type):
# We added a watchpoint so we should get a watchpoint added event. # We added a watchpoint so we should get a watchpoint added event.
event = lldb.SBEvent() event = lldb.SBEvent()
success = self.listener.WaitForEvent(1, event) success = self.listener.WaitForEvent(1, event)
self.assertTrue(success, "Successfully got watchpoint event") self.assertTrue(success, "Successfully got watchpoint event")
self.assertTrue( self.assertTrue(
lldb.SBWatchpoint.EventIsWatchpointEvent(event), lldb.SBWatchpoint.EventIsWatchpointEvent(event),
"Event is a watchpoint event.") "Event is a watchpoint event.")
found_type = lldb.SBWatchpoint.GetWatchpointEventTypeFromEvent(event) found_type = lldb.SBWatchpoint.GetWatchpointEventTypeFromEvent(event)
self.assertTrue( self.assertEqual(
found_type == event_type, found_type, event_type,
"Event is not correct type, expected: %d, found: %d" % "Event is not correct type, expected: %d, found: %d" %
(event_type, (event_type,
found_type)) found_type))
# There shouldn't be another event waiting around: # There shouldn't be another event waiting around:
found_event = self.listener.PeekAtNextEventForBroadcasterWithType( found_event = self.listener.PeekAtNextEventForBroadcasterWithType(
self.target_bcast, lldb.SBTarget.eBroadcastBitBreakpointChanged, event) self.target_bcast, lldb.SBTarget.eBroadcastBitBreakpointChanged, event)
if found_event: if found_event:
print("Found an event I didn't expect: ", event) print("Found an event I didn't expect: ", event)
self.assertTrue(not found_event, "Only one event per change.") self.assertTrue(not found_event, "Only one event per change.")

lldb/test/API/functionalities/avoids-fd-leak/TestFdLeak.py

Show All 39 Lines def do_test(self, commands):
self.runCmd(c) self.runCmd(c)
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
process = target.LaunchSimple( process = target.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
self.assertTrue(process, PROCESS_IS_VALID) self.assertTrue(process, PROCESS_IS_VALID)
self.assertTrue( self.assertEqual(
process.GetState() == lldb.eStateExited, process.GetState(), lldb.eStateExited,
"Process should have exited.") "Process should have exited.")
self.assertTrue( self.assertEqual(
process.GetExitStatus() == 0, process.GetExitStatus(), 0,
"Process returned non-zero status. Were incorrect file descriptors passed?") "Process returned non-zero status. Were incorrect file descriptors passed?")
# The check for descriptor leakage needs to be implemented differently # The check for descriptor leakage needs to be implemented differently
# here. # here.
@skipIfWindows @skipIfWindows
@skipIfTargetAndroid() # Android have some other file descriptors open by the shell @skipIfTargetAndroid() # Android have some other file descriptors open by the shell
@skipIfDarwinEmbedded # <rdar://problem/33888742> # debugserver on ios has an extra fd open on launch @skipIfDarwinEmbedded # <rdar://problem/33888742> # debugserver on ios has an extra fd open on launch
def test_fd_leak_multitarget(self): def test_fd_leak_multitarget(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getBuildArtifact("a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
breakpoint = target.BreakpointCreateBySourceRegex( breakpoint = target.BreakpointCreateBySourceRegex(
'Set breakpoint here', lldb.SBFileSpec("main.c", False)) 'Set breakpoint here', lldb.SBFileSpec("main.c", False))
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
process1 = target.LaunchSimple( process1 = target.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
self.assertTrue(process1, PROCESS_IS_VALID) self.assertTrue(process1, PROCESS_IS_VALID)
self.assertTrue( self.assertEqual(
process1.GetState() == lldb.eStateStopped, process1.GetState(), lldb.eStateStopped,
"Process should have been stopped.") "Process should have been stopped.")
target2 = self.dbg.CreateTarget(exe) target2 = self.dbg.CreateTarget(exe)
process2 = target2.LaunchSimple( process2 = target2.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
self.assertTrue(process2, PROCESS_IS_VALID) self.assertTrue(process2, PROCESS_IS_VALID)
self.assertTrue( self.assertEqual(
process2.GetState() == lldb.eStateExited, process2.GetState(), lldb.eStateExited,
"Process should have exited.") "Process should have exited.")
self.assertTrue( self.assertEqual(
process2.GetExitStatus() == 0, process2.GetExitStatus(), 0,
"Process returned non-zero status. Were incorrect file descriptors passed?") "Process returned non-zero status. Were incorrect file descriptors passed?")

lldb/test/API/functionalities/breakpoint/address_breakpoints/TestAddressBreakpoints.py

Show First 20 Lines • Show All 61 Lines • ▼ Show 20 Lines def address_breakpoints(self):
error = lldb.SBError() error = lldb.SBError()
process = target.Launch(launch_info, error) process = target.Launch(launch_info, error)
self.assertTrue(process, PROCESS_IS_VALID) self.assertTrue(process, PROCESS_IS_VALID)
# Did we hit our breakpoint? # Did we hit our breakpoint?
from lldbsuite.test.lldbutil import get_threads_stopped_at_breakpoint from lldbsuite.test.lldbutil import get_threads_stopped_at_breakpoint
threads = get_threads_stopped_at_breakpoint(process, breakpoint) threads = get_threads_stopped_at_breakpoint(process, breakpoint)
self.assertTrue( self.assertEqual(
len(threads) == 1, len(threads), 1,
"There should be a thread stopped at our breakpoint") "There should be a thread stopped at our breakpoint")
# The hit count for the breakpoint should be 1. # The hit count for the breakpoint should be 1.
self.assertEquals(breakpoint.GetHitCount(), 1) self.assertEquals(breakpoint.GetHitCount(), 1)
process.Kill() process.Kill()
# Now re-launch and see that we hit the breakpoint again: # Now re-launch and see that we hit the breakpoint again:
launch_info.Clear() launch_info.Clear()
launch_info.SetLaunchFlags(flags) launch_info.SetLaunchFlags(flags)
process = target.Launch(launch_info, error) process = target.Launch(launch_info, error)
self.assertTrue(process, PROCESS_IS_VALID) self.assertTrue(process, PROCESS_IS_VALID)
thread = get_threads_stopped_at_breakpoint(process, breakpoint) thread = get_threads_stopped_at_breakpoint(process, breakpoint)
self.assertTrue( self.assertEqual(
len(threads) == 1, len(threads), 1,
"There should be a thread stopped at our breakpoint") "There should be a thread stopped at our breakpoint")
# The hit count for the breakpoint should now be 2. # The hit count for the breakpoint should now be 2.
self.assertEquals(breakpoint.GetHitCount(), 2) self.assertEquals(breakpoint.GetHitCount(), 2)

lldb/test/API/functionalities/breakpoint/breakpoint_hit_count/TestBreakpointHitCount.py

Show First 20 Lines • Show All 87 Lines • ▼ Show 20 Lines def do_test_breakpoint_location_hit_count(self):
from lldbsuite.test.lldbutil import get_stopped_thread from lldbsuite.test.lldbutil import get_stopped_thread
thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint) thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint)
self.assertTrue( self.assertTrue(
thread.IsValid(), thread.IsValid(),
"There should be a thread stopped due to breakpoint") "There should be a thread stopped due to breakpoint")
frame0 = thread.GetFrameAtIndex(0) frame0 = thread.GetFrameAtIndex(0)
location1 = breakpoint.FindLocationByAddress(frame0.GetPC()) location1 = breakpoint.FindLocationByAddress(frame0.GetPC())
self.assertTrue( self.assertEqual(
frame0.GetLineEntry().GetLine() == self.a_int_body_line_no, frame0.GetLineEntry().GetLine(), self.a_int_body_line_no,
"Stopped in int a(int)") "Stopped in int a(int)")
self.assertTrue(location1) self.assertTrue(location1)
self.assertEqual(location1.GetHitCount(), 1) self.assertEqual(location1.GetHitCount(), 1)
self.assertEqual(breakpoint.GetHitCount(), 1) self.assertEqual(breakpoint.GetHitCount(), 1)
process.Continue() process.Continue()
# Verify 2nd breakpoint location is hit. # Verify 2nd breakpoint location is hit.
thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint) thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint)
self.assertTrue( self.assertTrue(
thread.IsValid(), thread.IsValid(),
"There should be a thread stopped due to breakpoint") "There should be a thread stopped due to breakpoint")
frame0 = thread.GetFrameAtIndex(0) frame0 = thread.GetFrameAtIndex(0)
location2 = breakpoint.FindLocationByAddress(frame0.GetPC()) location2 = breakpoint.FindLocationByAddress(frame0.GetPC())
self.assertTrue( self.assertEqual(
frame0.GetLineEntry().GetLine() == self.a_float_body_line_no, frame0.GetLineEntry().GetLine(), self.a_float_body_line_no,
"Stopped in float a(float)") "Stopped in float a(float)")
self.assertTrue(location2) self.assertTrue(location2)
self.assertEqual(location2.GetHitCount(), 1) self.assertEqual(location2.GetHitCount(), 1)
self.assertEqual(location1.GetHitCount(), 1) self.assertEqual(location1.GetHitCount(), 1)
self.assertEqual(breakpoint.GetHitCount(), 2) self.assertEqual(breakpoint.GetHitCount(), 2)
process.Continue() process.Continue()
Show All 11 Lines

lldb/test/API/functionalities/breakpoint/breakpoint_language/TestBreakpointLanguage.py

Show All 32 Lines def test_regex_breakpoint_language(self):
self.target = self.dbg.CreateTarget(exe, None, None, False, error) self.target = self.dbg.CreateTarget(exe, None, None, False, error)
self.assertTrue(self.target, VALID_TARGET) self.assertTrue(self.target, VALID_TARGET)
cpp_bp = self.target.BreakpointCreateByRegex( cpp_bp = self.target.BreakpointCreateByRegex(
"func_from", "func_from",
lldb.eLanguageTypeC_plus_plus, lldb.eLanguageTypeC_plus_plus,
lldb.SBFileSpecList(), lldb.SBFileSpecList(),
lldb.SBFileSpecList()) lldb.SBFileSpecList())
self.assertTrue( self.assertEqual(
cpp_bp.GetNumLocations() == 1, cpp_bp.GetNumLocations(), 1,
"Only one C++ symbol matches") "Only one C++ symbol matches")
self.assertTrue(self.check_location_file(cpp_bp, 0, "b.cpp")) self.assertTrue(self.check_location_file(cpp_bp, 0, "b.cpp"))
c_bp = self.target.BreakpointCreateByRegex( c_bp = self.target.BreakpointCreateByRegex(
"func_from", "func_from",
lldb.eLanguageTypeC, lldb.eLanguageTypeC,
lldb.SBFileSpecList(), lldb.SBFileSpecList(),
lldb.SBFileSpecList()) lldb.SBFileSpecList())
self.assertTrue( self.assertEqual(
c_bp.GetNumLocations() == 1, c_bp.GetNumLocations(), 1,
"Only one C symbol matches") "Only one C symbol matches")
self.assertTrue(self.check_location_file(c_bp, 0, "a.c")) self.assertTrue(self.check_location_file(c_bp, 0, "a.c"))
objc_bp = self.target.BreakpointCreateByRegex( objc_bp = self.target.BreakpointCreateByRegex(
"func_from", "func_from",
lldb.eLanguageTypeObjC, lldb.eLanguageTypeObjC,
lldb.SBFileSpecList(), lldb.SBFileSpecList(),
lldb.SBFileSpecList()) lldb.SBFileSpecList())
self.assertTrue( self.assertEqual(
objc_bp.GetNumLocations() == 0, objc_bp.GetNumLocations(), 0,
"No ObjC symbol matches") "No ObjC symbol matches")
def test_by_name_breakpoint_language(self): def test_by_name_breakpoint_language(self):
"""Test that the name regex breakpoint commands obey the language filter.""" """Test that the name regex breakpoint commands obey the language filter."""
self.build() self.build()
# Create a target by the debugger. # Create a target by the debugger.
exe = self.getBuildArtifact("a.out") exe = self.getBuildArtifact("a.out")
error = lldb.SBError() error = lldb.SBError()
# Don't read in dependencies so we don't come across false matches that # Don't read in dependencies so we don't come across false matches that
# add unwanted breakpoint hits. # add unwanted breakpoint hits.
self.target = self.dbg.CreateTarget(exe, None, None, False, error) self.target = self.dbg.CreateTarget(exe, None, None, False, error)
self.assertTrue(self.target, VALID_TARGET) self.assertTrue(self.target, VALID_TARGET)
cpp_bp = self.target.BreakpointCreateByName( cpp_bp = self.target.BreakpointCreateByName(
"func_from_cpp", "func_from_cpp",
lldb.eFunctionNameTypeAuto, lldb.eFunctionNameTypeAuto,
lldb.eLanguageTypeC_plus_plus, lldb.eLanguageTypeC_plus_plus,
lldb.SBFileSpecList(), lldb.SBFileSpecList(),
lldb.SBFileSpecList()) lldb.SBFileSpecList())
self.assertTrue( self.assertEqual(
cpp_bp.GetNumLocations() == 1, cpp_bp.GetNumLocations(), 1,
"Only one C++ symbol matches") "Only one C++ symbol matches")
self.assertTrue(self.check_location_file(cpp_bp, 0, "b.cpp")) self.assertTrue(self.check_location_file(cpp_bp, 0, "b.cpp"))
no_cpp_bp = self.target.BreakpointCreateByName( no_cpp_bp = self.target.BreakpointCreateByName(
"func_from_c", "func_from_c",
lldb.eFunctionNameTypeAuto, lldb.eFunctionNameTypeAuto,
lldb.eLanguageTypeC_plus_plus, lldb.eLanguageTypeC_plus_plus,
lldb.SBFileSpecList(), lldb.SBFileSpecList(),
lldb.SBFileSpecList()) lldb.SBFileSpecList())
self.assertTrue( self.assertEqual(
no_cpp_bp.GetNumLocations() == 0, no_cpp_bp.GetNumLocations(), 0,
"And the C one doesn't match") "And the C one doesn't match")
c_bp = self.target.BreakpointCreateByName( c_bp = self.target.BreakpointCreateByName(
"func_from_c", "func_from_c",
lldb.eFunctionNameTypeAuto, lldb.eFunctionNameTypeAuto,
lldb.eLanguageTypeC, lldb.eLanguageTypeC,
lldb.SBFileSpecList(), lldb.SBFileSpecList(),
lldb.SBFileSpecList()) lldb.SBFileSpecList())
self.assertTrue( self.assertEqual(
c_bp.GetNumLocations() == 1, c_bp.GetNumLocations(), 1,
"Only one C symbol matches") "Only one C symbol matches")
self.assertTrue(self.check_location_file(c_bp, 0, "a.c")) self.assertTrue(self.check_location_file(c_bp, 0, "a.c"))
no_c_bp = self.target.BreakpointCreateByName( no_c_bp = self.target.BreakpointCreateByName(
"func_from_cpp", "func_from_cpp",
lldb.eFunctionNameTypeAuto, lldb.eFunctionNameTypeAuto,
lldb.eLanguageTypeC, lldb.eLanguageTypeC,
lldb.SBFileSpecList(), lldb.SBFileSpecList(),
lldb.SBFileSpecList()) lldb.SBFileSpecList())
self.assertTrue( self.assertEqual(
no_c_bp.GetNumLocations() == 0, no_c_bp.GetNumLocations(), 0,
"And the C++ one doesn't match") "And the C++ one doesn't match")
objc_bp = self.target.BreakpointCreateByName( objc_bp = self.target.BreakpointCreateByName(
"func_from_cpp", "func_from_cpp",
lldb.eFunctionNameTypeAuto, lldb.eFunctionNameTypeAuto,
lldb.eLanguageTypeObjC, lldb.eLanguageTypeObjC,
lldb.SBFileSpecList(), lldb.SBFileSpecList(),
lldb.SBFileSpecList()) lldb.SBFileSpecList())
self.assertTrue( self.assertEqual(
objc_bp.GetNumLocations() == 0, objc_bp.GetNumLocations(), 0,
"No ObjC symbol matches") "No ObjC symbol matches")

lldb/test/API/functionalities/breakpoint/breakpoint_names/TestBreakpointNames.py

Show First 20 Lines • Show All 209 Lines • ▼ Show 20 Lines def make_a_dummy_name(self):
self.dbg.GetDummyTarget().DeleteBreakpointName(self.bp_name_string) self.dbg.GetDummyTarget().DeleteBreakpointName(self.bp_name_string)
# Execute the cleanup function during test case tear down. # Execute the cleanup function during test case tear down.
self.addTearDownHook(cleanup) self.addTearDownHook(cleanup)
# Now find it in the dummy target, and make sure these settings took: # Now find it in the dummy target, and make sure these settings took:
bp_name = lldb.SBBreakpointName(dummy_target, self.bp_name_string) bp_name = lldb.SBBreakpointName(dummy_target, self.bp_name_string)
# Make sure the name is right: # Make sure the name is right:
self.assertTrue (bp_name.GetName() == self.bp_name_string, "Wrong bp_name: %s"%(bp_name.GetName())) self.assertEqual(bp_name.GetName(), self.bp_name_string, "Wrong bp_name: %s"%(bp_name.GetName()))
bp_name.SetOneShot(self.is_one_shot) bp_name.SetOneShot(self.is_one_shot)
bp_name.SetIgnoreCount(self.ignore_count) bp_name.SetIgnoreCount(self.ignore_count)
bp_name.SetCondition(self.condition) bp_name.SetCondition(self.condition)
bp_name.SetAutoContinue(self.auto_continue) bp_name.SetAutoContinue(self.auto_continue)
bp_name.SetThreadID(self.tid) bp_name.SetThreadID(self.tid)
bp_name.SetThreadIndex(self.tidx) bp_name.SetThreadIndex(self.tidx)
bp_name.SetThreadName(self.thread_name) bp_name.SetThreadName(self.thread_name)
bp_name.SetQueueName(self.queue_name) bp_name.SetQueueName(self.queue_name)
▲ Show 20 Lines • Show All 144 Lines • Show Last 20 Lines

lldb/test/API/functionalities/breakpoint/source_regexp/TestSourceRegexBreakpoints.py

Show All 34 Lines def source_regex_locations(self):
func_names = lldb.SBStringList() func_names = lldb.SBStringList()
func_names.AppendString("a_func") func_names.AppendString("a_func")
source_regex = "Set . breakpoint here" source_regex = "Set . breakpoint here"
main_break = target.BreakpointCreateBySourceRegex( main_break = target.BreakpointCreateBySourceRegex(
source_regex, lldb.SBFileSpecList(), target_files, func_names) source_regex, lldb.SBFileSpecList(), target_files, func_names)
num_locations = main_break.GetNumLocations() num_locations = main_break.GetNumLocations()
self.assertTrue( self.assertEqual(
num_locations == 1, num_locations, 1,
"a.c in a_func should give one breakpoint, got %d." % "a.c in a_func should give one breakpoint, got %d." %
(num_locations)) (num_locations))
loc = main_break.GetLocationAtIndex(0) loc = main_break.GetLocationAtIndex(0)
self.assertTrue(loc.IsValid(), "Got a valid location.") self.assertTrue(loc.IsValid(), "Got a valid location.")
address = loc.GetAddress() address = loc.GetAddress()
self.assertTrue( self.assertTrue(
address.IsValid(), address.IsValid(),
Show All 15 Lines def source_regex_restrictions(self):
# First look just in main: # First look just in main:
target_files = lldb.SBFileSpecList() target_files = lldb.SBFileSpecList()
target_files.Append(lldb.SBFileSpec("main.c")) target_files.Append(lldb.SBFileSpec("main.c"))
source_regex = "Set . breakpoint here" source_regex = "Set . breakpoint here"
main_break = target.BreakpointCreateBySourceRegex( main_break = target.BreakpointCreateBySourceRegex(
source_regex, lldb.SBFileSpecList(), target_files, lldb.SBStringList()) source_regex, lldb.SBFileSpecList(), target_files, lldb.SBStringList())
num_locations = main_break.GetNumLocations() num_locations = main_break.GetNumLocations()
self.assertTrue( self.assertEqual(
num_locations == 2, num_locations, 2,
"main.c should have 2 matches, got %d." % "main.c should have 2 matches, got %d." %
(num_locations)) (num_locations))
# Now look in both files: # Now look in both files:
target_files.Append(lldb.SBFileSpec("a.c")) target_files.Append(lldb.SBFileSpec("a.c"))
main_break = target.BreakpointCreateBySourceRegex( main_break = target.BreakpointCreateBySourceRegex(
source_regex, lldb.SBFileSpecList(), target_files, lldb.SBStringList()) source_regex, lldb.SBFileSpecList(), target_files, lldb.SBStringList())
num_locations = main_break.GetNumLocations() num_locations = main_break.GetNumLocations()
self.assertTrue( self.assertEqual(
num_locations == 4, num_locations, 4,
"main.c and a.c should have 4 matches, got %d." % "main.c and a.c should have 4 matches, got %d." %
(num_locations)) (num_locations))
# Now restrict it to functions: # Now restrict it to functions:
func_names = lldb.SBStringList() func_names = lldb.SBStringList()
func_names.AppendString("main_func") func_names.AppendString("main_func")
main_break = target.BreakpointCreateBySourceRegex( main_break = target.BreakpointCreateBySourceRegex(
source_regex, lldb.SBFileSpecList(), target_files, func_names) source_regex, lldb.SBFileSpecList(), target_files, func_names)
num_locations = main_break.GetNumLocations() num_locations = main_break.GetNumLocations()
self.assertTrue( self.assertEqual(
num_locations == 2, num_locations, 2,
"main_func in main.c and a.c should have 2 matches, got %d." % "main_func in main.c and a.c should have 2 matches, got %d." %
(num_locations)) (num_locations))

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/atomic/TestLibCxxAtomic.py

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines def test(self):
# Extract the content of the std::atomic wrappers. # Extract the content of the std::atomic wrappers.
self.assertEqual(s_atomic.GetNumChildren(), 1) self.assertEqual(s_atomic.GetNumChildren(), 1)
s = s_atomic.GetChildAtIndex(0) s = s_atomic.GetChildAtIndex(0)
self.assertEqual(i_atomic.GetNumChildren(), 1) self.assertEqual(i_atomic.GetNumChildren(), 1)
i = i_atomic.GetChildAtIndex(0) i = i_atomic.GetChildAtIndex(0)
self.assertEqual(i.GetValueAsUnsigned(0), 5, "i == 5") self.assertEqual(i.GetValueAsUnsigned(0), 5, "i == 5")
self.assertEqual(s.GetNumChildren(), 2, "s has two children") self.assertEqual(s.GetNumChildren(), 2, "s has two children")
self.assertTrue( self.assertEqual(
s.GetChildAtIndex(0).GetValueAsUnsigned(0) == 1, s.GetChildAtIndex(0).GetValueAsUnsigned(0), 1,
"s.x == 1") "s.x == 1")
self.assertTrue( self.assertEqual(
s.GetChildAtIndex(1).GetValueAsUnsigned(0) == 2, s.GetChildAtIndex(1).GetValueAsUnsigned(0), 2,
"s.y == 2") "s.y == 2")
# Try printing the child that points to its own parent object. # Try printing the child that points to its own parent object.
# This should just treat the atomic pointer as a normal pointer. # This should just treat the atomic pointer as a normal pointer.
self.expect("frame var p.child", substrs=["Value = 0x"]) self.expect("frame var p.child", substrs=["Value = 0x"])
self.expect("frame var p", substrs=["parent = {", "Value = 0x", "}"]) self.expect("frame var p", substrs=["parent = {", "Value = 0x", "}"])
self.expect("frame var p.child.parent", substrs=["p.child.parent = {\n Value = 0x"]) self.expect("frame var p.child.parent", substrs=["p.child.parent = {\n Value = 0x"])

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/list/TestDataFormatterLibcxxList.py

Show First 20 Lines • Show All 206 Lines • ▼ Show 20 Lines def test_with_run_command(self):
self.assertTrue(countingList.GetChildAtIndex( self.assertTrue(countingList.GetChildAtIndex(
0).GetValueAsUnsigned(0) == 3141, "list[0] == 3141") 0).GetValueAsUnsigned(0) == 3141, "list[0] == 3141")
self.assertTrue(countingList.GetChildAtIndex( self.assertTrue(countingList.GetChildAtIndex(
1).GetValueAsUnsigned(0) == 3141, "list[1] == 3141") 1).GetValueAsUnsigned(0) == 3141, "list[1] == 3141")
self.runCmd("continue") self.runCmd("continue")
self.assertTrue( self.assertEqual(
countingList.GetChildAtIndex(0).GetValueAsUnsigned(0) == 3141, countingList.GetChildAtIndex(0).GetValueAsUnsigned(0), 3141,
"uniqued list[0] == 3141") "uniqued list[0] == 3141")
self.assertTrue( self.assertEqual(
countingList.GetChildAtIndex(1).GetValueAsUnsigned(0) == 3142, countingList.GetChildAtIndex(1).GetValueAsUnsigned(0), 3142,
"uniqued list[1] == 3142") "uniqued list[1] == 3142")

lldb/test/API/functionalities/data-formatter/format-propagation/TestFormatPropagation.py

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines def test_with_run_command(self):
self.assertTrue(X is not None and X.IsValid(), "could not find X") self.assertTrue(X is not None and X.IsValid(), "could not find X")
Y = parent.GetChildMemberWithName("Y") Y = parent.GetChildMemberWithName("Y")
self.assertTrue(Y is not None and Y.IsValid(), "could not find Y") self.assertTrue(Y is not None and Y.IsValid(), "could not find Y")
# check their values now # check their values now
self.assertEquals(X.GetValue(), "1", "X has an invalid value") self.assertEquals(X.GetValue(), "1", "X has an invalid value")
self.assertEquals(Y.GetValue(), "2", "Y has an invalid value") self.assertEquals(Y.GetValue(), "2", "Y has an invalid value")
# set the format on the parent # set the format on the parent
parent.SetFormat(lldb.eFormatHex) parent.SetFormat(lldb.eFormatHex)
self.assertTrue( self.assertEqual(
X.GetValue() == "0x00000001", X.GetValue(), "0x00000001",
"X has not changed format") "X has not changed format")
self.assertTrue( self.assertEqual(
Y.GetValue() == "0x00000002", Y.GetValue(), "0x00000002",
"Y has not changed format") "Y has not changed format")
# Step and check if the values make sense still # Step and check if the values make sense still
self.runCmd("next") self.runCmd("next")
self.assertEquals(X.GetValue(), "0x00000004", "X has not become 4") self.assertEquals(X.GetValue(), "0x00000004", "X has not become 4")
self.assertEquals(Y.GetValue(), "0x00000002", "Y has not stuck as hex") self.assertEquals(Y.GetValue(), "0x00000002", "Y has not stuck as hex")
# Check that children can still make their own choices # Check that children can still make their own choices
Y.SetFormat(lldb.eFormatDecimal) Y.SetFormat(lldb.eFormatDecimal)
self.assertEquals(X.GetValue(), "0x00000004", "X is still hex") self.assertEquals(X.GetValue(), "0x00000004", "X is still hex")
self.assertEquals(Y.GetValue(), "2", "Y has not been reset") self.assertEquals(Y.GetValue(), "2", "Y has not been reset")
# Make a few more changes # Make a few more changes
parent.SetFormat(lldb.eFormatDefault) parent.SetFormat(lldb.eFormatDefault)
X.SetFormat(lldb.eFormatHex) X.SetFormat(lldb.eFormatHex)
Y.SetFormat(lldb.eFormatDefault) Y.SetFormat(lldb.eFormatDefault)
self.assertTrue( self.assertEqual(
X.GetValue() == "0x00000004", X.GetValue(), "0x00000004",
"X is not hex as it asked") "X is not hex as it asked")
self.assertEquals(Y.GetValue(), "2", "Y is not defaulted") self.assertEquals(Y.GetValue(), "2", "Y is not defaulted")

lldb/test/API/functionalities/data-formatter/synthupdate/TestSyntheticFilterRecompute.py

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Lines def test_rdar12437442_with_run_command(self):
id_x = self.dbg.GetSelectedTarget().GetProcess( id_x = self.dbg.GetSelectedTarget().GetProcess(
).GetSelectedThread().GetSelectedFrame().FindVariable("x") ).GetSelectedThread().GetSelectedFrame().FindVariable("x")
id_x.SetPreferDynamicValue(lldb.eDynamicCanRunTarget) id_x.SetPreferDynamicValue(lldb.eDynamicCanRunTarget)
id_x.SetPreferSyntheticValue(True) id_x.SetPreferSyntheticValue(True)
if self.TraceOn(): if self.TraceOn():
self.runCmd("expr --dynamic-type run-target --ptr-depth 1 -- x") self.runCmd("expr --dynamic-type run-target --ptr-depth 1 -- x")
self.assertTrue( self.assertEqual(
id_x.GetSummary() == '@"5 elements"', id_x.GetSummary(), '@"5 elements"',
"array does not get correct summary") "array does not get correct summary")
self.runCmd("next") self.runCmd("next")
self.runCmd("frame select 0") self.runCmd("frame select 0")
id_x = self.dbg.GetSelectedTarget().GetProcess( id_x = self.dbg.GetSelectedTarget().GetProcess(
).GetSelectedThread().GetSelectedFrame().FindVariable("x") ).GetSelectedThread().GetSelectedFrame().FindVariable("x")
id_x.SetPreferDynamicValue(lldb.eDynamicCanRunTarget) id_x.SetPreferDynamicValue(lldb.eDynamicCanRunTarget)
id_x.SetPreferSyntheticValue(True) id_x.SetPreferSyntheticValue(True)
if self.TraceOn(): if self.TraceOn():
self.runCmd("expr --dynamic-type run-target --ptr-depth 1 -- x") self.runCmd("expr --dynamic-type run-target --ptr-depth 1 -- x")
self.assertTrue( self.assertEqual(
id_x.GetNumChildren() == 7, id_x.GetNumChildren(), 7,
"dictionary does not have 7 children") "dictionary does not have 7 children")
id_x.SetPreferSyntheticValue(False) id_x.SetPreferSyntheticValue(False)
self.assertFalse( self.assertNotEqual(
id_x.GetNumChildren() == 7, id_x.GetNumChildren(), 7,
"dictionary still looks synthetic") "dictionary still looks synthetic")
id_x.SetPreferSyntheticValue(True) id_x.SetPreferSyntheticValue(True)
self.assertTrue( self.assertEqual(
id_x.GetSummary() == "7 key/value pairs", id_x.GetSummary(), "7 key/value pairs",
"dictionary does not get correct summary") "dictionary does not get correct summary")

lldb/test/API/functionalities/dynamic_value_child_count/TestDynamicValueChildCount.py

Show First 20 Lines • Show All 69 Lines • ▼ Show 20 Lines def test_get_dynamic_vals(self):
b = self.frame().FindVariable("b").GetDynamicValue(lldb.eDynamicCanRunTarget) b = self.frame().FindVariable("b").GetDynamicValue(lldb.eDynamicCanRunTarget)
self.assertEquals(b.GetNumChildren(), 0, "b has 0 children") self.assertEquals(b.GetNumChildren(), 0, "b has 0 children")
self.runCmd("continue") self.runCmd("continue")
self.assertEquals(b.GetNumChildren(), 0, "b still has 0 children") self.assertEquals(b.GetNumChildren(), 0, "b still has 0 children")
self.runCmd("continue") self.runCmd("continue")
self.assertNotEqual(b.GetNumChildren(), 0, "b now has 1 child") self.assertNotEqual(b.GetNumChildren(), 0, "b now has 1 child")
self.runCmd("continue") self.runCmd("continue")
self.assertTrue( self.assertEqual(
b.GetNumChildren() == 0, b.GetNumChildren(), 0,
"b didn't go back to 0 children") "b didn't go back to 0 children")

lldb/test/API/functionalities/exec/TestExec.py

Show First 20 Lines • Show All 93 Lines • ▼ Show 20 Lines def do_test(self, skip_exec):
if not skip_exec: if not skip_exec:
self.assertNotEqual(process.GetState(), lldb.eStateExited, self.assertNotEqual(process.GetState(), lldb.eStateExited,
"Process should not have exited!") "Process should not have exited!")
self.assertEqual(process.GetState(), lldb.eStateStopped, self.assertEqual(process.GetState(), lldb.eStateStopped,
"Process should be stopped at __dyld_start") "Process should be stopped at __dyld_start")
threads = lldbutil.get_stopped_threads( threads = lldbutil.get_stopped_threads(
process, lldb.eStopReasonExec) process, lldb.eStopReasonExec)
self.assertTrue( self.assertEqual(
len(threads) == 1, len(threads), 1,
"We got a thread stopped for exec.") "We got a thread stopped for exec.")
# Run and we should stop at breakpoint in main after exec # Run and we should stop at breakpoint in main after exec
process.Continue() process.Continue()
threads = lldbutil.get_threads_stopped_at_breakpoint( threads = lldbutil.get_threads_stopped_at_breakpoint(
process, breakpoint2) process, breakpoint2)
if self.TraceOn(): if self.TraceOn():
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Lines def test_correct_thread_plan_state_before_exec(self):
self.assertNotEqual(process.GetState(), lldb.eStateExited, self.assertNotEqual(process.GetState(), lldb.eStateExited,
"Process should not have exited!") "Process should not have exited!")
self.assertEqual(process.GetState(), lldb.eStateStopped, self.assertEqual(process.GetState(), lldb.eStateStopped,
"Process should be stopped at __dyld_start") "Process should be stopped at __dyld_start")
threads = lldbutil.get_stopped_threads( threads = lldbutil.get_stopped_threads(
process, lldb.eStopReasonExec) process, lldb.eStopReasonExec)
self.assertTrue( self.assertEqual(
len(threads) == 1, len(threads), 1,
"We got a thread stopped for exec.") "We got a thread stopped for exec.")
# Run and we should stop at breakpoint in main after exec # Run and we should stop at breakpoint in main after exec
process.Continue() process.Continue()
threads = lldbutil.get_threads_stopped_at_breakpoint( threads = lldbutil.get_threads_stopped_at_breakpoint(
process, breakpoint2) process, breakpoint2)
self.assertEqual(len(threads), 1, self.assertEqual(len(threads), 1,
"Stopped at breakpoint in exec'ed process.") "Stopped at breakpoint in exec'ed process.")

lldb/test/API/functionalities/inline-stepping/TestInlineStepping.py

Show First 20 Lines • Show All 191 Lines • ▼ Show 20 Lines def inline_stepping(self):
# inline_trivial_2: # inline_trivial_2:
break_2_in_main = target.BreakpointCreateBySourceRegex( break_2_in_main = target.BreakpointCreateBySourceRegex(
'// At second call of caller_trivial_1 in main.', self.main_source_spec) '// At second call of caller_trivial_1 in main.', self.main_source_spec)
self.assertTrue(break_2_in_main, VALID_BREAKPOINT) self.assertTrue(break_2_in_main, VALID_BREAKPOINT)
threads = lldbutil.continue_to_breakpoint( threads = lldbutil.continue_to_breakpoint(
self.process, break_2_in_main) self.process, break_2_in_main)
self.assertTrue( self.assertEqual(
len(threads) == 1, len(threads), 1,
"Successfully ran to call site of second caller_trivial_1 call.") "Successfully ran to call site of second caller_trivial_1 call.")
self.thread = threads[0] self.thread = threads[0]
step_sequence = [["// In caller_trivial_1.", "into"], step_sequence = [["// In caller_trivial_1.", "into"],
["// In caller_trivial_2.", "into"], ["// In caller_trivial_2.", "into"],
["// In inline_trivial_1.", "into"]] ["// In inline_trivial_1.", "into"]]
self.run_step_sequence(step_sequence) self.run_step_sequence(step_sequence)
# Then call some trivial function, and make sure we end up back where # Then call some trivial function, and make sure we end up back where
# we were in the inlined call stack: # we were in the inlined call stack:
frame = self.thread.GetFrameAtIndex(0) frame = self.thread.GetFrameAtIndex(0)
before_line_entry = frame.GetLineEntry() before_line_entry = frame.GetLineEntry()
value = frame.EvaluateExpression("function_to_call()") value = frame.EvaluateExpression("function_to_call()")
after_line_entry = frame.GetLineEntry() after_line_entry = frame.GetLineEntry()
self.assertTrue( self.assertEqual(
before_line_entry.GetLine() == after_line_entry.GetLine(), before_line_entry.GetLine(), after_line_entry.GetLine(),
"Line entry before and after function calls are the same.") "Line entry before and after function calls are the same.")
# Now make sure stepping OVER in the middle of the stack works, and # Now make sure stepping OVER in the middle of the stack works, and
# then check finish from the inlined frame: # then check finish from the inlined frame:
step_sequence = [["// At increment in inline_trivial_1.", "over"], step_sequence = [["// At increment in inline_trivial_1.", "over"],
["// At increment in caller_trivial_2.", "out"]] ["// At increment in caller_trivial_2.", "out"]]
self.run_step_sequence(step_sequence) self.run_step_sequence(step_sequence)
# Now run to the place in main just before the first call to # Now run to the place in main just before the first call to
# caller_ref_1: # caller_ref_1:
break_3_in_main = target.BreakpointCreateBySourceRegex( break_3_in_main = target.BreakpointCreateBySourceRegex(
'// At first call of caller_ref_1 in main.', self.main_source_spec) '// At first call of caller_ref_1 in main.', self.main_source_spec)
self.assertTrue(break_3_in_main, VALID_BREAKPOINT) self.assertTrue(break_3_in_main, VALID_BREAKPOINT)
threads = lldbutil.continue_to_breakpoint( threads = lldbutil.continue_to_breakpoint(
self.process, break_3_in_main) self.process, break_3_in_main)
self.assertTrue( self.assertEqual(
len(threads) == 1, len(threads), 1,
"Successfully ran to call site of first caller_ref_1 call.") "Successfully ran to call site of first caller_ref_1 call.")
self.thread = threads[0] self.thread = threads[0]
step_sequence = [["// In caller_ref_1.", "into"], step_sequence = [["// In caller_ref_1.", "into"],
["// In caller_ref_2.", "into"], ["// In caller_ref_2.", "into"],
["// In inline_ref_1.", "into"], ["// In inline_ref_1.", "into"],
["// In inline_ref_2.", "into"], ["// In inline_ref_2.", "into"],
["// In called_by_inline_ref.", "into"], ["// In called_by_inline_ref.", "into"],
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

lldb/test/API/functionalities/memory/read/TestMemoryRead.py

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 Lines def test_memory_read(self):
# 0x7fff5fbff9a8: {0x0ec0bf27} # 0x7fff5fbff9a8: {0x0ec0bf27}
# 0x7fff5fbff9ac: {0x215db505} # 0x7fff5fbff9ac: {0x215db505}
self.runCmd( self.runCmd(
"memory read --format uint32_t[] --size 4 --count 4 `&argc`") "memory read --format uint32_t[] --size 4 --count 4 `&argc`")
lines = self.res.GetOutput().splitlines() lines = self.res.GetOutput().splitlines()
for i in range(4): for i in range(4):
if i == 0: if i == 0:
# Verify that the printout for argc is correct. # Verify that the printout for argc is correct.
self.assertTrue( self.assertEqual(
argc == int( argc, int(lines[i].split(':')[1].strip(' {}'), 0))
lines[i].split(':')[1].strip(' {}'), 0))
addr = int(lines[i].split(':')[0], 0) addr = int(lines[i].split(':')[0], 0)
# Verify that the printout for addr is incremented correctly. # Verify that the printout for addr is incremented correctly.
self.assertEquals(addr, (address + i * 4)) self.assertEqual(addr, (address + i * 4))
# (lldb) memory read --format char[] --size 7 --count 1 `&my_string` # (lldb) memory read --format char[] --size 7 --count 1 `&my_string`
# 0x7fff5fbff990: {abcdefg} # 0x7fff5fbff990: {abcdefg}
self.expect( self.expect(
"memory read --format char[] --size 7 --count 1 `&my_string`", "memory read --format char[] --size 7 --count 1 `&my_string`",
substrs=['abcdefg']) substrs=['abcdefg'])
# (lldb) memory read --format 'hex float' --size 16 `&argc` # (lldb) memory read --format 'hex float' --size 16 `&argc`
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines def test_memory_read(self):
self.runCmd( self.runCmd(
"memory read --gdb-format 4%s &my_uint64s" % formatter) "memory read --gdb-format 4%s &my_uint64s" % formatter)
lines = self.res.GetOutput().splitlines() lines = self.res.GetOutput().splitlines()
objects_read = [] objects_read = []
for l in lines: for l in lines:
objects_read.extend(l.split(':')[1].split()) objects_read.extend(l.split(':')[1].split())
# Check that we got back 4 0x0000 etc bytes # Check that we got back 4 0x0000 etc bytes
for o in objects_read: for o in objects_read:
self.assertTrue (len(o) == expected_object_length) self.assertEqual(len(o), expected_object_length)
self.assertEquals(len(objects_read), 4) self.assertEquals(len(objects_read), 4)

lldb/test/API/functionalities/plugins/python_os_plugin/TestPythonOSPlugin.py

Show All 24 Lines def run_python_os_step(self):
self.build() self.build()
self.run_python_os_step() self.run_python_os_step()
def verify_os_thread_registers(self, thread): def verify_os_thread_registers(self, thread):
frame = thread.GetFrameAtIndex(0) frame = thread.GetFrameAtIndex(0)
registers = frame.GetRegisters().GetValueAtIndex(0) registers = frame.GetRegisters().GetValueAtIndex(0)
reg_value = thread.GetThreadID() + 1 reg_value = thread.GetThreadID() + 1
for reg in registers: for reg in registers:
self.assertTrue( self.assertEqual(
reg.GetValueAsUnsigned() == reg_value, reg.GetValueAsUnsigned(), reg_value,
"Verify the registers contains the correct value") "Verify the registers contains the correct value")
reg_value = reg_value + 1 reg_value = reg_value + 1
def run_python_os_funcionality(self): def run_python_os_funcionality(self):
"""Test that the Python operating system plugin works correctly""" """Test that the Python operating system plugin works correctly"""
# Set debugger into synchronous mode # Set debugger into synchronous mode
self.dbg.SetAsync(False) self.dbg.SetAsync(False)
▲ Show 20 Lines • Show All 123 Lines • ▼ Show 20 Lines def run_python_os_step(self):
"Make sure there is a thread 0x111111111 after we load the python OS plug-in") "Make sure there is a thread 0x111111111 after we load the python OS plug-in")
frame = thread.GetFrameAtIndex(0) frame = thread.GetFrameAtIndex(0)
self.assertTrue( self.assertTrue(
frame.IsValid(), frame.IsValid(),
"Make sure we get a frame from thread 0x111111111") "Make sure we get a frame from thread 0x111111111")
line_entry = frame.GetLineEntry() line_entry = frame.GetLineEntry()
self.assertTrue( self.assertEqual(
line_entry.GetFileSpec().GetFilename() == 'main.c', line_entry.GetFileSpec().GetFilename(), 'main.c',
"Make sure we stopped on line 5 in main.c") "Make sure we stopped on line 5 in main.c")
self.assertTrue( self.assertEqual(
line_entry.GetLine() == 5, line_entry.GetLine(), 5,
"Make sure we stopped on line 5 in main.c") "Make sure we stopped on line 5 in main.c")
# Now single step thread 0x111111111 and make sure it does what we need # Now single step thread 0x111111111 and make sure it does what we need
# it to # it to
thread.StepOver() thread.StepOver()
frame = thread.GetFrameAtIndex(0) frame = thread.GetFrameAtIndex(0)
self.assertTrue( self.assertTrue(
frame.IsValid(), frame.IsValid(),
"Make sure we get a frame from thread 0x111111111") "Make sure we get a frame from thread 0x111111111")
line_entry = frame.GetLineEntry() line_entry = frame.GetLineEntry()
self.assertTrue( self.assertEqual(
line_entry.GetFileSpec().GetFilename() == 'main.c', line_entry.GetFileSpec().GetFilename(), 'main.c',
"Make sure we stepped from line 5 to line 6 in main.c") "Make sure we stepped from line 5 to line 6 in main.c")
self.assertEquals(line_entry.GetLine(), 6, self.assertEquals(line_entry.GetLine(), 6,
"Make sure we stepped from line 5 to line 6 in main.c") "Make sure we stepped from line 5 to line 6 in main.c")

lldb/test/API/functionalities/signal/TestSendSignal.py

Show First 20 Lines • Show All 86 Lines • ▼ Show 20 Lines def test_with_run_command(self):
# Now make sure the thread was stopped with a SIGUSR1: # Now make sure the thread was stopped with a SIGUSR1:
threads = lldbutil.get_stopped_threads(process, lldb.eStopReasonSignal) threads = lldbutil.get_stopped_threads(process, lldb.eStopReasonSignal)
self.assertEquals(len(threads), 1, "One thread stopped for a signal.") self.assertEquals(len(threads), 1, "One thread stopped for a signal.")
thread = threads[0] thread = threads[0]
self.assertTrue( self.assertTrue(
thread.GetStopReasonDataCount() >= 1, thread.GetStopReasonDataCount() >= 1,
"There was data in the event.") "There was data in the event.")
self.assertTrue( self.assertEqual(
thread.GetStopReasonDataAtIndex(0) == lldbutil.get_signal_number('SIGUSR1'), thread.GetStopReasonDataAtIndex(0), lldbutil.get_signal_number('SIGUSR1'),
"The stop signal was SIGUSR1") "The stop signal was SIGUSR1")
def match_state(self, process_listener, expected_state): def match_state(self, process_listener, expected_state):
num_seconds = 5 num_seconds = 5
broadcaster = self.process().GetBroadcaster() broadcaster = self.process().GetBroadcaster()
event_type_mask = lldb.SBProcess.eBroadcastBitStateChanged event_type_mask = lldb.SBProcess.eBroadcastBitStateChanged
event = lldb.SBEvent() event = lldb.SBEvent()
got_event = process_listener.WaitForEventForBroadcasterWithType( got_event = process_listener.WaitForEventForBroadcasterWithType(
num_seconds, broadcaster, event_type_mask, event) num_seconds, broadcaster, event_type_mask, event)
self.assertTrue(got_event, "Got an event") self.assertTrue(got_event, "Got an event")
state = lldb.SBProcess.GetStateFromEvent(event) state = lldb.SBProcess.GetStateFromEvent(event)
self.assertEquals(state, expected_state, self.assertEquals(state, expected_state,
"It was the %s state." % "It was the %s state." %
lldb.SBDebugger_StateAsCString(expected_state)) lldb.SBDebugger_StateAsCString(expected_state))

lldb/test/API/functionalities/step-avoids-no-debug/TestStepNoDebug.py

Show First 20 Lines • Show All 72 Lines • ▼ Show 20 Linesclass StepAvoidsNoDebugTestCase(TestBase):
def hit_correct_line(self, pattern): def hit_correct_line(self, pattern):
target_line = line_number(self.main_source, pattern) target_line = line_number(self.main_source, pattern)
self.assertTrue( self.assertTrue(
target_line != 0, target_line != 0,
"Could not find source pattern " + "Could not find source pattern " +
pattern) pattern)
cur_line = self.thread.frames[0].GetLineEntry().GetLine() cur_line = self.thread.frames[0].GetLineEntry().GetLine()
self.assertTrue( self.assertEqual(
cur_line == target_line, cur_line, target_line,
"Stepped to line %d instead of expected %d with pattern '%s'." % "Stepped to line %d instead of expected %d with pattern '%s'." %
(cur_line, (cur_line,
target_line, target_line,
pattern)) pattern))
def hit_correct_function(self, pattern): def hit_correct_function(self, pattern):
name = self.thread.frames[0].GetFunctionName() name = self.thread.frames[0].GetFunctionName()
self.assertTrue( self.assertTrue(
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

lldb/test/API/functionalities/target-new-solib-notifications/TestModuleLoadedNotifys.py

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines def test_launch_notifications(self):
None, # stdin_path None, # stdin_path
None, # stdout_path None, # stdout_path
None, # stderr_path None, # stderr_path
None, # working directory None, # working directory
flags, # launch flags flags, # launch flags
False, # Stop at entry False, # Stop at entry
error) # error error) # error
self.assertTrue( self.assertEqual(
process.GetState() == lldb.eStateStopped, process.GetState(), lldb.eStateStopped,
PROCESS_STOPPED) PROCESS_STOPPED)
total_solibs_added = 0 total_solibs_added = 0
total_solibs_removed = 0 total_solibs_removed = 0
total_modules_added_events = 0 total_modules_added_events = 0
total_modules_removed_events = 0 total_modules_removed_events = 0
while listener.GetNextEvent(event): while listener.GetNextEvent(event):
if lldb.SBTarget.EventIsTargetEvent(event): if lldb.SBTarget.EventIsTargetEvent(event):
Show All 36 Lines

lldb/test/API/functionalities/thread/break_after_join/TestBreakAfterJoin.py

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines def test(self):
self.runCmd("continue") self.runCmd("continue")
# If the process hasn't exited, collect some information # If the process hasn't exited, collect some information
if process.GetState() != lldb.eStateExited: if process.GetState() != lldb.eStateExited:
self.runCmd("thread list") self.runCmd("thread list")
self.runCmd("process status") self.runCmd("process status")
# At this point, the inferior process should have exited. # At this point, the inferior process should have exited.
self.assertTrue( self.assertEqual(
process.GetState() == lldb.eStateExited, process.GetState(), lldb.eStateExited,
PROCESS_EXITED) PROCESS_EXITED)

lldb/test/API/functionalities/thread/create_after_attach/TestCreateAfterAttach.py

Show First 20 Lines • Show All 95 Lines • ▼ Show 20 Lines def test_create_after_attach(self):
'* thread #', '* thread #',
'thread_1_func', 'thread_1_func',
'stop reason = breakpoint']) 'stop reason = breakpoint'])
# Run to completion # Run to completion
self.runCmd("continue") self.runCmd("continue")
# At this point, the inferior process should have exited. # At this point, the inferior process should have exited.
self.assertTrue( self.assertEqual(
process.GetState() == lldb.eStateExited, process.GetState(), lldb.eStateExited,
PROCESS_EXITED) PROCESS_EXITED)

lldb/test/API/functionalities/thread/create_during_step/TestCreateDuringStep.py

Show First 20 Lines • Show All 99 Lines • ▼ Show 20 Lines def create_during_step_base(self, step_cmd, step_stop_reason):
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
stepping_thread = lldbutil.get_one_thread_stopped_at_breakpoint(process, self.bkpt) stepping_thread = lldbutil.get_one_thread_stopped_at_breakpoint(process, self.bkpt)
self.assertTrue(stepping_thread.IsValid(), "We stopped at the right breakpoint") self.assertTrue(stepping_thread.IsValid(), "We stopped at the right breakpoint")
# Get the number of threads # Get the number of threads
num_threads = process.GetNumThreads() num_threads = process.GetNumThreads()
# Make sure we see only two threads # Make sure we see only two threads
self.assertTrue( self.assertEqual(
num_threads == 2, num_threads, 2,
'Number of expected threads and actual threads do not match.') 'Number of expected threads and actual threads do not match.')
# Get the thread objects # Get the thread objects
thread1 = process.GetThreadAtIndex(0) thread1 = process.GetThreadAtIndex(0)
thread2 = process.GetThreadAtIndex(1) thread2 = process.GetThreadAtIndex(1)
current_line = self.breakpoint current_line = self.breakpoint
# Keep stepping until we've reached our designated continue point # Keep stepping until we've reached our designated continue point
Show All 15 Lines def create_during_step_base(self, step_cmd, step_stop_reason):
current_line <= self.continuepoint, current_line <= self.continuepoint,
"Stepped to unexpected line, " + "Stepped to unexpected line, " +
str(current_line)) str(current_line))
# Update the number of threads # Update the number of threads
num_threads = process.GetNumThreads() num_threads = process.GetNumThreads()
# Check to see that we increased the number of threads as expected # Check to see that we increased the number of threads as expected
self.assertTrue( self.assertEqual(
num_threads == 3, num_threads, 3,
'Number of expected threads and actual threads do not match after thread exit.') 'Number of expected threads and actual threads do not match after thread exit.')
stop_reason = stepping_thread.GetStopReason() stop_reason = stepping_thread.GetStopReason()
self.assertEqual(stop_reason, lldb.eStopReasonPlanComplete, "Stopped for plan completion") self.assertEqual(stop_reason, lldb.eStopReasonPlanComplete, "Stopped for plan completion")
# Run to completion # Run to completion
self.runCmd("process continue") self.runCmd("process continue")
# At this point, the inferior process should have exited. # At this point, the inferior process should have exited.
self.assertTrue( self.assertEqual(
process.GetState() == lldb.eStateExited, process.GetState(), lldb.eStateExited,
PROCESS_EXITED) PROCESS_EXITED)

lldb/test/API/functionalities/thread/exit_during_break/TestExitDuringBreak.py

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines def test(self):
self.assertTrue( self.assertTrue(
num_threads >= 5, num_threads >= 5,
'Number of expected threads and actual threads do not match.') 'Number of expected threads and actual threads do not match.')
# Run to completion # Run to completion
self.runCmd("continue") self.runCmd("continue")
# At this point, the inferior process should have exited. # At this point, the inferior process should have exited.
self.assertTrue( self.assertEqual(
process.GetState() == lldb.eStateExited, process.GetState(), lldb.eStateExited,
PROCESS_EXITED) PROCESS_EXITED)

lldb/test/API/functionalities/thread/multi_break/TestMultipleBreakpoints.py

Show First 20 Lines • Show All 79 Lines • ▼ Show 20 Lines def test(self):
# Delete the first breakpoint then continue # Delete the first breakpoint then continue
self.runCmd("breakpoint delete 1") self.runCmd("breakpoint delete 1")
# Run to completion # Run to completion
self.runCmd("continue") self.runCmd("continue")
# At this point, the inferior process should have exited. # At this point, the inferior process should have exited.
self.assertTrue( self.assertEqual(
process.GetState() == lldb.eStateExited, process.GetState(), lldb.eStateExited,
PROCESS_EXITED) PROCESS_EXITED)

lldb/test/API/functionalities/thread/thread_specific_break_plus_condition/TestThreadSpecificBpPlusCondition.py

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Lines def test_python(self):
cond_string = "my_value != %d" % (value) cond_string = "my_value != %d" % (value)
break_thread_body.SetThreadID(victim_thread.GetThreadID()) break_thread_body.SetThreadID(victim_thread.GetThreadID())
break_thread_body.SetCondition(cond_string) break_thread_body.SetCondition(cond_string)
process.Continue() process.Continue()
next_stop_state = process.GetState() next_stop_state = process.GetState()
self.assertTrue( self.assertEqual(
next_stop_state == lldb.eStateExited, next_stop_state, lldb.eStateExited,
"We should have not hit the breakpoint again.") "We should have not hit the breakpoint again.")

lldb/test/API/lang/c/array_types/TestArrayTypes.py

Show First 20 Lines • Show All 210 Lines • ▼ Show 20 Lines def test_and_python_api(self):
child5 = variable.GetChildAtIndex(5) child5 = variable.GetChildAtIndex(5)
self.DebugSBValue(child5) self.DebugSBValue(child5)
self.assertEquals(int(child5.GetValue(), 0), 6, self.assertEquals(int(child5.GetValue(), 0), 6,
"long_6[5] == 6") "long_6[5] == 6")
# Last, check that "long_6" has a value type of eValueTypeVariableLocal # Last, check that "long_6" has a value type of eValueTypeVariableLocal
# and "argc" has eValueTypeVariableArgument. # and "argc" has eValueTypeVariableArgument.
from lldbsuite.test.lldbutil import value_type_to_str from lldbsuite.test.lldbutil import value_type_to_str
self.assertTrue( self.assertEqual(
variable.GetValueType() == lldb.eValueTypeVariableLocal, variable.GetValueType(), lldb.eValueTypeVariableLocal,
"Variable 'long_6' should have '%s' value type." % "Variable 'long_6' should have '%s' value type." %
value_type_to_str( value_type_to_str(
lldb.eValueTypeVariableLocal)) lldb.eValueTypeVariableLocal))
argc = frame.FindVariable("argc") argc = frame.FindVariable("argc")
self.DebugSBValue(argc) self.DebugSBValue(argc)
self.assertEquals(argc.GetValueType(), lldb.eValueTypeVariableArgument, self.assertEquals(argc.GetValueType(), lldb.eValueTypeVariableArgument,
"Variable 'argc' should have '%s' value type." % "Variable 'argc' should have '%s' value type." %
value_type_to_str(lldb.eValueTypeVariableArgument)) value_type_to_str(lldb.eValueTypeVariableArgument))

lldb/test/API/lang/c/bitfields/TestBitfields.py

Show First 20 Lines • Show All 200 Lines • ▼ Show 20 Lines def test_and_python_api(self):
# The breakpoint should have a hit count of 1. # The breakpoint should have a hit count of 1.
self.assertEqual(breakpoint.GetHitCount(), 1, BREAKPOINT_HIT_ONCE) self.assertEqual(breakpoint.GetHitCount(), 1, BREAKPOINT_HIT_ONCE)
# Lookup the "bits" variable which contains 8 bitfields. # Lookup the "bits" variable which contains 8 bitfields.
frame = thread.GetFrameAtIndex(0) frame = thread.GetFrameAtIndex(0)
bits = frame.FindVariable("bits") bits = frame.FindVariable("bits")
self.DebugSBValue(bits) self.DebugSBValue(bits)
self.assertTrue( self.assertEqual(
bits.GetTypeName() == 'Bits', bits.GetTypeName(), 'Bits',
"bits.GetTypeName() == 'Bits'") "bits.GetTypeName() == 'Bits'")
self.assertTrue( self.assertEqual(
bits.GetNumChildren() == 10, bits.GetNumChildren(), 10,
"bits.GetNumChildren() == 10") "bits.GetNumChildren() == 10")
test_compiler = self.getCompiler() test_compiler = self.getCompiler()
self.assertEqual(bits.GetByteSize(), 32, "bits.GetByteSize() == 32") self.assertEqual(bits.GetByteSize(), 32, "bits.GetByteSize() == 32")
# Notice the pattern of int(b1.GetValue(), 0). We pass a base of 0 # Notice the pattern of int(b1.GetValue(), 0). We pass a base of 0
# so that the proper radix is determined based on the contents of the # so that the proper radix is determined based on the contents of the
# string. # string.
b1 = bits.GetChildMemberWithName("b1") b1 = bits.GetChildMemberWithName("b1")
Show All 26 Lines

lldb/test/API/lang/c/stepping/TestStepAndBreakpoints.py

Show First 20 Lines • Show All 109 Lines • ▼ Show 20 Lines def test_and_python_api(self):
current_bp.append(thread.GetStopReasonDataAtIndex(1)) current_bp.append(thread.GetStopReasonDataAtIndex(1))
stop_id_before_expression = process.GetStopID() stop_id_before_expression = process.GetStopID()
stop_id_before_including_expressions = process.GetStopID(True) stop_id_before_including_expressions = process.GetStopID(True)
frame.EvaluateExpression("(int) printf (print_string)") frame.EvaluateExpression("(int) printf (print_string)")
frame = thread.GetFrameAtIndex(0) frame = thread.GetFrameAtIndex(0)
self.assertTrue( self.assertEqual(
current_line == frame.GetLineEntry().GetLine(), current_line, frame.GetLineEntry().GetLine(),
"The line stayed the same after expression.") "The line stayed the same after expression.")
self.assertTrue( self.assertEqual(
current_file == frame.GetLineEntry().GetFileSpec(), current_file, frame.GetLineEntry().GetFileSpec(),
"The file stayed the same after expression.") "The file stayed the same after expression.")
self.assertTrue( self.assertEqual(
thread.GetStopReason() == lldb.eStopReasonBreakpoint, thread.GetStopReason(), lldb.eStopReasonBreakpoint,
"We still say we stopped for a breakpoint.") "We still say we stopped for a breakpoint.")
self.assertTrue(thread.GetStopReasonDataAtIndex(0) == current_bp[ self.assertTrue(thread.GetStopReasonDataAtIndex(0) == current_bp[
0] and thread.GetStopReasonDataAtIndex(1) == current_bp[1], "And it is the same breakpoint.") 0] and thread.GetStopReasonDataAtIndex(1) == current_bp[1], "And it is the same breakpoint.")
# Also make sure running the expression didn't change the public stop id # Also make sure running the expression didn't change the public stop id
# but did change if we are asking for expression stops as well. # but did change if we are asking for expression stops as well.
stop_id_after_expression = process.GetStopID() stop_id_after_expression = process.GetStopID()
stop_id_after_including_expressions = process.GetStopID(True) stop_id_after_including_expressions = process.GetStopID(True)
self.assertTrue( self.assertEqual(
stop_id_before_expression == stop_id_after_expression, stop_id_before_expression, stop_id_after_expression,
"Expression calling doesn't change stop ID") "Expression calling doesn't change stop ID")
self.assertTrue( self.assertTrue(
stop_id_after_including_expressions > stop_id_before_including_expressions, stop_id_after_including_expressions > stop_id_before_including_expressions,
"Stop ID including expressions increments over expression call.") "Stop ID including expressions increments over expression call.")
# Do the same thing with an expression that's going to crash, and make # Do the same thing with an expression that's going to crash, and make
# sure we are still unchanged. # sure we are still unchanged.
frame.EvaluateExpression("((char *) 0)[0] = 'a'") frame.EvaluateExpression("((char *) 0)[0] = 'a'")
frame = thread.GetFrameAtIndex(0) frame = thread.GetFrameAtIndex(0)
self.assertTrue( self.assertEqual(
current_line == frame.GetLineEntry().GetLine(), current_line, frame.GetLineEntry().GetLine(),
"The line stayed the same after expression.") "The line stayed the same after expression.")
self.assertTrue( self.assertEqual(
current_file == frame.GetLineEntry().GetFileSpec(), current_file, frame.GetLineEntry().GetFileSpec(),
"The file stayed the same after expression.") "The file stayed the same after expression.")
self.assertTrue( self.assertEqual(
thread.GetStopReason() == lldb.eStopReasonBreakpoint, thread.GetStopReason(), lldb.eStopReasonBreakpoint,
"We still say we stopped for a breakpoint.") "We still say we stopped for a breakpoint.")
self.assertTrue(thread.GetStopReasonDataAtIndex(0) == current_bp[ self.assertTrue(thread.GetStopReasonDataAtIndex(0) == current_bp[
0] and thread.GetStopReasonDataAtIndex(1) == current_bp[1], "And it is the same breakpoint.") 0] and thread.GetStopReasonDataAtIndex(1) == current_bp[1], "And it is the same breakpoint.")
# Now continue and make sure we just complete the step: # Now continue and make sure we just complete the step:
# Disable all our breakpoints first - sometimes the compiler puts two line table entries in for the # Disable all our breakpoints first - sometimes the compiler puts two line table entries in for the
# breakpoint a "b" and we don't want to hit that. # breakpoint a "b" and we don't want to hit that.
for bkpt in breakpoints_to_disable: for bkpt in breakpoints_to_disable:
Show All 32 Lines def test_and_python_api(self):
thread = threads[0] thread = threads[0]
# So do a step over here to make sure we can still do that: # So do a step over here to make sure we can still do that:
thread.StepOver() thread.StepOver()
# See that we are still in b: # See that we are still in b:
func_name = thread.GetFrameAtIndex(0).GetFunctionName() func_name = thread.GetFrameAtIndex(0).GetFunctionName()
self.assertTrue( self.assertEqual(
func_name == "b", func_name, "b",
"Should be in 'b', were in %s" % "Should be in 'b', were in %s" %
(func_name)) (func_name))
# Okay, now if we continue, we will finish off our function call and we # Okay, now if we continue, we will finish off our function call and we
# should end up back in "a" as if nothing had happened: # should end up back in "a" as if nothing had happened:
process.Continue() process.Continue()
self.assertTrue(thread.GetFrameAtIndex( self.assertTrue(thread.GetFrameAtIndex(
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lldb/test/API/lang/c/unions/TestUnionMembers.py

Show All 15 Lines def test_union_members(self):
self.assertTrue( self.assertTrue(
bp.IsValid() and bp.GetNumLocations() >= 1, bp.IsValid() and bp.GetNumLocations() >= 1,
VALID_BREAKPOINT) VALID_BREAKPOINT)
# Launch the process # Launch the process
self.process = self.target.LaunchSimple( self.process = self.target.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
self.assertTrue(self.process.IsValid(), PROCESS_IS_VALID) self.assertTrue(self.process.IsValid(), PROCESS_IS_VALID)
self.assertTrue( self.assertEqual(
self.process.GetState() == lldb.eStateStopped, self.process.GetState(), lldb.eStateStopped,
PROCESS_STOPPED) PROCESS_STOPPED)
thread = lldbutil.get_stopped_thread( thread = lldbutil.get_stopped_thread(
self.process, lldb.eStopReasonBreakpoint) self.process, lldb.eStopReasonBreakpoint)
self.assertTrue(thread.IsValid()) self.assertTrue(thread.IsValid())
frame = thread.GetSelectedFrame() frame = thread.GetSelectedFrame()
self.assertTrue(frame.IsValid()) self.assertTrue(frame.IsValid())
Show All 19 Lines

lldb/test/API/lang/cpp/breakpoint-commands/TestCPPBreakpointCommands.py

Show All 14 Linesclass CPPBreakpointCommandsTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def make_breakpoint(self, name, type, expected_num_locations): def make_breakpoint(self, name, type, expected_num_locations):
bkpt = self.target.BreakpointCreateByName(name, bkpt = self.target.BreakpointCreateByName(name,
type, type,
self.a_out_module, self.a_out_module,
self.nested_comp_unit) self.nested_comp_unit)
num_locations = bkpt.GetNumLocations() num_locations = bkpt.GetNumLocations()
self.assertTrue( self.assertEqual(
num_locations == expected_num_locations, num_locations, expected_num_locations,
"Wrong number of locations for '%s', expected: %d got: %d" % "Wrong number of locations for '%s', expected: %d got: %d" %
(name, (name,
expected_num_locations, expected_num_locations,
num_locations)) num_locations))
return bkpt return bkpt
def test_cpp_breakpoint_cmds(self): def test_cpp_breakpoint_cmds(self):
"""Test a sequence of breakpoint command add, list, and delete.""" """Test a sequence of breakpoint command add, list, and delete."""
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

lldb/test/API/lang/cpp/class_static/TestStaticVariables.py

Show First 20 Lines • Show All 134 Lines • ▼ Show 20 Lines def test_with_python_api(self):
# in_scope_only => False # in_scope_only => False
valList = frame.GetVariables(False, False, True, False) valList = frame.GetVariables(False, False, True, False)
for val in valList: for val in valList:
self.DebugSBValue(val) self.DebugSBValue(val)
name = val.GetName() name = val.GetName()
self.assertTrue(name in ['g_points', 'A::g_points']) self.assertTrue(name in ['g_points', 'A::g_points'])
if name == 'g_points': if name == 'g_points':
self.assertTrue( self.assertEqual(
val.GetValueType() == lldb.eValueTypeVariableStatic) val.GetValueType(), lldb.eValueTypeVariableStatic)
self.assertEqual(val.GetNumChildren(), 2) self.assertEqual(val.GetNumChildren(), 2)
elif name == 'A::g_points': elif name == 'A::g_points':
self.assertTrue( self.assertEqual(
val.GetValueType() == lldb.eValueTypeVariableGlobal) val.GetValueType(), lldb.eValueTypeVariableGlobal)
self.assertEqual(val.GetNumChildren(), 2) self.assertEqual(val.GetNumChildren(), 2)
child1 = val.GetChildAtIndex(1) child1 = val.GetChildAtIndex(1)
self.DebugSBValue(child1) self.DebugSBValue(child1)
child1_x = child1.GetChildAtIndex(0) child1_x = child1.GetChildAtIndex(0)
self.DebugSBValue(child1_x) self.DebugSBValue(child1_x)
self.assertTrue(child1_x.GetTypeName() == 'int' and self.assertTrue(child1_x.GetTypeName() == 'int' and
child1_x.GetValue() == '11') child1_x.GetValue() == '11')
Show All 17 Lines

lldb/test/API/lang/cpp/diamond/TestDiamond.py

Show All 27 Lines def test_with_run_command(self):
frame = thread.GetFrameAtIndex(0) frame = thread.GetFrameAtIndex(0)
j1 = frame.FindVariable("j1") j1 = frame.FindVariable("j1")
j1_Derived1 = j1.GetChildAtIndex(0) j1_Derived1 = j1.GetChildAtIndex(0)
j1_Derived2 = j1.GetChildAtIndex(1) j1_Derived2 = j1.GetChildAtIndex(1)
j1_Derived1_VBase = j1_Derived1.GetChildAtIndex(0) j1_Derived1_VBase = j1_Derived1.GetChildAtIndex(0)
j1_Derived2_VBase = j1_Derived2.GetChildAtIndex(0) j1_Derived2_VBase = j1_Derived2.GetChildAtIndex(0)
j1_Derived1_VBase_m_value = j1_Derived1_VBase.GetChildAtIndex(0) j1_Derived1_VBase_m_value = j1_Derived1_VBase.GetChildAtIndex(0)
j1_Derived2_VBase_m_value = j1_Derived2_VBase.GetChildAtIndex(0) j1_Derived2_VBase_m_value = j1_Derived2_VBase.GetChildAtIndex(0)
self.assertTrue( self.assertEqual(
j1_Derived1_VBase.GetLoadAddress() == j1_Derived2_VBase.GetLoadAddress(), j1_Derived1_VBase.GetLoadAddress(), j1_Derived2_VBase.GetLoadAddress(),
"ensure virtual base class is the same between Derived1 and Derived2") "ensure virtual base class is the same between Derived1 and Derived2")
self.assertTrue(j1_Derived1_VBase_m_value.GetValueAsUnsigned( self.assertTrue(j1_Derived1_VBase_m_value.GetValueAsUnsigned(
1) == j1_Derived2_VBase_m_value.GetValueAsUnsigned(2), "ensure m_value in VBase is the same") 1) == j1_Derived2_VBase_m_value.GetValueAsUnsigned(2), "ensure m_value in VBase is the same")
self.assertTrue(frame.FindVariable("d").GetChildAtIndex(0).GetChildAtIndex( self.assertTrue(frame.FindVariable("d").GetChildAtIndex(0).GetChildAtIndex(
0).GetValueAsUnsigned(0) == 12345, "ensure Derived2 from j1 is correct") 0).GetValueAsUnsigned(0) == 12345, "ensure Derived2 from j1 is correct")
thread.StepOver() thread.StepOver()
self.assertTrue(frame.FindVariable("d").GetChildAtIndex(0).GetChildAtIndex( self.assertTrue(frame.FindVariable("d").GetChildAtIndex(0).GetChildAtIndex(
0).GetValueAsUnsigned(0) == 12346, "ensure Derived2 from j2 is correct") 0).GetValueAsUnsigned(0) == 12346, "ensure Derived2 from j2 is correct")
def set_breakpoint(self, line): def set_breakpoint(self, line):
# Some compilers (for example GCC 4.4.7 and 4.6.1) emit multiple locations for the statement with the ternary # Some compilers (for example GCC 4.4.7 and 4.6.1) emit multiple locations for the statement with the ternary
# operator in the test program, while others emit only 1. # operator in the test program, while others emit only 1.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", line, num_expected_locations=-1, loc_exact=False) self, "main.cpp", line, num_expected_locations=-1, loc_exact=False)

lldb/test/API/lang/cpp/exceptions/TestCPPExceptionBreakpoints.py

Show All 40 Lines def test(self):
# Now run, and make sure we hit our breakpoint: # Now run, and make sure we hit our breakpoint:
process = target.LaunchSimple( process = target.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
self.assertTrue(process, "Got a valid process") self.assertTrue(process, "Got a valid process")
stopped_threads = [] stopped_threads = []
stopped_threads = lldbutil.get_threads_stopped_at_breakpoint( stopped_threads = lldbutil.get_threads_stopped_at_breakpoint(
process, exception_bkpt) process, exception_bkpt)
self.assertTrue( self.assertEqual(
len(stopped_threads) == 1, len(stopped_threads), 1,
"Stopped at our exception breakpoint.") "Stopped at our exception breakpoint.")
thread = stopped_threads[0] thread = stopped_threads[0]
# Make sure our throw function is still above us on the stack: # Make sure our throw function is still above us on the stack:
frame_functions = lldbutil.get_function_names(thread) frame_functions = lldbutil.get_function_names(thread)
self.assertTrue( self.assertEqual(
frame_functions.count("throws_exception_on_even(int)") == 1, frame_functions.count("throws_exception_on_even(int)"), 1,
"Our throw function is still on the stack.") "Our throw function is still on the stack.")
# Okay we hit our exception throw breakpoint, now make sure we get our catch breakpoint. # Okay we hit our exception throw breakpoint, now make sure we get our catch breakpoint.
# One potential complication is that we might hit a couple of the exception breakpoints in getting out of the throw. # One potential complication is that we might hit a couple of the exception breakpoints in getting out of the throw.
# so loop till we don't see the throws function on the stack. We should stop one more time for our exception breakpoint # so loop till we don't see the throws function on the stack. We should stop one more time for our exception breakpoint
# and that should be the catch... # and that should be the catch...
while frame_functions.count("throws_exception_on_even(int)") == 1: while frame_functions.count("throws_exception_on_even(int)") == 1:
stopped_threads = lldbutil.continue_to_breakpoint( stopped_threads = lldbutil.continue_to_breakpoint(
process, exception_bkpt) process, exception_bkpt)
self.assertEquals(len(stopped_threads), 1) self.assertEquals(len(stopped_threads), 1)
thread = stopped_threads[0] thread = stopped_threads[0]
frame_functions = lldbutil.get_function_names(thread) frame_functions = lldbutil.get_function_names(thread)
self.assertTrue( self.assertEqual(
frame_functions.count("throws_exception_on_even(int)") == 0, frame_functions.count("throws_exception_on_even(int)"), 0,
"At catch our throw function is off the stack") "At catch our throw function is off the stack")
self.assertTrue( self.assertEqual(
frame_functions.count("intervening_function(int)") == 0, frame_functions.count("intervening_function(int)"), 0,
"At catch our intervening function is off the stack") "At catch our intervening function is off the stack")
self.assertTrue( self.assertEqual(
frame_functions.count("catches_exception(int)") == 1, frame_functions.count("catches_exception(int)"), 1,
"At catch our catch function is on the stack") "At catch our catch function is on the stack")

lldb/test/API/lang/cpp/global_operators/TestCppGlobalOperators.py

Show All 35 Lines def prepare_executable_and_get_frame(self):
# Launch the process # Launch the process
args = None args = None
env = None env = None
process = target.LaunchSimple( process = target.LaunchSimple(
args, env, self.get_process_working_directory()) args, env, self.get_process_working_directory())
self.assertTrue(process.IsValid(), PROCESS_IS_VALID) self.assertTrue(process.IsValid(), PROCESS_IS_VALID)
# Get the thread of the process # Get the thread of the process
self.assertTrue( self.assertEqual(
process.GetState() == lldb.eStateStopped, process.GetState(), lldb.eStateStopped,
PROCESS_STOPPED) PROCESS_STOPPED)
thread = lldbutil.get_stopped_thread( thread = lldbutil.get_stopped_thread(
process, lldb.eStopReasonBreakpoint) process, lldb.eStopReasonBreakpoint)
return thread.GetSelectedFrame() return thread.GetSelectedFrame()
def test_equals_operator(self): def test_equals_operator(self):
frame = self.prepare_executable_and_get_frame() frame = self.prepare_executable_and_get_frame()
Show All 40 Lines

lldb/test/API/lang/cpp/gmodules/TestWithModuleDebugging.py

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines def test_specialized_typedef_from_pch(self):
# Get frame for current thread # Get frame for current thread
frame = thread.frames[0] frame = thread.frames[0]
testValue = frame.EvaluateExpression("test") testValue = frame.EvaluateExpression("test")
self.assertTrue( self.assertTrue(
testValue.GetError().Success(), testValue.GetError().Success(),
"Test expression value invalid: %s" % "Test expression value invalid: %s" %
(testValue.GetError().GetCString())) (testValue.GetError().GetCString()))
self.assertTrue( self.assertEqual(
testValue.GetTypeName() == "IntContainer", testValue.GetTypeName(), "IntContainer",
"Test expression type incorrect") "Test expression type incorrect")
memberValue = testValue.GetChildMemberWithName("storage") memberValue = testValue.GetChildMemberWithName("storage")
self.assertTrue( self.assertTrue(
memberValue.GetError().Success(), memberValue.GetError().Success(),
"Member value missing or invalid: %s" % "Member value missing or invalid: %s" %
(testValue.GetError().GetCString())) (testValue.GetError().GetCString()))
self.assertTrue( self.assertEqual(
memberValue.GetTypeName() == "int", memberValue.GetTypeName(), "int",
"Member type incorrect") "Member type incorrect")
self.assertEqual( self.assertEqual(
42, 42,
memberValue.GetValueAsSigned(), memberValue.GetValueAsSigned(),
"Member value incorrect") "Member value incorrect")
testValue = frame.EvaluateExpression("bar") testValue = frame.EvaluateExpression("bar")
self.assertTrue( self.assertTrue(
testValue.GetError().Success(), testValue.GetError().Success(),
"Test expression value invalid: %s" % "Test expression value invalid: %s" %
(testValue.GetError().GetCString())) (testValue.GetError().GetCString()))
self.assertTrue( self.assertEqual(
testValue.GetTypeName() == "Foo::Bar", testValue.GetTypeName(), "Foo::Bar",
"Test expression type incorrect") "Test expression type incorrect")
memberValue = testValue.GetChildMemberWithName("i") memberValue = testValue.GetChildMemberWithName("i")
self.assertTrue( self.assertTrue(
memberValue.GetError().Success(), memberValue.GetError().Success(),
"Member value missing or invalid: %s" % "Member value missing or invalid: %s" %
(testValue.GetError().GetCString())) (testValue.GetError().GetCString()))
self.assertTrue( self.assertEqual(
memberValue.GetTypeName() == "int", memberValue.GetTypeName(), "int",
"Member type incorrect") "Member type incorrect")
self.assertEqual( self.assertEqual(
123, 123,
memberValue.GetValueAsSigned(), memberValue.GetValueAsSigned(),
"Member value incorrect") "Member value incorrect")

lldb/test/API/lang/cpp/limit-debug-info/TestWithLimitDebugInfo.py

Show All 30 Lines def test_limit_debug_info(self):
VALID_BREAKPOINT) VALID_BREAKPOINT)
# Launch the process # Launch the process
process = target.LaunchSimple( process = target.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
self.assertTrue(process.IsValid(), PROCESS_IS_VALID) self.assertTrue(process.IsValid(), PROCESS_IS_VALID)
# Get the thread of the process # Get the thread of the process
self.assertTrue( self.assertEqual(
process.GetState() == lldb.eStateStopped, process.GetState(), lldb.eStateStopped,
PROCESS_STOPPED) PROCESS_STOPPED)
thread = lldbutil.get_stopped_thread( thread = lldbutil.get_stopped_thread(
process, lldb.eStopReasonBreakpoint) process, lldb.eStopReasonBreakpoint)
thread.StepInto() thread.StepInto()
# Get frame for current thread # Get frame for current thread
frame = thread.GetSelectedFrame() frame = thread.GetSelectedFrame()
Show All 9 Lines

lldb/test/API/lang/cpp/member-and-local-vars-with-same-name/TestMembersAndLocalsWithSameName.py

Show All 32 Lines def test_when_stopped_in_method(self):
bp4.IsValid() and bp4.GetNumLocations() >= 1, bp4.IsValid() and bp4.GetNumLocations() >= 1,
VALID_BREAKPOINT) VALID_BREAKPOINT)
# Launch the process # Launch the process
self.process = self.target.LaunchSimple( self.process = self.target.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
self.assertTrue(self.process.IsValid(), PROCESS_IS_VALID) self.assertTrue(self.process.IsValid(), PROCESS_IS_VALID)
self.assertTrue( self.assertEqual(
self.process.GetState() == lldb.eStateStopped, self.process.GetState(), lldb.eStateStopped,
PROCESS_STOPPED) PROCESS_STOPPED)
self._test_globals() self._test_globals()
self.process.Continue() self.process.Continue()
self.assertTrue( self.assertEqual(
self.process.GetState() == lldb.eStateStopped, self.process.GetState(), lldb.eStateStopped,
PROCESS_STOPPED) PROCESS_STOPPED)
thread = lldbutil.get_stopped_thread( thread = lldbutil.get_stopped_thread(
self.process, lldb.eStopReasonBreakpoint) self.process, lldb.eStopReasonBreakpoint)
self.assertTrue(thread.IsValid()) self.assertTrue(thread.IsValid())
frame = thread.GetSelectedFrame() frame = thread.GetSelectedFrame()
self.assertTrue(frame.IsValid()) self.assertTrue(frame.IsValid())
val = frame.EvaluateExpression("a") val = frame.EvaluateExpression("a")
self.assertTrue(val.IsValid()) self.assertTrue(val.IsValid())
self.assertEqual(val.GetValueAsUnsigned(), 12345) self.assertEqual(val.GetValueAsUnsigned(), 12345)
val = frame.EvaluateExpression("b") val = frame.EvaluateExpression("b")
self.assertTrue(val.IsValid()) self.assertTrue(val.IsValid())
self.assertEqual(val.GetValueAsUnsigned(), 54321) self.assertEqual(val.GetValueAsUnsigned(), 54321)
val = frame.EvaluateExpression("c") val = frame.EvaluateExpression("c")
self.assertTrue(val.IsValid()) self.assertTrue(val.IsValid())
self.assertEqual(val.GetValueAsUnsigned(), 34567) self.assertEqual(val.GetValueAsUnsigned(), 34567)
self.process.Continue() self.process.Continue()
self.assertTrue( self.assertEqual(
self.process.GetState() == lldb.eStateStopped, self.process.GetState(), lldb.eStateStopped,
PROCESS_STOPPED) PROCESS_STOPPED)
thread = lldbutil.get_stopped_thread( thread = lldbutil.get_stopped_thread(
self.process, lldb.eStopReasonBreakpoint) self.process, lldb.eStopReasonBreakpoint)
self.assertTrue(thread.IsValid()) self.assertTrue(thread.IsValid())
frame = thread.GetSelectedFrame() frame = thread.GetSelectedFrame()
self.assertTrue(frame.IsValid()) self.assertTrue(frame.IsValid())
val = frame.EvaluateExpression("a") val = frame.EvaluateExpression("a")
self.assertTrue(val.IsValid()) self.assertTrue(val.IsValid())
self.assertEqual(val.GetValueAsUnsigned(), 10001) self.assertEqual(val.GetValueAsUnsigned(), 10001)
val = frame.EvaluateExpression("b") val = frame.EvaluateExpression("b")
self.assertTrue(val.IsValid()) self.assertTrue(val.IsValid())
self.assertEqual(val.GetValueAsUnsigned(), 10002) self.assertEqual(val.GetValueAsUnsigned(), 10002)
val = frame.EvaluateExpression("c") val = frame.EvaluateExpression("c")
self.assertTrue(val.IsValid()) self.assertTrue(val.IsValid())
self.assertEqual(val.GetValueAsUnsigned(), 10003) self.assertEqual(val.GetValueAsUnsigned(), 10003)
self.process.Continue() self.process.Continue()
self.assertTrue( self.assertEqual(
self.process.GetState() == lldb.eStateStopped, self.process.GetState(), lldb.eStateStopped,
PROCESS_STOPPED) PROCESS_STOPPED)
thread = lldbutil.get_stopped_thread( thread = lldbutil.get_stopped_thread(
self.process, lldb.eStopReasonBreakpoint) self.process, lldb.eStopReasonBreakpoint)
self.assertTrue(thread.IsValid()) self.assertTrue(thread.IsValid())
frame = thread.GetSelectedFrame() frame = thread.GetSelectedFrame()
self.assertTrue(frame.IsValid()) self.assertTrue(frame.IsValid())
val = frame.EvaluateExpression("a") val = frame.EvaluateExpression("a")
Show All 33 Lines def test_when_stopped_in_function(self):
bp7.IsValid() and bp7.GetNumLocations() >= 1, bp7.IsValid() and bp7.GetNumLocations() >= 1,
VALID_BREAKPOINT) VALID_BREAKPOINT)
# Launch the process # Launch the process
self.process = self.target.LaunchSimple( self.process = self.target.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
self.assertTrue(self.process.IsValid(), PROCESS_IS_VALID) self.assertTrue(self.process.IsValid(), PROCESS_IS_VALID)
self.assertTrue( self.assertEqual(
self.process.GetState() == lldb.eStateStopped, self.process.GetState(), lldb.eStateStopped,
PROCESS_STOPPED) PROCESS_STOPPED)
self._test_globals() self._test_globals()
self.process.Continue() self.process.Continue()
self.assertTrue( self.assertEqual(
self.process.GetState() == lldb.eStateStopped, self.process.GetState(), lldb.eStateStopped,
PROCESS_STOPPED) PROCESS_STOPPED)
thread = lldbutil.get_stopped_thread( thread = lldbutil.get_stopped_thread(
self.process, lldb.eStopReasonBreakpoint) self.process, lldb.eStopReasonBreakpoint)
self.assertTrue(thread.IsValid()) self.assertTrue(thread.IsValid())
frame = thread.GetSelectedFrame() frame = thread.GetSelectedFrame()
self.assertTrue(frame.IsValid()) self.assertTrue(frame.IsValid())
self.enable_expression_log() self.enable_expression_log()
val = frame.EvaluateExpression("a") val = frame.EvaluateExpression("a")
self.disable_expression_log_and_check_for_locals(['a']) self.disable_expression_log_and_check_for_locals(['a'])
self.assertTrue(val.IsValid()) self.assertTrue(val.IsValid())
self.assertEqual(val.GetValueAsUnsigned(), 12345) self.assertEqual(val.GetValueAsUnsigned(), 12345)
val = frame.EvaluateExpression("b") val = frame.EvaluateExpression("b")
self.assertTrue(val.IsValid()) self.assertTrue(val.IsValid())
self.assertEqual(val.GetValueAsUnsigned(), 54321) self.assertEqual(val.GetValueAsUnsigned(), 54321)
val = frame.EvaluateExpression("c") val = frame.EvaluateExpression("c")
self.assertTrue(val.IsValid()) self.assertTrue(val.IsValid())
self.assertEqual(val.GetValueAsUnsigned(), 34567) self.assertEqual(val.GetValueAsUnsigned(), 34567)
self.process.Continue() self.process.Continue()
self.assertTrue( self.assertEqual(
self.process.GetState() == lldb.eStateStopped, self.process.GetState(), lldb.eStateStopped,
PROCESS_STOPPED) PROCESS_STOPPED)
thread = lldbutil.get_stopped_thread( thread = lldbutil.get_stopped_thread(
self.process, lldb.eStopReasonBreakpoint) self.process, lldb.eStopReasonBreakpoint)
self.assertTrue(thread.IsValid()) self.assertTrue(thread.IsValid())
frame = thread.GetSelectedFrame() frame = thread.GetSelectedFrame()
self.assertTrue(frame.IsValid()) self.assertTrue(frame.IsValid())
val = frame.EvaluateExpression("a") val = frame.EvaluateExpression("a")
Show All 10 Lines def test_when_stopped_in_function(self):
self.enable_expression_log() self.enable_expression_log()
val = frame.EvaluateExpression("c-b") val = frame.EvaluateExpression("c-b")
self.disable_expression_log_and_check_for_locals(['c','b']) self.disable_expression_log_and_check_for_locals(['c','b'])
self.assertTrue(val.IsValid()) self.assertTrue(val.IsValid())
self.assertEqual(val.GetValueAsUnsigned(), 1) self.assertEqual(val.GetValueAsUnsigned(), 1)
self.process.Continue() self.process.Continue()
self.assertTrue( self.assertEqual(
self.process.GetState() == lldb.eStateStopped, self.process.GetState(), lldb.eStateStopped,
PROCESS_STOPPED) PROCESS_STOPPED)
thread = lldbutil.get_stopped_thread( thread = lldbutil.get_stopped_thread(
self.process, lldb.eStopReasonBreakpoint) self.process, lldb.eStopReasonBreakpoint)
self.assertTrue(thread.IsValid()) self.assertTrue(thread.IsValid())
frame = thread.GetSelectedFrame() frame = thread.GetSelectedFrame()
self.assertTrue(frame.IsValid()) self.assertTrue(frame.IsValid())
val = frame.EvaluateExpression("a") val = frame.EvaluateExpression("a")
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

lldb/test/API/lang/cpp/nsimport/TestCppNsImport.py

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines def test_with_run_command(self):
# Launch the process # Launch the process
args = None args = None
env = None env = None
process = target.LaunchSimple( process = target.LaunchSimple(
args, env, self.get_process_working_directory()) args, env, self.get_process_working_directory())
self.assertTrue(process.IsValid(), PROCESS_IS_VALID) self.assertTrue(process.IsValid(), PROCESS_IS_VALID)
# Get the thread of the process # Get the thread of the process
self.assertTrue( self.assertEqual(
process.GetState() == lldb.eStateStopped, process.GetState(), lldb.eStateStopped,
PROCESS_STOPPED) PROCESS_STOPPED)
thread = lldbutil.get_stopped_thread( thread = lldbutil.get_stopped_thread(
process, lldb.eStopReasonBreakpoint) process, lldb.eStopReasonBreakpoint)
# Get current fream of the thread at the breakpoint # Get current fream of the thread at the breakpoint
frame = thread.GetSelectedFrame() frame = thread.GetSelectedFrame()
# Test imported namespaces # Test imported namespaces
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines def test_with_run_command(self):
self.assertTrue( self.assertTrue(
test_result.IsValid() and test_result.GetValueAsSigned() == 3, test_result.IsValid() and test_result.GetValueAsSigned() == 3,
"single = 3") "single = 3")
# Continue to second breakpoint # Continue to second breakpoint
process.Continue() process.Continue()
# Get the thread of the process # Get the thread of the process
self.assertTrue( self.assertEqual(
process.GetState() == lldb.eStateStopped, process.GetState(), lldb.eStateStopped,
PROCESS_STOPPED) PROCESS_STOPPED)
thread = lldbutil.get_stopped_thread( thread = lldbutil.get_stopped_thread(
process, lldb.eStopReasonBreakpoint) process, lldb.eStopReasonBreakpoint)
# Get current fream of the thread at the breakpoint # Get current fream of the thread at the breakpoint
frame = thread.GetSelectedFrame() frame = thread.GetSelectedFrame()
# Test function inside namespace # Test function inside namespace
test_result = frame.EvaluateExpression("fun_var") test_result = frame.EvaluateExpression("fun_var")
self.assertTrue( self.assertTrue(
test_result.IsValid() and test_result.GetValueAsSigned() == 5, test_result.IsValid() and test_result.GetValueAsSigned() == 5,
"fun_var = 5") "fun_var = 5")

lldb/test/API/lang/cpp/template/TestTemplateArgs.py

Show All 32 Lines def prepareProcess(self):
environment = None environment = None
# Now launch the process, and do not stop at entry point. # Now launch the process, and do not stop at entry point.
process = target.LaunchSimple( process = target.LaunchSimple(
arguments, environment, self.get_process_working_directory()) arguments, environment, self.get_process_working_directory())
self.assertTrue(process, PROCESS_IS_VALID) self.assertTrue(process, PROCESS_IS_VALID)
# Get the thread of the process # Get the thread of the process
self.assertTrue( self.assertEqual(
process.GetState() == lldb.eStateStopped, process.GetState(), lldb.eStateStopped,
PROCESS_STOPPED) PROCESS_STOPPED)
thread = lldbutil.get_stopped_thread( thread = lldbutil.get_stopped_thread(
process, lldb.eStopReasonBreakpoint) process, lldb.eStopReasonBreakpoint)
# Get frame for current thread # Get frame for current thread
return thread.GetSelectedFrame() return thread.GetSelectedFrame()
def test_integer_args(self): def test_integer_args(self):
frame = self.prepareProcess() frame = self.prepareProcess()
testpos = frame.FindVariable('testpos') testpos = frame.FindVariable('testpos')
self.assertTrue( self.assertTrue(
testpos.IsValid(), testpos.IsValid(),
'make sure we find a local variabble named "testpos"') 'make sure we find a local variabble named "testpos"')
self.assertEquals(testpos.GetType().GetName(), 'TestObj<1>') self.assertEquals(testpos.GetType().GetName(), 'TestObj<1>')
expr_result = frame.EvaluateExpression("testpos.getArg()") expr_result = frame.EvaluateExpression("testpos.getArg()")
self.assertTrue( self.assertTrue(
expr_result.IsValid(), expr_result.IsValid(),
'got a valid expression result from expression "testpos.getArg()"') 'got a valid expression result from expression "testpos.getArg()"')
self.assertEquals(expr_result.GetValue(), "1", "testpos.getArg() == 1") self.assertEquals(expr_result.GetValue(), "1", "testpos.getArg() == 1")
self.assertTrue( self.assertEqual(
expr_result.GetType().GetName() == "int", expr_result.GetType().GetName(), "int",
'expr_result.GetType().GetName() == "int"') 'expr_result.GetType().GetName() == "int"')
testneg = frame.FindVariable('testneg') testneg = frame.FindVariable('testneg')
self.assertTrue( self.assertTrue(
testneg.IsValid(), testneg.IsValid(),
'make sure we find a local variabble named "testneg"') 'make sure we find a local variabble named "testneg"')
self.assertEquals(testneg.GetType().GetName(), 'TestObj<-1>') self.assertEquals(testneg.GetType().GetName(), 'TestObj<-1>')
expr_result = frame.EvaluateExpression("testneg.getArg()") expr_result = frame.EvaluateExpression("testneg.getArg()")
self.assertTrue( self.assertTrue(
expr_result.IsValid(), expr_result.IsValid(),
'got a valid expression result from expression "testneg.getArg()"') 'got a valid expression result from expression "testneg.getArg()"')
self.assertTrue( self.assertEqual(
expr_result.GetValue() == "-1", expr_result.GetValue(), "-1",
"testneg.getArg() == -1") "testneg.getArg() == -1")
self.assertTrue( self.assertEqual(
expr_result.GetType().GetName() == "int", expr_result.GetType().GetName(), "int",
'expr_result.GetType().GetName() == "int"') 'expr_result.GetType().GetName() == "int"')
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489")
def test_template_template_args(self): def test_template_template_args(self):
frame = self.prepareProcess() frame = self.prepareProcess()
c1 = frame.FindVariable('c1') c1 = frame.FindVariable('c1')
self.assertTrue( self.assertTrue(
Show All 34 Lines def test_enum_args(self):
'make sure we find a local variabble named "member"') 'make sure we find a local variabble named "member"')
self.assertEqual(member.GetType().GetName(), self.assertEqual(member.GetType().GetName(),
'EnumTemplate<EnumType::Member>') 'EnumTemplate<EnumType::Member>')
expr_result = frame.EvaluateExpression("member.getMember()") expr_result = frame.EvaluateExpression("member.getMember()")
self.assertTrue( self.assertTrue(
expr_result.IsValid(), expr_result.IsValid(),
'got a valid expression result from expression "member.getMember()"') 'got a valid expression result from expression "member.getMember()"')
self.assertTrue( self.assertEqual(
expr_result.GetValue() == "123", expr_result.GetValue(), "123",
"member.getMember() == 123") "member.getMember() == 123")
self.assertTrue( self.assertEqual(
expr_result.GetType().GetName() == "int", expr_result.GetType().GetName(), "int",
'expr_result.GetType().GetName() == "int"') 'expr_result.GetType().GetName() == "int"')
# Make sure "subclass" can be displayed and also used in an expression # Make sure "subclass" can be displayed and also used in an expression
# correctly # correctly
subclass = frame.FindVariable('subclass') subclass = frame.FindVariable('subclass')
self.assertTrue( self.assertTrue(
subclass.IsValid(), subclass.IsValid(),
'make sure we find a local variabble named "subclass"') 'make sure we find a local variabble named "subclass"')
self.assertEqual(subclass.GetType().GetName(), self.assertEqual(subclass.GetType().GetName(),
'EnumTemplate<EnumType::Subclass>') 'EnumTemplate<EnumType::Subclass>')
expr_result = frame.EvaluateExpression("subclass.getMember()") expr_result = frame.EvaluateExpression("subclass.getMember()")
self.assertTrue( self.assertTrue(
expr_result.IsValid(), expr_result.IsValid(),
'got a valid expression result from expression "subclass.getMember()"') 'got a valid expression result from expression "subclass.getMember()"')
self.assertTrue( self.assertEqual(
expr_result.GetValue() == "246", expr_result.GetValue(), "246",
"subclass.getMember() == 246") "subclass.getMember() == 246")
self.assertTrue( self.assertEqual(
expr_result.GetType().GetName() == "int", expr_result.GetType().GetName(), "int",
'expr_result.GetType().GetName() == "int"') 'expr_result.GetType().GetName() == "int"')

lldb/test/API/lang/objc/blocks/TestObjCIvarsInBlocks.py

Show All 36 Lines def test_with_python_api(self):
breakpoint_two = target.BreakpointCreateBySourceRegex( breakpoint_two = target.BreakpointCreateBySourceRegex(
'// Break here inside the class method block.', self.class_source_file_spec) '// Break here inside the class method block.', self.class_source_file_spec)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
process = target.LaunchSimple( process = target.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
self.assertTrue(process, "Created a process.") self.assertTrue(process, "Created a process.")
self.assertTrue( self.assertEqual(
process.GetState() == lldb.eStateStopped, process.GetState(), lldb.eStateStopped,
"Stopped it too.") "Stopped it too.")
thread_list = lldbutil.get_threads_stopped_at_breakpoint( thread_list = lldbutil.get_threads_stopped_at_breakpoint(
process, breakpoint) process, breakpoint)
self.assertEqual(len(thread_list), 1) self.assertEqual(len(thread_list), 1)
thread = thread_list[0] thread = thread_list[0]
frame = thread.GetFrameAtIndex(0) frame = thread.GetFrameAtIndex(0)
Show All 13 Lines def test_with_python_api(self):
error = lldb.SBError() error = lldb.SBError()
direct_value = direct_blocky.GetValueAsSigned(error) direct_value = direct_blocky.GetValueAsSigned(error)
self.assertTrue(error.Success(), "Got direct value for blocky_ivar") self.assertTrue(error.Success(), "Got direct value for blocky_ivar")
indirect_value = indirect_blocky.GetValueAsSigned(error) indirect_value = indirect_blocky.GetValueAsSigned(error)
self.assertTrue(error.Success(), "Got indirect value for blocky_ivar") self.assertTrue(error.Success(), "Got indirect value for blocky_ivar")
self.assertTrue( self.assertEqual(
direct_value == indirect_value, direct_value, indirect_value,
"Direct and indirect values are equal.") "Direct and indirect values are equal.")
# Now make sure that we can get at the captured ivar through the expression parser. # Now make sure that we can get at the captured ivar through the expression parser.
# Doing a little trivial math will force this into the real expression # Doing a little trivial math will force this into the real expression
# parser: # parser:
direct_expr = frame.EvaluateExpression("blocky_ivar + 10") direct_expr = frame.EvaluateExpression("blocky_ivar + 10")
self.assertTrue( self.assertTrue(
direct_expr, direct_expr,
Show All 11 Lines def test_with_python_api(self):
error.Success(), error.Success(),
"Got value from direct use of expression parser") "Got value from direct use of expression parser")
indirect_value = indirect_expr.GetValueAsSigned(error) indirect_value = indirect_expr.GetValueAsSigned(error)
self.assertTrue( self.assertTrue(
error.Success(), error.Success(),
"Got value from indirect access using the expression parser") "Got value from indirect access using the expression parser")
self.assertTrue( self.assertEqual(
direct_value == indirect_value, direct_value, indirect_value,
"Direct ivar access and indirect through expression parser produce same value.") "Direct ivar access and indirect through expression parser produce same value.")
process.Continue() process.Continue()
self.assertTrue( self.assertEqual(
process.GetState() == lldb.eStateStopped, process.GetState(), lldb.eStateStopped,
"Stopped at the second breakpoint.") "Stopped at the second breakpoint.")
thread_list = lldbutil.get_threads_stopped_at_breakpoint( thread_list = lldbutil.get_threads_stopped_at_breakpoint(
process, breakpoint_two) process, breakpoint_two)
self.assertEqual(len(thread_list), 1) self.assertEqual(len(thread_list), 1)
thread = thread_list[0] thread = thread_list[0]
frame = thread.GetFrameAtIndex(0) frame = thread.GetFrameAtIndex(0)
self.assertTrue(frame, "frame 0 is valid") self.assertTrue(frame, "frame 0 is valid")
expr = frame.EvaluateExpression("(ret)") expr = frame.EvaluateExpression("(ret)")
self.assertTrue( self.assertTrue(
expr, "Successfully got a local variable in a block in a class method.") expr, "Successfully got a local variable in a block in a class method.")
ret_value_signed = expr.GetValueAsSigned(error) ret_value_signed = expr.GetValueAsSigned(error)
self.trace('ret_value_signed = %i' % (ret_value_signed)) self.trace('ret_value_signed = %i' % (ret_value_signed))
self.assertTrue( self.assertEqual(
ret_value_signed == 5, ret_value_signed, 5,
"The local variable in the block was what we expected.") "The local variable in the block was what we expected.")

lldb/test/API/lang/objc/foundation/TestObjCMethods.py

Show First 20 Lines • Show All 264 Lines • ▼ Show 20 Lines def test_print_ivars_correctly(self):
my_str_var = my_var.GetChildMemberWithName("str") my_str_var = my_var.GetChildMemberWithName("str")
self.assertTrue(my_str_var, "Found a str ivar in my") self.assertTrue(my_str_var, "Found a str ivar in my")
str_value = int(str_var.GetValue(), 0) str_value = int(str_var.GetValue(), 0)
my_str_value = int(my_str_var.GetValue(), 0) my_str_value = int(my_str_var.GetValue(), 0)
self.assertTrue( self.assertEqual(
str_value == my_str_value, str_value, my_str_value,
"Got the correct value for my->str") "Got the correct value for my->str")
def test_expression_lookups_objc(self): def test_expression_lookups_objc(self):
"""Test running an expression detect spurious debug info lookups (DWARF).""" """Test running an expression detect spurious debug info lookups (DWARF)."""
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getBuildArtifact("a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

lldb/test/API/lang/objc/global_ptrs/TestGlobalObjects.py

Show All 26 Lines def test_with_python_api(self):
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
bkpt = target.BreakpointCreateBySourceRegex('NSLog', self.main_source) bkpt = target.BreakpointCreateBySourceRegex('NSLog', self.main_source)
self.assertTrue(bkpt, VALID_BREAKPOINT) self.assertTrue(bkpt, VALID_BREAKPOINT)
# Before we launch, make an SBValue for our global object pointer: # Before we launch, make an SBValue for our global object pointer:
g_obj_ptr = target.FindFirstGlobalVariable("g_obj_ptr") g_obj_ptr = target.FindFirstGlobalVariable("g_obj_ptr")
self.assertTrue(g_obj_ptr.GetError().Success(), "Made the g_obj_ptr") self.assertTrue(g_obj_ptr.GetError().Success(), "Made the g_obj_ptr")
self.assertTrue( self.assertEqual(
g_obj_ptr.GetValueAsUnsigned(10) == 0, g_obj_ptr.GetValueAsUnsigned(10), 0,
"g_obj_ptr is initially null") "g_obj_ptr is initially null")
# Now launch the process, and do not stop at entry point. # Now launch the process, and do not stop at entry point.
process = target.LaunchSimple( process = target.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
self.assertTrue(process, PROCESS_IS_VALID) self.assertTrue(process, PROCESS_IS_VALID)
Show All 12 Lines

lldb/test/API/lang/objc/objc-baseclass-sbtype/TestObjCBaseClassSBType.py

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines def test_get_baseclass(self):
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
self.assertEquals(process.GetState(), lldb.eStateStopped, self.assertEquals(process.GetState(), lldb.eStateStopped,
PROCESS_STOPPED) PROCESS_STOPPED)
var = self.frame().FindVariable("foo") var = self.frame().FindVariable("foo")
var_ptr_type = var.GetType() var_ptr_type = var.GetType()
var_pte_type = var_ptr_type.GetPointeeType() var_pte_type = var_ptr_type.GetPointeeType()
self.assertTrue( self.assertEqual(
var_ptr_type.GetNumberOfDirectBaseClasses() == 1, var_ptr_type.GetNumberOfDirectBaseClasses(), 1,
"Foo * has one base class") "Foo * has one base class")
self.assertTrue( self.assertEqual(
var_pte_type.GetNumberOfDirectBaseClasses() == 1, var_pte_type.GetNumberOfDirectBaseClasses(), 1,
"Foo has one base class") "Foo has one base class")
self.assertTrue(var_ptr_type.GetDirectBaseClassAtIndex( self.assertTrue(var_ptr_type.GetDirectBaseClassAtIndex(
0).IsValid(), "Foo * has a valid base class") 0).IsValid(), "Foo * has a valid base class")
self.assertTrue(var_pte_type.GetDirectBaseClassAtIndex( self.assertTrue(var_pte_type.GetDirectBaseClassAtIndex(
0).IsValid(), "Foo * has a valid base class") 0).IsValid(), "Foo * has a valid base class")
self.assertEquals(var_ptr_type.GetDirectBaseClassAtIndex(0).GetName(), var_pte_type.GetDirectBaseClassAtIndex( self.assertEquals(var_ptr_type.GetDirectBaseClassAtIndex(0).GetName(), var_pte_type.GetDirectBaseClassAtIndex(
0).GetName(), "Foo and its pointer type don't agree on their base class") 0).GetName(), "Foo and its pointer type don't agree on their base class")

lldb/test/API/lang/objc/objc-dyn-sbtype/TestObjCDynamicSBType.py

Show All 40 Lines def test_dyn(self):
loc_exact=True) loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
v_object = self.frame().FindVariable( v_object = self.frame().FindVariable(
"object").GetDynamicValue(lldb.eDynamicCanRunTarget) "object").GetDynamicValue(lldb.eDynamicCanRunTarget)
v_base = self.frame().FindVariable( v_base = self.frame().FindVariable(
"base").GetDynamicValue(lldb.eDynamicCanRunTarget) "base").GetDynamicValue(lldb.eDynamicCanRunTarget)
self.assertTrue( self.assertEqual(
v_object.GetTypeName() == "MyDerivedClass *", v_object.GetTypeName(), "MyDerivedClass *",
"The NSObject is properly type-named") "The NSObject is properly type-named")
self.assertTrue( self.assertEqual(
v_base.GetTypeName() == "MyDerivedClass *", v_base.GetTypeName(), "MyDerivedClass *",
"The Base is properly type-named") "The Base is properly type-named")
object_type = v_object.GetType() object_type = v_object.GetType()
base_type = v_base.GetType() base_type = v_base.GetType()
self.assertTrue( self.assertEqual(
object_type.GetName() == "MyDerivedClass *", object_type.GetName(), "MyDerivedClass *",
"The dynamic SBType for NSObject is for the correct type") "The dynamic SBType for NSObject is for the correct type")
self.assertTrue( self.assertEqual(
base_type.GetName() == "MyDerivedClass *", base_type.GetName(), "MyDerivedClass *",
"The dynamic SBType for Base is for the correct type") "The dynamic SBType for Base is for the correct type")
object_pointee_type = object_type.GetPointeeType() object_pointee_type = object_type.GetPointeeType()
base_pointee_type = base_type.GetPointeeType() base_pointee_type = base_type.GetPointeeType()
self.assertTrue( self.assertEqual(
object_pointee_type.GetName() == "MyDerivedClass", object_pointee_type.GetName(), "MyDerivedClass",
"The dynamic type for NSObject figures out its pointee type just fine") "The dynamic type for NSObject figures out its pointee type just fine")
self.assertTrue( self.assertEqual(
base_pointee_type.GetName() == "MyDerivedClass", base_pointee_type.GetName(), "MyDerivedClass",
"The dynamic type for Base figures out its pointee type just fine") "The dynamic type for Base figures out its pointee type just fine")
self.assertTrue( self.assertEqual(
object_pointee_type.GetDirectBaseClassAtIndex(0).GetName() == "MyBaseClass", object_pointee_type.GetDirectBaseClassAtIndex(0).GetName(), "MyBaseClass",
"The dynamic type for NSObject can go back to its base class") "The dynamic type for NSObject can go back to its base class")
self.assertTrue( self.assertEqual(
base_pointee_type.GetDirectBaseClassAtIndex(0).GetName() == "MyBaseClass", base_pointee_type.GetDirectBaseClassAtIndex(0).GetName(), "MyBaseClass",
"The dynamic type for Base can go back to its base class") "The dynamic type for Base can go back to its base class")
self.assertTrue(object_pointee_type.GetDirectBaseClassAtIndex(0).GetType().GetDirectBaseClassAtIndex( self.assertTrue(object_pointee_type.GetDirectBaseClassAtIndex(0).GetType().GetDirectBaseClassAtIndex(
0).GetName() == "NSObject", "The dynamic type for NSObject can go up the hierarchy") 0).GetName() == "NSObject", "The dynamic type for NSObject can go up the hierarchy")
self.assertTrue(base_pointee_type.GetDirectBaseClassAtIndex(0).GetType().GetDirectBaseClassAtIndex( self.assertTrue(base_pointee_type.GetDirectBaseClassAtIndex(0).GetType().GetDirectBaseClassAtIndex(
0).GetName() == "NSObject", "The dynamic type for Base can go up the hierarchy") 0).GetName() == "NSObject", "The dynamic type for Base can go up the hierarchy")
self.assertTrue( self.assertEqual(
object_pointee_type.GetNumberOfFields() == 2, object_pointee_type.GetNumberOfFields(), 2,
"The dynamic type for NSObject has 2 fields") "The dynamic type for NSObject has 2 fields")
self.assertTrue( self.assertEqual(
base_pointee_type.GetNumberOfFields() == 2, base_pointee_type.GetNumberOfFields(), 2,
"The dynamic type for Base has 2 fields") "The dynamic type for Base has 2 fields")

lldb/test/API/lang/objc/objc-ivar-offsets/TestObjCIvarOffsets.py

Show All 30 Lines def test_with_python_api(self):
breakpoint = target.BreakpointCreateByLocation( breakpoint = target.BreakpointCreateByLocation(
self.main_source, self.stop_line) self.main_source, self.stop_line)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
process = target.LaunchSimple( process = target.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
self.assertTrue(process, "Created a process.") self.assertTrue(process, "Created a process.")
self.assertTrue( self.assertEqual(
process.GetState() == lldb.eStateStopped, process.GetState(), lldb.eStateStopped,
"Stopped it too.") "Stopped it too.")
thread_list = lldbutil.get_threads_stopped_at_breakpoint( thread_list = lldbutil.get_threads_stopped_at_breakpoint(
process, breakpoint) process, breakpoint)
self.assertEquals(len(thread_list), 1) self.assertEquals(len(thread_list), 1)
thread = thread_list[0] thread = thread_list[0]
frame = thread.GetFrameAtIndex(0) frame = thread.GetFrameAtIndex(0)
Show All 34 Lines

lldb/test/API/lang/objc/objc-ivar-stripped/TestObjCIvarStripped.py

Show All 37 Lines def test_with_python_api(self):
self.main_source, self.stop_line) self.main_source, self.stop_line)
self.assertTrue( self.assertTrue(
breakpoint.IsValid() and breakpoint.GetNumLocations() > 0, breakpoint.IsValid() and breakpoint.GetNumLocations() > 0,
VALID_BREAKPOINT) VALID_BREAKPOINT)
process = target.LaunchSimple( process = target.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
self.assertTrue(process, "Created a process.") self.assertTrue(process, "Created a process.")
self.assertTrue( self.assertEqual(
process.GetState() == lldb.eStateStopped, process.GetState(), lldb.eStateStopped,
"Stopped it too.") "Stopped it too.")
thread_list = lldbutil.get_threads_stopped_at_breakpoint( thread_list = lldbutil.get_threads_stopped_at_breakpoint(
process, breakpoint) process, breakpoint)
self.assertEquals(len(thread_list), 1) self.assertEquals(len(thread_list), 1)
thread = thread_list[0] thread = thread_list[0]
frame = thread.GetFrameAtIndex(0) frame = thread.GetFrameAtIndex(0)
Show All 11 Lines

lldb/test/API/lang/objc/objc-static-method-stripped/TestObjCStaticMethodStripped.py

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines def test_with_python_api(self):
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
self.assertTrue(process, PROCESS_IS_VALID) self.assertTrue(process, PROCESS_IS_VALID)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
thread_list = lldbutil.get_threads_stopped_at_breakpoint(process, bpt) thread_list = lldbutil.get_threads_stopped_at_breakpoint(process, bpt)
# Make sure we stopped at the first breakpoint. # Make sure we stopped at the first breakpoint.
self.assertTrue( self.assertNotEqual(
len(thread_list) != 0, len(thread_list), 0,
"No thread stopped at our breakpoint.") "No thread stopped at our breakpoint.")
self.assertEquals(len(thread_list), 1, self.assertEquals(len(thread_list), 1,
"More than one thread stopped at our breakpoint.") "More than one thread stopped at our breakpoint.")
# Now make sure we can call a function in the static method we've # Now make sure we can call a function in the static method we've
# stopped in. # stopped in.
frame = thread_list[0].GetFrameAtIndex(0) frame = thread_list[0].GetFrameAtIndex(0)
self.assertTrue(frame, "Got a valid frame 0 frame.") self.assertTrue(frame, "Got a valid frame 0 frame.")
cmd_value = frame.EvaluateExpression("(char *) sel_getName (_cmd)") cmd_value = frame.EvaluateExpression("(char *) sel_getName (_cmd)")
self.assertTrue(cmd_value.IsValid()) self.assertTrue(cmd_value.IsValid())
sel_name = cmd_value.GetSummary() sel_name = cmd_value.GetSummary()
self.assertTrue( self.assertEqual(
sel_name == "\"doSomethingWithString:\"", sel_name, "\"doSomethingWithString:\"",
"Got the right value for the selector as string.") "Got the right value for the selector as string.")
cmd_value = frame.EvaluateExpression( cmd_value = frame.EvaluateExpression(
"[Foo doSomethingElseWithString:string]") "[Foo doSomethingElseWithString:string]")
self.assertTrue(cmd_value.IsValid()) self.assertTrue(cmd_value.IsValid())
string_length = cmd_value.GetValueAsUnsigned() string_length = cmd_value.GetValueAsUnsigned()
self.assertTrue( self.assertEqual(
string_length == 27, string_length, 27,
"Got the right value from another class method on the same class.") "Got the right value from another class method on the same class.")

lldb/test/API/lang/objc/objc-static-method/TestObjCStaticMethod.py

Show All 38 Lines def test_with_python_api(self):
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
self.assertTrue(process, PROCESS_IS_VALID) self.assertTrue(process, PROCESS_IS_VALID)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
thread_list = lldbutil.get_threads_stopped_at_breakpoint(process, bpt) thread_list = lldbutil.get_threads_stopped_at_breakpoint(process, bpt)
# Make sure we stopped at the first breakpoint. # Make sure we stopped at the first breakpoint.
self.assertTrue( self.assertNotEqual(
len(thread_list) != 0, len(thread_list), 0,
"No thread stopped at our breakpoint.") "No thread stopped at our breakpoint.")
self.assertEquals(len(thread_list), 1, self.assertEquals(len(thread_list), 1,
"More than one thread stopped at our breakpoint.") "More than one thread stopped at our breakpoint.")
# Now make sure we can call a function in the static method we've # Now make sure we can call a function in the static method we've
# stopped in. # stopped in.
frame = thread_list[0].GetFrameAtIndex(0) frame = thread_list[0].GetFrameAtIndex(0)
self.assertTrue(frame, "Got a valid frame 0 frame.") self.assertTrue(frame, "Got a valid frame 0 frame.")
cmd_value = frame.EvaluateExpression("(char *) sel_getName (_cmd)") cmd_value = frame.EvaluateExpression("(char *) sel_getName (_cmd)")
self.assertTrue(cmd_value.IsValid()) self.assertTrue(cmd_value.IsValid())
sel_name = cmd_value.GetSummary() sel_name = cmd_value.GetSummary()
self.assertTrue( self.assertEqual(
sel_name == "\"doSomethingWithString:\"", sel_name, "\"doSomethingWithString:\"",
"Got the right value for the selector as string.") "Got the right value for the selector as string.")
cmd_value = frame.EvaluateExpression( cmd_value = frame.EvaluateExpression(
"[self doSomethingElseWithString:string]") "[self doSomethingElseWithString:string]")
self.assertTrue(cmd_value.IsValid()) self.assertTrue(cmd_value.IsValid())
string_length = cmd_value.GetValueAsUnsigned() string_length = cmd_value.GetValueAsUnsigned()
self.assertTrue( self.assertEqual(
string_length == 27, string_length, 27,
"Got the right value from another class method on the same class.") "Got the right value from another class method on the same class.")

lldb/test/API/lang/objc/objc-stepping/TestObjCStepping.py

Show First 20 Lines • Show All 208 Lines • ▼ Show 20 Lines def test_with_python_api(self):
for bkpt in breakpoints_to_disable: for bkpt in breakpoints_to_disable:
bkpt.SetEnabled(False) bkpt.SetEnabled(False)
threads = lldbutil.continue_to_breakpoint(process, break_step_nil) threads = lldbutil.continue_to_breakpoint(process, break_step_nil)
self.assertEqual(len(threads), 1, "Continued to step nil breakpoint.") self.assertEqual(len(threads), 1, "Continued to step nil breakpoint.")
thread.StepInto() thread.StepInto()
line_number = thread.GetFrameAtIndex(0).GetLineEntry().GetLine() line_number = thread.GetFrameAtIndex(0).GetLineEntry().GetLine()
self.assertTrue( self.assertEqual(
line_number == self.stepped_past_nil_line, line_number, self.stepped_past_nil_line,
"Step in over dispatch to nil stepped over.") "Step in over dispatch to nil stepped over.")

lldb/test/API/lang/objc/single-entry-dictionary/TestObjCSingleEntryDictionary.py

Show All 40 Lines def test_single_entry_dict(self):
# The breakpoint should have a hit count of 1. # The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
substrs=[' resolved, hit count = 1']) substrs=[' resolved, hit count = 1'])
d1 = self.frame().FindVariable("d1") d1 = self.frame().FindVariable("d1")
d1.SetPreferSyntheticValue(True) d1.SetPreferSyntheticValue(True)
d1.SetPreferDynamicValue(lldb.eDynamicCanRunTarget) d1.SetPreferDynamicValue(lldb.eDynamicCanRunTarget)
self.assertTrue( self.assertEqual(
d1.GetNumChildren() == 1, d1.GetNumChildren(), 1,
"dictionary has != 1 child elements") "dictionary has != 1 child elements")
pair = d1.GetChildAtIndex(0) pair = d1.GetChildAtIndex(0)
pair.SetPreferSyntheticValue(True) pair.SetPreferSyntheticValue(True)
pair.SetPreferDynamicValue(lldb.eDynamicCanRunTarget) pair.SetPreferDynamicValue(lldb.eDynamicCanRunTarget)
self.assertTrue( self.assertEqual(
pair.GetNumChildren() == 2, pair.GetNumChildren(), 2,
"pair has != 2 child elements") "pair has != 2 child elements")
key = pair.GetChildMemberWithName("key") key = pair.GetChildMemberWithName("key")
value = pair.GetChildMemberWithName("value") value = pair.GetChildMemberWithName("value")
key.SetPreferSyntheticValue(True) key.SetPreferSyntheticValue(True)
key.SetPreferDynamicValue(lldb.eDynamicCanRunTarget) key.SetPreferDynamicValue(lldb.eDynamicCanRunTarget)
value.SetPreferSyntheticValue(True) value.SetPreferSyntheticValue(True)
value.SetPreferDynamicValue(lldb.eDynamicCanRunTarget) value.SetPreferDynamicValue(lldb.eDynamicCanRunTarget)
self.assertTrue( self.assertEqual(
key.GetSummary() == '@"key"', key.GetSummary(), '@"key"',
"key doesn't contain key") "key doesn't contain key")
self.assertTrue( self.assertEqual(
value.GetSummary() == '@"value"', value.GetSummary(), '@"value"',
"value doesn't contain value") "value doesn't contain value")

lldb/test/API/macosx/indirect_symbol/TestIndirectSymbols.py

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Lines def test_with_python_api(self):
# get to that: # get to that:
break_indirect = target.BreakpointCreateByName("call_through_indirect") break_indirect = target.BreakpointCreateByName("call_through_indirect")
self.assertTrue(break_indirect, VALID_BREAKPOINT) self.assertTrue(break_indirect, VALID_BREAKPOINT)
# Now continue should take us to the second call through the indirect # Now continue should take us to the second call through the indirect
# symbol: # symbol:
threads = lldbutil.continue_to_breakpoint(process, break_indirect) threads = lldbutil.continue_to_breakpoint(process, break_indirect)
self.assertTrue( self.assertEqual(
len(threads) == 1, len(threads), 1,
"Stopped at breakpoint in indirect function.") "Stopped at breakpoint in indirect function.")
curr_function = thread.GetFrameAtIndex(0).GetFunctionName() curr_function = thread.GetFrameAtIndex(0).GetFunctionName()
self.assertTrue( self.assertEqual(
curr_function == "call_through_indirect_hidden", curr_function, "call_through_indirect_hidden",
"Stepped into indirect symbols.") "Stepped into indirect symbols.")
# Delete this breakpoint so it won't get in the way: # Delete this breakpoint so it won't get in the way:
target.BreakpointDelete(break_indirect.GetID()) target.BreakpointDelete(break_indirect.GetID())
# Now continue to the site of the first re-exported function call in # Now continue to the site of the first re-exported function call in
# main: # main:
threads = lldbutil.continue_to_breakpoint(process, break2) threads = lldbutil.continue_to_breakpoint(process, break2)
# This is stepping Into through a re-exported symbol to an indirect # This is stepping Into through a re-exported symbol to an indirect
# symbol: # symbol:
thread.StepInto() thread.StepInto()
curr_function = thread.GetFrameAtIndex(0).GetFunctionName() curr_function = thread.GetFrameAtIndex(0).GetFunctionName()
self.assertTrue( self.assertEqual(
curr_function == "call_through_indirect_hidden", curr_function, "call_through_indirect_hidden",
"Stepped into indirect symbols.") "Stepped into indirect symbols.")
# And the last bit is to set a breakpoint on the re-exported symbol and # And the last bit is to set a breakpoint on the re-exported symbol and
# make sure we are again in out target function. # make sure we are again in out target function.
break_reexported = target.BreakpointCreateByName( break_reexported = target.BreakpointCreateByName(
"reexport_to_indirect") "reexport_to_indirect")
self.assertTrue(break_reexported, VALID_BREAKPOINT) self.assertTrue(break_reexported, VALID_BREAKPOINT)
# Now continue should take us to the second call through the indirect # Now continue should take us to the second call through the indirect
# symbol: # symbol:
threads = lldbutil.continue_to_breakpoint(process, break_reexported) threads = lldbutil.continue_to_breakpoint(process, break_reexported)
self.assertTrue( self.assertEqual(
len(threads) == 1, len(threads), 1,
"Stopped at breakpoint in reexported function target.") "Stopped at breakpoint in reexported function target.")
curr_function = thread.GetFrameAtIndex(0).GetFunctionName() curr_function = thread.GetFrameAtIndex(0).GetFunctionName()
self.assertTrue( self.assertEqual(
curr_function == "call_through_indirect_hidden", curr_function, "call_through_indirect_hidden",
"Stepped into indirect symbols.") "Stepped into indirect symbols.")

lldb/test/API/macosx/queues/TestQueues.py

Show All 36 Linesclass TestQueues(TestBase):
def check_queue_for_valid_queue_id(self, queue): def check_queue_for_valid_queue_id(self, queue):
self.assertTrue( self.assertTrue(
queue.GetQueueID() != 0, "Check queue %s for valid QueueID (got 0x%x)" % queue.GetQueueID() != 0, "Check queue %s for valid QueueID (got 0x%x)" %
(queue.GetName(), queue.GetQueueID())) (queue.GetName(), queue.GetQueueID()))
def check_running_and_pending_items_on_queue( def check_running_and_pending_items_on_queue(
self, queue, expected_running, expected_pending): self, queue, expected_running, expected_pending):
self.assertTrue( self.assertEqual(
queue.GetNumPendingItems() == expected_pending, queue.GetNumPendingItems(), expected_pending,
"queue %s should have %d pending items, instead has %d pending items" % "queue %s should have %d pending items, instead has %d pending items" %
(queue.GetName(), (queue.GetName(),
expected_pending, expected_pending,
(queue.GetNumPendingItems()))) (queue.GetNumPendingItems())))
self.assertTrue( self.assertEqual(
queue.GetNumRunningItems() == expected_running, queue.GetNumRunningItems(), expected_running,
"queue %s should have %d running items, instead has %d running items" % "queue %s should have %d running items, instead has %d running items" %
(queue.GetName(), (queue.GetName(),
expected_running, expected_running,
(queue.GetNumRunningItems()))) (queue.GetNumRunningItems())))
def describe_threads(self): def describe_threads(self):
desc = [] desc = []
for x in self.inferior_process: for x in self.inferior_process:
id = x.GetIndexID() id = x.GetIndexID()
reason_str = lldbutil.stop_reason_to_str(x.GetStopReason()) reason_str = lldbutil.stop_reason_to_str(x.GetStopReason())
location = "\t".join([lldbutil.get_description( location = "\t".join([lldbutil.get_description(
x.GetFrameAtIndex(i)) for i in range(x.GetNumFrames())]) x.GetFrameAtIndex(i)) for i in range(x.GetNumFrames())])
desc.append( desc.append(
"thread %d: %s (queue id: %s) at\n\t%s" % "thread %d: %s (queue id: %s) at\n\t%s" %
(id, reason_str, x.GetQueueID(), location)) (id, reason_str, x.GetQueueID(), location))
print('\n'.join(desc)) print('\n'.join(desc))
def check_number_of_threads_owned_by_queue(self, queue, number_threads): def check_number_of_threads_owned_by_queue(self, queue, number_threads):
if (queue.GetNumThreads() != number_threads): if (queue.GetNumThreads() != number_threads):
self.describe_threads() self.describe_threads()
self.assertTrue( self.assertEqual(
queue.GetNumThreads() == number_threads, queue.GetNumThreads(), number_threads,
"queue %s should have %d thread executing, but has %d" % "queue %s should have %d thread executing, but has %d" %
(queue.GetName(), (queue.GetName(),
number_threads, number_threads,
queue.GetNumThreads())) queue.GetNumThreads()))
def check_queue_kind(self, queue, kind): def check_queue_kind(self, queue, kind):
expected_kind_string = "Unknown" expected_kind_string = "Unknown"
if kind == lldb.eQueueKindSerial: if kind == lldb.eQueueKindSerial:
expected_kind_string = "Serial queue" expected_kind_string = "Serial queue"
if kind == lldb.eQueueKindConcurrent: if kind == lldb.eQueueKindConcurrent:
expected_kind_string = "Concurrent queue" expected_kind_string = "Concurrent queue"
actual_kind_string = "Unknown" actual_kind_string = "Unknown"
if queue.GetKind() == lldb.eQueueKindSerial: if queue.GetKind() == lldb.eQueueKindSerial:
actual_kind_string = "Serial queue" actual_kind_string = "Serial queue"
if queue.GetKind() == lldb.eQueueKindConcurrent: if queue.GetKind() == lldb.eQueueKindConcurrent:
actual_kind_string = "Concurrent queue" actual_kind_string = "Concurrent queue"
self.assertTrue( self.assertEqual(
queue.GetKind() == kind, queue.GetKind(), kind,
"queue %s is expected to be a %s but it is actually a %s" % "queue %s is expected to be a %s but it is actually a %s" %
(queue.GetName(), (queue.GetName(),
expected_kind_string, expected_kind_string,
actual_kind_string)) actual_kind_string))
def check_queues_threads_match_queue(self, queue): def check_queues_threads_match_queue(self, queue):
for idx in range(0, queue.GetNumThreads()): for idx in range(0, queue.GetNumThreads()):
t = queue.GetThreadAtIndex(idx) t = queue.GetThreadAtIndex(idx)
self.assertTrue( self.assertTrue(
t.IsValid(), "Queue %s's thread #%d must be valid" % t.IsValid(), "Queue %s's thread #%d must be valid" %
(queue.GetName(), idx)) (queue.GetName(), idx))
self.assertTrue( self.assertEqual(
t.GetQueueID() == queue.GetQueueID(), t.GetQueueID(), queue.GetQueueID(),
"Queue %s has a QueueID of %d but its thread #%d has a QueueID of %d" % "Queue %s has a QueueID of %d but its thread #%d has a QueueID of %d" %
(queue.GetName(), (queue.GetName(),
queue.GetQueueID(), queue.GetQueueID(),
idx, idx,
t.GetQueueID())) t.GetQueueID()))
self.assertTrue( self.assertEqual(
t.GetQueueName() == queue.GetName(), t.GetQueueName(), queue.GetName(),
"Queue %s has a QueueName of %s but its thread #%d has a QueueName of %s" % "Queue %s has a QueueName of %s but its thread #%d has a QueueName of %s" %
(queue.GetName(), (queue.GetName(),
queue.GetName(), queue.GetName(),
idx, idx,
t.GetQueueName())) t.GetQueueName()))
self.assertTrue( self.assertEqual(
t.GetQueue().GetQueueID() == queue.GetQueueID(), t.GetQueue().GetQueueID(), queue.GetQueueID(),
"Thread #%d's Queue's QueueID of %d is not the same as the QueueID of its owning queue %d" % "Thread #%d's Queue's QueueID of %d is not the same as the QueueID of its owning queue %d" %
(idx, (idx,
t.GetQueue().GetQueueID(), t.GetQueue().GetQueueID(),
queue.GetQueueID())) queue.GetQueueID()))
def queues(self): def queues(self):
"""Test queues inspection SB APIs without libBacktraceRecording.""" """Test queues inspection SB APIs without libBacktraceRecording."""
exe = self.getBuildArtifact("a.out") exe = self.getBuildArtifact("a.out")
▲ Show 20 Lines • Show All 229 Lines • ▼ Show 20 Lines def queues_with_libBacktraceRecording(self):
self.check_queues_threads_match_queue(queue_performer_1) self.check_queues_threads_match_queue(queue_performer_1)
self.check_queues_threads_match_queue(queue_performer_2) self.check_queues_threads_match_queue(queue_performer_2)
self.check_queues_threads_match_queue(queue_performer_3) self.check_queues_threads_match_queue(queue_performer_3)
self.assertTrue(queue_performer_2.GetPendingItemAtIndex( self.assertTrue(queue_performer_2.GetPendingItemAtIndex(
0).IsValid(), "queue 2's pending item #0 is valid") 0).IsValid(), "queue 2's pending item #0 is valid")
self.assertTrue(queue_performer_2.GetPendingItemAtIndex(0).GetAddress().GetSymbol( self.assertTrue(queue_performer_2.GetPendingItemAtIndex(0).GetAddress().GetSymbol(
).GetName() == "doing_the_work_2", "queue 2's pending item #0 should be doing_the_work_2") ).GetName() == "doing_the_work_2", "queue 2's pending item #0 should be doing_the_work_2")
self.assertTrue( self.assertEqual(
queue_performer_2.GetNumPendingItems() == 9999, queue_performer_2.GetNumPendingItems(), 9999,
"verify that queue 2 still has 9999 pending items") "verify that queue 2 still has 9999 pending items")
self.assertTrue(queue_performer_2.GetPendingItemAtIndex( self.assertTrue(queue_performer_2.GetPendingItemAtIndex(
9998).IsValid(), "queue 2's pending item #9998 is valid") 9998).IsValid(), "queue 2's pending item #9998 is valid")
self.assertTrue(queue_performer_2.GetPendingItemAtIndex(9998).GetAddress().GetSymbol( self.assertTrue(queue_performer_2.GetPendingItemAtIndex(9998).GetAddress().GetSymbol(
).GetName() == "doing_the_work_2", "queue 2's pending item #0 should be doing_the_work_2") ).GetName() == "doing_the_work_2", "queue 2's pending item #0 should be doing_the_work_2")
self.assertTrue(queue_performer_2.GetPendingItemAtIndex( self.assertTrue(queue_performer_2.GetPendingItemAtIndex(
9999).IsValid() == False, "queue 2's pending item #9999 is invalid") 9999).IsValid() == False, "queue 2's pending item #9999 is invalid")

lldb/test/API/macosx/safe-to-func-call/TestSafeFuncCalls.py

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines def test_with_python_api(self):
select_thread = t select_thread = t
self.assertTrue( self.assertTrue(
main_thread.IsValid() and select_thread.IsValid(), main_thread.IsValid() and select_thread.IsValid(),
"Got both expected threads") "Got both expected threads")
self.assertTrue(main_thread.SafeToCallFunctions(), self.assertTrue(main_thread.SafeToCallFunctions(),
"It is safe to call functions on the main thread") "It is safe to call functions on the main thread")
self.assertTrue( self.assertEqual(
select_thread.SafeToCallFunctions() == False, select_thread.SafeToCallFunctions(), False,
"It is not safe to call functions on the select thread") "It is not safe to call functions on the select thread")

lldb/test/API/macosx/thread-names/TestInterruptThreadNames.py

Show First 20 Lines • Show All 120 Lines • ▼ Show 20 Lines def wait_for_stop(self, process, listener):
return False return False
retry_count = retry_count - 1 retry_count = retry_count - 1
return False return False
def check_number_of_threads(self, process): def check_number_of_threads(self, process):
self.assertTrue( self.assertEqual(
process.GetNumThreads() == 3, process.GetNumThreads(), 3,
"Check that the process has three threads when sitting at the stopper() breakpoint") "Check that the process has three threads when sitting at the stopper() breakpoint")
def check_expected_threads_present(self, main_thread, second_thread, third_thread): def check_expected_threads_present(self, main_thread, second_thread, third_thread):
self.assertTrue( self.assertTrue(
main_thread.IsValid() and second_thread.IsValid() and third_thread.IsValid(), main_thread.IsValid() and second_thread.IsValid() and third_thread.IsValid(),
"Got all three expected threads") "Got all three expected threads")

lldb/test/API/python_api/event/TestEvents.py

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines def test_listen_for_and_print_event(self):
None, # stdin_path None, # stdin_path
None, # stdout_path None, # stdout_path
None, # stderr_path None, # stderr_path
None, # working directory None, # working directory
flags, # launch flags flags, # launch flags
False, # Stop at entry False, # Stop at entry
error) # error error) # error
self.assertTrue( self.assertEqual(
process.GetState() == lldb.eStateStopped, process.GetState(), lldb.eStateStopped,
PROCESS_STOPPED) PROCESS_STOPPED)
# Create an empty event object. # Create an empty event object.
event = lldb.SBEvent() event = lldb.SBEvent()
traceOn = self.TraceOn() traceOn = self.TraceOn()
if traceOn: if traceOn:
lldbutil.print_stacktraces(process) lldbutil.print_stacktraces(process)
▲ Show 20 Lines • Show All 245 Lines • Show Last 20 Lines

lldb/test/API/python_api/formatters/TestFormattersSBAPI.py

Show First 20 Lines • Show All 122 Lines • ▼ Show 20 Lines def test_formatters_api(self):
self.expect("frame variable foo.B", matching=False, self.expect("frame variable foo.B", matching=False,
substrs=['hello world']) substrs=['hello world'])
self.expect("frame variable foo.F", matching=False, self.expect("frame variable foo.F", matching=False,
substrs=['hello world']) substrs=['hello world'])
filter = lldb.SBTypeFilter(0) filter = lldb.SBTypeFilter(0)
filter.AppendExpressionPath("A") filter.AppendExpressionPath("A")
filter.AppendExpressionPath("D") filter.AppendExpressionPath("D")
self.assertTrue( self.assertEqual(
filter.GetNumberOfExpressionPaths() == 2, filter.GetNumberOfExpressionPaths(), 2,
"filter with two items does not have two items") "filter with two items does not have two items")
category.AddTypeFilter(lldb.SBTypeNameSpecifier("JustAStruct"), filter) category.AddTypeFilter(lldb.SBTypeNameSpecifier("JustAStruct"), filter)
self.expect("frame variable foo", self.expect("frame variable foo",
substrs=['A = 1', 'D = 6.28']) substrs=['A = 1', 'D = 6.28'])
self.expect("frame variable foo", matching=False, self.expect("frame variable foo", matching=False,
substrs=['B = ', 'C = ', 'E = ', 'F = ']) substrs=['B = ', 'C = ', 'E = ', 'F = '])
Show All 34 Lines def test_formatters_api(self):
foo_var = self.dbg.GetSelectedTarget().GetProcess( foo_var = self.dbg.GetSelectedTarget().GetProcess(
).GetSelectedThread().GetSelectedFrame().FindVariable('foo') ).GetSelectedThread().GetSelectedFrame().FindVariable('foo')
self.assertTrue(foo_var.IsValid(), 'could not find foo') self.assertTrue(foo_var.IsValid(), 'could not find foo')
self.assertTrue( self.assertTrue(
foo_var.GetDeclaration().IsValid(), foo_var.GetDeclaration().IsValid(),
'foo declaration is invalid') 'foo declaration is invalid')
self.assertTrue( self.assertEqual(
foo_var.GetNumChildren() == 2, foo_var.GetNumChildren(), 2,
'synthetic value has wrong number of child items (synth)') 'synthetic value has wrong number of child items (synth)')
self.assertTrue( self.assertEqual(
foo_var.GetChildMemberWithName('X').GetValueAsUnsigned() == 1, foo_var.GetChildMemberWithName('X').GetValueAsUnsigned(), 1,
'foo_synth.X has wrong value (synth)') 'foo_synth.X has wrong value (synth)')
self.assertFalse( self.assertFalse(
foo_var.GetChildMemberWithName('B').IsValid(), foo_var.GetChildMemberWithName('B').IsValid(),
'foo_synth.B is valid but should not (synth)') 'foo_synth.B is valid but should not (synth)')
self.dbg.GetCategory("JASSynth").SetEnabled(False) self.dbg.GetCategory("JASSynth").SetEnabled(False)
foo_var = self.dbg.GetSelectedTarget().GetProcess( foo_var = self.dbg.GetSelectedTarget().GetProcess(
).GetSelectedThread().GetSelectedFrame().FindVariable('foo') ).GetSelectedThread().GetSelectedFrame().FindVariable('foo')
Show All 9 Lines def test_formatters_api(self):
category.AddTypeFilter(lldb.SBTypeNameSpecifier("JustAStruct"), filter) category.AddTypeFilter(lldb.SBTypeNameSpecifier("JustAStruct"), filter)
self.expect("frame variable foo", self.expect("frame variable foo",
substrs=['A = 1', 'D = 6.28']) substrs=['A = 1', 'D = 6.28'])
foo_var = self.dbg.GetSelectedTarget().GetProcess( foo_var = self.dbg.GetSelectedTarget().GetProcess(
).GetSelectedThread().GetSelectedFrame().FindVariable('foo') ).GetSelectedThread().GetSelectedFrame().FindVariable('foo')
self.assertTrue(foo_var.IsValid(), 'could not find foo') self.assertTrue(foo_var.IsValid(), 'could not find foo')
self.assertTrue( self.assertEqual(
foo_var.GetNumChildren() == 2, foo_var.GetNumChildren(), 2,
'synthetic value has wrong number of child items (filter)') 'synthetic value has wrong number of child items (filter)')
self.assertTrue( self.assertEqual(
foo_var.GetChildMemberWithName('X').GetValueAsUnsigned() == 0, foo_var.GetChildMemberWithName('X').GetValueAsUnsigned(), 0,
'foo_synth.X has wrong value (filter)') 'foo_synth.X has wrong value (filter)')
self.assertTrue( self.assertEqual(
foo_var.GetChildMemberWithName('A').GetValueAsUnsigned() == 1, foo_var.GetChildMemberWithName('A').GetValueAsUnsigned(), 1,
'foo_synth.A has wrong value (filter)') 'foo_synth.A has wrong value (filter)')
self.assertTrue(filter.ReplaceExpressionPathAtIndex( self.assertTrue(filter.ReplaceExpressionPathAtIndex(
0, "C"), "failed to replace an expression path in filter") 0, "C"), "failed to replace an expression path in filter")
self.expect("frame variable foo", self.expect("frame variable foo",
substrs=['A = 1', 'D = 6.28']) substrs=['A = 1', 'D = 6.28'])
category.AddTypeFilter(lldb.SBTypeNameSpecifier("JustAStruct"), filter) category.AddTypeFilter(lldb.SBTypeNameSpecifier("JustAStruct"), filter)
self.expect("frame variable foo", self.expect("frame variable foo",
substrs=["C = 'e'", 'D = 6.28']) substrs=["C = 'e'", 'D = 6.28'])
category.AddTypeFilter(lldb.SBTypeNameSpecifier("FooType"), filter) category.AddTypeFilter(lldb.SBTypeNameSpecifier("FooType"), filter)
filter.ReplaceExpressionPathAtIndex(1, "F") filter.ReplaceExpressionPathAtIndex(1, "F")
self.expect("frame variable foo", self.expect("frame variable foo",
substrs=["C = 'e'", 'D = 6.28']) substrs=["C = 'e'", 'D = 6.28'])
category.AddTypeFilter(lldb.SBTypeNameSpecifier("JustAStruct"), filter) category.AddTypeFilter(lldb.SBTypeNameSpecifier("JustAStruct"), filter)
self.expect("frame variable foo", self.expect("frame variable foo",
substrs=["C = 'e'", 'F = 0']) substrs=["C = 'e'", 'F = 0'])
self.expect("frame variable bar", self.expect("frame variable bar",
substrs=["C = 'e'", 'D = 6.28']) substrs=["C = 'e'", 'D = 6.28'])
foo_var = self.dbg.GetSelectedTarget().GetProcess( foo_var = self.dbg.GetSelectedTarget().GetProcess(
).GetSelectedThread().GetSelectedFrame().FindVariable('foo') ).GetSelectedThread().GetSelectedFrame().FindVariable('foo')
self.assertTrue(foo_var.IsValid(), 'could not find foo') self.assertTrue(foo_var.IsValid(), 'could not find foo')
self.assertTrue( self.assertEqual(
foo_var.GetChildMemberWithName('C').GetValueAsUnsigned() == ord('e'), foo_var.GetChildMemberWithName('C').GetValueAsUnsigned(), ord('e'),
'foo_synth.C has wrong value (filter)') 'foo_synth.C has wrong value (filter)')
chosen = self.dbg.GetFilterForType( chosen = self.dbg.GetFilterForType(
lldb.SBTypeNameSpecifier("JustAStruct")) lldb.SBTypeNameSpecifier("JustAStruct"))
self.assertTrue( self.assertEqual(
chosen.count == 2, chosen.count, 2,
"wrong filter found for JustAStruct") "wrong filter found for JustAStruct")
self.assertTrue( self.assertEqual(
chosen.GetExpressionPathAtIndex(0) == 'C', chosen.GetExpressionPathAtIndex(0), 'C',
"wrong item at index 0 for JustAStruct") "wrong item at index 0 for JustAStruct")
self.assertTrue( self.assertEqual(
chosen.GetExpressionPathAtIndex(1) == 'F', chosen.GetExpressionPathAtIndex(1), 'F',
"wrong item at index 1 for JustAStruct") "wrong item at index 1 for JustAStruct")
self.assertFalse( self.assertFalse(
category.DeleteTypeFilter( category.DeleteTypeFilter(
lldb.SBTypeNameSpecifier("NoSuchType")), lldb.SBTypeNameSpecifier("NoSuchType")),
"deleting a non-existing filter worked") "deleting a non-existing filter worked")
self.assertFalse( self.assertFalse(
category.DeleteTypeSummary( category.DeleteTypeSummary(
▲ Show 20 Lines • Show All 150 Lines • ▼ Show 20 Lines def test_formatters_api(self):
"hello static world", "hello static world",
lldb.eTypeOptionNone)) lldb.eTypeOptionNone))
summary = foo_ptr.GetTypeSummary() summary = foo_ptr.GetTypeSummary()
self.assertTrue( self.assertTrue(
summary.IsValid(), summary.IsValid(),
"no summary found for foo* when one was in place") "no summary found for foo* when one was in place")
self.assertTrue( self.assertEqual(
summary.GetData() == "hello static world", summary.GetData(), "hello static world",
"wrong summary found for foo*") "wrong summary found for foo*")
self.expect("frame variable e1", substrs=["I am an empty Empty1 {}"]) self.expect("frame variable e1", substrs=["I am an empty Empty1 {}"])
self.expect("frame variable e2", substrs=["I am an empty Empty2"]) self.expect("frame variable e2", substrs=["I am an empty Empty2"])
self.expect( self.expect(
"frame variable e2", "frame variable e2",
substrs=["I am an empty Empty2 {}"], substrs=["I am an empty Empty2 {}"],
matching=False) matching=False)
Show All 37 Lines def test_force_synth_off(self):
# Execute the cleanup function during test case tear down. # Execute the cleanup function during test case tear down.
self.addTearDownHook(cleanup) self.addTearDownHook(cleanup)
frame = self.dbg.GetSelectedTarget().GetProcess( frame = self.dbg.GetSelectedTarget().GetProcess(
).GetSelectedThread().GetSelectedFrame() ).GetSelectedThread().GetSelectedFrame()
int_vector = frame.FindVariable("int_vector") int_vector = frame.FindVariable("int_vector")
if self.TraceOn(): if self.TraceOn():
print(int_vector) print(int_vector)
self.assertTrue( self.assertEqual(
int_vector.GetNumChildren() == 0, int_vector.GetNumChildren(), 0,
'synthetic vector is empty') 'synthetic vector is empty')
self.runCmd('settings set target.enable-synthetic-value false') self.runCmd('settings set target.enable-synthetic-value false')
frame = self.dbg.GetSelectedTarget().GetProcess( frame = self.dbg.GetSelectedTarget().GetProcess(
).GetSelectedThread().GetSelectedFrame() ).GetSelectedThread().GetSelectedFrame()
int_vector = frame.FindVariable("int_vector") int_vector = frame.FindVariable("int_vector")
if self.TraceOn(): if self.TraceOn():
print(int_vector) print(int_vector)
self.assertFalse( self.assertFalse(
int_vector.GetNumChildren() == 0, int_vector.GetNumChildren() == 0,
'"physical" vector is not empty') '"physical" vector is not empty')
self.runCmd('settings set target.enable-synthetic-value true') self.runCmd('settings set target.enable-synthetic-value true')
frame = self.dbg.GetSelectedTarget().GetProcess( frame = self.dbg.GetSelectedTarget().GetProcess(
).GetSelectedThread().GetSelectedFrame() ).GetSelectedThread().GetSelectedFrame()
int_vector = frame.FindVariable("int_vector") int_vector = frame.FindVariable("int_vector")
if self.TraceOn(): if self.TraceOn():
print(int_vector) print(int_vector)
self.assertTrue( self.assertEqual(
int_vector.GetNumChildren() == 0, int_vector.GetNumChildren(), 0,
'synthetic vector is still empty') 'synthetic vector is still empty')

lldb/test/API/python_api/frame/TestFrames.py

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines def test_get_arg_vals_for_call_stack(self):
pc_value = gpr_reg_set.GetChildMemberWithName("pc") pc_value = gpr_reg_set.GetChildMemberWithName("pc")
self.assertTrue(pc_value, "We should have a valid PC.") self.assertTrue(pc_value, "We should have a valid PC.")
pc_value_int = int(pc_value.GetValue(), 0) pc_value_int = int(pc_value.GetValue(), 0)
# Make sure on arm targets we dont mismatch PC value on the basis of thumb bit. # Make sure on arm targets we dont mismatch PC value on the basis of thumb bit.
# Frame PC will not have thumb bit set in case of a thumb # Frame PC will not have thumb bit set in case of a thumb
# instruction as PC. # instruction as PC.
if self.getArchitecture() in ['arm', 'armv7', 'armv7k']: if self.getArchitecture() in ['arm', 'armv7', 'armv7k']:
pc_value_int &= ~1 pc_value_int &= ~1
self.assertTrue( self.assertEqual(
pc_value_int == frame.GetPC(), pc_value_int, frame.GetPC(),
"PC gotten as a value should equal frame's GetPC") "PC gotten as a value should equal frame's GetPC")
sp_value = gpr_reg_set.GetChildMemberWithName("sp") sp_value = gpr_reg_set.GetChildMemberWithName("sp")
self.assertTrue( self.assertTrue(
sp_value, "We should have a valid Stack Pointer.") sp_value, "We should have a valid Stack Pointer.")
self.assertEqual( self.assertEqual(
int(sp_value.GetValue(), 0), frame.GetSP(), int(sp_value.GetValue(), 0), frame.GetSP(),
"SP gotten as a value should equal frame's GetSP") "SP gotten as a value should equal frame's GetSP")
print("---", file=session) print("---", file=session)
process.Continue() process.Continue()
# At this point, the inferior process should have exited. # At this point, the inferior process should have exited.
self.assertTrue( self.assertEqual(
process.GetState() == lldb.eStateExited, process.GetState(), lldb.eStateExited,
PROCESS_EXITED) PROCESS_EXITED)
# Expect to find 'a' on the call stacks two times. # Expect to find 'a' on the call stacks two times.
self.assertEqual(callsOfA, 2, self.assertEqual(callsOfA, 2,
"Expect to find 'a' on the call stacks two times") "Expect to find 'a' on the call stacks two times")
# By design, the 'a' call frame has the following arg vals: # By design, the 'a' call frame has the following arg vals:
# o a((int)val=1, (char)ch='A') # o a((int)val=1, (char)ch='A')
# o a((int)val=3, (char)ch='A') # o a((int)val=3, (char)ch='A')
▲ Show 20 Lines • Show All 108 Lines • Show Last 20 Lines

lldb/test/API/python_api/lldbutil/iter/TestLLDBIterator.py

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Lines def test_lldb_iter_module(self):
for m in target.module_iter(): for m in target.module_iter():
mine.append(m) mine.append(m)
self.assertEqual(len(yours), len(mine)) self.assertEqual(len(yours), len(mine))
for i in range(len(yours)): for i in range(len(yours)):
if self.TraceOn(): if self.TraceOn():
print("yours[%d]='%s'" % (i, get_description(yours[i]))) print("yours[%d]='%s'" % (i, get_description(yours[i])))
print("mine[%d]='%s'" % (i, get_description(mine[i]))) print("mine[%d]='%s'" % (i, get_description(mine[i])))
self.assertTrue( self.assertEqual(
yours[i] == mine[i], yours[i], mine[i],
"UUID+FileSpec of yours[{0}] and mine[{0}] matches".format(i)) "UUID+FileSpec of yours[{0}] and mine[{0}] matches".format(i))
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_lldb_iter_breakpoint(self): def test_lldb_iter_breakpoint(self):
"""Test breakpoint_iter works correctly for SBTarget -> SBBreakpoint.""" """Test breakpoint_iter works correctly for SBTarget -> SBBreakpoint."""
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getBuildArtifact("a.out")
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

lldb/test/API/python_api/objc_type/TestObjCType.py

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines def test(self):
process, lldb.eStopReasonBreakpoint) process, lldb.eStopReasonBreakpoint)
self.assertTrue( self.assertTrue(
thread.IsValid(), thread.IsValid(),
"There should be a thread stopped due to breakpoint condition") "There should be a thread stopped due to breakpoint condition")
aBar = self.frame().FindVariable("aBar") aBar = self.frame().FindVariable("aBar")
aBarType = aBar.GetType() aBarType = aBar.GetType()
self.assertTrue(aBarType.IsValid(), "Bar should be a valid data type") self.assertTrue(aBarType.IsValid(), "Bar should be a valid data type")
self.assertTrue( self.assertEqual(
aBarType.GetName() == "Bar *", aBarType.GetName(), "Bar *",
"Bar has the right name") "Bar has the right name")
self.assertTrue( self.assertEqual(
aBarType.GetNumberOfDirectBaseClasses() == 1, aBarType.GetNumberOfDirectBaseClasses(), 1,
"Bar has a superclass") "Bar has a superclass")
aFooType = aBarType.GetDirectBaseClassAtIndex(0) aFooType = aBarType.GetDirectBaseClassAtIndex(0)
self.assertTrue(aFooType.IsValid(), "Foo should be a valid data type") self.assertTrue(aFooType.IsValid(), "Foo should be a valid data type")
self.assertEquals(aFooType.GetName(), "Foo", "Foo has the right name") self.assertEquals(aFooType.GetName(), "Foo", "Foo has the right name")
self.assertEquals(aBarType.GetNumberOfFields(), 1, "Bar has a field") self.assertEquals(aBarType.GetNumberOfFields(), 1, "Bar has a field")
aBarField = aBarType.GetFieldAtIndex(0) aBarField = aBarType.GetFieldAtIndex(0)
self.assertTrue( self.assertEqual(
aBarField.GetName() == "_iVar", aBarField.GetName(), "_iVar",
"The field has the right name") "The field has the right name")

lldb/test/API/python_api/sbdata/TestSBData.py

Show First 20 Lines • Show All 424 Lines • ▼ Show 20 Lines def test_with_run_command(self):
data2.SetDataFromUInt64Array([1, 2, 3, 4, 5]) data2.SetDataFromUInt64Array([1, 2, 3, 4, 5])
self.assert_data(data2.GetUnsignedInt64, 0, 1) self.assert_data(data2.GetUnsignedInt64, 0, 1)
self.assert_data(data2.GetUnsignedInt64, 8, 2) self.assert_data(data2.GetUnsignedInt64, 8, 2)
self.assert_data(data2.GetUnsignedInt64, 16, 3) self.assert_data(data2.GetUnsignedInt64, 16, 3)
self.assert_data(data2.GetUnsignedInt64, 24, 4) self.assert_data(data2.GetUnsignedInt64, 24, 4)
self.assert_data(data2.GetUnsignedInt64, 32, 5) self.assert_data(data2.GetUnsignedInt64, 32, 5)
self.assertTrue( self.assertEqual(
data2.uint64[0] == 1, data2.uint64[0], 1,
'read_data_helper failure: set data2[0] = 1') 'read_data_helper failure: set data2[0] = 1')
self.assertTrue( self.assertEqual(
data2.uint64[1] == 2, data2.uint64[1], 2,
'read_data_helper failure: set data2[1] = 2') 'read_data_helper failure: set data2[1] = 2')
self.assertTrue( self.assertEqual(
data2.uint64[2] == 3, data2.uint64[2], 3,
'read_data_helper failure: set data2[2] = 3') 'read_data_helper failure: set data2[2] = 3')
self.assertTrue( self.assertEqual(
data2.uint64[3] == 4, data2.uint64[3], 4,
'read_data_helper failure: set data2[3] = 4') 'read_data_helper failure: set data2[3] = 4')
self.assertTrue( self.assertEqual(
data2.uint64[4] == 5, data2.uint64[4], 5,
'read_data_helper failure: set data2[4] = 5') 'read_data_helper failure: set data2[4] = 5')
self.assertTrue( self.assertTrue(
data2.uint64[ data2.uint64[
0:2] == [ 0:2] == [
1, 1,
2], 2],
'read_data_helper failure: set data2[0:2] = [1,2]') 'read_data_helper failure: set data2[0:2] = [1,2]')
data2.SetDataFromSInt32Array([2, -2]) data2.SetDataFromSInt32Array([2, -2])
self.assert_data(data2.GetSignedInt32, 0, 2) self.assert_data(data2.GetSignedInt32, 0, 2)
self.assert_data(data2.GetSignedInt32, 4, -2) self.assert_data(data2.GetSignedInt32, 4, -2)
data2.SetDataFromSInt64Array([2, -2]) data2.SetDataFromSInt64Array([2, -2])
self.assert_data(data2.GetSignedInt64, 0, 2) self.assert_data(data2.GetSignedInt64, 0, 2)
self.assert_data(data2.GetSignedInt64, 8, -2) self.assert_data(data2.GetSignedInt64, 8, -2)
data2.SetDataFromUInt32Array([1, 2, 3, 4, 5]) data2.SetDataFromUInt32Array([1, 2, 3, 4, 5])
self.assert_data(data2.GetUnsignedInt32, 0, 1) self.assert_data(data2.GetUnsignedInt32, 0, 1)
self.assert_data(data2.GetUnsignedInt32, 4, 2) self.assert_data(data2.GetUnsignedInt32, 4, 2)
self.assert_data(data2.GetUnsignedInt32, 8, 3) self.assert_data(data2.GetUnsignedInt32, 8, 3)
self.assert_data(data2.GetUnsignedInt32, 12, 4) self.assert_data(data2.GetUnsignedInt32, 12, 4)
self.assert_data(data2.GetUnsignedInt32, 16, 5) self.assert_data(data2.GetUnsignedInt32, 16, 5)
self.assertTrue( self.assertEqual(
data2.uint32[0] == 1, data2.uint32[0], 1,
'read_data_helper failure: set 32-bit data2[0] = 1') 'read_data_helper failure: set 32-bit data2[0] = 1')
self.assertTrue( self.assertEqual(
data2.uint32[1] == 2, data2.uint32[1], 2,
'read_data_helper failure: set 32-bit data2[1] = 2') 'read_data_helper failure: set 32-bit data2[1] = 2')
self.assertTrue( self.assertEqual(
data2.uint32[2] == 3, data2.uint32[2], 3,
'read_data_helper failure: set 32-bit data2[2] = 3') 'read_data_helper failure: set 32-bit data2[2] = 3')
self.assertTrue( self.assertEqual(
data2.uint32[3] == 4, data2.uint32[3], 4,
'read_data_helper failure: set 32-bit data2[3] = 4') 'read_data_helper failure: set 32-bit data2[3] = 4')
self.assertTrue( self.assertEqual(
data2.uint32[4] == 5, data2.uint32[4], 5,
'read_data_helper failure: set 32-bit data2[4] = 5') 'read_data_helper failure: set 32-bit data2[4] = 5')
data2.SetDataFromDoubleArray([3.14, 6.28, 2.71]) data2.SetDataFromDoubleArray([3.14, 6.28, 2.71])
self.assertTrue(fabs(data2.GetDouble(error, 0) - 3.14) self.assertTrue(fabs(data2.GetDouble(error, 0) - 3.14)
< 0.5, 'set double data2[0] = 3.14') < 0.5, 'set double data2[0] = 3.14')
self.assertTrue(fabs(data2.GetDouble(error, 8) - 6.28) self.assertTrue(fabs(data2.GetDouble(error, 8) - 6.28)
< 0.5, 'set double data2[1] = 6.28') < 0.5, 'set double data2[1] = 6.28')
self.assertTrue(fabs(data2.GetDouble(error, 16) - 2.71) self.assertTrue(fabs(data2.GetDouble(error, 16) - 2.71)
Show All 31 Lines

lldb/test/API/python_api/sbvalue_persist/TestSBValuePersist.py

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Lines def test(self):
fooPersist = foo.Persist() fooPersist = foo.Persist()
barPersist = bar.Persist() barPersist = bar.Persist()
bazPersist = baz.Persist() bazPersist = baz.Persist()
self.assertTrue(fooPersist.IsValid(), "fooPersist is not valid") self.assertTrue(fooPersist.IsValid(), "fooPersist is not valid")
self.assertTrue(barPersist.IsValid(), "barPersist is not valid") self.assertTrue(barPersist.IsValid(), "barPersist is not valid")
self.assertTrue(bazPersist.IsValid(), "bazPersist is not valid") self.assertTrue(bazPersist.IsValid(), "bazPersist is not valid")
self.assertTrue( self.assertEqual(
fooPersist.GetValueAsUnsigned(0) == 10, fooPersist.GetValueAsUnsigned(0), 10,
"fooPersist != 10") "fooPersist != 10")
self.assertTrue( self.assertEqual(
barPersist.GetPointeeData().sint32[0] == 4, barPersist.GetPointeeData().sint32[0], 4,
"barPersist != 4") "barPersist != 4")
self.assertEquals(bazPersist.GetSummary(), '"85"', "bazPersist != 85") self.assertEquals(bazPersist.GetSummary(), '"85"', "bazPersist != 85")
self.runCmd("continue") self.runCmd("continue")
self.assertTrue(fooPersist.IsValid(), "fooPersist is not valid") self.assertTrue(fooPersist.IsValid(), "fooPersist is not valid")
self.assertTrue(barPersist.IsValid(), "barPersist is not valid") self.assertTrue(barPersist.IsValid(), "barPersist is not valid")
self.assertTrue(bazPersist.IsValid(), "bazPersist is not valid") self.assertTrue(bazPersist.IsValid(), "bazPersist is not valid")
self.assertTrue( self.assertEqual(
fooPersist.GetValueAsUnsigned(0) == 10, fooPersist.GetValueAsUnsigned(0), 10,
"fooPersist != 10") "fooPersist != 10")
self.assertTrue( self.assertEqual(
barPersist.GetPointeeData().sint32[0] == 4, barPersist.GetPointeeData().sint32[0], 4,
"barPersist != 4") "barPersist != 4")
self.assertEquals(bazPersist.GetSummary(), '"85"', "bazPersist != 85") self.assertEquals(bazPersist.GetSummary(), '"85"', "bazPersist != 85")
self.expect("expr *(%s)" % (barPersist.GetName()), substrs=['= 4']) self.expect("expr *(%s)" % (barPersist.GetName()), substrs=['= 4'])

lldb/test/API/python_api/signals/TestSignalsAPI.py

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Lines def test_ignore_signal(self):
unix_signals = process.GetUnixSignals() unix_signals = process.GetUnixSignals()
sigint = unix_signals.GetSignalNumberFromName("SIGINT") sigint = unix_signals.GetSignalNumberFromName("SIGINT")
unix_signals.SetShouldSuppress(sigint, True) unix_signals.SetShouldSuppress(sigint, True)
unix_signals.SetShouldStop(sigint, False) unix_signals.SetShouldStop(sigint, False)
unix_signals.SetShouldNotify(sigint, False) unix_signals.SetShouldNotify(sigint, False)
process.Continue() process.Continue()
self.assertTrue( self.assertEqual(
process.state == lldb.eStateExited, process.state, lldb.eStateExited,
"The process should have exited") "The process should have exited")
self.assertTrue( self.assertEqual(
process.GetExitStatus() == 0, process.GetExitStatus(), 0,
"The process should have returned 0") "The process should have returned 0")

lldb/test/API/python_api/target/TestTargetAPI.py

Show First 20 Lines • Show All 262 Lines • ▼ Show 20 Lines def find_global_variables(self, exe_name):
if not configuration.is_reproducer(): if not configuration.is_reproducer():
# While we are at it, let's also exercise the similar # While we are at it, let's also exercise the similar
# SBModule.FindGlobalVariables() API. # SBModule.FindGlobalVariables() API.
for m in target.module_iter(): for m in target.module_iter():
if os.path.normpath(m.GetFileSpec().GetDirectory()) == self.getBuildDir() and m.GetFileSpec().GetFilename() == exe_name: if os.path.normpath(m.GetFileSpec().GetDirectory()) == self.getBuildDir() and m.GetFileSpec().GetFilename() == exe_name:
value_list = m.FindGlobalVariables( value_list = m.FindGlobalVariables(
target, 'my_global_var_of_char_type', 3) target, 'my_global_var_of_char_type', 3)
self.assertEqual(value_list.GetSize(), 1) self.assertEqual(value_list.GetSize(), 1)
self.assertTrue( self.assertEqual(
value_list.GetValueAtIndex(0).GetValue() == "'X'") value_list.GetValueAtIndex(0).GetValue(), "'X'")
break break
def find_compile_units(self, exe): def find_compile_units(self, exe):
"""Exercise SBTarget.FindCompileUnits() API.""" """Exercise SBTarget.FindCompileUnits() API."""
source_name = "main.c" source_name = "main.c"
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
list = target.FindCompileUnits(lldb.SBFileSpec(source_name, False)) list = target.FindCompileUnits(lldb.SBFileSpec(source_name, False))
# Executable has been built just from one source file 'main.c', # Executable has been built just from one source file 'main.c',
# so we may check only the first element of list. # so we may check only the first element of list.
self.assertTrue( self.assertEqual(
list[0].GetCompileUnit().GetFileSpec().GetFilename() == source_name) list[0].GetCompileUnit().GetFileSpec().GetFilename(), source_name)
def find_functions(self, exe_name): def find_functions(self, exe_name):
"""Exercise SBTaget.FindFunctions() API.""" """Exercise SBTaget.FindFunctions() API."""
exe = self.getBuildArtifact(exe_name) exe = self.getBuildArtifact(exe_name)
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Try it with a null name: # Try it with a null name:
list = target.FindFunctions(None, lldb.eFunctionNameTypeAuto) list = target.FindFunctions(None, lldb.eFunctionNameTypeAuto)
self.assertEqual(list.GetSize(), 0) self.assertEqual(list.GetSize(), 0)
list = target.FindFunctions('c', lldb.eFunctionNameTypeAuto) list = target.FindFunctions('c', lldb.eFunctionNameTypeAuto)
self.assertEqual(list.GetSize(), 1) self.assertEqual(list.GetSize(), 1)
for sc in list: for sc in list:
self.assertTrue( self.assertEqual(
sc.GetModule().GetFileSpec().GetFilename() == exe_name) sc.GetModule().GetFileSpec().GetFilename(), exe_name)
self.assertEqual(sc.GetSymbol().GetName(), 'c') self.assertEqual(sc.GetSymbol().GetName(), 'c')
def get_description(self): def get_description(self):
"""Exercise SBTaget.GetDescription() API.""" """Exercise SBTaget.GetDescription() API."""
exe = self.getBuildArtifact("a.out") exe = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
▲ Show 20 Lines • Show All 202 Lines • Show Last 20 Lines

lldb/test/API/python_api/thread/TestThreadAPI.py

Show First 20 Lines • Show All 93 Lines • ▼ Show 20 Lines def get_process(self):
thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint) thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint)
self.assertTrue( self.assertTrue(
thread.IsValid(), thread.IsValid(),
"There should be a thread stopped due to breakpoint") "There should be a thread stopped due to breakpoint")
self.runCmd("process status") self.runCmd("process status")
proc_of_thread = thread.GetProcess() proc_of_thread = thread.GetProcess()
self.trace("proc_of_thread:", proc_of_thread) self.trace("proc_of_thread:", proc_of_thread)
self.assertTrue(proc_of_thread.GetProcessID() self.assertEqual(proc_of_thread.GetProcessID(), process.GetProcessID())
== process.GetProcessID())
def get_stop_description(self): def get_stop_description(self):
"""Test Python SBThread.GetStopDescription() API.""" """Test Python SBThread.GetStopDescription() API."""
exe = self.getBuildArtifact("a.out") exe = self.getBuildArtifact("a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines def step_out_of_malloc_into_function_b(self, exe_name):
process.Continue() process.Continue()
# On Linux malloc calls itself in some case. Remove the breakpoint because we don't want # On Linux malloc calls itself in some case. Remove the breakpoint because we don't want
# to hit it during step-out. # to hit it during step-out.
target.BreakpointDelete(breakpoint.GetID()) target.BreakpointDelete(breakpoint.GetID())
thread.StepOut() thread.StepOut()
self.runCmd("thread backtrace") self.runCmd("thread backtrace")
self.assertTrue( self.assertEqual(
thread.GetFrameAtIndex(0).GetLineEntry().GetLine() == self.step_out_of_malloc, thread.GetFrameAtIndex(0).GetLineEntry().GetLine(), self.step_out_of_malloc,
"step out of malloc into function b is successful") "step out of malloc into function b is successful")
def step_over_3_times(self, exe_name): def step_over_3_times(self, exe_name):
"""Test Python SBThread.StepOver() API.""" """Test Python SBThread.StepOver() API."""
exe = self.getBuildArtifact(exe_name) exe = self.getBuildArtifact(exe_name)
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

lldb/test/API/python_api/value/TestValueAPI.py

Show First 20 Lines • Show All 170 Lines • ▼ Show 20 Lines def test(self):
# Check value_iter works correctly. # Check value_iter works correctly.
for v in [ for v in [
lldb.value(frame0.FindVariable('uinthex')), lldb.value(frame0.FindVariable('uinthex')),
lldb.value(frame0.FindVariable('sinthex')) lldb.value(frame0.FindVariable('sinthex'))
]: ]:
self.assertTrue(v) self.assertTrue(v)
self.assertTrue( self.assertEqual(
frame0.FindVariable('uinthex').GetValueAsUnsigned() == 3768803088, frame0.FindVariable('uinthex').GetValueAsUnsigned(), 3768803088,
'unsigned uinthex == 3768803088') 'unsigned uinthex == 3768803088')
self.assertTrue( self.assertEqual(
frame0.FindVariable('sinthex').GetValueAsUnsigned() == 3768803088, frame0.FindVariable('sinthex').GetValueAsUnsigned(), 3768803088,
'unsigned sinthex == 3768803088') 'unsigned sinthex == 3768803088')
self.assertTrue( self.assertTrue(
frame0.FindVariable('uinthex').GetValueAsSigned() == - frame0.FindVariable('uinthex').GetValueAsSigned() == -
526164208, 526164208,
'signed uinthex == -526164208') 'signed uinthex == -526164208')
self.assertTrue( self.assertTrue(
frame0.FindVariable('sinthex').GetValueAsSigned() == - frame0.FindVariable('sinthex').GetValueAsSigned() == -
526164208, 526164208,
'signed sinthex == -526164208') 'signed sinthex == -526164208')

lldb/test/API/python_api/value/change_values/TestChangeValueAPI.py

Show First 20 Lines • Show All 76 Lines • ▼ Show 20 Lines def test_change_value(self):
actual_value = val_value.GetValueAsSigned(error, 0) actual_value = val_value.GetValueAsSigned(error, 0)
self.assertTrue(error.Success(), "Got a value from val") self.assertTrue(error.Success(), "Got a value from val")
self.assertEquals(actual_value, 100, "Got the right value from val") self.assertEquals(actual_value, 100, "Got the right value from val")
result = val_value.SetValueFromCString("12345") result = val_value.SetValueFromCString("12345")
self.assertTrue(result, "Setting val returned True.") self.assertTrue(result, "Setting val returned True.")
actual_value = val_value.GetValueAsSigned(error, 0) actual_value = val_value.GetValueAsSigned(error, 0)
self.assertTrue(error.Success(), "Got a changed value from val") self.assertTrue(error.Success(), "Got a changed value from val")
self.assertTrue( self.assertEqual(
actual_value == 12345, actual_value, 12345,
"Got the right changed value from val") "Got the right changed value from val")
# Now check that we can set a structure element: # Now check that we can set a structure element:
mine_value = frame0.FindVariable("mine") mine_value = frame0.FindVariable("mine")
self.assertTrue(mine_value.IsValid(), "Got the SBValue for mine") self.assertTrue(mine_value.IsValid(), "Got the SBValue for mine")
mine_second_value = mine_value.GetChildMemberWithName("second_val") mine_second_value = mine_value.GetChildMemberWithName("second_val")
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines def test_change_value(self):
frame0 = thread.GetFrameAtIndex(0) frame0 = thread.GetFrameAtIndex(0)
self.assertTrue(frame0.IsValid(), "Second time: got a valid frame.") self.assertTrue(frame0.IsValid(), "Second time: got a valid frame.")
sp_value = frame0.FindValue("sp", lldb.eValueTypeRegister) sp_value = frame0.FindValue("sp", lldb.eValueTypeRegister)
self.assertTrue(sp_value.IsValid(), "Got a stack pointer value") self.assertTrue(sp_value.IsValid(), "Got a stack pointer value")
result = sp_value.SetValueFromCString("1") result = sp_value.SetValueFromCString("1")
self.assertTrue(result, "Setting sp returned true.") self.assertTrue(result, "Setting sp returned true.")
actual_value = sp_value.GetValueAsUnsigned(error, 0) actual_value = sp_value.GetValueAsUnsigned(error, 0)
self.assertTrue(error.Success(), "Got a changed value for sp") self.assertTrue(error.Success(), "Got a changed value for sp")
self.assertTrue( self.assertEqual(
actual_value == 1, actual_value, 1,
"Got the right changed value for sp.") "Got the right changed value for sp.")
# Boundary condition test the SBValue.CreateValueFromExpression() API. # Boundary condition test the SBValue.CreateValueFromExpression() API.
# LLDB should not crash! # LLDB should not crash!
nosuchval = mine_value.CreateValueFromExpression(None, None) nosuchval = mine_value.CreateValueFromExpression(None, None)
process.Continue() process.Continue()
self.assertEquals(process.GetState(), lldb.eStateStopped) self.assertEquals(process.GetState(), lldb.eStateStopped)
thread = lldbutil.get_stopped_thread( thread = lldbutil.get_stopped_thread(
process, lldb.eStopReasonBreakpoint) process, lldb.eStopReasonBreakpoint)
self.assertTrue( self.assertTrue(
thread is None, thread is None,
"We should not have managed to hit our second breakpoint with sp == 1") "We should not have managed to hit our second breakpoint with sp == 1")
process.Kill() process.Kill()

lldb/test/API/python_api/watchpoint/TestSetWatchpoint.py

Show First 20 Lines • Show All 92 Lines • ▼ Show 20 Lines def test_watch_val(self):
self.assertTrue(thread, "The thread stopped due to watchpoint") self.assertTrue(thread, "The thread stopped due to watchpoint")
self.DebugSBValue(value) self.DebugSBValue(value)
# Continue the process. We don't expect the program to be stopped # Continue the process. We don't expect the program to be stopped
# again. # again.
process.Continue() process.Continue()
# At this point, the inferior process should have exited. # At this point, the inferior process should have exited.
self.assertTrue( self.assertEqual(
process.GetState() == lldb.eStateExited, process.GetState(), lldb.eStateExited,
PROCESS_EXITED) PROCESS_EXITED)
self.dbg.DeleteTarget(target) self.dbg.DeleteTarget(target)
# The next check relies on the watchpoint being destructed, which does # The next check relies on the watchpoint being destructed, which does
# not happen during replay because objects are intentionally kept alive # not happen during replay because objects are intentionally kept alive
# forever. # forever.
if not configuration.is_reproducer(): if not configuration.is_reproducer():
self.assertFalse(watchpoint.IsValid()) self.assertFalse(watchpoint.IsValid())

lldb/test/API/python_api/watchpoint/TestWatchpointIter.py

Show First 20 Lines • Show All 107 Lines • ▼ Show 20 Lines def test_watch_iter(self):
self.assertEqual(watchpoint.GetHardwareIndex(), -1) self.assertEqual(watchpoint.GetHardwareIndex(), -1)
self.assertFalse(watchpoint.IsEnabled()) self.assertFalse(watchpoint.IsEnabled())
# Continue. The program does not stop again when the variable is being # Continue. The program does not stop again when the variable is being
# read from because the watchpoint location has been disabled. # read from because the watchpoint location has been disabled.
process.Continue() process.Continue()
# At this point, the inferior process should have exited. # At this point, the inferior process should have exited.
self.assertTrue( self.assertEqual(
process.GetState() == lldb.eStateExited, process.GetState(), lldb.eStateExited,
PROCESS_EXITED) PROCESS_EXITED)
# Verify some vital statistics and exercise the iterator API. # Verify some vital statistics and exercise the iterator API.
for watchpoint in target.watchpoint_iter(): for watchpoint in target.watchpoint_iter():
self.assertTrue(watchpoint) self.assertTrue(watchpoint)
self.assertEqual(watchpoint.GetWatchSize(), 4) self.assertEqual(watchpoint.GetWatchSize(), 4)
self.assertEqual(watchpoint.GetHitCount(), 1) self.assertEqual(watchpoint.GetHitCount(), 1)
print(watchpoint) print(watchpoint)