This is an archive of the discontinued LLVM Phabricator instance.

Differential D42280

Wrap all references to build artifacts in the LLDB testsuite in TestBase::getBuildArtifact()
ClosedPublic

Authored by aprantl on Jan 18 2018, 7:14 PM.

Details

Reviewers
labath
jingham
zturner
jasonmolenda
clayborg
davide
Commits
rG595048f3ecf3: Wrap all references to build artifacts in the LLDB testsuite (NFC)
rLLDB323007: Wrap all references to build artifacts in the LLDB testsuite (NFC)
rL323007: Wrap all references to build artifacts in the LLDB testsuite (NFC)
Summary

This NFC commit is in preparation for https://reviews.llvm.org/D42281 (compile the LLDB tests out-of-tree).

Diff Detail

Event Timeline

aprantl created this revision.Jan 18 2018, 7:14 PM
Herald added subscribers: eraman, javed.absar, ki.stfu, kubamracek. · View Herald TranscriptJan 18 2018, 7:14 PM
labath added a subscriber: labath.Jan 19 2018, 2:19 AM

os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out") is getting quite long. I think we should make a utility function out of that.
Maybe self.getBuildArtifact("a.out") ? We could even make "a.out" the default value of the argument...

packages/Python/lldbsuite/test/android/platform/TestDefaultCacheLineSize.py
22

Do we want os.environ["LLDB_BUILD"] to be interpreted relative to os.getcwd(), what's the value of os.getcwd() at the point when this is executed?

aprantl updated this revision to Diff 130664.Jan 19 2018, 11:14 AM
aprantl retitled this revision from WIP: mechanical LLDB testsuite changes to Wrap all references to build artifacts in the LLDB testsuite in TestBase::getBuildArtifact().
aprantl edited the summary of this revision. (Show Details)
aprantl added reviewers: labath, jingham, zturner, jasonmolenda, clayborg.
aprantl added a subscriber: lldb-commits.

I have reworked this into an NFC commit based on feedback from Pavel.

Herald added subscribers: kbarton, nemanjai, emaste. · View Herald TranscriptJan 19 2018, 11:14 AM
jingham added a comment.Jan 19 2018, 11:31 AM

We have a lot of ugly boilerplate in the testsuite. I added:

(target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
                           "Set a breakpoint here", self.main_source_file)

Because that's what a lot of tests did. I converted a handful of tests and then ran out of time.

If we're going to touch how all the tests get started with their executable it would be nice to see how many of them can be easily converted to this interface. I can also add a file & line version of this, though in fact most tests that use file & line breakpoints actually use a source match to get a line number and then feed the line to lldb, so they could easily be converted to this.

Then all the business of locating the binary could be centralized.

I guess it's a little late for this comment, however...

vsk added a subscriber: vsk.Jan 19 2018, 11:38 AM
In D42280#982190, @jingham wrote:

We have a lot of ugly boilerplate in the testsuite. I added:

(target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
                           "Set a breakpoint here", self.main_source_file)

Because that's what a lot of tests did. I converted a handful of tests and then ran out of time.

If we're going to touch how all the tests get started with their executable it would be nice to see how many of them can be easily converted to this interface. I can also add a file & line version of this, though in fact most tests that use file & line breakpoints actually use a source match to get a line number and then feed the line to lldb, so they could easily be converted to this.

Then all the business of locating the binary could be centralized.

I guess it's a little late for this comment, however...

I think lldbutil.run_to_source_breakpoint is definitely worth standardizing on, but as it stands, this patch lgtm as an initial step.

labath accepted this revision.Jan 19 2018, 11:40 AM

Awesome. This will make flipping the out-of-tree switch much easier.

Making more tests use lldbutil.run_to_source_breakpoint would be nice, but I suspect that cannot be done with a shellscript, so I wouldn't tie that to this.

This revision is now accepted and ready to land.Jan 19 2018, 11:40 AM
davide accepted this revision.Jan 19 2018, 11:45 AM
davide added a subscriber: davide.

lgtm

clayborg accepted this revision.Jan 19 2018, 11:45 AM

Nice!

jingham accepted this revision.Jan 19 2018, 11:47 AM

I didn't intend to block this patch, just to point out that this was really work you shouldn't have had to do, and that as we touch these files we should clean them up so next time we don't have to. It will also make the test files easier to read.

aprantl added a comment.Jan 19 2018, 11:55 AM
In D42280#982229, @jingham wrote:

I didn't intend to block this patch, just to point out that this was really work you shouldn't have had to do, and that as we touch these files we should clean them up so next time we don't have to. It will also make the test files easier to read.

I skimmed through every test*.py file while preparing this patch and noticed that there seem to be 3-4 templates that many tests are derived from. Refactoring all the common code would be very good thing to do. I will try to get some of that done in subsequent patches.

aprantl updated this revision to Diff 130673.Jan 19 2018, 11:57 AM

Couple more bugfixes.
ninja check-lldb comes out clean for me now on Darwin.

Closed by commit rL323007: Wrap all references to build artifacts in the LLDB testsuite (NFC) (authored by adrian). · Explain WhyJan 19 2018, 3:26 PM
This revision was automatically updated to reflect the committed changes.
Herald added a subscriber: llvm-commits. · View Herald TranscriptJan 19 2018, 3:26 PM
labath added a comment.Jan 22 2018, 3:28 AM
In D42280#982229, @jingham wrote:

I didn't intend to block this patch, just to point out that this was really work you shouldn't have had to do, and that as we touch these files we should clean them up so next time we don't have to. It will also make the test files easier to read.

While we're on that topic, I would actually propose going one step further than lldbutil.run_to_source_breakpoint. I would propose creating a new test class (StandardLaunchTestCase ?) . This class would assume a certain executable name (a.out), a certain source file name (main.cpp, but this can be taken from a class property, so it can be overriden to main.mm for objc tests) and a certain breakpoint string.

That way, it can do the "build, set breakpoint, launch, validate stop reason" dance without any user input in the setUp() method, and the test can start with the process primed and ready and just focus on the thing it's testing

Revision Contents

PathSize
packages/
Python/
lldbsuite/
test/
android/
platform/
2 lines
api/
check_public_api_headers/
2 lines
listeners/
2 lines
multiple-debuggers/
4 lines
multiple-targets/
2 lines
multithreaded/
2 lines
arm/
breakpoint-it/
4 lines
benchmarks/
expression/
2 lines
4 lines
2 lines
4 lines
2 lines
driver/
batch_mode/
6 lines
expression_command/
expr-in-syscall/
2 lines
ir-interpreter-phi-nodes/
2 lines
multiline/
2 lines
options/
2 lines
test/
2 lines
functionalities/
apropos_with_process/
2 lines
archives/
2 lines
asan/
2 lines
2 lines
attach_resume/
2 lines
avoids-fd-leak/
4 lines
breakpoint/
address_breakpoints/
2 lines
auto_continue/
2 lines
breakpoint_case_sensitivity/
2 lines
breakpoint_command/
6 lines
2 lines
4 lines
breakpoint_conditions/
6 lines
breakpoint_hit_count/
2 lines
breakpoint_ids/
2 lines
breakpoint_ignore_count/
4 lines
breakpoint_in_delayslot/
2 lines
breakpoint_language/
4 lines
breakpoint_locations/
2 lines
breakpoint_names/
4 lines
breakpoint_options/
4 lines
comp_dir_symlink/
6 lines
cpp/
4 lines
cpp_exception/
2 lines
debugbreak/
2 lines
dummy_target_breakpoints/
2 lines
global_constructor/
2 lines
inlined_breakpoints/
2 lines
objc/
2 lines
serialize/
12 lines
source_regexp/
4 lines
step_over_breakpoint/
2 lines
command_script/
2 lines
command_script_immediate_output/
16 lines
conditional_break/
2 lines
data-formatter/
data-formatter-stl/
libcxx/
list/
loop/
2 lines
dead-strip/
2 lines
disassembly/
2 lines
2 lines
dynamic_value_child_count/
2 lines
embedded_interpreter/
2 lines
exec/
8 lines
expr-doesnt-deadlock/
2 lines
fat_archives/
2 lines
frame-diagnose/
array/
2 lines
bad-reference/
2 lines
complicated-expression/
2 lines
dereference-argument/
2 lines
dereference-function-return/
2 lines
dereference-this/
2 lines
inheritance/
2 lines
local-variable/
2 lines
virtual-method-call/
2 lines
frame-language/
2 lines
frame_var/
2 lines
inferior-assert/
12 lines
inferior-changed/
2 lines
inferior-crashing/
14 lines
recursive-inferior/
14 lines
inline-stepping/
6 lines
jitloader_gdb/
2 lines
launch_with_shellexpand/
2 lines
load_unload/
16 lines
longjmp/
2 lines
memory/
cache/
2 lines
find/
2 lines
read/
2 lines
mtc/
simple/
2 lines
nested_alias/
2 lines
non-overlapping-index-variable-i/
2 lines
nosucharch/
2 lines
postmortem/
minidump/
8 lines
process_attach/
4 lines
attach_denied/
2 lines
process_group/
2 lines
process_launch/
8 lines
process_save_core/
8 lines
ptr_refs/
2 lines
register/
intel_avx/
2 lines
intel_xtended_registers/
2 lines
mpx_bound_violation/
2 lines
register_command/
10 lines
rerun/
2 lines
return-value/
4 lines
set-data/
2 lines
signal/
2 lines
handle-segv/
2 lines
raise/
4 lines
stop-hook/
2 lines
2 lines
multiple_threads/
2 lines
target_command/
6 lines
thread/
backtrace_all/
2 lines
break_after_join/
2 lines
crash_during_step/
2 lines
create_after_attach/
2 lines
create_during_step/
2 lines
exit_during_break/
2 lines
exit_during_step/
2 lines
jump/
2 lines
multi_break/
2 lines
num_threads/
4 lines
state/
10 lines
step_out/
2 lines
step_until/
2 lines
thread_exit/
2 lines
thread_specific_break/
2 lines
thread_specific_break_plus_condition/
2 lines
tsan/
basic/
2 lines
cpp_global_location/
2 lines
global_location/
2 lines
multiple/
2 lines
thread_leak/
2 lines
thread_numbers/
2 lines
tty/
2 lines
ubsan/
basic/
2 lines
user-expression/
2 lines
unwind/
ehframe/
2 lines
noreturn/
2 lines
sigtramp/
2 lines
standard/
2 lines
watchpoint/
hello_watchlocation/
2 lines
hello_watchpoint/
2 lines
multi_watchpoint_slots/
2 lines
multiple_hits/
2 lines
step_over_watchpoint/
2 lines
variable_out_of_scope/
2 lines
watchpoint_commands/
10 lines
command/
4 lines
6 lines
condition/
2 lines
watchpoint_disable/
2 lines
watchpoint_events/
2 lines
watchpoint_on_vectors/
2 lines
watchpoint_set_command/
2 lines
2 lines
watchpoint_size/
2 lines
lang/
c/
anonymous/
4 lines
array_types/
4 lines
bitfields/
4 lines
blocks/
2 lines
conflicting-symbol/
4 lines
const_variables/
2 lines
enum_types/
2 lines
find_struct_type/
2 lines
forward/
2 lines
function_types/
2 lines
modules/
2 lines
register_variables/
2 lines
set_values/
2 lines
step-target/
2 lines
stepping/
2 lines
2 lines
tls_globals/
2 lines
typedef/
2 lines
unions/
2 lines
cpp/
breakpoint-commands/
2 lines
char1632_t/
2 lines
class_static/
2 lines
class_types/
8 lines
2 lines
diamond/
2 lines
dynamic-value/
2 lines
2 lines
enum_types/
2 lines
exceptions/
2 lines
inlines/
2 lines
namespace/
6 lines
stl/
4 lines
2 lines
template/
2 lines
unicode-literals/
2 lines
unique-types/
2 lines
unsigned_types/
2 lines
wchar_t/
2 lines
go/
expressions/
2 lines
formatters/
2 lines
goroutines/
2 lines
types/
2 lines
mixed/
2 lines
objc/
blocks/
2 lines
conflicting-definition/
2 lines
foundation/
2 lines
8 lines
12 lines
2 lines
2 lines
2 lines
global_ptrs/
2 lines
hidden-ivars/
2 lines
ivar-IMP/
2 lines
modules-auto-import/
2 lines
modules-incomplete/
2 lines
modules-inline-functions/
2 lines
modules/
2 lines
objc++/
2 lines
objc-baseclass-sbtype/
2 lines
objc-builtin-types/
2 lines
objc-checker/
2 lines
objc-class-method/
2 lines
objc-dyn-sbtype/
2 lines
objc-dynamic-value/
2 lines
objc-ivar-offsets/
2 lines
objc-ivar-stripped/
2 lines
objc-new-syntax/
2 lines
objc-optimized/
2 lines
objc-property/
2 lines
objc-static-method-stripped/
2 lines
objc-static-method/
2 lines
objc-stepping/
2 lines
objc-struct-argument/
2 lines
objc-struct-return/
2 lines
objc-super/
2 lines
print-obj/
2 lines
ptr_refs/
2 lines
radar-9691614/
2 lines
rdar-10967107/
2 lines
rdar-11355592/
2 lines
rdar-12408181/
2 lines
real-definition/
2 lines
single-entry-dictionary/
2 lines
linux/
add-symbols/
2 lines
thread/
create_during_instruction_step/
2 lines
2 lines
6 lines
4 lines
logging/
2 lines
macosx/
add-dsym/
2 lines
debug-info/
apple_types/
2 lines
find-dsym/
bundle-with-dot-in-filename/
2 lines
deep-bundle/
2 lines
indirect_symbol/
6 lines
nslog/
2 lines
order/
2 lines
queues/
4 lines
safe-to-func-call/
2 lines
thread-names/
2 lines
universal/
6 lines
python_api/
breakpoint/
4 lines
class_members/
2 lines
event/
6 lines
findvalue_duplist/
2 lines
frame/
6 lines
get-variables/
2 lines
inlines/
2 lines
function_symbol/
2 lines
2 lines
hello_world/
2 lines
interpreter/
2 lines
lldbutil/
frame/
2 lines
iter/
6 lines
2 lines
process/
2 lines
module_section/
6 lines
name_lookup/
2 lines
objc_type/
2 lines
process/
12 lines
io/
8 lines
read-mem-cstring/
2 lines
section/
2 lines
signals/
2 lines
symbol-context/
2 lines
two-files/
4 lines
target/
12 lines
thread/
10 lines
type/
2 lines
value/
2 lines
change_values/
2 lines
empty_class/
2 lines
linked_list/
2 lines
value_var_update/
2 lines
watchpoint/
2 lines
2 lines
2 lines
condition/
2 lines
watchlocation/
2 lines
4 lines
settings/
16 lines
quoting/
2 lines
source-manager/
16 lines
tools/
lldb-mi/
2 lines
2 lines
breakpoint/
2 lines
startup_options/
2 lines
symbol/
2 lines
types/
2 lines
warnings/
uuid/
4 lines

Diff 130544

packages/Python/lldbsuite/test/android/platform/TestDefaultCacheLineSize.py

Show All 13 Lines
class DefaultCacheLineSizeTestCase(TestBase): class DefaultCacheLineSizeTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipUnlessPlatform(['android']) @skipUnlessPlatform(['android'])
def test_cache_line_size(self): def test_cache_line_size(self):
self.build(dictionary=self.getBuildFlags()) self.build(dictionary=self.getBuildFlags())
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
labathUnsubmitted
Not Done
ReplyInline Actions

Do we want os.environ["LLDB_BUILD"] to be interpreted relative to os.getcwd(), what's the value of os.getcwd() at the point when this is executed?

labath: Do we want `os.environ["LLDB_BUILD"]` to be interpreted relative to `os.getcwd()`, what's the…
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target and target.IsValid(), "Target is valid") self.assertTrue(target and target.IsValid(), "Target is valid")
breakpoint = target.BreakpointCreateByName("main") breakpoint = target.BreakpointCreateByName("main")
self.assertTrue( self.assertTrue(
breakpoint and breakpoint.IsValid(), breakpoint and breakpoint.IsValid(),
"Breakpoint is valid") "Breakpoint is valid")
Show All 17 Lines

packages/Python/lldbsuite/test/api/check_public_api_headers/TestPublicAPIHeaders.py

Show All 33 Lines def test_sb_api_directory(self):
self.skipTest( self.skipTest(
"LLDB is 64-bit and cannot be linked to 32-bit test program.") "LLDB is 64-bit and cannot be linked to 32-bit test program.")
self.buildDriver(self.source, self.exe_name) self.buildDriver(self.source, self.exe_name)
self.sanity_check_executable(self.exe_name) self.sanity_check_executable(self.exe_name)
def sanity_check_executable(self, exe_name): def sanity_check_executable(self, exe_name):
"""Sanity check executable compiled from the auto-generated program.""" """Sanity check executable compiled from the auto-generated program."""
exe = os.path.join(os.getcwd(), exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, exe_name)
self.runCmd("file %s" % exe, CURRENT_EXECUTABLE_SET) self.runCmd("file %s" % exe, CURRENT_EXECUTABLE_SET)
self.line_to_break = line_number( self.line_to_break = line_number(
self.source, '// Set breakpoint here.') self.source, '// Set breakpoint here.')
env_cmd = "settings set target.env-vars %s=%s" % ( env_cmd = "settings set target.env-vars %s=%s" % (
self.dylibPath, self.getLLDBLibraryEnvVal()) self.dylibPath, self.getLLDBLibraryEnvVal())
if self.TraceOn(): if self.TraceOn():
Show All 18 Lines

packages/Python/lldbsuite/test/api/listeners/TestListener.py

Show All 29 Lines def test_receiving_breakpoint_added(self):
my_listener = lldb.SBListener("test_listener") my_listener = lldb.SBListener("test_listener")
my_listener.StartListeningForEventClass( my_listener.StartListeningForEventClass(
self.dbg, self.dbg,
lldb.SBTarget.GetBroadcasterClassName(), lldb.SBTarget.GetBroadcasterClassName(),
lldb.SBTarget.eBroadcastBitBreakpointChanged) lldb.SBTarget.eBroadcastBitBreakpointChanged)
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
bkpt = target.BreakpointCreateByName("main") bkpt = target.BreakpointCreateByName("main")
event = lldb.SBEvent() event = lldb.SBEvent()
my_listener.WaitForEvent(1, event) my_listener.WaitForEvent(1, event)
Show All 25 Lines

packages/Python/lldbsuite/test/api/multiple-debuggers/TestMultipleDebuggers.py

Show All 26 Lines @expectedFailureAll(
oslist=[ oslist=[
"windows", "windows",
"linux", "linux",
"freebsd"], "freebsd"],
bugnumber="llvm.org/pr20282") bugnumber="llvm.org/pr20282")
def test_multiple_debuggers(self): def test_multiple_debuggers(self):
env = {self.dylibPath: self.getLLDBLibraryEnvVal()} env = {self.dylibPath: self.getLLDBLibraryEnvVal()}
self.driver_exe = os.path.join(os.getcwd(), "multi-process-driver") self.driver_exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "multi-process-driver")
self.buildDriver('multi-process-driver.cpp', self.driver_exe) self.buildDriver('multi-process-driver.cpp', self.driver_exe)
self.addTearDownHook(lambda: os.remove(self.driver_exe)) self.addTearDownHook(lambda: os.remove(self.driver_exe))
self.signBinary(self.driver_exe) self.signBinary(self.driver_exe)
self.inferior_exe = os.path.join(os.getcwd(), "testprog") self.inferior_exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "testprog")
self.buildDriver('testprog.cpp', self.inferior_exe) self.buildDriver('testprog.cpp', self.inferior_exe)
self.addTearDownHook(lambda: os.remove(self.inferior_exe)) self.addTearDownHook(lambda: os.remove(self.inferior_exe))
# check_call will raise a CalledProcessError if multi-process-driver doesn't return # check_call will raise a CalledProcessError if multi-process-driver doesn't return
# exit code 0 to indicate success. We can let this exception go - the test harness # exit code 0 to indicate success. We can let this exception go - the test harness
# will recognize it as a test failure. # will recognize it as a test failure.
if self.TraceOn(): if self.TraceOn():
print("Running test %s" % self.driver_exe) print("Running test %s" % self.driver_exe)
check_call([self.driver_exe, self.inferior_exe], env=env) check_call([self.driver_exe, self.inferior_exe], env=env)
else: else:
with open(os.devnull, 'w') as fnull: with open(os.devnull, 'w') as fnull:
check_call([self.driver_exe, self.inferior_exe], check_call([self.driver_exe, self.inferior_exe],
env=env, stdout=fnull, stderr=fnull) env=env, stdout=fnull, stderr=fnull)

packages/Python/lldbsuite/test/api/multiple-targets/TestMultipleTargets.py

Show All 20 Linesclass TestMultipleTargets(TestBase):
@skipIfNoSBHeaders @skipIfNoSBHeaders
@skipIfHostIncompatibleWithRemote @skipIfHostIncompatibleWithRemote
@expectedFailureAll( @expectedFailureAll(
oslist=["windows", "freebsd"], oslist=["windows", "freebsd"],
bugnumber="llvm.org/pr20282") bugnumber="llvm.org/pr20282")
def test_multiple_targets(self): def test_multiple_targets(self):
env = {self.dylibPath: self.getLLDBLibraryEnvVal()} env = {self.dylibPath: self.getLLDBLibraryEnvVal()}
self.driver_exe = os.path.join(os.getcwd(), "multi-target") self.driver_exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "multi-target")
self.buildDriver('main.cpp', self.driver_exe) self.buildDriver('main.cpp', self.driver_exe)
self.addTearDownHook(lambda: os.remove(self.driver_exe)) self.addTearDownHook(lambda: os.remove(self.driver_exe))
self.signBinary(self.driver_exe) self.signBinary(self.driver_exe)
# check_call will raise a CalledProcessError if multi-process-driver doesn't return # check_call will raise a CalledProcessError if multi-process-driver doesn't return
# exit code 0 to indicate success. We can let this exception go - the test harness # exit code 0 to indicate success. We can let this exception go - the test harness
# will recognize it as a test failure. # will recognize it as a test failure.
if self.TraceOn(): if self.TraceOn():
print("Running test %s" % self.driver_exe) print("Running test %s" % self.driver_exe)
check_call([self.driver_exe, self.driver_exe], env=env) check_call([self.driver_exe, self.driver_exe], env=env)
else: else:
with open(os.devnull, 'w') as fnull: with open(os.devnull, 'w') as fnull:
check_call([self.driver_exe, self.driver_exe], check_call([self.driver_exe, self.driver_exe],
env=env, stdout=fnull, stderr=fnull) env=env, stdout=fnull, stderr=fnull)

packages/Python/lldbsuite/test/api/multithreaded/TestMultithreaded.py

Show First 20 Lines • Show All 86 Lines • ▼ Show 20 Lines def build_and_test(self, sources, test_name, args=None):
self.inferior = 'inferior_program' self.inferior = 'inferior_program'
self.buildProgram('inferior.cpp', self.inferior) self.buildProgram('inferior.cpp', self.inferior)
self.addTearDownHook(lambda: os.remove(self.inferior)) self.addTearDownHook(lambda: os.remove(self.inferior))
self.buildDriver(sources, test_name) self.buildDriver(sources, test_name)
self.addTearDownHook(lambda: os.remove(test_name)) self.addTearDownHook(lambda: os.remove(test_name))
test_exe = os.path.join(os.getcwd(), test_name) test_exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, test_name)
self.signBinary(test_exe) self.signBinary(test_exe)
exe = [test_exe, self.inferior] exe = [test_exe, self.inferior]
env = {self.dylibPath: self.getLLDBLibraryEnvVal()} env = {self.dylibPath: self.getLLDBLibraryEnvVal()}
if self.TraceOn(): if self.TraceOn():
print("Running test %s" % " ".join(exe)) print("Running test %s" % " ".join(exe))
check_call(exe, env=env) check_call(exe, env=env)
else: else:
with open(os.devnull, 'w') as fnull: with open(os.devnull, 'w') as fnull:
check_call(exe, env=env, stdout=fnull, stderr=fnull) check_call(exe, env=env, stdout=fnull, stderr=fnull)
def build_program(self, sources, program): def build_program(self, sources, program):
return self.buildDriver(sources, program) return self.buildDriver(sources, program)

packages/Python/lldbsuite/test/arm/breakpoint-it/TestBreakpointIt.py

Show All 15 Lines
class TestBreakpointIt(TestBase): class TestBreakpointIt(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
@skipIf(archs=no_match(["arm"])) @skipIf(archs=no_match(["arm"]))
def test_false(self): def test_false(self):
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("target create %s" % exe) self.runCmd("target create %s" % exe)
lldbutil.run_break_set_by_symbol(self, "bkpt_false", lldbutil.run_break_set_by_symbol(self, "bkpt_false",
extra_options="--skip-prologue 0") extra_options="--skip-prologue 0")
self.runCmd("run") self.runCmd("run")
self.assertEqual(self.process().GetState(), lldb.eStateExited, self.assertEqual(self.process().GetState(), lldb.eStateExited,
"Breakpoint does not get hit") "Breakpoint does not get hit")
@skipIf(archs=no_match(["arm"])) @skipIf(archs=no_match(["arm"]))
def test_true(self): def test_true(self):
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("target create %s" % exe) self.runCmd("target create %s" % exe)
bpid = lldbutil.run_break_set_by_symbol(self, "bkpt_true", bpid = lldbutil.run_break_set_by_symbol(self, "bkpt_true",
extra_options="--skip-prologue 0") extra_options="--skip-prologue 0")
self.runCmd("run") self.runCmd("run")
self.assertIsNotNone(lldbutil.get_one_thread_stopped_at_breakpoint_id( self.assertIsNotNone(lldbutil.get_one_thread_stopped_at_breakpoint_id(
self.process(), bpid)) self.process(), bpid))

packages/Python/lldbsuite/test/benchmarks/expression/TestExpressionCmd.py

Show All 33 Lines def test_expr_cmd(self):
self.exe_name = 'a.out' self.exe_name = 'a.out'
print() print()
self.run_lldb_repeated_exprs(self.exe_name, self.count) self.run_lldb_repeated_exprs(self.exe_name, self.count)
print("lldb expr cmd benchmark:", self.stopwatch) print("lldb expr cmd benchmark:", self.stopwatch)
def run_lldb_repeated_exprs(self, exe_name, count): def run_lldb_repeated_exprs(self, exe_name, count):
import pexpect import pexpect
exe = os.path.join(os.getcwd(), exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, exe_name)
# Set self.child_prompt, which is "(lldb) ". # Set self.child_prompt, which is "(lldb) ".
self.child_prompt = '(lldb) ' self.child_prompt = '(lldb) '
prompt = self.child_prompt prompt = self.child_prompt
# Reset the stopwatch now. # Reset the stopwatch now.
self.stopwatch.reset() self.stopwatch.reset()
for i in range(count): for i in range(count):
Show All 33 Lines

packages/Python/lldbsuite/test/benchmarks/expression/TestRepeatedExprs.py

Show All 38 Lines def test_compare_lldb_to_gdb(self):
self.run_lldb_repeated_exprs(self.exe_name, self.count) self.run_lldb_repeated_exprs(self.exe_name, self.count)
print("lldb benchmark:", self.stopwatch) print("lldb benchmark:", self.stopwatch)
self.run_gdb_repeated_exprs(self.exe_name, self.count) self.run_gdb_repeated_exprs(self.exe_name, self.count)
print("gdb benchmark:", self.stopwatch) print("gdb benchmark:", self.stopwatch)
print("lldb_avg/gdb_avg: %f" % (self.lldb_avg / self.gdb_avg)) print("lldb_avg/gdb_avg: %f" % (self.lldb_avg / self.gdb_avg))
def run_lldb_repeated_exprs(self, exe_name, count): def run_lldb_repeated_exprs(self, exe_name, count):
import pexpect import pexpect
exe = os.path.join(os.getcwd(), exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, exe_name)
# Set self.child_prompt, which is "(lldb) ". # Set self.child_prompt, which is "(lldb) ".
self.child_prompt = '(lldb) ' self.child_prompt = '(lldb) '
prompt = self.child_prompt prompt = self.child_prompt
# So that the child gets torn down after the test. # So that the child gets torn down after the test.
self.child = pexpect.spawn( self.child = pexpect.spawn(
'%s %s %s' % '%s %s %s' %
Show All 33 Lines def run_lldb_repeated_exprs(self, exe_name, count):
self.lldb_avg = self.stopwatch.avg() self.lldb_avg = self.stopwatch.avg()
if self.TraceOn(): if self.TraceOn():
print("lldb expression benchmark:", str(self.stopwatch)) print("lldb expression benchmark:", str(self.stopwatch))
self.child = None self.child = None
def run_gdb_repeated_exprs(self, exe_name, count): def run_gdb_repeated_exprs(self, exe_name, count):
import pexpect import pexpect
exe = os.path.join(os.getcwd(), exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, exe_name)
# Set self.child_prompt, which is "(gdb) ". # Set self.child_prompt, which is "(gdb) ".
self.child_prompt = '(gdb) ' self.child_prompt = '(gdb) '
prompt = self.child_prompt prompt = self.child_prompt
# So that the child gets torn down after the test. # So that the child gets torn down after the test.
self.child = pexpect.spawn('gdb --nx %s' % exe) self.child = pexpect.spawn('gdb --nx %s' % exe)
child = self.child child = self.child
Show All 36 Lines

packages/Python/lldbsuite/test/concurrent_base.py

Show First 20 Lines • Show All 108 Lines • ▼ Show 20 Lines def do_thread_actions(self,
num_delay_watchpoint_threads=0, num_delay_watchpoint_threads=0,
num_delay_crash_threads=0): num_delay_crash_threads=0):
""" Sets a breakpoint in the main thread where test parameters (numbers of threads) can be adjusted, runs the inferior """ Sets a breakpoint in the main thread where test parameters (numbers of threads) can be adjusted, runs the inferior
to that point, and modifies the locals that control the event thread counts. Also sets a breakpoint in to that point, and modifies the locals that control the event thread counts. Also sets a breakpoint in
breakpoint_func (the function executed by each 'breakpoint' thread) and a watchpoint on a global modified in breakpoint_func (the function executed by each 'breakpoint' thread) and a watchpoint on a global modified in
watchpoint_func. The inferior is continued until exit or a crash takes place, and the number of events seen by LLDB watchpoint_func. The inferior is continued until exit or a crash takes place, and the number of events seen by LLDB
is verified to match the expected number of events. is verified to match the expected number of events.
""" """
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Get the target # Get the target
self.inferior_target = self.dbg.GetSelectedTarget() self.inferior_target = self.dbg.GetSelectedTarget()
expected_bps = [] expected_bps = []
# Initialize all the breakpoints (main thread/aux thread) # Initialize all the breakpoints (main thread/aux thread)
▲ Show 20 Lines • Show All 163 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/darwin_log.py

Show First 20 Lines • Show All 156 Lines • ▼ Show 20 Lines def do_test(self, enable_options, expect_regexes=None,
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
# Build the darwin-log enable command. # Build the darwin-log enable command.
enable_cmd = expand_darwinlog_command('enable') enable_cmd = expand_darwinlog_command('enable')
if enable_options is not None and len(enable_options) > 0: if enable_options is not None and len(enable_options) > 0:
enable_cmd += ' ' + ' '.join(enable_options) enable_cmd += ' ' + ' '.join(enable_options)
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.exe_name)
self.run_lldb_to_breakpoint(exe, self.source, self.line, self.run_lldb_to_breakpoint(exe, self.source, self.line,
enable_command=enable_cmd, enable_command=enable_cmd,
settings_commands=settings_commands) settings_commands=settings_commands)
self.expect_prompt() self.expect_prompt()
# Now go. # Now go.
self.runCmd("process continue") self.runCmd("process continue")
self.expect(self.CONTINUE_REGEX) self.expect(self.CONTINUE_REGEX)
▲ Show 20 Lines • Show All 167 Lines • ▼ Show 20 Lines def do_test(self, enable_options, settings_commands=None,
@return @return
A list of structured data events received, in the order they A list of structured data events received, in the order they
were received. were received.
""" """
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.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, lldbtest.VALID_TARGET) self.assertTrue(target, lldbtest.VALID_TARGET)
# Run the darwin-log settings commands. # Run the darwin-log settings commands.
if settings_commands is not None: if settings_commands is not None:
for setting_command in settings_commands: for setting_command in settings_commands:
▲ Show 20 Lines • Show All 100 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/dosep.py

Show First 20 Lines • Show All 1,617 Lines • ▼ Show 20 Linesdef main(num_threads, test_subdir, test_runner_name, results_formatter):
# We can't use sys.path[0] to determine the script directory # We can't use sys.path[0] to determine the script directory
# because it doesn't work under a debugger # because it doesn't work under a debugger
parser = dotest_args.create_parser() parser = dotest_args.create_parser()
global dotest_options global dotest_options
dotest_options = dotest_args.parse_args(parser, dotest_argv) dotest_options = dotest_args.parse_args(parser, dotest_argv)
adjust_inferior_options(dotest_argv) adjust_inferior_options(dotest_argv)
session_dir = os.path.join(os.getcwd(), dotest_options.s) session_dir = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, dotest_options.s)
# The root directory was specified on the command line # The root directory was specified on the command line
test_directory = os.path.dirname(os.path.realpath(__file__)) test_directory = os.path.dirname(os.path.realpath(__file__))
if test_subdir and len(test_subdir) > 0: if test_subdir and len(test_subdir) > 0:
test_subdir = os.path.join(test_directory, test_subdir) test_subdir = os.path.join(test_directory, test_subdir)
if not os.path.isdir(test_subdir): if not os.path.isdir(test_subdir):
print( print(
'specified test subdirectory {} is not a valid directory\n' 'specified test subdirectory {} is not a valid directory\n'
▲ Show 20 Lines • Show All 176 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/driver/batch_mode/TestBatchMode.py

Show All 40 Lines @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr22274: need a pexpect replacement for windows") bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
def test_batch_mode_run_crash(self): def test_batch_mode_run_crash(self):
"""Test that the lldb driver's batch mode works correctly.""" """Test that the lldb driver's batch mode works correctly."""
self.build() self.build()
self.setTearDownCleanup() self.setTearDownCleanup()
import pexpect import pexpect
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
prompt = "(lldb) " prompt = "(lldb) "
# Pass CRASH so the process will crash and stop in batch mode. # Pass CRASH so the process will crash and stop in batch mode.
run_commands = ' -b -o "break set -n main" -o "run" -o "continue" -k "frame var touch_me_not"' run_commands = ' -b -o "break set -n main" -o "run" -o "continue" -k "frame var touch_me_not"'
self.child = pexpect.spawn( self.child = pexpect.spawn(
'%s %s %s %s -- CRASH' % '%s %s %s %s -- CRASH' %
(lldbtest_config.lldbExec, self.lldbOption, run_commands, exe)) (lldbtest_config.lldbExec, self.lldbOption, run_commands, exe))
child = self.child child = self.child
Show All 23 Lines @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr22274: need a pexpect replacement for windows") bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
def test_batch_mode_run_exit(self): def test_batch_mode_run_exit(self):
"""Test that the lldb driver's batch mode works correctly.""" """Test that the lldb driver's batch mode works correctly."""
self.build() self.build()
self.setTearDownCleanup() self.setTearDownCleanup()
import pexpect import pexpect
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
prompt = "(lldb) " prompt = "(lldb) "
# Now do it again, and make sure if we don't crash, we quit: # Now do it again, and make sure if we don't crash, we quit:
run_commands = ' -b -o "break set -n main" -o "run" -o "continue" ' run_commands = ' -b -o "break set -n main" -o "run" -o "continue" '
self.child = pexpect.spawn( self.child = pexpect.spawn(
'%s %s %s %s -- NOCRASH' % '%s %s %s %s -- NOCRASH' %
(lldbtest_config.lldbExec, self.lldbOption, run_commands, exe)) (lldbtest_config.lldbExec, self.lldbOption, run_commands, exe))
child = self.child child = self.child
Show All 26 Lines @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr22274: need a pexpect replacement for windows") bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
def test_batch_mode_attach_exit(self): def test_batch_mode_attach_exit(self):
"""Test that the lldb driver's batch mode works correctly.""" """Test that the lldb driver's batch mode works correctly."""
self.build() self.build()
self.setTearDownCleanup() self.setTearDownCleanup()
import pexpect import pexpect
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
prompt = "(lldb) " prompt = "(lldb) "
# Finally, start up the process by hand, attach to it, and wait for its completion. # Finally, start up the process by hand, attach to it, and wait for its completion.
# Attach is funny, since it looks like it stops with a signal on most Unixen so # Attach is funny, since it looks like it stops with a signal on most Unixen so
# care must be taken not to treat that as a reason to exit batch mode. # care must be taken not to treat that as a reason to exit batch mode.
# Start up the process by hand and wait for it to get to the wait loop. # Start up the process by hand and wait for it to get to the wait loop.
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/expression_command/expr-in-syscall/TestExpressionInSyscall.py

Show All 16 Linesclass ExprSyscallTestCase(TestBase):
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr21765, getpid() does not exist on Windows") bugnumber="llvm.org/pr21765, getpid() does not exist on Windows")
def test_setpgid(self): def test_setpgid(self):
self.build() self.build()
self.expr_syscall() self.expr_syscall()
def expr_syscall(self): def expr_syscall(self):
exe = os.path.join(os.getcwd(), 'a.out') exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, 'a.out')
# 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)
listener = lldb.SBListener("my listener") listener = lldb.SBListener("my listener")
# launch the inferior and don't wait for it to stop # launch the inferior and don't wait for it to stop
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/expression_command/ir-interpreter-phi-nodes/TestIRInterpreterPHINodes.py

Show All 11 Lines
class IRInterpreterPHINodesTestCase(TestBase): class IRInterpreterPHINodesTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def test_phi_node_support(self): def test_phi_node_support(self):
"""Test support for PHI nodes in the IR interpreter.""" """Test support for PHI nodes in the IR interpreter."""
self.build() self.build()
exe = os.path.join(os.getcwd(), 'a.out') exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, 'a.out')
self.runCmd('file ' + exe, CURRENT_EXECUTABLE_SET) self.runCmd('file ' + exe, CURRENT_EXECUTABLE_SET)
# Break on the first assignment to i # Break on the first assignment to i
line = line_number('main.cpp', 'i = 5') line = line_number('main.cpp', 'i = 5')
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=True) self, 'main.cpp', line, num_expected_locations=1, loc_exact=True)
self.runCmd('run', RUN_SUCCEEDED) self.runCmd('run', RUN_SUCCEEDED)
Show All 15 Lines

packages/Python/lldbsuite/test/expression_command/multiline/TestMultilineExpressions.py

Show All 22 Linesclass MultilineExpressionsTestCase(TestBase):
@skipIfRemote @skipIfRemote
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr22274: need a pexpect replacement for windows") bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
def test_with_run_commands(self): def test_with_run_commands(self):
"""Test that multiline expressions work correctly""" """Test that multiline expressions work correctly"""
self.build() self.build()
import pexpect import pexpect
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
prompt = "(lldb) " prompt = "(lldb) "
# So that the child gets torn down after the test. # So that the child gets torn down after the test.
self.child = pexpect.spawn( self.child = pexpect.spawn(
'%s %s %s' % '%s %s %s' %
(lldbtest_config.lldbExec, self.lldbOption, exe)) (lldbtest_config.lldbExec, self.lldbOption, exe))
child = self.child child = self.child
# Turn on logging for what the child sends back. # Turn on logging for what the child sends back.
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/expression_command/options/TestExprOptions.py

Show All 22 Linesclass ExprOptionsTestCase(TestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
self.main_source = "main.cpp" self.main_source = "main.cpp"
self.main_source_spec = lldb.SBFileSpec(self.main_source) self.main_source_spec = lldb.SBFileSpec(self.main_source)
self.line = line_number('main.cpp', '// breakpoint_in_main') self.line = line_number('main.cpp', '// breakpoint_in_main')
self.exe = os.path.join(os.getcwd(), "a.out") self.exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
def test_expr_options(self): def test_expr_options(self):
"""These expression command options should work as expected.""" """These expression command options should work as expected."""
self.build() self.build()
# Set debugger into synchronous mode # Set debugger into synchronous mode
self.dbg.SetAsync(False) self.dbg.SetAsync(False)
Show All 26 Lines

packages/Python/lldbsuite/test/expression_command/test/TestExprs.py

Show First 20 Lines • Show All 101 Lines • ▼ Show 20 Lines def test_many_expr_commands(self):
# (const char *) $8 = 0x... "/Volumes/data/lldb/svn/trunk/test/expression_command/test/a.out" # (const char *) $8 = 0x... "/Volumes/data/lldb/svn/trunk/test/expression_command/test/a.out"
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
def test_evaluate_expression_python(self): def test_evaluate_expression_python(self):
"""Test SBFrame.EvaluateExpression() API for evaluating an expression.""" """Test SBFrame.EvaluateExpression() API for evaluating an expression."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Create the breakpoint. # Create the breakpoint.
filespec = lldb.SBFileSpec("main.cpp", False) filespec = lldb.SBFileSpec("main.cpp", False)
breakpoint = target.BreakpointCreateByLocation(filespec, self.line) breakpoint = target.BreakpointCreateByLocation(filespec, self.line)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
▲ Show 20 Lines • Show All 137 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/apropos_with_process/TestAproposWithProcess.py

Show All 20 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break inside main(). # Find the line number to break inside main().
self.line = line_number('main.cpp', '// break here') self.line = line_number('main.cpp', '// break here')
def test_apropos_with_process(self): def test_apropos_with_process(self):
"""Test that apropos env doesn't crash trying to touch the process plugin commmand.""" """Test that apropos env doesn't crash trying to touch the process plugin commmand."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break in main() aftre the variables are assigned values. # Break in main() aftre the variables are assigned values.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 9 Lines

packages/Python/lldbsuite/test/functionalities/archives/TestBSDArchives.py

Show All 29 Lines @expectedFailureAll(
archs=[ archs=[
"arm", "arm",
"aarch64"], "aarch64"],
bugnumber="llvm.org/pr27795") bugnumber="llvm.org/pr27795")
def test(self): def test(self):
"""Break inside a() and b() defined within libfoo.a.""" """Break inside a() and b() defined within libfoo.a."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside a() by file and line first. # Break inside a() by file and line first.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "a.c", self.line, num_expected_locations=1, loc_exact=True) self, "a.c", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 24 Lines

packages/Python/lldbsuite/test/functionalities/asan/TestMemoryHistory.py

Show All 31 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
self.line_malloc = line_number('main.c', '// malloc line') self.line_malloc = line_number('main.c', '// malloc line')
self.line_malloc2 = line_number('main.c', '// malloc2 line') self.line_malloc2 = line_number('main.c', '// malloc2 line')
self.line_free = line_number('main.c', '// free line') self.line_free = line_number('main.c', '// free line')
self.line_breakpoint = line_number('main.c', '// break line') self.line_breakpoint = line_number('main.c', '// break line')
def asan_tests(self): def asan_tests(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.expect( self.expect(
"file " + exe, "file " + exe,
patterns=["Current executable set to .*a.out"]) patterns=["Current executable set to .*a.out"])
self.runCmd("breakpoint set -f main.c -l %d" % self.line_breakpoint) self.runCmd("breakpoint set -f main.c -l %d" % self.line_breakpoint)
# "memory history" command should not work without a process # "memory history" command should not work without a process
self.expect("memory history 0", self.expect("memory history 0",
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/asan/TestReportData.py

Show All 33 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
self.line_malloc = line_number('main.c', '// malloc line') self.line_malloc = line_number('main.c', '// malloc line')
self.line_malloc2 = line_number('main.c', '// malloc2 line') self.line_malloc2 = line_number('main.c', '// malloc2 line')
self.line_free = line_number('main.c', '// free line') self.line_free = line_number('main.c', '// free line')
self.line_breakpoint = line_number('main.c', '// break line') self.line_breakpoint = line_number('main.c', '// break line')
self.line_crash = line_number('main.c', '// BOOM line') self.line_crash = line_number('main.c', '// BOOM line')
def asan_tests(self): def asan_tests(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.expect( self.expect(
"file " + exe, "file " + exe,
patterns=["Current executable set to .*a.out"]) patterns=["Current executable set to .*a.out"])
self.runCmd("run") self.runCmd("run")
stop_reason = self.dbg.GetSelectedTarget().process.GetSelectedThread().GetStopReason() stop_reason = self.dbg.GetSelectedTarget().process.GetSelectedThread().GetStopReason()
if stop_reason == lldb.eStopReasonExec: if stop_reason == lldb.eStopReasonExec:
# On OS X 10.10 and older, we need to re-exec to enable # On OS X 10.10 and older, we need to re-exec to enable
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/attach_resume/TestAttachResume.py

Show All 24 Linesclass AttachResumeTestCase(TestBase):
def test_attach_continue_interrupt_detach(self): def test_attach_continue_interrupt_detach(self):
"""Test attach/continue/interrupt/detach""" """Test attach/continue/interrupt/detach"""
self.build() self.build()
self.process_attach_continue_interrupt_detach() self.process_attach_continue_interrupt_detach()
def process_attach_continue_interrupt_detach(self): def process_attach_continue_interrupt_detach(self):
"""Test attach/continue/interrupt/detach""" """Test attach/continue/interrupt/detach"""
exe = os.path.join(os.getcwd(), exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, exe_name)
popen = self.spawnSubprocess(exe) popen = self.spawnSubprocess(exe)
self.addTearDownHook(self.cleanupSubprocesses) self.addTearDownHook(self.cleanupSubprocesses)
self.runCmd("process attach -p " + str(popen.pid)) self.runCmd("process attach -p " + str(popen.pid))
self.setAsync(True) self.setAsync(True)
listener = self.dbg.GetListener() listener = self.dbg.GetListener()
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/avoids-fd-leak/TestFdLeak.py

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Linesclass AvoidsFdLeakTestCase(TestBase):
@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_log(self): def test_fd_leak_log(self):
self.do_test(["log enable -f '/dev/null' lldb commands"]) self.do_test(["log enable -f '/dev/null' lldb commands"])
def do_test(self, commands): def do_test(self, commands):
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
for c in commands: for c in 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())
Show All 12 Lines @expectedFailureAll(
bugnumber="llvm.org/pr25624 still failing with Python 2.7.10") bugnumber="llvm.org/pr25624 still failing with Python 2.7.10")
# 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 = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "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())
Show All 16 Lines

packages/Python/lldbsuite/test/functionalities/breakpoint/address_breakpoints/TestAddressBreakpoints.py

Show All 24 Lines def test_address_breakpoints(self):
self.address_breakpoints() self.address_breakpoints()
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
def address_breakpoints(self): def address_breakpoints(self):
"""Test address breakpoints set with shared library of SBAddress work correctly.""" """Test address breakpoints set with shared library of SBAddress work correctly."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Now create a breakpoint on main.c by name 'c'. # Now create a breakpoint on main.c by name 'c'.
breakpoint = target.BreakpointCreateBySourceRegex( breakpoint = target.BreakpointCreateBySourceRegex(
"Set a breakpoint here", lldb.SBFileSpec("main.c")) "Set a breakpoint here", lldb.SBFileSpec("main.c"))
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/breakpoint/auto_continue/TestBreakpointAutoContinue.py

Show All 30 Linesclass BreakpointAutoContinue(TestBase):
def test_auto_continue_on_location(self): def test_auto_continue_on_location(self):
"""Set auto-continue on a location and make sure only that location continues""" """Set auto-continue on a location and make sure only that location continues"""
self.build() self.build()
self.auto_continue_location() self.auto_continue_location()
def make_target_and_bkpt(self, additional_options=None, num_expected_loc=1, def make_target_and_bkpt(self, additional_options=None, num_expected_loc=1,
pattern="Set a breakpoint here"): pattern="Set a breakpoint here"):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.target = self.dbg.CreateTarget(exe) self.target = self.dbg.CreateTarget(exe)
self.assertTrue(self.target.IsValid(), "Target is not valid") self.assertTrue(self.target.IsValid(), "Target is not valid")
extra_options_txt = "--auto-continue 1 " extra_options_txt = "--auto-continue 1 "
if additional_options: if additional_options:
extra_options_txt += additional_options extra_options_txt += additional_options
bpno = lldbutil.run_break_set_by_source_regexp(self, pattern, bpno = lldbutil.run_break_set_by_source_regexp(self, pattern,
extra_options = extra_options_txt, extra_options = extra_options_txt,
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_case_sensitivity/TestBreakpointCaseSensitivity.py

Show All 33 Linesclass BreakpointCaseSensitivityTestCase(TestBase):
def case_sensitivity_breakpoint(self, case_insensitive): def case_sensitivity_breakpoint(self, case_insensitive):
"""Set breakpoint on file, should match files with different case if case_insensitive is True""" """Set breakpoint on file, should match files with different case if case_insensitive is True"""
# use different case to check CreateTarget # use different case to check CreateTarget
exe = 'a.out' exe = 'a.out'
if case_insensitive: if case_insensitive:
exe = exe.upper() exe = exe.upper()
exe = os.path.join(os.getcwd(), exe) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, exe)
# Create a target by the debugger. # Create a target by the debugger.
self.target = self.dbg.CreateTarget(exe) self.target = self.dbg.CreateTarget(exe)
self.assertTrue(self.target, VALID_TARGET) self.assertTrue(self.target, VALID_TARGET)
cwd = os.getcwd() cwd = os.getcwd()
# try both BreakpointCreateByLocation and BreakpointCreateBySourceRegex # try both BreakpointCreateByLocation and BreakpointCreateBySourceRegex
for regex in [False, True]: for regex in [False, True]:
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_command/TestBreakpointCommand.py

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines def setUp(self):
self.line = line_number('main.c', '// Set break point at this line.') self.line = line_number('main.c', '// Set break point at this line.')
# disable "There is a running process, kill it and restart?" prompt # disable "There is a running process, kill it and restart?" prompt
self.runCmd("settings set auto-confirm true") self.runCmd("settings set auto-confirm true")
self.addTearDownHook( self.addTearDownHook(
lambda: self.runCmd("settings clear auto-confirm")) lambda: self.runCmd("settings clear auto-confirm"))
def breakpoint_command_sequence(self): def breakpoint_command_sequence(self):
"""Test a sequence of breakpoint command add, list, and delete.""" """Test a sequence of breakpoint command add, list, and delete."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add three breakpoints on the same line. The first time we don't specify the file, # Add three breakpoints on the same line. The first time we don't specify the file,
# since the default file is the one containing main: # since the default file is the one containing main:
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, None, self.line, num_expected_locations=1, loc_exact=True) self, None, self.line, num_expected_locations=1, loc_exact=True)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.c", self.line, num_expected_locations=1, loc_exact=True) self, "main.c", self.line, num_expected_locations=1, loc_exact=True)
▲ Show 20 Lines • Show All 169 Lines • ▼ Show 20 Lines def breakpoint_command_sequence(self):
'stop reason = breakpoint']) 'stop reason = breakpoint'])
# The breakpoint should have a hit count of 2. # The breakpoint should have a hit count of 2.
self.expect("breakpoint list -f", BREAKPOINT_HIT_TWICE, self.expect("breakpoint list -f", BREAKPOINT_HIT_TWICE,
substrs=['resolved, hit count = 2']) substrs=['resolved, hit count = 2'])
def breakpoint_command_script_parameters(self): def breakpoint_command_script_parameters(self):
"""Test that the frame and breakpoint location are being properly passed to the script breakpoint command function.""" """Test that the frame and breakpoint location are being properly passed to the script breakpoint command function."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint. # Add a breakpoint.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.c", self.line, num_expected_locations=1, loc_exact=True) self, "main.c", self.line, num_expected_locations=1, loc_exact=True)
# Now add callbacks for the breakpoints just created. # Now add callbacks for the breakpoints just created.
self.runCmd("breakpoint command add -s python -o 'here = open(\"output-2.txt\", \"w\"); here.write(str(frame) + \"\\n\"); here.write(str(bp_loc) + \"\\n\"); here.close()' 1") self.runCmd("breakpoint command add -s python -o 'here = open(\"output-2.txt\", \"w\"); here.write(str(frame) + \"\\n\"); here.write(str(bp_loc) + \"\\n\"); here.close()' 1")
Show All 26 Lines def breakpoint_command_script_parameters(self):
startstr="frame #0:", startstr="frame #0:",
patterns=["1.* where = .*main .* resolved, hit count = 1"]) patterns=["1.* where = .*main .* resolved, hit count = 1"])
# Now remove 'output-2.txt' # Now remove 'output-2.txt'
os.remove('output-2.txt') os.remove('output-2.txt')
def breakpoint_commands_on_creation(self): def breakpoint_commands_on_creation(self):
"""Test that setting breakpoint commands when creating the breakpoint works""" """Test that setting breakpoint commands when creating the breakpoint works"""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target.IsValid(), "Created an invalid target.") self.assertTrue(target.IsValid(), "Created an invalid target.")
# Add a breakpoint. # Add a breakpoint.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.c", self.line, num_expected_locations=1, loc_exact=True, self, "main.c", self.line, num_expected_locations=1, loc_exact=True,
extra_options='-C bt -C "thread list" -C continue') extra_options='-C bt -C "thread list" -C continue')
bkpt = target.FindBreakpointByID(1) bkpt = target.FindBreakpointByID(1)
self.assertTrue(bkpt.IsValid(), "Couldn't find breakpoint 1") self.assertTrue(bkpt.IsValid(), "Couldn't find breakpoint 1")
com_list = lldb.SBStringList() com_list = lldb.SBStringList()
bkpt.GetCommandLineCommands(com_list) bkpt.GetCommandLineCommands(com_list)
self.assertEqual(com_list.GetSize(), 3, "Got the wrong number of commands") self.assertEqual(com_list.GetSize(), 3, "Got the wrong number of commands")
self.assertEqual(com_list.GetStringAtIndex(0), "bt", "First bt") self.assertEqual(com_list.GetStringAtIndex(0), "bt", "First bt")
self.assertEqual(com_list.GetStringAtIndex(1), "thread list", "Next thread list") self.assertEqual(com_list.GetStringAtIndex(1), "thread list", "Next thread list")
self.assertEqual(com_list.GetStringAtIndex(2), "continue", "Last continue") self.assertEqual(com_list.GetStringAtIndex(2), "continue", "Last continue")

packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_command/TestBreakpointCommandsFromPython.py

Show All 25 Lines def test_step_out_python(self):
self.do_set_python_command_from_python() self.do_set_python_command_from_python()
def setUp(self): def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
self.main_source = "main.c" self.main_source = "main.c"
self.main_source_spec = lldb.SBFileSpec(self.main_source) self.main_source_spec = lldb.SBFileSpec(self.main_source)
def do_set_python_command_from_python(self): def do_set_python_command_from_python(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
error = lldb.SBError() error = lldb.SBError()
self.target = self.dbg.CreateTarget(exe) self.target = self.dbg.CreateTarget(exe)
self.assertTrue(self.target, VALID_TARGET) self.assertTrue(self.target, VALID_TARGET)
body_bkpt = self.target.BreakpointCreateBySourceRegex( body_bkpt = self.target.BreakpointCreateBySourceRegex(
"Set break point at this line.", self.main_source_spec) "Set break point at this line.", self.main_source_spec)
self.assertTrue(body_bkpt, VALID_BREAKPOINT) self.assertTrue(body_bkpt, VALID_BREAKPOINT)
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_command/TestRegexpBreakCommand.py

Show All 25 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break inside main(). # Find the line number to break inside main().
self.source = 'main.c' self.source = 'main.c'
self.line = line_number( self.line = line_number(
self.source, '// Set break point at this line.') self.source, '// Set break point at this line.')
def regexp_break_command(self): def regexp_break_command(self):
"""Test the super consie "b" command, which is analias for _regexp-break.""" """Test the super consie "b" command, which is analias for _regexp-break."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
break_results = lldbutil.run_break_set_command( break_results = lldbutil.run_break_set_command(
self, "b %d" % self, "b %d" %
self.line) self.line)
lldbutil.check_breakpoint_result( lldbutil.check_breakpoint_result(
self, self,
break_results, break_results,
file_name='main.c', file_name='main.c',
line_number=self.line, line_number=self.line,
num_locations=1) num_locations=1)
break_results = lldbutil.run_break_set_command( break_results = lldbutil.run_break_set_command(
self, "b %s:%d" % (self.source, self.line)) self, "b %s:%d" % (self.source, self.line))
lldbutil.check_breakpoint_result( lldbutil.check_breakpoint_result(
self, self,
break_results, break_results,
file_name='main.c', file_name='main.c',
line_number=self.line, line_number=self.line,
num_locations=1) num_locations=1)
# Check breakpoint with full file path. # Check breakpoint with full file path.
full_path = os.path.join(os.getcwd(), self.source) full_path = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.source)
break_results = lldbutil.run_break_set_command( break_results = lldbutil.run_break_set_command(
self, "b %s:%d" % (full_path, self.line)) self, "b %s:%d" % (full_path, self.line))
lldbutil.check_breakpoint_result( lldbutil.check_breakpoint_result(
self, self,
break_results, break_results,
file_name='main.c', file_name='main.c',
line_number=self.line, line_number=self.line,
num_locations=1) num_locations=1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', substrs=['stopped',
'stop reason = breakpoint']) 'stop reason = breakpoint'])

packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_conditions/TestBreakpointConditions.py

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines def setUp(self):
# Find the line number to of function 'c'. # Find the line number to of function 'c'.
self.line1 = line_number( self.line1 = line_number(
'main.c', '// Find the line number of function "c" here.') 'main.c', '// Find the line number of function "c" here.')
self.line2 = line_number( self.line2 = line_number(
'main.c', "// Find the line number of c's parent call here.") 'main.c', "// Find the line number of c's parent call here.")
def breakpoint_conditions(self, inline=False): def breakpoint_conditions(self, inline=False):
"""Exercise breakpoint condition with 'breakpoint modify -c <expr> id'.""" """Exercise breakpoint condition with 'breakpoint modify -c <expr> id'."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
if inline: if inline:
# Create a breakpoint by function name 'c' and set the condition. # Create a breakpoint by function name 'c' and set the condition.
lldbutil.run_break_set_by_symbol( lldbutil.run_break_set_by_symbol(
self, self,
"c", "c",
extra_options="-c 'val == 3'", extra_options="-c 'val == 3'",
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Lines def breakpoint_conditions(self, inline=False):
"frame variable --show-types val", "frame variable --show-types val",
VARIABLES_DISPLAYED_CORRECTLY, VARIABLES_DISPLAYED_CORRECTLY,
startstr='(int) val = 1') startstr='(int) val = 1')
self.runCmd("process kill") self.runCmd("process kill")
def breakpoint_conditions_python(self): def breakpoint_conditions_python(self):
"""Use Python APIs to set breakpoint conditions.""" """Use Python APIs to set breakpoint conditions."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Now create a breakpoint on main.c by name 'c'. # Now create a breakpoint on main.c by name 'c'.
breakpoint = target.BreakpointCreateByName('c', 'a.out') breakpoint = target.BreakpointCreateByName('c', 'a.out')
#print("breakpoint:", breakpoint) #print("breakpoint:", breakpoint)
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Lines def breakpoint_conditions_python(self):
options = lldb.SBExpressionOptions() options = lldb.SBExpressionOptions()
value = frame0.EvaluateExpression("$0", options) value = frame0.EvaluateExpression("$0", options)
self.assertTrue(value.GetError().Fail(), self.assertTrue(value.GetError().Fail(),
"Conditions should not make result variables.") "Conditions should not make result variables.")
process.Continue() process.Continue()
def breakpoint_invalid_conditions_python(self): def breakpoint_invalid_conditions_python(self):
"""Use Python APIs to set breakpoint conditions.""" """Use Python APIs to set breakpoint conditions."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Now create a breakpoint on main.c by name 'c'. # Now create a breakpoint on main.c by name 'c'.
breakpoint = target.BreakpointCreateByName('c', 'a.out') breakpoint = target.BreakpointCreateByName('c', 'a.out')
#print("breakpoint:", breakpoint) #print("breakpoint:", breakpoint)
Show All 26 Lines

packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_hit_count/TestBreakpointHitCount.py

Show All 26 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
self.a_int_body_line_no = line_number( self.a_int_body_line_no = line_number(
'main.cpp', '// Breakpoint Location 1') 'main.cpp', '// Breakpoint Location 1')
self.a_float_body_line_no = line_number( self.a_float_body_line_no = line_number(
'main.cpp', '// Breakpoint Location 2') 'main.cpp', '// Breakpoint Location 2')
def do_test_breakpoint_location_hit_count(self): def do_test_breakpoint_location_hit_count(self):
"""Use Python APIs to check breakpoint hit count.""" """Use Python APIs to check breakpoint hit count."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Create a breakpoint in main.cpp by name 'a', # Create a breakpoint in main.cpp by name 'a',
# there should be two locations. # there should be two locations.
breakpoint = target.BreakpointCreateByName('a', 'a.out') breakpoint = target.BreakpointCreateByName('a', 'a.out')
self.assertTrue(breakpoint and self.assertTrue(breakpoint and
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_ids/TestBreakpointIDs.py

Show All 13 Lines
class BreakpointIDTestCase(TestBase): class BreakpointIDTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def test(self): def test(self):
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.expect("file " + exe, self.expect("file " + exe,
patterns=["Current executable set to .*a.out"]) patterns=["Current executable set to .*a.out"])
bpno = lldbutil.run_break_set_by_symbol( bpno = lldbutil.run_break_set_by_symbol(
self, 'product', num_expected_locations=-1, sym_exact=False) self, 'product', num_expected_locations=-1, sym_exact=False)
self.assertTrue(bpno == 1, "First breakpoint number is 1.") self.assertTrue(bpno == 1, "First breakpoint number is 1.")
bpno = lldbutil.run_break_set_by_symbol( bpno = lldbutil.run_break_set_by_symbol(
Show All 30 Lines

packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_ignore_count/TestBreakpointIgnoreCount.py

Show All 40 Lines def setUp(self):
'main.c', '// a(3) -> c(3) Find the call site of c(3).') 'main.c', '// a(3) -> c(3) Find the call site of c(3).')
self.line4 = line_number( self.line4 = line_number(
'main.c', '// a(3) -> c(3) Find the call site of a(3).') 'main.c', '// a(3) -> c(3) Find the call site of a(3).')
self.line5 = line_number( self.line5 = line_number(
'main.c', '// Find the call site of c in main.') 'main.c', '// Find the call site of c in main.')
def breakpoint_ignore_count(self): def breakpoint_ignore_count(self):
"""Exercise breakpoint ignore count with 'breakpoint set -i <count>'.""" """Exercise breakpoint ignore count with 'breakpoint set -i <count>'."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Create a breakpoint in main.c at line1. # Create a breakpoint in main.c at line1.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, self,
'main.c', 'main.c',
self.line1, self.line1,
extra_options='-i 1', extra_options='-i 1',
Show All 38 Lines def breakpoint_ignore_count(self):
# in function name 'c'. And frame #2 should point to main.c:45. # in function name 'c'. And frame #2 should point to main.c:45.
self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT_IGNORE_COUNT, self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT_IGNORE_COUNT,
#substrs = ["stop reason = breakpoint"], #substrs = ["stop reason = breakpoint"],
patterns=["frame #0.*main.c:%d" % self.line1, patterns=["frame #0.*main.c:%d" % self.line1,
"frame #1.*main.c:%d" % self.line5]) "frame #1.*main.c:%d" % self.line5])
def breakpoint_ignore_count_python(self): def breakpoint_ignore_count_python(self):
"""Use Python APIs to set breakpoint ignore count.""" """Use Python APIs to set breakpoint ignore count."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Now create a breakpoint on main.c by name 'c'. # Now create a breakpoint on main.c by name 'c'.
breakpoint = target.BreakpointCreateByName('c', 'a.out') breakpoint = target.BreakpointCreateByName('c', 'a.out')
self.assertTrue(breakpoint and self.assertTrue(breakpoint and
Show All 40 Lines

packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_in_delayslot/TestAvoidBreakpointInDelaySlot.py

Show All 15 Lines
class AvoidBreakpointInDelaySlotAPITestCase(TestBase): class AvoidBreakpointInDelaySlotAPITestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipIf(archs=no_match(re.compile('mips*'))) @skipIf(archs=no_match(re.compile('mips*')))
def test(self): def test(self):
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.expect("file " + exe, self.expect("file " + exe,
patterns=["Current executable set to .*a.out.*"]) patterns=["Current executable set to .*a.out.*"])
# 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)
breakpoint = target.BreakpointCreateByName('main', 'a.out') breakpoint = target.BreakpointCreateByName('main', 'a.out')
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_language/TestBreakpointLanguage.py

Show All 30 Lines def check_location_file(self, bp, loc, test_name):
comp_name = comp_unit.GetFileSpec().GetFilename() comp_name = comp_unit.GetFileSpec().GetFilename()
return comp_name == test_name return comp_name == test_name
def test_regex_breakpoint_language(self): def test_regex_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 = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "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.BreakpointCreateByRegex( cpp_bp = self.target.BreakpointCreateByRegex(
"func_from", "func_from",
Show All 24 Lines def test_regex_breakpoint_language(self):
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 = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "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",
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_locations/TestBreakpointLocations.py

Show All 35 Linesclass BreakpointLocationsTestCase(TestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break inside main(). # Find the line number to break inside main().
self.line = line_number('main.c', '// Set break point at this line.') self.line = line_number('main.c', '// Set break point at this line.')
def set_breakpoint (self): def set_breakpoint (self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, "Target %s is not valid"%(exe)) self.assertTrue(target, "Target %s is not valid"%(exe))
# This should create a breakpoint with 3 locations. # This should create a breakpoint with 3 locations.
bkpt = target.BreakpointCreateByLocation("main.c", self.line) bkpt = target.BreakpointCreateByLocation("main.c", self.line)
# The breakpoint list should show 3 locations. # The breakpoint list should show 3 locations.
▲ Show 20 Lines • Show All 148 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_names/TestBreakpointNames.py

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Linesclass BreakpointNames(TestBase):
def test_configuring_permissions_cli(self): def test_configuring_permissions_cli(self):
"""Use Python APIs to test that configuring permissions on names works correctly.""" """Use Python APIs to test that configuring permissions on names works correctly."""
self.build() self.build()
self.setup_target() self.setup_target()
self.do_check_configuring_permissions_cli() self.do_check_configuring_permissions_cli()
def setup_target(self): def setup_target(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# Create a targets we are making breakpoint in and copying to: # Create a targets we are making breakpoint in and copying to:
self.target = self.dbg.CreateTarget(exe) self.target = self.dbg.CreateTarget(exe)
self.assertTrue(self.target, VALID_TARGET) self.assertTrue(self.target, VALID_TARGET)
self.main_file_spec = lldb.SBFileSpec(os.path.join(os.getcwd(), "main.c")) self.main_file_spec = lldb.SBFileSpec(os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "main.c"))
def check_name_in_target(self, bkpt_name): def check_name_in_target(self, bkpt_name):
name_list = lldb.SBStringList() name_list = lldb.SBStringList()
self.target.GetBreakpointNames(name_list) self.target.GetBreakpointNames(name_list)
found_it = False found_it = False
for name in name_list: for name in name_list:
if name == bkpt_name: if name == bkpt_name:
found_it = True found_it = True
▲ Show 20 Lines • Show All 293 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_options/TestBreakpointOptions.py

Show All 22 Linesclass BreakpointOptionsTestCase(TestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break inside main(). # Find the line number to break inside main().
self.line = line_number('main.cpp', '// Set break point at this line.') self.line = line_number('main.cpp', '// Set break point at this line.')
def breakpoint_options_test(self): def breakpoint_options_test(self):
"""Test breakpoint command for different options.""" """Test breakpoint command for different options."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# This should create a breakpoint with 1 locations. # This should create a breakpoint with 1 locations.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, self,
"main.cpp", "main.cpp",
self.line, self.line,
extra_options="-K 1", extra_options="-K 1",
Show All 33 Lines def breakpoint_options_test(self):
self.runCmd("process continue") self.runCmd("process continue")
# We should exit. # We should exit.
self.expect("process status", "Process exited successfully", self.expect("process status", "Process exited successfully",
patterns=["^Process [0-9]+ exited with status = 0"]) patterns=["^Process [0-9]+ exited with status = 0"])
def breakpoint_options_language_test(self): def breakpoint_options_language_test(self):
"""Test breakpoint command for language option.""" """Test breakpoint command for language option."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# This should create a breakpoint with 1 locations. # This should create a breakpoint with 1 locations.
lldbutil.run_break_set_by_symbol( lldbutil.run_break_set_by_symbol(
self, self,
'ns::func', 'ns::func',
sym_exact=False, sym_exact=False,
extra_options="-L c++", extra_options="-L c++",
Show All 26 Lines

packages/Python/lldbsuite/test/functionalities/breakpoint/comp_dir_symlink/TestCompDirSymLink.py

Show All 20 Linesclass CompDirSymLinkTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break inside main(). # Find the line number to break inside main().
self.line = line_number(_SRC_FILE, '// Set break point at this line.') self.line = line_number(_SRC_FILE, '// Set break point at this line.')
self.src_path = os.path.join(os.getcwd(), _SRC_FILE) self.src_path = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, _SRC_FILE)
@skipIf(hostoslist=["windows"]) @skipIf(hostoslist=["windows"])
def test_symlink_paths_set(self): def test_symlink_paths_set(self):
pwd_symlink = self.create_src_symlink() pwd_symlink = self.create_src_symlink()
self.doBuild(pwd_symlink) self.doBuild(pwd_symlink)
self.runCmd( self.runCmd(
"settings set %s %s" % "settings set %s %s" %
(_COMP_DIR_SYM_LINK_PROP, pwd_symlink)) (_COMP_DIR_SYM_LINK_PROP, pwd_symlink))
Show All 16 Lines def test_symlink_paths_unset(self):
self.assertRaises( self.assertRaises(
AssertionError, AssertionError,
lldbutil.run_break_set_by_file_and_line, lldbutil.run_break_set_by_file_and_line,
self, self,
self.src_path, self.src_path,
self.line) self.line)
def create_src_symlink(self): def create_src_symlink(self):
pwd_symlink = os.path.join(os.getcwd(), 'pwd_symlink') pwd_symlink = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, 'pwd_symlink')
if os.path.exists(pwd_symlink): if os.path.exists(pwd_symlink):
os.unlink(pwd_symlink) os.unlink(pwd_symlink)
os.symlink(os.getcwd(), pwd_symlink) os.symlink(os.getcwd(), pwd_symlink)
self.addTearDownHook(lambda: os.remove(pwd_symlink)) self.addTearDownHook(lambda: os.remove(pwd_symlink))
return pwd_symlink return pwd_symlink
def doBuild(self, pwd_symlink): def doBuild(self, pwd_symlink):
self.build(None, None, {'PWD': pwd_symlink}, True) self.build(None, None, {'PWD': pwd_symlink}, True)
exe = os.path.join(os.getcwd(), _EXE_NAME) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, _EXE_NAME)
self.runCmd('file ' + exe, CURRENT_EXECUTABLE_SET) self.runCmd('file ' + exe, CURRENT_EXECUTABLE_SET)

packages/Python/lldbsuite/test/functionalities/breakpoint/cpp/TestCPPBreakpointLocations.py

Show All 39 Lines def verify_breakpoint_locations(self, target, bp_dict):
found = name in bp_loc_names found = name in bp_loc_names
if not found: if not found:
print("Didn't find '%s' in: %s" % (name, bp_loc_names)) print("Didn't find '%s' in: %s" % (name, bp_loc_names))
self.assertTrue(found, "Make sure we find all required locations") self.assertTrue(found, "Make sure we find all required locations")
def breakpoint_id_tests(self): def breakpoint_id_tests(self):
# Create a target by the debugger. # Create a target by the debugger.
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
bp_dicts = [ bp_dicts = [
{'name': 'func1', 'loc_names': ['a::c::func1()', 'b::c::func1()']}, {'name': 'func1', 'loc_names': ['a::c::func1()', 'b::c::func1()']},
{'name': 'func2', 'loc_names': ['a::c::func2()', 'c::d::func2()']}, {'name': 'func2', 'loc_names': ['a::c::func2()', 'c::d::func2()']},
{'name': 'func3', 'loc_names': ['a::c::func3()', 'b::c::func3()', 'c::d::func3()']}, {'name': 'func3', 'loc_names': ['a::c::func3()', 'b::c::func3()', 'c::d::func3()']},
{'name': 'c::func1', 'loc_names': ['a::c::func1()', 'b::c::func1()']}, {'name': 'c::func1', 'loc_names': ['a::c::func1()', 'b::c::func1()']},
{'name': 'c::func2', 'loc_names': ['a::c::func2()']}, {'name': 'c::func2', 'loc_names': ['a::c::func2()']},
{'name': 'c::func3', 'loc_names': ['a::c::func3()', 'b::c::func3()']}, {'name': 'c::func3', 'loc_names': ['a::c::func3()', 'b::c::func3()']},
{'name': 'a::c::func1', 'loc_names': ['a::c::func1()']}, {'name': 'a::c::func1', 'loc_names': ['a::c::func1()']},
{'name': 'b::c::func1', 'loc_names': ['b::c::func1()']}, {'name': 'b::c::func1', 'loc_names': ['b::c::func1()']},
{'name': 'c::d::func2', 'loc_names': ['c::d::func2()']}, {'name': 'c::d::func2', 'loc_names': ['c::d::func2()']},
{'name': 'a::c::func1()', 'loc_names': ['a::c::func1()']}, {'name': 'a::c::func1()', 'loc_names': ['a::c::func1()']},
{'name': 'b::c::func1()', 'loc_names': ['b::c::func1()']}, {'name': 'b::c::func1()', 'loc_names': ['b::c::func1()']},
{'name': 'c::d::func2()', 'loc_names': ['c::d::func2()']}, {'name': 'c::d::func2()', 'loc_names': ['c::d::func2()']},
] ]
for bp_dict in bp_dicts: for bp_dict in bp_dicts:
self.verify_breakpoint_locations(target, bp_dict) self.verify_breakpoint_locations(target, bp_dict)
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24764") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24764")
def test_destructors(self): def test_destructors(self):
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
# Don't skip prologue, so we can check the breakpoint address more # Don't skip prologue, so we can check the breakpoint address more
# easily # easily
self.runCmd("settings set target.skip-prologue false") self.runCmd("settings set target.skip-prologue false")
try: try:
names = ['~c', 'c::~c', 'c::~c()'] names = ['~c', 'c::~c', 'c::~c()']
loc_names = {'a::c::~c()', 'b::c::~c()'} loc_names = {'a::c::~c()', 'b::c::~c()'}
Show All 34 Lines

packages/Python/lldbsuite/test/functionalities/breakpoint/cpp_exception/TestCPPExceptionBreakpoint.py

Show All 26 Lines def test_cpp_exception_breakpoint(self):
self.do_cpp_exception_bkpt() self.do_cpp_exception_bkpt()
def setUp(self): def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
self.main_source = "main.c" self.main_source = "main.c"
self.main_source_spec = lldb.SBFileSpec(self.main_source) self.main_source_spec = lldb.SBFileSpec(self.main_source)
def do_cpp_exception_bkpt(self): def do_cpp_exception_bkpt(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
error = lldb.SBError() error = lldb.SBError()
self.target = self.dbg.CreateTarget(exe) self.target = self.dbg.CreateTarget(exe)
self.assertTrue(self.target, VALID_TARGET) self.assertTrue(self.target, VALID_TARGET)
exception_bkpt = self.target.BreakpointCreateForException( exception_bkpt = self.target.BreakpointCreateForException(
lldb.eLanguageTypeC_plus_plus, False, True) lldb.eLanguageTypeC_plus_plus, False, True)
self.assertTrue( self.assertTrue(
Show All 11 Lines

packages/Python/lldbsuite/test/functionalities/breakpoint/debugbreak/TestDebugBreak.py

Show All 14 Linesclass DebugBreakTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipIf(archs=no_match(["i386", "i686", "x86_64"])) @skipIf(archs=no_match(["i386", "i686", "x86_64"]))
@no_debug_info_test @no_debug_info_test
def test_asm_int_3(self): def test_asm_int_3(self):
"""Test that intrinsics like `__debugbreak();` and `asm {"int3"}` are treated like breakpoints.""" """Test that intrinsics like `__debugbreak();` and `asm {"int3"}` are treated like breakpoints."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# Run the program. # Run the program.
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())
# We've hit the first stop, so grab the frame. # We've hit the first stop, so grab the frame.
self.assertEqual(process.GetState(), lldb.eStateStopped) self.assertEqual(process.GetState(), lldb.eStateStopped)
Show All 28 Lines

packages/Python/lldbsuite/test/functionalities/breakpoint/dummy_target_breakpoints/TestBreakpointsWithNoTargets.py

Show All 40 Lines def dummy_breakpoint_test(self):
# to get a clean slate for the next test case. # to get a clean slate for the next test case.
def cleanup(): def cleanup():
self.runCmd('breakpoint delete -D -f', check=False) self.runCmd('breakpoint delete -D -f', check=False)
self.runCmd('breakpoint list', check=False) self.runCmd('breakpoint list', check=False)
# Execute the cleanup function during test case tear down. # Execute the cleanup function during test case tear down.
self.addTearDownHook(cleanup) self.addTearDownHook(cleanup)
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# The breakpoint list should show 3 locations. # The breakpoint list should show 3 locations.
self.expect( self.expect(
"breakpoint list -f", "breakpoint list -f",
"Breakpoint locations shown correctly", "Breakpoint locations shown correctly",
substrs=[ substrs=[
"1: file = 'main.c', line = %d, exact_match = 0, locations = 1" % "1: file = 'main.c', line = %d, exact_match = 0, locations = 1" %
Show All 17 Lines

packages/Python/lldbsuite/test/functionalities/breakpoint/global_constructor/TestBreakpointInGlobalConstructor.py

Show All 19 Linesclass TestBreakpointInGlobalConstructors(TestBase):
def setUp(self): def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
self.line_foo = line_number('foo.cpp', '// !BR_foo') self.line_foo = line_number('foo.cpp', '// !BR_foo')
self.line_main = line_number('main.cpp', '// !BR_main') self.line_main = line_number('main.cpp', '// !BR_main')
@expectedFailureAll(bugnumber="llvm.org/pr35480", oslist=["linux"]) @expectedFailureAll(bugnumber="llvm.org/pr35480", oslist=["linux"])
def test(self): def test(self):
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file %s" % exe) self.runCmd("file %s" % exe)
bp_main = lldbutil.run_break_set_by_file_and_line( bp_main = lldbutil.run_break_set_by_file_and_line(
self, 'main.cpp', self.line_main) self, 'main.cpp', self.line_main)
bp_foo = lldbutil.run_break_set_by_file_and_line( bp_foo = lldbutil.run_break_set_by_file_and_line(
self, 'foo.cpp', self.line_foo) self, 'foo.cpp', self.line_foo)
self.runCmd("run") self.runCmd("run")
Show All 10 Lines

packages/Python/lldbsuite/test/functionalities/breakpoint/inlined_breakpoints/TestInlinedBreakpoints.py

Show All 27 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break inside basic_type.cpp. # Find the line number to break inside basic_type.cpp.
self.line = line_number( self.line = line_number(
'basic_type.cpp', 'basic_type.cpp',
'// Set break point at this line.') '// Set break point at this line.')
def inlined_breakpoints(self): def inlined_breakpoints(self):
"""Test 'b basic_types.cpp:176' does break (where int.cpp includes basic_type.cpp).""" """Test 'b basic_types.cpp:176' does break (where int.cpp includes basic_type.cpp)."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# With the inline-breakpoint-strategy, our file+line breakpoint should # With the inline-breakpoint-strategy, our file+line breakpoint should
# not resolve to a location. # not resolve to a location.
self.runCmd('settings set target.inline-breakpoint-strategy headers') self.runCmd('settings set target.inline-breakpoint-strategy headers')
# Set a breakpoint and fail because it is in an inlined source # Set a breakpoint and fail because it is in an inlined source
# implemenation file # implemenation file
Show All 25 Lines

packages/Python/lldbsuite/test/functionalities/breakpoint/objc/TestObjCBreakpoints.py

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Linesclass TestObjCBreakpoints(TestBase):
def check_objc_breakpoints(self, have_dsym): def check_objc_breakpoints(self, have_dsym):
"""Test constant string generation amd comparison by the expression parser.""" """Test constant string generation amd comparison by the expression parser."""
# Set debugger into synchronous mode # Set debugger into synchronous mode
self.dbg.SetAsync(False) self.dbg.SetAsync(False)
# Create a target by the debugger. # Create a target by the debugger.
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.target = self.dbg.CreateTarget(exe) self.target = self.dbg.CreateTarget(exe)
self.assertTrue(self.target, VALID_TARGET) self.assertTrue(self.target, VALID_TARGET)
#---------------------------------------------------------------------- #----------------------------------------------------------------------
# Set breakpoints on all selectors whose name is "count". This should # Set breakpoints on all selectors whose name is "count". This should
# catch breakpoints that are both C functions _and_ anything whose # catch breakpoints that are both C functions _and_ anything whose
# selector is "count" because just looking at "count" we can't tell # selector is "count" because just looking at "count" we can't tell
# definitively if the name is a selector or a C function # definitively if the name is a selector or a C function
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/breakpoint/serialize/TestBreakpointSerialization.py

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Lines def setup_targets_and_cleanup(self):
if self.orig_target.IsValid(): if self.orig_target.IsValid():
self.dbg.DeleteTarget(self.orig_target) self.dbg.DeleteTarget(self.orig_target)
self.dbg.DeleteTarget(self.copy_target) self.dbg.DeleteTarget(self.copy_target)
self.addTearDownHook(cleanup) self.addTearDownHook(cleanup)
self.RemoveTempFile(self.bkpts_file_path) self.RemoveTempFile(self.bkpts_file_path)
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# Create the targets we are making breakpoints in and copying them to: # Create the targets we are making breakpoints in and copying them to:
self.orig_target = self.dbg.CreateTarget(exe) self.orig_target = self.dbg.CreateTarget(exe)
self.assertTrue(self.orig_target, VALID_TARGET) self.assertTrue(self.orig_target, VALID_TARGET)
self.copy_target = self.dbg.CreateTarget(exe) self.copy_target = self.dbg.CreateTarget(exe)
self.assertTrue(self.copy_target, VALID_TARGET) self.assertTrue(self.copy_target, VALID_TARGET)
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
self.bkpts_file_path = os.path.join(os.getcwd(), "breakpoints.json") self.bkpts_file_path = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "breakpoints.json")
self.bkpts_file_spec = lldb.SBFileSpec(self.bkpts_file_path) self.bkpts_file_spec = lldb.SBFileSpec(self.bkpts_file_path)
def check_equivalence(self, source_bps, do_write = True): def check_equivalence(self, source_bps, do_write = True):
error = lldb.SBError() error = lldb.SBError()
if (do_write): if (do_write):
error = self.orig_target.BreakpointsWriteToFile(self.bkpts_file_spec, source_bps) error = self.orig_target.BreakpointsWriteToFile(self.bkpts_file_spec, source_bps)
Show All 29 Lines def check_equivalence(self, source_bps, do_write = True):
# print ("Source text for %d is %s."%(i, source_text)) # print ("Source text for %d is %s."%(i, source_text))
self.assertTrue (source_text == copy_text, "Source and dest breakpoints are not identical: \nsource: %s\ndest: %s"%(source_text, copy_text)) self.assertTrue (source_text == copy_text, "Source and dest breakpoints are not identical: \nsource: %s\ndest: %s"%(source_text, copy_text))
def do_check_resolvers(self): def do_check_resolvers(self):
"""Use Python APIs to check serialization of breakpoint resolvers""" """Use Python APIs to check serialization of breakpoint resolvers"""
empty_module_list = lldb.SBFileSpecList() empty_module_list = lldb.SBFileSpecList()
empty_cu_list = lldb.SBFileSpecList() empty_cu_list = lldb.SBFileSpecList()
blubby_file_spec = lldb.SBFileSpec(os.path.join(os.getcwd(), "blubby.c")) blubby_file_spec = lldb.SBFileSpec(os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "blubby.c"))
# It isn't actually important for these purposes that these breakpoint # It isn't actually important for these purposes that these breakpoint
# actually have locations. # actually have locations.
source_bps = lldb.SBBreakpointList(self.orig_target) source_bps = lldb.SBBreakpointList(self.orig_target)
source_bps.Append(self.orig_target.BreakpointCreateByLocation("blubby.c", 666)) source_bps.Append(self.orig_target.BreakpointCreateByLocation("blubby.c", 666))
# Make sure we do one breakpoint right: # Make sure we do one breakpoint right:
self.check_equivalence(source_bps) self.check_equivalence(source_bps)
source_bps.Clear() source_bps.Clear()
Show All 11 Lines def do_check_filters(self):
module_list.Append(lldb.SBFileSpec("SomeBinary")) module_list.Append(lldb.SBFileSpec("SomeBinary"))
module_list.Append(lldb.SBFileSpec("SomeOtherBinary")) module_list.Append(lldb.SBFileSpec("SomeOtherBinary"))
cu_list = lldb.SBFileSpecList() cu_list = lldb.SBFileSpecList()
cu_list.Append(lldb.SBFileSpec("SomeCU.c")) cu_list.Append(lldb.SBFileSpec("SomeCU.c"))
cu_list.Append(lldb.SBFileSpec("AnotherCU.c")) cu_list.Append(lldb.SBFileSpec("AnotherCU.c"))
cu_list.Append(lldb.SBFileSpec("ThirdCU.c")) cu_list.Append(lldb.SBFileSpec("ThirdCU.c"))
blubby_file_spec = lldb.SBFileSpec(os.path.join(os.getcwd(), "blubby.c")) blubby_file_spec = lldb.SBFileSpec(os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "blubby.c"))
# It isn't actually important for these purposes that these breakpoint # It isn't actually important for these purposes that these breakpoint
# actually have locations. # actually have locations.
source_bps = lldb.SBBreakpointList(self.orig_target) source_bps = lldb.SBBreakpointList(self.orig_target)
bkpt = self.orig_target.BreakpointCreateByLocation(blubby_file_spec, 666, 0, module_list) bkpt = self.orig_target.BreakpointCreateByLocation(blubby_file_spec, 666, 0, module_list)
source_bps.Append(bkpt) source_bps.Append(bkpt)
# Make sure we do one right: # Make sure we do one right:
Show All 10 Lines def do_check_filters(self):
# And some number greater than one: # And some number greater than one:
self.check_equivalence(source_bps) self.check_equivalence(source_bps)
def do_check_options(self): def do_check_options(self):
"""Use Python APIs to check serialization of breakpoint options.""" """Use Python APIs to check serialization of breakpoint options."""
empty_module_list = lldb.SBFileSpecList() empty_module_list = lldb.SBFileSpecList()
empty_cu_list = lldb.SBFileSpecList() empty_cu_list = lldb.SBFileSpecList()
blubby_file_spec = lldb.SBFileSpec(os.path.join(os.getcwd(), "blubby.c")) blubby_file_spec = lldb.SBFileSpec(os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "blubby.c"))
# It isn't actually important for these purposes that these breakpoint # It isn't actually important for these purposes that these breakpoint
# actually have locations. # actually have locations.
source_bps = lldb.SBBreakpointList(self.orig_target) source_bps = lldb.SBBreakpointList(self.orig_target)
bkpt = self.orig_target.BreakpointCreateByLocation("blubby.c", 666) bkpt = self.orig_target.BreakpointCreateByLocation("blubby.c", 666)
bkpt.SetEnabled(False) bkpt.SetEnabled(False)
bkpt.SetOneShot(True) bkpt.SetOneShot(True)
Show All 27 Lines def do_check_options(self):
self.check_equivalence(source_bps) self.check_equivalence(source_bps)
def do_check_appending(self): def do_check_appending(self):
"""Use Python APIs to check appending to already serialized options.""" """Use Python APIs to check appending to already serialized options."""
empty_module_list = lldb.SBFileSpecList() empty_module_list = lldb.SBFileSpecList()
empty_cu_list = lldb.SBFileSpecList() empty_cu_list = lldb.SBFileSpecList()
blubby_file_spec = lldb.SBFileSpec(os.path.join(os.getcwd(), "blubby.c")) blubby_file_spec = lldb.SBFileSpec(os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "blubby.c"))
# It isn't actually important for these purposes that these breakpoint # It isn't actually important for these purposes that these breakpoint
# actually have locations. # actually have locations.
all_bps = lldb.SBBreakpointList(self.orig_target) all_bps = lldb.SBBreakpointList(self.orig_target)
source_bps = lldb.SBBreakpointList(self.orig_target) source_bps = lldb.SBBreakpointList(self.orig_target)
bkpt = self.orig_target.BreakpointCreateByLocation("blubby.c", 666) bkpt = self.orig_target.BreakpointCreateByLocation("blubby.c", 666)
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/breakpoint/source_regexp/TestSourceRegexBreakpoints.py

Show All 22 Linesclass TestSourceRegexBreakpoints(TestBase):
def test_restrictions(self): def test_restrictions(self):
self.build() self.build()
self.source_regex_restrictions() self.source_regex_restrictions()
def source_regex_locations(self): def source_regex_locations(self):
""" Test that restricting source expressions to files & to functions. """ """ Test that restricting source expressions to files & to functions. """
# Create a target by the debugger. # Create a target by the debugger.
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# First look just in main: # First look just in main:
target_files = lldb.SBFileSpecList() target_files = lldb.SBFileSpecList()
target_files.Append(lldb.SBFileSpec("a.c")) target_files.Append(lldb.SBFileSpec("a.c"))
func_names = lldb.SBStringList() func_names = lldb.SBStringList()
Show All 19 Lines def source_regex_locations(self):
line_entry = address.GetLineEntry() line_entry = address.GetLineEntry()
self.assertTrue(line_entry.IsValid(), "Got a valid line entry.") self.assertTrue(line_entry.IsValid(), "Got a valid line entry.")
self.assertTrue(line_entry.line == a_func_line, self.assertTrue(line_entry.line == a_func_line,
"Our line number matches the one lldbtest found.") "Our line number matches the one lldbtest found.")
def source_regex_restrictions(self): def source_regex_restrictions(self):
""" Test that restricting source expressions to files & to functions. """ """ Test that restricting source expressions to files & to functions. """
# Create a target by the debugger. # Create a target by the debugger.
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# 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(
Show All 31 Lines

packages/Python/lldbsuite/test/functionalities/breakpoint/step_over_breakpoint/TestStepOverBreakpoint.py

Show All 15 Lines
class StepOverBreakpointsTestCase(TestBase): class StepOverBreakpointsTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def setUp(self): def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
src = lldb.SBFileSpec("main.cpp") src = lldb.SBFileSpec("main.cpp")
# Create a target by the debugger. # Create a target by the debugger.
self.target = self.dbg.CreateTarget(exe) self.target = self.dbg.CreateTarget(exe)
self.assertTrue(self.target, VALID_TARGET) self.assertTrue(self.target, VALID_TARGET)
# Setup four breakpoints, two of them with false condition # Setup four breakpoints, two of them with false condition
self.line1 = line_number('main.cpp', "breakpoint_1") self.line1 = line_number('main.cpp', "breakpoint_1")
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/command_script/TestCommandScript.py

Show All 21 Linesclass CmdPythonTestCase(TestBase):
def pycmd_tests(self): def pycmd_tests(self):
self.runCmd("command source py_import") self.runCmd("command source py_import")
# Verify command that specifies eCommandRequiresTarget returns failure # Verify command that specifies eCommandRequiresTarget returns failure
# without a target. # without a target.
self.expect('targetname', self.expect('targetname',
substrs=['a.out'], matching=False, error=True) substrs=['a.out'], matching=False, error=True)
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.expect("file " + exe, self.expect("file " + exe,
patterns=["Current executable set to .*a.out"]) patterns=["Current executable set to .*a.out"])
self.expect('targetname', self.expect('targetname',
substrs=['a.out'], matching=True, error=False) substrs=['a.out'], matching=True, error=False)
# This is the function to remove the custom commands in order to have a # This is the function to remove the custom commands in order to have a
# clean slate for the next test case. # clean slate for the next test case.
▲ Show 20 Lines • Show All 108 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/command_script_immediate_output/TestCommandScriptImmediateOutput.py

Show All 26 Linesclass CommandScriptImmediateOutputTestCase (PExpectTest):
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr22274: need a pexpect replacement for windows") bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
@expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr26139") @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr26139")
def test_command_script_immediate_output_console(self): def test_command_script_immediate_output_console(self):
"""Test that LLDB correctly allows scripted commands to set immediate output to the console.""" """Test that LLDB correctly allows scripted commands to set immediate output to the console."""
self.launch(timeout=10) self.launch(timeout=10)
script = os.path.join(os.getcwd(), 'custom_command.py') script = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, 'custom_command.py')
prompt = "\(lldb\) " prompt = "\(lldb\) "
self.sendline('command script import %s' % script, patterns=[prompt]) self.sendline('command script import %s' % script, patterns=[prompt])
self.sendline( self.sendline(
'command script add -f custom_command.command_function mycommand', 'command script add -f custom_command.command_function mycommand',
patterns=[prompt]) patterns=[prompt])
self.sendline( self.sendline(
'mycommand', 'mycommand',
patterns='this is a test string, just a test string') patterns='this is a test string, just a test string')
self.sendline('command script delete mycommand', patterns=[prompt]) self.sendline('command script delete mycommand', patterns=[prompt])
self.quit(gracefully=False) self.quit(gracefully=False)
@skipIfRemote # test not remote-ready llvm.org/pr24813 @skipIfRemote # test not remote-ready llvm.org/pr24813
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr22274: need a pexpect replacement for windows") bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
@expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr26139") @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr26139")
def test_command_script_immediate_output_file(self): def test_command_script_immediate_output_file(self):
"""Test that LLDB correctly allows scripted commands to set immediate output to a file.""" """Test that LLDB correctly allows scripted commands to set immediate output to a file."""
self.launch(timeout=10) self.launch(timeout=10)
test_files = {os.path.join(os.getcwd(), 'read.txt'): 'r', test_files = {os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, 'read.txt'): 'r',
os.path.join(os.getcwd(), 'write.txt'): 'w', os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, 'write.txt'): 'w',
os.path.join(os.getcwd(), 'append.txt'): 'a', os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, 'append.txt'): 'a',
os.path.join(os.getcwd(), 'write_plus.txt'): 'w+', os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, 'write_plus.txt'): 'w+',
os.path.join(os.getcwd(), 'read_plus.txt'): 'r+', os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, 'read_plus.txt'): 'r+',
os.path.join(os.getcwd(), 'append_plus.txt'): 'a+'} os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, 'append_plus.txt'): 'a+'}
starter_string = 'Starter Garbage\n' starter_string = 'Starter Garbage\n'
write_string = 'writing to file with mode: ' write_string = 'writing to file with mode: '
for path, mode in test_files.iteritems(): for path, mode in test_files.iteritems():
with open(path, 'w+') as init: with open(path, 'w+') as init:
init.write(starter_string) init.write(starter_string)
script = os.path.join(os.getcwd(), 'custom_command.py') script = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, 'custom_command.py')
prompt = "\(lldb\) " prompt = "\(lldb\) "
self.sendline('command script import %s' % script, patterns=[prompt]) self.sendline('command script import %s' % script, patterns=[prompt])
self.sendline( self.sendline(
'command script add -f custom_command.write_file mywrite', 'command script add -f custom_command.write_file mywrite',
patterns=[prompt]) patterns=[prompt])
for path, mode in test_files.iteritems(): for path, mode in test_files.iteritems():
Show All 18 Lines

packages/Python/lldbsuite/test/functionalities/conditional_break/TestConditionalBreak.py

Show All 33 Lines def test_with_command(self):
self.build() self.build()
self.simulate_conditional_break_by_user() self.simulate_conditional_break_by_user()
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr26265: args in frames other than #0 are not evaluated correctly") bugnumber="llvm.org/pr26265: args in frames other than #0 are not evaluated correctly")
def do_conditional_break(self): def do_conditional_break(self):
"""Exercise some thread and frame APIs to break if c() is called by a().""" """Exercise some thread and frame APIs to break if c() is called by a()."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
breakpoint = target.BreakpointCreateByName("c", exe) breakpoint = target.BreakpointCreateByName("c", exe)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
# Now launch the process, and do not stop at entry point. # Now launch the process, and do not stop at entry point.
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/list/loop/TestDataFormatterLibcxxListLoop.py

Show All 18 Linesclass LibcxxListDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@add_test_categories(["libc++"]) @add_test_categories(["libc++"])
@expectedFailureAndroid(bugnumber="llvm.org/pr32592") @expectedFailureAndroid(bugnumber="llvm.org/pr32592")
@skipIfDarwin # rdar://25499635 @skipIfDarwin # rdar://25499635
def test_with_run_command(self): def test_with_run_command(self):
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target and target.IsValid(), "Target is valid") self.assertTrue(target and target.IsValid(), "Target is valid")
file_spec = lldb.SBFileSpec("main.cpp", False) file_spec = lldb.SBFileSpec("main.cpp", False)
breakpoint1 = target.BreakpointCreateBySourceRegex( breakpoint1 = target.BreakpointCreateBySourceRegex(
'// Set break point at this line.', file_spec) '// Set break point at this line.', file_spec)
self.assertTrue(breakpoint1 and breakpoint1.IsValid()) self.assertTrue(breakpoint1 and breakpoint1.IsValid())
breakpoint2 = target.BreakpointCreateBySourceRegex( breakpoint2 = target.BreakpointCreateBySourceRegex(
Show All 38 Lines

packages/Python/lldbsuite/test/functionalities/dead-strip/TestDeadStrip.py

Show All 22 Lines @expectedFailureAll(
oslist=["linux"], oslist=["linux"],
debug_info="gmodules", debug_info="gmodules",
bugnumber="llvm.org/pr27865") bugnumber="llvm.org/pr27865")
# The -dead_strip linker option isn't supported on FreeBSD versions of ld. # The -dead_strip linker option isn't supported on FreeBSD versions of ld.
@skipIfFreeBSD @skipIfFreeBSD
def test(self): def test(self):
"""Test breakpoint works correctly with dead-code stripping.""" """Test breakpoint works correctly with dead-code stripping."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break by function name f1 (live code). # Break by function name f1 (live code).
lldbutil.run_break_set_by_symbol( lldbutil.run_break_set_by_symbol(
self, "f1", num_expected_locations=1, module_name="a.out") self, "f1", num_expected_locations=1, module_name="a.out")
# Break by function name f2 (dead code). # Break by function name f2 (dead code).
lldbutil.run_break_set_by_symbol( lldbutil.run_break_set_by_symbol(
Show All 29 Lines

packages/Python/lldbsuite/test/functionalities/disassembly/TestDisassembleBreakpoint.py

Show All 16 Linesclass DisassemblyTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="function names print fully demangled instead of name-only") bugnumber="function names print fully demangled instead of name-only")
def test(self): def test(self):
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.expect("file " + exe, self.expect("file " + exe,
patterns=["Current executable set to .*a.out.*"]) patterns=["Current executable set to .*a.out.*"])
match_object = lldbutil.run_break_set_command(self, "br s -n sum") match_object = lldbutil.run_break_set_command(self, "br s -n sum")
lldbutil.check_breakpoint_result( lldbutil.check_breakpoint_result(
self, self,
match_object, match_object,
symbol_name='sum', symbol_name='sum',
Show All 39 Lines

packages/Python/lldbsuite/test/functionalities/disassembly/TestFrameDisassemble.py

Show All 24 Lines def test_frame_disassemble(self):
self.frame_disassemble_test() self.frame_disassemble_test()
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
def frame_disassemble_test(self): def frame_disassemble_test(self):
"""Sample test to ensure SBFrame::Disassemble produces SOME output""" """Sample test to ensure SBFrame::Disassemble produces SOME output"""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Now create a breakpoint in main.c at the source matching # Now create a breakpoint in main.c at the source matching
# "Set a breakpoint here" # "Set a breakpoint here"
breakpoint = target.BreakpointCreateBySourceRegex( breakpoint = target.BreakpointCreateBySourceRegex(
Show All 27 Lines

packages/Python/lldbsuite/test/functionalities/dynamic_value_child_count/TestDynamicValueChildCount.py

Show All 33 Lines def setUp(self):
'pass-to-base.cpp', '// Break here and check b has 0 children again') 'pass-to-base.cpp', '// Break here and check b has 0 children again')
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24663") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24663")
def test_get_dynamic_vals(self): def test_get_dynamic_vals(self):
"""Test fetching C++ dynamic values from pointers & references.""" """Test fetching C++ dynamic values from pointers & references."""
"""Get argument vals for the call stack when stopped on a breakpoint.""" """Get argument vals for the call stack when stopped on a breakpoint."""
self.build(dictionary=self.getBuildFlags()) self.build(dictionary=self.getBuildFlags())
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# Create a target from the debugger. # Create a target from the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Set up our breakpoints: # Set up our breakpoints:
Show All 34 Lines

packages/Python/lldbsuite/test/functionalities/embedded_interpreter/TestConvenienceVariables.py

Show All 23 Linesclass ConvenienceVariablesCase(TestBase):
@skipIfRemote @skipIfRemote
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr22274: need a pexpect replacement for windows") bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
def test_with_run_commands(self): def test_with_run_commands(self):
"""Test convenience variables lldb.debugger, lldb.target, lldb.process, lldb.thread, and lldb.frame.""" """Test convenience variables lldb.debugger, lldb.target, lldb.process, lldb.thread, and lldb.frame."""
self.build() self.build()
import pexpect import pexpect
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
prompt = "(lldb) " prompt = "(lldb) "
python_prompt = ">>> " python_prompt = ">>> "
# So that the child gets torn down after the test. # So that the child gets torn down after the test.
self.child = pexpect.spawn( self.child = pexpect.spawn(
'%s %s %s' % '%s %s %s' %
(lldbtest_config.lldbExec, self.lldbOption, exe)) (lldbtest_config.lldbExec, self.lldbOption, exe))
child = self.child child = self.child
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/exec/TestExec.py

Show All 38 Linesclass ExecTestCase(TestBase):
@expectedFailureAll(oslist=['macosx'], bugnumber="rdar://36134350") # when building with cmake on green gragon or on ci.swift.org, this test fails. @expectedFailureAll(oslist=['macosx'], bugnumber="rdar://36134350") # when building with cmake on green gragon or on ci.swift.org, this test fails.
@expectedFailureAll(archs=['i386'], bugnumber="rdar://28656532") @expectedFailureAll(archs=['i386'], bugnumber="rdar://28656532")
@expectedFailureAll(oslist=["ios", "tvos", "watchos", "bridgeos"], bugnumber="rdar://problem/34559552") # this exec test has problems on ios systems @expectedFailureAll(oslist=["ios", "tvos", "watchos", "bridgeos"], bugnumber="rdar://problem/34559552") # this exec test has problems on ios systems
def test_skipping_exec (self): def test_skipping_exec (self):
self.do_test(False) self.do_test(False)
def do_test(self, skip_exec): def do_test(self, skip_exec):
if self.getArchitecture() == 'x86_64': if self.getArchitecture() == 'x86_64':
source = os.path.join(os.getcwd(), "main.cpp") source = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "main.cpp")
o_file = os.path.join(os.getcwd(), "main.o") o_file = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "main.o")
execute_command( execute_command(
"'%s' -g -O0 -arch i386 -arch x86_64 '%s' -c -o '%s'" % "'%s' -g -O0 -arch i386 -arch x86_64 '%s' -c -o '%s'" %
(os.environ["CC"], source, o_file)) (os.environ["CC"], source, o_file))
execute_command( execute_command(
"'%s' -g -O0 -arch i386 -arch x86_64 '%s'" % "'%s' -g -O0 -arch i386 -arch x86_64 '%s'" %
(os.environ["CC"], o_file)) (os.environ["CC"], o_file))
if self.debug_info != "dsym": if self.debug_info != "dsym":
dsym_path = os.path.join(os.getcwd(), "a.out.dSYM") dsym_path = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out.dSYM")
execute_command("rm -rf '%s'" % (dsym_path)) execute_command("rm -rf '%s'" % (dsym_path))
else: else:
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# Create the target # Create the target
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
# Create any breakpoints we need # Create any breakpoints we need
breakpoint = target.BreakpointCreateBySourceRegex( breakpoint = target.BreakpointCreateBySourceRegex(
'Set breakpoint 1 here', lldb.SBFileSpec("main.cpp", False)) 'Set breakpoint 1 here', lldb.SBFileSpec("main.cpp", False))
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/expr-doesnt-deadlock/TestExprDoesntBlock.py

Show All 20 Linesclass ExprDoesntDeadlockTestCase(TestBase):
@expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr17946') @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr17946')
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="Windows doesn't have pthreads, test needs to be ported") bugnumber="Windows doesn't have pthreads, test needs to be ported")
@add_test_categories(["basic_process"]) @add_test_categories(["basic_process"])
def test_with_run_command(self): def test_with_run_command(self):
"""Test that expr will time out and allow other threads to run if it blocks.""" """Test that expr will time out and allow other threads to run if it blocks."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Now create a breakpoint at source line before call_me_to_get_lock # Now create a breakpoint at source line before call_me_to_get_lock
# gets called. # gets called.
Show All 26 Lines

packages/Python/lldbsuite/test/functionalities/fat_archives/TestFatArchives.py

Show All 28 Lines def test_breakpoint_resolution_dwarf(self):
"This test requires x86_64 as the architecture for the inferior") "This test requires x86_64 as the architecture for the inferior")
def main(self): def main(self):
'''This test compiles a quick example by making a fat file (universal) full of '''This test compiles a quick example by making a fat file (universal) full of
skinny .o files and makes sure we can use them to resolve breakpoints when doing skinny .o files and makes sure we can use them to resolve breakpoints when doing
DWARF in .o file debugging. The only thing this test needs to do is to compile and DWARF in .o file debugging. The only thing this test needs to do is to compile and
set a breakpoint in the target and verify any breakpoint locations have valid debug set a breakpoint in the target and verify any breakpoint locations have valid debug
info for the function, and source file and line.''' info for the function, and source file and line.'''
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# Create the target # Create the target
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
# Create a breakpoint by name # Create a breakpoint by name
breakpoint = target.BreakpointCreateByName('foo', exe) breakpoint = target.BreakpointCreateByName('foo', exe)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
Show All 16 Lines

packages/Python/lldbsuite/test/functionalities/frame-diagnose/array/TestArray.py

Show All 13 Lines
class TestArray(TestBase): class TestArray(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipUnlessDarwin @skipUnlessDarwin
@skipIfDarwinEmbedded # <rdar://problem/33842388> frame diagnose doesn't work for armv7 or arm64 @skipIfDarwinEmbedded # <rdar://problem/33842388> frame diagnose doesn't work for armv7 or arm64
def test_array(self): def test_array(self):
TestBase.setUp(self) TestBase.setUp(self)
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.expect("thread list", "Thread should be stopped", self.expect("thread list", "Thread should be stopped",
substrs=['stopped']) substrs=['stopped'])
self.expect( self.expect(
"frame diagnose", "frame diagnose",
"Crash diagnosis was accurate", "Crash diagnosis was accurate",
substrs=["a[10]"]) substrs=["a[10]"])

packages/Python/lldbsuite/test/functionalities/frame-diagnose/bad-reference/TestBadReference.py

Show All 13 Lines
class TestBadReference(TestBase): class TestBadReference(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipUnlessDarwin @skipUnlessDarwin
@skipIfDarwinEmbedded # <rdar://problem/33842388> frame diagnose doesn't work for armv7 or arm64 @skipIfDarwinEmbedded # <rdar://problem/33842388> frame diagnose doesn't work for armv7 or arm64
def test_bad_reference(self): def test_bad_reference(self):
TestBase.setUp(self) TestBase.setUp(self)
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.expect("thread list", "Thread should be stopped", self.expect("thread list", "Thread should be stopped",
substrs=['stopped']) substrs=['stopped'])
self.expect("frame diagnose", "Crash diagnosis was accurate", "f->b") self.expect("frame diagnose", "Crash diagnosis was accurate", "f->b")

packages/Python/lldbsuite/test/functionalities/frame-diagnose/complicated-expression/TestComplicatedExpression.py

Show All 13 Lines
class TestDiagnoseDereferenceArgument(TestBase): class TestDiagnoseDereferenceArgument(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipUnlessDarwin @skipUnlessDarwin
@skipIfDarwinEmbedded # <rdar://problem/33842388> frame diagnose doesn't work for armv7 or arm64 @skipIfDarwinEmbedded # <rdar://problem/33842388> frame diagnose doesn't work for armv7 or arm64
def test_diagnose_dereference_argument(self): def test_diagnose_dereference_argument(self):
TestBase.setUp(self) TestBase.setUp(self)
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.expect("thread list", "Thread should be stopped", self.expect("thread list", "Thread should be stopped",
substrs=['stopped']) substrs=['stopped'])
self.expect( self.expect(
"frame diagnose", "frame diagnose",
"Crash diagnosis was accurate", "Crash diagnosis was accurate",
"f->b->d") "f->b->d")

packages/Python/lldbsuite/test/functionalities/frame-diagnose/dereference-argument/TestDiagnoseDereferenceArgument.py

Show All 13 Lines
class TestDiagnoseDereferenceArgument(TestBase): class TestDiagnoseDereferenceArgument(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipUnlessDarwin @skipUnlessDarwin
@skipIfDarwinEmbedded # <rdar://problem/33842388> frame diagnose doesn't work for armv7 or arm64 @skipIfDarwinEmbedded # <rdar://problem/33842388> frame diagnose doesn't work for armv7 or arm64
def test_diagnose_dereference_argument(self): def test_diagnose_dereference_argument(self):
TestBase.setUp(self) TestBase.setUp(self)
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.expect("thread list", "Thread should be stopped", self.expect("thread list", "Thread should be stopped",
substrs=['stopped']) substrs=['stopped'])
self.expect( self.expect(
"frame diagnose", "frame diagnose",
"Crash diagnosis was accurate", "Crash diagnosis was accurate",
"f->b->d") "f->b->d")

packages/Python/lldbsuite/test/functionalities/frame-diagnose/dereference-function-return/TestDiagnoseDereferenceFunctionReturn.py

Show All 14 Linesclass TestDiagnoseDereferenceFunctionReturn(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipUnlessDarwin @skipUnlessDarwin
@skipIfDarwinEmbedded # <rdar://problem/33842388> frame diagnose doesn't work for armv7 or arm64 @skipIfDarwinEmbedded # <rdar://problem/33842388> frame diagnose doesn't work for armv7 or arm64
@expectedFailureAll(oslist=['macosx'], archs=['i386'], bugnumber="rdar://28656408") @expectedFailureAll(oslist=['macosx'], archs=['i386'], bugnumber="rdar://28656408")
def test_diagnose_dereference_function_return(self): def test_diagnose_dereference_function_return(self):
TestBase.setUp(self) TestBase.setUp(self)
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.expect("thread list", "Thread should be stopped", self.expect("thread list", "Thread should be stopped",
substrs=['stopped']) substrs=['stopped'])
self.expect( self.expect(
"frame diagnose", "frame diagnose",
"Crash diagnosis was accurate", "Crash diagnosis was accurate",
substrs=[ substrs=[
"GetAFoo", "GetAFoo",
"->b"]) "->b"])

packages/Python/lldbsuite/test/functionalities/frame-diagnose/dereference-this/TestDiagnoseDereferenceThis.py

Show All 13 Lines
class TestDiagnoseDereferenceThis(TestBase): class TestDiagnoseDereferenceThis(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipUnlessDarwin @skipUnlessDarwin
@skipIfDarwinEmbedded # <rdar://problem/33842388> frame diagnose doesn't work for armv7 or arm64 @skipIfDarwinEmbedded # <rdar://problem/33842388> frame diagnose doesn't work for armv7 or arm64
def test_diagnose_dereference_this(self): def test_diagnose_dereference_this(self):
TestBase.setUp(self) TestBase.setUp(self)
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.expect("thread list", "Thread should be stopped", self.expect("thread list", "Thread should be stopped",
substrs=['stopped']) substrs=['stopped'])
self.expect( self.expect(
"frame diagnose", "frame diagnose",
"Crash diagnosis was accurate", "Crash diagnosis was accurate",
"this->a") "this->a")

packages/Python/lldbsuite/test/functionalities/frame-diagnose/inheritance/TestDiagnoseInheritance.py

Show All 13 Lines
class TestDiagnoseInheritance(TestBase): class TestDiagnoseInheritance(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipUnlessDarwin @skipUnlessDarwin
@skipIfDarwinEmbedded # <rdar://problem/33842388> frame diagnose doesn't work for armv7 or arm64 @skipIfDarwinEmbedded # <rdar://problem/33842388> frame diagnose doesn't work for armv7 or arm64
def test_diagnose_inheritance(self): def test_diagnose_inheritance(self):
TestBase.setUp(self) TestBase.setUp(self)
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.expect("thread list", "Thread should be stopped", self.expect("thread list", "Thread should be stopped",
substrs=['stopped']) substrs=['stopped'])
self.expect("frame diagnose", "Crash diagnosis was accurate", "d") self.expect("frame diagnose", "Crash diagnosis was accurate", "d")

packages/Python/lldbsuite/test/functionalities/frame-diagnose/local-variable/TestLocalVariable.py

Show All 13 Lines
class TestLocalVariable(TestBase): class TestLocalVariable(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipUnlessDarwin @skipUnlessDarwin
@skipIfDarwinEmbedded # <rdar://problem/33842388> frame diagnose doesn't work for armv7 or arm64 @skipIfDarwinEmbedded # <rdar://problem/33842388> frame diagnose doesn't work for armv7 or arm64
def test_local_variable(self): def test_local_variable(self):
TestBase.setUp(self) TestBase.setUp(self)
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.expect("thread list", "Thread should be stopped", self.expect("thread list", "Thread should be stopped",
substrs=['stopped']) substrs=['stopped'])
self.expect("frame diagnose", "Crash diagnosis was accurate", "myInt") self.expect("frame diagnose", "Crash diagnosis was accurate", "myInt")

packages/Python/lldbsuite/test/functionalities/frame-diagnose/virtual-method-call/TestDiagnoseDereferenceVirtualMethodCall.py

Show All 13 Lines
class TestDiagnoseVirtualMethodCall(TestBase): class TestDiagnoseVirtualMethodCall(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipUnlessDarwin @skipUnlessDarwin
@skipIfDarwinEmbedded # <rdar://problem/33842388> frame diagnose doesn't work for armv7 or arm64 @skipIfDarwinEmbedded # <rdar://problem/33842388> frame diagnose doesn't work for armv7 or arm64
def test_diagnose_virtual_method_call(self): def test_diagnose_virtual_method_call(self):
TestBase.setUp(self) TestBase.setUp(self)
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.expect("thread list", "Thread should be stopped", self.expect("thread list", "Thread should be stopped",
substrs=['stopped']) substrs=['stopped'])
self.expect("frame diagnose", "Crash diagnosis was accurate", "foo") self.expect("frame diagnose", "Crash diagnosis was accurate", "foo")

packages/Python/lldbsuite/test/functionalities/frame-language/TestGuessLanguage.py

Show All 33 Linesclass TestFrameGuessLanguage(TestBase):
def check_language(self, thread, frame_no, test_lang): def check_language(self, thread, frame_no, test_lang):
frame = thread.frames[frame_no] frame = thread.frames[frame_no]
self.assertTrue(frame.IsValid(), "Frame %d was not valid."%(frame_no)) self.assertTrue(frame.IsValid(), "Frame %d was not valid."%(frame_no))
lang = frame.GuessLanguage() lang = frame.GuessLanguage()
self.assertEqual(lang, test_lang) self.assertEqual(lang, test_lang)
def do_test(self): def do_test(self):
"""Test GuessLanguage for C & C++.""" """Test GuessLanguage for C & C++."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Now create a breakpoint in main.c at the source matching # Now create a breakpoint in main.c at the source matching
# "Set a breakpoint here" # "Set a breakpoint here"
breakpoint = target.BreakpointCreateBySourceRegex( breakpoint = target.BreakpointCreateBySourceRegex(
Show All 37 Lines

packages/Python/lldbsuite/test/functionalities/frame_var/TestFrameVar.py

Show All 25 Lines def test_frame_var(self):
self.build() self.build()
self.do_test() self.do_test()
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
def do_test(self): def do_test(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Now create a breakpoint in main.c at the source matching # Now create a breakpoint in main.c at the source matching
# "Set a breakpoint here" # "Set a breakpoint here"
breakpoint = target.BreakpointCreateBySourceRegex( breakpoint = target.BreakpointCreateBySourceRegex(
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/inferior-assert/TestInferiorAssert.py

Show First 20 Lines • Show All 119 Lines • ▼ Show 20 Linesclass AssertingInferiorTestCase(TestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number of the call to assert. # Find the line number of the call to assert.
self.line = line_number('main.c', '// Assert here.') self.line = line_number('main.c', '// Assert here.')
def inferior_asserting(self): def inferior_asserting(self):
"""Inferior asserts upon launching; lldb should catch the event and stop.""" """Inferior asserts upon launching; lldb should catch the event and stop."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
stop_reason = self.check_stop_reason() stop_reason = self.check_stop_reason()
# And it should report a backtrace that includes the assert site. # And it should report a backtrace that includes the assert site.
self.expect("thread backtrace all", self.expect("thread backtrace all",
substrs=[stop_reason, 'main', 'argc', 'argv']) substrs=[stop_reason, 'main', 'argc', 'argv'])
# And it should report the correct line number. # And it should report the correct line number.
self.expect("thread backtrace all", self.expect("thread backtrace all",
substrs=[stop_reason, substrs=[stop_reason,
'main.c:%d' % self.line]) 'main.c:%d' % self.line])
def inferior_asserting_python(self): def inferior_asserting_python(self):
"""Inferior asserts upon launching; lldb should catch the event and stop.""" """Inferior asserts upon launching; lldb should catch the event and stop."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Now launch the process, and do not stop at entry point. # Now launch the process, and do not stop at entry point.
# Both argv and envp are null. # Both argv and envp are null.
process = target.LaunchSimple( process = target.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
if process.GetState() != lldb.eStateStopped: if process.GetState() != lldb.eStateStopped:
self.fail("Process should be in the 'stopped' state, " self.fail("Process should be in the 'stopped' state, "
"instead the actual state is: '%s'" % "instead the actual state is: '%s'" %
lldbutil.state_type_to_str(process.GetState())) lldbutil.state_type_to_str(process.GetState()))
thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonSignal) thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonSignal)
if not thread: if not thread:
self.fail("Fail to stop the thread upon assert") self.fail("Fail to stop the thread upon assert")
if self.TraceOn(): if self.TraceOn():
lldbutil.print_stacktrace(thread) lldbutil.print_stacktrace(thread)
def inferior_asserting_registers(self): def inferior_asserting_registers(self):
"""Test that lldb can read registers after asserting.""" """Test that lldb can read registers after asserting."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.check_stop_reason() self.check_stop_reason()
# lldb should be able to read from registers from the inferior after # lldb should be able to read from registers from the inferior after
# asserting. # asserting.
lldbplatformutil.check_first_register_readable(self) lldbplatformutil.check_first_register_readable(self)
def inferior_asserting_disassemble(self): def inferior_asserting_disassemble(self):
"""Test that lldb can disassemble frames after asserting.""" """Test that lldb can disassemble frames after asserting."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Launch the process, and do not stop at the entry point. # Launch the process, and do not stop at the entry point.
target.LaunchSimple(None, None, self.get_process_working_directory()) target.LaunchSimple(None, None, self.get_process_working_directory())
self.check_stop_reason() self.check_stop_reason()
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Lines def check_expr_in_main(self, thread):
self.expect("p hello_world", substrs=['Hello']) self.expect("p hello_world", substrs=['Hello'])
self.expect("p argv[0]", substrs=['a.out']) self.expect("p argv[0]", substrs=['a.out'])
self.expect("p null_ptr", substrs=['= 0x0']) self.expect("p null_ptr", substrs=['= 0x0'])
return True return True
return False return False
def inferior_asserting_expr(self): def inferior_asserting_expr(self):
"""Test that the lldb expression interpreter can read symbols after asserting.""" """Test that the lldb expression interpreter can read symbols after asserting."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Launch the process, and do not stop at the entry point. # Launch the process, and do not stop at the entry point.
target.LaunchSimple(None, None, self.get_process_working_directory()) target.LaunchSimple(None, None, self.get_process_working_directory())
self.check_stop_reason() self.check_stop_reason()
process = target.GetProcess() process = target.GetProcess()
self.assertTrue(process.IsValid(), "current process is valid") self.assertTrue(process.IsValid(), "current process is valid")
thread = process.GetThreadAtIndex(0) thread = process.GetThreadAtIndex(0)
self.assertTrue(thread.IsValid(), "current thread is valid") self.assertTrue(thread.IsValid(), "current thread is valid")
# The lldb expression interpreter should be able to read from addresses # The lldb expression interpreter should be able to read from addresses
# of the inferior after a call to assert(). # of the inferior after a call to assert().
self.assertTrue( self.assertTrue(
self.check_expr_in_main(thread), self.check_expr_in_main(thread),
"cannot find 'main' in the backtrace") "cannot find 'main' in the backtrace")
def inferior_asserting_step(self): def inferior_asserting_step(self):
"""Test that lldb functions correctly after stepping through a call to assert().""" """Test that lldb functions correctly after stepping through a call to assert()."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Launch the process, and do not stop at the entry point. # Launch the process, and do not stop at the entry point.
self.set_breakpoint(self.line) self.set_breakpoint(self.line)
target.LaunchSimple(None, None, self.get_process_working_directory()) target.LaunchSimple(None, None, self.get_process_working_directory())
Show All 31 Lines

packages/Python/lldbsuite/test/functionalities/inferior-changed/TestInferiorChanged.py

Show All 35 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number of the crash. # Find the line number of the crash.
self.line1 = line_number('main.c', '// Crash here.') self.line1 = line_number('main.c', '// Crash here.')
self.line2 = line_number('main2.c', '// Not crash here.') self.line2 = line_number('main2.c', '// Not crash here.')
def inferior_crashing(self): def inferior_crashing(self):
"""Inferior crashes upon launching; lldb should catch the event and stop.""" """Inferior crashes upon launching; lldb should catch the event and stop."""
self.exe = os.path.join(os.getcwd(), "a.out") self.exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + self.exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
# We should have one crashing thread # We should have one crashing thread
self.assertEqual( self.assertEqual(
len(lldbutil.get_crashed_threads(self, self.dbg.GetSelectedTarget().GetProcess())), len(lldbutil.get_crashed_threads(self, self.dbg.GetSelectedTarget().GetProcess())),
1, 1,
Show All 32 Lines

packages/Python/lldbsuite/test/functionalities/inferior-crashing/TestInferiorCrashing.py

Show First 20 Lines • Show All 94 Lines • ▼ Show 20 Linesclass CrashingInferiorTestCase(TestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number of the crash. # Find the line number of the crash.
self.line = line_number('main.c', '// Crash here.') self.line = line_number('main.c', '// Crash here.')
def inferior_crashing(self): def inferior_crashing(self):
"""Inferior crashes upon launching; lldb should catch the event and stop.""" """Inferior crashes upon launching; lldb should catch the event and stop."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
# The exact stop reason depends on the platform # The exact stop reason depends on the platform
if self.platformIsDarwin(): if self.platformIsDarwin():
stop_reason = 'stop reason = EXC_BAD_ACCESS' stop_reason = 'stop reason = EXC_BAD_ACCESS'
elif self.getPlatform() == "linux" or self.getPlatform() == "freebsd": elif self.getPlatform() == "linux" or self.getPlatform() == "freebsd":
stop_reason = 'stop reason = signal SIGSEGV' stop_reason = 'stop reason = signal SIGSEGV'
else: else:
stop_reason = 'stop reason = invalid address' stop_reason = 'stop reason = invalid address'
self.expect("thread list", STOPPED_DUE_TO_EXC_BAD_ACCESS, self.expect("thread list", STOPPED_DUE_TO_EXC_BAD_ACCESS,
substrs=['stopped', substrs=['stopped',
stop_reason]) stop_reason])
# And it should report the correct line number. # And it should report the correct line number.
self.expect("thread backtrace all", self.expect("thread backtrace all",
substrs=[stop_reason, substrs=[stop_reason,
'main.c:%d' % self.line]) 'main.c:%d' % self.line])
def inferior_crashing_python(self): def inferior_crashing_python(self):
"""Inferior crashes upon launching; lldb should catch the event and stop.""" """Inferior crashes upon launching; lldb should catch the event and stop."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Now launch the process, and do not stop at entry point. # Now launch the process, and do not stop at entry point.
# Both argv and envp are null. # Both argv and envp are null.
process = target.LaunchSimple( process = target.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
Show All 9 Lines def inferior_crashing_python(self):
1, 1,
"Failed to stop the thread upon bad access exception") "Failed to stop the thread upon bad access exception")
if self.TraceOn(): if self.TraceOn():
lldbutil.print_stacktrace(threads[0]) lldbutil.print_stacktrace(threads[0])
def inferior_crashing_registers(self): def inferior_crashing_registers(self):
"""Test that lldb can read registers after crashing.""" """Test that lldb can read registers after crashing."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.check_stop_reason() self.check_stop_reason()
# lldb should be able to read from registers from the inferior after # lldb should be able to read from registers from the inferior after
# crashing. # crashing.
lldbplatformutil.check_first_register_readable(self) lldbplatformutil.check_first_register_readable(self)
def inferior_crashing_expr(self): def inferior_crashing_expr(self):
"""Test that the lldb expression interpreter can read symbols after crashing.""" """Test that the lldb expression interpreter can read symbols after crashing."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.check_stop_reason() self.check_stop_reason()
# The lldb expression interpreter should be able to read from addresses # The lldb expression interpreter should be able to read from addresses
# of the inferior after a crash. # of the inferior after a crash.
self.expect("p argc", self.expect("p argc",
startstr='(int) $0 = 1') startstr='(int) $0 = 1')
self.expect("p hello_world", self.expect("p hello_world",
substrs=['Hello']) substrs=['Hello'])
def inferior_crashing_step(self): def inferior_crashing_step(self):
"""Test that lldb functions correctly after stepping through a crash.""" """Test that lldb functions correctly after stepping through a crash."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.set_breakpoint(self.line) self.set_breakpoint(self.line)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs=['main.c:%d' % self.line, substrs=['main.c:%d' % self.line,
'stop reason = breakpoint']) 'stop reason = breakpoint'])
Show All 13 Lines def inferior_crashing_step(self):
lldbplatformutil.check_first_register_readable(self) lldbplatformutil.check_first_register_readable(self)
# And it should report the correct line number. # And it should report the correct line number.
self.expect("thread backtrace all", self.expect("thread backtrace all",
substrs=['main.c:%d' % self.line]) substrs=['main.c:%d' % self.line])
def inferior_crashing_step_after_break(self): def inferior_crashing_step_after_break(self):
"""Test that lldb behaves correctly when stepping after a crash.""" """Test that lldb behaves correctly when stepping after a crash."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.check_stop_reason() self.check_stop_reason()
expected_state = 'exited' # Provide the exit code. expected_state = 'exited' # Provide the exit code.
if self.platformIsDarwin(): if self.platformIsDarwin():
# TODO: Determine why 'next' and 'continue' have no effect after a # TODO: Determine why 'next' and 'continue' have no effect after a
# crash. # crash.
expected_state = 'stopped' expected_state = 'stopped'
self.expect("next", self.expect("next",
substrs=['Process', expected_state]) substrs=['Process', expected_state])
if expected_state == 'exited': if expected_state == 'exited':
self.expect( self.expect(
"thread list", "thread list",
error=True, error=True,
substrs=['Process must be launched']) substrs=['Process must be launched'])
else: else:
self.check_stop_reason() self.check_stop_reason()
def inferior_crashing_expr_step_expr(self): def inferior_crashing_expr_step_expr(self):
"""Test that lldb expressions work before and after stepping after a crash.""" """Test that lldb expressions work before and after stepping after a crash."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.check_stop_reason() self.check_stop_reason()
# The lldb expression interpreter should be able to read from addresses # The lldb expression interpreter should be able to read from addresses
# of the inferior after a crash. # of the inferior after a crash.
self.expect("p argv[0]", self.expect("p argv[0]",
Show All 9 Lines

packages/Python/lldbsuite/test/functionalities/inferior-crashing/recursive-inferior/TestRecursiveInferior.py

Show First 20 Lines • Show All 77 Lines • ▼ Show 20 Linesclass CrashingRecursiveInferiorTestCase(TestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number of the crash. # Find the line number of the crash.
self.line = line_number('main.c', '// Crash here.') self.line = line_number('main.c', '// Crash here.')
def recursive_inferior_crashing(self): def recursive_inferior_crashing(self):
"""Inferior crashes upon launching; lldb should catch the event and stop.""" """Inferior crashes upon launching; lldb should catch the event and stop."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
# The exact stop reason depends on the platform # The exact stop reason depends on the platform
if self.platformIsDarwin(): if self.platformIsDarwin():
stop_reason = 'stop reason = EXC_BAD_ACCESS' stop_reason = 'stop reason = EXC_BAD_ACCESS'
elif self.getPlatform() == "linux" or self.getPlatform() == "freebsd": elif self.getPlatform() == "linux" or self.getPlatform() == "freebsd":
Show All 17 Lines def recursive_inferior_crashing(self):
# And it should report the correct line number. # And it should report the correct line number.
self.expect("thread backtrace all", self.expect("thread backtrace all",
substrs=[stop_reason, substrs=[stop_reason,
'main.c:%d' % self.line]) 'main.c:%d' % self.line])
def recursive_inferior_crashing_python(self): def recursive_inferior_crashing_python(self):
"""Inferior crashes upon launching; lldb should catch the event and stop.""" """Inferior crashes upon launching; lldb should catch the event and stop."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Now launch the process, and do not stop at entry point. # Now launch the process, and do not stop at entry point.
# Both argv and envp are null. # Both argv and envp are null.
process = target.LaunchSimple( process = target.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
Show All 9 Lines def recursive_inferior_crashing_python(self):
1, 1,
"Failed to stop the thread upon bad access exception") "Failed to stop the thread upon bad access exception")
if self.TraceOn(): if self.TraceOn():
lldbutil.print_stacktrace(threads[0]) lldbutil.print_stacktrace(threads[0])
def recursive_inferior_crashing_registers(self): def recursive_inferior_crashing_registers(self):
"""Test that lldb can read registers after crashing.""" """Test that lldb can read registers after crashing."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.check_stop_reason() self.check_stop_reason()
# lldb should be able to read from registers from the inferior after # lldb should be able to read from registers from the inferior after
# crashing. # crashing.
lldbplatformutil.check_first_register_readable(self) lldbplatformutil.check_first_register_readable(self)
def recursive_inferior_crashing_expr(self): def recursive_inferior_crashing_expr(self):
"""Test that the lldb expression interpreter can read symbols after crashing.""" """Test that the lldb expression interpreter can read symbols after crashing."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.check_stop_reason() self.check_stop_reason()
# The lldb expression interpreter should be able to read from addresses # The lldb expression interpreter should be able to read from addresses
# of the inferior after a crash. # of the inferior after a crash.
self.expect("p i", self.expect("p i",
startstr='(int) $0 =') startstr='(int) $0 =')
def recursive_inferior_crashing_step(self): def recursive_inferior_crashing_step(self):
"""Test that lldb functions correctly after stepping through a crash.""" """Test that lldb functions correctly after stepping through a crash."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.set_breakpoint(self.line) self.set_breakpoint(self.line)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs=['main.c:%d' % self.line, substrs=['main.c:%d' % self.line,
'stop reason = breakpoint']) 'stop reason = breakpoint'])
Show All 11 Lines def recursive_inferior_crashing_step(self):
lldbplatformutil.check_first_register_readable(self) lldbplatformutil.check_first_register_readable(self)
# And it should report the correct line number. # And it should report the correct line number.
self.expect("thread backtrace all", self.expect("thread backtrace all",
substrs=['main.c:%d' % self.line]) substrs=['main.c:%d' % self.line])
def recursive_inferior_crashing_step_after_break(self): def recursive_inferior_crashing_step_after_break(self):
"""Test that lldb behaves correctly when stepping after a crash.""" """Test that lldb behaves correctly when stepping after a crash."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.check_stop_reason() self.check_stop_reason()
expected_state = 'exited' # Provide the exit code. expected_state = 'exited' # Provide the exit code.
if self.platformIsDarwin(): if self.platformIsDarwin():
# TODO: Determine why 'next' and 'continue' have no effect after a # TODO: Determine why 'next' and 'continue' have no effect after a
# crash. # crash.
expected_state = 'stopped' expected_state = 'stopped'
self.expect("next", self.expect("next",
substrs=['Process', expected_state]) substrs=['Process', expected_state])
if expected_state == 'exited': if expected_state == 'exited':
self.expect( self.expect(
"thread list", "thread list",
error=True, error=True,
substrs=['Process must be launched']) substrs=['Process must be launched'])
else: else:
self.check_stop_reason() self.check_stop_reason()
def recursive_inferior_crashing_expr_step_expr(self): def recursive_inferior_crashing_expr_step_expr(self):
"""Test that lldb expressions work before and after stepping after a crash.""" """Test that lldb expressions work before and after stepping after a crash."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.check_stop_reason() self.check_stop_reason()
# The lldb expression interpreter should be able to read from addresses # The lldb expression interpreter should be able to read from addresses
# of the inferior after a crash. # of the inferior after a crash.
self.expect("p null", self.expect("p null",
Show All 10 Lines

packages/Python/lldbsuite/test/functionalities/inline-stepping/TestInlineStepping.py

Show First 20 Lines • Show All 139 Lines • ▼ Show 20 Lines def run_step_sequence(self, step_sequence):
for step_pattern in step_sequence: for step_pattern in step_sequence:
step_stop_line = line_number(self.main_source, step_pattern[0]) step_stop_line = line_number(self.main_source, step_pattern[0])
target_line_entry.SetLine(step_stop_line) target_line_entry.SetLine(step_stop_line)
self.do_step(step_pattern[1], target_line_entry, test_stack_depth) self.do_step(step_pattern[1], target_line_entry, test_stack_depth)
def inline_stepping(self): def inline_stepping(self):
"""Use Python APIs to test stepping over and hitting breakpoints.""" """Use Python APIs to test stepping over and hitting breakpoints."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
break_1_in_main = target.BreakpointCreateBySourceRegex( break_1_in_main = target.BreakpointCreateBySourceRegex(
'// Stop here and step over to set up stepping over.', self.main_source_spec) '// Stop here and step over to set up stepping over.', self.main_source_spec)
self.assertTrue(break_1_in_main, VALID_BREAKPOINT) self.assertTrue(break_1_in_main, VALID_BREAKPOINT)
▲ Show 20 Lines • Show All 95 Lines • ▼ Show 20 Lines def inline_stepping(self):
["// In inline_ref_1.", "out"], ["// In inline_ref_1.", "out"],
["// At increment in inline_ref_1.", "over"], ["// At increment in inline_ref_1.", "over"],
["// In caller_ref_2.", "out"], ["// In caller_ref_2.", "out"],
["// At increment in caller_ref_2.", "over"]] ["// At increment in caller_ref_2.", "over"]]
self.run_step_sequence(step_sequence) self.run_step_sequence(step_sequence)
def inline_stepping_step_over(self): def inline_stepping_step_over(self):
"""Use Python APIs to test stepping over and hitting breakpoints.""" """Use Python APIs to test stepping over and hitting breakpoints."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
break_1_in_main = target.BreakpointCreateBySourceRegex( break_1_in_main = target.BreakpointCreateBySourceRegex(
'// At second call of caller_ref_1 in main.', self.main_source_spec) '// At second call of caller_ref_1 in main.', self.main_source_spec)
self.assertTrue(break_1_in_main, VALID_BREAKPOINT) self.assertTrue(break_1_in_main, VALID_BREAKPOINT)
Show All 14 Lines def inline_stepping_step_over(self):
step_sequence = [["// In caller_ref_1.", "into"], step_sequence = [["// In caller_ref_1.", "into"],
["// In caller_ref_2.", "into"], ["// In caller_ref_2.", "into"],
["// At increment in caller_ref_2.", "over"]] ["// At increment in caller_ref_2.", "over"]]
self.run_step_sequence(step_sequence) self.run_step_sequence(step_sequence)
def step_in_template(self): def step_in_template(self):
"""Use Python APIs to test stepping in to templated functions.""" """Use Python APIs to test stepping in to templated functions."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
break_1_in_main = target.BreakpointCreateBySourceRegex( break_1_in_main = target.BreakpointCreateBySourceRegex(
'// Call max_value template', self.main_source_spec) '// Call max_value template', self.main_source_spec)
self.assertTrue(break_1_in_main, VALID_BREAKPOINT) self.assertTrue(break_1_in_main, VALID_BREAKPOINT)
Show All 31 Lines

packages/Python/lldbsuite/test/functionalities/jitloader_gdb/TestJITLoaderGDB.py

Show All 16 Linesclass JITLoaderGDBTestCase(TestBase):
@skipTestIfFn( @skipTestIfFn(
lambda: "Skipped because the test crashes the test runner", lambda: "Skipped because the test crashes the test runner",
bugnumber="llvm.org/pr24702") bugnumber="llvm.org/pr24702")
@unittest2.expectedFailure("llvm.org/pr24702") @unittest2.expectedFailure("llvm.org/pr24702")
def test_bogus_values(self): def test_bogus_values(self):
"""Test that we handle inferior misusing the GDB JIT interface""" """Test that we handle inferior misusing the GDB JIT interface"""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# launch the process, do not stop at entry point. # launch the process, 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)
# The inferior will now pass bogus values over the interface. Make sure # The inferior will now pass bogus values over the interface. Make sure
# we don't crash. # we don't crash.
self.assertEqual(process.GetState(), lldb.eStateExited) self.assertEqual(process.GetState(), lldb.eStateExited)
self.assertEqual(process.GetExitStatus(), 0) self.assertEqual(process.GetExitStatus(), 0)

packages/Python/lldbsuite/test/functionalities/launch_with_shellexpand/TestLaunchWithShellExpand.py

Show All 19 Lines @expectedFailureAll(
oslist=[ oslist=[
"windows", "windows",
"linux", "linux",
"freebsd"], "freebsd"],
bugnumber="llvm.org/pr24778 llvm.org/pr22627") bugnumber="llvm.org/pr24778 llvm.org/pr22627")
@skipIfDarwinEmbedded # iOS etc don't launch the binary via a shell, so arg expansion won't happen @skipIfDarwinEmbedded # iOS etc don't launch the binary via a shell, so arg expansion won't happen
def test(self): def test(self):
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("target create %s" % exe) self.runCmd("target create %s" % exe)
# Create the target # Create the target
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
# Create any breakpoints we need # Create any breakpoints we need
breakpoint = target.BreakpointCreateBySourceRegex( breakpoint = target.BreakpointCreateBySourceRegex(
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/load_unload/TestLoadUnload.py

Show First 20 Lines • Show All 94 Lines • ▼ Show 20 Lines def test_modules_search_paths(self):
self.build() self.build()
if self.platformIsDarwin(): if self.platformIsDarwin():
dylibName = 'libloadunload_d.dylib' dylibName = 'libloadunload_d.dylib'
else: else:
dylibName = 'libloadunload_d.so' dylibName = 'libloadunload_d.so'
# The directory with the dynamic library we did not link to. # The directory with the dynamic library we did not link to.
new_dir = os.path.join(os.getcwd(), "hidden") new_dir = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "hidden")
old_dylib = os.path.join(os.getcwd(), dylibName) old_dylib = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, dylibName)
new_dylib = os.path.join(new_dir, dylibName) new_dylib = os.path.join(new_dir, dylibName)
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.expect("target modules list", self.expect("target modules list",
substrs=[old_dylib]) substrs=[old_dylib])
# self.expect("target modules list -t 3", # self.expect("target modules list -t 3",
# patterns = ["%s-[^-]*-[^-]*" % self.getArchitecture()]) # patterns = ["%s-[^-]*-[^-]*" % self.getArchitecture()])
# Add an image search path substitution pair. # Add an image search path substitution pair.
self.runCmd( self.runCmd(
Show All 34 Linesclass LoadUnloadTestCase(TestBase):
@skipIfWindows # Windows doesn't have dlopen and friends, dynamic libraries work differently @skipIfWindows # Windows doesn't have dlopen and friends, dynamic libraries work differently
def test_dyld_library_path(self): def test_dyld_library_path(self):
"""Test (DY)LD_LIBRARY_PATH after moving libd.dylib, which defines d_function, somewhere else.""" """Test (DY)LD_LIBRARY_PATH after moving libd.dylib, which defines d_function, somewhere else."""
# Invoke the default build rule. # Invoke the default build rule.
self.build() self.build()
self.copy_shlibs_to_remote(hidden_dir=True) self.copy_shlibs_to_remote(hidden_dir=True)
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Shut off ANSI color usage so we don't get ANSI escape sequences # Shut off ANSI color usage so we don't get ANSI escape sequences
# mixed in with stop locations. # mixed in with stop locations.
self.dbg.SetUseColor(False) self.dbg.SetUseColor(False)
if self.platformIsDarwin(): if self.platformIsDarwin():
dylibName = 'libloadunload_d.dylib' dylibName = 'libloadunload_d.dylib'
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Linesclass LoadUnloadTestCase(TestBase):
@skipIfWindows # Windows doesn't have dlopen and friends, dynamic libraries work differently @skipIfWindows # Windows doesn't have dlopen and friends, dynamic libraries work differently
def test_lldb_process_load_and_unload_commands(self): def test_lldb_process_load_and_unload_commands(self):
"""Test that lldb process load/unload command work correctly.""" """Test that lldb process load/unload command work correctly."""
# Invoke the default build rule. # Invoke the default build rule.
self.build() self.build()
self.copy_shlibs_to_remote() self.copy_shlibs_to_remote()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break at main.cpp before the call to dlopen(). # Break at main.cpp before the call to dlopen().
# Use lldb's process load command to load the dylib, instead. # Use lldb's process load command to load the dylib, instead.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Linesclass LoadUnloadTestCase(TestBase):
@skipIfFreeBSD # llvm.org/pr14424 - missing FreeBSD Makefiles/testcase support @skipIfFreeBSD # llvm.org/pr14424 - missing FreeBSD Makefiles/testcase support
def test_load_unload(self): def test_load_unload(self):
"""Test breakpoint by name works correctly with dlopen'ing.""" """Test breakpoint by name works correctly with dlopen'ing."""
# Invoke the default build rule. # Invoke the default build rule.
self.build() self.build()
self.copy_shlibs_to_remote() self.copy_shlibs_to_remote()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break by function name a_function (not yet loaded). # Break by function name a_function (not yet loaded).
lldbutil.run_break_set_by_symbol( lldbutil.run_break_set_by_symbol(
self, "a_function", num_expected_locations=0) self, "a_function", num_expected_locations=0)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 26 Linesclass LoadUnloadTestCase(TestBase):
@skipIfWindows # Windows doesn't have dlopen and friends, dynamic libraries work differently @skipIfWindows # Windows doesn't have dlopen and friends, dynamic libraries work differently
def test_step_over_load(self): def test_step_over_load(self):
"""Test stepping over code that loads a shared library works correctly.""" """Test stepping over code that loads a shared library works correctly."""
# Invoke the default build rule. # Invoke the default build rule.
self.build() self.build()
self.copy_shlibs_to_remote() self.copy_shlibs_to_remote()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break by function name a_function (not yet loaded). # Break by function name a_function (not yet loaded).
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 15 Linesclass LoadUnloadTestCase(TestBase):
@skipIfWindows # Windows doesn't have dlopen and friends, dynamic libraries work differently @skipIfWindows # Windows doesn't have dlopen and friends, dynamic libraries work differently
@unittest2.expectedFailure("llvm.org/pr25806") @unittest2.expectedFailure("llvm.org/pr25806")
def test_static_init_during_load(self): def test_static_init_during_load(self):
"""Test that we can set breakpoints correctly in static initializers""" """Test that we can set breakpoints correctly in static initializers"""
self.build() self.build()
self.copy_shlibs_to_remote() self.copy_shlibs_to_remote()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
a_init_bp_num = lldbutil.run_break_set_by_symbol( a_init_bp_num = lldbutil.run_break_set_by_symbol(
self, "a_init", num_expected_locations=0) self, "a_init", num_expected_locations=0)
b_init_bp_num = lldbutil.run_break_set_by_symbol( b_init_bp_num = lldbutil.run_break_set_by_symbol(
self, "b_init", num_expected_locations=0) self, "b_init", num_expected_locations=0)
d_init_bp_num = lldbutil.run_break_set_by_symbol( d_init_bp_num = lldbutil.run_break_set_by_symbol(
self, "d_init", num_expected_locations=1) self, "d_init", num_expected_locations=1)
Show All 27 Lines

packages/Python/lldbsuite/test/functionalities/longjmp/TestLongjmp.py

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Linesclass LongjmpTestCase(TestBase):
@expectedFailureAll(oslist=["linux"], bugnumber="llvm.org/pr20231") @expectedFailureAll(oslist=["linux"], bugnumber="llvm.org/pr20231")
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
def test_step_back_out(self): def test_step_back_out(self):
"""Test stepping when the inferior calls setjmp/longjmp, in particular, thread step-out after thread step-in.""" """Test stepping when the inferior calls setjmp/longjmp, in particular, thread step-out after thread step-in."""
self.build() self.build()
self.step_back_out() self.step_back_out()
def start_test(self, symbol): def start_test(self, symbol):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break in main(). # Break in main().
lldbutil.run_break_set_by_symbol( lldbutil.run_break_set_by_symbol(
self, symbol, num_expected_locations=-1) self, symbol, num_expected_locations=-1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 29 Lines

packages/Python/lldbsuite/test/functionalities/memory/cache/TestMemoryCache.py

Show All 22 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break inside main(). # Find the line number to break inside main().
self.line = line_number('main.cpp', '// Set break point at this line.') self.line = line_number('main.cpp', '// Set break point at this line.')
@expectedFlakeyOS(oslist=["windows"]) @expectedFlakeyOS(oslist=["windows"])
def test_memory_cache(self): def test_memory_cache(self):
"""Test the MemoryCache class with a sequence of 'memory read' and 'memory write' operations.""" """Test the MemoryCache class with a sequence of 'memory read' and 'memory write' operations."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break in main() after the variables are assigned values. # Break in main() after the variables are assigned values.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 27 Lines

packages/Python/lldbsuite/test/functionalities/memory/find/TestMemoryFind.py

Show All 22 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break inside main(). # Find the line number to break inside main().
self.line = line_number('main.cpp', '// break here') self.line = line_number('main.cpp', '// break here')
@expectedFailureAll(oslist=["windows"]) @expectedFailureAll(oslist=["windows"])
def test_memory_find(self): def test_memory_find(self):
"""Test the 'memory find' command.""" """Test the 'memory find' command."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break in main() aftre the variables are assigned values. # Break in main() aftre the variables are assigned values.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 32 Lines

packages/Python/lldbsuite/test/functionalities/memory/read/TestMemoryRead.py

Show All 20 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break inside main(). # Find the line number to break inside main().
self.line = line_number('main.cpp', '// Set break point at this line.') self.line = line_number('main.cpp', '// Set break point at this line.')
def test_memory_read(self): def test_memory_read(self):
"""Test the 'memory read' command with plain and vector formats.""" """Test the 'memory read' command with plain and vector formats."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break in main() aftre the variables are assigned values. # Break in main() aftre the variables are assigned values.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
▲ Show 20 Lines • Show All 100 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/mtc/simple/TestMTCSimple.py

Show All 27 Linesclass MTCSimpleTestCase(TestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
@skipIf(archs=['i386']) @skipIf(archs=['i386'])
def mtc_tests(self): def mtc_tests(self):
# Load the test # Load the test
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.expect("file " + exe, patterns=["Current executable set to .*a.out"]) self.expect("file " + exe, patterns=["Current executable set to .*a.out"])
self.runCmd("env DYLD_INSERT_LIBRARIES=%s" % self.mtc_dylib_path) self.runCmd("env DYLD_INSERT_LIBRARIES=%s" % self.mtc_dylib_path)
self.runCmd("run") self.runCmd("run")
process = self.dbg.GetSelectedTarget().process process = self.dbg.GetSelectedTarget().process
thread = process.GetSelectedThread() thread = process.GetSelectedThread()
frame = thread.GetSelectedFrame() frame = thread.GetSelectedFrame()
Show All 15 Lines

packages/Python/lldbsuite/test/functionalities/nested_alias/TestNestedAlias.py

Show All 20 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break inside main(). # Find the line number to break inside main().
self.line = line_number('main.cpp', '// break here') self.line = line_number('main.cpp', '// break here')
def test_nested_alias(self): def test_nested_alias(self):
"""Test that an alias can reference other aliases without crashing.""" """Test that an alias can reference other aliases without crashing."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break in main() aftre the variables are assigned values. # Break in main() aftre the variables are assigned values.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/non-overlapping-index-variable-i/TestIndexVariable.py

Show All 18 Lines def setUp(self):
self.line_to_break = line_number( self.line_to_break = line_number(
self.source, '// Set breakpoint here.') self.source, '// Set breakpoint here.')
# rdar://problem/9890530 # rdar://problem/9890530
def test_eval_index_variable(self): def test_eval_index_variable(self):
"""Test expressions of variable 'i' which appears in two for loops.""" """Test expressions of variable 'i' which appears in two for loops."""
self.build() self.build()
self.exe_name = 'a.out' self.exe_name = 'a.out'
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.exe_name)
self.runCmd("file %s" % exe, CURRENT_EXECUTABLE_SET) self.runCmd("file %s" % exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, self,
self.source, self.source,
self.line_to_break, self.line_to_break,
num_expected_locations=1, num_expected_locations=1,
loc_exact=True) loc_exact=True)
Show All 14 Lines

packages/Python/lldbsuite/test/functionalities/nosucharch/TestNoSuchArch.py

Show All 9 Lines
class NoSuchArchTestCase(TestBase): class NoSuchArchTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def test(self): def test(self):
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# Check that passing an invalid arch via the command-line fails but # Check that passing an invalid arch via the command-line fails but
# doesn't crash # doesn't crash
self.expect( self.expect(
"target crete --arch nothingtoseehere %s" % "target crete --arch nothingtoseehere %s" %
(exe), error=True) (exe), error=True)
# Check that passing an invalid arch via the SB API fails but doesn't # Check that passing an invalid arch via the SB API fails but doesn't
# crash # crash
target = self.dbg.CreateTargetWithFileAndArch(exe, "nothingtoseehere") target = self.dbg.CreateTargetWithFileAndArch(exe, "nothingtoseehere")
self.assertFalse(target.IsValid(), "This target should not be valid") self.assertFalse(target.IsValid(), "This target should not be valid")
# Now just create the target with the default arch and check it's fine # Now just create the target with the default arch and check it's fine
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target.IsValid(), "This target should now be valid") self.assertTrue(target.IsValid(), "This target should now be valid")

packages/Python/lldbsuite/test/functionalities/postmortem/minidump/TestMiniDump.py

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Lines def test_stack_info_in_mini_dump(self):
frame = thread.GetFrameAtIndex(i) frame = thread.GetFrameAtIndex(i)
self.assertTrue(frame.IsValid()) self.assertTrue(frame.IsValid())
self.assertEqual(frame.GetPC(), pc_list[i]) self.assertEqual(frame.GetPC(), pc_list[i])
@skipUnlessWindows # Minidump saving works only on windows @skipUnlessWindows # Minidump saving works only on windows
def test_deeper_stack_in_mini_dump(self): def test_deeper_stack_in_mini_dump(self):
"""Test that we can examine a more interesting stack in a mini dump.""" """Test that we can examine a more interesting stack in a mini dump."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
core = os.path.join(os.getcwd(), "core.dmp") core = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "core.dmp")
try: try:
# Set a breakpoint and capture a mini dump. # Set a breakpoint and capture a mini dump.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
breakpoint = target.BreakpointCreateByName("bar") breakpoint = target.BreakpointCreateByName("bar")
process = target.LaunchSimple( process = target.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
self.assertEqual(process.GetState(), lldb.eStateStopped) self.assertEqual(process.GetState(), lldb.eStateStopped)
self.assertTrue(process.SaveCore(core)) self.assertTrue(process.SaveCore(core))
Show All 18 Lines def test_deeper_stack_in_mini_dump(self):
self.assertTrue(self.dbg.DeleteTarget(target)) self.assertTrue(self.dbg.DeleteTarget(target))
if (os.path.isfile(core)): if (os.path.isfile(core)):
os.unlink(core) os.unlink(core)
@skipUnlessWindows # Minidump saving works only on windows @skipUnlessWindows # Minidump saving works only on windows
def test_local_variables_in_mini_dump(self): def test_local_variables_in_mini_dump(self):
"""Test that we can examine local variables in a mini dump.""" """Test that we can examine local variables in a mini dump."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
core = os.path.join(os.getcwd(), "core.dmp") core = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "core.dmp")
try: try:
# Set a breakpoint and capture a mini dump. # Set a breakpoint and capture a mini dump.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
breakpoint = target.BreakpointCreateByName("bar") breakpoint = target.BreakpointCreateByName("bar")
process = target.LaunchSimple( process = target.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
self.assertEqual(process.GetState(), lldb.eStateStopped) self.assertEqual(process.GetState(), lldb.eStateStopped)
self.assertTrue(process.SaveCore(core)) self.assertTrue(process.SaveCore(core))
Show All 16 Lines

packages/Python/lldbsuite/test/functionalities/process_attach/TestProcessAttach.py

Show All 21 Linesclass ProcessAttachTestCase(TestBase):
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
@skipIfiOSSimulator @skipIfiOSSimulator
@expectedFailureAll(oslist=['ios', 'watchos', 'tvos', 'bridgeos'], bugnumber="<rdar://problem/34538611>") # old lldb-server has race condition, launching an inferior and then launching debugserver in quick succession sometimes fails @expectedFailureAll(oslist=['ios', 'watchos', 'tvos', 'bridgeos'], bugnumber="<rdar://problem/34538611>") # old lldb-server has race condition, launching an inferior and then launching debugserver in quick succession sometimes fails
def test_attach_to_process_by_id(self): def test_attach_to_process_by_id(self):
"""Test attach by process id""" """Test attach by process id"""
self.build() self.build()
exe = os.path.join(os.getcwd(), exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, exe_name)
# Spawn a new process # Spawn a new process
popen = self.spawnSubprocess(exe) popen = self.spawnSubprocess(exe)
self.addTearDownHook(self.cleanupSubprocesses) self.addTearDownHook(self.cleanupSubprocesses)
self.runCmd("process attach -p " + str(popen.pid)) self.runCmd("process attach -p " + str(popen.pid))
target = self.dbg.GetSelectedTarget() target = self.dbg.GetSelectedTarget()
Show All 27 Lines def test_attach_to_process_from_different_dir_by_id(self):
process = target.GetProcess() process = target.GetProcess()
self.assertTrue(process, PROCESS_IS_VALID) self.assertTrue(process, PROCESS_IS_VALID)
@expectedFailureAll(oslist=['ios', 'watchos', 'tvos', 'bridgeos'], bugnumber="<rdar://problem/34538611>") # old lldb-server has race condition, launching an inferior and then launching debugserver in quick succession sometimes fails @expectedFailureAll(oslist=['ios', 'watchos', 'tvos', 'bridgeos'], bugnumber="<rdar://problem/34538611>") # old lldb-server has race condition, launching an inferior and then launching debugserver in quick succession sometimes fails
def test_attach_to_process_by_name(self): def test_attach_to_process_by_name(self):
"""Test attach by process name""" """Test attach by process name"""
self.build() self.build()
exe = os.path.join(os.getcwd(), exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, exe_name)
# Spawn a new process # Spawn a new process
popen = self.spawnSubprocess(exe) popen = self.spawnSubprocess(exe)
self.addTearDownHook(self.cleanupSubprocesses) self.addTearDownHook(self.cleanupSubprocesses)
self.runCmd("process attach -n " + exe_name) self.runCmd("process attach -n " + exe_name)
target = self.dbg.GetSelectedTarget() target = self.dbg.GetSelectedTarget()
Show All 10 Lines

packages/Python/lldbsuite/test/functionalities/process_attach/attach_denied/TestAttachDenied.py

Show All 19 Linesclass AttachDeniedTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipIfWindows @skipIfWindows
@skipIfiOSSimulator @skipIfiOSSimulator
@skipIfDarwinEmbedded # ptrace(ATTACH_REQUEST...) won't work on ios/tvos/etc @skipIfDarwinEmbedded # ptrace(ATTACH_REQUEST...) won't work on ios/tvos/etc
def test_attach_to_process_by_id_denied(self): def test_attach_to_process_by_id_denied(self):
"""Test attach by process id denied""" """Test attach by process id denied"""
self.build() self.build()
exe = os.path.join(os.getcwd(), exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, exe_name)
# Use a file as a synchronization point between test and inferior. # Use a file as a synchronization point between test and inferior.
pid_file_path = lldbutil.append_to_process_working_directory( pid_file_path = lldbutil.append_to_process_working_directory(
"pid_file_%d" % (int(time.time()))) "pid_file_%d" % (int(time.time())))
self.addTearDownHook( self.addTearDownHook(
lambda: self.run_platform_command( lambda: self.run_platform_command(
"rm %s" % "rm %s" %
(pid_file_path))) (pid_file_path)))
Show All 10 Lines

packages/Python/lldbsuite/test/functionalities/process_group/TestChangeProcessGroup.py

Show All 20 Lines def setUp(self):
self.line = line_number('main.c', '// Set breakpoint here') self.line = line_number('main.c', '// Set breakpoint here')
@skipIfFreeBSD # Times out on FreeBSD llvm.org/pr23731 @skipIfFreeBSD # Times out on FreeBSD llvm.org/pr23731
@skipIfWindows # setpgid call does not exist on Windows @skipIfWindows # setpgid call does not exist on Windows
@expectedFailureAndroid("http://llvm.org/pr23762", api_levels=[16]) @expectedFailureAndroid("http://llvm.org/pr23762", api_levels=[16])
@expectedFailureAll(oslist=['ios', 'watchos', 'tvos', 'bridgeos'], bugnumber="<rdar://problem/34538611>") # old lldb-server has race condition, launching an inferior and then launching debugserver in quick succession sometimes fails @expectedFailureAll(oslist=['ios', 'watchos', 'tvos', 'bridgeos'], bugnumber="<rdar://problem/34538611>") # old lldb-server has race condition, launching an inferior and then launching debugserver in quick succession sometimes fails
def test_setpgid(self): def test_setpgid(self):
self.build() self.build()
exe = os.path.join(os.getcwd(), 'a.out') exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, 'a.out')
# Use a file as a synchronization point between test and inferior. # Use a file as a synchronization point between test and inferior.
pid_file_path = lldbutil.append_to_process_working_directory( pid_file_path = lldbutil.append_to_process_working_directory(
"pid_file_%d" % (int(time.time()))) "pid_file_%d" % (int(time.time())))
self.addTearDownHook( self.addTearDownHook(
lambda: self.run_platform_command( lambda: self.run_platform_command(
"rm %s" % "rm %s" %
(pid_file_path))) (pid_file_path)))
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/process_launch/TestProcessLaunch.py

Show All 27 Linesclass ProcessLaunchTestCase(TestBase):
def tearDown(self): def tearDown(self):
self.runCmd("settings clear auto-confirm") self.runCmd("settings clear auto-confirm")
TestBase.tearDown(self) TestBase.tearDown(self)
@not_remote_testsuite_ready @not_remote_testsuite_ready
def test_io(self): def test_io(self):
"""Test that process launch I/O redirection flags work properly.""" """Test that process launch I/O redirection flags work properly."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.expect("file " + exe, self.expect("file " + exe,
patterns=["Current executable set to .*a.out"]) patterns=["Current executable set to .*a.out"])
in_file = "input-file.txt" in_file = "input-file.txt"
out_file = "output-test.out" out_file = "output-test.out"
err_file = "output-test.err" err_file = "output-test.err"
# Make sure the output files do not exist before launching the process # Make sure the output files do not exist before launching the process
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 Lines"
# not working? # not working?
@not_remote_testsuite_ready @not_remote_testsuite_ready
@expectedFailureAll(oslist=["linux"], bugnumber="llvm.org/pr20265") @expectedFailureAll(oslist=["linux"], bugnumber="llvm.org/pr20265")
def test_set_working_dir(self): def test_set_working_dir(self):
"""Test that '-w dir' sets the working dir when running the inferior.""" """Test that '-w dir' sets the working dir when running the inferior."""
d = {'CXX_SOURCES': 'print_cwd.cpp'} d = {'CXX_SOURCES': 'print_cwd.cpp'}
self.build(dictionary=d) self.build(dictionary=d)
self.setTearDownCleanup(d) self.setTearDownCleanup(d)
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe) self.runCmd("file " + exe)
mywd = 'my_working_dir' mywd = 'my_working_dir'
out_file_name = "my_working_dir_test.out" out_file_name = "my_working_dir_test.out"
err_file_name = "my_working_dir_test.err" err_file_name = "my_working_dir_test.err"
my_working_dir_path = os.path.join(os.getcwd(), mywd) my_working_dir_path = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, mywd)
out_file_path = os.path.join(my_working_dir_path, out_file_name) out_file_path = os.path.join(my_working_dir_path, out_file_name)
err_file_path = os.path.join(my_working_dir_path, err_file_name) err_file_path = os.path.join(my_working_dir_path, err_file_name)
# Make sure the output files do not exist before launching the process # Make sure the output files do not exist before launching the process
try: try:
os.remove(out_file_path) os.remove(out_file_path)
os.remove(err_file_path) os.remove(err_file_path)
except OSError: except OSError:
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines def test_set_working_dir(self):
self.fail(err_msg) self.fail(err_msg)
def test_environment_with_special_char(self): def test_environment_with_special_char(self):
"""Test that environment variables containing '*' and '}' are handled correctly by the inferior.""" """Test that environment variables containing '*' and '}' are handled correctly by the inferior."""
source = 'print_env.cpp' source = 'print_env.cpp'
d = {'CXX_SOURCES': source} d = {'CXX_SOURCES': source}
self.build(dictionary=d) self.build(dictionary=d)
self.setTearDownCleanup(d) self.setTearDownCleanup(d)
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
evil_var = 'INIT*MIDDLE}TAIL' evil_var = 'INIT*MIDDLE}TAIL'
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
main_source_spec = lldb.SBFileSpec(source) main_source_spec = lldb.SBFileSpec(source)
breakpoint = target.BreakpointCreateBySourceRegex( breakpoint = target.BreakpointCreateBySourceRegex(
'// Set breakpoint here.', main_source_spec) '// Set breakpoint here.', main_source_spec)
Show All 19 Lines

packages/Python/lldbsuite/test/functionalities/process_save_core/TestProcessSaveCore.py

Show All 15 Linesclass ProcessSaveCoreTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@not_remote_testsuite_ready @not_remote_testsuite_ready
@skipUnlessWindows @skipUnlessWindows
def test_cannot_save_core_unless_process_stopped(self): def test_cannot_save_core_unless_process_stopped(self):
"""Test that SaveCore fails if the process isn't stopped.""" """Test that SaveCore fails if the process isn't stopped."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
core = os.path.join(os.getcwd(), "core.dmp") core = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "core.dmp")
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.assertNotEqual(process.GetState(), lldb.eStateStopped) self.assertNotEqual(process.GetState(), lldb.eStateStopped)
error = process.SaveCore(core) error = process.SaveCore(core)
self.assertTrue(error.Fail()) self.assertTrue(error.Fail())
@not_remote_testsuite_ready @not_remote_testsuite_ready
@skipUnlessWindows @skipUnlessWindows
def test_save_windows_mini_dump(self): def test_save_windows_mini_dump(self):
"""Test that we can save a Windows mini dump.""" """Test that we can save a Windows mini dump."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
core = os.path.join(os.getcwd(), "core.dmp") core = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "core.dmp")
try: try:
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
breakpoint = target.BreakpointCreateByName("bar") breakpoint = target.BreakpointCreateByName("bar")
process = target.LaunchSimple( process = target.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
self.assertEqual(process.GetState(), lldb.eStateStopped) self.assertEqual(process.GetState(), lldb.eStateStopped)
self.assertTrue(process.SaveCore(core)) self.assertTrue(process.SaveCore(core))
self.assertTrue(os.path.isfile(core)) self.assertTrue(os.path.isfile(core))
Show All 20 Lines

packages/Python/lldbsuite/test/functionalities/ptr_refs/TestPtrRefs.py

Show All 14 Linesclass TestPtrRefs(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipUnlessDarwin @skipUnlessDarwin
def test_ptr_refs(self): def test_ptr_refs(self):
"""Test format string functionality.""" """Test format string functionality."""
self.build() self.build()
exe_name = 'a.out' exe_name = 'a.out'
exe = os.path.join(os.getcwd(), exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, exe_name)
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
main_file_spec = lldb.SBFileSpec('main.c') main_file_spec = lldb.SBFileSpec('main.c')
breakpoint = target.BreakpointCreateBySourceRegex( breakpoint = target.BreakpointCreateBySourceRegex(
'break', main_file_spec) 'break', main_file_spec)
self.assertTrue(breakpoint and self.assertTrue(breakpoint and
Show All 18 Lines

packages/Python/lldbsuite/test/functionalities/register/intel_avx/TestYMMRegister.py

Show All 19 Linesclass TestYMMRegister(TestBase):
@skipIfFreeBSD @skipIfFreeBSD
@skipIfiOSSimulator @skipIfiOSSimulator
@skipIfTargetAndroid() @skipIfTargetAndroid()
@skipIf(archs=no_match(['i386', 'x86_64'])) @skipIf(archs=no_match(['i386', 'x86_64']))
def test(self): def test(self):
self.build() self.build()
self.setTearDownCleanup() self.setTearDownCleanup()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
byte_pattern1 = 0x80 byte_pattern1 = 0x80
byte_pattern2 = 0xFF byte_pattern2 = 0xFF
# Launch the process and stop. # Launch the process and stop.
Show All 40 Lines

packages/Python/lldbsuite/test/functionalities/register/intel_xtended_registers/TestMPXRegisters.py

Show All 29 Lines def test_mpx_registers_with_example_code(self):
"""Test Intel(R) MPX registers with example code.""" """Test Intel(R) MPX registers with example code."""
self.build() self.build()
self.mpx_registers_with_example_code() self.mpx_registers_with_example_code()
def mpx_registers_with_example_code(self): def mpx_registers_with_example_code(self):
"""Test Intel(R) MPX registers after running example code.""" """Test Intel(R) MPX registers after running example code."""
self.line = line_number('main.cpp', '// Set a break point here.') self.line = line_number('main.cpp', '// Set a break point here.')
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line(self, "main.cpp", self.line, num_expected_locations=1) lldbutil.run_break_set_by_file_and_line(self, "main.cpp", self.line, num_expected_locations=1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
target = self.dbg.GetSelectedTarget() target = self.dbg.GetSelectedTarget()
process = target.GetProcess() process = target.GetProcess()
Show All 23 Lines

packages/Python/lldbsuite/test/functionalities/register/intel_xtended_registers/mpx_bound_violation/TestBoundViolation.py

Show All 23 Linesclass RegisterCommandsTestCase(TestBase):
@skipIf(archs=no_match(['i386', 'x86_64'])) @skipIf(archs=no_match(['i386', 'x86_64']))
@skipIf(oslist=["linux"], compiler="gcc", compiler_version=["<", "5"]) #GCC version >= 5 supports Intel(R) MPX. @skipIf(oslist=["linux"], compiler="gcc", compiler_version=["<", "5"]) #GCC version >= 5 supports Intel(R) MPX.
def test_mpx_boundary_violation(self): def test_mpx_boundary_violation(self):
"""Test Intel(R) MPX bound violation signal.""" """Test Intel(R) MPX bound violation signal."""
self.build() self.build()
self.mpx_boundary_violation() self.mpx_boundary_violation()
def mpx_boundary_violation(self): def mpx_boundary_violation(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
target = self.dbg.GetSelectedTarget() target = self.dbg.GetSelectedTarget()
process = target.GetProcess() process = target.GetProcess()
if (process.GetState() == lldb.eStateExited): if (process.GetState() == lldb.eStateExited):
Show All 17 Lines

packages/Python/lldbsuite/test/functionalities/register/register_command/TestRegisters.py

Show First 20 Lines • Show All 118 Lines • ▼ Show 20 Linesclass RegisterCommandsTestCase(TestBase):
@skipIfiOSSimulator @skipIfiOSSimulator
@skipIf(archs=no_match(['amd64', 'x86_64'])) @skipIf(archs=no_match(['amd64', 'x86_64']))
def test_convenience_registers_16bit_with_process_attach(self): def test_convenience_registers_16bit_with_process_attach(self):
"""Test convenience registers after a 'process attach'.""" """Test convenience registers after a 'process attach'."""
self.build() self.build()
self.convenience_registers_with_process_attach(test_16bit_regs=True) self.convenience_registers_with_process_attach(test_16bit_regs=True)
def common_setup(self): def common_setup(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break in main(). # Break in main().
lldbutil.run_break_set_by_symbol( lldbutil.run_break_set_by_symbol(
self, "main", num_expected_locations=-1) self, "main", num_expected_locations=-1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', 'stop reason = breakpoint']) substrs=['stopped', 'stop reason = breakpoint'])
# platform specific logging of the specified category # platform specific logging of the specified category
def log_enable(self, category): def log_enable(self, category):
# This intentionally checks the host platform rather than the target # This intentionally checks the host platform rather than the target
# platform as logging is host side. # platform as logging is host side.
self.platform = "" self.platform = ""
if (sys.platform.startswith("freebsd") or if (sys.platform.startswith("freebsd") or
sys.platform.startswith("linux") or sys.platform.startswith("linux") or
sys.platform.startswith("netbsd")): sys.platform.startswith("netbsd")):
self.platform = "posix" self.platform = "posix"
if self.platform != "": if self.platform != "":
self.log_file = os.path.join(os.getcwd(), 'TestRegisters.log') self.log_file = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, 'TestRegisters.log')
self.runCmd( self.runCmd(
"log enable " + "log enable " +
self.platform + self.platform +
" " + " " +
str(category) + str(category) +
" registers -v -f " + " registers -v -f " +
self.log_file, self.log_file,
RUN_SUCCEEDED) RUN_SUCCEEDED)
Show All 19 Lines def write_and_read(self, frame, register, new_value, must_exist=True):
"register read " + "register read " +
register, register,
substrs=[ substrs=[
register + register +
' = ', ' = ',
new_value]) new_value])
def fp_special_purpose_register_read(self): def fp_special_purpose_register_read(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Launch the process and stop. # Launch the process and stop.
self.expect("run", PROCESS_STOPPED, substrs=['stopped']) self.expect("run", PROCESS_STOPPED, substrs=['stopped'])
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Lines def fp_special_purpose_register_read(self):
'ftag' + ' = ', str( 'ftag' + ' = ', str(
"0x%0.4x" % "0x%0.4x" %
(reg_value_ftag_initial | ( (reg_value_ftag_initial | (
1 << fstat_top_pointer_initial)))]) 1 << fstat_top_pointer_initial)))])
reg_value_ftag_initial = reg_value_ftag_initial | ( reg_value_ftag_initial = reg_value_ftag_initial | (
1 << fstat_top_pointer_initial) 1 << fstat_top_pointer_initial)
def fp_register_write(self): def fp_register_write(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Launch the process, stop at the entry point. # Launch the process, stop at the entry point.
error = lldb.SBError() error = lldb.SBError()
process = target.Launch( process = target.Launch(
▲ Show 20 Lines • Show All 158 Lines • ▼ Show 20 Lines def convenience_registers(self):
# Now write rax with a unique bit pattern and test that eax indeed # Now write rax with a unique bit pattern and test that eax indeed
# represents the lower half of rax. # represents the lower half of rax.
self.runCmd("register write rax 0x1234567887654321") self.runCmd("register write rax 0x1234567887654321")
self.expect("register read rax 0x1234567887654321", self.expect("register read rax 0x1234567887654321",
substrs=['0x1234567887654321']) substrs=['0x1234567887654321'])
def convenience_registers_with_process_attach(self, test_16bit_regs): def convenience_registers_with_process_attach(self, test_16bit_regs):
"""Test convenience registers after a 'process attach'.""" """Test convenience registers after a 'process attach'."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# Spawn a new process # Spawn a new process
pid = self.spawnSubprocess(exe, ['wait_for_attach']).pid pid = self.spawnSubprocess(exe, ['wait_for_attach']).pid
self.addTearDownHook(self.cleanupSubprocesses) self.addTearDownHook(self.cleanupSubprocesses)
if self.TraceOn(): if self.TraceOn():
print("pid of spawned process: %d" % pid) print("pid of spawned process: %d" % pid)
Show All 12 Lines

packages/Python/lldbsuite/test/functionalities/rerun/TestRerun.py

Show All 12 Lines
class TestRerun(TestBase): class TestRerun(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def test(self): def test(self):
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("target create %s" % exe) self.runCmd("target create %s" % exe)
# Create the target # Create the target
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
# Create any breakpoints we need # Create any breakpoints we need
breakpoint = target.BreakpointCreateBySourceRegex( breakpoint = target.BreakpointCreateBySourceRegex(
Show All 34 Lines

packages/Python/lldbsuite/test/functionalities/return-value/TestReturnValue.py

Show All 34 Lines @expectedFailureAll(
"<=", "<=",
"3.6"], "3.6"],
archs=["i386"]) archs=["i386"])
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_with_python(self): def test_with_python(self):
"""Test getting return values from stepping out.""" """Test getting return values from stepping out."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
error = lldb.SBError() error = lldb.SBError()
self.target = self.dbg.CreateTarget(exe) self.target = self.dbg.CreateTarget(exe)
self.assertTrue(self.target, VALID_TARGET) self.assertTrue(self.target, VALID_TARGET)
inner_sint_bkpt = self.target.BreakpointCreateByName("inner_sint", exe) inner_sint_bkpt = self.target.BreakpointCreateByName("inner_sint", exe)
self.assertTrue(inner_sint_bkpt, VALID_BREAKPOINT) self.assertTrue(inner_sint_bkpt, VALID_BREAKPOINT)
▲ Show 20 Lines • Show All 132 Lines • ▼ Show 20 Lines @expectedFailureAll(
"<=", "<=",
"3.6"], "3.6"],
archs=["i386"]) archs=["i386"])
@expectedFailureAll(compiler=["gcc"], archs=["x86_64", "i386"]) @expectedFailureAll(compiler=["gcc"], archs=["x86_64", "i386"])
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
@skipIfDarwinEmbedded # <rdar://problem/33976032> ABIMacOSX_arm64 doesn't get structs this big correctly @skipIfDarwinEmbedded # <rdar://problem/33976032> ABIMacOSX_arm64 doesn't get structs this big correctly
def test_vector_values(self): def test_vector_values(self):
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
error = lldb.SBError() error = lldb.SBError()
self.target = self.dbg.CreateTarget(exe) self.target = self.dbg.CreateTarget(exe)
self.assertTrue(self.target, VALID_TARGET) self.assertTrue(self.target, VALID_TARGET)
main_bktp = self.target.BreakpointCreateByName("main", exe) main_bktp = self.target.BreakpointCreateByName("main", exe)
self.assertTrue(main_bktp, VALID_BREAKPOINT) self.assertTrue(main_bktp, VALID_BREAKPOINT)
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/set-data/TestSetData.py

Show All 15 Lines
class SetDataTestCase(TestBase): class SetDataTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipUnlessDarwin @skipUnlessDarwin
def test_set_data(self): def test_set_data(self):
"""Test setting the contents of variables and registers using raw data.""" """Test setting the contents of variables and registers using raw data."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("br s -p First") self.runCmd("br s -p First")
self.runCmd("br s -p Second") self.runCmd("br s -p Second")
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.expect("p myFoo.x", VARIABLES_DISPLAYED_CORRECTLY, self.expect("p myFoo.x", VARIABLES_DISPLAYED_CORRECTLY,
Show All 39 Lines

packages/Python/lldbsuite/test/functionalities/signal/TestSendSignal.py

Show All 23 Linesclass SendSignalTestCase(TestBase):
@expectedFailureAll( @expectedFailureAll(
oslist=['freebsd'], oslist=['freebsd'],
bugnumber="llvm.org/pr23318: does not report running state") bugnumber="llvm.org/pr23318: does not report running state")
@skipIfWindows # Windows does not support signals @skipIfWindows # Windows does not support signals
def test_with_run_command(self): def test_with_run_command(self):
"""Test that lldb command 'process signal SIGUSR1' sends a signal to the inferior process.""" """Test that lldb command 'process signal SIGUSR1' sends a signal to the inferior process."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Now create a breakpoint on main.c by name 'c'. # Now create a breakpoint on main.c by name 'c'.
breakpoint = target.BreakpointCreateByLocation('main.c', self.line) breakpoint = target.BreakpointCreateByLocation('main.c', self.line)
self.assertTrue(breakpoint and self.assertTrue(breakpoint and
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/signal/handle-segv/TestHandleSegv.py

Show All 14 Lines
class HandleSegvTestCase(TestBase): class HandleSegvTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipIfWindows # signals do not exist on Windows @skipIfWindows # signals do not exist on Windows
@skipIfDarwin @skipIfDarwin
def test_inferior_handle_sigsegv(self): def test_inferior_handle_sigsegv(self):
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# launch # launch
process = target.LaunchSimple( process = target.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
Show All 18 Lines

packages/Python/lldbsuite/test/functionalities/signal/raise/TestRaise.py

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines def set_handle(self, signal, pass_signal, stop_at_signal, notify_signal):
"process handle %s -p %s -s %s -n %s" % "process handle %s -p %s -s %s -n %s" %
(signal, pass_signal, stop_at_signal, notify_signal), return_obj) (signal, pass_signal, stop_at_signal, notify_signal), return_obj)
self.assertTrue( self.assertTrue(
return_obj.Succeeded(), return_obj.Succeeded(),
"Setting signal handling failed") "Setting signal handling failed")
def signal_test(self, signal, test_passing): def signal_test(self, signal, test_passing):
"""Test that we handle inferior raising signals""" """Test that we handle inferior raising signals"""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
lldbutil.run_break_set_by_symbol(self, "main") lldbutil.run_break_set_by_symbol(self, "main")
# launch # launch
process = self.launch(target, signal) process = self.launch(target, signal)
▲ Show 20 Lines • Show All 122 Lines • ▼ Show 20 Linesclass RaiseTestCase(TestBase):
@expectedFailureAll( @expectedFailureAll(
oslist=["linux"] + oslist=["linux"] +
getDarwinOSTriples(), getDarwinOSTriples(),
bugnumber="llvm.org/pr20231") bugnumber="llvm.org/pr20231")
def test_restart_bug(self): def test_restart_bug(self):
"""Test that we catch a signal in the edge case where the process receives it while we are """Test that we catch a signal in the edge case where the process receives it while we are
about to interrupt it""" about to interrupt it"""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
bkpt = target.BreakpointCreateByName("main") bkpt = target.BreakpointCreateByName("main")
self.assertTrue(bkpt.IsValid(), VALID_BREAKPOINT) self.assertTrue(bkpt.IsValid(), VALID_BREAKPOINT)
# launch the inferior and don't wait for it to stop # launch the inferior and don't wait for it to stop
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/stop-hook/TestStopHookCmd.py

Show All 32 Linesclass StopHookCmdTestCase(TestBase):
@no_debug_info_test @no_debug_info_test
def test_not_crashing_if_no_target(self): def test_not_crashing_if_no_target(self):
"""target stop-hook list should not crash if no target has been set.""" """target stop-hook list should not crash if no target has been set."""
self.runCmd("target stop-hook list", check=False) self.runCmd("target stop-hook list", check=False)
def test(self): def test(self):
"""Test a sequence of target stop-hook commands.""" """Test a sequence of target stop-hook commands."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.begl, num_expected_locations=1, loc_exact=True) self, "main.cpp", self.begl, num_expected_locations=1, loc_exact=True)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
Show All 28 Lines

packages/Python/lldbsuite/test/functionalities/stop-hook/TestStopHookMechanism.py

Show All 39 Lines @expectedFailureAll(
hostoslist=["windows"], hostoslist=["windows"],
bugnumber="llvm.org/pr22274: need a pexpect replacement for windows") bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
@skipIf(oslist=['ios', 'watchos', 'tvos', 'bridgeos'], archs=['armv7', 'armv7k']) # <rdar://problem/34582291> problem with armv7 and step-over and stop-hook firing on ios etc systems @skipIf(oslist=['ios', 'watchos', 'tvos', 'bridgeos'], archs=['armv7', 'armv7k']) # <rdar://problem/34582291> problem with armv7 and step-over and stop-hook firing on ios etc systems
def test(self): def test(self):
"""Test the stop-hook mechanism.""" """Test the stop-hook mechanism."""
self.build() self.build()
import pexpect import pexpect
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
prompt = "(lldb) " prompt = "(lldb) "
add_prompt = "Enter your stop hook command(s). Type 'DONE' to end." add_prompt = "Enter your stop hook command(s). Type 'DONE' to end."
add_prompt1 = "> " add_prompt1 = "> "
# So that the child gets torn down after the test. # So that the child gets torn down after the test.
self.child = pexpect.spawn('%s %s' % self.child = pexpect.spawn('%s %s' %
(lldbtest_config.lldbExec, self.lldbOption)) (lldbtest_config.lldbExec, self.lldbOption))
child = self.child child = self.child
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/stop-hook/multiple_threads/TestStopHookMultipleThreads.py

Show All 40 Lines @expectedFailureAll(
hostoslist=["windows"], hostoslist=["windows"],
bugnumber="llvm.org/pr22274: need a pexpect replacement for windows") bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
def test_stop_hook_multiple_threads(self): def test_stop_hook_multiple_threads(self):
"""Test that lldb stop-hook works for multiple threads.""" """Test that lldb stop-hook works for multiple threads."""
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
import pexpect import pexpect
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.exe_name)
prompt = "(lldb) " prompt = "(lldb) "
# So that the child gets torn down after the test. # So that the child gets torn down after the test.
self.child = pexpect.spawn('%s %s' % self.child = pexpect.spawn('%s %s' %
(lldbtest_config.lldbExec, self.lldbOption)) (lldbtest_config.lldbExec, self.lldbOption))
child = self.child child = self.child
# Turn on logging for what the child sends back. # Turn on logging for what the child sends back.
if self.TraceOn(): if self.TraceOn():
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/target_command/TestTargetCommand.py

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Lines def test_target_variable_command_no_fail(self):
d = {'C_SOURCES': 'globals.c', 'EXE': 'globals'} d = {'C_SOURCES': 'globals.c', 'EXE': 'globals'}
self.build(dictionary=d) self.build(dictionary=d)
self.addTearDownCleanup(dictionary=d) self.addTearDownCleanup(dictionary=d)
self.do_target_variable_command_no_fail('globals') self.do_target_variable_command_no_fail('globals')
def do_target_command(self): def do_target_command(self):
"""Exercise 'target create', 'target list', 'target select' commands.""" """Exercise 'target create', 'target list', 'target select' commands."""
exe_a = os.path.join(os.getcwd(), "a.out") exe_a = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
exe_b = os.path.join(os.getcwd(), "b.out") exe_b = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "b.out")
exe_c = os.path.join(os.getcwd(), "c.out") exe_c = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "c.out")
self.runCmd("target list") self.runCmd("target list")
output = self.res.GetOutput() output = self.res.GetOutput()
if output.startswith("No targets"): if output.startswith("No targets"):
# We start from index 0. # We start from index 0.
base = 0 base = 0
else: else:
# Find the largest index of the existing list. # Find the largest index of the existing list.
▲ Show 20 Lines • Show All 201 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/thread/backtrace_all/TestBacktraceAll.py

Show All 24 Linesclass BreakpointAfterJoinTestCase(TestBase):
# The android-arm compiler can't compile the inferior # The android-arm compiler can't compile the inferior
@skipIfTargetAndroid(archs=["arm"]) @skipIfTargetAndroid(archs=["arm"])
# because of an issue around std::future. # because of an issue around std::future.
# TODO: Change the test to don't depend on std::future<T> # TODO: Change the test to don't depend on std::future<T>
def test(self): def test(self):
"""Test breakpoint handling after a thread join.""" """Test breakpoint handling after a thread join."""
self.build(dictionary=self.getBuildFlags()) self.build(dictionary=self.getBuildFlags())
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# This should create a breakpoint # This should create a breakpoint
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "ParallelTask.cpp", self.breakpoint, num_expected_locations=-1) self, "ParallelTask.cpp", self.breakpoint, num_expected_locations=-1)
# The breakpoint list should show 1 location. # The breakpoint list should show 1 location.
self.expect( self.expect(
Show All 26 Lines

packages/Python/lldbsuite/test/functionalities/thread/break_after_join/TestBreakAfterJoin.py

Show All 30 Lines @expectedFailureAll(
bugnumber="llvm.org/pr15824 thread states not properly maintained and <rdar://problem/28557237>") bugnumber="llvm.org/pr15824 thread states not properly maintained and <rdar://problem/28557237>")
@expectedFailureAll( @expectedFailureAll(
oslist=["freebsd"], oslist=["freebsd"],
bugnumber="llvm.org/pr18190 thread states not properly maintained") bugnumber="llvm.org/pr18190 thread states not properly maintained")
def test(self): def test(self):
"""Test breakpoint handling after a thread join.""" """Test breakpoint handling after a thread join."""
self.build(dictionary=self.getBuildFlags()) self.build(dictionary=self.getBuildFlags())
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# This should create a breakpoint in the main thread. # This should create a breakpoint in the main thread.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.breakpoint, num_expected_locations=1) self, "main.cpp", self.breakpoint, num_expected_locations=1)
# The breakpoint list should show 1 location. # The breakpoint list should show 1 location.
self.expect( self.expect(
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/thread/crash_during_step/TestCrashDuringStep.py

Show All 20 Lines def setUp(self):
self.breakpoint = line_number('main.cpp', '// Set breakpoint here') self.breakpoint = line_number('main.cpp', '// Set breakpoint here')
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
# IO error due to breakpoint at invalid address # IO error due to breakpoint at invalid address
@expectedFailureAll(triple=re.compile('^mips')) @expectedFailureAll(triple=re.compile('^mips'))
def test_step_inst_with(self): def test_step_inst_with(self):
"""Test thread creation during step-inst handling.""" """Test thread creation during step-inst handling."""
self.build(dictionary=self.getBuildFlags()) self.build(dictionary=self.getBuildFlags())
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target and target.IsValid(), "Target is valid") self.assertTrue(target and target.IsValid(), "Target is valid")
self.bp_num = lldbutil.run_break_set_by_file_and_line( self.bp_num = lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.breakpoint, num_expected_locations=1) self, "main.cpp", self.breakpoint, num_expected_locations=1)
# Run the program. # Run the program.
Show All 27 Lines

packages/Python/lldbsuite/test/functionalities/thread/create_after_attach/TestCreateAfterAttach.py

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines def setUp(self):
# Find the line numbers for our breakpoints. # Find the line numbers for our breakpoints.
self.break_1 = line_number('main.cpp', '// Set first breakpoint here') self.break_1 = line_number('main.cpp', '// Set first breakpoint here')
self.break_2 = line_number('main.cpp', '// Set second breakpoint here') self.break_2 = line_number('main.cpp', '// Set second breakpoint here')
self.break_3 = line_number('main.cpp', '// Set third breakpoint here') self.break_3 = line_number('main.cpp', '// Set third breakpoint here')
def create_after_attach(self, use_fork): def create_after_attach(self, use_fork):
"""Test thread creation after process attach.""" """Test thread creation after process attach."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# Spawn a new process # Spawn a new process
if use_fork: if use_fork:
pid = self.forkSubprocess(exe) pid = self.forkSubprocess(exe)
else: else:
popen = self.spawnSubprocess(exe) popen = self.spawnSubprocess(exe)
pid = popen.pid pid = popen.pid
self.addTearDownHook(self.cleanupSubprocesses) self.addTearDownHook(self.cleanupSubprocesses)
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/thread/create_during_step/TestCreateDuringStep.py

Show First 20 Lines • Show All 77 Lines • ▼ Show 20 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line numbers to break and continue. # Find the line numbers to break and continue.
self.breakpoint = line_number('main.cpp', '// Set breakpoint here') self.breakpoint = line_number('main.cpp', '// Set breakpoint here')
self.continuepoint = line_number('main.cpp', '// Continue from here') self.continuepoint = line_number('main.cpp', '// Continue from here')
def create_during_step_base(self, step_cmd, step_stop_reason): def create_during_step_base(self, step_cmd, step_stop_reason):
"""Test thread creation while using step-in.""" """Test thread creation while using step-in."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Get the target process # Get the target process
target = self.dbg.GetSelectedTarget() target = self.dbg.GetSelectedTarget()
# This should create a breakpoint in the stepping thread. # This should create a breakpoint in the stepping thread.
self.bkpt = target.BreakpointCreateByLocation("main.cpp", self.breakpoint) self.bkpt = target.BreakpointCreateByLocation("main.cpp", self.breakpoint)
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/thread/exit_during_break/TestExitDuringBreak.py

Show All 23 Lines def setUp(self):
self.breakpoint = line_number('main.cpp', '// Set breakpoint here') self.breakpoint = line_number('main.cpp', '// Set breakpoint here')
@expectedFailureAll( @expectedFailureAll(
oslist=["linux"], oslist=["linux"],
bugnumber="llvm.org/pr15824 thread states not properly maintained") bugnumber="llvm.org/pr15824 thread states not properly maintained")
def test(self): def test(self):
"""Test thread exit during breakpoint handling.""" """Test thread exit during breakpoint handling."""
self.build(dictionary=self.getBuildFlags()) self.build(dictionary=self.getBuildFlags())
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# This should create a breakpoint in the main thread. # This should create a breakpoint in the main thread.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.breakpoint, num_expected_locations=1) self, "main.cpp", self.breakpoint, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 29 Lines

packages/Python/lldbsuite/test/functionalities/thread/exit_during_step/TestExitDuringStep.py

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line numbers to break and continue. # Find the line numbers to break and continue.
self.breakpoint = line_number('main.cpp', '// Set breakpoint here') self.breakpoint = line_number('main.cpp', '// Set breakpoint here')
self.continuepoint = line_number('main.cpp', '// Continue from here') self.continuepoint = line_number('main.cpp', '// Continue from here')
def exit_during_step_base(self, step_cmd, step_stop_reason, by_instruction): def exit_during_step_base(self, step_cmd, step_stop_reason, by_instruction):
"""Test thread exit during step handling.""" """Test thread exit during step handling."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# This should create a breakpoint in the main thread. # This should create a breakpoint in the main thread.
self.bp_num = lldbutil.run_break_set_by_file_and_line( self.bp_num = lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.breakpoint, num_expected_locations=1) self, "main.cpp", self.breakpoint, num_expected_locations=1)
# The breakpoint list should show 1 location. # The breakpoint list should show 1 location.
self.expect( self.expect(
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/thread/jump/TestThreadJump.py

Show All 14 Lines
class ThreadJumpTestCase(TestBase): class ThreadJumpTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def test(self): def test(self):
"""Test thread jump handling.""" """Test thread jump handling."""
self.build(dictionary=self.getBuildFlags()) self.build(dictionary=self.getBuildFlags())
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Find the line numbers for our breakpoints. # Find the line numbers for our breakpoints.
self.mark1 = line_number('main.cpp', '// 1st marker') self.mark1 = line_number('main.cpp', '// 1st marker')
self.mark2 = line_number('main.cpp', '// 2nd marker') self.mark2 = line_number('main.cpp', '// 2nd marker')
self.mark3 = line_number('main.cpp', '// 3rd marker') self.mark3 = line_number('main.cpp', '// 3rd marker')
self.mark4 = line_number('main.cpp', '// 4th marker') self.mark4 = line_number('main.cpp', '// 4th marker')
self.mark5 = line_number('other.cpp', '// other marker') self.mark5 = line_number('other.cpp', '// other marker')
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/thread/multi_break/TestMultipleBreakpoints.py

Show All 32 Lines @expectedFailureAll(
oslist=["freebsd"], oslist=["freebsd"],
bugnumber="llvm.org/pr18190 thread states not properly maintained") bugnumber="llvm.org/pr18190 thread states not properly maintained")
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr24668: Breakpoints not resolved correctly") bugnumber="llvm.org/pr24668: Breakpoints not resolved correctly")
def test(self): def test(self):
"""Test simultaneous breakpoints in multiple threads.""" """Test simultaneous breakpoints in multiple threads."""
self.build(dictionary=self.getBuildFlags()) self.build(dictionary=self.getBuildFlags())
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# This should create a breakpoint in the main thread. # This should create a breakpoint in the main thread.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.breakpoint, num_expected_locations=1) self, "main.cpp", self.breakpoint, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/thread/num_threads/TestNumThreads.py

Show All 21 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
# Find the line numbers for our break points. # Find the line numbers for our break points.
self.thread3_notify_all_line = line_number('main.cpp', '// Set thread3 break point on notify_all at this line.') self.thread3_notify_all_line = line_number('main.cpp', '// Set thread3 break point on notify_all at this line.')
self.thread3_before_lock_line = line_number('main.cpp', '// Set thread3 break point on lock at this line.') self.thread3_before_lock_line = line_number('main.cpp', '// Set thread3 break point on lock at this line.')
def test_number_of_threads(self): def test_number_of_threads(self):
"""Test number of threads.""" """Test number of threads."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# This should create a breakpoint with 1 location. # This should create a breakpoint with 1 location.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.thread3_notify_all_line, num_expected_locations=1) self, "main.cpp", self.thread3_notify_all_line, num_expected_locations=1)
# The breakpoint list should show 1 location. # The breakpoint list should show 1 location.
self.expect( self.expect(
Show All 22 Lines def test_number_of_threads(self):
self.assertTrue( self.assertTrue(
num_threads >= 13, num_threads >= 13,
'Number of expected threads and actual threads do not match.') 'Number of expected threads and actual threads do not match.')
@skipIfDarwin # rdar://33462362 @skipIfDarwin # rdar://33462362
def test_unique_stacks(self): def test_unique_stacks(self):
"""Test backtrace unique with multiple threads executing the same stack.""" """Test backtrace unique with multiple threads executing the same stack."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Set a break point on the thread3 notify all (should get hit on threads 4-13). # Set a break point on the thread3 notify all (should get hit on threads 4-13).
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.thread3_before_lock_line, num_expected_locations=1) self, "main.cpp", self.thread3_before_lock_line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/thread/state/TestThreadStates.py

Show First 20 Lines • Show All 76 Lines • ▼ Show 20 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line numbers for our breakpoints. # Find the line numbers for our breakpoints.
self.break_1 = line_number('main.cpp', '// Set first breakpoint here') self.break_1 = line_number('main.cpp', '// Set first breakpoint here')
self.break_2 = line_number('main.cpp', '// Set second breakpoint here') self.break_2 = line_number('main.cpp', '// Set second breakpoint here')
def thread_state_after_breakpoint_test(self): def thread_state_after_breakpoint_test(self):
"""Test thread state after breakpoint.""" """Test thread state after breakpoint."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# This should create a breakpoint in the main thread. # This should create a breakpoint in the main thread.
bp = lldbutil.run_break_set_by_file_and_line( bp = lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.break_1, num_expected_locations=1) self, "main.cpp", self.break_1, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 23 Lines def wait_for_running_event(self, process):
self, listener, process, [ self, listener, process, [
lldb.eStateConnected]) lldb.eStateConnected])
lldbutil.expect_state_changes( lldbutil.expect_state_changes(
self, listener, process, [ self, listener, process, [
lldb.eStateRunning]) lldb.eStateRunning])
def thread_state_after_continue_test(self): def thread_state_after_continue_test(self):
"""Test thread state after continue.""" """Test thread state after continue."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# This should create a breakpoint in the main thread. # This should create a breakpoint in the main thread.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.break_1, num_expected_locations=1) self, "main.cpp", self.break_1, num_expected_locations=1)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.break_2, num_expected_locations=1) self, "main.cpp", self.break_2, num_expected_locations=1)
Show All 25 Lines def thread_state_after_continue_test(self):
# Go back to synchronous interactions # Go back to synchronous interactions
self.dbg.SetAsync(False) self.dbg.SetAsync(False)
# Kill the process # Kill the process
self.runCmd("process kill") self.runCmd("process kill")
def thread_state_after_expression_test(self): def thread_state_after_expression_test(self):
"""Test thread state after expression.""" """Test thread state after expression."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# This should create a breakpoint in the main thread. # This should create a breakpoint in the main thread.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.break_1, num_expected_locations=1) self, "main.cpp", self.break_1, num_expected_locations=1)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.break_2, num_expected_locations=1) self, "main.cpp", self.break_2, num_expected_locations=1)
Show All 19 Lines def thread_state_after_expression_test(self):
thread.IsSuspended(), thread.IsSuspended(),
"Thread state is \'suspended\' after expression evaluation.") "Thread state is \'suspended\' after expression evaluation.")
# Let the process run to completion # Let the process run to completion
self.runCmd("process continue") self.runCmd("process continue")
def process_interrupt_test(self): def process_interrupt_test(self):
"""Test process interrupt and continue.""" """Test process interrupt and continue."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# This should create a breakpoint in the main thread. # This should create a breakpoint in the main thread.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.break_1, num_expected_locations=1) self, "main.cpp", self.break_1, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 23 Lines def process_interrupt_test(self):
# Get the inferior out of its loop # Get the inferior out of its loop
self.runCmd("expression g_test = 1") self.runCmd("expression g_test = 1")
# Run to completion # Run to completion
self.runCmd("continue") self.runCmd("continue")
def thread_states_test(self): def thread_states_test(self):
"""Test thread states (comprehensive).""" """Test thread states (comprehensive)."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# This should create a breakpoint in the main thread. # This should create a breakpoint in the main thread.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.break_1, num_expected_locations=1) self, "main.cpp", self.break_1, num_expected_locations=1)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.break_2, num_expected_locations=1) self, "main.cpp", self.break_2, num_expected_locations=1)
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/thread/step_out/TestThreadStepOut.py

Show First 20 Lines • Show All 119 Lines • ▼ Show 20 Lines def step_out_with_python(self):
desc = lldbutil.get_description(frame.GetLineEntry()) desc = lldbutil.get_description(frame.GetLineEntry())
expect = "main.cpp:%d" % self.step_out_destination expect = "main.cpp:%d" % self.step_out_destination
self.assertTrue( self.assertTrue(
expect in desc, "Expected %s but thread stopped at %s" % expect in desc, "Expected %s but thread stopped at %s" %
(expect, desc)) (expect, desc))
def step_out_test(self, step_out_func): def step_out_test(self, step_out_func):
"""Test single thread step out of a function.""" """Test single thread step out of a function."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# This should create a breakpoint in the main thread. # This should create a breakpoint in the main thread.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.breakpoint, num_expected_locations=1) self, "main.cpp", self.breakpoint, num_expected_locations=1)
# The breakpoint list should show 1 location. # The breakpoint list should show 1 location.
self.expect( self.expect(
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/thread/step_until/TestStepUntil.py

Show All 20 Lines def setUp(self):
# Find the line numbers that we will step to in main: # Find the line numbers that we will step to in main:
self.main_source = "main.c" self.main_source = "main.c"
self.less_than_two = line_number('main.c', 'Less than 2') self.less_than_two = line_number('main.c', 'Less than 2')
self.greater_than_two = line_number('main.c', 'Greater than or equal to 2.') self.greater_than_two = line_number('main.c', 'Greater than or equal to 2.')
self.back_out_in_main = line_number('main.c', 'Back out in main') self.back_out_in_main = line_number('main.c', 'Back out in main')
def do_until (self, args, until_lines, expected_linenum): def do_until (self, args, until_lines, expected_linenum):
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
main_source_spec = lldb.SBFileSpec(self.main_source) main_source_spec = lldb.SBFileSpec(self.main_source)
break_before = target.BreakpointCreateBySourceRegex( break_before = target.BreakpointCreateBySourceRegex(
'At the start', 'At the start',
main_source_spec) main_source_spec)
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/thread/thread_exit/TestThreadExit.py

Show All 22 Lines def setUp(self):
self.break_1 = line_number('main.cpp', '// Set first breakpoint here') self.break_1 = line_number('main.cpp', '// Set first breakpoint here')
self.break_2 = line_number('main.cpp', '// Set second breakpoint here') self.break_2 = line_number('main.cpp', '// Set second breakpoint here')
self.break_3 = line_number('main.cpp', '// Set third breakpoint here') self.break_3 = line_number('main.cpp', '// Set third breakpoint here')
self.break_4 = line_number('main.cpp', '// Set fourth breakpoint here') self.break_4 = line_number('main.cpp', '// Set fourth breakpoint here')
def test(self): def test(self):
"""Test thread exit handling.""" """Test thread exit handling."""
self.build(dictionary=self.getBuildFlags()) self.build(dictionary=self.getBuildFlags())
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# This should create a breakpoint with 1 location. # This should create a breakpoint with 1 location.
bp1_id = lldbutil.run_break_set_by_file_and_line( bp1_id = lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.break_1, num_expected_locations=1) self, "main.cpp", self.break_1, num_expected_locations=1)
bp2_id = lldbutil.run_break_set_by_file_and_line( bp2_id = lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.break_2, num_expected_locations=1) self, "main.cpp", self.break_2, num_expected_locations=1)
bp3_id = lldbutil.run_break_set_by_file_and_line( bp3_id = lldbutil.run_break_set_by_file_and_line(
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/thread/thread_specific_break/TestThreadSpecificBreakpoint.py

Show All 18 Linesclass ThreadSpecificBreakTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@expectedFailureAll(oslist=["windows"]) @expectedFailureAll(oslist=["windows"])
@expectedFailureAll(oslist=['ios', 'watchos', 'tvos', 'bridgeos'], archs=['armv7', 'armv7k'], bugnumber='rdar://problem/34563920') # armv7 ios problem - breakpoint with tid qualifier isn't working @expectedFailureAll(oslist=['ios', 'watchos', 'tvos', 'bridgeos'], archs=['armv7', 'armv7k'], bugnumber='rdar://problem/34563920') # armv7 ios problem - breakpoint with tid qualifier isn't working
def test_python(self): def test_python(self):
"""Test that we obey thread conditioned breakpoints.""" """Test that we obey thread conditioned breakpoints."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# This test works by setting a breakpoint in a function conditioned to stop only on # This test works by setting a breakpoint in a function conditioned to stop only on
# the main thread, and then calling this function on a secondary thread, joining, # the main thread, and then calling this function on a secondary thread, joining,
# and then calling again on the main thread. If the thread specific breakpoint works # and then calling again on the main thread. If the thread specific breakpoint works
# then it should not be hit on the secondary thread, only on the main # then it should not be hit on the secondary thread, only on the main
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/thread/thread_specific_break_plus_condition/TestThreadSpecificBpPlusCondition.py

Show All 22 Linesclass ThreadSpecificBreakPlusConditionTestCase(TestBase):
@skipIf(oslist=['windows', 'freebsd']) @skipIf(oslist=['windows', 'freebsd'])
# hits break in another thread in testrun # hits break in another thread in testrun
@expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr18522') @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr18522')
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@expectedFailureAll(oslist=['ios', 'watchos', 'tvos', 'bridgeos'], archs=['armv7', 'armv7k'], bugnumber='rdar://problem/34563348') # Two threads seem to end up with the same my_value when built for armv7. @expectedFailureAll(oslist=['ios', 'watchos', 'tvos', 'bridgeos'], archs=['armv7', 'armv7k'], bugnumber='rdar://problem/34563348') # Two threads seem to end up with the same my_value when built for armv7.
def test_python(self): def test_python(self):
"""Test that we obey thread conditioned breakpoints.""" """Test that we obey thread conditioned breakpoints."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
main_source_spec = lldb.SBFileSpec("main.cpp") main_source_spec = lldb.SBFileSpec("main.cpp")
# Set a breakpoint in the thread body, and make it active for only the # Set a breakpoint in the thread body, and make it active for only the
# first thread. # first thread.
Show All 39 Lines

packages/Python/lldbsuite/test/functionalities/tsan/basic/TestTsanBasic.py

Show All 27 Linesclass TsanBasicTestCase(TestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
self.line_malloc = line_number('main.c', '// malloc line') self.line_malloc = line_number('main.c', '// malloc line')
self.line_thread1 = line_number('main.c', '// thread1 line') self.line_thread1 = line_number('main.c', '// thread1 line')
self.line_thread2 = line_number('main.c', '// thread2 line') self.line_thread2 = line_number('main.c', '// thread2 line')
def tsan_tests(self): def tsan_tests(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.expect( self.expect(
"file " + exe, "file " + exe,
patterns=["Current executable set to .*a.out"]) patterns=["Current executable set to .*a.out"])
self.runCmd("run") self.runCmd("run")
stop_reason = self.dbg.GetSelectedTarget().process.GetSelectedThread().GetStopReason() stop_reason = self.dbg.GetSelectedTarget().process.GetSelectedThread().GetStopReason()
if stop_reason == lldb.eStopReasonExec: if stop_reason == lldb.eStopReasonExec:
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/tsan/cpp_global_location/TestTsanCPPGlobalLocation.py

Show All 24 Lines def test(self):
self.build() self.build()
self.tsan_tests() self.tsan_tests()
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
def tsan_tests(self): def tsan_tests(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.expect( self.expect(
"file " + exe, "file " + exe,
patterns=["Current executable set to .*a.out"]) patterns=["Current executable set to .*a.out"])
self.runCmd("run") self.runCmd("run")
stop_reason = self.dbg.GetSelectedTarget().process.GetSelectedThread().GetStopReason() stop_reason = self.dbg.GetSelectedTarget().process.GetSelectedThread().GetStopReason()
if stop_reason == lldb.eStopReasonExec: if stop_reason == lldb.eStopReasonExec:
Show All 28 Lines

packages/Python/lldbsuite/test/functionalities/tsan/global_location/TestTsanGlobalLocation.py

Show All 24 Lines def test(self):
self.build() self.build()
self.tsan_tests() self.tsan_tests()
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
def tsan_tests(self): def tsan_tests(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.expect( self.expect(
"file " + exe, "file " + exe,
patterns=["Current executable set to .*a.out"]) patterns=["Current executable set to .*a.out"])
self.runCmd("run") self.runCmd("run")
stop_reason = self.dbg.GetSelectedTarget().process.GetSelectedThread().GetStopReason() stop_reason = self.dbg.GetSelectedTarget().process.GetSelectedThread().GetStopReason()
if stop_reason == lldb.eStopReasonExec: if stop_reason == lldb.eStopReasonExec:
Show All 28 Lines

packages/Python/lldbsuite/test/functionalities/tsan/multiple/TestTsanMultiple.py

Show All 24 Lines def test(self):
self.build() self.build()
self.tsan_tests() self.tsan_tests()
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
def tsan_tests(self): def tsan_tests(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.expect( self.expect(
"file " + exe, "file " + exe,
patterns=["Current executable set to .*a.out"]) patterns=["Current executable set to .*a.out"])
self.runCmd("env TSAN_OPTIONS=abort_on_error=0") self.runCmd("env TSAN_OPTIONS=abort_on_error=0")
self.runCmd("run") self.runCmd("run")
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/tsan/thread_leak/TestTsanThreadLeak.py

Show All 20 Linesclass TsanThreadLeakTestCase(TestBase):
@skipIfFreeBSD # llvm.org/pr21136 runtimes not yet available by default @skipIfFreeBSD # llvm.org/pr21136 runtimes not yet available by default
@skipIfRemote @skipIfRemote
@skipUnlessThreadSanitizer @skipUnlessThreadSanitizer
def test(self): def test(self):
self.build() self.build()
self.tsan_tests() self.tsan_tests()
def tsan_tests(self): def tsan_tests(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.expect( self.expect(
"file " + exe, "file " + exe,
patterns=["Current executable set to .*a.out"]) patterns=["Current executable set to .*a.out"])
self.runCmd("run") self.runCmd("run")
stop_reason = self.dbg.GetSelectedTarget().process.GetSelectedThread().GetStopReason() stop_reason = self.dbg.GetSelectedTarget().process.GetSelectedThread().GetStopReason()
if stop_reason == lldb.eStopReasonExec: if stop_reason == lldb.eStopReasonExec:
Show All 11 Lines

packages/Python/lldbsuite/test/functionalities/tsan/thread_numbers/TestTsanThreadNumbers.py

Show All 24 Lines def test(self):
self.build() self.build()
self.tsan_tests() self.tsan_tests()
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
def tsan_tests(self): def tsan_tests(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.expect( self.expect(
"file " + exe, "file " + exe,
patterns=["Current executable set to .*a.out"]) patterns=["Current executable set to .*a.out"])
self.runCmd("run") self.runCmd("run")
stop_reason = self.dbg.GetSelectedTarget().process.GetSelectedThread().GetStopReason() stop_reason = self.dbg.GetSelectedTarget().process.GetSelectedThread().GetStopReason()
if stop_reason == lldb.eStopReasonExec: if stop_reason == lldb.eStopReasonExec:
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/tty/TestTerminal.py

Show All 29 Linesclass LaunchInTerminalTestCase(TestBase):
# This env var is only defined when the shell is running in a local mac # This env var is only defined when the shell is running in a local mac
# terminal window # terminal window
@unittest2.skipUnless( @unittest2.skipUnless(
'TERM_PROGRAM' in os.environ, 'TERM_PROGRAM' in os.environ,
"test must be run on local system") "test must be run on local system")
@no_debug_info_test @no_debug_info_test
def test_launch_in_terminal(self): def test_launch_in_terminal(self):
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
launch_info = lldb.SBLaunchInfo(["-lAF", "/tmp/"]) launch_info = lldb.SBLaunchInfo(["-lAF", "/tmp/"])
launch_info.SetLaunchFlags( launch_info.SetLaunchFlags(
lldb.eLaunchFlagLaunchInTTY | lldb.eLaunchFlagCloseTTYOnExit) lldb.eLaunchFlagLaunchInTTY | lldb.eLaunchFlagCloseTTYOnExit)
error = lldb.SBError() error = lldb.SBError()
process = target.Launch(launch_info, error) process = target.Launch(launch_info, error)
print("Error was: %s."%(error.GetCString())) print("Error was: %s."%(error.GetCString()))
self.assertTrue( self.assertTrue(
error.Success(), error.Success(),
"Make sure launch happened successfully in a terminal window") "Make sure launch happened successfully in a terminal window")
# Running in synchronous mode our process should have run and already # Running in synchronous mode our process should have run and already
# exited by the time target.Launch() returns # exited by the time target.Launch() returns
self.assertTrue(process.GetState() == lldb.eStateExited) self.assertTrue(process.GetState() == lldb.eStateExited)

packages/Python/lldbsuite/test/functionalities/ubsan/basic/TestUbsanBasic.py

Show All 21 Linesclass UbsanBasicTestCase(TestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
self.line_align = line_number('main.c', '// align line') self.line_align = line_number('main.c', '// align line')
def ubsan_tests(self): def ubsan_tests(self):
# Load the test # Load the test
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.expect( self.expect(
"file " + exe, "file " + exe,
patterns=["Current executable set to .*a.out"]) patterns=["Current executable set to .*a.out"])
self.runCmd("run") self.runCmd("run")
process = self.dbg.GetSelectedTarget().process process = self.dbg.GetSelectedTarget().process
thread = process.GetSelectedThread() thread = process.GetSelectedThread()
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/ubsan/user-expression/TestUbsanUserExpression.py

Show All 21 Linesclass UbsanUserExpressionTestCase(TestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
self.line_breakpoint = line_number('main.c', '// breakpoint line') self.line_breakpoint = line_number('main.c', '// breakpoint line')
def ubsan_tests(self): def ubsan_tests(self):
# Load the test # Load the test
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.expect( self.expect(
"file " + exe, "file " + exe,
patterns=["Current executable set to .*a.out"]) patterns=["Current executable set to .*a.out"])
self.runCmd("breakpoint set -f main.c -l %d" % self.line_breakpoint) self.runCmd("breakpoint set -f main.c -l %d" % self.line_breakpoint)
self.runCmd("run") self.runCmd("run")
Show All 11 Lines

packages/Python/lldbsuite/test/functionalities/unwind/ehframe/TestEhFrameUnwind.py

Show All 17 Linesclass EHFrameBasedUnwind(TestBase):
@skipUnlessPlatform(['linux']) @skipUnlessPlatform(['linux'])
@skipIf(archs=["aarch64", "arm", "i386", "i686"]) @skipIf(archs=["aarch64", "arm", "i386", "i686"])
def test(self): def test(self):
"""Test that we can backtrace correctly from Non ABI functions on the stack""" """Test that we can backtrace correctly from Non ABI functions on the stack"""
self.build() self.build()
self.setTearDownCleanup() self.setTearDownCleanup()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
lldbutil.run_break_set_by_symbol(self, "func") lldbutil.run_break_set_by_symbol(self, "func")
process = target.LaunchSimple( process = target.LaunchSimple(
["abc", "xyz"], None, self.get_process_working_directory()) ["abc", "xyz"], None, self.get_process_working_directory())
Show All 18 Lines

packages/Python/lldbsuite/test/functionalities/unwind/noreturn/TestNoreturnUnwind.py

Show All 19 Linesclass NoreturnUnwind(TestBase):
# clang does not preserve LR in noreturn functions, making unwinding impossible # clang does not preserve LR in noreturn functions, making unwinding impossible
@skipIf(compiler="clang", archs=['arm'], oslist=['linux']) @skipIf(compiler="clang", archs=['arm'], oslist=['linux'])
@expectedFailureAll(bugnumber="llvm.org/pr33452", triple='^mips') @expectedFailureAll(bugnumber="llvm.org/pr33452", triple='^mips')
def test(self): def test(self):
"""Test that we can backtrace correctly with 'noreturn' functions on the stack""" """Test that we can backtrace correctly with 'noreturn' functions on the stack"""
self.build() self.build()
self.setTearDownCleanup() self.setTearDownCleanup()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
process = target.LaunchSimple( process = target.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
if not process: if not process:
self.fail("SBTarget.Launch() failed") self.fail("SBTarget.Launch() failed")
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/unwind/sigtramp/TestSigtrampUnwind.py

Show All 19 Linesclass SigtrampUnwind(TestBase):
# This test could probably be adapted to run on linux/*bsd easily enough. # This test could probably be adapted to run on linux/*bsd easily enough.
@skipUnlessDarwin @skipUnlessDarwin
@expectedFailureAll(oslist=["ios", "watchos", "tvos", "bridgeos"], bugnumber="<rdar://problem/34006863>") # lldb skips 1 frame on arm64 above _sigtramp @expectedFailureAll(oslist=["ios", "watchos", "tvos", "bridgeos"], bugnumber="<rdar://problem/34006863>") # lldb skips 1 frame on arm64 above _sigtramp
def test(self): def test(self):
"""Test that we can backtrace correctly with _sigtramp on the stack""" """Test that we can backtrace correctly with _sigtramp on the stack"""
self.build() self.build()
self.setTearDownCleanup() self.setTearDownCleanup()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
lldbutil.run_break_set_by_file_and_line(self, "main.c", line_number( lldbutil.run_break_set_by_file_and_line(self, "main.c", line_number(
'main.c', '// Set breakpoint here'), num_expected_locations=1) 'main.c', '// Set breakpoint here'), num_expected_locations=1)
process = target.LaunchSimple( process = target.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/unwind/standard/TestStandardUnwind.py

Show First 20 Lines • Show All 78 Lines • ▼ Show 20 Lines def standard_unwind_tests(self):
# stepping # stepping
"pthread_once", "pthread_once",
# Uses ldxr and stxr what interferes with the software single # Uses ldxr and stxr what interferes with the software single
# stepping # stepping
] ]
else: else:
self.skipTest("No expectations for the current architecture") self.skipTest("No expectations for the current architecture")
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
target.BreakpointCreateByName("main") target.BreakpointCreateByName("main")
process = target.LaunchSimple( process = target.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
self.assertTrue(process is not None, "SBTarget.Launch() failed") self.assertTrue(process is not None, "SBTarget.Launch() failed")
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/watchpoint/hello_watchlocation/TestWatchLocation.py

Show All 40 Linesclass HelloWatchLocationTestCase(TestBase):
@expectedFailureAll(triple=re.compile('^mips')) @expectedFailureAll(triple=re.compile('^mips'))
# SystemZ also currently supports only one H/W watchpoint # SystemZ also currently supports only one H/W watchpoint
@expectedFailureAll(archs=['s390x']) @expectedFailureAll(archs=['s390x'])
@skipIfDarwin @skipIfDarwin
def test_hello_watchlocation(self): def test_hello_watchlocation(self):
"""Test watching a location with '-s size' option.""" """Test watching a location with '-s size' option."""
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, None, self.line, num_expected_locations=1, loc_exact=False) self, None, self.line, num_expected_locations=1, loc_exact=False)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/watchpoint/hello_watchpoint/TestMyFirstWatchpoint.py

Show All 34 Lines @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows") bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
@add_test_categories(["basic_process"]) @add_test_categories(["basic_process"])
def test_hello_watchpoint_using_watchpoint_set(self): def test_hello_watchpoint_using_watchpoint_set(self):
"""Test a simple sequence of watchpoint creation and watchpoint hit.""" """Test a simple sequence of watchpoint creation and watchpoint hit."""
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, None, self.line, num_expected_locations=1) self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/watchpoint/multi_watchpoint_slots/TestWatchpointMultipleSlots.py

Show All 31 Linesclass WatchpointSlotsTestCase(TestBase):
# This is a arm and aarch64 specific test case. No other architectures tested. # This is a arm and aarch64 specific test case. No other architectures tested.
@skipIf(archs=no_match(['arm', 'aarch64'])) @skipIf(archs=no_match(['arm', 'aarch64']))
def test_multiple_watchpoints_on_same_word(self): def test_multiple_watchpoints_on_same_word(self):
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Detect line number after which we are going to increment arrayName. # Detect line number after which we are going to increment arrayName.
loc_line = line_number('main.c', '// About to write byteArray') loc_line = line_number('main.c', '// About to write byteArray')
# Set a breakpoint on the line detected above. # Set a breakpoint on the line detected above.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.c", loc_line, num_expected_locations=1, loc_exact=True) self, "main.c", loc_line, num_expected_locations=1, loc_exact=True)
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/watchpoint/multiple_hits/TestMultipleHits.py

Show All 18 Linesclass MultipleHitsTestCase(TestBase):
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows") bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
@skipIf(bugnumber="llvm.org/pr30758", oslist=["linux"], archs=["arm", "aarch64"]) @skipIf(bugnumber="llvm.org/pr30758", oslist=["linux"], archs=["arm", "aarch64"])
def test(self): def test(self):
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target and target.IsValid(), VALID_TARGET) self.assertTrue(target and target.IsValid(), VALID_TARGET)
bp = target.BreakpointCreateByName("main") bp = target.BreakpointCreateByName("main")
self.assertTrue(bp and bp.IsValid(), "Breakpoint is valid") self.assertTrue(bp and bp.IsValid(), "Breakpoint is valid")
process = target.LaunchSimple(None, None, process = target.LaunchSimple(None, None,
self.get_process_working_directory()) self.get_process_working_directory())
Show All 23 Lines

packages/Python/lldbsuite/test/functionalities/watchpoint/step_over_watchpoint/TestStepOverWatchpoint.py

Show All 23 Lines @expectedFailureAll(
bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows") bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
# Read-write watchpoints not supported on SystemZ # Read-write watchpoints not supported on SystemZ
@expectedFailureAll(archs=['s390x']) @expectedFailureAll(archs=['s390x'])
@expectedFailureAll(oslist=["ios", "watchos", "tvos", "bridgeos"], bugnumber="<rdar://problem/34027183>") # watchpoint tests aren't working on arm64 @expectedFailureAll(oslist=["ios", "watchos", "tvos", "bridgeos"], bugnumber="<rdar://problem/34027183>") # watchpoint tests aren't working on arm64
@add_test_categories(["basic_process"]) @add_test_categories(["basic_process"])
def test(self): def test(self):
"""Test stepping over watchpoints.""" """Test stepping over watchpoints."""
self.build() self.build()
exe = os.path.join(os.getcwd(), 'a.out') exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, 'a.out')
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(self.target, VALID_TARGET) self.assertTrue(self.target, VALID_TARGET)
lldbutil.run_break_set_by_symbol(self, 'main') lldbutil.run_break_set_by_symbol(self, 'main')
process = target.LaunchSimple(None, None, process = target.LaunchSimple(None, None,
self.get_process_working_directory()) self.get_process_working_directory())
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/watchpoint/variable_out_of_scope/TestWatchedVarHitWhenInScope.py

Show All 36 Linesclass WatchedVariableHitWhenInScopeTestCase(TestBase):
# Test hangs due to a kernel bug, see fdfeff0f in the linux kernel for details # Test hangs due to a kernel bug, see fdfeff0f in the linux kernel for details
@skipIfTargetAndroid(api_levels=list(range(25+1)), archs=["aarch64", "arm"]) @skipIfTargetAndroid(api_levels=list(range(25+1)), archs=["aarch64", "arm"])
@unittest2.expectedFailure("rdar://problem/18685649") @unittest2.expectedFailure("rdar://problem/18685649")
def test_watched_var_should_only_hit_when_in_scope(self): def test_watched_var_should_only_hit_when_in_scope(self):
"""Test that a variable watchpoint should only hit when in scope.""" """Test that a variable watchpoint should only hit when in scope."""
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped in main. # Add a breakpoint to set a watchpoint when stopped in main.
lldbutil.run_break_set_by_symbol( lldbutil.run_break_set_by_symbol(
self, "main", num_expected_locations=-1) self, "main", num_expected_locations=-1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 35 Lines

packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/TestWatchpointCommands.py

Show All 40 Lines @expectedFailureAll(
bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows") bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
# Read-write watchpoints not supported on SystemZ # Read-write watchpoints not supported on SystemZ
@expectedFailureAll(archs=['s390x']) @expectedFailureAll(archs=['s390x'])
def test_rw_watchpoint(self): def test_rw_watchpoint(self):
"""Test read_write watchpoint and expect to stop two times.""" """Test read_write watchpoint and expect to stop two times."""
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, None, self.line, num_expected_locations=1) self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Lines @expectedFailureAll(
bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows") bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
# Read-write watchpoints not supported on SystemZ # Read-write watchpoints not supported on SystemZ
@expectedFailureAll(archs=['s390x']) @expectedFailureAll(archs=['s390x'])
def test_rw_watchpoint_delete(self): def test_rw_watchpoint_delete(self):
"""Test delete watchpoint and expect not to stop for watchpoint.""" """Test delete watchpoint and expect not to stop for watchpoint."""
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, None, self.line, num_expected_locations=1) self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 40 Lines @expectedFailureAll(
bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows") bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
# Read-write watchpoints not supported on SystemZ # Read-write watchpoints not supported on SystemZ
@expectedFailureAll(archs=['s390x']) @expectedFailureAll(archs=['s390x'])
def test_rw_watchpoint_set_ignore_count(self): def test_rw_watchpoint_set_ignore_count(self):
"""Test watchpoint ignore count and expect to not to stop at all.""" """Test watchpoint ignore count and expect to not to stop at all."""
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, None, self.line, num_expected_locations=1) self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines @expectedFailureAll(
bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows") bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
# Read-write watchpoints not supported on SystemZ # Read-write watchpoints not supported on SystemZ
@expectedFailureAll(archs=['s390x']) @expectedFailureAll(archs=['s390x'])
def test_rw_disable_after_first_stop(self): def test_rw_disable_after_first_stop(self):
"""Test read_write watchpoint but disable it after the first stop.""" """Test read_write watchpoint but disable it after the first stop."""
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, None, self.line, num_expected_locations=1) self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Lines @expectedFailureAll(
bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows") bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
# Read-write watchpoints not supported on SystemZ # Read-write watchpoints not supported on SystemZ
@expectedFailureAll(archs=['s390x']) @expectedFailureAll(archs=['s390x'])
def test_rw_disable_then_enable(self): def test_rw_disable_then_enable(self):
"""Test read_write watchpoint, disable initially, then enable it.""" """Test read_write watchpoint, disable initially, then enable it."""
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, None, self.line, num_expected_locations=1) self, None, self.line, num_expected_locations=1)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, None, self.line2, num_expected_locations=1) self, None, self.line2, num_expected_locations=1)
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/command/TestWatchpointCommandLLDB.py

Show All 39 Linesclass WatchpointLLDBCommandTestCase(TestBase):
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows") bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
def test_watchpoint_command(self): def test_watchpoint_command(self):
"""Test 'watchpoint command'.""" """Test 'watchpoint command'."""
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, None, self.line, num_expected_locations=1) self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Linesclass WatchpointLLDBCommandTestCase(TestBase):
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows") bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
def test_watchpoint_command_can_disable_a_watchpoint(self): def test_watchpoint_command_can_disable_a_watchpoint(self):
"""Test that 'watchpoint command' action can disable a watchpoint after it is triggered.""" """Test that 'watchpoint command' action can disable a watchpoint after it is triggered."""
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, None, self.line, num_expected_locations=1) self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/command/TestWatchpointCommandPython.py

Show All 40 Lines @expectedFailureAll(
oslist=["linux"], oslist=["linux"],
archs=["aarch64"], archs=["aarch64"],
bugnumber="llvm.org/pr27710") bugnumber="llvm.org/pr27710")
def test_watchpoint_command(self): def test_watchpoint_command(self):
"""Test 'watchpoint command'.""" """Test 'watchpoint command'."""
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, None, self.line, num_expected_locations=1) self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Lines @expectedFailureAll(
oslist=["linux"], oslist=["linux"],
archs=["aarch64"], archs=["aarch64"],
bugnumber="llvm.org/pr27710") bugnumber="llvm.org/pr27710")
def test_continue_in_watchpoint_command(self): def test_continue_in_watchpoint_command(self):
"""Test continue in a watchpoint command.""" """Test continue in a watchpoint command."""
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, None, self.line, num_expected_locations=1) self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 11 Lines def test_continue_in_watchpoint_command(self):
substrs=[ substrs=[
'Watchpoint created', 'Watchpoint created',
'size = 4', 'size = 4',
'type = w', 'type = w',
'%s:%d' % '%s:%d' %
(self.source, (self.source,
self.decl)]) self.decl)])
cmd_script_file = os.path.join(os.getcwd(), "watchpoint_command.py") cmd_script_file = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "watchpoint_command.py")
self.runCmd("command script import '%s'" % (cmd_script_file)) self.runCmd("command script import '%s'" % (cmd_script_file))
self.runCmd( self.runCmd(
'watchpoint command add -F watchpoint_command.watchpoint_command') 'watchpoint command add -F watchpoint_command.watchpoint_command')
# List the watchpoint command we just added. # List the watchpoint command we just added.
self.expect("watchpoint command list 1", self.expect("watchpoint command list 1",
substrs=['watchpoint_command.watchpoint_command']) substrs=['watchpoint_command.watchpoint_command'])
Show All 13 Lines

packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/condition/TestWatchpointConditionCmd.py

Show All 39 Linesclass WatchpointConditionCmdTestCase(TestBase):
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows") bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
def test_watchpoint_cond(self): def test_watchpoint_cond(self):
"""Test watchpoint condition.""" """Test watchpoint condition."""
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, None, self.line, num_expected_locations=1) self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 40 Lines

packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_disable/TestWatchpointDisable.py

Show All 31 Lines def test_disable_enable_works (self):
self.build() self.build()
self.do_test(True) self.do_test(True)
def do_test(self, test_enable): def do_test(self, test_enable):
"""Set a watchpoint, disable it and make sure it doesn't get hit.""" """Set a watchpoint, disable it and make sure it doesn't get hit."""
exe = 'a.out' exe = 'a.out'
exe = os.path.join(os.getcwd(), exe) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, exe)
main_file_spec = lldb.SBFileSpec("main.c") main_file_spec = lldb.SBFileSpec("main.c")
# Create a target by the debugger. # Create a target by the debugger.
self.target = self.dbg.CreateTarget(exe) self.target = self.dbg.CreateTarget(exe)
self.assertTrue(self.target, VALID_TARGET) self.assertTrue(self.target, VALID_TARGET)
cwd = os.getcwd() cwd = os.getcwd()
Show All 37 Lines

packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_events/TestWatchpointEvents.py

Show All 27 Lines @expectedFailureAll(
bugnumber="llvm.org/pr27710") bugnumber="llvm.org/pr27710")
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows") bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
def test_with_python_api(self): def test_with_python_api(self):
"""Test that adding, deleting and modifying watchpoints sends the appropriate events.""" """Test that adding, deleting and modifying watchpoints sends the appropriate events."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
self.main_source_spec = lldb.SBFileSpec(self.main_source) self.main_source_spec = lldb.SBFileSpec(self.main_source)
break_in_main = target.BreakpointCreateBySourceRegex( break_in_main = target.BreakpointCreateBySourceRegex(
'// Put a breakpoint here.', self.main_source_spec) '// Put a breakpoint here.', self.main_source_spec)
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_on_vectors/TestValueOfVectorVariable.py

Show All 30 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
# Our simple source filename. # Our simple source filename.
self.source = 'main.c' self.source = 'main.c'
self.exe_name = 'a.out' self.exe_name = 'a.out'
self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name} self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
def value_of_vector_variable_with_watchpoint_set(self): def value_of_vector_variable_with_watchpoint_set(self):
"""Test verify displayed value of vector variable""" """Test verify displayed value of vector variable"""
exe = os.path.join(os.getcwd(), 'a.out') exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, 'a.out')
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Set break to get a frame # Set break to get a frame
self.runCmd("b main") self.runCmd("b main")
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
# Value of a vector variable should be displayed correctly # Value of a vector variable should be displayed correctly
self.expect( self.expect(
"watchpoint set variable global_vector", "watchpoint set variable global_vector",
WATCHPOINT_CREATED, WATCHPOINT_CREATED,
substrs=['new value: (1, 2, 3, 4)']) substrs=['new value: (1, 2, 3, 4)'])

packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_set_command/TestWatchLocationWithWatchSet.py

Show All 38 Linesclass WatchLocationUsingWatchpointSetTestCase(TestBase):
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows") bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
def test_watchlocation_using_watchpoint_set(self): def test_watchlocation_using_watchpoint_set(self):
"""Test watching a location with 'watchpoint set expression -w write -s size' option.""" """Test watching a location with 'watchpoint set expression -w write -s size' option."""
self.build() self.build()
self.setTearDownCleanup() self.setTearDownCleanup()
exe = os.path.join(os.getcwd(), 'a.out') exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, 'a.out')
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, None, self.line, num_expected_locations=1) self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_set_command/TestWatchpointSetErrorCases.py

Show All 27 Lines def setUp(self):
# Build dictionary to have unique executable names for each test # Build dictionary to have unique executable names for each test
# method. # method.
def test_error_cases_with_watchpoint_set(self): def test_error_cases_with_watchpoint_set(self):
"""Test error cases with the 'watchpoint set' command.""" """Test error cases with the 'watchpoint set' command."""
self.build() self.build()
self.setTearDownCleanup() self.setTearDownCleanup()
exe = os.path.join(os.getcwd(), 'a.out') exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, 'a.out')
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, None, self.line, num_expected_locations=1) self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 30 Lines

packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_size/TestWatchpointSizes.py

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Linesclass WatchpointSizeTestCase(TestBase):
def test_four_byte_watchpoints_with_dword_selection(self): def test_four_byte_watchpoints_with_dword_selection(self):
"""Test to selectively watch two double words in an 8-byte dword array.""" """Test to selectively watch two double words in an 8-byte dword array."""
self.run_watchpoint_size_test('dwordArray', 2, '4') self.run_watchpoint_size_test('dwordArray', 2, '4')
def run_watchpoint_size_test(self, arrayName, array_size, watchsize): def run_watchpoint_size_test(self, arrayName, array_size, watchsize):
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Detect line number after which we are going to increment arrayName. # Detect line number after which we are going to increment arrayName.
loc_line = line_number('main.c', '// About to write ' + arrayName) loc_line = line_number('main.c', '// About to write ' + arrayName)
# Set a breakpoint on the line detected above. # Set a breakpoint on the line detected above.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.c", loc_line, num_expected_locations=1, loc_exact=True) self, "main.c", loc_line, num_expected_locations=1, loc_exact=True)
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/c/anonymous/TestAnonymous.py

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Linesclass AnonymousTestCase(TestBase):
def test_child_by_name(self): def test_child_by_name(self):
self.build() self.build()
# Set debugger into synchronous mode # Set debugger into synchronous mode
self.dbg.SetAsync(False) self.dbg.SetAsync(False)
# Create a target # Create a target
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
break_in_main = target.BreakpointCreateBySourceRegex( break_in_main = target.BreakpointCreateBySourceRegex(
'// Set breakpoint 2 here.', lldb.SBFileSpec(self.source)) '// Set breakpoint 2 here.', lldb.SBFileSpec(self.source))
self.assertTrue(break_in_main, VALID_BREAKPOINT) self.assertTrue(break_in_main, VALID_BREAKPOINT)
process = target.LaunchSimple( process = target.LaunchSimple(
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines def setUp(self):
self.line2 = line_number(self.source, '// Set breakpoint 2 here.') self.line2 = line_number(self.source, '// Set breakpoint 2 here.')
def common_setup(self, line): def common_setup(self, line):
# Set debugger into synchronous mode # Set debugger into synchronous mode
self.dbg.SetAsync(False) self.dbg.SetAsync(False)
# Create a target # Create a target
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Set breakpoints inside and outside methods that take pointers to the # Set breakpoints inside and outside methods that take pointers to the
# containing struct. # containing struct.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, self.source, line, num_expected_locations=1, loc_exact=True) self, self.source, line, num_expected_locations=1, loc_exact=True)
Show All 13 Lines

packages/Python/lldbsuite/test/lang/c/array_types/TestArrayTypes.py

Show All 18 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break inside main(). # Find the line number to break inside main().
self.line = line_number('main.c', '// Set break point at this line.') self.line = line_number('main.c', '// Set break point at this line.')
def test_and_run_command(self): def test_and_run_command(self):
"""Test 'frame variable var_name' on some variables with array types.""" """Test 'frame variable var_name' on some variables with array types."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.c", self.line, num_expected_locations=1, loc_exact=False) self, "main.c", self.line, num_expected_locations=1, loc_exact=False)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
# The test suite sometimes shows that the process has exited without stopping. # The test suite sometimes shows that the process has exited without stopping.
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines def test_and_run_command(self):
"frame variable --show-types long_6", "frame variable --show-types long_6",
VARIABLES_DISPLAYED_CORRECTLY, VARIABLES_DISPLAYED_CORRECTLY,
startstr='(long [6])') startstr='(long [6])')
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_and_python_api(self): def test_and_python_api(self):
"""Use Python APIs to inspect variables with array types.""" """Use Python APIs to inspect variables with array types."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
breakpoint = target.BreakpointCreateByLocation("main.c", self.line) breakpoint = target.BreakpointCreateByLocation("main.c", self.line)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
# Sanity check the print representation of breakpoint. # Sanity check the print representation of breakpoint.
▲ Show 20 Lines • Show All 132 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/c/bitfields/TestBitfields.py

Show All 21 Lines def setUp(self):
self.line = line_number('main.c', '// Set break point at this line.') self.line = line_number('main.c', '// Set break point at this line.')
# BitFields exhibit crashes in record layout on Windows # BitFields exhibit crashes in record layout on Windows
# (http://llvm.org/pr21800) # (http://llvm.org/pr21800)
@skipIfWindows @skipIfWindows
def test_and_run_command(self): def test_and_run_command(self):
"""Test 'frame variable ...' on a variable with bitfields.""" """Test 'frame variable ...' on a variable with bitfields."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the main. # Break inside the main.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.c", self.line, num_expected_locations=1, loc_exact=True) self, "main.c", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
▲ Show 20 Lines • Show All 79 Lines • ▼ Show 20 Linesclass BitfieldsTestCase(TestBase):
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
# BitFields exhibit crashes in record layout on Windows # BitFields exhibit crashes in record layout on Windows
# (http://llvm.org/pr21800) # (http://llvm.org/pr21800)
@skipIfWindows @skipIfWindows
def test_and_python_api(self): def test_and_python_api(self):
"""Use Python APIs to inspect a bitfields variable.""" """Use Python APIs to inspect a bitfields variable."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
breakpoint = target.BreakpointCreateByLocation("main.c", self.line) breakpoint = target.BreakpointCreateByLocation("main.c", self.line)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
process = target.LaunchSimple( process = target.LaunchSimple(
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/c/blocks/TestBlocks.py

Show All 20 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line numbers to break at. # Find the line numbers to break at.
self.lines.append(line_number('main.c', '// Set breakpoint 0 here.')) self.lines.append(line_number('main.c', '// Set breakpoint 0 here.'))
self.lines.append(line_number('main.c', '// Set breakpoint 1 here.')) self.lines.append(line_number('main.c', '// Set breakpoint 1 here.'))
def launch_common(self): def launch_common(self):
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.is_started = False self.is_started = False
# Break inside the foo function which takes a bar_ptr argument. # Break inside the foo function which takes a bar_ptr argument.
for line in self.lines: for line in self.lines:
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.c", line, num_expected_locations=1, loc_exact=True) self, "main.c", line, num_expected_locations=1, loc_exact=True)
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/c/conflicting-symbol/TestConflictingSymbol.py

Show All 19 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
self.One_line = line_number('One/One.c', '// break here') self.One_line = line_number('One/One.c', '// break here')
self.Two_line = line_number('Two/Two.c', '// break here') self.Two_line = line_number('Two/Two.c', '// break here')
self.main_line = line_number('main.c', '// break here') self.main_line = line_number('main.c', '// break here')
def test_conflicting_symbols(self): def test_conflicting_symbols(self):
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget("a.out") target = self.dbg.CreateTarget("a.out")
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Register our shared libraries for remote targets so they get # Register our shared libraries for remote targets so they get
# automatically uploaded # automatically uploaded
environment = self.registerSharedLibrariesWithTarget( environment = self.registerSharedLibrariesWithTarget(
target, ['One', 'Two']) target, ['One', 'Two'])
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Lines def test_conflicting_symbols(self):
"An error should be printed when symbols can't be ordered", "An error should be printed when symbols can't be ordered",
error=True, error=True,
substrs=[ substrs=[
"Multiple internal symbols"]) "Multiple internal symbols"])
@expectedFailureAll(bugnumber="llvm.org/pr35043") @expectedFailureAll(bugnumber="llvm.org/pr35043")
def test_shadowed(self): def test_shadowed(self):
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget("a.out") target = self.dbg.CreateTarget("a.out")
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Register our shared libraries for remote targets so they get # Register our shared libraries for remote targets so they get
# automatically uploaded # automatically uploaded
environment = self.registerSharedLibrariesWithTarget( environment = self.registerSharedLibrariesWithTarget(
target, ['One', 'Two']) target, ['One', 'Two'])
Show All 16 Lines

packages/Python/lldbsuite/test/lang/c/const_variables/TestConstVariables.py

Show All 32 Lines @expectedFailureAll(
'aarch64'], 'aarch64'],
bugnumber="llvm.org/pr27883") bugnumber="llvm.org/pr27883")
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr24489: Name lookup not working correctly on Windows") bugnumber="llvm.org/pr24489: Name lookup not working correctly on Windows")
def test_and_run_command(self): def test_and_run_command(self):
"""Test interpreted and JITted expressions on constant values.""" """Test interpreted and JITted expressions on constant values."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the main. # Break inside the main.
lldbutil.run_break_set_by_symbol( lldbutil.run_break_set_by_symbol(
self, "main", num_expected_locations=1) self, "main", num_expected_locations=1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 27 Lines

packages/Python/lldbsuite/test/lang/c/enum_types/TestEnumTypes.py

Show All 18 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break inside main(). # Find the line number to break inside main().
self.line = line_number('main.c', '// Set break point at this line.') self.line = line_number('main.c', '// Set break point at this line.')
def test(self): def test(self):
"""Test 'image lookup -t days' and check for correct display and enum value printing.""" """Test 'image lookup -t days' and check for correct display and enum value printing."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the main. # Break inside the main.
bkpt_id = lldbutil.run_break_set_by_file_and_line( bkpt_id = lldbutil.run_break_set_by_file_and_line(
self, "main.c", self.line, num_expected_locations=1, loc_exact=True) self, "main.c", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/c/find_struct_type/TestFindStructTypes.py

Show All 27 Lines def test_find_types_struct_type(self):
self.do_test() self.do_test()
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
def do_test(self): def do_test(self):
"""Make sure FindTypes actually finds 'struct typename' not just 'typename'.""" """Make sure FindTypes actually finds 'struct typename' not just 'typename'."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Make sure this works with struct # Make sure this works with struct
type_list = target.FindTypes("struct mytype") type_list = target.FindTypes("struct mytype")
self.assertEqual(type_list.GetSize(), 1, "Found one instance of the type with struct") self.assertEqual(type_list.GetSize(), 1, "Found one instance of the type with struct")
Show All 23 Lines

packages/Python/lldbsuite/test/lang/c/forward/TestForwardDeclaration.py

Show All 11 Lines
class ForwardDeclarationTestCase(TestBase): class ForwardDeclarationTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def test_and_run_command(self): def test_and_run_command(self):
"""Display *bar_ptr when stopped on a function with forward declaration of struct bar.""" """Display *bar_ptr when stopped on a function with forward declaration of struct bar."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the foo function which takes a bar_ptr argument. # Break inside the foo function which takes a bar_ptr argument.
lldbutil.run_break_set_by_symbol( lldbutil.run_break_set_by_symbol(
self, "foo", num_expected_locations=1, sym_exact=True) self, "foo", num_expected_locations=1, sym_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 27 Lines

packages/Python/lldbsuite/test/lang/c/function_types/TestFunctionTypes.py

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 Lines def test_pointers(self):
self.expect("expr (int (*)(const char*, ...))printf", self.expect("expr (int (*)(const char*, ...))printf",
substrs=['(int (*)(const char *, ...)) $1 = '], substrs=['(int (*)(const char *, ...)) $1 = '],
patterns=regexps) patterns=regexps)
self.expect("expr $1(\"Hello world\\n\")", self.expect("expr $1(\"Hello world\\n\")",
startstr='(int) $2 = 12') startstr='(int) $2 = 12')
def runToBreakpoint(self): def runToBreakpoint(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the main. # Break inside the main.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.c", self.line, num_expected_locations=1, loc_exact=True) self, "main.c", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', substrs=['stopped',
'stop reason = breakpoint']) 'stop reason = breakpoint'])
# 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'])

packages/Python/lldbsuite/test/lang/c/modules/TestCModules.py

Show All 22 Lines @expectedFailureAll(
oslist=["linux"], oslist=["linux"],
bugnumber="http://llvm.org/pr23456 'fopen' has unknown return type") bugnumber="http://llvm.org/pr23456 'fopen' has unknown return type")
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr24489: Name lookup not working correctly on Windows") bugnumber="llvm.org/pr24489: Name lookup not working correctly on Windows")
@skipIf(macos_version=["<", "10.12"]) @skipIf(macos_version=["<", "10.12"])
def test_expr(self): def test_expr(self):
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the foo function which takes a bar_ptr argument. # Break inside the foo function which takes a bar_ptr argument.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.c", self.line, num_expected_locations=1, loc_exact=True) self, "main.c", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/c/register_variables/TestRegisterVariables.py

Show First 20 Lines • Show All 108 Lines • ▼ Show 20 Lines def test_and_run_command(self):
# This test now ensures that each probable # This test now ensures that each probable
# register variable location is actually a register, and # register variable location is actually a register, and
# if so, whether we can print out the variable there. # if so, whether we can print out the variable there.
# It only requires one of them to be handled in a non-error # It only requires one of them to be handled in a non-error
# way. # way.
register_variables_count = 0 register_variables_count = 0
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the main. # Break inside the main.
lldbutil.run_break_set_by_source_regexp( lldbutil.run_break_set_by_source_regexp(
self, "break", num_expected_locations=3) self, "break", num_expected_locations=3)
#################### ####################
# First breakpoint # First breakpoint
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/c/set_values/TestSetValues.py

Show All 22 Lines def setUp(self):
self.line2 = line_number('main.c', '// Set break point #2.') self.line2 = line_number('main.c', '// Set break point #2.')
self.line3 = line_number('main.c', '// Set break point #3.') self.line3 = line_number('main.c', '// Set break point #3.')
self.line4 = line_number('main.c', '// Set break point #4.') self.line4 = line_number('main.c', '// Set break point #4.')
self.line5 = line_number('main.c', '// Set break point #5.') self.line5 = line_number('main.c', '// Set break point #5.')
def test(self): def test(self):
"""Test settings and readings of program variables.""" """Test settings and readings of program variables."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Set breakpoints on several places to set program variables. # Set breakpoints on several places to set program variables.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.c", self.line1, num_expected_locations=1, loc_exact=True) self, "main.c", self.line1, num_expected_locations=1, loc_exact=True)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.c", self.line2, num_expected_locations=1, loc_exact=True) self, "main.c", self.line2, num_expected_locations=1, loc_exact=True)
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/c/step-target/TestStepTarget.py

Show All 18 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
# Find the line numbers that we will step to in main: # Find the line numbers that we will step to in main:
self.main_source = "main.c" self.main_source = "main.c"
self.end_line = line_number(self.main_source, "All done") self.end_line = line_number(self.main_source, "All done")
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def get_to_start(self): def get_to_start(self):
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
self.main_source_spec = lldb.SBFileSpec(self.main_source) self.main_source_spec = lldb.SBFileSpec(self.main_source)
break_in_main = target.BreakpointCreateBySourceRegex( break_in_main = target.BreakpointCreateBySourceRegex(
'Break here to try targetted stepping', self.main_source_spec) 'Break here to try targetted stepping', self.main_source_spec)
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/c/stepping/TestStepAndBreakpoints.py

Show All 22 Linesclass TestCStepping(TestBase):
@add_test_categories(['pyapi', 'basic_process']) @add_test_categories(['pyapi', 'basic_process'])
@expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr17932') @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr17932')
@expectedFailureAll(oslist=["linux"], bugnumber="llvm.org/pr14437") @expectedFailureAll(oslist=["linux"], bugnumber="llvm.org/pr14437")
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24777") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24777")
def test_and_python_api(self): def test_and_python_api(self):
"""Test stepping over vrs. hitting breakpoints & subsequent stepping in various forms.""" """Test stepping over vrs. hitting breakpoints & subsequent stepping in various forms."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
self.main_source_spec = lldb.SBFileSpec(self.main_source) self.main_source_spec = lldb.SBFileSpec(self.main_source)
breakpoints_to_disable = [] breakpoints_to_disable = []
▲ Show 20 Lines • Show All 259 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/c/stepping/TestThreadStepping.py

Show All 28 Lines def setUp(self):
self.line3 = line_number( self.line3 = line_number(
'main.c', '// thread step-out while stopped at "c(2)"') 'main.c', '// thread step-out while stopped at "c(2)"')
self.line4 = line_number( self.line4 = line_number(
'main.c', '// frame select 1, thread step-out while stopped at "c(3)"') 'main.c', '// frame select 1, thread step-out while stopped at "c(3)"')
def test_step_out_with_run_command(self): def test_step_out_with_run_command(self):
"""Exercise thread step-out and frame select followed by thread step-out.""" """Exercise thread step-out and frame select followed by thread step-out."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Create a breakpoint inside function 'c'. # Create a breakpoint inside function 'c'.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.c", self.line1, num_expected_locations=1, loc_exact=True) self, "main.c", self.line1, num_expected_locations=1, loc_exact=True)
# Now run the program. # Now run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/c/tls_globals/TestTlsGlobals.py

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Linesclass TlsGlobalTestCase(TestBase):
@skipIfWindows @skipIfWindows
@expectedFailureAll( @expectedFailureAll(
bugnumber="llvm.org/pr28392", bugnumber="llvm.org/pr28392",
oslist=no_match( oslist=no_match(
lldbplatformutil.getDarwinOSTriples())) lldbplatformutil.getDarwinOSTriples()))
def test(self): def test(self):
"""Test thread-local storage.""" """Test thread-local storage."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
if self.platformIsDarwin(): if self.platformIsDarwin():
self.registerSharedLibrariesWithTarget(target, ['liba.dylib']) self.registerSharedLibrariesWithTarget(target, ['liba.dylib'])
line1 = line_number('main.c', '// thread breakpoint') line1 = line_number('main.c', '// thread breakpoint')
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.c", line1, num_expected_locations=1, loc_exact=True) self, "main.c", line1, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 38 Lines

packages/Python/lldbsuite/test/lang/c/typedef/Testtypedef.py

Show All 20 Lines @expectedFailureAll(
bugnumber="llvm.org/pr25626 expectedFailureClang fails on FreeBSD") bugnumber="llvm.org/pr25626 expectedFailureClang fails on FreeBSD")
def test_typedef(self): def test_typedef(self):
"""Test 'image lookup -t a' and check for correct display at different scopes.""" """Test 'image lookup -t a' and check for correct display at different scopes."""
self.build() self.build()
self.image_lookup_for_multiple_typedefs() self.image_lookup_for_multiple_typedefs()
def image_lookup_for_multiple_typedefs(self): def image_lookup_for_multiple_typedefs(self):
"""Test 'image lookup -t a' at different scopes and check for correct display.""" """Test 'image lookup -t a' at different scopes and check for correct display."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
typearray = ( typearray = (
"float", "float",
"float", "float",
"char", "char",
"double *", "double *",
"float", "float",
"int", "int",
Show All 18 Lines

packages/Python/lldbsuite/test/lang/c/unions/TestUnionMembers.py

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines def _load_exe(self):
cwd = os.getcwd() cwd = os.getcwd()
src_file = os.path.join(cwd, "main.c") src_file = os.path.join(cwd, "main.c")
self.src_file_spec = lldb.SBFileSpec(src_file) self.src_file_spec = lldb.SBFileSpec(src_file)
self.assertTrue(self.src_file_spec.IsValid(), "breakpoint file") self.assertTrue(self.src_file_spec.IsValid(), "breakpoint file")
# Get the path of the executable # Get the path of the executable
exe_path = os.path.join(cwd, 'a.out') exe_path = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], 'a.out')
# Load the executable # Load the executable
self.target = self.dbg.CreateTarget(exe_path) self.target = self.dbg.CreateTarget(exe_path)
self.assertTrue(self.target.IsValid(), VALID_TARGET) self.assertTrue(self.target.IsValid(), VALID_TARGET)

packages/Python/lldbsuite/test/lang/cpp/breakpoint-commands/TestCPPBreakpointCommands.py

Show All 29 Lines def make_breakpoint(self, name, type, expected_num_locations):
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."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# Create a target from the debugger. # Create a target from the debugger.
self.target = self.dbg.CreateTarget(exe) self.target = self.dbg.CreateTarget(exe)
self.assertTrue(self.target, VALID_TARGET) self.assertTrue(self.target, VALID_TARGET)
self.a_out_module = lldb.SBFileSpecList() self.a_out_module = lldb.SBFileSpecList()
self.a_out_module.Append(lldb.SBFileSpec(exe)) self.a_out_module.Append(lldb.SBFileSpec(exe))
Show All 40 Lines

packages/Python/lldbsuite/test/lang/cpp/char1632_t/TestChar1632T.py

Show All 26 Lines def setUp(self):
line_number(self.source, '// breakpoint2')] line_number(self.source, '// breakpoint2')]
@expectedFailureAll( @expectedFailureAll(
compiler="icc", compiler="icc",
bugnumber="ICC (13.1) does not emit the DW_TAG_base_type for char16_t and char32_t.") bugnumber="ICC (13.1) does not emit the DW_TAG_base_type for char16_t and char32_t.")
def test(self): def test(self):
"""Test that the C++11 support for char16_t and char32_t works correctly.""" """Test that the C++11 support for char16_t and char32_t works correctly."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Set breakpoints # Set breakpoints
for line in self.lines: for line in self.lines:
lldbutil.run_break_set_by_file_and_line(self, "main.cpp", line) lldbutil.run_break_set_by_file_and_line(self, "main.cpp", line)
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/cpp/class_static/TestStaticVariables.py

Show First 20 Lines • Show All 61 Lines • ▼ Show 20 Linesclass StaticVariableTestCase(TestBase):
@expectedFailureAll( @expectedFailureAll(
compiler=["clang"], compiler=["clang"],
compiler_version=["<", "3.9"], compiler_version=["<", "3.9"],
bugnumber='llvm.org/pr20550') bugnumber='llvm.org/pr20550')
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_with_python_api(self): def test_with_python_api(self):
"""Test Python APIs on file and class static variables.""" """Test Python APIs on file and class static variables."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line) breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
# Now launch the process, and do not stop at entry point. # Now launch the process, and do not stop at entry point.
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/cpp/class_types/TestClassTypes.py

Show All 18 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break for main.cpp. # Find the line number to break for main.cpp.
self.line = line_number('main.cpp', '// Set break point at this line.') self.line = line_number('main.cpp', '// Set break point at this line.')
def test_with_run_command(self): def test_with_run_command(self):
"""Test 'frame variable this' when stopped on a class constructor.""" """Test 'frame variable this' when stopped on a class constructor."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break on the ctor function of class C. # Break on the ctor function of class C.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.line, num_expected_locations=-1) self, "main.cpp", self.line, num_expected_locations=-1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 20 Lines def test_with_run_command(self):
substrs=[ substrs=[
'C *', 'C *',
' this = ']) ' this = '])
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_with_python_api(self): def test_with_python_api(self):
"""Use Python APIs to create a breakpoint by (filespec, line).""" """Use Python APIs to create a breakpoint by (filespec, line)."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
filespec = target.GetExecutable() filespec = target.GetExecutable()
self.assertTrue(filespec, VALID_FILESPEC) self.assertTrue(filespec, VALID_FILESPEC)
fsDir = os.path.normpath(filespec.GetDirectory()) fsDir = os.path.normpath(filespec.GetDirectory())
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines def test_with_python_api(self):
# We should be stopped on the breakpoint with a hit count of 1. # We should be stopped on the breakpoint with a hit count of 1.
self.assertTrue(breakpoint.GetHitCount() == 1, BREAKPOINT_HIT_ONCE) self.assertTrue(breakpoint.GetHitCount() == 1, BREAKPOINT_HIT_ONCE)
process.Continue() process.Continue()
def test_with_expr_parser(self): def test_with_expr_parser(self):
"""Test 'frame variable this' and 'expr this' when stopped inside a constructor.""" """Test 'frame variable this' and 'expr this' when stopped inside a constructor."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# rdar://problem/8516141 # rdar://problem/8516141
# Is this a case of clang (116.1) generating bad debug info? # Is this a case of clang (116.1) generating bad debug info?
# #
# Break on the ctor function of class C. # Break on the ctor function of class C.
# self.expect("breakpoint set -M C", BREAKPOINT_CREATED, # self.expect("breakpoint set -M C", BREAKPOINT_CREATED,
# startstr = "Breakpoint created: 1: name = 'C'") # startstr = "Breakpoint created: 1: name = 'C'")
Show All 40 Lines def test_with_expr_parser(self):
# #
# Verify that expr this->m_c_int behaves correctly. # Verify that expr this->m_c_int behaves correctly.
self.expect("expression this->m_c_int", VARIABLES_DISPLAYED_CORRECTLY, self.expect("expression this->m_c_int", VARIABLES_DISPLAYED_CORRECTLY,
patterns=['\(int\) \$[0-9]+ = 66']) patterns=['\(int\) \$[0-9]+ = 66'])
def test_with_constructor_name(self): def test_with_constructor_name(self):
"""Test 'frame variable this' and 'expr this' when stopped inside a constructor.""" """Test 'frame variable this' and 'expr this' when stopped inside a constructor."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
filespec = target.GetExecutable() filespec = target.GetExecutable()
self.assertTrue(filespec, VALID_FILESPEC) self.assertTrue(filespec, VALID_FILESPEC)
fsDir = os.path.normpath(filespec.GetDirectory()) fsDir = os.path.normpath(filespec.GetDirectory())
Show All 37 Lines

packages/Python/lldbsuite/test/lang/cpp/class_types/TestClassTypesDisassembly.py

Show First 20 Lines • Show All 72 Lines • ▼ Show 20 Linesclass IterateFrameAndDisassembleTestCase(TestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break for main.cpp. # Find the line number to break for main.cpp.
self.line = line_number('main.cpp', '// Set break point at this line.') self.line = line_number('main.cpp', '// Set break point at this line.')
def breakOnCtor(self): def breakOnCtor(self):
"""Setup/run the program so it stops on C's constructor.""" """Setup/run the program so it stops on C's constructor."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break on the ctor function of class C. # Break on the ctor function of class C.
bpno = lldbutil.run_break_set_by_file_and_line( bpno = lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.line, num_expected_locations=-1) self, "main.cpp", self.line, num_expected_locations=-1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 11 Lines

packages/Python/lldbsuite/test/lang/cpp/diamond/TestDiamond.py

""" """
Tests that bool types work Tests that bool types work
""" """
import lldb import lldb
from lldbsuite.test.lldbtest import * from lldbsuite.test.lldbtest import *
import lldbsuite.test.lldbutil as lldbutil import lldbsuite.test.lldbutil as lldbutil
class CPPTestDiamondInheritance(TestBase): class CPPTestDiamondInheritance(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def test_with_run_command(self): def test_with_run_command(self):
"""Test that virtual base classes work in when SBValue objects are used to explore the variable value""" """Test that virtual base classes work in when SBValue objects are used to explore the variable value"""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
self.set_breakpoint(line_number('main.cpp', '// breakpoint 1')) self.set_breakpoint(line_number('main.cpp', '// breakpoint 1'))
self.set_breakpoint(line_number('main.cpp', '// breakpoint 2')) self.set_breakpoint(line_number('main.cpp', '// breakpoint 2'))
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 27 Lines

packages/Python/lldbsuite/test/lang/cpp/dynamic-value/TestCppValueCast.py

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines def setUp(self):
self.d_virtual = { self.d_virtual = {
'CXX_SOURCES': self.source, 'CXX_SOURCES': self.source,
'EXE': self.exe_name, 'EXE': self.exe_name,
'CFLAGS_EXTRAS': '-DDO_VIRTUAL_INHERITANCE'} 'CFLAGS_EXTRAS': '-DDO_VIRTUAL_INHERITANCE'}
self.d_regular = {'CXX_SOURCES': self.source, 'EXE': self.exe_name} self.d_regular = {'CXX_SOURCES': self.source, 'EXE': self.exe_name}
def do_sbvalue_cast(self, exe_name): def do_sbvalue_cast(self, exe_name):
"""Test SBValue::Cast(SBType) API for C++ types.""" """Test SBValue::Cast(SBType) API for C++ types."""
exe = os.path.join(os.getcwd(), exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, exe_name)
# Create a target from the debugger. # Create a target from the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Set up our breakpoints: # Set up our breakpoints:
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/cpp/dynamic-value/TestDynamicValue.py

Show All 31 Lines def setUp(self):
self.main_second_call_line = line_number( self.main_second_call_line = line_number(
'pass-to-base.cpp', '// Break here and get real address of reallyA.') 'pass-to-base.cpp', '// Break here and get real address of reallyA.')
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24663") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24663")
def test_get_dynamic_vals(self): def test_get_dynamic_vals(self):
"""Test fetching C++ dynamic values from pointers & references.""" """Test fetching C++ dynamic values from pointers & references."""
self.build(dictionary=self.getBuildFlags()) self.build(dictionary=self.getBuildFlags())
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# Create a target from the debugger. # Create a target from the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Set up our breakpoints: # Set up our breakpoints:
▲ Show 20 Lines • Show All 205 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/cpp/enum_types/TestCPP11EnumTypes.py

Show First 20 Lines • Show All 72 Lines • ▼ Show 20 Linesclass CPP11EnumTypesTestCase(TestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break inside main(). # Find the line number to break inside main().
self.line = line_number('main.cpp', '// Set break point at this line.') self.line = line_number('main.cpp', '// Set break point at this line.')
def image_lookup_for_enum_type(self): def image_lookup_for_enum_type(self):
"""Test C++11 enumeration class types.""" """Test C++11 enumeration class types."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the main. # Break inside the main.
bkpt_id = lldbutil.run_break_set_by_file_and_line( bkpt_id = lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/cpp/exceptions/TestCPPExceptionBreakpoints.py

Show All 24 Lines def setUp(self):
self.source, '// This is the line you should stop at for catch') self.source, '// This is the line you should stop at for catch')
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr24538, clang-cl does not support throw or catch") bugnumber="llvm.org/pr24538, clang-cl does not support throw or catch")
def test(self): def test(self):
"""Test lldb exception breakpoint command for CPP.""" """Test lldb exception breakpoint command for CPP."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# Create a target from the debugger. # Create a target from the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
exception_bkpt = target.BreakpointCreateForException( exception_bkpt = target.BreakpointCreateForException(
lldb.eLanguageTypeC_plus_plus, True, True) lldb.eLanguageTypeC_plus_plus, True, True)
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/cpp/inlines/TestInlines.py

Show All 33 Lines def test(self):
VARIABLES_DISPLAYED_CORRECTLY, VARIABLES_DISPLAYED_CORRECTLY,
startstr='(int) inner_input =') startstr='(int) inner_input =')
# Check that 'expr' finds a variable # Check that 'expr' finds a variable
self.expect("expr inner_input", VARIABLES_DISPLAYED_CORRECTLY, self.expect("expr inner_input", VARIABLES_DISPLAYED_CORRECTLY,
startstr='(int) $0 =') startstr='(int) $0 =')
def runToBreakpoint(self): def runToBreakpoint(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the main. # Break inside the main.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, self,
"inlines.cpp", "inlines.cpp",
self.line, self.line,
num_expected_locations=2, num_expected_locations=2,
Show All 12 Lines

packages/Python/lldbsuite/test/lang/cpp/namespace/TestNamespace.py

Show All 25 Lines def test_breakpoints_func_auto(self):
names = [ names = [
"func()", "func()",
"func(int)", "func(int)",
"A::B::func()", "A::B::func()",
"A::func()", "A::func()",
"A::func(int)"] "A::func(int)"]
# Create a target by the debugger. # Create a target by the debugger.
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
module_list = lldb.SBFileSpecList() module_list = lldb.SBFileSpecList()
module_list.Append(lldb.SBFileSpec(exe, False)) module_list.Append(lldb.SBFileSpec(exe, False))
cu_list = lldb.SBFileSpecList() cu_list = lldb.SBFileSpecList()
# Set a breakpoint by name "func" which should pick up all functions # Set a breakpoint by name "func" which should pick up all functions
# whose basename is "func" # whose basename is "func"
bp = target.BreakpointCreateByName( bp = target.BreakpointCreateByName(
"func", lldb.eFunctionNameTypeAuto, module_list, cu_list) "func", lldb.eFunctionNameTypeAuto, module_list, cu_list)
for bp_loc in bp: for bp_loc in bp:
name = bp_loc.GetAddress().GetFunction().GetName() name = bp_loc.GetAddress().GetFunction().GetName()
self.assertTrue( self.assertTrue(
name in names, name in names,
"make sure breakpoint locations are correct for 'func' with eFunctionNameTypeAuto") "make sure breakpoint locations are correct for 'func' with eFunctionNameTypeAuto")
@expectedFailureAll(bugnumber="llvm.org/pr28548", compiler="gcc") @expectedFailureAll(bugnumber="llvm.org/pr28548", compiler="gcc")
def test_breakpoints_func_full(self): def test_breakpoints_func_full(self):
"""Test that we can set breakpoints correctly by fullname to find all functions whose fully qualified name is "func" """Test that we can set breakpoints correctly by fullname to find all functions whose fully qualified name is "func"
(no namespaces).""" (no namespaces)."""
self.build() self.build()
names = ["func()", "func(int)"] names = ["func()", "func(int)"]
# Create a target by the debugger. # Create a target by the debugger.
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
module_list = lldb.SBFileSpecList() module_list = lldb.SBFileSpecList()
module_list.Append(lldb.SBFileSpec(exe, False)) module_list.Append(lldb.SBFileSpec(exe, False))
cu_list = lldb.SBFileSpecList() cu_list = lldb.SBFileSpecList()
# Set a breakpoint by name "func" whose fullly qualified named matches "func" which # Set a breakpoint by name "func" whose fullly qualified named matches "func" which
# should pick up only functions whose basename is "func" and has no # should pick up only functions whose basename is "func" and has no
# containing context # containing context
bp = target.BreakpointCreateByName( bp = target.BreakpointCreateByName(
"func", lldb.eFunctionNameTypeFull, module_list, cu_list) "func", lldb.eFunctionNameTypeFull, module_list, cu_list)
for bp_loc in bp: for bp_loc in bp:
name = bp_loc.GetAddress().GetFunction().GetName() name = bp_loc.GetAddress().GetFunction().GetName()
self.assertTrue( self.assertTrue(
name in names, name in names,
"make sure breakpoint locations are correct for 'func' with eFunctionNameTypeFull") "make sure breakpoint locations are correct for 'func' with eFunctionNameTypeFull")
def test_breakpoints_a_func_full(self): def test_breakpoints_a_func_full(self):
"""Test that we can set breakpoints correctly by fullname to find all functions whose fully qualified name is "A::func".""" """Test that we can set breakpoints correctly by fullname to find all functions whose fully qualified name is "A::func"."""
self.build() self.build()
names = ["A::func()", "A::func(int)"] names = ["A::func()", "A::func(int)"]
# Create a target by the debugger. # Create a target by the debugger.
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
module_list = lldb.SBFileSpecList() module_list = lldb.SBFileSpecList()
module_list.Append(lldb.SBFileSpec(exe, False)) module_list.Append(lldb.SBFileSpec(exe, False))
cu_list = lldb.SBFileSpecList() cu_list = lldb.SBFileSpecList()
# Set a breakpoint by name "A::func" whose fullly qualified named matches "A::func" which # Set a breakpoint by name "A::func" whose fullly qualified named matches "A::func" which
# should pick up only functions whose basename is "func" and is # should pick up only functions whose basename is "func" and is
▲ Show 20 Lines • Show All 147 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/cpp/stl/TestSTL.py

Show All 24 Lines def setUp(self):
self.source = 'main.cpp' self.source = 'main.cpp'
self.line = line_number( self.line = line_number(
self.source, '// Set break point at this line.') self.source, '// Set break point at this line.')
@expectedFailureAll(bugnumber="rdar://problem/10400981") @expectedFailureAll(bugnumber="rdar://problem/10400981")
def test(self): def test(self):
"""Test some expressions involving STL data types.""" """Test some expressions involving STL data types."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# The following two lines, if uncommented, will enable loggings. # The following two lines, if uncommented, will enable loggings.
#self.ci.HandleCommand("log enable -f /tmp/lldb.log lldb default", res) #self.ci.HandleCommand("log enable -f /tmp/lldb.log lldb default", res)
# self.assertTrue(res.Succeeded()) # self.assertTrue(res.Succeeded())
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# rdar://problem/8543077 # rdar://problem/8543077
Show All 31 Linesclass STLTestCase(TestBase):
@expectedFailureAll( @expectedFailureAll(
compiler="icc", compiler="icc",
bugnumber="ICC (13.1, 14-beta) do not emit DW_TAG_template_type_parameter.") bugnumber="ICC (13.1, 14-beta) do not emit DW_TAG_template_type_parameter.")
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_SBType_template_aspects(self): def test_SBType_template_aspects(self):
"""Test APIs for getting template arguments from an SBType.""" """Test APIs for getting template arguments from an SBType."""
self.build() self.build()
exe = os.path.join(os.getcwd(), 'a.out') exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, 'a.out')
# 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)
# Create the breakpoint inside function 'main'. # Create the breakpoint inside function 'main'.
breakpoint = target.BreakpointCreateByLocation(self.source, self.line) breakpoint = target.BreakpointCreateByLocation(self.source, self.line)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
Show All 40 Lines

packages/Python/lldbsuite/test/lang/cpp/stl/TestStdCXXDisassembly.py

Show All 25 Linesclass StdCXXDisassembleTestCase(TestBase):
# rdar://problem/8504895 # rdar://problem/8504895
# Crash while doing 'disassemble -n "-[NSNumber descriptionWithLocale:]" # Crash while doing 'disassemble -n "-[NSNumber descriptionWithLocale:]"
@unittest2.skipIf( @unittest2.skipIf(
TestBase.skipLongRunningTest(), TestBase.skipLongRunningTest(),
"Skip this long running test") "Skip this long running test")
def test_stdcxx_disasm(self): def test_stdcxx_disasm(self):
"""Do 'disassemble' on each and every 'Code' symbol entry from the std c++ lib.""" """Do 'disassemble' on each and every 'Code' symbol entry from the std c++ lib."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# rdar://problem/8543077 # rdar://problem/8543077
# test/stl: clang built binaries results in the breakpoint locations = 3, # test/stl: clang built binaries results in the breakpoint locations = 3,
# is this a problem with clang generated debug info? # is this a problem with clang generated debug info?
# #
# Break on line 13 of main.cpp. # Break on line 13 of main.cpp.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/cpp/template/TestTemplateArgs.py

Show All 13 Lines
class TemplateArgsTestCase(TestBase): class TemplateArgsTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def prepareProcess(self): def prepareProcess(self):
self.build() self.build()
# Create a target by the debugger. # Create a target by the debugger.
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Set breakpoints inside and outside methods that take pointers to the # Set breakpoints inside and outside methods that take pointers to the
# containing struct. # containing struct.
line = line_number('main.cpp', '// Breakpoint 1') line = line_number('main.cpp', '// Breakpoint 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=True) self, "main.cpp", line, num_expected_locations=1, loc_exact=True)
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/cpp/unicode-literals/TestUnicodeLiterals.py

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Lines def setUp(self):
self.source, '// Set break point at this line.') self.source, '// Set break point at this line.')
def rdar12991846(self, expr=None): def rdar12991846(self, expr=None):
"""Test that the expression parser returns proper Unicode strings.""" """Test that the expression parser returns proper Unicode strings."""
if self.getArchitecture() in ['i386']: if self.getArchitecture() in ['i386']:
self.skipTest( self.skipTest(
"Skipping because this test is known to crash on i386") "Skipping because this test is known to crash on i386")
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Break on the struct declration statement in main.cpp. # Break on the struct declration statement in main.cpp.
lldbutil.run_break_set_by_file_and_line(self, "main.cpp", self.line) lldbutil.run_break_set_by_file_and_line(self, "main.cpp", self.line)
Show All 15 Lines

packages/Python/lldbsuite/test/lang/cpp/unique-types/TestUniqueTypes.py

Show All 27 Lines def test(self):
compiler = self.getCompiler() compiler = self.getCompiler()
compiler_basename = os.path.basename(compiler) compiler_basename = os.path.basename(compiler)
if "clang" in compiler_basename and int( if "clang" in compiler_basename and int(
self.getCompilerVersion().split('.')[0]) < 3: self.getCompilerVersion().split('.')[0]) < 3:
self.skipTest( self.skipTest(
"rdar://problem/9173060 lldb hangs while running unique-types for clang version < 3") "rdar://problem/9173060 lldb hangs while running unique-types for clang version < 3")
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.line, num_expected_locations=-1, loc_exact=True) self, "main.cpp", self.line, num_expected_locations=-1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
Show All 26 Lines

packages/Python/lldbsuite/test/lang/cpp/unsigned_types/TestUnsignedTypes.py

Show All 21 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break inside main(). # Find the line number to break inside main().
self.line = line_number('main.cpp', '// Set break point at this line.') self.line = line_number('main.cpp', '// Set break point at this line.')
def test(self): def test(self):
"""Test that variables with unsigned types display correctly.""" """Test that variables with unsigned types display correctly."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# GCC puts a breakpoint on the last line of a multi-line expression, so # GCC puts a breakpoint on the last line of a multi-line expression, so
# if GCC is the target compiler, we cannot rely on an exact line match. # if GCC is the target compiler, we cannot rely on an exact line match.
need_exact = "gcc" not in self.getCompiler() need_exact = "gcc" not in self.getCompiler()
# Break on line 19 in main() aftre the variables are assigned values. # Break on line 19 in main() aftre the variables are assigned values.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, self,
Show All 26 Lines

packages/Python/lldbsuite/test/lang/cpp/wchar_t/TestCxxWCharT.py

Show All 22 Lines def setUp(self):
# Find the line number to break for main.cpp. # Find the line number to break for main.cpp.
self.source = 'main.cpp' self.source = 'main.cpp'
self.line = line_number( self.line = line_number(
self.source, '// Set break point at this line.') self.source, '// Set break point at this line.')
def test(self): def test(self):
"""Test that C++ supports wchar_t correctly.""" """Test that C++ supports wchar_t correctly."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Break on the struct declration statement in main.cpp. # Break on the struct declration statement in main.cpp.
lldbutil.run_break_set_by_file_and_line(self, "main.cpp", self.line) lldbutil.run_break_set_by_file_and_line(self, "main.cpp", self.line)
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/go/expressions/TestExpressions.py

Show All 34 Lines def check_builtin(self, name, size=0, typeclass=lldb.eTypeClassBuiltin):
self.assertEqual(1, len(tl)) self.assertEqual(1, len(tl))
t = list(tl)[0] t = list(tl)[0]
self.assertEqual(name, t.name) self.assertEqual(name, t.name)
self.assertEqual(typeclass, t.type) self.assertEqual(typeclass, t.type)
if size > 0: if size > 0:
self.assertEqual(size, t.size) self.assertEqual(size, t.size)
def launchProcess(self): def launchProcess(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
bpt = target.BreakpointCreateByLocation( bpt = target.BreakpointCreateByLocation(
self.main_source, self.break_line) self.main_source, self.break_line)
self.assertTrue(bpt, VALID_BREAKPOINT) self.assertTrue(bpt, VALID_BREAKPOINT)
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/go/formatters/TestGoFormatters.py

Show All 25 Linesclass TestGoLanguage(TestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line numbers to break inside main(). # Find the line numbers to break inside main().
self.main_source = "main.go" self.main_source = "main.go"
self.break_line = line_number(self.main_source, '// stop here') self.break_line = line_number(self.main_source, '// stop here')
def launchProcess(self): def launchProcess(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
self.bpt = target.BreakpointCreateByLocation( self.bpt = target.BreakpointCreateByLocation(
self.main_source, self.break_line) self.main_source, self.break_line)
self.assertTrue(self.bpt, VALID_BREAKPOINT) self.assertTrue(self.bpt, VALID_BREAKPOINT)
Show All 34 Lines

packages/Python/lldbsuite/test/lang/go/goroutines/TestGoroutines.py

Show All 30 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
# Find the line numbers to break inside main(). # Find the line numbers to break inside main().
self.main_source = "main.go" self.main_source = "main.go"
self.break_line1 = line_number(self.main_source, '// stop1') self.break_line1 = line_number(self.main_source, '// stop1')
self.break_line2 = line_number(self.main_source, '// stop2') self.break_line2 = line_number(self.main_source, '// stop2')
self.break_line3 = line_number(self.main_source, '// stop3') self.break_line3 = line_number(self.main_source, '// stop3')
def launchProcess(self): def launchProcess(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
self.bpt1 = target.BreakpointCreateByLocation( self.bpt1 = target.BreakpointCreateByLocation(
self.main_source, self.break_line1) self.main_source, self.break_line1)
self.assertTrue(self.bpt1, VALID_BREAKPOINT) self.assertTrue(self.bpt1, VALID_BREAKPOINT)
self.bpt2 = target.BreakpointCreateByLocation( self.bpt2 = target.BreakpointCreateByLocation(
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/go/types/TestGoASTContext.py

Show All 40 Lines def check_builtin(self, name, size=0, typeclass=lldb.eTypeClassBuiltin):
self.assertEqual(1, len(tl)) self.assertEqual(1, len(tl))
t = list(tl)[0] t = list(tl)[0]
self.assertEqual(name, t.name) self.assertEqual(name, t.name)
self.assertEqual(typeclass, t.type) self.assertEqual(typeclass, t.type)
if size > 0: if size > 0:
self.assertEqual(size, t.size) self.assertEqual(size, t.size)
def launchProcess(self): def launchProcess(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
bpt = target.BreakpointCreateByLocation( bpt = target.BreakpointCreateByLocation(
self.main_source, self.break_line) self.main_source, self.break_line)
self.assertTrue(bpt, VALID_BREAKPOINT) self.assertTrue(bpt, VALID_BREAKPOINT)
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/mixed/TestMixedLanguages.py

Show All 11 Lines
class MixedLanguagesTestCase(TestBase): class MixedLanguagesTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def test_language_of_frame(self): def test_language_of_frame(self):
"""Test that the language defaults to the language of the current frame.""" """Test that the language defaults to the language of the current frame."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Execute the cleanup function during test case tear down # Execute the cleanup function during test case tear down
# to restore the frame format. # to restore the frame format.
def cleanup(): def cleanup():
self.runCmd( self.runCmd(
"settings set frame-format %s" % "settings set frame-format %s" %
self.format_string, check=False) self.format_string, check=False)
Show All 32 Lines

packages/Python/lldbsuite/test/lang/objc/blocks/TestObjCIvarsInBlocks.py

Show All 25 Linesclass TestObjCIvarsInBlocks(TestBase):
@skipUnlessDarwin @skipUnlessDarwin
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@expectedFailureAll( @expectedFailureAll(
archs=["i[3-6]86"], archs=["i[3-6]86"],
bugnumber="This test requires the 2.0 runtime, so it will fail on i386") bugnumber="This test requires the 2.0 runtime, so it will fail on i386")
def test_with_python_api(self): def test_with_python_api(self):
"""Test printing the ivars of the self when captured in blocks""" """Test printing the ivars of the self when captured in blocks"""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
breakpoint = target.BreakpointCreateBySourceRegex( breakpoint = target.BreakpointCreateBySourceRegex(
'// Break here inside the block.', self.class_source_file_spec) '// Break here inside the block.', self.class_source_file_spec)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/objc/conflicting-definition/TestConflictingDefinition.py

Show All 40 Lines def test_frame_var_after_stop_at_implementation(self):
# This should display correctly. # This should display correctly.
self.expect( self.expect(
"expr 42", "expr 42",
"A simple expression should execute correctly", "A simple expression should execute correctly",
substrs=[ substrs=[
"42"]) "42"])
def common_setup(self): def common_setup(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.registerSharedLibrariesWithTarget(target, self.shlib_names) self.registerSharedLibrariesWithTarget(target, self.shlib_names)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)

packages/Python/lldbsuite/test/lang/objc/foundation/TestConstStrings.py

Show All 26 Lines def setUp(self):
self.line = line_number(self.main_source, '// Set breakpoint here.') self.line = line_number(self.main_source, '// Set breakpoint here.')
@skipUnlessDarwin @skipUnlessDarwin
def test_break(self): def test_break(self):
"""Test constant string generation amd comparison by the expression parser.""" """Test constant string generation amd comparison by the expression parser."""
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(self.d) self.setTearDownCleanup(self.d)
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, self,
self.main_source, self.main_source,
self.line, self.line,
num_expected_locations=1, num_expected_locations=1,
loc_exact=True) loc_exact=True)
Show All 17 Lines

packages/Python/lldbsuite/test/lang/objc/foundation/TestObjCMethods.py

Show All 29 Lines def setUp(self):
self.main_source = "main.m" self.main_source = "main.m"
self.line = line_number( self.line = line_number(
self.main_source, self.main_source,
'// Set break point at this line.') '// Set break point at this line.')
def test_break(self): def test_break(self):
"""Test setting objc breakpoints using '_regexp-break' and 'breakpoint set'.""" """Test setting objc breakpoints using '_regexp-break' and 'breakpoint set'."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Stop at +[NSString stringWithFormat:]. # Stop at +[NSString stringWithFormat:].
break_results = lldbutil.run_break_set_command( break_results = lldbutil.run_break_set_command(
self, "_regexp-break +[NSString stringWithFormat:]") self, "_regexp-break +[NSString stringWithFormat:]")
lldbutil.check_breakpoint_result( lldbutil.check_breakpoint_result(
self, self,
break_results, break_results,
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Lines def test_break(self):
self.expect("thread backtrace", "Stop at -[NSAutoreleasePool release]", self.expect("thread backtrace", "Stop at -[NSAutoreleasePool release]",
substrs=["Foundation`-[NSAutoreleasePool release]"]) substrs=["Foundation`-[NSAutoreleasePool release]"])
# rdar://problem/8542091 # rdar://problem/8542091
# rdar://problem/8492646 # rdar://problem/8492646
def test_data_type_and_expr(self): def test_data_type_and_expr(self):
"""Lookup objective-c data types and evaluate expressions.""" """Lookup objective-c data types and evaluate expressions."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Stop at -[MyString description]. # Stop at -[MyString description].
lldbutil.run_break_set_by_symbol( lldbutil.run_break_set_by_symbol(
self, self,
'-[MyString description]', '-[MyString description]',
num_expected_locations=1, num_expected_locations=1,
sym_exact=True) sym_exact=True)
▲ Show 20 Lines • Show All 96 Lines • ▼ Show 20 Lines# locations = 1")
"Object description displayed correctly", "Object description displayed correctly",
patterns=["Hello from.*a.out.*with timestamp: "]) patterns=["Hello from.*a.out.*with timestamp: "])
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_print_ivars_correctly(self): def test_print_ivars_correctly(self):
self.build() self.build()
# See: <rdar://problem/8717050> lldb needs to use the ObjC runtime symbols for ivar offsets # See: <rdar://problem/8717050> lldb needs to use the ObjC runtime symbols for ivar offsets
# Only fails for the ObjC 2.0 runtime. # Only fails for the ObjC 2.0 runtime.
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
break1 = target.BreakpointCreateByLocation(self.main_source, self.line) break1 = target.BreakpointCreateByLocation(self.main_source, self.line)
self.assertTrue(break1, VALID_BREAKPOINT) self.assertTrue(break1, VALID_BREAKPOINT)
# Now launch the process, and do not stop at entry point. # Now launch the process, and do not stop at entry point.
Show All 33 Lines def test_print_ivars_correctly(self):
self.assertTrue( self.assertTrue(
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 = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Stop at -[MyString initWithNSString:]. # Stop at -[MyString initWithNSString:].
lldbutil.run_break_set_by_symbol( lldbutil.run_break_set_by_symbol(
self, self,
'-[MyString initWithNSString:]', '-[MyString initWithNSString:]',
num_expected_locations=1, num_expected_locations=1,
sym_exact=True) sym_exact=True)
Show All 36 Lines

packages/Python/lldbsuite/test/lang/objc/foundation/TestObjCMethods2.py

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines def setUp(self):
self.lines.append( self.lines.append(
line_number( line_number(
'main.m', 'main.m',
'// Set break point at this line')) '// Set break point at this line'))
def test_more_expr_commands(self): def test_more_expr_commands(self):
"""More expression commands for objective-c.""" """More expression commands for objective-c."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Create a bunch of breakpoints. # Create a bunch of breakpoints.
for line in self.lines: for line in self.lines:
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.m", line, num_expected_locations=1, loc_exact=True) self, "main.m", line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 20 Lines def test_more_expr_commands(self):
substrs=["(char *)", substrs=["(char *)",
"description"]) "description"])
self.runCmd("process continue") self.runCmd("process continue")
def test_NSArray_expr_commands(self): def test_NSArray_expr_commands(self):
"""Test expression commands for NSArray.""" """Test expression commands for NSArray."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside Test_NSArray: # Break inside Test_NSArray:
line = self.lines[1] line = self.lines[1]
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.m", line, num_expected_locations=1, loc_exact=True) self, "main.m", line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 10 Lines def test_NSArray_expr_commands(self):
patterns=["\(int\) \$.* = 3"]) patterns=["\(int\) \$.* = 3"])
self.expect("expression (int)array2.count", self.expect("expression (int)array2.count",
patterns=["\(int\) \$.* = 3"]) patterns=["\(int\) \$.* = 3"])
self.runCmd("process continue") self.runCmd("process continue")
def test_NSString_expr_commands(self): def test_NSString_expr_commands(self):
"""Test expression commands for NSString.""" """Test expression commands for NSString."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside Test_NSString: # Break inside Test_NSString:
line = self.lines[2] line = self.lines[2]
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.m", line, num_expected_locations=1, loc_exact=True) self, "main.m", line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 13 Lines def test_NSString_expr_commands(self):
self.runCmd("image lookup -t NSString") self.runCmd("image lookup -t NSString")
self.expect('expression str = (id)[NSString stringWithCString: "new"]') self.expect('expression str = (id)[NSString stringWithCString: "new"]')
self.runCmd("process continue") self.runCmd("process continue")
@expectedFailureAll(archs=["i[3-6]86"], bugnumber="<rdar://problem/28814052>") @expectedFailureAll(archs=["i[3-6]86"], bugnumber="<rdar://problem/28814052>")
def test_MyString_dump_with_runtime(self): def test_MyString_dump_with_runtime(self):
"""Test dump of a known Objective-C object by dereferencing it.""" """Test dump of a known Objective-C object by dereferencing it."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
line = self.lines[4] line = self.lines[4]
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.m", line, num_expected_locations=1, loc_exact=True) self, "main.m", line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.expect( self.expect(
"expression --show-types -- *my", "expression --show-types -- *my",
patterns=[ patterns=[
"\(MyString\) \$.* = ", "\(MyString\) \$.* = ",
"\(MyBase\)"]) "\(MyBase\)"])
self.runCmd("process continue") self.runCmd("process continue")
@expectedFailureAll(archs=["i[3-6]86"], bugnumber="<rdar://problem/28814052>") @expectedFailureAll(archs=["i[3-6]86"], bugnumber="<rdar://problem/28814052>")
def test_runtime_types(self): def test_runtime_types(self):
"""Test commands that require runtime types""" """Test commands that require runtime types"""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside Test_NSString: # Break inside Test_NSString:
line = self.lines[2] line = self.lines[2]
lldbutil.run_break_set_by_source_regexp( lldbutil.run_break_set_by_source_regexp(
self, "NSString tests") self, "NSString tests")
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 11 Lines def test_runtime_types(self):
"Code=35", "Code=35",
"be completed."]) "be completed."])
self.runCmd("process continue") self.runCmd("process continue")
@expectedFailureAll(archs=["i[3-6]86"], bugnumber="<rdar://problem/28814052>") @expectedFailureAll(archs=["i[3-6]86"], bugnumber="<rdar://problem/28814052>")
def test_NSError_p(self): def test_NSError_p(self):
"""Test that p of the result of an unknown method does require a cast.""" """Test that p of the result of an unknown method does require a cast."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
line = self.lines[4] line = self.lines[4]
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.m", line, num_expected_locations=1, loc_exact=True) self, "main.m", line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.expect("p [NSError thisMethodIsntImplemented:0]", error=True, patterns=[ self.expect("p [NSError thisMethodIsntImplemented:0]", error=True, patterns=[
"no known method", "cast the message send to the method's return type"]) "no known method", "cast the message send to the method's return type"])
self.runCmd("process continue") self.runCmd("process continue")

packages/Python/lldbsuite/test/lang/objc/foundation/TestObjectDescriptionAPI.py

Show All 28 Linesclass ObjectDescriptionAPITestCase(TestBase):
# rdar://problem/10857337 # rdar://problem/10857337
@skipUnlessDarwin @skipUnlessDarwin
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_find_global_variables_then_object_description(self): def test_find_global_variables_then_object_description(self):
"""Exercise SBTarget.FindGlobalVariables() API.""" """Exercise SBTarget.FindGlobalVariables() API."""
d = {'EXE': 'b.out'} d = {'EXE': 'b.out'}
self.build(dictionary=d) self.build(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
exe = os.path.join(os.getcwd(), 'b.out') exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, 'b.out')
# 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)
breakpoint = target.BreakpointCreateByLocation(self.source, self.line) breakpoint = target.BreakpointCreateByLocation(self.source, self.line)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
Show All 33 Lines

packages/Python/lldbsuite/test/lang/objc/foundation/TestRuntimeTypes.py

Show All 22 Lines @expectedFailureAll(
debug_info="gmodules", debug_info="gmodules",
bugnumber="llvm.org/pr27862") bugnumber="llvm.org/pr27862")
def test_break(self): def test_break(self):
"""Test setting objc breakpoints using '_regexp-break' and 'breakpoint set'.""" """Test setting objc breakpoints using '_regexp-break' and 'breakpoint set'."""
if self.getArchitecture() != 'x86_64': if self.getArchitecture() != 'x86_64':
self.skipTest("This only applies to the v2 runtime") self.skipTest("This only applies to the v2 runtime")
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Stop at -[MyString description]. # Stop at -[MyString description].
lldbutil.run_break_set_by_symbol( lldbutil.run_break_set_by_symbol(
self, self,
'-[MyString description]', '-[MyString description]',
num_expected_locations=1, num_expected_locations=1,
sym_exact=True) sym_exact=True)
Show All 23 Lines

packages/Python/lldbsuite/test/lang/objc/foundation/TestSymbolTable.py

Show All 30 Lines symbols_list = ['-[MyString initWithNSString:]',
'Test_NSArray', 'Test_NSArray',
'main' 'main'
] ]
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_with_python_api(self): def test_with_python_api(self):
"""Test symbol table access with Python APIs.""" """Test symbol table access with Python APIs."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Launch the process, and do not stop at the entry point. # Launch the process, and do not stop at the entry point.
process = target.LaunchSimple( process = target.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
Show All 27 Lines

packages/Python/lldbsuite/test/lang/objc/global_ptrs/TestGlobalObjects.py

Show All 19 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
self.main_source = lldb.SBFileSpec("main.m") self.main_source = lldb.SBFileSpec("main.m")
@skipUnlessDarwin @skipUnlessDarwin
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_with_python_api(self): def test_with_python_api(self):
"""Test that a global ObjC object found before the process is started updates correctly.""" """Test that a global ObjC object found before the process is started updates correctly."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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:
Show All 24 Lines

packages/Python/lldbsuite/test/lang/objc/hidden-ivars/TestHiddenIvars.py

Show First 20 Lines • Show All 103 Lines • ▼ Show 20 Lines def common_setup(self, strip):
environment = self.registerSharedLibrariesWithTarget( environment = self.registerSharedLibrariesWithTarget(
target, self.shlib_names) target, self.shlib_names)
# 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, environment, self.get_process_working_directory()) None, environment, self.get_process_working_directory())
self.assertTrue(process, PROCESS_IS_VALID) self.assertTrue(process, PROCESS_IS_VALID)
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the foo function which takes a bar_ptr argument. # Break inside the foo function which takes a bar_ptr argument.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.m", self.line, num_expected_locations=1, loc_exact=True) self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
▲ Show 20 Lines • Show All 117 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/objc/ivar-IMP/TestObjCiVarIMP.py

Show All 29 Linesclass ObjCiVarIMPTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipUnlessDarwin @skipUnlessDarwin
@skipIf(archs=['i386']) # objc file does not build for i386 @skipIf(archs=['i386']) # objc file does not build for i386
@no_debug_info_test @no_debug_info_test
def test_imp_ivar_type(self): def test_imp_ivar_type(self):
"""Test that dynamically discovered ivars of type IMP do not crash LLDB""" """Test that dynamically discovered ivars of type IMP do not crash LLDB"""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# Create a target from the debugger. # Create a target from the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Set up our breakpoint # Set up our breakpoint
bkpt = lldbutil.run_break_set_by_source_regexp(self, "break here") bkpt = lldbutil.run_break_set_by_source_regexp(self, "break here")
Show All 16 Lines

packages/Python/lldbsuite/test/lang/objc/modules-auto-import/TestModulesAutoImport.py

Show All 23 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break inside main(). # Find the line number to break inside main().
self.line = line_number('main.m', '// Set breakpoint 0 here.') self.line = line_number('main.m', '// Set breakpoint 0 here.')
@skipUnlessDarwin @skipUnlessDarwin
@skipIf(macos_version=["<", "10.12"]) @skipIf(macos_version=["<", "10.12"])
def test_expr(self): def test_expr(self):
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the foo function which takes a bar_ptr argument. # Break inside the foo function which takes a bar_ptr argument.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.m", self.line, num_expected_locations=1, loc_exact=True) self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 13 Lines

packages/Python/lldbsuite/test/lang/objc/modules-incomplete/TestIncompleteModules.py

Show All 21 Lines def setUp(self):
# Find the line number to break inside main(). # Find the line number to break inside main().
self.line = line_number('main.m', '// Set breakpoint 0 here.') self.line = line_number('main.m', '// Set breakpoint 0 here.')
@skipUnlessDarwin @skipUnlessDarwin
@unittest2.expectedFailure("rdar://20416388") @unittest2.expectedFailure("rdar://20416388")
@skipIf(macos_version=["<", "10.12"]) @skipIf(macos_version=["<", "10.12"])
def test_expr(self): def test_expr(self):
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the foo function which takes a bar_ptr argument. # Break inside the foo function which takes a bar_ptr argument.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.m", self.line, num_expected_locations=1, loc_exact=True) self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 29 Lines

packages/Python/lldbsuite/test/lang/objc/modules-inline-functions/TestModulesInlineFunctions.py

Show All 24 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break inside main(). # Find the line number to break inside main().
self.line = line_number('main.m', '// Set breakpoint here.') self.line = line_number('main.m', '// Set breakpoint here.')
@skipUnlessDarwin @skipUnlessDarwin
@skipIf(macos_version=["<", "10.12"]) @skipIf(macos_version=["<", "10.12"])
def test_expr(self): def test_expr(self):
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the foo function which takes a bar_ptr argument. # Break inside the foo function which takes a bar_ptr argument.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.m", self.line, num_expected_locations=1, loc_exact=True) self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 19 Lines

packages/Python/lldbsuite/test/lang/objc/modules/TestObjCModules.py

Show All 27 Linesclass ObjCModulesTestCase(TestBase):
@skipUnlessDarwin @skipUnlessDarwin
@unittest2.expectedFailure("rdar://20416388") @unittest2.expectedFailure("rdar://20416388")
@skipIf(macos_version=["<", "10.12"]) @skipIf(macos_version=["<", "10.12"])
def test_expr(self): def test_expr(self):
if not self.applies(): if not self.applies():
return return
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the foo function which takes a bar_ptr argument. # Break inside the foo function which takes a bar_ptr argument.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.m", self.line, num_expected_locations=1, loc_exact=True) self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 40 Lines

packages/Python/lldbsuite/test/lang/objc/objc++/TestObjCXX.py

Show All 18 Linesclass ObjCXXTestCase(TestBase):
@skipUnlessDarwin @skipUnlessDarwin
def test_break(self): def test_break(self):
"""Test ivars of Objective-C++ classes""" """Test ivars of Objective-C++ classes"""
if self.getArchitecture() == 'i386': if self.getArchitecture() == 'i386':
self.skipTest("requires Objective-C 2.0 runtime") self.skipTest("requires Objective-C 2.0 runtime")
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_source_regexp( lldbutil.run_break_set_by_source_regexp(
self, 'breakpoint 1', num_expected_locations=1) self, 'breakpoint 1', num_expected_locations=1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.expect("expr f->f", "Found ivar in class", self.expect("expr f->f", "Found ivar in class",
substrs=["= 3"]) substrs=["= 3"])

packages/Python/lldbsuite/test/lang/objc/objc-baseclass-sbtype/TestObjCBaseClassSBType.py

Show All 27 Linesclass ObjCDynamicValueTestCase(TestBase):
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_get_baseclass(self): def test_get_baseclass(self):
"""Test fetching ObjC dynamic values.""" """Test fetching ObjC dynamic values."""
if self.getArchitecture() == 'i386': if self.getArchitecture() == 'i386':
# rdar://problem/9946499 # rdar://problem/9946499
self.skipTest("Dynamic types for ObjC V1 runtime not implemented") self.skipTest("Dynamic types for ObjC V1 runtime not implemented")
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# Create a target from the debugger. # Create a target from the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Set up our breakpoints: # Set up our breakpoints:
Show All 24 Lines

packages/Python/lldbsuite/test/lang/objc/objc-builtin-types/TestObjCBuiltinTypes.py

Show All 23 Lines def setUp(self):
self.main_source, '// Set breakpoint here.') self.main_source, '// Set breakpoint here.')
@skipUnlessDarwin @skipUnlessDarwin
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
#<rdar://problem/10591460> [regression] Can't print ivar value: error: reference to 'id' is ambiguous #<rdar://problem/10591460> [regression] Can't print ivar value: error: reference to 'id' is ambiguous
def test_with_python_api(self): def test_with_python_api(self):
"""Test expression parser respect for ObjC built-in types.""" """Test expression parser respect for ObjC built-in types."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
bpt = target.BreakpointCreateByLocation( bpt = target.BreakpointCreateByLocation(
self.main_source, self.break_line) self.main_source, self.break_line)
self.assertTrue(bpt, VALID_BREAKPOINT) self.assertTrue(bpt, VALID_BREAKPOINT)
Show All 24 Lines

packages/Python/lldbsuite/test/lang/objc/objc-checker/TestObjCCheckers.py

Show All 27 Linesclass ObjCCheckerTestCase(TestBase):
@skipUnlessDarwin @skipUnlessDarwin
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_objc_checker(self): def test_objc_checker(self):
"""Test that checkers catch unrecognized selectors""" """Test that checkers catch unrecognized selectors"""
if self.getArchitecture() == 'i386': if self.getArchitecture() == 'i386':
self.skipTest("requires Objective-C 2.0 runtime") self.skipTest("requires Objective-C 2.0 runtime")
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# Create a target from the debugger. # Create a target from the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Set up our breakpoints: # Set up our breakpoints:
Show All 35 Lines

packages/Python/lldbsuite/test/lang/objc/objc-class-method/TestObjCClassMethod.py

Show All 22 Lines def setUp(self):
self.break_line = line_number( self.break_line = line_number(
self.main_source, '// Set breakpoint here.') self.main_source, '// Set breakpoint here.')
@skipUnlessDarwin @skipUnlessDarwin
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_with_python_api(self): def test_with_python_api(self):
"""Test calling functions in class methods.""" """Test calling functions in class methods."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
bpt = target.BreakpointCreateByLocation( bpt = target.BreakpointCreateByLocation(
self.main_source, self.break_line) self.main_source, self.break_line)
self.assertTrue(bpt, VALID_BREAKPOINT) self.assertTrue(bpt, VALID_BREAKPOINT)
Show All 29 Lines

packages/Python/lldbsuite/test/lang/objc/objc-dyn-sbtype/TestObjCDynamicSBType.py

Show All 28 Linesclass ObjCDynamicSBTypeTestCase(TestBase):
@skipIf(archs="i[3-6]86") @skipIf(archs="i[3-6]86")
def test_dyn(self): def test_dyn(self):
"""Test that we are able to properly report a usable dynamic type.""" """Test that we are able to properly report a usable dynamic type."""
d = {'EXE': self.exe_name} d = {'EXE': self.exe_name}
self.build(dictionary=d) self.build(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, self,
self.main_source, self.main_source,
self.line, self.line,
num_expected_locations=1, num_expected_locations=1,
loc_exact=True) loc_exact=True)
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/objc/objc-dynamic-value/TestObjCDynamicValue.py

Show All 37 Linesclass ObjCDynamicValueTestCase(TestBase):
@expectedFailureDarwin("llvm.org/pr20271 rdar://18684107") @expectedFailureDarwin("llvm.org/pr20271 rdar://18684107")
def test_get_objc_dynamic_vals(self): def test_get_objc_dynamic_vals(self):
"""Test fetching ObjC dynamic values.""" """Test fetching ObjC dynamic values."""
if self.getArchitecture() == 'i386': if self.getArchitecture() == 'i386':
# rdar://problem/9946499 # rdar://problem/9946499
self.skipTest("Dynamic types for ObjC V1 runtime not implemented") self.skipTest("Dynamic types for ObjC V1 runtime not implemented")
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# Create a target from the debugger. # Create a target from the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Set up our breakpoints: # Set up our breakpoints:
▲ Show 20 Lines • Show All 157 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/objc/objc-ivar-offsets/TestObjCIvarOffsets.py

Show All 22 Lines def setUp(self):
self.stop_line = line_number( self.stop_line = line_number(
self.main_source, '// Set breakpoint here.') self.main_source, '// Set breakpoint here.')
@skipUnlessDarwin @skipUnlessDarwin
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_with_python_api(self): def test_with_python_api(self):
"""Test printing ObjC objects that use unbacked properties""" """Test printing ObjC objects that use unbacked properties"""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
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)
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/objc/objc-ivar-stripped/TestObjCIvarStripped.py

Show All 25 Linesclass TestObjCIvarStripped(TestBase):
@skipUnlessDarwin @skipUnlessDarwin
@skipIf( @skipIf(
debug_info=no_match("dsym"), debug_info=no_match("dsym"),
bugnumber="This test requires a stripped binary and a dSYM") bugnumber="This test requires a stripped binary and a dSYM")
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_with_python_api(self): def test_with_python_api(self):
"""Test that we can find stripped Objective-C ivars in the runtime""" """Test that we can find stripped Objective-C ivars in the runtime"""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out.stripped") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out.stripped")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
self.dbg.HandleCommand("add-dsym a.out.dSYM") self.dbg.HandleCommand("add-dsym a.out.dSYM")
breakpoint = target.BreakpointCreateByLocation( breakpoint = target.BreakpointCreateByLocation(
self.main_source, self.stop_line) self.main_source, self.stop_line)
Show All 28 Lines

packages/Python/lldbsuite/test/lang/objc/objc-new-syntax/TestObjCNewSyntax.py

Show All 22 Linesclass ObjCNewSyntaxTestCase(TestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break inside main(). # Find the line number to break inside main().
self.line = line_number('main.m', '// Set breakpoint 0 here.') self.line = line_number('main.m', '// Set breakpoint 0 here.')
def runToBreakpoint(self): def runToBreakpoint(self):
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the foo function which takes a bar_ptr argument. # Break inside the foo function which takes a bar_ptr argument.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.m", self.line, num_expected_locations=1, loc_exact=True) self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
▲ Show 20 Lines • Show All 165 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/objc/objc-optimized/TestObjcOptimized.py

Show All 28 Linesclass ObjcOptimizedTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
myclass = "MyClass" myclass = "MyClass"
mymethod = "description" mymethod = "description"
method_spec = "-[%s %s]" % (myclass, mymethod) method_spec = "-[%s %s]" % (myclass, mymethod)
def test_break(self): def test_break(self):
"""Test 'expr member' continues to work for optimized build.""" """Test 'expr member' continues to work for optimized build."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_symbol( lldbutil.run_break_set_by_symbol(
self, self,
self.method_spec, self.method_spec,
num_expected_locations=1, num_expected_locations=1,
sym_exact=True) sym_exact=True)
Show All 31 Lines

packages/Python/lldbsuite/test/lang/objc/objc-property/TestObjCProperty.py

Show All 27 Linesclass ObjCPropertyTestCase(TestBase):
@skipUnlessDarwin @skipUnlessDarwin
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_objc_properties(self): def test_objc_properties(self):
"""Test that expr uses the correct property getters and setters""" """Test that expr uses the correct property getters and setters"""
if self.getArchitecture() == 'i386': if self.getArchitecture() == 'i386':
self.skipTest("requires modern objc runtime") self.skipTest("requires modern objc runtime")
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# Create a target from the debugger. # Create a target from the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Set up our breakpoints: # Set up our breakpoints:
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/objc/objc-static-method-stripped/TestObjCStaticMethodStripped.py

Show All 28 Lines @skipIf(
debug_info=no_match("dsym"), debug_info=no_match("dsym"),
bugnumber="This test requires a stripped binary and a dSYM") bugnumber="This test requires a stripped binary and a dSYM")
#<rdar://problem/12042992> #<rdar://problem/12042992>
def test_with_python_api(self): def test_with_python_api(self):
"""Test calling functions in static methods with a stripped binary.""" """Test calling functions in static methods with a stripped binary."""
if self.getArchitecture() == 'i386': if self.getArchitecture() == 'i386':
self.skipTest("requires modern objc runtime") self.skipTest("requires modern objc runtime")
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
bpt = target.BreakpointCreateByLocation( bpt = target.BreakpointCreateByLocation(
self.main_source, self.break_line) self.main_source, self.break_line)
self.assertTrue(bpt, VALID_BREAKPOINT) self.assertTrue(bpt, VALID_BREAKPOINT)
Show All 35 Lines

packages/Python/lldbsuite/test/lang/objc/objc-static-method/TestObjCStaticMethod.py

Show All 23 Lines def setUp(self):
self.main_source, '// Set breakpoint here.') self.main_source, '// Set breakpoint here.')
@skipUnlessDarwin @skipUnlessDarwin
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
#<rdar://problem/9745789> "expression" can't call functions in class methods #<rdar://problem/9745789> "expression" can't call functions in class methods
def test_with_python_api(self): def test_with_python_api(self):
"""Test calling functions in static methods.""" """Test calling functions in static methods."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
bpt = target.BreakpointCreateByLocation( bpt = target.BreakpointCreateByLocation(
self.main_source, self.break_line) self.main_source, self.break_line)
self.assertTrue(bpt, VALID_BREAKPOINT) self.assertTrue(bpt, VALID_BREAKPOINT)
Show All 35 Lines

packages/Python/lldbsuite/test/lang/objc/objc-stepping/TestObjCStepping.py

Show All 30 Lines def setUp(self):
self.stepped_past_nil_line = line_number( self.stepped_past_nil_line = line_number(
self.main_source, '// Step over nil should stop here.') self.main_source, '// Step over nil should stop here.')
@skipUnlessDarwin @skipUnlessDarwin
@add_test_categories(['pyapi', 'basic_process']) @add_test_categories(['pyapi', 'basic_process'])
def test_with_python_api(self): def test_with_python_api(self):
"""Test stepping through ObjC method dispatch in various forms.""" """Test stepping through ObjC method dispatch in various forms."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
self.main_source_spec = lldb.SBFileSpec(self.main_source) self.main_source_spec = lldb.SBFileSpec(self.main_source)
breakpoints_to_disable = [] breakpoints_to_disable = []
▲ Show 20 Lines • Show All 175 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/objc/objc-struct-argument/TestObjCStructArgument.py

Show All 23 Lines def setUp(self):
self.main_source, '// Set breakpoint here.') self.main_source, '// Set breakpoint here.')
@skipUnlessDarwin @skipUnlessDarwin
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@skipIf(debug_info=no_match(["gmodules"]), oslist=['ios', 'watchos', 'tvos', 'bridgeos'], archs=['armv7', 'arm64']) # this test program only builds for ios with -gmodules @skipIf(debug_info=no_match(["gmodules"]), oslist=['ios', 'watchos', 'tvos', 'bridgeos'], archs=['armv7', 'arm64']) # this test program only builds for ios with -gmodules
def test_with_python_api(self): def test_with_python_api(self):
"""Test passing structs to Objective-C methods.""" """Test passing structs to Objective-C methods."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
bpt = target.BreakpointCreateByLocation( bpt = target.BreakpointCreateByLocation(
self.main_source, self.break_line) self.main_source, self.break_line)
self.assertTrue(bpt, VALID_BREAKPOINT) self.assertTrue(bpt, VALID_BREAKPOINT)
Show All 29 Lines

packages/Python/lldbsuite/test/lang/objc/objc-struct-return/TestObjCStructReturn.py

Show All 22 Lines def setUp(self):
self.break_line = line_number( self.break_line = line_number(
self.main_source, '// Set breakpoint here.') self.main_source, '// Set breakpoint here.')
@skipUnlessDarwin @skipUnlessDarwin
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_with_python_api(self): def test_with_python_api(self):
"""Test calling functions in class methods.""" """Test calling functions in class methods."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
bpt = target.BreakpointCreateByLocation( bpt = target.BreakpointCreateByLocation(
self.main_source, self.break_line) self.main_source, self.break_line)
self.assertTrue(bpt, VALID_BREAKPOINT) self.assertTrue(bpt, VALID_BREAKPOINT)
Show All 23 Lines

packages/Python/lldbsuite/test/lang/objc/objc-super/TestObjCSuper.py

Show All 22 Lines def setUp(self):
self.break_line = line_number( self.break_line = line_number(
self.main_source, '// Set breakpoint here.') self.main_source, '// Set breakpoint here.')
@skipUnlessDarwin @skipUnlessDarwin
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_with_python_api(self): def test_with_python_api(self):
"""Test calling methods on super.""" """Test calling methods on super."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
bpt = target.BreakpointCreateByLocation( bpt = target.BreakpointCreateByLocation(
self.main_source, self.break_line) self.main_source, self.break_line)
self.assertTrue(bpt, VALID_BREAKPOINT) self.assertTrue(bpt, VALID_BREAKPOINT)
Show All 28 Lines

packages/Python/lldbsuite/test/lang/objc/print-obj/TestPrintObj.py

Show All 32 Lines def test_print_obj(self):
Set a breakpoint on the line in my_pthread_routine. Then switch threads Set a breakpoint on the line in my_pthread_routine. Then switch threads
to the main thread, and do print the lock_me object. Since that will to the main thread, and do print the lock_me object. Since that will
try to get the lock already gotten by my_pthread_routime thread, it will try to get the lock already gotten by my_pthread_routime thread, it will
have to switch to running all threads, and that should then succeed. have to switch to running all threads, and that should then succeed.
""" """
d = {'EXE': 'b.out'} d = {'EXE': 'b.out'}
self.build(dictionary=d) self.build(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
exe = os.path.join(os.getcwd(), 'b.out') exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, 'b.out')
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
breakpoint = target.BreakpointCreateByLocation(self.source, self.line) breakpoint = target.BreakpointCreateByLocation(self.source, self.line)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
self.runCmd("breakpoint list") self.runCmd("breakpoint list")
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lang/objc/ptr_refs/TestPtrRefsObjC.py

Show All 14 Linesclass TestPtrRefsObjC(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipUnlessDarwin @skipUnlessDarwin
def test_ptr_refs(self): def test_ptr_refs(self):
"""Test the ptr_refs tool on Darwin with Objective-C""" """Test the ptr_refs tool on Darwin with Objective-C"""
self.build() self.build()
exe_name = 'a.out' exe_name = 'a.out'
exe = os.path.join(os.getcwd(), exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, exe_name)
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
main_file_spec = lldb.SBFileSpec('main.m') main_file_spec = lldb.SBFileSpec('main.m')
breakpoint = target.BreakpointCreateBySourceRegex( breakpoint = target.BreakpointCreateBySourceRegex(
'break', main_file_spec) 'break', main_file_spec)
self.assertTrue(breakpoint and self.assertTrue(breakpoint and
Show All 19 Lines

packages/Python/lldbsuite/test/lang/objc/radar-9691614/TestObjCMethodReturningBOOL.py

Show All 27 Lines def setUp(self):
self.line = line_number(self.main_source, '// Set breakpoint here.') self.line = line_number(self.main_source, '// Set breakpoint here.')
def test_method_ret_BOOL(self): def test_method_ret_BOOL(self):
"""Test that objective-c method returning BOOL works correctly.""" """Test that objective-c method returning BOOL works correctly."""
d = {'EXE': self.exe_name} d = {'EXE': self.exe_name}
self.build(dictionary=d) self.build(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.m", self.line, num_expected_locations=1, loc_exact=True) self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.expect("process status", STOPPED_DUE_TO_BREAKPOINT, self.expect("process status", STOPPED_DUE_TO_BREAKPOINT,
substrs=[" at %s:%d" % (self.main_source, self.line), substrs=[" at %s:%d" % (self.main_source, self.line),
"stop reason = breakpoint"]) "stop reason = breakpoint"])
# rdar://problem/9691614 # rdar://problem/9691614
self.runCmd('p (int)[my isValid]') self.runCmd('p (int)[my isValid]')

packages/Python/lldbsuite/test/lang/objc/rdar-10967107/TestRdar10967107.py

Show All 27 Lines def setUp(self):
self.line = line_number(self.main_source, '// Set breakpoint here.') self.line = line_number(self.main_source, '// Set breakpoint here.')
def test_cfrange_diff_cfgregoriandate(self): def test_cfrange_diff_cfgregoriandate(self):
"""Test that CoreFoundation classes CFGregorianDate and CFRange are not improperly uniqued.""" """Test that CoreFoundation classes CFGregorianDate and CFRange are not improperly uniqued."""
d = {'EXE': self.exe_name} d = {'EXE': self.exe_name}
self.build(dictionary=d) self.build(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, self,
self.main_source, self.main_source,
self.line, self.line,
num_expected_locations=1, num_expected_locations=1,
loc_exact=True) loc_exact=True)
Show All 29 Lines

packages/Python/lldbsuite/test/lang/objc/rdar-11355592/TestRdar11355592.py

Show All 27 Lines def setUp(self):
self.line = line_number(self.main_source, '// Set breakpoint here.') self.line = line_number(self.main_source, '// Set breakpoint here.')
def test_charstar_dyntype(self): def test_charstar_dyntype(self):
"""Test that we do not attempt to make a dynamic type for a 'const char*'""" """Test that we do not attempt to make a dynamic type for a 'const char*'"""
d = {'EXE': self.exe_name} d = {'EXE': self.exe_name}
self.build(dictionary=d) self.build(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, self,
self.main_source, self.main_source,
self.line, self.line,
num_expected_locations=1, num_expected_locations=1,
loc_exact=True) loc_exact=True)
Show All 38 Lines

packages/Python/lldbsuite/test/lang/objc/rdar-12408181/TestRdar12408181.py

Show All 27 Lines def setUp(self):
self.line = line_number(self.main_source, '// Set breakpoint here.') self.line = line_number(self.main_source, '// Set breakpoint here.')
def test_nswindow_count(self): def test_nswindow_count(self):
"""Test that we are able to find out how many children NSWindow has.""" """Test that we are able to find out how many children NSWindow has."""
d = {'EXE': self.exe_name} d = {'EXE': self.exe_name}
self.build(dictionary=d) self.build(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, self,
self.main_source, self.main_source,
self.line, self.line,
num_expected_locations=1, num_expected_locations=1,
loc_exact=True) loc_exact=True)
Show All 20 Lines

packages/Python/lldbsuite/test/lang/objc/real-definition/TestRealDefinition.py

Show First 20 Lines • Show All 86 Lines • ▼ Show 20 Lines def test_frame_var_after_stop_at_implementation(self):
self.expect( self.expect(
"frame variable foo->_bar->_hidden_ivar", "frame variable foo->_bar->_hidden_ivar",
VARIABLES_DISPLAYED_CORRECTLY, VARIABLES_DISPLAYED_CORRECTLY,
substrs=[ substrs=[
"(NSString *)", "(NSString *)",
"foo->_bar->_hidden_ivar = 0x"]) "foo->_bar->_hidden_ivar = 0x"])
def common_setup(self): def common_setup(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the foo function which takes a bar_ptr argument. # Break inside the foo function which takes a bar_ptr argument.
line = line_number('main.m', '// Set breakpoint in main') line = line_number('main.m', '// Set breakpoint in main')
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.m", line, num_expected_locations=1, loc_exact=True) self, "main.m", line, num_expected_locations=1, loc_exact=True)

packages/Python/lldbsuite/test/lang/objc/single-entry-dictionary/TestObjCSingleEntryDictionary.py

Show All 24 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break inside main(). # Find the line number to break inside main().
self.line = line_number('main.m', '// break here') self.line = line_number('main.m', '// break here')
@skipUnlessDarwin @skipUnlessDarwin
@expectedFailureAll(oslist=['watchos'], bugnumber="rdar://problem/34642736") # bug in NSDictionary formatting on watchos @expectedFailureAll(oslist=['watchos'], bugnumber="rdar://problem/34642736") # bug in NSDictionary formatting on watchos
def test_single_entry_dict(self): def test_single_entry_dict(self):
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the foo function which takes a bar_ptr argument. # Break inside the foo function which takes a bar_ptr argument.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.m", self.line, num_expected_locations=1, loc_exact=True) self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 38 Lines

packages/Python/lldbsuite/test/linux/add-symbols/TestTargetSymbolsAddCommand.py

Show All 17 Linesclass TargetSymbolsAddCommand(TestBase):
@no_debug_info_test # Prevent the genaration of the dwarf version of this test @no_debug_info_test # Prevent the genaration of the dwarf version of this test
@skipUnlessPlatform(['linux']) @skipUnlessPlatform(['linux'])
def test_target_symbols_add(self): def test_target_symbols_add(self):
"""Test that 'target symbols add' can load the symbols """Test that 'target symbols add' can load the symbols
even if gnu.build-id and gnu_debuglink are not present in the module. even if gnu.build-id and gnu_debuglink are not present in the module.
Similar to test_add_dsym_mid_execution test for macos.""" Similar to test_add_dsym_mid_execution test for macos."""
self.build(clean=True) self.build(clean=True)
exe = os.path.join(os.getcwd(), "stripped.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "stripped.out")
self.target = self.dbg.CreateTarget(exe) self.target = self.dbg.CreateTarget(exe)
self.assertTrue(self.target, VALID_TARGET) self.assertTrue(self.target, VALID_TARGET)
main_bp = self.target.BreakpointCreateByName("main", "stripped.out") main_bp = self.target.BreakpointCreateByName("main", "stripped.out")
self.assertTrue(main_bp, VALID_BREAKPOINT) self.assertTrue(main_bp, VALID_BREAKPOINT)
self.process = self.target.LaunchSimple( self.process = self.target.LaunchSimple(
Show All 18 Lines

packages/Python/lldbsuite/test/linux/thread/create_during_instruction_step/TestCreateDuringInstructionStep.py

Show All 20 Linesclass CreateDuringInstructionStepTestCase(TestBase):
@skipUnlessPlatform(['linux']) @skipUnlessPlatform(['linux'])
@expectedFailureAndroid('llvm.org/pr24737', archs=['arm']) @expectedFailureAndroid('llvm.org/pr24737', archs=['arm'])
@expectedFailureAll( @expectedFailureAll(
oslist=["linux"], oslist=["linux"],
archs=["arm"], archs=["arm"],
bugnumber="llvm.org/pr24737") bugnumber="llvm.org/pr24737")
def test_step_inst(self): def test_step_inst(self):
self.build(dictionary=self.getBuildFlags()) self.build(dictionary=self.getBuildFlags())
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target and target.IsValid(), "Target is valid") self.assertTrue(target and target.IsValid(), "Target is valid")
# This should create a breakpoint in the stepping thread. # This should create a breakpoint in the stepping thread.
breakpoint = target.BreakpointCreateByName("main") breakpoint = target.BreakpointCreateByName("main")
self.assertTrue( self.assertTrue(
breakpoint and breakpoint.IsValid(), breakpoint and breakpoint.IsValid(),
"Breakpoint is valid") "Breakpoint is valid")
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lldbinline.py

Show First 20 Lines • Show All 161 Lines • ▼ Show 20 Lines def __test_with_gmodules(self):
self.buildGModules() self.buildGModules()
self.do_test() self.do_test()
def execute_user_command(self, __command): def execute_user_command(self, __command):
exec(__command, globals(), locals()) exec(__command, globals(), locals())
def do_test(self): def do_test(self):
exe_name = "a.out" exe_name = "a.out"
exe = os.path.join(os.getcwd(), exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, exe_name)
source_files = [f for f in os.listdir(os.getcwd()) if source_type(f)] source_files = [f for f in os.listdir(os.getcwd()) if source_type(f)]
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
parser = CommandParser() parser = CommandParser()
parser.parse_source_files(source_files) parser.parse_source_files(source_files)
parser.set_breakpoints(target) parser.set_breakpoints(target)
process = target.LaunchSimple(None, None, os.getcwd()) process = target.LaunchSimple(None, None, os.getcwd())
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lldbtest.py

Show First 20 Lines • Show All 1,816 Lines • ▼ Show 20 Linesclass TestBase(Base):
maxLaunchCount = 3 maxLaunchCount = 3
# Time to wait before the next launching attempt in second(s). # Time to wait before the next launching attempt in second(s).
# Can be overridden by the LLDB_TIME_WAIT_NEXT_LAUNCH environment variable. # Can be overridden by the LLDB_TIME_WAIT_NEXT_LAUNCH environment variable.
timeWaitNextLaunch = 1.0 timeWaitNextLaunch = 1.0
def generateSource(self, source): def generateSource(self, source):
template = source + '.template' template = source + '.template'
temp = os.path.join(os.getcwd(), template) temp = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, template)
with open(temp, 'r') as f: with open(temp, 'r') as f:
content = f.read() content = f.read()
public_api_dir = os.path.join( public_api_dir = os.path.join(
os.environ["LLDB_SRC"], "include", "lldb", "API") os.environ["LLDB_SRC"], "include", "lldb", "API")
# Look under the include/lldb/API directory and add #include statements # Look under the include/lldb/API directory and add #include statements
# for all the SB API headers. # for all the SB API headers.
public_headers = os.listdir(public_api_dir) public_headers = os.listdir(public_api_dir)
# For different platforms, the include statement can vary. # For different platforms, the include statement can vary.
if self.hasDarwinFramework(): if self.hasDarwinFramework():
include_stmt = "'#include <%s>' % os.path.join('LLDB', header)" include_stmt = "'#include <%s>' % os.path.join('LLDB', header)"
else: else:
include_stmt = "'#include <%s>' % os.path.join('" + public_api_dir + "', header)" include_stmt = "'#include <%s>' % os.path.join('" + public_api_dir + "', header)"
list = [eval(include_stmt) for header in public_headers if ( list = [eval(include_stmt) for header in public_headers if (
header.startswith("SB") and header.endswith(".h"))] header.startswith("SB") and header.endswith(".h"))]
includes = '\n'.join(list) includes = '\n'.join(list)
new_content = content.replace('%include_SB_APIs%', includes) new_content = content.replace('%include_SB_APIs%', includes)
src = os.path.join(os.getcwd(), source) src = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, source)
with open(src, 'w') as f: with open(src, 'w') as f:
f.write(new_content) f.write(new_content)
self.addTearDownHook(lambda: os.remove(src)) self.addTearDownHook(lambda: os.remove(src))
def setUp(self): def setUp(self):
#import traceback #import traceback
# traceback.print_stack() # traceback.print_stack()
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines def registerSharedLibrariesWithTarget(self, target, shlibs):
else: else:
# Check relative names # Check relative names
local_shlib_path = os.path.join( local_shlib_path = os.path.join(
os.getcwd(), shlib_prefix + name + shlib_extension) os.getcwd(), shlib_prefix + name + shlib_extension)
if not os.path.exists(local_shlib_path): if not os.path.exists(local_shlib_path):
local_shlib_path = os.path.join( local_shlib_path = os.path.join(
os.getcwd(), name + shlib_extension) os.getcwd(), name + shlib_extension)
if not os.path.exists(local_shlib_path): if not os.path.exists(local_shlib_path):
local_shlib_path = os.path.join(os.getcwd(), name) local_shlib_path = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, name)
# Make sure we found the local shared library in the above code # Make sure we found the local shared library in the above code
self.assertTrue(os.path.exists(local_shlib_path)) self.assertTrue(os.path.exists(local_shlib_path))
# Add the shared library to our target # Add the shared library to our target
shlib_module = target.AddModule(local_shlib_path, None, None, None) shlib_module = target.AddModule(local_shlib_path, None, None, None)
if lldb.remote_platform: if lldb.remote_platform:
# We must set the remote install location if we want the shared library # We must set the remote install location if we want the shared library
▲ Show 20 Lines • Show All 428 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/lldbutil.py

Show First 20 Lines • Show All 731 Lines • ▼ Show 20 Lines """Start up a target, using exe_name as the executable, and run it to
an SBLaunchInfo. If you do that, remember to set the working directory as well. an SBLaunchInfo. If you do that, remember to set the working directory as well.
If your executable isn't called a.out, you can pass that in. And if your executable isn't If your executable isn't called a.out, you can pass that in. And if your executable isn't
in the CWD, pass in the absolute path to the executable in exe_name, and set in_cwd to False. in the CWD, pass in the absolute path to the executable in exe_name, and set in_cwd to False.
If the target isn't valid, the breakpoint isn't found, or hit, the If the target isn't valid, the breakpoint isn't found, or hit, the
function will cause a testsuite failure. function will cause a testsuite failure.
If successful it returns a tuple with the target process and thread that hit the breakpoint.""" If successful it returns a tuple with the target process and thread that hit the breakpoint."""
if in_cwd: if in_cwd:
exe = os.path.join(os.getcwd(), exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, exe_name)
# Create the target # Create the target
target = test.dbg.CreateTarget(exe) target = test.dbg.CreateTarget(exe)
test.assertTrue(target, "Target: %s is not valid."%(exe_name)) test.assertTrue(target, "Target: %s is not valid."%(exe_name))
# Set the breakpoints # Set the breakpoints
breakpoint = target.BreakpointCreateBySourceRegex( breakpoint = target.BreakpointCreateBySourceRegex(
bkpt_pattern, source_spec) bkpt_pattern, source_spec)
▲ Show 20 Lines • Show All 445 Lines • ▼ Show 20 Lines if lldb.remote_platform.GetName() == 'remote-windows':
return os.path.join(*paths).replace(os.path.sep, '\\') return os.path.join(*paths).replace(os.path.sep, '\\')
return os.path.join(*paths).replace(os.path.sep, '/') return os.path.join(*paths).replace(os.path.sep, '/')
def append_to_process_working_directory(*paths): def append_to_process_working_directory(*paths):
remote = lldb.remote_platform remote = lldb.remote_platform
if remote: if remote:
return join_remote_paths(remote.GetWorkingDirectory(), *paths) return join_remote_paths(remote.GetWorkingDirectory(), *paths)
return os.path.join(os.getcwd(), *paths) return os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, *paths)
# ================================================== # ==================================================
# Utility functions to get the correct signal number # Utility functions to get the correct signal number
# ================================================== # ==================================================
import signal import signal
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/logging/TestLogging.py

Show All 28 Linesclass LogTestCase(TestBase):
def test(self): def test(self):
self.build() self.build()
if self.debug_info == "dsym": if self.debug_info == "dsym":
self.command_log_tests("dsym") self.command_log_tests("dsym")
else: else:
self.command_log_tests("dwarf") self.command_log_tests("dwarf")
def command_log_tests(self, type): def command_log_tests(self, type):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.expect("file " + exe, self.expect("file " + exe,
patterns=["Current executable set to .*a.out"]) patterns=["Current executable set to .*a.out"])
log_file = os.path.join( log_file = os.path.join(
os.getcwd(), os.getcwd(),
"lldb-commands-log-%s-%s-%s.txt" % "lldb-commands-log-%s-%s-%s.txt" %
(type, (type,
os.path.basename( os.path.basename(
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/macosx/add-dsym/TestAddDsymMidExecutionCommand.py

Show All 20 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
self.source = 'main.c' self.source = 'main.c'
@no_debug_info_test # Prevent the genaration of the dwarf version of this test @no_debug_info_test # Prevent the genaration of the dwarf version of this test
def test_add_dsym_mid_execution(self): def test_add_dsym_mid_execution(self):
"""Test that add-dsym mid-execution loads the symbols at the right place for a slid binary.""" """Test that add-dsym mid-execution loads the symbols at the right place for a slid binary."""
self.buildDsym(clean=True) self.buildDsym(clean=True)
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.target = self.dbg.CreateTarget(exe) self.target = self.dbg.CreateTarget(exe)
self.assertTrue(self.target, VALID_TARGET) self.assertTrue(self.target, VALID_TARGET)
main_bp = self.target.BreakpointCreateByName("main", "a.out") main_bp = self.target.BreakpointCreateByName("main", "a.out")
self.assertTrue(main_bp, VALID_BREAKPOINT) self.assertTrue(main_bp, VALID_BREAKPOINT)
self.runCmd("settings set target.disable-aslr false") self.runCmd("settings set target.disable-aslr false")
Show All 12 Lines

packages/Python/lldbsuite/test/macosx/debug-info/apple_types/TestAppleTypesIsProduced.py

Show All 25 Lines def test_debug_info_for_apple_types(self):
if not self.getCompiler().endswith('clang'): if not self.getCompiler().endswith('clang'):
self.skipTest("clang compiler only test") self.skipTest("clang compiler only test")
self.build() self.build()
if self.debug_info == "dsym": if self.debug_info == "dsym":
exe = os.path.join(os.getcwd(), exe = os.path.join(os.getcwd(),
"a.out.dSYM/Contents/Resources/DWARF/a.out") "a.out.dSYM/Contents/Resources/DWARF/a.out")
else: else:
exe = os.path.join(os.getcwd(), "main.o") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "main.o")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
self.assertTrue(target.GetNumModules() > 0) self.assertTrue(target.GetNumModules() > 0)
# Hide stdout if not running with '-t' option. # Hide stdout if not running with '-t' option.
if not self.TraceOn(): if not self.TraceOn():
self.HideStdout() self.HideStdout()
Show All 29 Lines

packages/Python/lldbsuite/test/macosx/find-dsym/bundle-with-dot-in-filename/TestBundleWithDotInFilename.py

Show All 31 Lines def tearDown(self):
# Destroy process before TestBase.tearDown() # Destroy process before TestBase.tearDown()
self.dbg.GetSelectedTarget().GetProcess().Destroy() self.dbg.GetSelectedTarget().GetProcess().Destroy()
# Call super's tearDown(). # Call super's tearDown().
TestBase.tearDown(self) TestBase.tearDown(self)
def test_attach_and_check_dsyms(self): def test_attach_and_check_dsyms(self):
"""Test attach to binary, see if the bundle dSYM is found""" """Test attach to binary, see if the bundle dSYM is found"""
exe = os.path.join(os.getcwd(), exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, exe_name)
self.build() self.build()
popen = self.spawnSubprocess(exe) popen = self.spawnSubprocess(exe)
self.addTearDownHook(self.cleanupSubprocesses) self.addTearDownHook(self.cleanupSubprocesses)
# Give the inferior time to start up, dlopen a bundle, remove the bundle it linked in # Give the inferior time to start up, dlopen a bundle, remove the bundle it linked in
sleep(5) sleep(5)
# Since the library that was dlopen()'ed is now removed, lldb will need to find the # Since the library that was dlopen()'ed is now removed, lldb will need to find the
Show All 23 Lines

packages/Python/lldbsuite/test/macosx/find-dsym/deep-bundle/TestDeepBundle.py

Show All 31 Lines def tearDown(self):
# Destroy process before TestBase.tearDown() # Destroy process before TestBase.tearDown()
self.dbg.GetSelectedTarget().GetProcess().Destroy() self.dbg.GetSelectedTarget().GetProcess().Destroy()
# Call super's tearDown(). # Call super's tearDown().
TestBase.tearDown(self) TestBase.tearDown(self)
def test_attach_and_check_dsyms(self): def test_attach_and_check_dsyms(self):
"""Test attach to binary, see if the framework dSYM is found""" """Test attach to binary, see if the framework dSYM is found"""
exe = os.path.join(os.getcwd(), exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, exe_name)
self.build() self.build()
popen = self.spawnSubprocess(exe) popen = self.spawnSubprocess(exe)
self.addTearDownHook(self.cleanupSubprocesses) self.addTearDownHook(self.cleanupSubprocesses)
# Give the inferior time to start up, dlopen a bundle, remove the bundle it linked in # Give the inferior time to start up, dlopen a bundle, remove the bundle it linked in
sleep(5) sleep(5)
# Since the library that was dlopen()'ed is now removed, lldb will need to find the # Since the library that was dlopen()'ed is now removed, lldb will need to find the
Show All 27 Lines

packages/Python/lldbsuite/test/macosx/indirect_symbol/TestIndirectSymbols.py

Show All 20 Lines def setUp(self):
# Find the line numbers that we will step to in main: # Find the line numbers that we will step to in main:
self.main_source = "main.c" self.main_source = "main.c"
@skipUnlessDarwin @skipUnlessDarwin
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_with_python_api(self): def test_with_python_api(self):
"""Test stepping and setting breakpoints in indirect and re-exported symbols.""" """Test stepping and setting breakpoints in indirect and re-exported symbols."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
if self.platformIsDarwin(): if self.platformIsDarwin():
lib1 = os.path.join(os.getcwd(), 'libindirect.dylib') lib1 = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, 'libindirect.dylib')
lib2 = os.path.join(os.getcwd(), 'libreexport.dylib') lib2 = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, 'libreexport.dylib')
self.registerSharedLibrariesWithTarget(target, [lib1, lib2]) self.registerSharedLibrariesWithTarget(target, [lib1, lib2])
self.main_source_spec = lldb.SBFileSpec(self.main_source) self.main_source_spec = lldb.SBFileSpec(self.main_source)
break1 = target.BreakpointCreateBySourceRegex( break1 = target.BreakpointCreateBySourceRegex(
"Set breakpoint here to step in indirect.", self.main_source_spec) "Set breakpoint here to step in indirect.", self.main_source_spec)
self.assertTrue(break1, VALID_BREAKPOINT) self.assertTrue(break1, VALID_BREAKPOINT)
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/macosx/nslog/TestDarwinNSLogOutput.py

Show First 20 Lines • Show All 105 Lines • ▼ Show 20 Lines def expect(self, pattern, exactly=False, *args, **kwargs):
return self.child.expect_exact(pattern, *args, **kwargs) return self.child.expect_exact(pattern, *args, **kwargs)
return self.child.expect(pattern, *args, **kwargs) return self.child.expect(pattern, *args, **kwargs)
def do_test(self, expect_regexes=None, settings_commands=None): def do_test(self, expect_regexes=None, settings_commands=None):
""" Run a test. """ """ Run a test. """
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.exe_name)
self.run_lldb_to_breakpoint(exe, self.source, self.line, self.run_lldb_to_breakpoint(exe, self.source, self.line,
settings_commands=settings_commands) settings_commands=settings_commands)
self.expect_prompt() self.expect_prompt()
# Now go. # Now go.
self.runCmd("process continue") self.runCmd("process continue")
self.expect(expect_regexes) self.expect(expect_regexes)
Show All 31 Lines

packages/Python/lldbsuite/test/macosx/order/TestOrderFile.py

Show All 16 Lines
class OrderFileTestCase(TestBase): class OrderFileTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipUnlessDarwin @skipUnlessDarwin
def test(self): def test(self):
"""Test debug symbols follow the correct order by the order file.""" """Test debug symbols follow the correct order by the order file."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Test that the debug symbols have Function f3 before Function f1. # Test that the debug symbols have Function f3 before Function f1.
# Use "-s address" option to sort by address. # Use "-s address" option to sort by address.
self.runCmd("image dump symtab -s address a.out") self.runCmd("image dump symtab -s address a.out")
output = self.res.GetOutput() output = self.res.GetOutput()
mo_f3 = re.search("Code +.+f3", output) mo_f3 = re.search("Code +.+f3", output)
mo_f1 = re.search("Code +.+f1", output) mo_f1 = re.search("Code +.+f1", output)
# Match objects for f3 and f1 must exist and f3 must come before f1. # Match objects for f3 and f1 must exist and f3 must come before f1.
self.assertTrue(mo_f3 and mo_f1 and mo_f3.start() < mo_f1.start(), self.assertTrue(mo_f3 and mo_f1 and mo_f3.start() < mo_f1.start(),
"Symbols have correct order by the order file") "Symbols have correct order by the order file")
self.runCmd("run", RUN_COMPLETED) self.runCmd("run", RUN_COMPLETED)

packages/Python/lldbsuite/test/macosx/queues/TestQueues.py

Show First 20 Lines • Show All 99 Lines • ▼ Show 20 Lines def check_queues_threads_match_queue(self, queue):
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 = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
self.main_source_spec = lldb.SBFileSpec(self.main_source) self.main_source_spec = lldb.SBFileSpec(self.main_source)
break1 = target.BreakpointCreateByName("stopper", 'a.out') break1 = target.BreakpointCreateByName("stopper", 'a.out')
self.assertTrue(break1, VALID_BREAKPOINT) self.assertTrue(break1, VALID_BREAKPOINT)
process = target.LaunchSimple( process = target.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
▲ Show 20 Lines • Show All 124 Lines • ▼ Show 20 Lines def queues(self):
stream), stream),
"Get QoS printable string for background QoS thread") "Get QoS printable string for background QoS thread")
self.assertTrue( self.assertTrue(
stream.GetData() == "Background", stream.GetData() == "Background",
"background QoS thread name is valid") "background QoS thread name is valid")
def queues_with_libBacktraceRecording(self): def queues_with_libBacktraceRecording(self):
"""Test queues inspection SB APIs with libBacktraceRecording present.""" """Test queues inspection SB APIs with libBacktraceRecording present."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
if not os.path.isfile( if not os.path.isfile(
'/Applications/Xcode.app/Contents/Developer/usr/lib/libBacktraceRecording.dylib'): '/Applications/Xcode.app/Contents/Developer/usr/lib/libBacktraceRecording.dylib'):
self.skipTest( self.skipTest(
"Skipped because libBacktraceRecording.dylib was present on the system.") "Skipped because libBacktraceRecording.dylib was present on the system.")
if not os.path.isfile( if not os.path.isfile(
'/usr/lib/system/introspection/libdispatch.dylib'): '/usr/lib/system/introspection/libdispatch.dylib'):
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/macosx/safe-to-func-call/TestSafeFuncCalls.py

Show All 20 Lines def setUp(self):
# Find the line numbers that we will step to in main: # Find the line numbers that we will step to in main:
self.main_source = "main.c" self.main_source = "main.c"
@skipUnlessDarwin @skipUnlessDarwin
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_with_python_api(self): def test_with_python_api(self):
"""Test function call thread safety.""" """Test function call thread safety."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
self.main_source_spec = lldb.SBFileSpec(self.main_source) self.main_source_spec = lldb.SBFileSpec(self.main_source)
break1 = target.BreakpointCreateByName("stopper", 'a.out') break1 = target.BreakpointCreateByName("stopper", 'a.out')
self.assertTrue(break1, VALID_BREAKPOINT) self.assertTrue(break1, VALID_BREAKPOINT)
process = target.LaunchSimple( process = target.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
Show All 36 Lines

packages/Python/lldbsuite/test/macosx/thread-names/TestInterruptThreadNames.py

Show All 17 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
@skipUnlessDarwin @skipUnlessDarwin
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_with_python_api(self): def test_with_python_api(self):
"""Test that we get thread names when interrupting a process.""" """Test that we get thread names when interrupting a process."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
launch_info = lldb.SBLaunchInfo(None) launch_info = lldb.SBLaunchInfo(None)
error = lldb.SBError() error = lldb.SBError()
lldb.debugger.SetAsync(True) lldb.debugger.SetAsync(True)
process = target.Launch(launch_info, error) process = target.Launch(launch_info, error)
▲ Show 20 Lines • Show All 105 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/macosx/universal/TestUniversal.py

Show All 27 Lines @unittest2.skipUnless(hasattr(os, "uname") and os.uname()[4] in [
'i386', 'x86_64'], "requires i386 or x86_64") 'i386', 'x86_64'], "requires i386 or x86_64")
@skipIfDarwinEmbedded # this test file assumes we're targetting an x86 system @skipIfDarwinEmbedded # this test file assumes we're targetting an x86 system
def test_sbdebugger_create_target_with_file_and_target_triple(self): def test_sbdebugger_create_target_with_file_and_target_triple(self):
"""Test the SBDebugger.CreateTargetWithFileAndTargetTriple() API.""" """Test the SBDebugger.CreateTargetWithFileAndTargetTriple() API."""
# Invoke the default build rule. # Invoke the default build rule.
self.build() self.build()
# Note that "testit" is a universal binary. # Note that "testit" is a universal binary.
exe = os.path.join(os.getcwd(), "testit") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "testit")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTargetWithFileAndTargetTriple( target = self.dbg.CreateTargetWithFileAndTargetTriple(
exe, "i386-apple-macosx") exe, "i386-apple-macosx")
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# 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)
@skipUnlessDarwin @skipUnlessDarwin
@unittest2.skipUnless(hasattr(os, "uname") and os.uname()[4] in [ @unittest2.skipUnless(hasattr(os, "uname") and os.uname()[4] in [
'i386', 'x86_64'], "requires i386 or x86_64") 'i386', 'x86_64'], "requires i386 or x86_64")
@skipIfDarwinEmbedded # this test file assumes we're targetting an x86 system @skipIfDarwinEmbedded # this test file assumes we're targetting an x86 system
def test_process_launch_for_universal(self): def test_process_launch_for_universal(self):
"""Test process launch of a universal binary.""" """Test process launch of a universal binary."""
from lldbsuite.test.lldbutil import print_registers from lldbsuite.test.lldbutil import print_registers
# Invoke the default build rule. # Invoke the default build rule.
self.build() self.build()
# Note that "testit" is a universal binary. # Note that "testit" is a universal binary.
exe = os.path.join(os.getcwd(), "testit") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "testit")
# By default, x86_64 is assumed if no architecture is specified. # By default, x86_64 is assumed if no architecture is specified.
self.expect("file " + exe, CURRENT_EXECUTABLE_SET, self.expect("file " + exe, CURRENT_EXECUTABLE_SET,
startstr="Current executable set to ", startstr="Current executable set to ",
substrs=["testit' (x86_64)."]) substrs=["testit' (x86_64)."])
# Break inside the main. # Break inside the main.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Lines def test_process_attach_with_wrong_arch(self):
# Now keep the architecture at 32 bit, but switch the binary we launch to # Now keep the architecture at 32 bit, but switch the binary we launch to
# 64 bit, and make sure on attach we switch to the correct # 64 bit, and make sure on attach we switch to the correct
# architecture. # architecture.
# Invoke the default build rule. # Invoke the default build rule.
self.build() self.build()
# Note that "testit" is a universal binary. # Note that "testit" is a universal binary.
exe = os.path.join(os.getcwd(), "testit") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "testit")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTargetWithFileAndTargetTriple( target = self.dbg.CreateTargetWithFileAndTargetTriple(
exe, "i386-apple-macosx") exe, "i386-apple-macosx")
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
pointer_size = target.GetAddressByteSize() pointer_size = target.GetAddressByteSize()
self.assertTrue(pointer_size == 4, "Initially we were 32 bit.") self.assertTrue(pointer_size == 4, "Initially we were 32 bit.")
Show All 31 Lines

packages/Python/lldbsuite/test/python_api/breakpoint/TestBreakpointAPI.py

Show All 17 Linesclass BreakpointAPITestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_breakpoint_is_valid(self): def test_breakpoint_is_valid(self):
"""Make sure that if an SBBreakpoint gets deleted its IsValid returns false.""" """Make sure that if an SBBreakpoint gets deleted its IsValid returns false."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Now create a breakpoint on main.c by name 'AFunction'. # Now create a breakpoint on main.c by name 'AFunction'.
breakpoint = target.BreakpointCreateByName('AFunction', 'a.out') breakpoint = target.BreakpointCreateByName('AFunction', 'a.out')
#print("breakpoint:", breakpoint) #print("breakpoint:", breakpoint)
Show All 17 Lines def test_breakpoint_is_valid(self):
"Breakpoint we deleted is no longer valid.") "Breakpoint we deleted is no longer valid.")
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_target_delete(self): def test_target_delete(self):
"""Make sure that if an SBTarget gets deleted the associated """Make sure that if an SBTarget gets deleted the associated
Breakpoint's IsValid returns false.""" Breakpoint's IsValid returns false."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Now create a breakpoint on main.c by name 'AFunction'. # Now create a breakpoint on main.c by name 'AFunction'.
breakpoint = target.BreakpointCreateByName('AFunction', 'a.out') breakpoint = target.BreakpointCreateByName('AFunction', 'a.out')
#print("breakpoint:", breakpoint) #print("breakpoint:", breakpoint)
Show All 9 Lines

packages/Python/lldbsuite/test/python_api/class_members/TestSBTypeClassMembers.py

Show All 28 Linesclass SBTypeMemberFunctionsTest(TestBase):
@skipUnlessDarwin @skipUnlessDarwin
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test(self): def test(self):
"""Test SBType APIs to fetch member function types.""" """Test SBType APIs to fetch member function types."""
d = {'EXE': self.exe_name} d = {'EXE': self.exe_name}
self.build(dictionary=d) self.build(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.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)
# Create the breakpoint inside function 'main'. # Create the breakpoint inside function 'main'.
breakpoint = target.BreakpointCreateByLocation(self.source, self.line) breakpoint = target.BreakpointCreateByLocation(self.source, self.line)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/python_api/event/TestEvents.py

Show All 27 Linesclass EventAPITestCase(TestBase):
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@expectedFailureAll( @expectedFailureAll(
oslist=["linux"], oslist=["linux"],
bugnumber="llvm.org/pr23730 Flaky, fails ~1/10 cases") bugnumber="llvm.org/pr23730 Flaky, fails ~1/10 cases")
def test_listen_for_and_print_event(self): def test_listen_for_and_print_event(self):
"""Exercise SBEvent API.""" """Exercise SBEvent API."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.dbg.SetAsync(True) self.dbg.SetAsync(True)
# 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)
# Now create a breakpoint on main.c by name 'c'. # Now create a breakpoint on main.c by name 'c'.
▲ Show 20 Lines • Show All 72 Lines • ▼ Show 20 Lines def test_listen_for_and_print_event(self):
# Shouldn't we be testing against some kind of expectation here? # Shouldn't we be testing against some kind of expectation here?
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@expectedFlakeyLinux("llvm.org/pr23730") # Flaky, fails ~1/100 cases @expectedFlakeyLinux("llvm.org/pr23730") # Flaky, fails ~1/100 cases
@expectedFlakeyOS(oslist=["windows"]) @expectedFlakeyOS(oslist=["windows"])
def test_wait_for_event(self): def test_wait_for_event(self):
"""Exercise SBListener.WaitForEvent() API.""" """Exercise SBListener.WaitForEvent() API."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.dbg.SetAsync(True) self.dbg.SetAsync(True)
# 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)
# Now create a breakpoint on main.c by name 'c'. # Now create a breakpoint on main.c by name 'c'.
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Linesclass EventAPITestCase(TestBase):
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@expectedFailureAll( @expectedFailureAll(
oslist=["linux"], oslist=["linux"],
bugnumber="llvm.org/pr23617 Flaky, fails ~1/10 cases") bugnumber="llvm.org/pr23617 Flaky, fails ~1/10 cases")
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
def test_add_listener_to_broadcaster(self): def test_add_listener_to_broadcaster(self):
"""Exercise some SBBroadcaster APIs.""" """Exercise some SBBroadcaster APIs."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.dbg.SetAsync(True) self.dbg.SetAsync(True)
# 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)
# Now create a breakpoint on main.c by name 'c'. # Now create a breakpoint on main.c by name 'c'.
▲ Show 20 Lines • Show All 100 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/python_api/findvalue_duplist/TestSBFrameFindValue.py

Show All 17 Linesclass SBFrameFindValueTestCase(TestBase):
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_formatters_api(self): def test_formatters_api(self):
"""Test that SBFrame::FindValue finds things but does not duplicate the entire variables list""" """Test that SBFrame::FindValue finds things but does not duplicate the entire variables list"""
self.build() self.build()
self.setTearDownCleanup() self.setTearDownCleanup()
exe_name = "a.out" exe_name = "a.out"
exe = os.path.join(os.getcwd(), exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, exe_name)
# Create the target # Create the target
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Set the breakpoints # Set the breakpoints
breakpoint = target.BreakpointCreateBySourceRegex( breakpoint = target.BreakpointCreateBySourceRegex(
'Set breakpoint here', lldb.SBFileSpec("main.cpp")) 'Set breakpoint here', lldb.SBFileSpec("main.cpp"))
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/python_api/frame/TestFrames.py

Show All 18 Linesclass FrameAPITestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
def test_get_arg_vals_for_call_stack(self): def test_get_arg_vals_for_call_stack(self):
"""Exercise SBFrame.GetVariables() API to get argument vals.""" """Exercise SBFrame.GetVariables() API to get argument vals."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Now create a breakpoint on main.c by name 'c'. # Now create a breakpoint on main.c by name 'c'.
breakpoint = target.BreakpointCreateByName('c', 'a.out') breakpoint = target.BreakpointCreateByName('c', 'a.out')
#print("breakpoint:", breakpoint) #print("breakpoint:", breakpoint)
▲ Show 20 Lines • Show All 86 Lines • ▼ Show 20 Lines def test_get_arg_vals_for_call_stack(self):
exe=False, exe=False,
substrs=["a((int)val=1, (char)ch='A')", substrs=["a((int)val=1, (char)ch='A')",
"a((int)val=3, (char)ch='A')"]) "a((int)val=3, (char)ch='A')"])
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_frame_api_boundary_condition(self): def test_frame_api_boundary_condition(self):
"""Exercise SBFrame APIs with boundary condition inputs.""" """Exercise SBFrame APIs with boundary condition inputs."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Now create a breakpoint on main.c by name 'c'. # Now create a breakpoint on main.c by name 'c'.
breakpoint = target.BreakpointCreateByName('c', 'a.out') breakpoint = target.BreakpointCreateByName('c', 'a.out')
#print("breakpoint:", breakpoint) #print("breakpoint:", breakpoint)
Show All 25 Lines def test_frame_api_boundary_condition(self):
print("val2:", val2) print("val2:", val2)
frame.EvaluateExpression(None) frame.EvaluateExpression(None)
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_frame_api_IsEqual(self): def test_frame_api_IsEqual(self):
"""Exercise SBFrame API IsEqual.""" """Exercise SBFrame API IsEqual."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Now create a breakpoint on main.c by name 'c'. # Now create a breakpoint on main.c by name 'c'.
breakpoint = target.BreakpointCreateByName('c', 'a.out') breakpoint = target.BreakpointCreateByName('c', 'a.out')
#print("breakpoint:", breakpoint) #print("breakpoint:", breakpoint)
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/python_api/frame/get-variables/TestGetVariables.py

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Linesclass TestGetVariables(TestBase):
def test(self): def test(self):
self.build() self.build()
# Set debugger into synchronous mode # Set debugger into synchronous mode
self.dbg.SetAsync(False) self.dbg.SetAsync(False)
# Create a target by the debugger. # Create a target by the debugger.
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
line1 = line_number(self.source, '// breakpoint 1') line1 = line_number(self.source, '// breakpoint 1')
line2 = line_number(self.source, '// breakpoint 2') line2 = line_number(self.source, '// breakpoint 2')
line3 = line_number(self.source, '// breakpoint 3') line3 = line_number(self.source, '// breakpoint 3')
breakpoint1 = target.BreakpointCreateByLocation(self.source, line1) breakpoint1 = target.BreakpointCreateByLocation(self.source, line1)
▲ Show 20 Lines • Show All 234 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/python_api/frame/inlines/TestInlinedFrame.py

Show All 26 Lines def setUp(self):
self.source, '// This should correspond to the first break stop.') self.source, '// This should correspond to the first break stop.')
self.second_stop = line_number( self.second_stop = line_number(
self.source, '// This should correspond to the second break stop.') self.source, '// This should correspond to the second break stop.')
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_stop_at_outer_inline(self): def test_stop_at_outer_inline(self):
"""Exercise SBFrame.IsInlined() and SBFrame.GetFunctionName().""" """Exercise SBFrame.IsInlined() and SBFrame.GetFunctionName()."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Now create a breakpoint on main.c by the name of 'inner_inline'. # Now create a breakpoint on main.c by the name of 'inner_inline'.
breakpoint = target.BreakpointCreateByName('inner_inline', 'a.out') breakpoint = target.BreakpointCreateByName('inner_inline', 'a.out')
#print("breakpoint:", breakpoint) #print("breakpoint:", breakpoint)
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/python_api/function_symbol/TestDisasmAPI.py

Show All 25 Lines def setUp(self):
'main.c', '// Find the line number for breakpoint 1 here.') 'main.c', '// Find the line number for breakpoint 1 here.')
self.line2 = line_number( self.line2 = line_number(
'main.c', '// Find the line number for breakpoint 2 here.') 'main.c', '// Find the line number for breakpoint 2 here.')
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test(self): def test(self):
"""Exercise getting SBAddress objects, disassembly, and SBAddress APIs.""" """Exercise getting SBAddress objects, disassembly, and SBAddress APIs."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Now create the two breakpoints inside function 'a'. # Now create the two breakpoints inside function 'a'.
breakpoint1 = target.BreakpointCreateByLocation('main.c', self.line1) breakpoint1 = target.BreakpointCreateByLocation('main.c', self.line1)
breakpoint2 = target.BreakpointCreateByLocation('main.c', self.line2) breakpoint2 = target.BreakpointCreateByLocation('main.c', self.line2)
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/python_api/function_symbol/TestSymbolAPI.py

Show All 25 Lines def setUp(self):
'main.c', '// Find the line number for breakpoint 1 here.') 'main.c', '// Find the line number for breakpoint 1 here.')
self.line2 = line_number( self.line2 = line_number(
'main.c', '// Find the line number for breakpoint 2 here.') 'main.c', '// Find the line number for breakpoint 2 here.')
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test(self): def test(self):
"""Exercise some SBSymbol and SBAddress APIs.""" """Exercise some SBSymbol and SBAddress APIs."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Now create the two breakpoints inside function 'a'. # Now create the two breakpoints inside function 'a'.
breakpoint1 = target.BreakpointCreateByLocation('main.c', self.line1) breakpoint1 = target.BreakpointCreateByLocation('main.c', self.line1)
breakpoint2 = target.BreakpointCreateByLocation('main.c', self.line2) breakpoint2 = target.BreakpointCreateByLocation('main.c', self.line2)
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/python_api/hello_world/TestHelloWorld.py

Show All 15 Lines
class HelloWorldTestCase(TestBase): class HelloWorldTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Get the full path to our executable to be attached/debugged. # Get the full path to our executable to be attached/debugged.
self.exe = os.path.join(os.getcwd(), self.testMethodName) self.exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.testMethodName)
self.d = {'EXE': self.testMethodName} self.d = {'EXE': self.testMethodName}
# Find a couple of the line numbers within main.c. # Find a couple of the line numbers within main.c.
self.line1 = line_number('main.c', '// Set break point at this line.') self.line1 = line_number('main.c', '// Set break point at this line.')
self.line2 = line_number('main.c', '// Waiting to be attached...') self.line2 = line_number('main.c', '// Waiting to be attached...')
def tearDown(self): def tearDown(self):
# Destroy process before TestBase.tearDown() # Destroy process before TestBase.tearDown()
self.dbg.GetSelectedTarget().GetProcess().Destroy() self.dbg.GetSelectedTarget().GetProcess().Destroy()
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/python_api/interpreter/TestCommandInterpreterAPI.py

Show All 18 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break on inside main.cpp. # Find the line number to break on inside main.cpp.
self.line = line_number('main.c', 'Hello world.') self.line = line_number('main.c', 'Hello world.')
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_with_process_launch_api(self): def test_with_process_launch_api(self):
"""Test the SBCommandInterpreter APIs.""" """Test the SBCommandInterpreter APIs."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Retrieve the associated command interpreter from our debugger. # Retrieve the associated command interpreter from our debugger.
ci = self.dbg.GetCommandInterpreter() ci = self.dbg.GetCommandInterpreter()
self.assertTrue(ci, VALID_COMMAND_INTERPRETER) self.assertTrue(ci, VALID_COMMAND_INTERPRETER)
Show All 40 Lines

packages/Python/lldbsuite/test/python_api/lldbutil/frame/TestFrameUtils.py

Show All 21 Lines def setUp(self):
# Find the line number to break inside main(). # Find the line number to break inside main().
self.line = line_number('main.c', self.line = line_number('main.c',
"// Find the line number here.") "// Find the line number here.")
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_frame_utils(self): def test_frame_utils(self):
"""Test utility functions for the frame object.""" """Test utility functions for the frame object."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
breakpoint = target.BreakpointCreateByLocation("main.c", self.line) breakpoint = target.BreakpointCreateByLocation("main.c", self.line)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
# Now launch the process, and do not stop at entry point. # Now launch the process, and do not stop at entry point.
Show All 26 Lines

packages/Python/lldbsuite/test/python_api/lldbutil/iter/TestLLDBIterator.py

Show All 24 Lines def setUp(self):
self.line1 = line_number( self.line1 = line_number(
'main.cpp', '// Set break point at this line.') 'main.cpp', '// Set break point at this line.')
self.line2 = line_number('main.cpp', '// And that line.') self.line2 = line_number('main.cpp', '// And that line.')
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_lldb_iter_module(self): def test_lldb_iter_module(self):
"""Test module_iter works correctly for SBTarget -> SBModule.""" """Test module_iter works correctly for SBTarget -> SBModule."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line1) breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line1)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
# Now launch the process, and do not stop at entry point. # Now launch the process, and do not stop at entry point.
Show All 19 Lines def test_lldb_iter_module(self):
self.assertTrue( self.assertTrue(
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 = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line1) breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line1)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line2) breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line2)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
Show All 15 Lines def test_lldb_iter_breakpoint(self):
print("mine[%d]='%s'" % (i, get_description(mine[i]))) print("mine[%d]='%s'" % (i, get_description(mine[i])))
self.assertTrue(yours[i] == mine[i], self.assertTrue(yours[i] == mine[i],
"ID of yours[{0}] and mine[{0}] matches".format(i)) "ID of yours[{0}] and mine[{0}] matches".format(i))
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_lldb_iter_frame(self): def test_lldb_iter_frame(self):
"""Test iterator works correctly for SBProcess->SBThread->SBFrame.""" """Test iterator works correctly for SBProcess->SBThread->SBFrame."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line1) breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line1)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
# Now launch the process, and do not stop at entry point. # Now launch the process, and do not stop at entry point.
Show All 20 Lines

packages/Python/lldbsuite/test/python_api/lldbutil/iter/TestRegistersIterator.py

Show All 24 Lines def setUp(self):
self.line1 = line_number( self.line1 = line_number(
'main.cpp', '// Set break point at this line.') 'main.cpp', '// Set break point at this line.')
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@expectedFailureAll(oslist=["windows"]) @expectedFailureAll(oslist=["windows"])
def test_iter_registers(self): def test_iter_registers(self):
"""Test iterator works correctly for lldbutil.iter_registers().""" """Test iterator works correctly for lldbutil.iter_registers()."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line1) breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line1)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
# Now launch the process, and do not stop at entry point. # Now launch the process, and do not stop at entry point.
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/python_api/lldbutil/process/TestPrintStackTraces.py

Show All 31 Linesclass ThreadsStackTracesTestCase(TestBase):
@expectedFailureAll(triple='mips*') @expectedFailureAll(triple='mips*')
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
@expectedFlakeyAndroid("llvm.org/26492", archs=["arm"]) @expectedFlakeyAndroid("llvm.org/26492", archs=["arm"])
@expectedFlakeyLinux("llvm.org/pr27687") @expectedFlakeyLinux("llvm.org/pr27687")
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_stack_traces(self): def test_stack_traces(self):
"""Test SBprocess and SBThread APIs with printing of the stack traces.""" """Test SBprocess and SBThread APIs with printing of the stack traces."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line) breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
# Now launch the process, and do not stop at entry point. # Now launch the process, and do not stop at entry point.
Show All 15 Lines

packages/Python/lldbsuite/test/python_api/module_section/TestModuleAndSection.py

Show All 20 Linesclass ModuleAndSectionAPIsTestCase(TestBase):
# Py3 asserts due to a bug in SWIG. A fix for this was upstreamed into # Py3 asserts due to a bug in SWIG. A fix for this was upstreamed into
# SWIG 3.0.8. # SWIG 3.0.8.
@skipIf(py_version=['>=', (3, 0)], swig_version=['<', (3, 0, 8)]) @skipIf(py_version=['>=', (3, 0)], swig_version=['<', (3, 0, 8)])
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_module_and_section(self): def test_module_and_section(self):
"""Test module and section APIs.""" """Test module and section APIs."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
self.assertTrue(target.GetNumModules() > 0) self.assertTrue(target.GetNumModules() > 0)
# Hide stdout if not running with '-t' option. # Hide stdout if not running with '-t' option.
if not self.TraceOn(): if not self.TraceOn():
self.HideStdout() self.HideStdout()
Show All 34 Lines def test_module_and_section(self):
"symbol type: %s" % "symbol type: %s" %
symbol_type_to_str( symbol_type_to_str(
sym.GetType())) sym.GetType()))
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_module_and_section_boundary_condition(self): def test_module_and_section_boundary_condition(self):
"""Test module and section APIs by passing None when it expects a Python string.""" """Test module and section APIs by passing None when it expects a Python string."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
self.assertTrue(target.GetNumModules() > 0) self.assertTrue(target.GetNumModules() > 0)
# Hide stdout if not running with '-t' option. # Hide stdout if not running with '-t' option.
if not self.TraceOn(): if not self.TraceOn():
self.HideStdout() self.HideStdout()
Show All 24 Lines def test_module_and_section_boundary_condition(self):
if sec1: if sec1:
sec1.FindSubSection(None) sec1.FindSubSection(None)
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_module_compile_unit_iter(self): def test_module_compile_unit_iter(self):
"""Test module's compile unit iterator APIs.""" """Test module's compile unit iterator APIs."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
self.assertTrue(target.GetNumModules() > 0) self.assertTrue(target.GetNumModules() > 0)
# Hide stdout if not running with '-t' option. # Hide stdout if not running with '-t' option.
if not self.TraceOn(): if not self.TraceOn():
self.HideStdout() self.HideStdout()
Show All 14 Lines

packages/Python/lldbsuite/test/python_api/name_lookup/TestNameLookup.py

Show All 22 Linesclass TestNameLookup(TestBase):
def test_target(self): def test_target(self):
"""Exercise SBTarget.FindFunctions() with various name masks. """Exercise SBTarget.FindFunctions() with various name masks.
A previous regression caused mangled names to not be able to be looked up. A previous regression caused mangled names to not be able to be looked up.
This test verifies that using a mangled name with eFunctionNameTypeFull works This test verifies that using a mangled name with eFunctionNameTypeFull works
and that using a function basename with eFunctionNameTypeFull works for all and that using a function basename with eFunctionNameTypeFull works for all
C++ functions that are at the global namespace level.""" C++ functions that are at the global namespace level."""
self.build(); self.build();
exe = os.path.join(os.getcwd(), 'a.out') exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, 'a.out')
# 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)
exe_module = target.FindModule(target.GetExecutable()) exe_module = target.FindModule(target.GetExecutable())
c_name_to_symbol = {} c_name_to_symbol = {}
Show All 27 Lines

packages/Python/lldbsuite/test/python_api/objc_type/TestObjCType.py

Show All 22 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
self.line = line_number("main.m", '// Break at this line') self.line = line_number("main.m", '// Break at this line')
@skipUnlessDarwin @skipUnlessDarwin
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test(self): def test(self):
"""Test SBType for ObjC classes.""" """Test SBType for ObjC classes."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Create the breakpoint inside function 'main'. # Create the breakpoint inside function 'main'.
breakpoint = target.BreakpointCreateByLocation("main.m", self.line) breakpoint = target.BreakpointCreateByLocation("main.m", self.line)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
Show All 35 Lines

packages/Python/lldbsuite/test/python_api/process/TestProcessAPI.py

Show All 23 Lines def setUp(self):
self.line = line_number( self.line = line_number(
"main.cpp", "main.cpp",
"// Set break point at this line and check variable 'my_char'.") "// Set break point at this line and check variable 'my_char'.")
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_read_memory(self): def test_read_memory(self):
"""Test Python SBProcess.ReadMemory() API.""" """Test Python SBProcess.ReadMemory() API."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line) breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
# Launch the process, and do not stop at the entry point. # Launch the process, and do not stop at the entry point.
▲ Show 20 Lines • Show All 81 Lines • ▼ Show 20 Lines def test_read_memory(self):
if my_uint32 != 12345: if my_uint32 != 12345:
self.fail( self.fail(
"Result from SBProcess.ReadUnsignedFromMemory() does not match our expected output") "Result from SBProcess.ReadUnsignedFromMemory() does not match our expected output")
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_write_memory(self): def test_write_memory(self):
"""Test Python SBProcess.WriteMemory() API.""" """Test Python SBProcess.WriteMemory() API."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line) breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
# Launch the process, and do not stop at the entry point. # Launch the process, and do not stop at the entry point.
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines def test_write_memory(self):
"Result from SBProcess.ReadMemory() matches our expected output: 'a'", "Result from SBProcess.ReadMemory() matches our expected output: 'a'",
exe=False, exe=False,
startstr=b'a') startstr=b'a')
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_access_my_int(self): def test_access_my_int(self):
"""Test access 'my_int' using Python SBProcess.GetByteOrder() and other APIs.""" """Test access 'my_int' using Python SBProcess.GetByteOrder() and other APIs."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line) breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
# Launch the process, and do not stop at the entry point. # Launch the process, and do not stop at the entry point.
▲ Show 20 Lines • Show All 81 Lines • ▼ Show 20 Lines def test_access_my_int(self):
if self.TraceOn(): if self.TraceOn():
for i in content: for i in content:
print("byte:", i) print("byte:", i)
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_remote_launch(self): def test_remote_launch(self):
"""Test SBProcess.RemoteLaunch() API with a process not in eStateConnected, and it should fail.""" """Test SBProcess.RemoteLaunch() API with a process not in eStateConnected, and it should fail."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Launch the process, and do not stop at the entry point. # Launch the process, and do not stop at the entry point.
process = target.LaunchSimple( process = target.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
if self.TraceOn(): if self.TraceOn():
print("process state:", state_type_to_str(process.GetState())) print("process state:", state_type_to_str(process.GetState()))
self.assertTrue(process.GetState() != lldb.eStateConnected) self.assertTrue(process.GetState() != lldb.eStateConnected)
error = lldb.SBError() error = lldb.SBError()
success = process.RemoteLaunch( success = process.RemoteLaunch(
None, None, None, None, None, None, 0, False, error) None, None, None, None, None, None, 0, False, error)
self.assertTrue( self.assertTrue(
not success, not success,
"RemoteLaunch() should fail for process state != eStateConnected") "RemoteLaunch() should fail for process state != eStateConnected")
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_get_num_supported_hardware_watchpoints(self): def test_get_num_supported_hardware_watchpoints(self):
"""Test SBProcess.GetNumSupportedHardwareWatchpoints() API with a process.""" """Test SBProcess.GetNumSupportedHardwareWatchpoints() API with a process."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line) breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
# Launch the process, and do not stop at the entry point. # Launch the process, and do not stop at the entry point.
process = target.LaunchSimple( process = target.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
error = lldb.SBError() error = lldb.SBError()
num = process.GetNumSupportedHardwareWatchpoints(error) num = process.GetNumSupportedHardwareWatchpoints(error)
if self.TraceOn() and error.Success(): if self.TraceOn() and error.Success():
print("Number of supported hardware watchpoints: %d" % num) print("Number of supported hardware watchpoints: %d" % num)
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@no_debug_info_test @no_debug_info_test
def test_get_process_info(self): def test_get_process_info(self):
"""Test SBProcess::GetProcessInfo() API with a locally launched process.""" """Test SBProcess::GetProcessInfo() API with a locally launched process."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Launch the process and stop at the entry point. # Launch the process and stop at the entry point.
launch_info = lldb.SBLaunchInfo(None) launch_info = lldb.SBLaunchInfo(None)
launch_info.SetWorkingDirectory(self.get_process_working_directory()) launch_info.SetWorkingDirectory(self.get_process_working_directory())
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/python_api/process/io/TestProcessIO.py

Show All 14 Lines
class ProcessIOTestCase(TestBase): class ProcessIOTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Get the full path to our executable to be debugged. # Get the full path to our executable to be debugged.
self.exe = os.path.join(os.getcwd(), "process_io") self.exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "process_io")
self.local_input_file = os.path.join(os.getcwd(), "input.txt") self.local_input_file = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "input.txt")
self.local_output_file = os.path.join(os.getcwd(), "output.txt") self.local_output_file = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "output.txt")
self.local_error_file = os.path.join(os.getcwd(), "error.txt") self.local_error_file = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "error.txt")
self.input_file = os.path.join( self.input_file = os.path.join(
self.get_process_working_directory(), "input.txt") self.get_process_working_directory(), "input.txt")
self.output_file = os.path.join( self.output_file = os.path.join(
self.get_process_working_directory(), "output.txt") self.get_process_working_directory(), "output.txt")
self.error_file = os.path.join( self.error_file = os.path.join(
self.get_process_working_directory(), "error.txt") self.get_process_working_directory(), "error.txt")
self.lines = ["Line 1", "Line 2", "Line 3"] self.lines = ["Line 1", "Line 2", "Line 3"]
▲ Show 20 Lines • Show All 202 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/python_api/process/read-mem-cstring/TestReadMemCString.py

Show All 15 Linesclass TestReadMemCString(TestBase):
def test_read_memory_c_string(self): def test_read_memory_c_string(self):
"""Test corner case behavior of SBProcess::ReadCStringFromMemory""" """Test corner case behavior of SBProcess::ReadCStringFromMemory"""
self.build() self.build()
self.dbg.SetAsync(False) self.dbg.SetAsync(False)
self.main_source = "main.c" self.main_source = "main.c"
self.main_source_spec = lldb.SBFileSpec(self.main_source) self.main_source_spec = lldb.SBFileSpec(self.main_source)
self.exe = os.path.join(os.getcwd(), "read-mem-cstring") self.exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "read-mem-cstring")
(target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint( (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(
self, 'breakpoint here', self.main_source_spec, None, self.exe) self, 'breakpoint here', self.main_source_spec, None, self.exe)
frame = thread.GetFrameAtIndex(0) frame = thread.GetFrameAtIndex(0)
err = lldb.SBError() err = lldb.SBError()
Show All 25 Lines

packages/Python/lldbsuite/test/python_api/section/TestSectionAPI.py

Show All 13 Linesclass SectionAPITestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_get_target_byte_size(self): def test_get_target_byte_size(self):
d = {'EXE': 'b.out'} d = {'EXE': 'b.out'}
self.build(dictionary=d) self.build(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
exe = os.path.join(os.getcwd(), 'b.out') exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, 'b.out')
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# find the .data section of the main module # find the .data section of the main module
mod = target.GetModuleAtIndex(0) mod = target.GetModuleAtIndex(0)
data_section = None data_section = None
for s in mod.sections: for s in mod.sections:
sect_type = s.GetSectionType() sect_type = s.GetSectionType()
Show All 13 Lines

packages/Python/lldbsuite/test/python_api/signals/TestSignalsAPI.py

Show All 16 Lines
class SignalsAPITestCase(TestBase): class SignalsAPITestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@skipIfWindows # Windows doesn't have signals @skipIfWindows # Windows doesn't have signals
def test_ignore_signal(self): def test_ignore_signal(self):
"""Test Python SBUnixSignals.Suppress/Stop/Notify() API.""" """Test Python SBUnixSignals.Suppress/Stop/Notify() API."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
line = line_number( line = line_number(
"main.cpp", "main.cpp",
"// Set break point at this line and setup signal ignores.") "// Set break point at this line and setup signal ignores.")
Show All 25 Lines

packages/Python/lldbsuite/test/python_api/symbol-context/TestSymbolContext.py

Show All 25 Lines def setUp(self):
self.line = line_number( self.line = line_number(
'main.c', '// Find the line number of function "c" here.') 'main.c', '// Find the line number of function "c" here.')
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
def test(self): def test(self):
"""Exercise SBSymbolContext API extensively.""" """Exercise SBSymbolContext API extensively."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Now create a breakpoint on main.c by name 'c'. # Now create a breakpoint on main.c by name 'c'.
breakpoint = target.BreakpointCreateByName('c', 'a.out') breakpoint = target.BreakpointCreateByName('c', 'a.out')
#print("breakpoint:", breakpoint) #print("breakpoint:", breakpoint)
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/python_api/symbol-context/two-files/TestSymbolContextTwoFiles.py

Show All 15 Linesclass SymbolContextTwoFilesTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@expectedFailureAll(oslist=["windows"]) @expectedFailureAll(oslist=["windows"])
def test_lookup_by_address(self): def test_lookup_by_address(self):
"""Test lookup by address in a module with multiple compilation units""" """Test lookup by address in a module with multiple compilation units"""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
module = target.GetModuleAtIndex(0) module = target.GetModuleAtIndex(0)
self.assertTrue(module.IsValid()) self.assertTrue(module.IsValid())
for symbol_name in ["struct1::f()", "struct2::f()"]: for symbol_name in ["struct1::f()", "struct2::f()"]:
sc_list = module.FindFunctions(symbol_name, lldb.eSymbolTypeCode) sc_list = module.FindFunctions(symbol_name, lldb.eSymbolTypeCode)
self.assertTrue(1, sc_list.GetSize()) self.assertTrue(1, sc_list.GetSize())
symbol_address = sc_list.GetContextAtIndex( symbol_address = sc_list.GetContextAtIndex(
0).GetSymbol().GetStartAddress() 0).GetSymbol().GetStartAddress()
self.assertTrue(symbol_address.IsValid()) self.assertTrue(symbol_address.IsValid())
sc_by_address = module.ResolveSymbolContextForAddress( sc_by_address = module.ResolveSymbolContextForAddress(
symbol_address, lldb.eSymbolContextFunction) symbol_address, lldb.eSymbolContextFunction)
self.assertEqual(symbol_name, self.assertEqual(symbol_name,
sc_by_address.GetFunction().GetName()) sc_by_address.GetFunction().GetName())
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_ranges_in_multiple_compile_unit(self): def test_ranges_in_multiple_compile_unit(self):
"""This test verifies that we correctly handle the case when multiple """This test verifies that we correctly handle the case when multiple
compile unit contains DW_AT_ranges and DW_AT_ranges_base attributes.""" compile unit contains DW_AT_ranges and DW_AT_ranges_base attributes."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
source1 = "file1.cpp" source1 = "file1.cpp"
line1 = line_number(source1, '// Break1') line1 = line_number(source1, '// Break1')
breakpoint1 = target.BreakpointCreateByLocation(source1, line1) breakpoint1 = target.BreakpointCreateByLocation(source1, line1)
self.assertIsNotNone(breakpoint1) self.assertIsNotNone(breakpoint1)
Show All 28 Lines

packages/Python/lldbsuite/test/python_api/target/TestTargetAPI.py

Show First 20 Lines • Show All 143 Lines • ▼ Show 20 Lines def test_read_memory(self):
data_section = self.find_data_section(target) data_section = self.find_data_section(target)
sb_addr = lldb.SBAddress(data_section, 0) sb_addr = lldb.SBAddress(data_section, 0)
error = lldb.SBError() error = lldb.SBError()
content = target.ReadMemory(sb_addr, 1, error) content = target.ReadMemory(sb_addr, 1, error)
self.assertTrue(error.Success(), "Make sure memory read succeeded") self.assertTrue(error.Success(), "Make sure memory read succeeded")
self.assertEqual(len(content), 1) self.assertEqual(len(content), 1)
def create_simple_target(self, fn): def create_simple_target(self, fn):
exe = os.path.join(os.getcwd(), fn) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, fn)
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
return target return target
def find_data_section(self, target): def find_data_section(self, target):
mod = target.GetModuleAtIndex(0) mod = target.GetModuleAtIndex(0)
data_section = None data_section = None
for s in mod.sections: for s in mod.sections:
Show All 9 Lines def find_data_section(self, target):
data_section = ss data_section = ss
break break
self.assertIsNotNone(data_section) self.assertIsNotNone(data_section)
return data_section return data_section
def find_global_variables(self, exe_name): def find_global_variables(self, exe_name):
"""Exercise SBTaget.FindGlobalVariables() API.""" """Exercise SBTaget.FindGlobalVariables() API."""
exe = os.path.join(os.getcwd(), exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, 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)
# rdar://problem/9700873 # rdar://problem/9700873
# Find global variable value fails for dwarf if inferior not started # Find global variable value fails for dwarf if inferior not started
# (Was CrashTracer: [USER] 1 crash in Python at _lldb.so: lldb_private::MemoryCache::Read + 94) # (Was CrashTracer: [USER] 1 crash in Python at _lldb.so: lldb_private::MemoryCache::Read + 94)
Show All 35 Lines def find_global_variables(self, exe_name):
target, 'my_global_var_of_char_type', 3) target, 'my_global_var_of_char_type', 3)
self.assertTrue(value_list.GetSize() == 1) self.assertTrue(value_list.GetSize() == 1)
self.assertTrue( self.assertTrue(
value_list.GetValueAtIndex(0).GetValue() == "'X'") value_list.GetValueAtIndex(0).GetValue() == "'X'")
break break
def find_functions(self, exe_name): def find_functions(self, exe_name):
"""Exercise SBTaget.FindFunctions() API.""" """Exercise SBTaget.FindFunctions() API."""
exe = os.path.join(os.getcwd(), exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, 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)
list = target.FindFunctions('c', lldb.eFunctionNameTypeAuto) list = target.FindFunctions('c', lldb.eFunctionNameTypeAuto)
self.assertTrue(list.GetSize() == 1) self.assertTrue(list.GetSize() == 1)
for sc in list: for sc in list:
self.assertTrue( self.assertTrue(
sc.GetModule().GetFileSpec().GetFilename() == exe_name) sc.GetModule().GetFileSpec().GetFilename() == exe_name)
self.assertTrue(sc.GetSymbol().GetName() == 'c') self.assertTrue(sc.GetSymbol().GetName() == 'c')
def get_description(self): def get_description(self):
"""Exercise SBTaget.GetDescription() API.""" """Exercise SBTaget.GetDescription() API."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
from lldbsuite.test.lldbutil import get_description from lldbsuite.test.lldbutil import get_description
# get_description() allows no option to mean # get_description() allows no option to mean
Show All 11 Lines def get_description(self):
if not desc: if not desc:
self.fail("SBTarget.GetDescription() failed") self.fail("SBTarget.GetDescription() failed")
self.expect(desc, exe=False, self.expect(desc, exe=False,
substrs=['a.out', 'Target', 'Module', 'Breakpoint']) substrs=['a.out', 'Target', 'Module', 'Breakpoint'])
@not_remote_testsuite_ready @not_remote_testsuite_ready
def launch_new_process_and_redirect_stdout(self): def launch_new_process_and_redirect_stdout(self):
"""Exercise SBTaget.Launch() API with redirected stdout.""" """Exercise SBTaget.Launch() API with redirected stdout."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Add an extra twist of stopping the inferior in a breakpoint, and then continue till it's done. # Add an extra twist of stopping the inferior in a breakpoint, and then continue till it's done.
# We should still see the entire stdout redirected once the process is # We should still see the entire stdout redirected once the process is
# finished. # finished.
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines def launch_new_process_and_redirect_stdout(self):
except OSError: except OSError:
pass pass
self.expect(output, exe=False, self.expect(output, exe=False,
substrs=["a(1)", "b(2)", "a(3)"]) substrs=["a(1)", "b(2)", "a(3)"])
def resolve_symbol_context_with_address(self): def resolve_symbol_context_with_address(self):
"""Exercise SBTaget.ResolveSymbolContextForAddress() API.""" """Exercise SBTaget.ResolveSymbolContextForAddress() API."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Now create the two breakpoints inside function 'a'. # Now create the two breakpoints inside function 'a'.
breakpoint1 = target.BreakpointCreateByLocation('main.c', self.line1) breakpoint1 = target.BreakpointCreateByLocation('main.c', self.line1)
breakpoint2 = target.BreakpointCreateByLocation('main.c', self.line2) breakpoint2 = target.BreakpointCreateByLocation('main.c', self.line2)
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/python_api/thread/TestThreadAPI.py

Show First 20 Lines • Show All 72 Lines • ▼ Show 20 Lines def setUp(self):
"main2.cpp", "// we should reach here after 3 step-over's.") "main2.cpp", "// we should reach here after 3 step-over's.")
# We'll use the test method name as the exe_name for executable # We'll use the test method name as the exe_name for executable
# comppiled from main2.cpp. # comppiled from main2.cpp.
self.exe_name = self.testMethodName self.exe_name = self.testMethodName
def get_process(self): def get_process(self):
"""Test Python SBThread.GetProcess() API.""" """Test Python SBThread.GetProcess() API."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
breakpoint = target.BreakpointCreateByLocation( breakpoint = target.BreakpointCreateByLocation(
"main.cpp", self.break_line) "main.cpp", self.break_line)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
self.runCmd("breakpoint list") self.runCmd("breakpoint list")
Show All 10 Lines def get_process(self):
proc_of_thread = thread.GetProcess() proc_of_thread = thread.GetProcess()
#print("proc_of_thread:", proc_of_thread) #print("proc_of_thread:", proc_of_thread)
self.assertTrue(proc_of_thread.GetProcessID() self.assertTrue(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 = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
breakpoint = target.BreakpointCreateByLocation( breakpoint = target.BreakpointCreateByLocation(
"main.cpp", self.break_line) "main.cpp", self.break_line)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
#self.runCmd("breakpoint list") #self.runCmd("breakpoint list")
Show All 12 Lines def get_stop_description(self):
# and expect to get a Python string as the return object! # and expect to get a Python string as the return object!
# The 100 is just an arbitrary number specifying the buffer size. # The 100 is just an arbitrary number specifying the buffer size.
stop_description = thread.GetStopDescription(100) stop_description = thread.GetStopDescription(100)
self.expect(stop_description, exe=False, self.expect(stop_description, exe=False,
startstr='breakpoint') startstr='breakpoint')
def step_out_of_malloc_into_function_b(self, exe_name): def step_out_of_malloc_into_function_b(self, exe_name):
"""Test Python SBThread.StepOut() API to step out of a malloc call where the call site is at function b().""" """Test Python SBThread.StepOut() API to step out of a malloc call where the call site is at function b()."""
exe = os.path.join(os.getcwd(), exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, exe_name)
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
breakpoint = target.BreakpointCreateByName('malloc') breakpoint = target.BreakpointCreateByName('malloc')
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
# Launch the process, and do not stop at the entry point. # Launch the process, and do not stop at the entry point.
Show All 30 Lines def step_out_of_malloc_into_function_b(self, exe_name):
thread.StepOut() thread.StepOut()
self.runCmd("thread backtrace") self.runCmd("thread backtrace")
self.assertTrue( self.assertTrue(
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 = os.path.join(os.getcwd(), exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, exe_name)
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
breakpoint = target.BreakpointCreateByLocation( breakpoint = target.BreakpointCreateByLocation(
'main2.cpp', self.step_out_of_malloc) 'main2.cpp', self.step_out_of_malloc)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
self.runCmd("breakpoint list") self.runCmd("breakpoint list")
Show All 29 Lines def step_over_3_times(self, exe_name):
# rdar://problem/9223880 # rdar://problem/9223880
# #
# Which has been fixed on the lldb by compensating for inaccurate line # Which has been fixed on the lldb by compensating for inaccurate line
# table information with r140416. # table information with r140416.
self.assertTrue(lineEntry.GetLine() == self.after_3_step_overs) self.assertTrue(lineEntry.GetLine() == self.after_3_step_overs)
def run_to_address(self, exe_name): def run_to_address(self, exe_name):
"""Test Python SBThread.RunToAddress() API.""" """Test Python SBThread.RunToAddress() API."""
exe = os.path.join(os.getcwd(), exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, exe_name)
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
breakpoint = target.BreakpointCreateByLocation( breakpoint = target.BreakpointCreateByLocation(
'main2.cpp', self.step_out_of_malloc) 'main2.cpp', self.step_out_of_malloc)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
self.runCmd("breakpoint list") self.runCmd("breakpoint list")
Show All 39 Lines

packages/Python/lldbsuite/test/python_api/type/TestTypeList.py

Show All 28 Lines def setUp(self):
self.line = line_number(self.source, '// Break at this line') self.line = line_number(self.source, '// Break at this line')
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test(self): def test(self):
"""Exercise SBType and SBTypeList API.""" """Exercise SBType and SBTypeList API."""
d = {'EXE': self.exe_name} d = {'EXE': self.exe_name}
self.build(dictionary=d) self.build(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.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)
# Create the breakpoint inside function 'main'. # Create the breakpoint inside function 'main'.
breakpoint = target.BreakpointCreateByLocation(self.source, self.line) breakpoint = target.BreakpointCreateByLocation(self.source, self.line)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/python_api/value/TestValueAPI.py

Show All 27 Linesclass ValueAPITestCase(TestBase):
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24772") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24772")
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test(self): def test(self):
"""Exercise some SBValue APIs.""" """Exercise some SBValue APIs."""
d = {'EXE': self.exe_name} d = {'EXE': self.exe_name}
self.build(dictionary=d) self.build(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.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)
# Create the breakpoint inside function 'main'. # Create the breakpoint inside function 'main'.
breakpoint = target.BreakpointCreateByLocation('main.c', self.line) breakpoint = target.BreakpointCreateByLocation('main.c', self.line)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
▲ Show 20 Lines • Show All 124 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/python_api/value/change_values/TestChangeValueAPI.py

Show All 32 Linesclass ChangeValueAPITestCase(TestBase):
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@expectedFlakeyLinux("llvm.org/pr25652") @expectedFlakeyLinux("llvm.org/pr25652")
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24772") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24772")
def test_change_value(self): def test_change_value(self):
"""Exercise the SBValue::SetValueFromCString API.""" """Exercise the SBValue::SetValueFromCString API."""
d = {'EXE': self.exe_name} d = {'EXE': self.exe_name}
self.build(dictionary=d) self.build(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.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)
# Create the breakpoint inside function 'main'. # Create the breakpoint inside function 'main'.
breakpoint = target.BreakpointCreateByLocation('main.c', self.line) breakpoint = target.BreakpointCreateByLocation('main.c', self.line)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
▲ Show 20 Lines • Show All 136 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/python_api/value/empty_class/TestValueAPIEmptyClass.py

Show All 9 Lines
class ValueAPIEmptyClassTestCase(TestBase): class ValueAPIEmptyClassTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test(self): def test(self):
self.build() self.build()
exe = os.path.join(os.getcwd(), 'a.out') exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, 'a.out')
line = line_number('main.cpp', '// Break at this line') line = line_number('main.cpp', '// Break at this line')
# 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)
# Create the breakpoint inside function 'main'. # Create the breakpoint inside function 'main'.
breakpoint = target.BreakpointCreateByLocation('main.cpp', line) breakpoint = target.BreakpointCreateByLocation('main.cpp', line)
Show All 34 Lines

packages/Python/lldbsuite/test/python_api/value/linked_list/TestValueAPILinkedList.py

Show All 30 Linesclass ValueAsLinkedListTestCase(TestBase):
# SWIG 3.0.8. # SWIG 3.0.8.
@skipIf(py_version=['>=', (3, 0)], swig_version=['<', (3, 0, 8)]) @skipIf(py_version=['>=', (3, 0)], swig_version=['<', (3, 0, 8)])
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test(self): def test(self):
"""Exercise SBValue API linked_list_iter.""" """Exercise SBValue API linked_list_iter."""
d = {'EXE': self.exe_name} d = {'EXE': self.exe_name}
self.build(dictionary=d) self.build(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.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)
# Create the breakpoint inside function 'main'. # Create the breakpoint inside function 'main'.
breakpoint = target.BreakpointCreateByLocation('main.cpp', self.line) breakpoint = target.BreakpointCreateByLocation('main.cpp', self.line)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/python_api/value_var_update/TestValueVarUpdate.py

Show All 15 Lines
class HelloWorldTestCase(TestBase): class HelloWorldTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Get the full path to our executable to be attached/debugged. # Get the full path to our executable to be attached/debugged.
self.exe = os.path.join(os.getcwd(), self.testMethodName) self.exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.testMethodName)
self.d = {'EXE': self.testMethodName} self.d = {'EXE': self.testMethodName}
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_with_process_launch_api(self): def test_with_process_launch_api(self):
"""Test SBValue::GetValueDidChange""" """Test SBValue::GetValueDidChange"""
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
target = self.dbg.CreateTarget(self.exe) target = self.dbg.CreateTarget(self.exe)
Show All 39 Lines

packages/Python/lldbsuite/test/python_api/watchpoint/TestSetWatchpoint.py

Show All 30 Linesclass SetWatchpointAPITestCase(TestBase):
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows") bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
# Read-write watchpoints not supported on SystemZ # Read-write watchpoints not supported on SystemZ
@expectedFailureAll(archs=['s390x']) @expectedFailureAll(archs=['s390x'])
def test_watch_val(self): def test_watch_val(self):
"""Exercise SBValue.Watch() API to set a watchpoint.""" """Exercise SBValue.Watch() API to set a watchpoint."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Now create a breakpoint on main.c. # Now create a breakpoint on main.c.
breakpoint = target.BreakpointCreateByLocation(self.source, self.line) breakpoint = target.BreakpointCreateByLocation(self.source, self.line)
self.assertTrue(breakpoint and self.assertTrue(breakpoint and
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/python_api/watchpoint/TestWatchpointIgnoreCount.py

Show All 30 Linesclass WatchpointIgnoreCountTestCase(TestBase):
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows") bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
# Read-write watchpoints not supported on SystemZ # Read-write watchpoints not supported on SystemZ
@expectedFailureAll(archs=['s390x']) @expectedFailureAll(archs=['s390x'])
def test_set_watch_ignore_count(self): def test_set_watch_ignore_count(self):
"""Test SBWatchpoint.SetIgnoreCount() API.""" """Test SBWatchpoint.SetIgnoreCount() API."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Create a breakpoint on main.c in order to set our watchpoint later. # Create a breakpoint on main.c in order to set our watchpoint later.
breakpoint = target.BreakpointCreateByLocation(self.source, self.line) breakpoint = target.BreakpointCreateByLocation(self.source, self.line)
self.assertTrue(breakpoint and self.assertTrue(breakpoint and
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/python_api/watchpoint/TestWatchpointIter.py

Show All 33 Linesclass WatchpointIteratorTestCase(TestBase):
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows") bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
def test_watch_iter(self): def test_watch_iter(self):
"""Exercise SBTarget.watchpoint_iter() API to iterate on the available watchpoints.""" """Exercise SBTarget.watchpoint_iter() API to iterate on the available watchpoints."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Create a breakpoint on main.c in order to set our watchpoint later. # Create a breakpoint on main.c in order to set our watchpoint later.
breakpoint = target.BreakpointCreateByLocation(self.source, self.line) breakpoint = target.BreakpointCreateByLocation(self.source, self.line)
self.assertTrue(breakpoint and self.assertTrue(breakpoint and
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/python_api/watchpoint/condition/TestWatchpointConditionAPI.py

Show All 36 Lines @expectedFailureAll(
oslist=["linux"], oslist=["linux"],
archs=["aarch64"], archs=["aarch64"],
bugnumber="llvm.org/pr27710") bugnumber="llvm.org/pr27710")
@skipIfWindows # Watchpoints not supported on Windows, and this test hangs @skipIfWindows # Watchpoints not supported on Windows, and this test hangs
def test_watchpoint_cond_api(self): def test_watchpoint_cond_api(self):
"""Test watchpoint condition API.""" """Test watchpoint condition API."""
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.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)
# Now create a breakpoint on main.c. # Now create a breakpoint on main.c.
breakpoint = target.BreakpointCreateByLocation(self.source, self.line) breakpoint = target.BreakpointCreateByLocation(self.source, self.line)
self.assertTrue(breakpoint and self.assertTrue(breakpoint and
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/python_api/watchpoint/watchlocation/TestSetWatchlocation.py

Show All 31 Linesclass SetWatchlocationAPITestCase(TestBase):
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows") bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
def test_watch_location(self): def test_watch_location(self):
"""Exercise SBValue.WatchPointee() API to set a watchpoint.""" """Exercise SBValue.WatchPointee() API to set a watchpoint."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Now create a breakpoint on main.c. # Now create a breakpoint on main.c.
breakpoint = target.BreakpointCreateByLocation(self.source, self.line) breakpoint = target.BreakpointCreateByLocation(self.source, self.line)
self.assertTrue(breakpoint and self.assertTrue(breakpoint and
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/python_api/watchpoint/watchlocation/TestTargetWatchAddress.py

Show All 30 Linesclass TargetWatchAddressAPITestCase(TestBase):
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows") bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
def test_watch_address(self): def test_watch_address(self):
"""Exercise SBTarget.WatchAddress() API to set a watchpoint.""" """Exercise SBTarget.WatchAddress() API to set a watchpoint."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Now create a breakpoint on main.c. # Now create a breakpoint on main.c.
breakpoint = target.BreakpointCreateByLocation(self.source, self.line) breakpoint = target.BreakpointCreateByLocation(self.source, self.line)
self.assertTrue(breakpoint and self.assertTrue(breakpoint and
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Linesclass TargetWatchAddressAPITestCase(TestBase):
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
# No size constraint on MIPS for watches # No size constraint on MIPS for watches
@skipIf(archs=['mips', 'mipsel', 'mips64', 'mips64el']) @skipIf(archs=['mips', 'mipsel', 'mips64', 'mips64el'])
@skipIf(archs=['s390x']) # Likewise on SystemZ @skipIf(archs=['s390x']) # Likewise on SystemZ
@expectedFailureAll(oslist=["windows"]) @expectedFailureAll(oslist=["windows"])
def test_watch_address_with_invalid_watch_size(self): def test_watch_address_with_invalid_watch_size(self):
"""Exercise SBTarget.WatchAddress() API but pass an invalid watch_size.""" """Exercise SBTarget.WatchAddress() API but pass an invalid watch_size."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
# 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)
# Now create a breakpoint on main.c. # Now create a breakpoint on main.c.
breakpoint = target.BreakpointCreateByLocation(self.source, self.line) breakpoint = target.BreakpointCreateByLocation(self.source, self.line)
self.assertTrue(breakpoint and self.assertTrue(breakpoint and
Show All 28 Lines

packages/Python/lldbsuite/test/settings/TestSettings.py

Show First 20 Lines • Show All 119 Lines • ▼ Show 20 Lines def test_set_term_width(self):
self.expect("settings show", SETTING_MSG("term-width"), self.expect("settings show", SETTING_MSG("term-width"),
substrs=["term-width (int) = 70"]) substrs=["term-width (int) = 70"])
# rdar://problem/10712130 # rdar://problem/10712130
def test_set_frame_format(self): def test_set_frame_format(self):
"""Test that 'set frame-format' with a backtick char in the format string works as well as fullpath.""" """Test that 'set frame-format' with a backtick char in the format string works as well as fullpath."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
def cleanup(): def cleanup():
self.runCmd( self.runCmd(
"settings set frame-format %s" % "settings set frame-format %s" %
self.format_string, check=False) self.format_string, check=False)
# Execute the cleanup function during test case tear down. # Execute the cleanup function during test case tear down.
Show All 19 Lines def test_set_frame_format(self):
self.runCmd("run") self.runCmd("run")
self.expect("thread backtrace", self.expect("thread backtrace",
substrs=["`main", os.getcwd()]) substrs=["`main", os.getcwd()])
def test_set_auto_confirm(self): def test_set_auto_confirm(self):
"""Test that after 'set auto-confirm true', manual confirmation should not kick in.""" """Test that after 'set auto-confirm true', manual confirmation should not kick in."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("settings set auto-confirm true") self.runCmd("settings set auto-confirm true")
# Immediately test the setting. # Immediately test the setting.
self.expect("settings show auto-confirm", SETTING_MSG("auto-confirm"), self.expect("settings show auto-confirm", SETTING_MSG("auto-confirm"),
startstr="auto-confirm (boolean) = true") startstr="auto-confirm (boolean) = true")
# Now 'breakpoint delete' should just work fine without confirmation # Now 'breakpoint delete' should just work fine without confirmation
# prompt from the command interpreter. # prompt from the command interpreter.
self.runCmd("breakpoint set -n main") self.runCmd("breakpoint set -n main")
self.expect("breakpoint delete", self.expect("breakpoint delete",
startstr="All breakpoints removed") startstr="All breakpoints removed")
# Restore the original setting of auto-confirm. # Restore the original setting of auto-confirm.
self.runCmd("settings clear auto-confirm") self.runCmd("settings clear auto-confirm")
self.expect("settings show auto-confirm", SETTING_MSG("auto-confirm"), self.expect("settings show auto-confirm", SETTING_MSG("auto-confirm"),
startstr="auto-confirm (boolean) = false") startstr="auto-confirm (boolean) = false")
@skipIf(archs=no_match(['x86_64', 'i386', 'i686'])) @skipIf(archs=no_match(['x86_64', 'i386', 'i686']))
def test_disassembler_settings(self): def test_disassembler_settings(self):
"""Test that user options for the disassembler take effect.""" """Test that user options for the disassembler take effect."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# AT&T syntax # AT&T syntax
self.runCmd("settings set target.x86-disassembly-flavor att") self.runCmd("settings set target.x86-disassembly-flavor att")
self.runCmd("settings set target.use-hex-immediates false") self.runCmd("settings set target.use-hex-immediates false")
self.expect("disassemble -n numberfn", self.expect("disassemble -n numberfn",
substrs=["$90"]) substrs=["$90"])
self.runCmd("settings set target.use-hex-immediates true") self.runCmd("settings set target.use-hex-immediates true")
Show All 16 Lines def test_disassembler_settings(self):
self.runCmd("settings set target.hex-immediate-style asm") self.runCmd("settings set target.hex-immediate-style asm")
self.expect("disassemble -n numberfn", self.expect("disassemble -n numberfn",
substrs=["5ah"]) substrs=["5ah"])
@skipIfDarwinEmbedded # <rdar://problem/34446098> debugserver on ios etc can't write files @skipIfDarwinEmbedded # <rdar://problem/34446098> debugserver on ios etc can't write files
def test_run_args_and_env_vars(self): def test_run_args_and_env_vars(self):
"""Test that run-args and env-vars are passed to the launched process.""" """Test that run-args and env-vars are passed to the launched process."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Set the run-args and the env-vars. # Set the run-args and the env-vars.
# And add hooks to restore the settings during tearDown(). # And add hooks to restore the settings during tearDown().
self.runCmd('settings set target.run-args A B C') self.runCmd('settings set target.run-args A B C')
self.addTearDownHook( self.addTearDownHook(
lambda: self.runCmd("settings clear target.run-args")) lambda: self.runCmd("settings clear target.run-args"))
self.runCmd('settings set target.env-vars ["MY_ENV_VAR"]=YES') self.runCmd('settings set target.env-vars ["MY_ENV_VAR"]=YES')
Show All 17 Lines def test_run_args_and_env_vars(self):
"argv[3] matches", "argv[3] matches",
"Environment variable 'MY_ENV_VAR' successfully passed."]) "Environment variable 'MY_ENV_VAR' successfully passed."])
@skipIfRemote # it doesn't make sense to send host env to remote target @skipIfRemote # it doesn't make sense to send host env to remote target
def test_pass_host_env_vars(self): def test_pass_host_env_vars(self):
"""Test that the host env vars are passed to the launched process.""" """Test that the host env vars are passed to the launched process."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# By default, inherit-env is 'true'. # By default, inherit-env is 'true'.
self.expect( self.expect(
'settings show target.inherit-env', 'settings show target.inherit-env',
"Default inherit-env is 'true'", "Default inherit-env is 'true'",
startstr="target.inherit-env (boolean) = true") startstr="target.inherit-env (boolean) = true")
Show All 22 Lines def test_pass_host_env_vars(self):
"The host environment variable 'MY_HOST_ENV_VAR1' successfully passed.", "The host environment variable 'MY_HOST_ENV_VAR1' successfully passed.",
"The host environment variable 'MY_HOST_ENV_VAR2' successfully passed."]) "The host environment variable 'MY_HOST_ENV_VAR2' successfully passed."])
@skipIfDarwinEmbedded # <rdar://problem/34446098> debugserver on ios etc can't write files @skipIfDarwinEmbedded # <rdar://problem/34446098> debugserver on ios etc can't write files
def test_set_error_output_path(self): def test_set_error_output_path(self):
"""Test that setting target.error/output-path for the launched process works.""" """Test that setting target.error/output-path for the launched process works."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Set the error-path and output-path and verify both are set. # Set the error-path and output-path and verify both are set.
self.runCmd("settings set target.error-path stderr.txt") self.runCmd("settings set target.error-path stderr.txt")
self.runCmd("settings set target.output-path stdout.txt") self.runCmd("settings set target.output-path stdout.txt")
# And add hooks to restore the original settings during tearDown(). # And add hooks to restore the original settings during tearDown().
self.addTearDownHook( self.addTearDownHook(
lambda: self.runCmd("settings clear target.output-path")) lambda: self.runCmd("settings clear target.output-path"))
▲ Show 20 Lines • Show All 112 Lines • ▼ Show 20 Lines def test_settings_with_trailing_whitespace(self):
# string # string
self.runCmd("settings set target.arg0 abc") # Set to known value self.runCmd("settings set target.arg0 abc") # Set to known value
# Set to new value with trailing whitespaces # Set to new value with trailing whitespaces
self.runCmd("settings set target.arg0 cde\t ") self.runCmd("settings set target.arg0 cde\t ")
self.expect("settings show target.arg0", SETTING_MSG("target.arg0"), self.expect("settings show target.arg0", SETTING_MSG("target.arg0"),
startstr='target.arg0 (string) = "cde"') startstr='target.arg0 (string) = "cde"')
self.runCmd("settings clear target.arg0", check=False) self.runCmd("settings clear target.arg0", check=False)
# file # file
path1 = os.path.join(os.getcwd(), "path1.txt") path1 = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "path1.txt")
path2 = os.path.join(os.getcwd(), "path2.txt") path2 = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "path2.txt")
self.runCmd( self.runCmd(
"settings set target.output-path %s" % "settings set target.output-path %s" %
path1) # Set to known value path1) # Set to known value
self.expect( self.expect(
"settings show target.output-path", "settings show target.output-path",
SETTING_MSG("target.output-path"), SETTING_MSG("target.output-path"),
startstr='target.output-path (file) = ', startstr='target.output-path (file) = ',
substrs=[path1]) substrs=[path1])
▲ Show 20 Lines • Show All 129 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/settings/quoting/TestQuoting.py

Show First 20 Lines • Show All 73 Lines • ▼ Show 20 Linesclass SettingsCommandTestCase(TestBase):
def test_bare_double(self): def test_bare_double(self):
self.do_test_args('a\\"b', 'a"b\0') self.do_test_args('a\\"b', 'a"b\0')
def do_test_args(self, args_in, args_out): def do_test_args(self, args_in, args_out):
"""Test argument parsing. Run the program with args_in. The program dumps its arguments """Test argument parsing. Run the program with args_in. The program dumps its arguments
to stdout. Compare the stdout with args_out.""" to stdout. Compare the stdout with args_out."""
self.buildDefault() self.buildDefault()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("process launch -- " + args_in) self.runCmd("process launch -- " + args_in)
if lldb.remote_platform: if lldb.remote_platform:
src_file_spec = lldb.SBFileSpec('output.txt', False) src_file_spec = lldb.SBFileSpec('output.txt', False)
dst_file_spec = lldb.SBFileSpec('output.txt', True) dst_file_spec = lldb.SBFileSpec('output.txt', True)
lldb.remote_platform.Get(src_file_spec, dst_file_spec) lldb.remote_platform.Get(src_file_spec, dst_file_spec)
with open('output.txt', 'r') as f: with open('output.txt', 'r') as f:
output = f.read() output = f.read()
self.RemoveTempFile("output.txt") self.RemoveTempFile("output.txt")
self.assertEqual(output, args_out) self.assertEqual(output, args_out)

packages/Python/lldbsuite/test/source-manager/TestSourceManager.py

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines def get_expected_stop_column_number(self):
# whitespace character --- where we expect the debugger breakpoint # whitespace character --- where we expect the debugger breakpoint
# column to be --- is equal to the number of characters that get # column to be --- is equal to the number of characters that get
# stripped off the front when we lstrip it, plus one to specify # stripped off the front when we lstrip it, plus one to specify
# the character column after the initial whitespace. # the character column after the initial whitespace.
return len(stop_line) - len(stop_line.lstrip()) + 1 return len(stop_line) - len(stop_line.lstrip()) + 1
def do_display_source_python_api(self, use_color, column_marker_regex): def do_display_source_python_api(self, use_color, column_marker_regex):
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Launch the process, and do not stop at the entry point. # Launch the process, and do not stop at the entry point.
args = None args = None
envp = None envp = None
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines def test_display_source_python_ansi_terminal(self):
dumb terminal and thus no color support (the default).""" dumb terminal and thus no color support (the default)."""
use_color = True use_color = True
underline_regex = ansi_underline_surround_regex(r".") underline_regex = ansi_underline_surround_regex(r".")
self.do_display_source_python_api(use_color, underline_regex) self.do_display_source_python_api(use_color, underline_regex)
def test_move_and_then_display_source(self): def test_move_and_then_display_source(self):
"""Test that target.source-map settings work by moving main.c to hidden/main.c.""" """Test that target.source-map settings work by moving main.c to hidden/main.c."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Move main.c to hidden/main.c. # Move main.c to hidden/main.c.
main_c = "main.c" main_c = "main.c"
main_c_hidden = os.path.join("hidden", main_c) main_c_hidden = os.path.join("hidden", main_c)
os.rename(main_c, main_c_hidden) os.rename(main_c, main_c_hidden)
# Restore main.c after the test. # Restore main.c after the test.
self.addTearDownHook(lambda: os.rename(main_c_hidden, main_c)) self.addTearDownHook(lambda: os.rename(main_c_hidden, main_c))
if self.TraceOn(): if self.TraceOn():
system([["ls"]]) system([["ls"]])
system([["ls", "hidden"]]) system([["ls", "hidden"]])
# Set source remapping with invalid replace path and verify we get an # Set source remapping with invalid replace path and verify we get an
# error # error
self.expect( self.expect(
"settings set target.source-map /a/b/c/d/e /q/r/s/t/u", "settings set target.source-map /a/b/c/d/e /q/r/s/t/u",
error=True, error=True,
substrs=['''error: the replacement path doesn't exist: "/q/r/s/t/u"''']) substrs=['''error: the replacement path doesn't exist: "/q/r/s/t/u"'''])
# Set target.source-map settings. # Set target.source-map settings.
self.runCmd("settings set target.source-map %s %s" % self.runCmd("settings set target.source-map %s %s" %
(os.getcwd(), os.path.join(os.getcwd(), "hidden"))) (os.getcwd(), os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "hidden")))
# And verify that the settings work. # And verify that the settings work.
self.expect("settings show target.source-map", self.expect("settings show target.source-map",
substrs=[os.getcwd(), os.path.join(os.getcwd(), "hidden")]) substrs=[os.getcwd(), os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "hidden")])
# Display main() and verify that the source mapping has been kicked in. # Display main() and verify that the source mapping has been kicked in.
self.expect("source list -n main", SOURCE_DISPLAYED_CORRECTLY, self.expect("source list -n main", SOURCE_DISPLAYED_CORRECTLY,
substrs=['Hello world']) substrs=['Hello world'])
def test_modify_source_file_while_debugging(self): def test_modify_source_file_while_debugging(self):
"""Modify a source file while debugging the executable.""" """Modify a source file while debugging the executable."""
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.c", self.line, num_expected_locations=1, loc_exact=True) self, "main.c", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
▲ Show 20 Lines • Show All 66 Lines • ▼ Show 20 Lines def test_modify_source_file_while_debugging(self):
"source list -f main.c -l %d" % "source list -f main.c -l %d" %
self.line, self.line,
SOURCE_DISPLAYED_CORRECTLY, SOURCE_DISPLAYED_CORRECTLY,
substrs=['Hello lldb']) substrs=['Hello lldb'])
def test_set_breakpoint_with_absolute_path(self): def test_set_breakpoint_with_absolute_path(self):
self.build() self.build()
self.runCmd("settings set target.source-map %s %s" % self.runCmd("settings set target.source-map %s %s" %
(os.getcwd(), os.path.join(os.getcwd(), "hidden"))) (os.getcwd(), os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "hidden")))
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "a.out")
main = os.path.join(os.getcwd(), "hidden", "main.c") main = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "hidden", "main.c")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, main, self.line, num_expected_locations=1, loc_exact=False) self, main, self.line, num_expected_locations=1, loc_exact=False)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', substrs=['stopped',
'main.c:%d' % self.line, 'main.c:%d' % self.line,
'stop reason = breakpoint']) 'stop reason = breakpoint'])

packages/Python/lldbsuite/test/tools/lldb-mi/TestMiFile.py

Show All 36 Linesclass MiFileTestCase(lldbmi_testcase.MiTestCaseBase):
@skipIfRemote # We do not currently support remote debugging via the MI. @skipIfRemote # We do not currently support remote debugging via the MI.
def test_lldbmi_file_exec_and_symbols_absolute_path(self): def test_lldbmi_file_exec_and_symbols_absolute_path(self):
"""Test that 'lldb-mi --interpreter' works for -file-exec-and-symbols fullpath/exe.""" """Test that 'lldb-mi --interpreter' works for -file-exec-and-symbols fullpath/exe."""
self.spawnLldbMi(args=None) self.spawnLldbMi(args=None)
# Test that -file-exec-and-symbols works for absolute path # Test that -file-exec-and-symbols works for absolute path
import os import os
path = os.path.join(os.getcwd(), self.myexe) path = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.myexe)
self.runCmd("-file-exec-and-symbols \"%s\"" % path) self.runCmd("-file-exec-and-symbols \"%s\"" % path)
self.expect("\^done") self.expect("\^done")
# Run # Run
self.runCmd("-exec-run") self.runCmd("-exec-run")
self.expect("\^running") self.expect("\^running")
self.expect("\*stopped,reason=\"exited-normally\"") self.expect("\*stopped,reason=\"exited-normally\"")
Show All 30 Lines

packages/Python/lldbsuite/test/tools/lldb-mi/TestMiLibraryLoaded.py

Show All 23 Lines def test_lldbmi_library_loaded(self):
self.spawnLldbMi(args=None) self.spawnLldbMi(args=None)
# Load executable # Load executable
self.runCmd("-file-exec-and-symbols %s" % self.myexe) self.runCmd("-file-exec-and-symbols %s" % self.myexe)
self.expect("\^done") self.expect("\^done")
# Test =library-loaded # Test =library-loaded
import os import os
path = os.path.join(os.getcwd(), self.myexe) path = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.myexe)
symbols_path = os.path.join( symbols_path = os.path.join(
path + ".dSYM", path + ".dSYM",
"Contents", "Contents",
"Resources", "Resources",
"DWARF", "DWARF",
self.myexe) self.myexe)
def add_slashes(x): return x.replace( def add_slashes(x): return x.replace(
Show All 19 Lines

packages/Python/lldbsuite/test/tools/lldb-mi/breakpoint/TestMiBreak.py

Show First 20 Lines • Show All 194 Lines • ▼ Show 20 Lines def test_lldbmi_break_insert_file_line_absolute_path(self):
self.runCmd("-break-insert -f main") self.runCmd("-break-insert -f main")
self.expect("\^done,bkpt={number=\"1\"") self.expect("\^done,bkpt={number=\"1\"")
self.runCmd("-exec-run") self.runCmd("-exec-run")
self.expect("\^running") self.expect("\^running")
self.expect("\*stopped,reason=\"breakpoint-hit\"") self.expect("\*stopped,reason=\"breakpoint-hit\"")
import os import os
path = os.path.join(os.getcwd(), "main.cpp") path = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "main.cpp")
line = line_number('main.cpp', '// BP_return') line = line_number('main.cpp', '// BP_return')
self.runCmd("-break-insert %s:%d" % (path, line)) self.runCmd("-break-insert %s:%d" % (path, line))
self.expect("\^done,bkpt={number=\"2\"") self.expect("\^done,bkpt={number=\"2\"")
self.runCmd("-exec-continue") self.runCmd("-exec-continue")
self.expect("\^running") self.expect("\^running")
self.expect("\*stopped,reason=\"breakpoint-hit\"") self.expect("\*stopped,reason=\"breakpoint-hit\"")
▲ Show 20 Lines • Show All 147 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/tools/lldb-mi/startup_options/TestMiStartupOptions.py

Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Linesclass MiStartupOptionsTestCase(lldbmi_testcase.MiTestCaseBase):
@skipIfRemote # We do not currently support remote debugging via the MI. @skipIfRemote # We do not currently support remote debugging via the MI.
@skipIfWindows # llvm.org/pr24452: Get lldb-mi tests working on Windows @skipIfWindows # llvm.org/pr24452: Get lldb-mi tests working on Windows
@skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
def test_lldbmi_executable_option_absolute_path(self): def test_lldbmi_executable_option_absolute_path(self):
"""Test that 'lldb-mi --interpreter %s' loads executable which is specified via absolute path.""" """Test that 'lldb-mi --interpreter %s' loads executable which is specified via absolute path."""
# Prepare path to executable # Prepare path to executable
import os import os
path = os.path.join(os.getcwd(), self.myexe) path = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.myexe)
self.spawnLldbMi(args="%s" % path) self.spawnLldbMi(args="%s" % path)
# Test that the executable is loaded when file was specified using # Test that the executable is loaded when file was specified using
# absolute path # absolute path
self.expect("-file-exec-and-symbols \"%s\"" % path) self.expect("-file-exec-and-symbols \"%s\"" % path)
self.expect("\^done") self.expect("\^done")
▲ Show 20 Lines • Show All 230 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/tools/lldb-mi/symbol/TestMiSymbol.py

Show First 20 Lines • Show All 86 Lines • ▼ Show 20 Lines def test_lldbmi_symbol_list_lines_file(self):
# relative path # relative path
self.runCmd("-symbol-list-lines ./main.cpp") self.runCmd("-symbol-list-lines ./main.cpp")
self.expect( self.expect(
"\^error,message=\"error: No source filenames matched '\./main\.cpp'\. \"") "\^error,message=\"error: No source filenames matched '\./main\.cpp'\. \"")
# Test that -symbol-list-lines works when file is specified using # Test that -symbol-list-lines works when file is specified using
# absolute path # absolute path
import os import os
path = os.path.join(os.getcwd(), "main.cpp") path = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "main.cpp")
self.runCmd("-symbol-list-lines \"%s\"" % path) self.runCmd("-symbol-list-lines \"%s\"" % path)
self.expect( self.expect(
"\^done,lines=\[\{pc=\"0x0*%x\",line=\"%d\"\}(,\{pc=\"0x[0-9a-f]+\",line=\"\d+\"\})+\]" % "\^done,lines=\[\{pc=\"0x0*%x\",line=\"%d\"\}(,\{pc=\"0x[0-9a-f]+\",line=\"\d+\"\})+\]" %
(addr, line)) (addr, line))
# Test that -symbol-list-lines fails when file doesn't exist # Test that -symbol-list-lines fails when file doesn't exist
self.runCmd("-symbol-list-lines unknown_dir/main.cpp") self.runCmd("-symbol-list-lines unknown_dir/main.cpp")
self.expect( self.expect(
"\^error,message=\"error: No source filenames matched 'unknown_dir/main\.cpp'\. \"") "\^error,message=\"error: No source filenames matched 'unknown_dir/main\.cpp'\. \"")

packages/Python/lldbsuite/test/types/AbstractBase.py

Show All 28 Linesclass GenericTester(TestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# We'll use the test method name as the exe_name. # We'll use the test method name as the exe_name.
# There are a bunch of test cases under test/types and we don't want the # There are a bunch of test cases under test/types and we don't want the
# module cacheing subsystem to be confused with executable name "a.out" # module cacheing subsystem to be confused with executable name "a.out"
# used for all the test cases. # used for all the test cases.
self.exe_name = self.testMethodName self.exe_name = self.testMethodName
self.golden_filename = os.path.join(os.getcwd(), "golden-output.txt") self.golden_filename = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, "golden-output.txt")
def tearDown(self): def tearDown(self):
"""Cleanup the test byproducts.""" """Cleanup the test byproducts."""
#print("Removing golden-output.txt...") #print("Removing golden-output.txt...")
if os.path.exists(self.golden_filename): if os.path.exists(self.golden_filename):
os.remove(self.golden_filename) os.remove(self.golden_filename)
TestBase.tearDown(self) TestBase.tearDown(self)
▲ Show 20 Lines • Show All 254 Lines • Show Last 20 Lines

packages/Python/lldbsuite/test/warnings/uuid/TestAddDsymCommand.py

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines def test_add_dsym_with_dSYM_bundle(self):
self.generate_main_cpp(version=1) self.generate_main_cpp(version=1)
self.buildDsym(clean=True) self.buildDsym(clean=True)
self.exe_name = 'a.out' self.exe_name = 'a.out'
self.do_add_dsym_with_dSYM_bundle(self.exe_name) self.do_add_dsym_with_dSYM_bundle(self.exe_name)
def generate_main_cpp(self, version=0): def generate_main_cpp(self, version=0):
"""Generate main.cpp from main.cpp.template.""" """Generate main.cpp from main.cpp.template."""
temp = os.path.join(os.getcwd(), self.template) temp = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.template)
with open(temp, 'r') as f: with open(temp, 'r') as f:
content = f.read() content = f.read()
new_content = content.replace( new_content = content.replace(
'%ADD_EXTRA_CODE%', '%ADD_EXTRA_CODE%',
'printf("This is version %d\\n");' % 'printf("This is version %d\\n");' %
version) version)
src = os.path.join(os.getcwd(), self.source) src = os.path.join(os.getcwd(), os.environ["LLDB_BUILD"], self.mydir, self.source)
with open(src, 'w') as f: with open(src, 'w') as f:
f.write(new_content) f.write(new_content)
# The main.cpp has been generated, add a teardown hook to remove it. # The main.cpp has been generated, add a teardown hook to remove it.
if not self.teardown_hook_added: if not self.teardown_hook_added:
self.addTearDownHook(lambda: os.remove(src)) self.addTearDownHook(lambda: os.remove(src))
self.teardown_hook_added = True self.teardown_hook_added = True
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines