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

Repository
rL LLVM

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 ↗(On Diff #130544)

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
lldb/
trunk/
packages/
Python/
lldbsuite/
test/
android/
platform/
2 lines
api/
check_public_api_headers/
4 lines
listeners/
2 lines
arm/
breakpoint-it/
4 lines
benchmarks/
continue/
3 lines
expression/
2 lines
2 lines
libcxxlist/
3 lines
libcxxmap/
3 lines
2 lines
2 lines
driver/
batch_mode/
6 lines
expression_command/
anonymous-struct/
3 lines
call-function/
3 lines
2 lines
2 lines
expr-in-syscall/
2 lines
formatters/
2 lines
ir-interpreter-phi-nodes/
2 lines
ir-interpreter/
2 lines
multiline/
2 lines
options/
2 lines
persist_objc_pointeetype/
2 lines
persistent_ptr_update/
2 lines
persistent_types/
2 lines
2 lines
persistent_variables/
2 lines
po_verbosity/
2 lines
radar_8638051/
2 lines
radar_9531204/
2 lines
radar_9673664/
2 lines
test/
6 lines
2 lines
top-level/
2 lines
two-files/
2 lines
functionalities/
apropos_with_process/
2 lines
archives/
2 lines
asan/
2 lines
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
2 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/
2 lines
breakpoint_options/
4 lines
breakpoint_set_restart/
2 lines
cpp/
4 lines
cpp_exception/
2 lines
debugbreak/
2 lines
dummy_target_breakpoints/
2 lines
global_constructor/
2 lines
hardware_breakpoints/
hardware_breakpoint_on_multiple_threads/
8 lines
inlined_breakpoints/
2 lines
move_nearest/
2 lines
objc/
2 lines
serialize/
2 lines
source_regexp/
4 lines
step_over_breakpoint/
2 lines
command_script/
2 lines
completion/
5 lines
conditional_break/
6 lines
darwin_log/
filter/
exact_match/
activity-chain/
2 lines
activity/
2 lines
category/
2 lines
message/
2 lines
subsystem/
2 lines
regex/
activity-chain/
2 lines
activity/
2 lines
category/
2 lines
subsystem/
2 lines
format/
2 lines
source/
debug/
2 lines
info/
2 lines
data-formatter/
boolreference/
2 lines
compactvectors/
2 lines
data-formatter-advanced/
2 lines
data-formatter-categories/
2 lines
data-formatter-cpp/
2 lines
data-formatter-disabling/
2 lines
data-formatter-enum-format/
2 lines
data-formatter-globals/
2 lines
data-formatter-named-summaries/
2 lines
data-formatter-objc/
10 lines
nsindexpath/
2 lines
nsstring/
2 lines
data-formatter-proper-plurals/
2 lines
data-formatter-ptr-to-array/
2 lines
data-formatter-python-synth/
4 lines
data-formatter-script/
2 lines
data-formatter-skip-summary/
2 lines
data-formatter-smart-array/
2 lines
data-formatter-stl/
libcxx/
atomic/
2 lines
function/
2 lines
initializerlist/
2 lines
iterator/
2 lines
list/
2 lines
loop/
2 lines
map/
2 lines
multimap/
2 lines
multiset/
2 lines
set/
2 lines
string/
2 lines
unordered/
2 lines
vbool/
2 lines
vector/
2 lines
libstdcpp/
iterator/
2 lines
list/
2 lines
map/
2 lines
smart_ptr/
2 lines
string/
2 lines
tuple/
2 lines
unique_ptr/
4 lines
vbool/
2 lines
vector/
2 lines
data-formatter-synth/
2 lines
data-formatter-synthtype/
2 lines
data-formatter-synthval/
2 lines
format-propagation/
2 lines
frameformat_smallstruct/
2 lines
hexcaps/
2 lines
language_category_updates/
2 lines
nsarraysynth/
2 lines
nsdictionarysynth/
2 lines
nssetsynth/
2 lines
ostypeformatting/
2 lines
parray/
2 lines
poarray/
2 lines
ptr_ref_typedef/
2 lines
pyobjsynthprovider/
2 lines
refpointer-recursion/
2 lines
summary-string-onfail/
2 lines
synthcapping/
2 lines
synthupdate/
2 lines
type_summary_list_script/
2 lines
user-format-vs-summary/
2 lines
var-in-aggregate-misuse/
2 lines
varscript_formatting/
2 lines
vector-types/
2 lines
dead-strip/
2 lines
disassembly/
2 lines
2 lines
dynamic_value_child_count/
2 lines
embedded_interpreter/
2 lines
exec/
4 lines
expr-doesnt-deadlock/
2 lines
fat_archives/
2 lines
format/
7 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/
12 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/
5 lines
nosucharch/
2 lines
plugins/
python_os_plugin/
4 lines
postmortem/
minidump/
4 lines
pre_run_dylibs/
2 lines
process_group/
2 lines
process_launch/
6 lines
process_save_core/
4 lines
ptr_refs/
3 lines
recursion/
2 lines
register/
intel_avx/
2 lines
intel_xtended_registers/
2 lines
mpx_bound_violation/
2 lines
register_command/
8 lines
rerun/
2 lines
return-value/
4 lines
set-data/
2 lines
signal/
2 lines
handle-segv/
2 lines
raise/
4 lines
single-quote-in-filename-to-lldb/
7 lines
step-avoids-no-debug/
2 lines
stop-hook/
2 lines
2 lines
target_command/
12 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
type_completion/
2 lines
type_lookup/
2 lines
ubsan/
basic/
2 lines
user-expression/
2 lines
unwind/
ehframe/
2 lines
noreturn/
2 lines
sigtramp/
2 lines
standard/
2 lines
value_md5_crash/
2 lines
watchpoint/
hello_watchpoint/
2 lines
multi_watchpoint_slots/
2 lines
multiple_hits/
2 lines
multiple_threads/
16 lines
step_over_watchpoint/
2 lines
watchpoint_disable/
4 lines
watchpoint_events/
2 lines
watchpoint_on_vectors/
4 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/
8 lines
const_variables/
2 lines
enum_types/
2 lines
find_struct_type/
2 lines
forward/
2 lines
function_types/
2 lines
global_variables/
2 lines
modules/
2 lines
register_variables/
2 lines
set_values/
2 lines
shared_lib/
2 lines
shared_lib_stripped_symbols/
2 lines
step-target/
2 lines
stepping/
2 lines
2 lines
strings/
2 lines
tls_globals/
2 lines
typedef/
2 lines
unions/
2 lines
cpp/
auto/
2 lines
bool/
2 lines
breakpoint-commands/
2 lines
call-function/
2 lines
chained-calls/
2 lines
char1632_t/
2 lines
class_static/
4 lines
class_types/
14 lines
2 lines
diamond/
2 lines
dynamic-value/
2 lines
enum_types/
2 lines
exceptions/
2 lines
frame-var-anon-unions/
2 lines
global_operators/
3 lines
gmodules/
2 lines
inlines/
2 lines
limit-debug-info/
2 lines
member-and-local-vars-with-same-name/
2 lines
namespace/
8 lines
16 lines
namespace_definitions/
2 lines
nsimport/
3 lines
overloaded-functions/
2 lines
rvalue-references/
2 lines
scope/
3 lines
signed_types/
2 lines
static_members/
2 lines
static_methods/
2 lines
stl/
4 lines
2 lines
template/
2 lines
this/
2 lines
unicode-literals/
2 lines
unique-types/
2 lines
unsigned_types/
2 lines
virtual/
2 lines
wchar_t/
2 lines
go/
expressions/
2 lines
formatters/
2 lines
goroutines/
2 lines
runtime/
2 lines
types/
2 lines
mixed/
2 lines
objc/
blocks/
2 lines
conflicting-definition/
2 lines
forward-decl/
2 lines
foundation/
2 lines
4 lines
8 lines
12 lines
2 lines
2 lines
global_ptrs/
2 lines
hidden-ivars/
10 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-dynamic-value/
2 lines
objc-ivar-offsets/
2 lines
objc-ivar-stripped/
4 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
ptr_refs/
3 lines
real-definition/
2 lines
self/
2 lines
single-entry-dictionary/
2 lines
linux/
add-symbols/
5 lines
builtin_trap/
2 lines
thread/
create_during_instruction_step/
2 lines
3 lines
7 lines
26 lines
logging/
2 lines
macosx/
add-dsym/
5 lines
debug-info/
apple_types/
4 lines
indirect_symbol/
2 lines
nslog/
2 lines
order/
4 lines
queues/
4 lines
safe-to-func-call/
2 lines
thread-names/
2 lines
python_api/
breakpoint/
4 lines
event/
6 lines
findvalue_duplist/
3 lines
formatters/
2 lines
frame/
6 lines
get-variables/
2 lines
inlines/
2 lines
function_symbol/
2 lines
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
rdar-12481949/
2 lines
sbdata/
2 lines
sbvalue_persist/
2 lines
signals/
2 lines
symbol-context/
4 lines
two-files/
4 lines
target/
6 lines
thread/
4 lines
value/
empty_class/
2 lines
watchpoint/
2 lines
2 lines
2 lines
watchlocation/
2 lines
4 lines
settings/
12 lines
quoting/
2 lines
source-manager/
8 lines
tools/
lldb-mi/
7 lines
2 lines
14 lines
startup_options/
32 lines
lldb-server/
2 lines
6 lines
platform-process-connect/
9 lines
types/
2 lines
warnings/
uuid/
15 lines

Diff 130707

lldb/trunk/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 = self.getBuildArtifact("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")
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

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

Show All 14 Lines
class SBDirCheckerCase(TestBase): class SBDirCheckerCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def setUp(self): def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
self.source = 'main.cpp' self.source = 'main.cpp'
self.exe_name = 'a.out' self.exe_name = self.getBuildArtifact("a.out")
self.generateSource(self.source) self.generateSource(self.source)
@skipIfNoSBHeaders @skipIfNoSBHeaders
def test_sb_api_directory(self): def test_sb_api_directory(self):
"""Test the SB API directory and make sure there's no unwanted stuff.""" """Test the SB API directory and make sure there's no unwanted stuff."""
# Only proceed if this is an Apple OS, "x86_64", and local platform. # Only proceed if this is an Apple OS, "x86_64", and local platform.
if not (self.platformIsDarwin() and self.getArchitecture() == "x86_64"): if not (self.platformIsDarwin() and self.getArchitecture() == "x86_64"):
self.skipTest("This test is only for LLDB.framework built 64-bit") self.skipTest("This test is only for LLDB.framework built 64-bit")
if self.getArchitecture() == "i386": if self.getArchitecture() == "i386":
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 = self.getBuildArtifact(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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("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))

lldb/trunk/packages/Python/lldbsuite/test/benchmarks/continue/TestBenchmarkContinue.py

Show All 24 Lines def test_run_command(self):
self.data_formatter_commands() self.data_formatter_commands()
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
BenchBase.setUp(self) BenchBase.setUp(self)
def data_formatter_commands(self): def data_formatter_commands(self):
"""Benchmark different ways to continue a process""" """Benchmark different ways to continue a process"""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file "+self.getBuildArtifact("a.out"),
CURRENT_EXECUTABLE_SET)
bkpt = self.target().FindBreakpointByID( bkpt = self.target().FindBreakpointByID(
lldbutil.run_break_set_by_source_regexp( lldbutil.run_break_set_by_source_regexp(
self, "// break here")) self, "// break here"))
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 All 32 Lines

lldb/trunk/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 = self.getBuildArtifact(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

lldb/trunk/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 = self.getBuildArtifact(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 20 Lines • Show All 86 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/benchmarks/libcxxlist/TestBenchmarkLibcxxList.py

Show All 24 Lines def test_run_command(self):
self.data_formatter_commands() self.data_formatter_commands()
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
BenchBase.setUp(self) BenchBase.setUp(self)
def data_formatter_commands(self): def data_formatter_commands(self):
"""Benchmark the std::list data formatter (libc++)""" """Benchmark the std::list data formatter (libc++)"""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"),
CURRENT_EXECUTABLE_SET)
bkpt = self.target().FindBreakpointByID( bkpt = self.target().FindBreakpointByID(
lldbutil.run_break_set_by_source_regexp( lldbutil.run_break_set_by_source_regexp(
self, "break here")) self, "break here"))
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 All 25 Lines

lldb/trunk/packages/Python/lldbsuite/test/benchmarks/libcxxmap/TestBenchmarkLibcxxMap.py

Show All 24 Lines def test_run_command(self):
self.data_formatter_commands() self.data_formatter_commands()
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
BenchBase.setUp(self) BenchBase.setUp(self)
def data_formatter_commands(self): def data_formatter_commands(self):
"""Benchmark the std::map data formatter (libc++)""" """Benchmark the std::map data formatter (libc++)"""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " +self.getBuildArtifact("a.out"),
CURRENT_EXECUTABLE_SET)
bkpt = self.target().FindBreakpointByID( bkpt = self.target().FindBreakpointByID(
lldbutil.run_break_set_by_source_regexp( lldbutil.run_break_set_by_source_regexp(
self, "break here")) self, "break here"))
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 All 25 Lines

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/packages/Python/lldbsuite/test/darwin_log.py

Show First 20 Lines • Show All 340 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 = self.getBuildArtifact(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

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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

lldb/trunk/packages/Python/lldbsuite/test/expression_command/anonymous-struct/TestCallUserAnonTypedef.py

Show All 26 Linesclass TestExprLookupAnonStructTypedef(TestBase):
@expectedFailureAll( @expectedFailureAll(
oslist=['linux'], oslist=['linux'],
archs=['arm'], archs=['arm'],
bugnumber="llvm.org/pr27868") bugnumber="llvm.org/pr27868")
def test(self): def test(self):
"""Test typedeffed untagged struct arguments for function call expressions""" """Test typedeffed untagged struct arguments for function call expressions"""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file "+self.getBuildArtifact("a.out"),
CURRENT_EXECUTABLE_SET)
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,
num_expected_locations=-1, num_expected_locations=-1,
loc_exact=True loc_exact=True
) )
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.expect("expr multiply(&s)", substrs=['$0 = 1']) self.expect("expr multiply(&s)", substrs=['$0 = 1'])

lldb/trunk/packages/Python/lldbsuite/test/expression_command/call-function/TestCallStdStringFunction.py

Show All 24 Linesclass ExprCommandCallFunctionTestCase(TestBase):
@expectedFailureAll( @expectedFailureAll(
compiler="icc", compiler="icc",
bugnumber="llvm.org/pr14437, fails with ICC 13.1") bugnumber="llvm.org/pr14437, fails with ICC 13.1")
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
def test_with(self): def test_with(self):
"""Test calling std::String member function.""" """Test calling std::String member function."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"),
CURRENT_EXECUTABLE_SET)
# Some versions of GCC encode two locations for the 'return' statement # Some versions of GCC encode two locations for the 'return' statement
# in main.cpp # in main.cpp
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 Lines

lldb/trunk/packages/Python/lldbsuite/test/expression_command/call-function/TestCallStopAndContinue.py

Show All 25 Linesclass ExprCommandCallStopContinueTestCase(TestBase):
@expectedFlakeyDarwin("llvm.org/pr20274") @expectedFlakeyDarwin("llvm.org/pr20274")
@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(self): def test(self):
"""Test gathering result from interrupted function call.""" """Test gathering result from interrupted function call."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
# Some versions of GCC encode two locations for the 'return' statement # Some versions of GCC encode two locations for the 'return' statement
# in main.cpp # in main.cpp
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 16 Lines

lldb/trunk/packages/Python/lldbsuite/test/expression_command/call-function/TestCallUserDefinedFunction.py

Show All 31 Linesclass ExprCommandCallUserDefinedFunction(TestBase):
@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(self): def test(self):
"""Test return values of user defined function calls.""" """Test return values of user defined function calls."""
self.build() self.build()
# Set breakpoint in main and run exe # Set breakpoint in main and run exe
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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)
# Test recursive function call. # Test recursive function call.
self.expect("expr fib(5)", substrs=['$0 = 5']) self.expect("expr fib(5)", substrs=['$0 = 5'])
Show All 14 Lines

lldb/trunk/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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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

lldb/trunk/packages/Python/lldbsuite/test/expression_command/formatters/TestFormatters.py

Show All 37 Lines def test(self):
def cleanup(): def cleanup():
self.runCmd('type summary clear', check=False) self.runCmd('type summary clear', check=False)
self.runCmd('type synthetic clear', check=False) self.runCmd('type synthetic clear', 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)
"""Test expr + formatters for good interoperability.""" """Test expr + formatters for good interoperability."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.line, loc_exact=True) self, "main.cpp", self.line, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.runCmd("command script import formatters.py") self.runCmd("command script import formatters.py")
self.runCmd("command script import foosynth.py") self.runCmd("command script import foosynth.py")
▲ Show 20 Lines • Show All 244 Lines • Show Last 20 Lines

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/packages/Python/lldbsuite/test/expression_command/ir-interpreter/TestIRInterpreter.py

Show All 28 Lines def setUp(self):
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 build_and_run(self): def build_and_run(self):
"""Test the IR interpreter""" """Test the IR interpreter"""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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)
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
# getpid() is POSIX, among other problems, see bug # getpid() is POSIX, among other problems, see bug
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/packages/Python/lldbsuite/test/expression_command/persist_objc_pointeetype/TestPersistObjCPointeeType.py

Show All 28 Lines def test_with(self):
self.build() self.build()
def cleanup(): def cleanup():
pass pass
# Execute the cleanup function during test case tear down. # Execute the cleanup function during test case tear down.
self.addTearDownHook(cleanup) self.addTearDownHook(cleanup)
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.m", self.line, loc_exact=True) self, "main.m", self.line, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.expect("p *self", substrs=['_sc_name = nil', self.expect("p *self", substrs=['_sc_name = nil',
'_sc_name2 = nil', '_sc_name2 = nil',
'_sc_name3 = nil', '_sc_name3 = nil',
'_sc_name4 = nil', '_sc_name4 = nil',
'_sc_name5 = nil', '_sc_name5 = nil',
'_sc_name6 = nil', '_sc_name6 = nil',
'_sc_name7 = nil', '_sc_name7 = nil',
'_sc_name8 = nil']) '_sc_name8 = nil'])

lldb/trunk/packages/Python/lldbsuite/test/expression_command/persistent_ptr_update/TestPersistentPtrUpdate.py

Show All 22 Lines def test(self):
self.build() self.build()
def cleanup(): def cleanup():
pass pass
# Execute the cleanup function during test case tear down. # Execute the cleanup function during test case tear down.
self.addTearDownHook(cleanup) self.addTearDownHook(cleanup)
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
self.runCmd('break set -p here') self.runCmd('break set -p here')
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.runCmd("expr void* $foo = 0") self.runCmd("expr void* $foo = 0")
self.runCmd("continue") self.runCmd("continue")
self.expect("expr $foo", substrs=['$foo', '0x0']) self.expect("expr $foo", substrs=['$foo', '0x0'])

lldb/trunk/packages/Python/lldbsuite/test/expression_command/persistent_types/TestNestedPersistentTypes.py

Show All 16 Linesclass NestedPersistentTypesTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
def test_persistent_types(self): def test_persistent_types(self):
"""Test that nested persistent types work.""" """Test that nested persistent types work."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
self.runCmd("breakpoint set --name main") self.runCmd("breakpoint set --name main")
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.runCmd("expression struct $foo { int a; int b; };") self.runCmd("expression struct $foo { int a; int b; };")
self.runCmd( self.runCmd(
Show All 12 Lines

lldb/trunk/packages/Python/lldbsuite/test/expression_command/persistent_types/TestPersistentTypes.py

Show All 16 Linesclass PersistenttypesTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
def test_persistent_types(self): def test_persistent_types(self):
"""Test that lldb persistent types works correctly.""" """Test that lldb persistent types works correctly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
self.runCmd("breakpoint set --name main") self.runCmd("breakpoint set --name main")
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.runCmd("expression struct $foo { int a; int b; };") self.runCmd("expression struct $foo { int a; int b; };")
self.expect( self.expect(
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/expression_command/persistent_variables/TestPersistentVariables.py

Show All 13 Lines
class PersistentVariablesTestCase(TestBase): class PersistentVariablesTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def test_persistent_variables(self): def test_persistent_variables(self):
"""Test that lldb persistent variables works correctly.""" """Test that lldb persistent variables works correctly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
self.runCmd("breakpoint set --source-pattern-regexp break") self.runCmd("breakpoint set --source-pattern-regexp break")
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.runCmd("expression int $i = i") self.runCmd("expression int $i = i")
self.expect("expression $i == i", self.expect("expression $i == i",
Show All 25 Lines

lldb/trunk/packages/Python/lldbsuite/test/expression_command/po_verbosity/TestPoVerbosity.py

Show All 31 Lines def test(self):
def cleanup(): def cleanup():
self.runCmd('type summary clear', check=False) self.runCmd('type summary clear', check=False)
self.runCmd('type synthetic clear', check=False) self.runCmd('type synthetic clear', 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)
"""Test expr + formatters for good interoperability.""" """Test expr + formatters for good interoperability."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.m", self.line, loc_exact=True) self, "main.m", self.line, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.expect("expr -O -v -- foo", self.expect("expr -O -v -- foo",
substrs=['(id) $', ' = 0x', '1 = 2', '2 = 3;']) substrs=['(id) $', ' = 0x', '1 = 2', '2 = 3;'])
Show All 15 Lines

lldb/trunk/packages/Python/lldbsuite/test/expression_command/radar_8638051/Test8638051.py

Show All 13 Lines
class Radar8638051TestCase(TestBase): class Radar8638051TestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def test_expr_commands(self): def test_expr_commands(self):
"""The following expression commands should not crash.""" """The following expression commands should not crash."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
self.runCmd("breakpoint set -n c") self.runCmd("breakpoint set -n c")
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.expect("expression val", self.expect("expression val",
startstr="(int) $0 = 1") startstr="(int) $0 = 1")
# (int) $0 = 1 # (int) $0 = 1
Show All 10 Lines

lldb/trunk/packages/Python/lldbsuite/test/expression_command/radar_9531204/TestPrintfAfterUp.py

Show All 17 Linesclass Radar9531204TestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
# rdar://problem/9531204 # rdar://problem/9531204
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
def test_expr_commands(self): def test_expr_commands(self):
"""The evaluating printf(...) after break stop and then up a stack frame.""" """The evaluating printf(...) after break stop and then up a stack frame."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_symbol( lldbutil.run_break_set_by_symbol(
self, 'foo', sym_exact=True, num_expected_locations=1) self, 'foo', sym_exact=True, num_expected_locations=1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.runCmd("frame variable") self.runCmd("frame variable")
Show All 11 Lines

lldb/trunk/packages/Python/lldbsuite/test/expression_command/radar_9673664/TestExprHelpExamples.py

Show All 23 Lines def setUp(self):
self.main_source = "main.c" self.main_source = "main.c"
self.line = line_number(self.main_source, '// Set breakpoint here.') self.line = line_number(self.main_source, '// Set breakpoint here.')
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
def test_expr_commands(self): def test_expr_commands(self):
"""The following expression commands should just work.""" """The following expression commands should just work."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
# rdar://problem/9673664 lldb expression evaluation problem # rdar://problem/9673664 lldb expression evaluation problem
self.expect('expr char str[] = "foo"; str[0]', self.expect('expr char str[] = "foo"; str[0]',
substrs=["'f'"]) substrs=["'f'"])
# runCmd: expr char c[] = "foo"; c[0] # runCmd: expr char c[] = "foo"; c[0]
# output: (char) $0 = 'f' # output: (char) $0 = 'f'

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

Show All 39 Lines def setUp(self):
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 build_and_run(self): def build_and_run(self):
"""These basic expression commands should work as expected.""" """These basic expression commands should work as expected."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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=False) self, "main.cpp", self.line, num_expected_locations=1, loc_exact=False)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
@unittest2.expectedFailure( @unittest2.expectedFailure(
"llvm.org/pr17135 <rdar://problem/14874559> APFloat::toString does not identify the correct (i.e. least) precision.") "llvm.org/pr17135 <rdar://problem/14874559> APFloat::toString does not identify the correct (i.e. least) precision.")
▲ Show 20 Lines • Show All 45 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 = self.getBuildArtifact("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 84 Lines • ▼ Show 20 Linesclass BasicExprCommandsTestCase(TestBase):
# rdar://problem/8686536 # rdar://problem/8686536
# CommandInterpreter::HandleCommand is stripping \'s from input for # CommandInterpreter::HandleCommand is stripping \'s from input for
# WantsRawCommand commands # WantsRawCommand commands
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
def test_expr_commands_can_handle_quotes(self): def test_expr_commands_can_handle_quotes(self):
"""Throw some expression commands with quotes at lldb.""" """Throw some expression commands with quotes at lldb."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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=False) self, "main.cpp", self.line, num_expected_locations=1, loc_exact=False)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
# runCmd: expression 'a' # runCmd: expression 'a'
# output: (char) $0 = 'a' # output: (char) $0 = 'a'
Show All 36 Lines

lldb/trunk/packages/Python/lldbsuite/test/expression_command/test/TestExprs2.py

Show All 25 Linesclass ExprCommands2TestCase(TestBase):
@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_more_expr_commands(self): def test_more_expr_commands(self):
"""Test some more expression commands.""" """Test some more expression commands."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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=False) self, "main.cpp", self.line, num_expected_locations=1, loc_exact=False)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
# Does static casting work? # Does static casting work?
self.expect("expression (int*)argv", self.expect("expression (int*)argv",
Show All 23 Lines

lldb/trunk/packages/Python/lldbsuite/test/expression_command/top-level/TestTopLevelExprs.py

Show All 31 Lines def setUp(self):
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 build_and_run(self): def build_and_run(self):
"""Test top-level expressions.""" """Test top-level expressions."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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=False) self, "main.cpp", self.line, num_expected_locations=1, loc_exact=False)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
def run_dummy(self): def run_dummy(self):
self.runCmd("file dummy", CURRENT_EXECUTABLE_SET) self.runCmd("file dummy", CURRENT_EXECUTABLE_SET)
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/expression_command/two-files/TestObjCTypeQueryFromOtherCompileUnit.py

Show All 22 Lines def setUp(self):
# Find the line number to break for main.m. # Find the line number to break for main.m.
self.line = line_number( self.line = line_number(
'main.m', "// Set breakpoint here, then do 'expr (NSArray*)array_token'.") 'main.m', "// Set breakpoint here, then do 'expr (NSArray*)array_token'.")
@skipUnlessDarwin @skipUnlessDarwin
def test(self): def test(self):
"""The expression parser's type search should be wider than the current compilation unit.""" """The expression parser's type search should be wider than the current compilation unit."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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)
# Now do a NSArry type query from the 'main.m' compile uint. # Now do a NSArry type query from the 'main.m' compile uint.
self.expect("expression (NSArray*)array_token", self.expect("expression (NSArray*)array_token",
substrs=['(NSArray *) $0 = 0x']) substrs=['(NSArray *) $0 = 0x'])
# (NSArray *) $0 = 0x00007fff70118398 # (NSArray *) $0 = 0x00007fff70118398

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
breakpoint = target.BreakpointCreateBySourceRegex( breakpoint = target.BreakpointCreateBySourceRegex(
'Set breakpoint here', lldb.SBFileSpec("main.c", False)) 'Set breakpoint here', lldb.SBFileSpec("main.c", False))
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
process1 = target.LaunchSimple( process1 = target.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
Show All 16 Lines

lldb/trunk/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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact(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

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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")

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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,
Show All 30 Lines

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("a.out")
error = lldb.SBError() error = lldb.SBError()
# Don't read in dependencies so we don't come across false matches that # Don't read in dependencies so we don't come across false matches that
# add unwanted breakpoint hits. # add unwanted breakpoint hits.
self.target = self.dbg.CreateTarget(exe, None, None, False, error) self.target = self.dbg.CreateTarget(exe, None, None, False, error)
self.assertTrue(self.target, VALID_TARGET) self.assertTrue(self.target, VALID_TARGET)
cpp_bp = self.target.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 = self.getBuildArtifact("a.out")
error = lldb.SBError() error = lldb.SBError()
# Don't read in dependencies so we don't come across false matches that # Don't read in dependencies so we don't come across false matches that
# add unwanted breakpoint hits. # add unwanted breakpoint hits.
self.target = self.dbg.CreateTarget(exe, None, None, False, error) self.target = self.dbg.CreateTarget(exe, None, None, False, error)
self.assertTrue(self.target, VALID_TARGET) self.assertTrue(self.target, VALID_TARGET)
cpp_bp = self.target.BreakpointCreateByName( cpp_bp = self.target.BreakpointCreateByName(
"func_from_cpp", "func_from_cpp",
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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(), "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()
▲ Show 20 Lines • Show All 298 Lines • Show Last 20 Lines

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("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

lldb/trunk/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_set_restart/TestBreakpointSetRestart.py

Show All 10 Linesclass BreakpointSetRestart(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
BREAKPOINT_TEXT = 'Set a breakpoint here' BREAKPOINT_TEXT = 'Set a breakpoint here'
def test_breakpoint_set_restart(self): def test_breakpoint_set_restart(self):
self.build() self.build()
cwd = os.getcwd() cwd = os.getcwd()
exe = os.path.join(cwd, 'a.out') exe = self.getBuildArtifact("a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
self.dbg.SetAsync(True) self.dbg.SetAsync(True)
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 25 Lines

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

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

Show All 16 Linesclass TestBreakpointInGlobalConstructors(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
def test(self): def test(self):
self.build() self.build()
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')
target = self.dbg.CreateTarget("a.out") target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
env= self.registerSharedLibrariesWithTarget(target, ["foo"]) env= self.registerSharedLibrariesWithTarget(target, ["foo"])
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)
Show All 13 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/breakpoint/hardware_breakpoints/hardware_breakpoint_on_multiple_threads/TestHWBreakMultiThread.py

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines def setUp(self):
# Our simple source filename. # Our simple source filename.
self.source = 'main.cpp' self.source = 'main.cpp'
# Find the line number to break inside main(). # Find the line number to break inside main().
self.first_stop = line_number( self.first_stop = line_number(
self.source, 'Starting thread creation with hardware breakpoint set') self.source, 'Starting thread creation with hardware breakpoint set')
def break_multi_thread(self, removal_type): def break_multi_thread(self, removal_type):
"""Test that lldb hardware breakpoints work for multiple threads.""" """Test that lldb hardware breakpoints work for multiple threads."""
self.runCmd( self.runCmd("file " + self.getBuildArtifact("a.out"),
"file %s" %
os.path.join(
os.getcwd(),
'a.out'),
CURRENT_EXECUTABLE_SET) CURRENT_EXECUTABLE_SET)
# Stop in main before creating any threads. # Stop in main before creating any threads.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, None, self.first_stop, num_expected_locations=1) self, None, self.first_stop, 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 Last 20 Lines

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/packages/Python/lldbsuite/test/functionalities/breakpoint/move_nearest/TestMoveNearest.py

Show All 18 Lines def setUp(self):
self.line1 = line_number('foo.h', '// !BR1') self.line1 = line_number('foo.h', '// !BR1')
self.line2 = line_number('foo.h', '// !BR2') self.line2 = line_number('foo.h', '// !BR2')
self.line_main = line_number('main.cpp', '// !BR_main') self.line_main = line_number('main.cpp', '// !BR_main')
def test(self): def test(self):
"""Test target.move-to-nearest logic""" """Test target.move-to-nearest logic"""
self.build() self.build()
target = self.dbg.CreateTarget("a.out") target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
lldbutil.run_break_set_by_symbol(self, 'main', sym_exact=True) lldbutil.run_break_set_by_symbol(self, 'main', sym_exact=True)
environment = self.registerSharedLibrariesWithTarget(target, ["foo"]) environment = self.registerSharedLibrariesWithTarget(target, ["foo"])
process = target.LaunchSimple(None, environment, self.get_process_working_directory()) process = target.LaunchSimple(None, environment, self.get_process_working_directory())
self.assertEquals(process.GetState(), lldb.eStateStopped) self.assertEquals(process.GetState(), lldb.eStateStopped)
# Regardless of the -m value the breakpoint should have exactly one # Regardless of the -m value the breakpoint should have exactly one
Show All 28 Lines

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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)
▲ Show 20 Lines • Show All 217 Lines • Show Last 20 Lines

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/packages/Python/lldbsuite/test/functionalities/completion/TestCompletion.py

Show First 20 Lines • Show All 297 Lines • ▼ Show 20 Lines def test_target_va(self):
self.complete_from_to('target va', 'target variable ') self.complete_from_to('target va', 'target variable ')
@expectedFailureAll(hostoslist=["windows"], bugnumber="llvm.org/pr24679") @expectedFailureAll(hostoslist=["windows"], bugnumber="llvm.org/pr24679")
@expectedFailureAll( @expectedFailureAll(
oslist=lldbplatform.darwin_all, oslist=lldbplatform.darwin_all,
bugnumber="llvm.org/pr25485,<rdar://problem/28573448>") bugnumber="llvm.org/pr25485,<rdar://problem/28573448>")
def test_symbol_name(self): def test_symbol_name(self):
self.build() self.build()
self.complete_from_to('''file a.out self.complete_from_to('''file %s
breakpoint set -n Fo''', breakpoint set -n Fo''' %
self.getBuildArtifact("a.out"),
'breakpoint set -n Foo::Bar(int,\\ int)', 'breakpoint set -n Foo::Bar(int,\\ int)',
turn_off_re_match=True) turn_off_re_match=True)
def complete_from_to(self, str_input, patterns, turn_off_re_match=False): def complete_from_to(self, str_input, patterns, turn_off_re_match=False):
"""Test that the completion mechanism completes str_input to patterns, """Test that the completion mechanism completes str_input to patterns,
where patterns could be a pattern-string or a list of pattern-strings""" where patterns could be a pattern-string or a list of pattern-strings"""
import pexpect import pexpect
# Patterns should not be None in order to proceed. # Patterns should not be None in order to proceed.
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

lldb/trunk/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 = self.getBuildArtifact("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 56 Lines • ▼ Show 20 Lines def simulate_conditional_break_by_user(self):
# breakpoint such that lldb only stops when the caller of c() is a(). # breakpoint such that lldb only stops when the caller of c() is a().
# the "my" package that defines the date() function. # the "my" package that defines the date() function.
if self.TraceOn(): if self.TraceOn():
print("About to source .lldb") print("About to source .lldb")
if not self.TraceOn(): if not self.TraceOn():
self.HideStdout() self.HideStdout()
# Separate out the "file a.out" command from .lldb file, for the sake of # Separate out the "file " + self.getBuildArtifact("a.out") command from .lldb file, for the sake of
# remote testsuite. # remote testsuite.
self.runCmd("file a.out") self.runCmd("file " + self.getBuildArtifact("a.out"))
self.runCmd("command source .lldb") self.runCmd("command source .lldb")
self.runCmd("break list") self.runCmd("break list")
if self.TraceOn(): if self.TraceOn():
print("About to run.") print("About to run.")
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 19 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/darwin_log/filter/exact_match/activity-chain/TestDarwinLogFilterMatchActivityChain.py

Show All 23 Linesclass TestDarwinLogFilterMatchActivityChain(darwin_log.DarwinLogTestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
super(TestDarwinLogFilterMatchActivityChain, self).setUp() super(TestDarwinLogFilterMatchActivityChain, self).setUp()
# Source filename. # Source filename.
self.source = 'main.c' self.source = 'main.c'
# Output filename. # Output filename.
self.exe_name = 'a.out' self.exe_name = self.getBuildArtifact("a.out")
self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name} self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
# Locate breakpoint. # Locate breakpoint.
self.line = lldbtest.line_number(self.source, '// break here') self.line = lldbtest.line_number(self.source, '// break here')
def tearDown(self): def tearDown(self):
# Shut down the process if it's still running. # Shut down the process if it's still running.
if self.child: if self.child:
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/darwin_log/filter/exact_match/activity/TestDarwinLogFilterMatchActivity.py

Show All 23 Linesclass TestDarwinLogFilterMatchActivity(darwin_log.DarwinLogTestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
super(TestDarwinLogFilterMatchActivity, self).setUp() super(TestDarwinLogFilterMatchActivity, self).setUp()
# Source filename. # Source filename.
self.source = 'main.c' self.source = 'main.c'
# Output filename. # Output filename.
self.exe_name = 'a.out' self.exe_name = self.getBuildArtifact("a.out")
self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name} self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
# Locate breakpoint. # Locate breakpoint.
self.line = lldbtest.line_number(self.source, '// break here') self.line = lldbtest.line_number(self.source, '// break here')
def tearDown(self): def tearDown(self):
# Shut down the process if it's still running. # Shut down the process if it's still running.
if self.child: if self.child:
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/darwin_log/filter/exact_match/category/TestDarwinLogFilterMatchCategory.py

Show All 23 Linesclass TestDarwinLogFilterMatchCategory(darwin_log.DarwinLogTestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
super(TestDarwinLogFilterMatchCategory, self).setUp() super(TestDarwinLogFilterMatchCategory, self).setUp()
# Source filename. # Source filename.
self.source = 'main.c' self.source = 'main.c'
# Output filename. # Output filename.
self.exe_name = 'a.out' self.exe_name = self.getBuildArtifact("a.out")
self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name} self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
# Locate breakpoint. # Locate breakpoint.
self.line = lldbtest.line_number(self.source, '// break here') self.line = lldbtest.line_number(self.source, '// break here')
def tearDown(self): def tearDown(self):
# Shut down the process if it's still running. # Shut down the process if it's still running.
if self.child: if self.child:
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/darwin_log/filter/exact_match/message/TestDarwinLogFilterMatchMessage.py

Show All 23 Linesclass TestDarwinLogFilterMatchMessage(darwin_log.DarwinLogTestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
super(TestDarwinLogFilterMatchMessage, self).setUp() super(TestDarwinLogFilterMatchMessage, self).setUp()
# Source filename. # Source filename.
self.source = 'main.c' self.source = 'main.c'
# Output filename. # Output filename.
self.exe_name = 'a.out' self.exe_name = self.getBuildArtifact("a.out")
self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name} self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
# Locate breakpoint. # Locate breakpoint.
self.line = lldbtest.line_number(self.source, '// break here') self.line = lldbtest.line_number(self.source, '// break here')
self.strict_sources = True self.strict_sources = True
# Turn on process monitor logging while we work out issues. # Turn on process monitor logging while we work out issues.
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/darwin_log/filter/exact_match/subsystem/TestDarwinLogFilterMatchSubsystem.py

Show All 23 Linesclass TestDarwinLogFilterMatchSubsystem(darwin_log.DarwinLogTestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
super(TestDarwinLogFilterMatchSubsystem, self).setUp() super(TestDarwinLogFilterMatchSubsystem, self).setUp()
# Source filename. # Source filename.
self.source = 'main.c' self.source = 'main.c'
# Output filename. # Output filename.
self.exe_name = 'a.out' self.exe_name = self.getBuildArtifact("a.out")
self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name} self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
# Locate breakpoint. # Locate breakpoint.
self.line = lldbtest.line_number(self.source, '// break here') self.line = lldbtest.line_number(self.source, '// break here')
def tearDown(self): def tearDown(self):
# Shut down the process if it's still running. # Shut down the process if it's still running.
if self.child: if self.child:
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/darwin_log/filter/regex/activity-chain/TestDarwinLogFilterRegexActivityChain.py

Show All 23 Linesclass TestDarwinLogFilterRegexActivityChain(darwin_log.DarwinLogTestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
super(TestDarwinLogFilterRegexActivityChain, self).setUp() super(TestDarwinLogFilterRegexActivityChain, self).setUp()
# Source filename. # Source filename.
self.source = 'main.c' self.source = 'main.c'
# Output filename. # Output filename.
self.exe_name = 'a.out' self.exe_name = self.getBuildArtifact("a.out")
self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name} self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
# Locate breakpoint. # Locate breakpoint.
self.line = lldbtest.line_number(self.source, '// break here') self.line = lldbtest.line_number(self.source, '// break here')
def tearDown(self): def tearDown(self):
# Shut down the process if it's still running. # Shut down the process if it's still running.
if self.child: if self.child:
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/darwin_log/filter/regex/activity/TestDarwinLogFilterRegexActivity.py

Show All 23 Linesclass TestDarwinLogFilterRegexActivity(darwin_log.DarwinLogTestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
super(TestDarwinLogFilterRegexActivity, self).setUp() super(TestDarwinLogFilterRegexActivity, self).setUp()
# Source filename. # Source filename.
self.source = 'main.c' self.source = 'main.c'
# Output filename. # Output filename.
self.exe_name = 'a.out' self.exe_name = self.getBuildArtifact("a.out")
self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name} self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
# Locate breakpoint. # Locate breakpoint.
self.line = lldbtest.line_number(self.source, '// break here') self.line = lldbtest.line_number(self.source, '// break here')
def tearDown(self): def tearDown(self):
# Shut down the process if it's still running. # Shut down the process if it's still running.
if self.child: if self.child:
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/darwin_log/filter/regex/category/TestDarwinLogFilterRegexCategory.py

Show All 23 Linesclass TestDarwinLogFilterRegexCategory(darwin_log.DarwinLogTestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
super(TestDarwinLogFilterRegexCategory, self).setUp() super(TestDarwinLogFilterRegexCategory, self).setUp()
# Source filename. # Source filename.
self.source = 'main.c' self.source = 'main.c'
# Output filename. # Output filename.
self.exe_name = 'a.out' self.exe_name = self.getBuildArtifact("a.out")
self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name} self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
# Locate breakpoint. # Locate breakpoint.
self.line = lldbtest.line_number(self.source, '// break here') self.line = lldbtest.line_number(self.source, '// break here')
def tearDown(self): def tearDown(self):
# Shut down the process if it's still running. # Shut down the process if it's still running.
if self.child: if self.child:
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/darwin_log/filter/regex/subsystem/TestDarwinLogFilterRegexSubsystem.py

Show All 23 Linesclass TestDarwinLogFilterRegexSubsystem(darwin_log.DarwinLogTestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
super(TestDarwinLogFilterRegexSubsystem, self).setUp() super(TestDarwinLogFilterRegexSubsystem, self).setUp()
# Source filename. # Source filename.
self.source = 'main.c' self.source = 'main.c'
# Output filename. # Output filename.
self.exe_name = 'a.out' self.exe_name = self.getBuildArtifact("a.out")
self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name} self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
# Locate breakpoint. # Locate breakpoint.
self.line = lldbtest.line_number(self.source, '// break here') self.line = lldbtest.line_number(self.source, '// break here')
def tearDown(self): def tearDown(self):
# Shut down the process if it's still running. # Shut down the process if it's still running.
if self.child: if self.child:
▲ Show 20 Lines • Show All 120 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/darwin_log/format/TestDarwinLogMessageFormat.py

Show All 22 Linesclass TestDarwinLogMessageFormat(darwin_log.DarwinLogTestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
super(TestDarwinLogMessageFormat, self).setUp() super(TestDarwinLogMessageFormat, self).setUp()
# Source filename. # Source filename.
self.source = 'main.c' self.source = 'main.c'
# Output filename. # Output filename.
self.exe_name = 'a.out' self.exe_name = self.getBuildArtifact("a.out")
self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name} self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
# Locate breakpoint. # Locate breakpoint.
self.line = lldbtest.line_number(self.source, '// break here') self.line = lldbtest.line_number(self.source, '// break here')
def tearDown(self): def tearDown(self):
# Shut down the process if it's still running. # Shut down the process if it's still running.
if self.child: if self.child:
▲ Show 20 Lines • Show All 149 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/darwin_log/source/debug/TestDarwinLogSourceDebug.py

Show All 23 Linesclass TestDarwinLogSourceDebug(darwin_log.DarwinLogTestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
super(TestDarwinLogSourceDebug, self).setUp() super(TestDarwinLogSourceDebug, self).setUp()
# Source filename. # Source filename.
self.source = 'main.c' self.source = 'main.c'
# Output filename. # Output filename.
self.exe_name = 'a.out' self.exe_name = self.getBuildArtifact("a.out")
self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name} self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
# Locate breakpoint. # Locate breakpoint.
self.line = lldbtest.line_number(self.source, '// break here') self.line = lldbtest.line_number(self.source, '// break here')
# Indicate we want strict-sources behavior. # Indicate we want strict-sources behavior.
self.strict_sources = True self.strict_sources = True
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/darwin_log/source/info/TestDarwinLogSourceInfo.py

Show All 23 Linesclass TestDarwinLogSourceInfo(darwin_log.DarwinLogTestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
super(TestDarwinLogSourceInfo, self).setUp() super(TestDarwinLogSourceInfo, self).setUp()
# Source filename. # Source filename.
self.source = 'main.c' self.source = 'main.c'
# Output filename. # Output filename.
self.exe_name = 'a.out' self.exe_name = self.getBuildArtifact("a.out")
self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name} self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
# Locate breakpoint. # Locate breakpoint.
self.line = lldbtest.line_number(self.source, '// break here') self.line = lldbtest.line_number(self.source, '// break here')
# Indicate we want strict-sources behavior. # Indicate we want strict-sources behavior.
self.strict_sources = True self.strict_sources = True
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/boolreference/TestFormattersBoolRefPtr.py

Show All 26 Linesclass DataFormatterBoolRefPtr(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 at. # Find the line number to break at.
self.line = line_number('main.mm', '// Set break point at this line.') self.line = line_number('main.mm', '// Set break point at this line.')
def boolrefptr_data_formatter_commands(self): def boolrefptr_data_formatter_commands(self):
"""Test the formatters we use for BOOL& and BOOL* in Objective-C.""" """Test the formatters we use for BOOL& and BOOL* in Objective-C."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.mm", self.line, num_expected_locations=1, loc_exact=True) self, "main.mm", 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 38 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/compactvectors/TestCompactVectors.py

Show All 21 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break at. # Find the line number to break at.
self.line = line_number('main.cpp', '// Set break point at this line.') self.line = line_number('main.cpp', '// Set break point at this line.')
@skipUnlessDarwin @skipUnlessDarwin
def test_with_run_command(self): def test_with_run_command(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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 25 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-advanced/TestDataFormatterAdv.py

Show All 19 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break at. # Find the line number to break at.
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 that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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 20 Lines • Show All 286 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-categories/TestDataFormatterCategories.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 at. # Find the line number to break at.
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 that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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 20 Lines • Show All 322 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-cpp/TestDataFormatterCpp.py

Show All 23 Lines def setUp(self):
self.line = line_number('main.cpp', '// Set break point at this line.') self.line = line_number('main.cpp', '// Set break point at this line.')
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr24462: Data formatters have problems on Windows") bugnumber="llvm.org/pr24462: Data formatters have problems on Windows")
def test_with_run_command(self): def test_with_run_command(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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 20 Lines • Show All 258 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-disabling/TestDataFormatterDisabling.py

Show All 23 Lines def setUp(self):
self.line = line_number('main.cpp', '// Set break point at this line.') self.line = line_number('main.cpp', '// Set break point at this line.')
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr24462, Data formatters have problems on Windows") bugnumber="llvm.org/pr24462, Data formatters have problems on Windows")
def test_with_run_command(self): def test_with_run_command(self):
"""Check that we can properly disable all data formatter categories.""" """Check that we can properly disable all data formatter categories."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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 20 Lines • Show All 51 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-enum-format/TestDataFormatterEnumFormat.py

Show All 19 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break at. # Find the line number to break at.
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 that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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 31 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-globals/TestDataFormatterGlobals.py

Show All 19 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break at. # Find the line number to break at.
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 that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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)
# This is the function to remove the custom formats in order to have a # This is the function to remove the custom formats in order to have a
# clean slate for the next test case. # clean slate for the next test case.
def cleanup(): def cleanup():
self.runCmd('type format clear', check=False) self.runCmd('type format clear', check=False)
Show All 35 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-named-summaries/TestDataFormatterNamedSummaries.py

Show All 19 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break at. # Find the line number to break at.
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 that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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 20 Lines • Show All 97 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjC.py

Show First 20 Lines • Show All 90 Lines • ▼ Show 20 Linesclass ObjCDataFormatterTestCase(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 at. # Find the line number to break at.
self.line = line_number('main.m', '// Set break point at this line.') self.line = line_number('main.m', '// Set break point at this line.')
def plain_data_formatter_commands(self): def plain_data_formatter_commands(self):
"""Test basic ObjC formatting behavior.""" """Test basic ObjC formatting behavior."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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)
# 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 20 Lines • Show All 49 Lines • ▼ Show 20 Lines def plain_data_formatter_commands(self):
substrs=['(Class) myclass3 = Molecule']) substrs=['(Class) myclass3 = Molecule'])
self.expect('frame variable myclass4', self.expect('frame variable myclass4',
substrs=['(Class) myclass4 = NSMutableArray']) substrs=['(Class) myclass4 = NSMutableArray'])
self.expect('frame variable myclass5', self.expect('frame variable myclass5',
substrs=['(Class) myclass5 = nil']) substrs=['(Class) myclass5 = nil'])
def appkit_common_data_formatters_command(self): def appkit_common_data_formatters_command(self):
"""Test formatters for AppKit classes.""" """Test formatters for AppKit classes."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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)
# 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 20 Lines • Show All 181 Lines • ▼ Show 20 Lines def nsdate_data_formatter_commands(self):
self.expect( self.expect(
'frame variable mut_bv', 'frame variable mut_bv',
substrs=[ substrs=[
'(CFMutableBitVectorRef) mut_bv = ', '(CFMutableBitVectorRef) mut_bv = ',
'1110 0110 1011 0000 1101 1010 1000 1111 0011 0101 1101 0001 00']) '1110 0110 1011 0000 1101 1010 1000 1111 0011 0101 1101 0001 00'])
def expr_objc_data_formatter_commands(self): def expr_objc_data_formatter_commands(self):
"""Test common cases of expression parser <--> formatters interaction.""" """Test common cases of expression parser <--> formatters interaction."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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)
# 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 31 Lines def expr_objc_data_formatter_commands(self):
self.expect( self.expect(
'expr -d run --object-description -- @"Hello for long enough to avoid short string types"', 'expr -d run --object-description -- @"Hello for long enough to avoid short string types"',
substrs=['Hello for long enough to avoid short string types']) substrs=['Hello for long enough to avoid short string types'])
self.expect('expr -d run --object-description -- @"Hello"', self.expect('expr -d run --object-description -- @"Hello"',
matching=False, substrs=['@"Hello" Hello']) matching=False, substrs=['@"Hello" Hello'])
def cf_data_formatter_commands(self): def cf_data_formatter_commands(self):
"""Test formatters for Core OSX frameworks.""" """Test formatters for Core OSX frameworks."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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)
# 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 38 Lines def cf_data_formatter_commands(self):
expect_strings.append( expect_strings.append(
'(RGBColor *) rgb_color_ptr = red=3 green=56 blue=35') '(RGBColor *) rgb_color_ptr = red=3 green=56 blue=35')
self.expect("frame variable", self.expect("frame variable",
substrs=expect_strings) substrs=expect_strings)
def kvo_data_formatter_commands(self): def kvo_data_formatter_commands(self):
"""Test the behavior of formatters when KVO is in use.""" """Test the behavior of formatters when KVO is in use."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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)
# 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 37 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-objc/nsindexpath/TestDataFormatterNSIndexPath.py

Show All 15 Lines
class NSIndexPathDataFormatterTestCase(TestBase): class NSIndexPathDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def appkit_tester_impl(self, commands): def appkit_tester_impl(self, commands):
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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)
# 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 20 Lines • Show All 84 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-objc/nsstring/TestDataFormatterNSString.py

Show All 15 Lines
class NSStringDataFormatterTestCase(TestBase): class NSStringDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def appkit_tester_impl(self, commands): def appkit_tester_impl(self, commands):
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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)
# 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 20 Lines • Show All 89 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-proper-plurals/TestFormattersOneIsSingular.py

Show All 26 Linesclass DataFormatterOneIsSingularTestCase(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 at. # Find the line number to break at.
self.line = line_number('main.m', '// Set break point at this line.') self.line = line_number('main.m', '// Set break point at this line.')
def oneness_data_formatter_commands(self): def oneness_data_formatter_commands(self):
"""Test that 1 item is not as reported as 1 items.""" """Test that 1 item is not as reported as 1 items."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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)
# 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 38 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-ptr-to-array/TestPtrToArrayFormatting.py

Show All 23 Linesclass PtrToArrayDataFormatterTestCase(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 at. # Find the line number to break at.
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 data_formatter_commands(self): def data_formatter_commands(self):
"""Test that LLDB handles the clang typeclass Paren correctly.""" """Test that LLDB handles the clang typeclass Paren correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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 19 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-python-synth/TestDataFormatterPythonSynth.py

Show All 34 Lines def setUp(self):
self.line = line_number('main.cpp', '// Set break point at this line.') self.line = line_number('main.cpp', '// Set break point at this line.')
self.line2 = line_number('main.cpp', self.line2 = line_number('main.cpp',
'// Set cast break point at this line.') '// Set cast break point at this line.')
self.line3 = line_number( self.line3 = line_number(
'main.cpp', '// Set second cast break point at this line.') 'main.cpp', '// Set second cast break point at this line.')
def data_formatter_commands(self): def data_formatter_commands(self):
"""Test using Python synthetic children provider.""" """Test using Python synthetic children provider."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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)
process = self.dbg.GetSelectedTarget().GetProcess() process = self.dbg.GetSelectedTarget().GetProcess()
▲ Show 20 Lines • Show All 165 Lines • ▼ Show 20 Lines def data_formatter_commands(self):
'b = 2', 'b = 2',
'j = 18']) 'j = 18'])
self.expect("frame variable f00_1", matching=False, self.expect("frame variable f00_1", matching=False,
substrs=['fake_a = ']) substrs=['fake_a = '])
def rdar10960550_formatter_commands(self): def rdar10960550_formatter_commands(self):
"""Test that synthetic children persist stoppoints.""" """Test that synthetic children persist stoppoints."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
# The second breakpoint is on a multi-line expression, so the comment # The second breakpoint is on a multi-line expression, so the comment
# can't be on the right line... # can't be on the right line...
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.line2, num_expected_locations=1, loc_exact=False) self, "main.cpp", self.line2, num_expected_locations=1, loc_exact=False)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.line3, num_expected_locations=1, loc_exact=True) self, "main.cpp", self.line3, num_expected_locations=1, loc_exact=True)
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-script/TestDataFormatterScript.py

Show All 23 Linesclass ScriptDataFormatterTestCase(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 at. # Find the line number to break at.
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 data_formatter_commands(self): def data_formatter_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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 20 Lines • Show All 145 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-skip-summary/TestDataFormatterSkipSummary.py

Show All 30 Linesclass SkipSummaryDataFormatterTestCase(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 at. # Find the line number to break at.
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 data_formatter_commands(self): def data_formatter_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
#import lldbsuite.test.lldbutil as lldbutil #import lldbsuite.test.lldbutil as lldbutil
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.
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-smart-array/TestDataFormatterSmartArray.py

Show All 27 Linesclass SmartArrayDataFormatterTestCase(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 at. # Find the line number to break at.
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 data_formatter_commands(self): def data_formatter_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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)
process = self.dbg.GetSelectedTarget().GetProcess() process = self.dbg.GetSelectedTarget().GetProcess()
▲ Show 20 Lines • Show All 415 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/atomic/TestLibCxxAtomic.py

Show All 22 Lines def get_variable(self, name):
var.SetPreferSyntheticValue(True) var.SetPreferSyntheticValue(True)
return var return var
@skipIf(compiler=["gcc"]) @skipIf(compiler=["gcc"])
@add_test_categories(["libc++"]) @add_test_categories(["libc++"])
def test(self): def test(self):
"""Test that std::atomic as defined by libc++ is correctly printed by LLDB""" """Test that std::atomic as defined by libc++ is correctly printed by LLDB"""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
bkpt = self.target().FindBreakpointByID( bkpt = self.target().FindBreakpointByID(
lldbutil.run_break_set_by_source_regexp( lldbutil.run_break_set_by_source_regexp(
self, "Set break point at this line.")) self, "Set break point at this line."))
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
lldbutil.skip_if_library_missing( lldbutil.skip_if_library_missing(
Show All 23 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/function/TestLibCxxFunction.py

Show All 21 Lines def get_variable(self, name):
var.SetPreferDynamicValue(lldb.eDynamicCanRunTarget) var.SetPreferDynamicValue(lldb.eDynamicCanRunTarget)
var.SetPreferSyntheticValue(True) var.SetPreferSyntheticValue(True)
return var return var
@add_test_categories(["libc++"]) @add_test_categories(["libc++"])
def test(self): def test(self):
"""Test that std::function as defined by libc++ is correctly printed by LLDB""" """Test that std::function as defined by libc++ is correctly printed by LLDB"""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
bkpt = self.target().FindBreakpointByID( bkpt = self.target().FindBreakpointByID(
lldbutil.run_break_set_by_source_regexp( lldbutil.run_break_set_by_source_regexp(
self, "Set break point at this line.")) self, "Set break point at this line."))
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 All 14 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/initializerlist/TestInitializerList.py

Show All 19 Linesclass InitializerListTestCase(TestBase):
@skipIfWindows # libc++ not ported to Windows yet @skipIfWindows # libc++ not ported to Windows yet
@skipIf(compiler="gcc") @skipIf(compiler="gcc")
@expectedFailureAll( @expectedFailureAll(
oslist=["linux"], oslist=["linux"],
bugnumber="fails on clang 3.5 and tot") bugnumber="fails on clang 3.5 and tot")
def test(self): def test(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
bkpt = self.target().FindBreakpointByID( bkpt = self.target().FindBreakpointByID(
lldbutil.run_break_set_by_source_regexp( lldbutil.run_break_set_by_source_regexp(
self, "Set break point at this line.")) self, "Set break point at this line."))
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
lldbutil.skip_if_library_missing( lldbutil.skip_if_library_missing(
Show All 12 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/iterator/TestDataFormatterLibccIterator.py

Show All 23 Lines def setUp(self):
self.line = line_number('main.cpp', '// Set break point at this line.') self.line = line_number('main.cpp', '// Set break point at this line.')
ns = 'ndk' if lldbplatformutil.target_is_android() else '' ns = 'ndk' if lldbplatformutil.target_is_android() else ''
self.namespace = 'std::__' + ns + '1' self.namespace = 'std::__' + ns + '1'
@add_test_categories(["libc++"]) @add_test_categories(["libc++"])
def test_with_run_command(self): def test_with_run_command(self):
"""Test that libc++ iterators format properly.""" """Test that libc++ iterators format properly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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) self, "main.cpp", self.line, 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,
Show All 36 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/list/TestDataFormatterLibcxxList.py

Show All 28 Lines def setUp(self):
'// Set third break point at this line.') '// Set third break point at this line.')
self.line4 = line_number('main.cpp', self.line4 = line_number('main.cpp',
'// Set fourth break point at this line.') '// Set fourth break point at this line.')
@add_test_categories(["libc++"]) @add_test_categories(["libc++"])
def test_with_run_command(self): def test_with_run_command(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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) self, "main.cpp", self.line, num_expected_locations=-1)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.line2, num_expected_locations=-1) self, "main.cpp", self.line2, num_expected_locations=-1)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.line3, num_expected_locations=-1) self, "main.cpp", self.line3, num_expected_locations=-1)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
▲ Show 20 Lines • Show All 170 Lines • Show Last 20 Lines

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/map/TestDataFormatterLibccMap.py

Show All 20 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
ns = 'ndk' if lldbplatformutil.target_is_android() else '' ns = 'ndk' if lldbplatformutil.target_is_android() else ''
self.namespace = 'std::__' + ns + '1' self.namespace = 'std::__' + ns + '1'
@add_test_categories(["libc++"]) @add_test_categories(["libc++"])
def test_with_run_command(self): def test_with_run_command(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
bkpt = self.target().FindBreakpointByID( bkpt = self.target().FindBreakpointByID(
lldbutil.run_break_set_by_source_regexp( lldbutil.run_break_set_by_source_regexp(
self, "Set break point at this line.")) self, "Set break point at this line."))
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 277 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/multimap/TestDataFormatterLibccMultiMap.py

Show All 21 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
ns = 'ndk' if lldbplatformutil.target_is_android() else '' ns = 'ndk' if lldbplatformutil.target_is_android() else ''
self.namespace = 'std::__' + ns + '1' self.namespace = 'std::__' + ns + '1'
@add_test_categories(["libc++"]) @add_test_categories(["libc++"])
def test_with_run_command(self): def test_with_run_command(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
bkpt = self.target().FindBreakpointByID( bkpt = self.target().FindBreakpointByID(
lldbutil.run_break_set_by_source_regexp( lldbutil.run_break_set_by_source_regexp(
self, "Set break point at this line.")) self, "Set break point at this line."))
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 276 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/multiset/TestDataFormatterLibcxxMultiSet.py

Show All 25 Lines def getVariableType(self, name):
var = self.frame().FindVariable(name) var = self.frame().FindVariable(name)
self.assertTrue(var.IsValid()) self.assertTrue(var.IsValid())
return var.GetType().GetCanonicalType().GetName() return var.GetType().GetCanonicalType().GetName()
@add_test_categories(["libc++"]) @add_test_categories(["libc++"])
def test_with_run_command(self): def test_with_run_command(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
bkpt = self.target().FindBreakpointByID( bkpt = self.target().FindBreakpointByID(
lldbutil.run_break_set_by_source_regexp( lldbutil.run_break_set_by_source_regexp(
self, "Set break point at this line.")) self, "Set break point at this line."))
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 91 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/set/TestDataFormatterLibcxxSet.py

Show All 25 Lines def getVariableType(self, name):
var = self.frame().FindVariable(name) var = self.frame().FindVariable(name)
self.assertTrue(var.IsValid()) self.assertTrue(var.IsValid())
return var.GetType().GetCanonicalType().GetName() return var.GetType().GetCanonicalType().GetName()
@add_test_categories(["libc++"]) @add_test_categories(["libc++"])
def test_with_run_command(self): def test_with_run_command(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
bkpt = self.target().FindBreakpointByID( bkpt = self.target().FindBreakpointByID(
lldbutil.run_break_set_by_source_regexp(self, "Set break point at this line.")) lldbutil.run_break_set_by_source_regexp(self, "Set break point at this line."))
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 20 Lines • Show All 86 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/string/TestDataFormatterLibcxxString.py

Show All 24 Lines def setUp(self):
self.line = line_number('main.cpp', '// Set break point at this line.') self.line = line_number('main.cpp', '// Set break point at this line.')
ns = 'ndk' if lldbplatformutil.target_is_android() else '' ns = 'ndk' if lldbplatformutil.target_is_android() else ''
self.namespace = 'std::__' + ns + '1' self.namespace = 'std::__' + ns + '1'
@add_test_categories(["libc++"]) @add_test_categories(["libc++"])
def test_with_run_command(self): def test_with_run_command(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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) self, "main.cpp", self.line, 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,
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/unordered/TestDataFormatterUnordered.py

Show All 19 Linesclass LibcxxUnorderedDataFormatterTestCase(TestBase):
def setUp(self): def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
ns = 'ndk' if lldbplatformutil.target_is_android() else '' ns = 'ndk' if lldbplatformutil.target_is_android() else ''
self.namespace = 'std::__' + ns + '1' self.namespace = 'std::__' + ns + '1'
@add_test_categories(["libc++"]) @add_test_categories(["libc++"])
def test_with_run_command(self): def test_with_run_command(self):
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_source_regexp( lldbutil.run_break_set_by_source_regexp(
self, "Set break point at this line.") self, "Set break point at this line.")
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 20 Lines • Show All 46 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/vbool/TestDataFormatterLibcxxVBool.py

Show All 21 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break at. # Find the line number to break at.
self.line = line_number('main.cpp', '// Set break point at this line.') self.line = line_number('main.cpp', '// Set break point at this line.')
@add_test_categories(["libc++"]) @add_test_categories(["libc++"])
def test_with_run_command(self): def test_with_run_command(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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) self, "main.cpp", self.line, 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,
Show All 40 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/vector/TestDataFormatterLibcxxVector.py

Show All 15 Lines
class LibcxxVectorDataFormatterTestCase(TestBase): class LibcxxVectorDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@add_test_categories(["libc++"]) @add_test_categories(["libc++"])
def test_with_run_command(self): def test_with_run_command(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
bkpt = self.target().FindBreakpointByID( bkpt = self.target().FindBreakpointByID(
lldbutil.run_break_set_by_source_regexp( lldbutil.run_break_set_by_source_regexp(
self, "break here")) self, "break here"))
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 153 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/iterator/TestDataFormatterStdIterator.py

Show All 22 Lines def setUp(self):
# Find the line number to break at. # Find the line number to break at.
self.line = line_number('main.cpp', '// Set break point at this line.') self.line = line_number('main.cpp', '// Set break point at this line.')
@skipIfWindows # libstdcpp not ported to Windows @skipIfWindows # libstdcpp not ported to Windows
@skipIfwatchOS # libstdcpp not ported to watchos @skipIfwatchOS # libstdcpp not ported to watchos
def test_with_run_command(self): def test_with_run_command(self):
"""Test that libstdcpp iterators format properly.""" """Test that libstdcpp iterators format properly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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) self, "main.cpp", self.line, 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,
Show All 36 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/list/TestDataFormatterStdList.py

Show All 26 Lines def setUp(self):
self.final_line = line_number( self.final_line = line_number(
'main.cpp', '// Set final break point at this line.') 'main.cpp', '// Set final break point at this line.')
@skipIfWindows # libstdcpp not ported to Windows @skipIfWindows # libstdcpp not ported to Windows
@skipIfwatchOS # libstdcpp not ported to watchos @skipIfwatchOS # libstdcpp not ported to watchos
def test_with_run_command(self): def test_with_run_command(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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) self, "main.cpp", self.line, 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,
▲ Show 20 Lines • Show All 167 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/map/TestDataFormatterStdMap.py

Show All 23 Lines def setUp(self):
self.line = line_number('main.cpp', '// Set break point at this line.') self.line = line_number('main.cpp', '// Set break point at this line.')
@skipIfWindows # libstdcpp not ported to Windows @skipIfWindows # libstdcpp not ported to Windows
@skipIfFreeBSD @skipIfFreeBSD
@skipIfwatchOS # libstdcpp not ported to watchos @skipIfwatchOS # libstdcpp not ported to watchos
def test_with_run_command(self): def test_with_run_command(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_source_regexp( lldbutil.run_break_set_by_source_regexp(
self, "Set break point at this line.") self, "Set break point at this line.")
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 20 Lines • Show All 296 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/smart_ptr/TestDataFormatterStdSmartPtr.py

Show All 15 Linesclass StdSmartPtrDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipIfFreeBSD @skipIfFreeBSD
@skipIfWindows # libstdcpp not ported to Windows @skipIfWindows # libstdcpp not ported to Windows
@skipIfDarwin # doesn't compile on Darwin @skipIfDarwin # doesn't compile on Darwin
@skipIfwatchOS # libstdcpp not ported to watchos @skipIfwatchOS # libstdcpp not ported to watchos
def test_with_run_command(self): def test_with_run_command(self):
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_source_regexp( lldbutil.run_break_set_by_source_regexp(
self, "Set break point at this line.") self, "Set break point at this line.")
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'])
Show All 18 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/string/TestDataFormatterStdString.py

Show All 23 Lines def setUp(self):
# Find the line number to break at. # Find the line number to break at.
self.line = line_number('main.cpp', '// Set break point at this line.') self.line = line_number('main.cpp', '// Set break point at this line.')
@skipIfWindows # libstdcpp not ported to Windows @skipIfWindows # libstdcpp not ported to Windows
@skipIfwatchOS # libstdcpp not ported to watchos @skipIfwatchOS # libstdcpp not ported to watchos
def test_with_run_command(self): def test_with_run_command(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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) self, "main.cpp", self.line, 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,
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/tuple/TestDataFormatterStdTuple.py

Show All 15 Linesclass StdTupleDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipIfFreeBSD @skipIfFreeBSD
@skipIfWindows # libstdcpp not ported to Windows @skipIfWindows # libstdcpp not ported to Windows
@skipIfDarwin # doesn't compile on Darwin @skipIfDarwin # doesn't compile on Darwin
@skipIfwatchOS # libstdcpp not ported to watchos @skipIfwatchOS # libstdcpp not ported to watchos
def test_with_run_command(self): def test_with_run_command(self):
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_source_regexp( lldbutil.run_break_set_by_source_regexp(
self, "Set break point at this line.") self, "Set break point at this line.")
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'])
Show All 18 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/unique_ptr/TestDataFormatterStdUniquePtr.py

Show All 15 Linesclass StdUniquePtrDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipIfFreeBSD @skipIfFreeBSD
@skipIfWindows # libstdcpp not ported to Windows @skipIfWindows # libstdcpp not ported to Windows
@skipIfDarwin # doesn't compile on Darwin @skipIfDarwin # doesn't compile on Darwin
@skipIfwatchOS # libstdcpp not ported to watchos @skipIfwatchOS # libstdcpp not ported to watchos
def test_with_run_command(self): def test_with_run_command(self):
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_source_regexp( lldbutil.run_break_set_by_source_regexp(
self, "Set break point at this line.") self, "Set break point at this line.")
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'])
Show All 36 Linesclass StdUniquePtrDataFormatterTestCase(TestBase):
@skipIfWindows # libstdcpp not ported to Windows @skipIfWindows # libstdcpp not ported to Windows
@skipIfDarwin # doesn't compile on Darwin @skipIfDarwin # doesn't compile on Darwin
@skipIfwatchOS # libstdcpp not ported to watchos @skipIfwatchOS # libstdcpp not ported to watchos
def test_recursive_unique_ptr(self): def test_recursive_unique_ptr(self):
# Tests that LLDB can handle when we have a loop in the unique_ptr # Tests that LLDB can handle when we have a loop in the unique_ptr
# reference chain and that it correctly handles the different options # reference chain and that it correctly handles the different options
# for the frame variable command in this case. # for the frame variable command in this case.
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_source_regexp( lldbutil.run_break_set_by_source_regexp(
self, "Set break point at this line.") self, "Set break point at this 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=['stopped', 'stop reason = breakpoint']) substrs=['stopped', 'stop reason = breakpoint'])
self.expect("frame variable f1->fp", self.expect("frame variable f1->fp",
Show All 13 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/vbool/TestDataFormatterStdVBool.py

Show All 26 Lines @expectedFailureAll(
oslist=['freebsd'], oslist=['freebsd'],
bugnumber='llvm.org/pr20548 fails to build on lab.llvm.org buildbot') bugnumber='llvm.org/pr20548 fails to build on lab.llvm.org buildbot')
@skipIfWindows # libstdcpp not ported to Windows. @skipIfWindows # libstdcpp not ported to Windows.
@skipIfDarwin @skipIfDarwin
@skipIfwatchOS # libstdcpp not ported to watchos @skipIfwatchOS # libstdcpp not ported to watchos
def test_with_run_command(self): def test_with_run_command(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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) self, "main.cpp", self.line, 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,
Show All 40 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/vector/TestDataFormatterStdVector.py

Show All 23 Lines def setUp(self):
self.line = line_number('main.cpp', '// Set break point at this line.') self.line = line_number('main.cpp', '// Set break point at this line.')
@skipIfFreeBSD @skipIfFreeBSD
@skipIfWindows # libstdcpp not ported to Windows @skipIfWindows # libstdcpp not ported to Windows
@skipIfwatchOS # libstdcpp not ported to watchos @skipIfwatchOS # libstdcpp not ported to watchos
def test_with_run_command(self): def test_with_run_command(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_source_regexp( lldbutil.run_break_set_by_source_regexp(
self, "Set break point at this line.") self, "Set break point at this line.")
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 20 Lines • Show All 178 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-synth/TestDataFormatterSynth.py

Show All 19 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break at. # Find the line number to break at.
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 that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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 20 Lines • Show All 184 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-synthtype/TestDataFormatterSynthType.py

Show All 21 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break at. # Find the line number to break at.
self.line = line_number('main.cpp', 'break here') self.line = line_number('main.cpp', 'break here')
@skipIfFreeBSD # llvm.org/pr20545 bogus output confuses buildbot parser @skipIfFreeBSD # llvm.org/pr20545 bogus output confuses buildbot parser
def test_with_run_command(self): def test_with_run_command(self):
"""Test using Python synthetic children provider to provide a typename.""" """Test using Python synthetic children provider to provide a typename."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-synthval/TestDataFormatterSynthVal.py

Show All 24 Linesclass DataFormatterSynthValueTestCase(TestBase):
@skipIfFreeBSD # llvm.org/pr20545 bogus output confuses buildbot parser @skipIfFreeBSD # llvm.org/pr20545 bogus output confuses buildbot parser
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr24462, Data formatters have problems on Windows") bugnumber="llvm.org/pr24462, Data formatters have problems on Windows")
def test_with_run_command(self): def test_with_run_command(self):
"""Test using Python synthetic children provider to provide a value.""" """Test using Python synthetic children provider to provide a value."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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 20 Lines • Show All 81 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/format-propagation/TestFormatPropagation.py

Show All 20 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break at. # Find the line number to break at.
self.line = line_number('main.cpp', '// Set break point at this line.') self.line = line_number('main.cpp', '// Set break point at this line.')
# rdar://problem/14035604 # rdar://problem/14035604
def test_with_run_command(self): def test_with_run_command(self):
"""Check for an issue where capping does not work because the Target pointer appears to be changing behind our backs.""" """Check for an issue where capping does not work because the Target pointer appears to be changing behind our backs."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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 20 Lines • Show All 48 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/frameformat_smallstruct/TestFrameFormatSmallStruct.py

Show All 19 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break at. # Find the line number to break at.
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 that the user can input a format but it will not prevail over summary format's choices.""" """Test that the user can input a format but it will not prevail over summary format's choices."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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,
substrs=['stopped', substrs=['stopped',
'stop reason = breakpoint']) 'stop reason = breakpoint'])
self.expect("thread list", substrs=['addPair(p=(x = 3, y = -3))']) self.expect("thread list", substrs=['addPair(p=(x = 3, y = -3))'])

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/hexcaps/TestDataFormatterHexCaps.py

Show All 19 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break at. # Find the line number to break at.
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 that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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 20 Lines • Show All 53 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/language_category_updates/TestDataFormatterLanguageCategoryUpdates.py

Show All 32 Lines def test_with_run_command(self):
self, self,
'type_specifier'): 'type_specifier'):
self.type_category.DeleteTypeSummary(self.type_specifier) self.type_category.DeleteTypeSummary(self.type_specifier)
# Execute the cleanup function during test case tear down. # Execute the cleanup function during test case tear down.
self.addTearDownHook(cleanup) self.addTearDownHook(cleanup)
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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 37 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/nsarraysynth/TestNSArraySynthetic.py

Show All 22 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break at. # Find the line number to break at.
self.line = line_number('main.m', '// Set break point at this line.') self.line = line_number('main.m', '// Set break point at this line.')
@skipUnlessDarwin @skipUnlessDarwin
def test_rdar11086338_with_run_command(self): def test_rdar11086338_with_run_command(self):
"""Test that NSArray reports its synthetic children properly.""" """Test that NSArray reports its synthetic children properly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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)
# 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 20 Lines • Show All 71 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/nsdictionarysynth/TestNSDictionarySynthetic.py

Show All 22 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break at. # Find the line number to break at.
self.line = line_number('main.m', '// Set break point at this line.') self.line = line_number('main.m', '// Set break point at this line.')
@skipUnlessDarwin @skipUnlessDarwin
def test_rdar11988289_with_run_command(self): def test_rdar11988289_with_run_command(self):
"""Test that NSDictionary reports its synthetic children properly.""" """Test that NSDictionary reports its synthetic children properly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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)
# 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 20 Lines • Show All 85 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/nssetsynth/TestNSSetSynthetic.py

Show All 22 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break at. # Find the line number to break at.
self.line = line_number('main.m', '// Set break point at this line.') self.line = line_number('main.m', '// Set break point at this line.')
@skipUnlessDarwin @skipUnlessDarwin
def test_rdar12529957_with_run_command(self): def test_rdar12529957_with_run_command(self):
"""Test that NSSet reports its synthetic children properly.""" """Test that NSSet reports its synthetic children properly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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)
# 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 20 Lines • Show All 76 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/ostypeformatting/TestFormattersOsType.py

Show All 22 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break at. # Find the line number to break at.
self.line = line_number('main.mm', '// Set break point at this line.') self.line = line_number('main.mm', '// Set break point at this line.')
@skipUnlessDarwin @skipUnlessDarwin
def test_ostype_with_run_command(self): def test_ostype_with_run_command(self):
"""Test the formatters we use for OSType.""" """Test the formatters we use for OSType."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.mm", self.line, num_expected_locations=1, loc_exact=True) self, "main.mm", 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 16 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/parray/TestPrintArray.py

Show All 25 Linesclass PrintArrayTestCase(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 at. # Find the line number to break at.
self.line = line_number('main.cpp', 'break here') self.line = line_number('main.cpp', 'break here')
def printarray_data_formatter_commands(self): def printarray_data_formatter_commands(self):
"""Test that expr -Z works""" """Test that expr -Z works"""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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 20 Lines • Show All 94 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/poarray/TestPrintObjectArray.py

Show All 26 Linesclass PrintObjectArrayTestCase(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 at. # Find the line number to break at.
self.line = line_number('main.mm', 'break here') self.line = line_number('main.mm', 'break here')
def printarray_data_formatter_commands(self): def printarray_data_formatter_commands(self):
"""Test that expr -O -Z works""" """Test that expr -O -Z works"""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.mm", self.line, num_expected_locations=1, loc_exact=True) self, "main.mm", 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 20 Lines • Show All 69 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/ptr_ref_typedef/TestPtrRef2Typedef.py

Show All 19 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break at. # Find the line number to break at.
self.line = line_number('main.cpp', '// Set breakpoint here') self.line = line_number('main.cpp', '// Set breakpoint here')
def test_with_run_command(self): def test_with_run_command(self):
"""Test that a pointer/reference to a typedef is formatted as we want.""" """Test that a pointer/reference to a typedef is formatted as we want."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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 31 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/pyobjsynthprovider/TestPyObjSynthProvider.py

Show All 27 Linesclass PyObjectSynthProviderTestCase(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 at. # Find the line number to break at.
self.line = line_number('main.cpp', 'break here') self.line = line_number('main.cpp', 'break here')
def provider_data_formatter_commands(self): def provider_data_formatter_commands(self):
"""Test that the PythonObjectSyntheticChildProvider helper class works""" """Test that the PythonObjectSyntheticChildProvider helper class works"""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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 29 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/refpointer-recursion/TestDataFormatterRefPtrRecursion.py

Show All 19 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break at. # Find the line number to break at.
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 that ValueObjectPrinter does not cause an infinite loop when a reference to a struct that contains a pointer to itself is printed.""" """Test that ValueObjectPrinter does not cause an infinite loop when a reference to a struct that contains a pointer to itself is printed."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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,
substrs=['stopped', substrs=['stopped',
'stop reason = breakpoint']) 'stop reason = breakpoint'])
self.expect("frame variable foo", substrs=[]) self.expect("frame variable foo", substrs=[])
self.expect("frame variable foo --ptr-depth=1", substrs=['ID = 1']) self.expect("frame variable foo --ptr-depth=1", substrs=['ID = 1'])
self.expect("frame variable foo --ptr-depth=2", substrs=['ID = 1']) self.expect("frame variable foo --ptr-depth=2", substrs=['ID = 1'])
self.expect("frame variable foo --ptr-depth=3", substrs=['ID = 1']) self.expect("frame variable foo --ptr-depth=3", substrs=['ID = 1'])

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/summary-string-onfail/Test-rdar-9974002.py

Show All 24 Linesclass Radar9974002DataFormatterTestCase(TestBase):
def test_with_run_command(self): def test_with_run_command(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.build() self.build()
if "clang" in self.getCompiler() and "3.4" in self.getCompilerVersion(): if "clang" in self.getCompiler() and "3.4" in self.getCompilerVersion():
self.skipTest( self.skipTest(
"llvm.org/pr16214 -- clang emits partial DWARF for structures referenced via typedef") "llvm.org/pr16214 -- clang emits partial DWARF for structures referenced via typedef")
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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 20 Lines • Show All 106 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/synthcapping/TestSyntheticCapping.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 at. # Find the line number to break at.
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):
"""Check for an issue where capping does not work because the Target pointer appears to be changing behind our backs.""" """Check for an issue where capping does not work because the Target pointer appears to be changing behind our backs."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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)
process = self.dbg.GetSelectedTarget().GetProcess() process = self.dbg.GetSelectedTarget().GetProcess()
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/synthupdate/TestSyntheticFilterRecompute.py

Show All 22 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break at. # Find the line number to break at.
self.line = line_number('main.m', '// Set break point at this line.') self.line = line_number('main.m', '// Set break point at this line.')
@skipUnlessDarwin @skipUnlessDarwin
def test_rdar12437442_with_run_command(self): def test_rdar12437442_with_run_command(self):
"""Test that we update SBValues correctly as dynamic types change.""" """Test that we update SBValues correctly as dynamic types change."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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)
# 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 20 Lines • Show All 48 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/type_summary_list_script/TestTypeSummaryListScript.py

Show All 24 Linesclass TypeSummaryListScriptTestCase(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 at. # Find the line number to break at.
self.line = line_number('main.cpp', 'Break here') self.line = line_number('main.cpp', 'Break here')
def data_formatter_commands(self): def data_formatter_commands(self):
"""Test printing out Python summary formatters.""" """Test printing out Python summary formatters."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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 24 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/user-format-vs-summary/TestUserFormatVsSummary.py

Show All 19 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break at. # Find the line number to break at.
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 that the user can input a format but it will not prevail over summary format's choices.""" """Test that the user can input a format but it will not prevail over summary format's choices."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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 38 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/var-in-aggregate-misuse/TestVarInAggregateMisuse.py

Show All 19 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break at. # Find the line number to break at.
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 that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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 20 Lines • Show All 44 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/varscript_formatting/TestDataFormatterVarScriptFormatting.py

Show All 22 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break at. # Find the line number to break at.
self.line = line_number('main.cpp', ' // Set breakpoint here.') self.line = line_number('main.cpp', ' // Set breakpoint here.')
@skipIfFreeBSD # llvm.org/pr20545 bogus output confuses buildbot parser @skipIfFreeBSD # llvm.org/pr20545 bogus output confuses buildbot parser
def test_with_run_command(self): def test_with_run_command(self):
"""Test using Python synthetic children provider.""" """Test using Python synthetic children provider."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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 21 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/vector-types/TestVectorTypesFormatting.py

Show All 22 Lines def setUp(self):
# Find the line number to break at. # Find the line number to break at.
self.line = line_number('main.cpp', '// break here') self.line = line_number('main.cpp', '// break here')
# rdar://problem/14035604 # rdar://problem/14035604
@skipIf(compiler='gcc') # gcc don't have ext_vector_type extension @skipIf(compiler='gcc') # gcc don't have ext_vector_type extension
def test_with_run_command(self): def test_with_run_command(self):
"""Check that vector types format properly""" """Check that vector types format properly"""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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 20 Lines • Show All 51 Lines • Show Last 20 Lines

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

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

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines def do_test(self, skip_exec):
o_file = os.path.join(os.getcwd(), "main.o") o_file = os.path.join(os.getcwd(), "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 = self.getBuildArtifact("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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/packages/Python/lldbsuite/test/functionalities/format/TestFormats.py

Show All 16 Linesclass TestFormats(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@expectedFailureAll( @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_formats(self): def test_formats(self):
"""Test format string functionality.""" """Test format string functionality."""
self.build() self.build()
exe = self.getBuildArtifact("a.out")
import pexpect import pexpect
prompt = "(lldb) " prompt = "(lldb) "
child = pexpect.spawn( child = pexpect.spawn(
'%s %s -x -o "b main" -o r a.out' % '%s %s -x -o "b main" -o r %s' %
(lldbtest_config.lldbExec, self.lldbOption)) (lldbtest_config.lldbExec, self.lldbOption, exe))
# Turn on logging for what the child sends back. # Turn on logging for what the child sends back.
if self.TraceOn(): if self.TraceOn():
child.logfile_read = sys.stdout child.logfile_read = sys.stdout
# So that the spawned lldb session gets shutdown durng teardown. # So that the spawned lldb session gets shutdown durng teardown.
self.child = child self.child = child
# Substitute 'Help!' for 'help' using the 'commands regex' mechanism. # Substitute 'Help!' for 'help' using the 'commands regex' mechanism.
child.expect_exact(prompt + 'target create "a.out"') child.expect_exact(prompt + 'target create "%s"' % exe)
child.expect_exact(prompt + 'b main') child.expect_exact(prompt + 'b main')
child.expect_exact(prompt + 'r') child.expect_exact(prompt + 'r')
child.expect_exact(prompt) child.expect_exact(prompt)
child.sendline() child.sendline()
# child.expect_exact(prompt + "target create") # child.expect_exact(prompt + "target create")
# #
# child.sendline("command regex 'Help__'") # child.sendline("command regex 'Help__'")
# child.expect_exact(regex_prompt) # child.expect_exact(regex_prompt)
Show All 20 Lines

lldb/trunk/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 = self.getBuildArtifact("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]"])

lldb/trunk/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 = self.getBuildArtifact("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")

lldb/trunk/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 = self.getBuildArtifact("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")

lldb/trunk/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 = self.getBuildArtifact("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")

lldb/trunk/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 = self.getBuildArtifact("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"])

lldb/trunk/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 = self.getBuildArtifact("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")

lldb/trunk/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 = self.getBuildArtifact("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")

lldb/trunk/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 = self.getBuildArtifact("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")

lldb/trunk/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 = self.getBuildArtifact("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")

lldb/trunk/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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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

lldb/trunk/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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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)

lldb/trunk/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 = self.getBuildArtifact("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

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

Show First 20 Lines • Show All 99 Lines • ▼ Show 20 Lines def test_modules_search_paths(self):
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(), "hidden")
old_dylib = os.path.join(os.getcwd(), dylibName) old_dylib = os.path.join(os.getcwd(), 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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 14 Linesclass LoadUnloadTestCase(TestBase):
@skipIfFreeBSD # llvm.org/pr14424 - missing FreeBSD Makefiles/testcase support @skipIfFreeBSD # llvm.org/pr14424 - missing FreeBSD Makefiles/testcase support
@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_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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

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

Show All 17 Lines def setUp(self):
self.source = 'main.cpp' self.source = 'main.cpp'
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.runCmd("file " + self.getBuildArtifact("a.out"),
exe = os.path.join(os.getcwd(), self.exe_name) 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 13 Lines

lldb/trunk/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 = self.getBuildArtifact("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")

lldb/trunk/packages/Python/lldbsuite/test/functionalities/plugins/python_os_plugin/TestPythonOSPlugin.py

Show All 39 Linesclass PluginPythonOSPlugin(TestBase):
def run_python_os_funcionality(self): def run_python_os_funcionality(self):
"""Test that the Python operating system plugin works correctly""" """Test that the Python operating system plugin works correctly"""
# Set debugger into synchronous mode # Set debugger into synchronous mode
self.dbg.SetAsync(False) self.dbg.SetAsync(False)
# Create a target by the debugger. # Create a target by the debugger.
cwd = os.getcwd() cwd = os.getcwd()
exe = os.path.join(cwd, "a.out") exe = self.getBuildArtifact("a.out")
python_os_plugin_path = os.path.join(cwd, "operating_system.py") python_os_plugin_path = os.path.join(cwd, "operating_system.py")
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_source_regexp(self, "// Set breakpoint here") lldbutil.run_break_set_by_source_regexp(self, "// Set breakpoint here")
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Linesclass PluginPythonOSPlugin(TestBase):
def run_python_os_step(self): def run_python_os_step(self):
"""Test that the Python operating system plugin works correctly and allows single stepping of a virtual thread that is backed by a real thread""" """Test that the Python operating system plugin works correctly and allows single stepping of a virtual thread that is backed by a real thread"""
# 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.
cwd = os.getcwd() cwd = os.getcwd()
exe = os.path.join(cwd, "a.out") exe = self.getBuildArtifact("a.out")
python_os_plugin_path = os.path.join(cwd, "operating_system2.py") python_os_plugin_path = os.path.join(cwd, "operating_system2.py")
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_source_regexp(self, "// Set breakpoint here") lldbutil.run_break_set_by_source_regexp(self, "// Set breakpoint here")
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

lldb/trunk/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 = self.getBuildArtifact("a.out")
core = os.path.join(os.getcwd(), "core.dmp") core = os.path.join(os.getcwd(), "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)
Show All 19 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 = self.getBuildArtifact("a.out")
core = os.path.join(os.getcwd(), "core.dmp") core = os.path.join(os.getcwd(), "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)
Show All 17 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/pre_run_dylibs/TestPreRunDylibs.py

Show All 14 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
@skipIf(oslist=no_match(['darwin','macos'])) @skipIf(oslist=no_match(['darwin','macos']))
def test(self): def test(self):
"""Test that we find directly linked dylib pre-run.""" """Test that we find directly linked dylib pre-run."""
self.build() self.build()
target = self.dbg.CreateTarget("a.out") target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# I don't know what the name of a shared library # I don't know what the name of a shared library
# extension is in general, so instead of using FindModule, # extension is in general, so instead of using FindModule,
# I'll iterate through the module and do a basename match. # I'll iterate through the module and do a basename match.
found_it = False found_it = False
for module in target.modules: for module in target.modules:
file_name = module.GetFileSpec().GetFilename() file_name = module.GetFileSpec().GetFilename()
if file_name.find("unlikely_name") != -1: if file_name.find("unlikely_name") != -1:
found_it = True found_it = True
break break
self.assertTrue(found_it, "Couldn't find unlikely_to_occur_name in loaded libraries.") self.assertTrue(found_it, "Couldn't find unlikely_to_occur_name in loaded libraries.")

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("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(), 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)
▲ Show 20 Lines • Show All 53 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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("a.out")
core = os.path.join(os.getcwd(), "core.dmp") core = os.path.join(os.getcwd(), "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 = self.getBuildArtifact("a.out")
core = os.path.join(os.getcwd(), "core.dmp") core = os.path.join(os.getcwd(), "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))
Show All 21 Lines

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

Show All 13 Lines
class TestPtrRefs(TestBase): class 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 = self.getBuildArtifact("a.out")
exe = os.path.join(os.getcwd(), 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

lldb/trunk/packages/Python/lldbsuite/test/functionalities/recursion/TestValueObjectRecursion.py

Show All 19 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break at. # Find the line number to break at.
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 that deeply nested ValueObjects still work.""" """Test that deeply nested ValueObjects still work."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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 33 Lines

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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)
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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

lldb/trunk/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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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

lldb/trunk/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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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

lldb/trunk/packages/Python/lldbsuite/test/functionalities/single-quote-in-filename-to-lldb/TestSingleQuoteInFilename.py

Show All 29 Linesclass SingleQuoteInCommandLineTestCase(TestBase):
@expectedFailureAll( @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")
@no_debug_info_test @no_debug_info_test
def test_lldb_invocation_with_single_quote_in_filename(self): def test_lldb_invocation_with_single_quote_in_filename(self):
"""Test that 'lldb my_file_name' works where my_file_name is a string with a single quote char in it.""" """Test that 'lldb my_file_name' works where my_file_name is a string with a single quote char in it."""
import pexpect import pexpect
self.buildDefault() self.buildDefault()
system([["cp", "a.out", "\"%s\"" % self.myexe]]) system([["cp",
self.getBuildArtifact("a.out"),
"\"%s\"" % self.getBuildArtifact(self.myexe)]])
# The default lldb prompt. # The default lldb prompt.
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, self.myexe)) (lldbtest_config.lldbExec, self.lldbOption,
self.getBuildArtifact(self.myexe)))
child = self.child child = self.child
child.setecho(True) child.setecho(True)
# Turn on logging for input/output to/from the child. # Turn on logging for input/output to/from the child.
with open('child_send.txt', 'w') as f_send: with open('child_send.txt', 'w') as f_send:
with open('child_read.txt', 'w') as f_read: with open('child_read.txt', 'w') as f_read:
child.logfile_send = f_send child.logfile_send = f_send
child.logfile_read = f_read child.logfile_read = f_read
Show All 23 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/step-avoids-no-debug/TestStepNoDebug.py

Show First 20 Lines • Show All 86 Lines • ▼ Show 20 Linesclass ReturnValueTestCase(TestBase):
def hit_correct_function(self, pattern): def hit_correct_function(self, pattern):
name = self.thread.frames[0].GetFunctionName() name = self.thread.frames[0].GetFunctionName()
self.assertTrue( self.assertTrue(
pattern in name, "Got to '%s' not the expected function '%s'." % pattern in name, "Got to '%s' not the expected function '%s'." %
(name, pattern)) (name, pattern))
def get_to_starting_point(self): def get_to_starting_point(self):
exe = os.path.join(os.getcwd(), "a.out") exe = self.getBuildArtifact("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_bkpt = self.target.BreakpointCreateBySourceRegex( inner_bkpt = self.target.BreakpointCreateBySourceRegex(
"Stop here and step out of me", self.main_source_spec) "Stop here and step out of me", self.main_source_spec)
self.assertTrue(inner_bkpt, VALID_BREAKPOINT) self.assertTrue(inner_bkpt, VALID_BREAKPOINT)
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

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

Show All 19 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.line_b = line_number('b.c', '// Set break point at this line.') self.line_b = line_number('b.c', '// Set break point at this line.')
self.line_c = line_number('c.c', '// Set break point at this line.') self.line_c = line_number('c.c', '// Set break point at this line.')
def test_target_command(self): def test_target_command(self):
"""Test some target commands: create, list, select.""" """Test some target commands: create, list, select."""
da = {'C_SOURCES': 'a.c', 'EXE': 'a.out'} da = {'C_SOURCES': 'a.c', 'EXE': self.getBuildArtifact('a.out')}
self.build(dictionary=da) self.build(dictionary=da)
self.addTearDownCleanup(dictionary=da) self.addTearDownCleanup(dictionary=da)
db = {'C_SOURCES': 'b.c', 'EXE': 'b.out'} db = {'C_SOURCES': 'b.c', 'EXE': self.getBuildArtifact('b.out')}
self.build(dictionary=db) self.build(dictionary=db)
self.addTearDownCleanup(dictionary=db) self.addTearDownCleanup(dictionary=db)
dc = {'C_SOURCES': 'c.c', 'EXE': 'c.out'} dc = {'C_SOURCES': 'c.c', 'EXE': self.getBuildArtifact('c.out')}
self.build(dictionary=dc) self.build(dictionary=dc)
self.addTearDownCleanup(dictionary=dc) self.addTearDownCleanup(dictionary=dc)
self.do_target_command() self.do_target_command()
# rdar://problem/9763907 # rdar://problem/9763907
# 'target variable' command fails if the target program has been run # 'target variable' command fails if the target program has been run
@expectedFailureAndroid(archs=['aarch64']) @expectedFailureAndroid(archs=['aarch64'])
def test_target_variable_command(self): def test_target_variable_command(self):
"""Test 'target variable' command before and after starting the inferior.""" """Test 'target variable' command before and after starting the inferior."""
d = {'C_SOURCES': 'globals.c', 'EXE': 'globals'} d = {'C_SOURCES': 'globals.c', 'EXE': self.getBuildArtifact('globals')}
self.build(dictionary=d) self.build(dictionary=d)
self.addTearDownCleanup(dictionary=d) self.addTearDownCleanup(dictionary=d)
self.do_target_variable_command('globals') self.do_target_variable_command('globals')
@expectedFailureAndroid(archs=['aarch64']) @expectedFailureAndroid(archs=['aarch64'])
def test_target_variable_command_no_fail(self): def test_target_variable_command_no_fail(self):
"""Test 'target variable' command before and after starting the inferior.""" """Test 'target variable' command before and after starting the inferior."""
d = {'C_SOURCES': 'globals.c', 'EXE': 'globals'} d = {'C_SOURCES': 'globals.c', 'EXE': self.getBuildArtifact('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 = self.getBuildArtifact("a.out")
exe_b = os.path.join(os.getcwd(), "b.out") exe_b = os.path.join(os.getcwd(), "b.out")
exe_c = os.path.join(os.getcwd(), "c.out") exe_c = os.path.join(os.getcwd(), "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
▲ Show 20 Lines • Show All 203 Lines • Show Last 20 Lines

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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)

lldb/trunk/packages/Python/lldbsuite/test/functionalities/type_completion/TestTypeCompletion.py

Show All 19 Linesclass TypeCompletionTestCase(TestBase):
@expectedFailureAll( @expectedFailureAll(
compiler="icc", compiler="icc",
bugnumber="often fails with 'NameAndAddress should be valid.") bugnumber="often fails with 'NameAndAddress should be valid.")
# Fails with gcc 4.8.1 with llvm.org/pr15301 LLDB prints incorrect sizes # Fails with gcc 4.8.1 with llvm.org/pr15301 LLDB prints incorrect sizes
# of STL containers # of STL containers
def test_with_run_command(self): def test_with_run_command(self):
"""Check that types only get completed when necessary.""" """Check that types only get completed when necessary."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_source_regexp( lldbutil.run_break_set_by_source_regexp(
self, "// Set break point at this line.") self, "// Set break point at this line.")
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 20 Lines • Show All 122 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/type_lookup/TestTypeLookup.py

Show All 23 Lines def setUp(self):
# Find the line number to break at. # Find the line number to break at.
self.line = line_number('main.mm', '// break here') self.line = line_number('main.mm', '// break here')
@skipUnlessDarwin @skipUnlessDarwin
@skipIf(archs=['i386']) @skipIf(archs=['i386'])
def test_type_lookup(self): def test_type_lookup(self):
"""Test type lookup command.""" """Test type lookup command."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.mm", self.line, num_expected_locations=1, loc_exact=True) self, "main.mm", 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 15 Lines

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/packages/Python/lldbsuite/test/functionalities/value_md5_crash/TestValueMD5Crash.py

Show All 21 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break at. # Find the line number to break at.
self.line = line_number('main.cpp', '// break here') self.line = line_number('main.cpp', '// break here')
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24663") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24663")
def test_with_run_command(self): def test_with_run_command(self):
"""Verify that the hash computing logic for ValueObject's values can't crash us.""" """Verify that the hash computing logic for ValueObject's values can't crash us."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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 17 Lines

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

Show All 22 Lines def setUp(self):
# Our simple source filename. # Our simple source filename.
self.source = 'main.c' self.source = 'main.c'
# Find the line number to break inside main(). # Find the line number to break inside main().
self.line = line_number( self.line = line_number(
self.source, '// Set break point at this line.') self.source, '// Set break point at this line.')
# And the watchpoint variable declaration line number. # And the watchpoint variable declaration line number.
self.decl = line_number(self.source, self.decl = line_number(self.source,
'// Watchpoint variable declaration.') '// Watchpoint variable declaration.')
self.exe_name = 'a.out' self.exe_name = self.getBuildArtifact('a.out')
self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name} self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
@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")
@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."""
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

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

Show All 21 Linesclass WatchpointSlotsTestCase(TestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Source filename. # Source filename.
self.source = 'main.c' self.source = 'main.c'
# Output filename. # Output filename.
self.exe_name = 'a.out' self.exe_name = self.getBuildArtifact("a.out")
self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name} self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
# 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)
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/packages/Python/lldbsuite/test/functionalities/watchpoint/multiple_threads/TestWatchpointMultipleThreads.py

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines def setUp(self):
# Our simple source filename. # Our simple source filename.
self.source = 'main.cpp' self.source = 'main.cpp'
# Find the line number to break inside main(). # Find the line number to break inside main().
self.first_stop = line_number( self.first_stop = line_number(
self.source, '// Set break point at this line') self.source, '// Set break point at this line')
def hello_multiple_threads(self): def hello_multiple_threads(self):
"""Test that lldb watchpoint works for multiple threads.""" """Test that lldb watchpoint works for multiple threads."""
self.runCmd( self.runCmd("file " + self.getBuildArtifact("a.out"),
"file %s" %
os.path.join(
os.getcwd(),
'a.out'),
CURRENT_EXECUTABLE_SET) 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.first_stop, num_expected_locations=1) self, None, self.first_stop, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 30 Lines def hello_multiple_threads(self):
# Use the '-v' option to do verbose listing of the watchpoint. # Use the '-v' option to do verbose listing of the watchpoint.
# The hit count should now be 1. # The hit count should now be 1.
self.expect("watchpoint list -v", self.expect("watchpoint list -v",
substrs=['hit_count = 1']) substrs=['hit_count = 1'])
def hello_multiple_threads_wp_set_and_then_delete(self): def hello_multiple_threads_wp_set_and_then_delete(self):
"""Test that lldb watchpoint works for multiple threads, and after the watchpoint is deleted, the watchpoint event should no longer fires.""" """Test that lldb watchpoint works for multiple threads, and after the watchpoint is deleted, the watchpoint event should no longer fires."""
self.runCmd( self.runCmd("file " + self.getBuildArtifact("a.out"),
"file %s" %
os.path.join(
os.getcwd(),
'a.out'),
CURRENT_EXECUTABLE_SET) 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.first_stop, num_expected_locations=1) self, None, self.first_stop, 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

lldb/trunk/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 = self.getBuildArtifact("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

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

Show All 29 Linesclass TestWatchpointSetEnable(TestBase):
def test_disable_enable_works (self): def test_disable_enable_works (self):
"""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."""
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 = self.getBuildArtifact("a.out")
exe = os.path.join(os.getcwd(), 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

lldb/trunk/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 = self.getBuildArtifact("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

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

Show All 25 Lines def test_value_of_vector_variable_using_watchpoint_set(self):
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
self.value_of_vector_variable_with_watchpoint_set() self.value_of_vector_variable_with_watchpoint_set()
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
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 = self.getBuildArtifact("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 = self.getBuildArtifact("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)'])

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

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

Show All 22 Linesclass WatchpointSizeTestCase(TestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Source filename. # Source filename.
self.source = 'main.c' self.source = 'main.c'
# Output filename. # Output filename.
self.exe_name = 'a.out' self.exe_name = self.getBuildArtifact("a.out")
self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name} self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
@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_byte_size_watchpoints_with_byte_selection(self): def test_byte_size_watchpoints_with_byte_selection(self):
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

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

Show All 12 Lines
class TestConflictingSymbols(TestBase): class TestConflictingSymbols(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
def test_conflicting_symbols(self): def test_conflicting_symbols(self):
self.build() self.build()
exe = os.path.join(os.getcwd(), "a.out") exe = self.getBuildArtifact("a.out")
target = self.dbg.CreateTarget("a.out") target = self.dbg.CreateTarget(exe)
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'])
lldbutil.run_break_set_by_source_regexp(self, '// break here', lldbutil.run_break_set_by_source_regexp(self, '// break here',
▲ Show 20 Lines • Show All 53 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 = self.getBuildArtifact("a.out")
target = self.dbg.CreateTarget("a.out") target = self.dbg.CreateTarget(exe)
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'])
lldbutil.run_break_set_by_source_regexp(self, '// break here', lldbutil.run_break_set_by_source_regexp(self, '// break here',
Show All 16 Lines

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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'])

lldb/trunk/packages/Python/lldbsuite/test/lang/c/global_variables/TestGlobalVariables.py

Show All 21 Lines def setUp(self):
self.shlib_names = ["a"] self.shlib_names = ["a"]
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24764") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24764")
def test_c_global_variables(self): def test_c_global_variables(self):
"""Test 'frame variable --scope --no-args' which omits args and shows scopes.""" """Test 'frame variable --scope --no-args' which omits args and shows scopes."""
self.build() self.build()
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget("a.out") target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# 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.source, self.line, num_expected_locations=1, loc_exact=True) self, self.source, self.line, num_expected_locations=1, loc_exact=True)
# Register our shared libraries for remote targets so they get # Register our shared libraries for remote targets so they get
# automatically uploaded # automatically uploaded
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/packages/Python/lldbsuite/test/lang/c/shared_lib/TestSharedLib.py

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Lines def setUp(self):
self.line = line_number(self.source, '// Set breakpoint 0 here.') self.line = line_number(self.source, '// Set breakpoint 0 here.')
self.shlib_names = ["foo"] self.shlib_names = ["foo"]
def common_setup(self, preload_symbols = True): def common_setup(self, preload_symbols = True):
# Run in synchronous mode # Run in synchronous mode
self.dbg.SetAsync(False) self.dbg.SetAsync(False)
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget("a.out") target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
self.runCmd("settings set target.preload-symbols " + str(preload_symbols).lower()) self.runCmd("settings set target.preload-symbols " + str(preload_symbols).lower())
# 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, self.source, self.line, num_expected_locations=1, loc_exact=True) self, self.source, self.line, num_expected_locations=1, loc_exact=True)
Show All 18 Lines

lldb/trunk/packages/Python/lldbsuite/test/lang/c/shared_lib_stripped_symbols/TestSharedLibStrippedSymbols.py

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines def setUp(self):
self.line = line_number(self.source, '// Set breakpoint 0 here.') self.line = line_number(self.source, '// Set breakpoint 0 here.')
self.shlib_names = ["foo"] self.shlib_names = ["foo"]
def common_setup(self): def common_setup(self):
# Run in synchronous mode # Run in synchronous mode
self.dbg.SetAsync(False) self.dbg.SetAsync(False)
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget("a.out") target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# 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, self.source, self.line, num_expected_locations=1, loc_exact=True) self, self.source, self.line, num_expected_locations=1, loc_exact=True)
# Register our shared libraries for remote targets so they get # Register our shared libraries for remote targets so they get
# automatically uploaded # automatically uploaded
Show All 16 Lines

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/packages/Python/lldbsuite/test/lang/c/strings/TestCStrings.py

Show All 9 Lines
class CStringsTestCase(TestBase): class CStringsTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
def test_with_run_command(self): def test_with_run_command(self):
"""Tests that C strings work as expected in expressions""" """Tests that C strings work as expected in expressions"""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
line = line_number('main.c', '// breakpoint 1') line = line_number('main.c', '// breakpoint 1')
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)
self.runCmd("process launch", RUN_SUCCEEDED) self.runCmd("process launch", RUN_SUCCEEDED)
self.expect("expression -- a[2]", self.expect("expression -- a[2]",
Show All 31 Lines

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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)

lldb/trunk/packages/Python/lldbsuite/test/lang/cpp/auto/TestCPPAuto.py

Show All 12 Linesclass CPPAutoTestCase(TestBase):
@expectedFailureAll( @expectedFailureAll(
compiler="gcc", compiler="gcc",
bugnumber="GCC generates incomplete debug info") bugnumber="GCC generates incomplete debug info")
@expectedFailureAll(oslist=['windows'], bugnumber="llvm.org/pr26339") @expectedFailureAll(oslist=['windows'], bugnumber="llvm.org/pr26339")
def test_with_run_command(self): def test_with_run_command(self):
"""Test that auto types work in the expression parser""" """Test that auto types work in the expression parser"""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
line = line_number('main.cpp', '// break here') line = line_number('main.cpp', '// break here')
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", line, num_expected_locations=-1, loc_exact=False) self, "main.cpp", line, num_expected_locations=-1, loc_exact=False)
self.runCmd("process launch", RUN_SUCCEEDED) self.runCmd("process launch", RUN_SUCCEEDED)
self.expect('expr auto f = 123456; f', substrs=['int', '123456']) self.expect('expr auto f = 123456; f', substrs=['int', '123456'])
Show All 11 Lines

lldb/trunk/packages/Python/lldbsuite/test/lang/cpp/bool/TestCPPBool.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 CPPBoolTestCase(TestBase): class CPPBoolTestCase(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 bool types work in the expression parser""" """Test that bool types work in the expression parser"""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
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=False) self, "main.cpp", line, num_expected_locations=-1, loc_exact=False)
self.runCmd("process launch", RUN_SUCCEEDED) self.runCmd("process launch", RUN_SUCCEEDED)
self.expect("expression -- bool second_bool = my_bool; second_bool", self.expect("expression -- bool second_bool = my_bool; second_bool",
startstr="(bool) $0 = false") startstr="(bool) $0 = false")
self.expect("expression -- my_bool = true", self.expect("expression -- my_bool = true",
startstr="(bool) $1 = true") startstr="(bool) $1 = true")

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/packages/Python/lldbsuite/test/lang/cpp/call-function/TestCallCPPFunction.py

Show All 16 Lines def setUp(self):
self.line = line_number('main.cpp', '// breakpoint') self.line = line_number('main.cpp', '// breakpoint')
@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_with_run_command(self): def test_with_run_command(self):
"""Test calling a function by basename""" """Test calling a function by basename"""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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("process launch", RUN_SUCCEEDED) self.runCmd("process launch", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", self.expect("thread list",
STOPPED_DUE_TO_BREAKPOINT, STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', 'stop reason = breakpoint']) substrs=['stopped', 'stop reason = breakpoint'])
self.expect("expression -- a_function_to_call()", self.expect("expression -- a_function_to_call()",
startstr="(int) $0 = 0") startstr="(int) $0 = 0")

lldb/trunk/packages/Python/lldbsuite/test/lang/cpp/chained-calls/TestCppChainedCalls.py

Show All 13 Lines def test_with_run_command(self):
# Get main source file # Get main source file
src_file = "main.cpp" src_file = "main.cpp"
src_file_spec = lldb.SBFileSpec(src_file) src_file_spec = lldb.SBFileSpec(src_file)
self.assertTrue(src_file_spec.IsValid(), "Main source file") self.assertTrue(src_file_spec.IsValid(), "Main source file")
# Get the path of the executable # Get the path of the executable
cwd = os.getcwd() cwd = os.getcwd()
exe_file = "a.out" exe_file = self.getBuildArtifact("a.out")
exe_path = os.path.join(cwd, exe_file) exe_path = os.path.join(cwd, exe_file)
# Load the executable # Load the executable
target = self.dbg.CreateTarget(exe_path) target = self.dbg.CreateTarget(exe_path)
self.assertTrue(target.IsValid(), VALID_TARGET) self.assertTrue(target.IsValid(), VALID_TARGET)
# Break on main function # Break on main function
main_breakpoint = target.BreakpointCreateBySourceRegex( main_breakpoint = target.BreakpointCreateBySourceRegex(
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

lldb/trunk/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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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

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

Show All 21 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break at. # Find the line number to break at.
self.line = line_number('main.cpp', '// Set break point at this line.') self.line = line_number('main.cpp', '// Set break point at this line.')
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24764") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24764")
def test_with_run_command(self): def test_with_run_command(self):
"""Test that file and class static variables display correctly.""" """Test that file and class static variables display correctly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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 23 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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("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())
fsFile = filespec.GetFilename() fsFile = filespec.GetFilename()
self.assertTrue(fsDir == os.getcwd() and fsFile == "a.out", self.assertTrue(fsDir == os.path.dirname(self.getBuildArtifact())
and fsFile == "a.out",
"FileSpec matches the executable") "FileSpec matches the executable")
bpfilespec = lldb.SBFileSpec("main.cpp", False) bpfilespec = lldb.SBFileSpec("main.cpp", False)
breakpoint = target.BreakpointCreateByLocation(bpfilespec, self.line) breakpoint = target.BreakpointCreateByLocation(bpfilespec, self.line)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
# Verify the breakpoint just created. # Verify the breakpoint just created.
Show All 30 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 = self.getBuildArtifact("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 = self.getBuildArtifact("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())
fsFile = filespec.GetFilename() fsFile = filespec.GetFilename()
self.assertTrue(fsDir == os.getcwd() and fsFile == "a.out", self.assertTrue(fsDir == os.path.dirname(self.getBuildArtifact())
and fsFile == "a.out",
"FileSpec matches the executable") "FileSpec matches the executable")
bpfilespec = lldb.SBFileSpec("main.cpp", False) bpfilespec = lldb.SBFileSpec("main.cpp", False)
breakpoint = target.BreakpointCreateByLocation(bpfilespec, self.line) breakpoint = target.BreakpointCreateByLocation(bpfilespec, self.line)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
# Verify the breakpoint just created. # Verify the breakpoint just created.
Show All 26 Lines

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/packages/Python/lldbsuite/test/lang/cpp/frame-var-anon-unions/TestFrameVariableAnonymousUnions.py

""" """
Tests that frame variable looks into anonymous unions Tests that frame variable looks into anonymous unions
""" """
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 FrameVariableAnonymousUnionsTestCase(TestBase): class FrameVariableAnonymousUnionsTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def test_with_run_command(self): def test_with_run_command(self):
"""Tests that frame variable looks into anonymous unions""" """Tests that frame variable looks into anonymous unions"""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
line = line_number('main.cpp', '// break here') line = line_number('main.cpp', '// break here')
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", line, num_expected_locations=-1, loc_exact=False) self, "main.cpp", line, num_expected_locations=-1, loc_exact=False)
self.runCmd("process launch", RUN_SUCCEEDED) self.runCmd("process launch", RUN_SUCCEEDED)
process = self.dbg.GetSelectedTarget().GetProcess() process = self.dbg.GetSelectedTarget().GetProcess()
Show All 11 Lines

lldb/trunk/packages/Python/lldbsuite/test/lang/cpp/global_operators/TestCppGlobalOperators.py

Show All 15 Lines def prepare_executable_and_get_frame(self):
# Get main source file # Get main source file
src_file = "main.cpp" src_file = "main.cpp"
src_file_spec = lldb.SBFileSpec(src_file) src_file_spec = lldb.SBFileSpec(src_file)
self.assertTrue(src_file_spec.IsValid(), "Main source file") self.assertTrue(src_file_spec.IsValid(), "Main source file")
# Get the path of the executable # Get the path of the executable
cwd = os.getcwd() cwd = os.getcwd()
exe_file = "a.out" exe_path = self.getBuildArtifact("a.out")
exe_path = os.path.join(cwd, exe_file)
# Load the executable # Load the executable
target = self.dbg.CreateTarget(exe_path) target = self.dbg.CreateTarget(exe_path)
self.assertTrue(target.IsValid(), VALID_TARGET) self.assertTrue(target.IsValid(), VALID_TARGET)
# Break on main function # Break on main function
main_breakpoint = target.BreakpointCreateBySourceRegex( main_breakpoint = target.BreakpointCreateBySourceRegex(
"// break here", src_file_spec) "// break here", src_file_spec)
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/lang/cpp/gmodules/TestWithModuleDebugging.py

Show All 13 Lines def test_specialized_typedef_from_pch(self):
self.build() self.build()
cwd = os.getcwd() cwd = os.getcwd()
src_file = os.path.join(cwd, "main.cpp") src_file = os.path.join(cwd, "main.cpp")
src_file_spec = lldb.SBFileSpec(src_file) src_file_spec = lldb.SBFileSpec(src_file)
self.assertTrue(src_file_spec.IsValid(), "breakpoint file") self.assertTrue(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 = self.getBuildArtifact("a.out")
# Load the executable # Load the executable
target = self.dbg.CreateTarget(exe_path) target = self.dbg.CreateTarget(exe_path)
self.assertTrue(target.IsValid(), VALID_TARGET) self.assertTrue(target.IsValid(), VALID_TARGET)
# Break on interesting line # Break on interesting line
breakpoint = target.BreakpointCreateBySourceRegex( breakpoint = target.BreakpointCreateBySourceRegex(
"break here", src_file_spec) "break here", src_file_spec)
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/TestWithLimitDebugInfo.py

Show All 13 Lines def test_limit_debug_info(self):
cwd = os.getcwd() cwd = os.getcwd()
src_file = os.path.join(cwd, "main.cpp") src_file = os.path.join(cwd, "main.cpp")
src_file_spec = lldb.SBFileSpec(src_file) src_file_spec = lldb.SBFileSpec(src_file)
self.assertTrue(src_file_spec.IsValid(), "breakpoint file") self.assertTrue(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 = self.getBuildArtifact("a.out")
# Load the executable # Load the executable
target = self.dbg.CreateTarget(exe_path) target = self.dbg.CreateTarget(exe_path)
self.assertTrue(target.IsValid(), VALID_TARGET) self.assertTrue(target.IsValid(), VALID_TARGET)
# Break on main function # Break on main function
breakpoint = target.BreakpointCreateBySourceRegex( breakpoint = target.BreakpointCreateBySourceRegex(
"break here", src_file_spec) "break here", src_file_spec)
Show All 35 Lines

lldb/trunk/packages/Python/lldbsuite/test/lang/cpp/member-and-local-vars-with-same-name/TestMembersAndLocalsWithSameName.py

Show First 20 Lines • Show All 215 Lines • ▼ Show 20 Lines def _load_exe(self):
cwd = os.getcwd() cwd = os.getcwd()
src_file = os.path.join(cwd, "main.cpp") src_file = os.path.join(cwd, "main.cpp")
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 = self.getBuildArtifact("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)
def _test_globals(self): def _test_globals(self):
thread = lldbutil.get_stopped_thread( thread = lldbutil.get_stopped_thread(
self.process, lldb.eStopReasonBreakpoint) self.process, lldb.eStopReasonBreakpoint)
Show All 15 Lines

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 All 34 Lines def runToBkpt(self, command):
substrs=['stopped', substrs=['stopped',
'stop reason = breakpoint']) 'stop reason = breakpoint'])
# rdar://problem/8668674 # rdar://problem/8668674
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24764") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24764")
def test_with_run_command(self): def test_with_run_command(self):
"""Test that anonymous and named namespace variables display correctly.""" """Test that anonymous and named namespace variables display correctly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, self,
"main.cpp", "main.cpp",
self.line_break_ns1, self.line_break_ns1,
num_expected_locations=1, num_expected_locations=1,
loc_exact=True) loc_exact=True)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/lang/cpp/namespace/TestNamespaceLookup.py

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines @expectedFailureAll(
oslist=[ oslist=[
"windows", "windows",
"linux", "linux",
"freebsd"], "freebsd"],
bugnumber="llvm.org/pr25819") bugnumber="llvm.org/pr25819")
def test_scope_lookup_with_run_command(self): def test_scope_lookup_with_run_command(self):
"""Test scope lookup of functions in lldb.""" """Test scope lookup of functions in lldb."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, self,
"ns.cpp", "ns.cpp",
self.line_break_global_scope, self.line_break_global_scope,
num_expected_locations=1, num_expected_locations=1,
loc_exact=False) loc_exact=False)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
▲ Show 20 Lines • Show All 84 Lines • ▼ Show 20 Lines def test_scope_lookup_with_run_command(self):
self.expect("expr -- ::func()", startstr="(int) $14 = 1") self.expect("expr -- ::func()", startstr="(int) $14 = 1")
# Evaluate B::func() - should call B::func() # Evaluate B::func() - should call B::func()
self.expect("expr -- B::func()", startstr="(int) $15 = 4") self.expect("expr -- B::func()", startstr="(int) $15 = 4")
@unittest2.expectedFailure("lldb scope lookup of functions bugs") @unittest2.expectedFailure("lldb scope lookup of functions bugs")
def test_function_scope_lookup_with_run_command(self): def test_function_scope_lookup_with_run_command(self):
"""Test scope lookup of functions in lldb.""" """Test scope lookup of functions in lldb."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, self,
"ns.cpp", "ns.cpp",
self.line_break_global_scope, self.line_break_global_scope,
num_expected_locations=1, num_expected_locations=1,
loc_exact=False) loc_exact=False)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
Show All 20 Lines def test_function_scope_lookup_with_run_command(self):
# FIXME: lldb finds Y::foo because lookup for variables is done # FIXME: lldb finds Y::foo because lookup for variables is done
# before functions. # before functions.
self.expect("expr -- foo()", startstr="(int) $2 = 42") self.expect("expr -- foo()", startstr="(int) $2 = 42")
@unittest2.expectedFailure("lldb file scope lookup bugs") @unittest2.expectedFailure("lldb file scope lookup bugs")
def test_file_scope_lookup_with_run_command(self): def test_file_scope_lookup_with_run_command(self):
"""Test file scope lookup in lldb.""" """Test file scope lookup in lldb."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, self,
"ns2.cpp", "ns2.cpp",
self.line_break_file_scope, self.line_break_file_scope,
num_expected_locations=1, num_expected_locations=1,
loc_exact=False) loc_exact=False)
# Run to BP_file_scope at file scope # Run to BP_file_scope at file scope
self.runToBkpt("run") self.runToBkpt("run")
# Evaluate func() - should call static ns2.cpp:func() # Evaluate func() - should call static ns2.cpp:func()
# FIXME: This test fails because lldb doesn't know about file scopes so # FIXME: This test fails because lldb doesn't know about file scopes so
# finds the global ::func(). # finds the global ::func().
self.expect("expr -- func()", startstr="(int) $0 = 2") self.expect("expr -- func()", startstr="(int) $0 = 2")
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr25819") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr25819")
def test_scope_lookup_before_using_with_run_command(self): def test_scope_lookup_before_using_with_run_command(self):
"""Test scope lookup before using in lldb.""" """Test scope lookup before using in lldb."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, self,
"ns3.cpp", "ns3.cpp",
self.line_break_before_using_directive, self.line_break_before_using_directive,
num_expected_locations=1, num_expected_locations=1,
loc_exact=False) loc_exact=False)
Show All 13 Lines @expectedFailureAll(
oslist=[ oslist=[
"windows", "windows",
"linux", "linux",
"freebsd"], "freebsd"],
bugnumber="llvm.org/pr25819") bugnumber="llvm.org/pr25819")
def test_scope_after_using_directive_lookup_with_run_command(self): def test_scope_after_using_directive_lookup_with_run_command(self):
"""Test scope lookup after using directive in lldb.""" """Test scope lookup after using directive in lldb."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, self,
"ns3.cpp", "ns3.cpp",
self.line_break_after_using_directive, self.line_break_after_using_directive,
num_expected_locations=1, num_expected_locations=1,
loc_exact=False) loc_exact=False)
# Run to BP_after_using_directive at global scope after using # Run to BP_after_using_directive at global scope after using
# declaration # declaration
self.runToBkpt("run") self.runToBkpt("run")
# Evaluate func2() - should call A::func2() # Evaluate func2() - should call A::func2()
self.expect("expr -- func2()", startstr="(int) $0 = 3") self.expect("expr -- func2()", startstr="(int) $0 = 3")
@unittest2.expectedFailure( @unittest2.expectedFailure(
"lldb scope lookup after using declaration bugs") "lldb scope lookup after using declaration bugs")
# NOTE: this test may fail on older systems that don't emit import # NOTE: this test may fail on older systems that don't emit import
# emtries in DWARF - may need to add checks for compiler versions here. # emtries in DWARF - may need to add checks for compiler versions here.
def test_scope_after_using_declaration_lookup_with_run_command(self): def test_scope_after_using_declaration_lookup_with_run_command(self):
"""Test scope lookup after using declaration in lldb.""" """Test scope lookup after using declaration in lldb."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, self,
"ns2.cpp", "ns2.cpp",
self.line_break_nested_ns_scope_after_using, self.line_break_nested_ns_scope_after_using,
num_expected_locations=1, num_expected_locations=1,
loc_exact=False) loc_exact=False)
# Run to BP_nested_ns_scope_after_using at nested ns scope after using # Run to BP_nested_ns_scope_after_using at nested ns scope after using
# declaration # declaration
self.runToBkpt("run") self.runToBkpt("run")
# Evaluate func() - should call A::func() # Evaluate func() - should call A::func()
self.expect("expr -- func()", startstr="(int) $0 = 3") self.expect("expr -- func()", startstr="(int) $0 = 3")
@unittest2.expectedFailure("lldb scope lookup ambiguity after using bugs") @unittest2.expectedFailure("lldb scope lookup ambiguity after using bugs")
def test_scope_ambiguity_after_using_lookup_with_run_command(self): def test_scope_ambiguity_after_using_lookup_with_run_command(self):
"""Test scope lookup ambiguity after using in lldb.""" """Test scope lookup ambiguity after using in lldb."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, self,
"ns3.cpp", "ns3.cpp",
self.line_break_after_using_directive, self.line_break_after_using_directive,
num_expected_locations=1, num_expected_locations=1,
loc_exact=False) loc_exact=False)
Show All 9 Lines @expectedFailureAll(
oslist=[ oslist=[
"windows", "windows",
"linux", "linux",
"freebsd"], "freebsd"],
bugnumber="llvm.org/pr25819") bugnumber="llvm.org/pr25819")
def test_scope_lookup_shadowed_by_using_with_run_command(self): def test_scope_lookup_shadowed_by_using_with_run_command(self):
"""Test scope lookup shadowed by using in lldb.""" """Test scope lookup shadowed by using in lldb."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, self,
"ns2.cpp", "ns2.cpp",
self.line_break_nested_ns_scope, self.line_break_nested_ns_scope,
num_expected_locations=1, num_expected_locations=1,
loc_exact=False) loc_exact=False)
# Run to BP_nested_ns_scope at nested ns scope # Run to BP_nested_ns_scope at nested ns scope
self.runToBkpt("run") self.runToBkpt("run")
# Evaluate func(10) - should call A::func(10) # Evaluate func(10) - should call A::func(10)
# NOTE: Under the rules of C++, this test would normally get an error # NOTE: Under the rules of C++, this test would normally get an error
# because A::B::func() shadows A::func(), but lldb intentionally # because A::B::func() shadows A::func(), but lldb intentionally
# disobeys these rules so that the intended overload can be found # disobeys these rules so that the intended overload can be found
# by only removing duplicates if they have the same type. # by only removing duplicates if they have the same type.
self.expect("expr -- func(10)", startstr="(int) $0 = 13") self.expect("expr -- func(10)", startstr="(int) $0 = 13")

lldb/trunk/packages/Python/lldbsuite/test/lang/cpp/namespace_definitions/TestNamespaceDefinitions.py

Show All 40 Lines def setUp(self):
self.line = line_number(self.source, '// Set breakpoint here') self.line = line_number(self.source, '// Set breakpoint here')
self.shlib_names = ["a", "b"] self.shlib_names = ["a", "b"]
def common_setup(self): def common_setup(self):
# Run in synchronous mode # Run in synchronous mode
self.dbg.SetAsync(False) self.dbg.SetAsync(False)
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget("a.out") target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# 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, self.source, self.line, num_expected_locations=1, loc_exact=True) self, self.source, self.line, num_expected_locations=1, loc_exact=True)
# Register our shared libraries for remote targets so they get # Register our shared libraries for remote targets so they get
# automatically uploaded # automatically uploaded
Show All 16 Lines

lldb/trunk/packages/Python/lldbsuite/test/lang/cpp/nsimport/TestCppNsImport.py

Show All 16 Lines def test_with_run_command(self):
# Get main source file # Get main source file
src_file = "main.cpp" src_file = "main.cpp"
src_file_spec = lldb.SBFileSpec(src_file) src_file_spec = lldb.SBFileSpec(src_file)
self.assertTrue(src_file_spec.IsValid(), "Main source file") self.assertTrue(src_file_spec.IsValid(), "Main source file")
# Get the path of the executable # Get the path of the executable
cwd = os.getcwd() cwd = os.getcwd()
exe_file = "a.out" exe_path = self.getBuildArtifact("a.out")
exe_path = os.path.join(cwd, exe_file)
# Load the executable # Load the executable
target = self.dbg.CreateTarget(exe_path) target = self.dbg.CreateTarget(exe_path)
self.assertTrue(target.IsValid(), VALID_TARGET) self.assertTrue(target.IsValid(), VALID_TARGET)
# Break on main function # Break on main function
break_0 = target.BreakpointCreateBySourceRegex( break_0 = target.BreakpointCreateBySourceRegex(
"// break 0", src_file_spec) "// break 0", src_file_spec)
▲ Show 20 Lines • Show All 104 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/lang/cpp/overloaded-functions/TestOverloadedFunctions.py

Show All 16 Lines def setUp(self):
self.line = line_number('main.cpp', '// breakpoint') self.line = line_number('main.cpp', '// breakpoint')
@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_with_run_command(self): def test_with_run_command(self):
"""Test that functions with the same name are resolved correctly""" """Test that functions with the same name are resolved correctly"""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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("process launch", RUN_SUCCEEDED) self.runCmd("process launch", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", self.expect("thread list",
STOPPED_DUE_TO_BREAKPOINT, STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', 'stop reason = breakpoint']) substrs=['stopped', 'stop reason = breakpoint'])
self.expect("expression -- Dump(myB)", self.expect("expression -- Dump(myB)",
startstr="(int) $0 = 2") startstr="(int) $0 = 2")
self.expect("expression -- Static()", self.expect("expression -- Static()",
startstr="(int) $1 = 1") startstr="(int) $1 = 1")

lldb/trunk/packages/Python/lldbsuite/test/lang/cpp/rvalue-references/TestRvalueReferences.py

Show All 16 Lines @expectedFailureAll(
compiler="icc", compiler="icc",
bugnumber="ICC (13.1, 14-beta) do not emit DW_TAG_rvalue_reference_type.") bugnumber="ICC (13.1, 14-beta) do not emit DW_TAG_rvalue_reference_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")
def test_with_run_command(self): def test_with_run_command(self):
"""Test that rvalues are supported in the C++ expression parser""" """Test that rvalues are supported in the C++ expression parser"""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
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'))
self.runCmd("process launch", RUN_SUCCEEDED) self.runCmd("process launch", RUN_SUCCEEDED)
# Note that clang as of r187480 doesn't emit DW_TAG_const_type, unlike gcc 4.8.1 # Note that clang as of r187480 doesn't emit DW_TAG_const_type, unlike gcc 4.8.1
# With gcc 4.8.1, lldb reports the type as (int &&const) # With gcc 4.8.1, lldb reports the type as (int &&const)
Show All 23 Lines

lldb/trunk/packages/Python/lldbsuite/test/lang/cpp/scope/TestCppScope.py

Show All 23 Lines def do_test(self, test_c):
# Get main source file # Get main source file
src_file = "main.cpp" src_file = "main.cpp"
src_file_spec = lldb.SBFileSpec(src_file) src_file_spec = lldb.SBFileSpec(src_file)
self.assertTrue(src_file_spec.IsValid(), "Main source file") self.assertTrue(src_file_spec.IsValid(), "Main source file")
# Get the path of the executable # Get the path of the executable
cwd = os.getcwd() cwd = os.getcwd()
exe_file = "a.out" exe_path = self.getBuildArtifact("a.out")
exe_path = os.path.join(cwd, exe_file)
# Load the executable # Load the executable
target = self.dbg.CreateTarget(exe_path) target = self.dbg.CreateTarget(exe_path)
self.assertTrue(target.IsValid(), VALID_TARGET) self.assertTrue(target.IsValid(), VALID_TARGET)
# Break on main function # Break on main function
main_breakpoint = target.BreakpointCreateBySourceRegex( main_breakpoint = target.BreakpointCreateBySourceRegex(
"// break here", src_file_spec) "// break here", src_file_spec)
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/lang/cpp/signed_types/TestSignedTypes.py

Show All 27 Linesclass SignedTypesTestCase(TestBase):
def test(self): def test(self):
"""Test that variables with signed types display correctly.""" """Test that variables with signed types display correctly."""
self.build() self.build()
# Run in synchronous mode # Run in synchronous mode
self.dbg.SetAsync(False) self.dbg.SetAsync(False)
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget("a.out") target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, self.source, self.line, num_expected_locations=1, loc_exact=True) self, self.source, self.line, num_expected_locations=1, loc_exact=True)
# 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())
Show All 24 Lines

lldb/trunk/packages/Python/lldbsuite/test/lang/cpp/static_members/TestCPPStaticMembers.py

Show All 15 Linesclass CPPStaticMembersTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.expectedFailure # llvm.org/pr15401 @unittest2.expectedFailure # llvm.org/pr15401
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
def test_with_run_command(self): def test_with_run_command(self):
"""Test that member variables have the correct layout, scope and qualifiers when stopped inside and outside C++ methods""" """Test that member variables have the correct layout, scope and qualifiers when stopped inside and outside C++ methods"""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
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'))
self.runCmd("process launch", RUN_SUCCEEDED) self.runCmd("process launch", RUN_SUCCEEDED)
self.expect("expression my_a.access()", self.expect("expression my_a.access()",
startstr="(long) $0 = 10") startstr="(long) $0 = 10")
Show All 30 Lines

lldb/trunk/packages/Python/lldbsuite/test/lang/cpp/static_methods/TestCPPStaticMethods.py

Show All 14 Linesclass CPPStaticMethodsTestCase(TestBase):
def setUp(self): def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
self.line = line_number('main.cpp', '// Break at this line') self.line = line_number('main.cpp', '// Break at this line')
@expectedFailureAll(oslist=["windows"]) @expectedFailureAll(oslist=["windows"])
def test_with_run_command(self): def test_with_run_command(self):
"""Test that static methods are properly distinguished from regular methods""" """Test that static methods are properly distinguished from regular methods"""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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("process launch", RUN_SUCCEEDED) self.runCmd("process launch", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", self.expect("thread list",
STOPPED_DUE_TO_BREAKPOINT, STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', 'stop reason = breakpoint']) substrs=['stopped', 'stop reason = breakpoint'])
self.expect("expression -- A::getStaticValue()", self.expect("expression -- A::getStaticValue()",
startstr="(int) $0 = 5") startstr="(int) $0 = 5")
self.expect("expression -- my_a.getMemberValue()", self.expect("expression -- my_a.getMemberValue()",
startstr="(int) $1 = 3") startstr="(int) $1 = 3")

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/packages/Python/lldbsuite/test/lang/cpp/this/TestCPPThis.py

Show All 18 Lines @expectedFailureAll(
compiler="icc", compiler="icc",
bugnumber="ICC doesn't emit correct DWARF inline debug info for inlined member functions.") bugnumber="ICC doesn't emit correct DWARF inline debug info for inlined member functions.")
@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_with_run_command(self): def test_with_run_command(self):
"""Test that the appropriate member variables are available when stopped in C++ static, inline, and const methods""" """Test that the appropriate member variables are available when stopped in C++ static, inline, and const methods"""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
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'))
self.set_breakpoint(line_number('main.cpp', '// breakpoint 3')) self.set_breakpoint(line_number('main.cpp', '// breakpoint 3'))
self.set_breakpoint(line_number('main.cpp', '// breakpoint 4')) self.set_breakpoint(line_number('main.cpp', '// breakpoint 4'))
self.runCmd("process launch", RUN_SUCCEEDED) self.runCmd("process launch", RUN_SUCCEEDED)
Show All 25 Lines

lldb/trunk/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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/packages/Python/lldbsuite/test/lang/cpp/virtual/TestVirtual.py

Show All 39 Lines def test_virtual_madness(self):
"""Test that expression works correctly with virtual inheritance as well as virtual function.""" """Test that expression works correctly with virtual inheritance as well as virtual function."""
self.build() self.build()
# Bring the program to the point where we can issue a series of # Bring the program to the point where we can issue a series of
# 'expression' command to compare against the golden output. # 'expression' command to compare against the golden output.
self.dbg.SetAsync(False) self.dbg.SetAsync(False)
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget("a.out") target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
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)
# 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(
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

lldb/trunk/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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/packages/Python/lldbsuite/test/lang/go/runtime/TestGoLanguageRuntime

Show All 24 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, '// Set breakpoint 1') self.break_line1 = line_number(self.main_source, '// Set breakpoint 1')
self.break_line2 = line_number(self.main_source, '// Set breakpoint 2') self.break_line2 = line_number(self.main_source, '// Set breakpoint 2')
def launchProcess(self): def launchProcess(self):
exe = os.path.join(os.getcwd(), "a.out") exe = self.getBuildArtifact("a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
bpt1 = target.BreakpointCreateByLocation(self.main_source, self.break_line1) bpt1 = target.BreakpointCreateByLocation(self.main_source, self.break_line1)
self.assertTrue(bpt1, VALID_BREAKPOINT) self.assertTrue(bpt1, VALID_BREAKPOINT)
bpt2 = target.BreakpointCreateByLocation(self.main_source, self.break_line2) bpt2 = target.BreakpointCreateByLocation(self.main_source, self.break_line2)
self.assertTrue(bpt2, VALID_BREAKPOINT) self.assertTrue(bpt2, VALID_BREAKPOINT)
Show All 39 Lines

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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)

lldb/trunk/packages/Python/lldbsuite/test/lang/objc/forward-decl/TestForwardDecl.py

Show All 22 Lines def setUp(self):
self.line = line_number(self.source, '// Set breakpoint 0 here.') self.line = line_number(self.source, '// Set breakpoint 0 here.')
self.shlib_names = ["Container"] self.shlib_names = ["Container"]
@skipUnlessDarwin @skipUnlessDarwin
def test_expr(self): def test_expr(self):
self.build() self.build()
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget("a.out") target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
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)
# Register our shared libraries for remote targets so they get # Register our shared libraries for remote targets so they get
# automatically uploaded # automatically uploaded
Show All 20 Lines

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/packages/Python/lldbsuite/test/lang/objc/foundation/TestFoundationDisassembly.py

Show All 26 Linesclass FoundationDisassembleTestCase(TestBase):
def test_foundation_disasm(self): def test_foundation_disasm(self):
"""Do 'disassemble -n func' on each and every 'Code' symbol entry from the Foundation.framework.""" """Do 'disassemble -n func' on each and every 'Code' symbol entry from the Foundation.framework."""
self.build() self.build()
# Enable synchronous mode # Enable synchronous mode
self.dbg.SetAsync(False) self.dbg.SetAsync(False)
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget("a.out") target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
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)
foundation_framework = None foundation_framework = None
Show All 27 Lines def test_foundation_disasm(self):
#print("func:", func) #print("func:", func)
self.runCmd('disassemble -n "%s"' % func) self.runCmd('disassemble -n "%s"' % func)
def test_simple_disasm(self): def test_simple_disasm(self):
"""Test the lldb 'disassemble' command""" """Test the lldb 'disassemble' command"""
self.build() self.build()
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget("a.out") target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
print(target) print(target)
for module in target.modules: for module in target.modules:
print(module) print(module)
# Stop at +[NSString stringWithFormat:]. # Stop at +[NSString stringWithFormat:].
symbol_name = "+[NSString stringWithFormat:]" symbol_name = "+[NSString stringWithFormat:]"
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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")

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

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

Show First 20 Lines • Show All 83 Lines • ▼ Show 20 Lines def common_setup(self, strip):
if strip: if strip:
self.assertTrue(subprocess.call( self.assertTrue(subprocess.call(
['/usr/bin/strip', '-Sx', 'libInternalDefiner.dylib']) == 0, 'stripping dylib succeeded') ['/usr/bin/strip', '-Sx', 'libInternalDefiner.dylib']) == 0, 'stripping dylib succeeded')
self.assertTrue(subprocess.call(['/bin/rm', self.assertTrue(subprocess.call(['/bin/rm',
'-rf', '-rf',
'libInternalDefiner.dylib.dSYM']) == 0, 'libInternalDefiner.dylib.dSYM']) == 0,
'remove dylib dSYM file succeeded') 'remove dylib dSYM file succeeded')
self.assertTrue(subprocess.call( self.assertTrue(subprocess.call(['/usr/bin/strip', '-Sx',
['/usr/bin/strip', '-Sx', 'a.out']) == 0, 'stripping a.out succeeded') self.getBuildArtifact("a.out")
]) == 0,
'stripping a.out succeeded')
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget("a.out") target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
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)
# 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, 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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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"])

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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 "+self.getBuildArtifact("a.out.dSYM"))
breakpoint = target.BreakpointCreateByLocation( breakpoint = target.BreakpointCreateByLocation(
self.main_source, self.stop_line) self.main_source, self.stop_line)
self.assertTrue( self.assertTrue(
breakpoint.IsValid() and breakpoint.GetNumLocations() > 0, breakpoint.IsValid() and breakpoint.GetNumLocations() > 0,
VALID_BREAKPOINT) VALID_BREAKPOINT)
process = target.LaunchSimple( process = target.LaunchSimple(
Show All 23 Lines

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

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

Show All 13 Lines
class TestPtrRefsObjC(TestBase): class 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 = self.getBuildArtifact("a.out")
exe = os.path.join(os.getcwd(), 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

lldb/trunk/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 = self.getBuildArtifact("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)

lldb/trunk/packages/Python/lldbsuite/test/lang/objc/self/TestObjCSelf.py

Show All 9 Lines
class ObjCSelfTestCase(TestBase): class ObjCSelfTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipUnlessDarwin @skipUnlessDarwin
def test_with_run_command(self): def test_with_run_command(self):
"""Test that the appropriate member variables are available when stopped in Objective-C class and instance methods""" """Test that the appropriate member variables are available when stopped in Objective-C class and instance methods"""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
self.set_breakpoint(line_number('main.m', '// breakpoint 1')) self.set_breakpoint(line_number('main.m', '// breakpoint 1'))
self.set_breakpoint(line_number('main.m', '// breakpoint 2')) self.set_breakpoint(line_number('main.m', '// breakpoint 2'))
self.runCmd("process launch", RUN_SUCCEEDED) self.runCmd("process launch", RUN_SUCCEEDED)
self.expect("expression -- m_a = 2", self.expect("expression -- m_a = 2",
startstr="(int) $0 = 2") startstr="(int) $0 = 2")
Show All 13 Lines

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
self.assertTrue(self.process, PROCESS_IS_VALID) self.assertTrue(self.process, PROCESS_IS_VALID)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.assertTrue(self.process.GetState() == lldb.eStateStopped, self.assertTrue(self.process.GetState() == lldb.eStateStopped,
STOPPED_DUE_TO_BREAKPOINT) STOPPED_DUE_TO_BREAKPOINT)
exe_module = self.target.GetModuleAtIndex(0) exe_module = self.target.GetModuleAtIndex(0)
# Check that symbols are not loaded and main.c is not know to be # Check that symbols are not loaded and main.c is not know to be
# the source file. # the source file.
self.expect("frame select", substrs=['main.c'], matching=False) self.expect("frame select", substrs=['main.c'], matching=False)
# Tell LLDB that a.out has symbols for stripped.out # Tell LLDB that a.out has symbols for stripped.out
self.runCmd("target symbols add -s stripped.out a.out") self.runCmd("target symbols add -s %s %s" %
exe, self.getBuildArtifact("a.out"))
# Check that symbols are now loaded and main.c is in the output. # Check that symbols are now loaded and main.c is in the output.
self.expect("frame select", substrs=['main.c']) self.expect("frame select", substrs=['main.c'])

lldb/trunk/packages/Python/lldbsuite/test/linux/builtin_trap/TestBuiltinTrap.py

Show All 24 Linesclass BuiltinTrapTestCase(TestBase):
# gcc generates incorrect linetable # gcc generates incorrect linetable
@expectedFailureAll(archs="arm", compiler="gcc", triple=".*-android") @expectedFailureAll(archs="arm", compiler="gcc", triple=".*-android")
@expectedFailureAll(oslist=['linux'], archs=['arm']) @expectedFailureAll(oslist=['linux'], archs=['arm'])
@skipIfWindows @skipIfWindows
def test_with_run_command(self): def test_with_run_command(self):
"""Test that LLDB handles a function with __builtin_trap correctly.""" """Test that LLDB handles a function with __builtin_trap correctly."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
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,
num_expected_locations=1, num_expected_locations=1,
loc_exact=True) 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 All 12 Lines

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/packages/Python/lldbsuite/test/lldbinline.py

Show First 20 Lines • Show All 160 Lines • ▼ Show 20 Lines def __test_with_gmodules(self):
self.BuildMakefile() self.BuildMakefile()
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 = self.getBuildArtifact("a.out")
exe = os.path.join(os.getcwd(), 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

lldb/trunk/packages/Python/lldbsuite/test/lldbtest.py

Show First 20 Lines • Show All 1,567 Lines • ▼ Show 20 Lines def buildGModules(
compiler, compiler,
dictionary, dictionary,
clean): clean):
raise Exception("Don't know how to build binary with gmodules") raise Exception("Don't know how to build binary with gmodules")
def buildGo(self): def buildGo(self):
"""Build the default go binary. """Build the default go binary.
""" """
system([[which('go'), 'build -gcflags "-N -l" -o a.out main.go']]) exe = self.getBuildArtifact("a.out")
system([[which('go'), 'build -gcflags "-N -l" -o %s main.go' % exe]])
def signBinary(self, binary_path): def signBinary(self, binary_path):
if sys.platform.startswith("darwin"): if sys.platform.startswith("darwin"):
codesign_cmd = "codesign --force --sign \"%s\" %s" % ( codesign_cmd = "codesign --force --sign \"%s\" %s" % (
lldbtest_config.codesign_identity, binary_path) lldbtest_config.codesign_identity, binary_path)
call(codesign_cmd, shell=True) call(codesign_cmd, shell=True)
def findBuiltClang(self): def findBuiltClang(self):
▲ Show 20 Lines • Show All 678 Lines • ▼ Show 20 Lines def build(
elif self.debug_info == "dwo": elif self.debug_info == "dwo":
return self.buildDwo(architecture, compiler, dictionary, clean) return self.buildDwo(architecture, compiler, dictionary, clean)
elif self.debug_info == "gmodules": elif self.debug_info == "gmodules":
return self.buildGModules( return self.buildGModules(
architecture, compiler, dictionary, clean) architecture, compiler, dictionary, clean)
else: else:
self.fail("Can't build for debug info: %s" % self.debug_info) self.fail("Can't build for debug info: %s" % self.debug_info)
def getBuildArtifact(self, name="a.out"):
"""Return absolute path to an artifact in the test's build directory."""
return os.path.join(os.getcwd(), name)
def run_platform_command(self, cmd): def run_platform_command(self, cmd):
platform = self.dbg.GetSelectedPlatform() platform = self.dbg.GetSelectedPlatform()
shell_command = lldb.SBPlatformShellCommand(cmd) shell_command = lldb.SBPlatformShellCommand(cmd)
err = platform.Run(shell_command) err = platform.Run(shell_command)
return (err, shell_command.GetStatus(), shell_command.GetOutput()) return (err, shell_command.GetStatus(), shell_command.GetOutput())
# ================================================= # =================================================
# Misc. helper methods for debugging test execution # Misc. helper methods for debugging test execution
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/lldbutil.py

Show First 20 Lines • Show All 719 Lines • ▼ Show 20 Linesdef get_crashed_threads(test, process):
threads = [] threads = []
if process.GetState() != lldb.eStateStopped: if process.GetState() != lldb.eStateStopped:
return threads return threads
for thread in process: for thread in process:
if is_thread_crashed(test, thread): if is_thread_crashed(test, thread):
threads.append(thread) threads.append(thread)
return threads return threads
def run_to_source_breakpoint(test, bkpt_pattern, source_spec, launch_info = None, exe_name = "a.out", in_cwd = True): def run_to_source_breakpoint(test, bkpt_pattern, source_spec,
launch_info = None, exe_name = "a.out",
in_cwd = True):
"""Start up a target, using exe_name as the executable, and run it to """Start up a target, using exe_name as the executable, and run it to
a breakpoint set by source regex bkpt_pattern. a breakpoint set by source regex bkpt_pattern.
If you want to pass in launch arguments or environment variables, you can optionally pass in
an SBLaunchInfo. If you do that, remember to set the working directory as well. If you want to pass in launch arguments or environment
If your executable isn't called a.out, you can pass that in. And if your executable isn't variables, you can optionally pass in an SBLaunchInfo. If you
in the CWD, pass in the absolute path to the executable in exe_name, and set in_cwd to False. 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 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 = test.getBuildArtifact(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 540 Lines • Show Last 20 Lines

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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")
self.process = self.target.LaunchSimple( self.process = self.target.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
self.assertTrue(self.process, PROCESS_IS_VALID) self.assertTrue(self.process, PROCESS_IS_VALID)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.assertTrue(self.process.GetState() == lldb.eStateStopped, self.assertTrue(self.process.GetState() == lldb.eStateStopped,
STOPPED_DUE_TO_BREAKPOINT) STOPPED_DUE_TO_BREAKPOINT)
self.runCmd("add-dsym hide.app/Contents/a.out.dSYM") self.runCmd("add-dsym " +
self.getBuildArtifact("hide.app/Contents/a.out.dSYM"))
self.expect("frame select", self.expect("frame select",
substrs=['a.out`main at main.c']) substrs=['a.out`main at main.c'])

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

Show All 22 Linesclass AppleTypesTestCase(TestBase):
def test_debug_info_for_apple_types(self): def test_debug_info_for_apple_types(self):
"""Test that __apple_types section does get produced by clang.""" """Test that __apple_types section does get produced by clang."""
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 = self.getBuildArtifact(
"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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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(), 'libindirect.dylib')
lib2 = os.path.join(os.getcwd(), 'libreexport.dylib') lib2 = os.path.join(os.getcwd(), 'libreexport.dylib')
self.registerSharedLibrariesWithTarget(target, [lib1, lib2]) self.registerSharedLibrariesWithTarget(target, [lib1, lib2])
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

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

Show All 32 Lines def setUp(self):
self.child = None self.child = None
self.child_prompt = '(lldb) ' self.child_prompt = '(lldb) '
self.strict_sources = False self.strict_sources = False
# Source filename. # Source filename.
self.source = 'main.m' self.source = 'main.m'
# Output filename. # Output filename.
self.exe_name = 'a.out' self.exe_name = self.getBuildArtifact("a.out")
self.d = {'OBJC_SOURCES': self.source, 'EXE': self.exe_name} self.d = {'OBJC_SOURCES': self.source, 'EXE': self.exe_name}
# Locate breakpoint. # Locate breakpoint.
self.line = lldbtest.line_number(self.source, '// break here') self.line = lldbtest.line_number(self.source, '// break here')
def tearDown(self): def tearDown(self):
# Shut down the process if it's still running. # Shut down the process if it's still running.
if self.child: if self.child:
▲ Show 20 Lines • Show All 104 Lines • Show Last 20 Lines

lldb/trunk/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 = self.getBuildArtifact("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 %s" % exe)
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)

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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

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

Show All 16 Linesclass SBFrameFindValueTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@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 = self.getBuildArtifact("a.out")
exe = os.path.join(os.getcwd(), 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

lldb/trunk/packages/Python/lldbsuite/test/python_api/formatters/TestFormattersSBAPI.py

Show All 22 Linesclass SBFormattersAPITestCase(TestBase):
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_formatters_api(self): def test_formatters_api(self):
"""Test Python APIs for working with formatters""" """Test Python APIs for working with formatters"""
self.build() self.build()
self.setTearDownCleanup() self.setTearDownCleanup()
"""Test Python APIs for working with formatters""" """Test Python APIs for working with formatters"""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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 20 Lines • Show All 457 Lines • Show Last 20 Lines

lldb/trunk/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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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

lldb/trunk/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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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

lldb/trunk/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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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

lldb/trunk/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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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

lldb/trunk/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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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

lldb/trunk/packages/Python/lldbsuite/test/python_api/rdar-12481949/Test-rdar-12481949.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 at. # Find the line number to break at.
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):
"""Check that SBValue.GetValueAsSigned() does the right thing for a 32-bit -1.""" """Check that SBValue.GetValueAsSigned() does the right thing for a 32-bit -1."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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 31 Lines

lldb/trunk/packages/Python/lldbsuite/test/python_api/sbdata/TestSBData.py

Show All 39 Lines def test_byte_order_and_address_byte_size(self):
data.SetData(error, addr_data, lldb.eByteOrderLittle, 8) data.SetData(error, addr_data, lldb.eByteOrderLittle, 8)
addr = data.GetAddress(error, 0) addr = data.GetAddress(error, 0)
self.assertTrue(addr == 0x8877665544332211); self.assertTrue(addr == 0x8877665544332211);
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_with_run_command(self): def test_with_run_command(self):
"""Test the SBData APIs.""" """Test the SBData APIs."""
self.build() self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), 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 20 Lines • Show All 501 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/python_api/sbvalue_persist/TestSBValuePersist.py

Show All 16 Linesclass SBValuePersistTestCase(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/pr24772") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24772")
def test(self): def test(self):
"""Test SBValue::Persist""" """Test SBValue::Persist"""
self.build() self.build()
self.setTearDownCleanup() self.setTearDownCleanup()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_source_regexp(self, "break here") lldbutil.run_break_set_by_source_regexp(self, "break here")
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',
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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 18 Lines def test(self):
# Now get the SBSymbolContext from this frame. We want everything. :-) # Now get the SBSymbolContext from this frame. We want everything. :-)
context = frame0.GetSymbolContext(lldb.eSymbolContextEverything) context = frame0.GetSymbolContext(lldb.eSymbolContextEverything)
self.assertTrue(context) self.assertTrue(context)
# Get the description of this module. # Get the description of this module.
module = context.GetModule() module = context.GetModule()
desc = lldbutil.get_description(module) desc = lldbutil.get_description(module)
self.expect(desc, "The module should match", exe=False, self.expect(desc, "The module should match", exe=False,
substrs=[os.path.join(self.mydir, 'a.out')]) substrs=[self.getBuildArtifact("a.out")])
compileUnit = context.GetCompileUnit() compileUnit = context.GetCompileUnit()
self.expect( self.expect(
str(compileUnit), str(compileUnit),
"The compile unit should match", "The compile unit should match",
exe=False, exe=False,
substrs=[ substrs=[
os.path.join( os.path.join(
Show All 31 Lines

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("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

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

Show First 20 Lines • Show All 237 Lines • ▼ Show 20 Lines def find_functions(self, exe_name):
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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 20 Lines • Show All 161 Lines • Show Last 20 Lines

lldb/trunk/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 = self.getBuildArtifact("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

lldb/trunk/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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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

lldb/trunk/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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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

lldb/trunk/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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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

lldb/trunk/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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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

lldb/trunk/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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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 = self.getBuildArtifact("a.out")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
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

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 = self.getBuildArtifact("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 259 Lines • Show Last 20 Lines

lldb/trunk/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 = self.getBuildArtifact("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)

lldb/trunk/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 = self.getBuildArtifact("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 = self.getBuildArtifact("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.
Show All 19 Lines def test_move_and_then_display_source(self):
# 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 = self.getBuildArtifact("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 68 Lines • ▼ Show 20 Lines def test_modify_source_file_while_debugging(self):
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(), "hidden")))
exe = os.path.join(os.getcwd(), "a.out") exe = self.getBuildArtifact("a.out")
main = os.path.join(os.getcwd(), "hidden", "main.c") main = os.path.join(os.getcwd(), "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'])

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

Show All 35 Linesclass MiFileTestCase(lldbmi_testcase.MiTestCaseBase):
@skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
@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 self.runCmd("-file-exec-and-symbols \"%s\"" % self.myexe)
path = os.path.join(os.getcwd(), self.myexe)
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\"")
@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
@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_relative_path(self): def test_lldbmi_file_exec_and_symbols_relative_path(self):
"""Test that 'lldb-mi --interpreter' works for -file-exec-and-symbols relpath/exe.""" """Test that 'lldb-mi --interpreter' works for -file-exec-and-symbols relpath/exe."""
self.spawnLldbMi(args=None) self.spawnLldbMi(args=None)
# Test that -file-exec-and-symbols works for relative path # Test that -file-exec-and-symbols works for relative path
path = "./%s" % self.myexe import os
path = os.path.relpath(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 12 Lines

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

Show All 29 Lines def test_lldbmi_library_loaded(self):
# Test =library-loaded # Test =library-loaded
import os import os
path = os.path.join(os.getcwd(), self.myexe) path = os.path.join(os.getcwd(), self.myexe)
symbols_path = os.path.join( symbols_path = os.path.join(
path + ".dSYM", path + ".dSYM",
"Contents", "Contents",
"Resources", "Resources",
"DWARF", "DWARF",
self.myexe) "a.out")
def add_slashes(x): return x.replace( def add_slashes(x): return x.replace(
"\\", "\\",
"\\\\").replace( "\\\\").replace(
"\"", "\"",
"\\\"").replace( "\\\"").replace(
"\'", "\'",
"\\\'").replace( "\\\'").replace(
Show All 13 Lines

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-mi/lldbmi_testcase.py

""" """
Base class for lldb-mi test cases. Base class for lldb-mi test cases.
""" """
from __future__ import print_function from __future__ import print_function
from lldbsuite.test.lldbtest import * from lldbsuite.test.lldbtest import *
class MiTestCaseBase(Base): class MiTestCaseBase(TestBase):
mydir = None mydir = None
myexe = "a.out" myexe = None
mylog = "child.log" mylog = None
@classmethod @classmethod
def classCleanup(cls): def classCleanup(cls):
if cls.myexe:
TestBase.RemoveTempFile(cls.myexe) TestBase.RemoveTempFile(cls.myexe)
if cls.mylog:
TestBase.RemoveTempFile(cls.mylog) TestBase.RemoveTempFile(cls.mylog)
def setUp(self): def setUp(self):
Base.setUp(self) Base.setUp(self)
self.buildDefault() self.buildDefault()
self.child_prompt = "(gdb)" self.child_prompt = "(gdb)"
self.myexe = self.getBuildArtifact("a.out")
def tearDown(self): def tearDown(self):
if self.TraceOn(): if self.TraceOn():
print("\n\nContents of %s:" % self.mylog) print("\n\nContents of %s:" % self.mylog)
try: try:
print(open(self.mylog, "r").read()) print(open(self.mylog, "r").read())
except IOError: except IOError:
pass pass
Base.tearDown(self) Base.tearDown(self)
def spawnLldbMi(self, args=None): def spawnLldbMi(self, args=None):
import pexpect import pexpect
self.child = pexpect.spawn("%s --interpreter %s" % ( self.child = pexpect.spawn("%s --interpreter %s" % (
self.lldbMiExec, args if args else "")) self.lldbMiExec, args if args else ""))
self.child.setecho(True) self.child.setecho(True)
self.mylog = self.getBuildArtifact("child.log")
self.child.logfile_read = open(self.mylog, "w") self.child.logfile_read = open(self.mylog, "w")
# wait until lldb-mi has started up and is ready to go # wait until lldb-mi has started up and is ready to go
self.expect(self.child_prompt, exactly=True) self.expect(self.child_prompt, exactly=True)
def runCmd(self, cmd): def runCmd(self, cmd):
self.child.sendline(cmd) self.child.sendline(cmd)
def expect(self, pattern, exactly=False, *args, **kwargs): def expect(self, pattern, exactly=False, *args, **kwargs):
if exactly: if exactly:
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)

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

""" """
Test lldb-mi startup options. Test lldb-mi startup options.
""" """
from __future__ import print_function from __future__ import print_function
import lldbmi_testcase import lldbmi_testcase
from lldbsuite.test.decorators import * from lldbsuite.test.decorators import *
from lldbsuite.test.lldbtest import * from lldbsuite.test.lldbtest import *
from lldbsuite.test import lldbutil from lldbsuite.test import lldbutil
import os
class MiStartupOptionsTestCase(lldbmi_testcase.MiTestCaseBase): class MiStartupOptionsTestCase(lldbmi_testcase.MiTestCaseBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@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
▲ Show 20 Lines • Show All 42 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 self.spawnLldbMi(args="%s" % self.myexe)
path = os.path.join(os.getcwd(), self.myexe)
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\"" % self.myexe)
self.expect("\^done") self.expect("\^done")
# Test that lldb-mi is ready when executable was loaded # Test that lldb-mi is ready when executable was loaded
self.expect(self.child_prompt, exactly=True) self.expect(self.child_prompt, exactly=True)
# 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\"")
@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_relative_path(self): def test_lldbmi_executable_option_relative_path(self):
"""Test that 'lldb-mi --interpreter %s' loads executable which is specified via relative path.""" """Test that 'lldb-mi --interpreter %s' loads executable which is specified via relative path."""
# Prepare path to executable # Prepare path to executable
path = "./%s" % self.myexe path = os.path.relpath(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
# relative path # relative path
self.expect("-file-exec-and-symbols \"%s\"" % path) self.expect("-file-exec-and-symbols \"%s\"" % path)
self.expect("\^done") self.expect("\^done")
# Test that lldb-mi is ready when executable was loaded # Test that lldb-mi is ready when executable was loaded
Show All 19 Lines def test_lldbmi_executable_option_unknown_path(self):
self.expect("-file-exec-and-symbols \"%s\"" % path) self.expect("-file-exec-and-symbols \"%s\"" % path)
self.expect( self.expect(
"\^error,msg=\"Command 'file-exec-and-symbols'. Target binary '%s' is invalid. error: unable to find executable for '%s'\"" % "\^error,msg=\"Command 'file-exec-and-symbols'. Target binary '%s' is invalid. error: unable to find executable for '%s'\"" %
(path, path)) (path, path))
# Test that lldb-mi is ready when executable was loaded # Test that lldb-mi is ready when executable was loaded
self.expect(self.child_prompt, exactly=True) self.expect(self.child_prompt, exactly=True)
def copyScript(self, sourceFile):
"""copy the script to builddir and replace a.out with the full path"""
destFile = os.path.join(os.path.dirname(self.myexe),
sourceFile+'.script')
with open(sourceFile, 'r') as src:
with open(destFile, 'w+') as dest:
dest.write(src.read().replace("a.out", self.myexe))
return destFile
@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
@skipIfLinux # llvm.org/pr22841: lldb-mi tests fail on all Linux buildbots @skipIfLinux # llvm.org/pr22841: lldb-mi tests fail on all Linux buildbots
def test_lldbmi_source_option_start_script(self): def test_lldbmi_source_option_start_script(self):
"""Test that 'lldb-mi --interpreter' can execute user's commands after initial commands were executed.""" """Test that 'lldb-mi --interpreter' can execute user's commands after initial commands were executed."""
# Prepared source file # Prepared source file
sourceFile = "start_script" sourceFile = self.copyScript("start_script")
self.spawnLldbMi(args="--source %s" % sourceFile) self.spawnLldbMi(args="--source %s" % sourceFile)
# After '-file-exec-and-symbols a.out' # After '-file-exec-and-symbols a.out'
self.expect("-file-exec-and-symbols %s" % self.myexe) self.expect("-file-exec-and-symbols %s" % self.myexe)
self.expect("\^done") self.expect("\^done")
# After '-break-insert -f main' # After '-break-insert -f main'
self.expect("-break-insert -f main") self.expect("-break-insert -f main")
Show All 16 Lines def test_lldbmi_source_option_start_script(self):
# Test that lldb-mi is ready after execution of --source start_script # Test that lldb-mi is ready after execution of --source start_script
self.expect(self.child_prompt, exactly=True) self.expect(self.child_prompt, exactly=True)
# Try to evaluate 'a' expression # Try to evaluate 'a' expression
self.runCmd("-data-evaluate-expression a") self.runCmd("-data-evaluate-expression a")
self.expect("\^done,value=\"10\"") self.expect("\^done,value=\"10\"")
self.expect(self.child_prompt, exactly=True) self.expect(self.child_prompt, exactly=True)
os.unlink(sourceFile)
@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
@skipIfLinux # llvm.org/pr22841: lldb-mi tests fail on all Linux buildbots @skipIfLinux # llvm.org/pr22841: lldb-mi tests fail on all Linux buildbots
def test_lldbmi_source_option_start_script_exit(self): def test_lldbmi_source_option_start_script_exit(self):
"""Test that 'lldb-mi --interpreter' can execute a prepared file which passed via --source option.""" """Test that 'lldb-mi --interpreter' can execute a prepared file which passed via --source option."""
# Prepared source file # Prepared source file
sourceFile = "start_script_exit" sourceFile = self.copyScript("start_script_exit")
self.spawnLldbMi(args="--source %s" % sourceFile) self.spawnLldbMi(args="--source %s" % sourceFile)
# After '-file-exec-and-symbols a.out' # After '-file-exec-and-symbols a.out'
self.expect("-file-exec-and-symbols %s" % self.myexe) self.expect("-file-exec-and-symbols %s" % self.myexe)
self.expect("\^done") self.expect("\^done")
# After '-break-insert -f main' # After '-break-insert -f main'
self.expect("-break-insert -f main") self.expect("-break-insert -f main")
Show All 17 Lines def test_lldbmi_source_option_start_script_exit(self):
# After '-data-evaluate-expression a' # After '-data-evaluate-expression a'
self.expect("-data-evaluate-expression a") self.expect("-data-evaluate-expression a")
self.expect("\^done,value=\"10\"") self.expect("\^done,value=\"10\"")
# After '-gdb-exit' # After '-gdb-exit'
self.expect("-gdb-exit") self.expect("-gdb-exit")
self.expect("\^exit") self.expect("\^exit")
self.expect("\*stopped,reason=\"exited-normally\"") self.expect("\*stopped,reason=\"exited-normally\"")
os.unlink(sourceFile)
@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_source_option_start_script_error(self): def test_lldbmi_source_option_start_script_error(self):
"""Test that 'lldb-mi --interpreter' stops execution of initial commands in case of error.""" """Test that 'lldb-mi --interpreter' stops execution of initial commands in case of error."""
# Prepared source file # Prepared source file
sourceFile = "start_script_error" sourceFile = self.copyScript("start_script_error")
self.spawnLldbMi(args="--source %s" % sourceFile) self.spawnLldbMi(args="--source %s" % sourceFile)
# After '-file-exec-and-symbols a.out' # After '-file-exec-and-symbols a.out'
self.expect("-file-exec-and-symbols %s" % self.myexe) self.expect("-file-exec-and-symbols %s" % self.myexe)
self.expect("\^done") self.expect("\^done")
# After '-break-ins -f main' # After '-break-ins -f main'
self.expect("-break-ins -f main") self.expect("-break-ins -f main")
self.expect("\^error") self.expect("\^error")
# Test that lldb-mi is ready after execution of --source start_script # Test that lldb-mi is ready after execution of --source start_script
self.expect(self.child_prompt, exactly=True) self.expect(self.child_prompt, exactly=True)
os.unlink(sourceFile)
@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_log_option(self): def test_lldbmi_log_option(self):
"""Test that 'lldb-mi --log' creates a log file in the current directory.""" """Test that 'lldb-mi --log' creates a log file in the current directory."""
logDirectory = "." logDirectory = "."
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestLldbGdbServer.py

Show First 20 Lines • Show All 552 Lines • ▼ Show 20 Lines def p_returns_correct_data_size_for_each_qRegisterInfo(self):
context = self.expect_gdbremote_sequence() context = self.expect_gdbremote_sequence()
self.assertIsNotNone(context) self.assertIsNotNone(context)
# Gather register info entries. # Gather register info entries.
reg_infos = self.parse_register_info_packets(context) reg_infos = self.parse_register_info_packets(context)
self.assertIsNotNone(reg_infos) self.assertIsNotNone(reg_infos)
self.assertTrue(len(reg_infos) > 0) self.assertTrue(len(reg_infos) > 0)
inferior_exe_path = os.path.abspath("a.out") inferior_exe_path = self.getBuildArtifact("a.out")
Target = self.dbg.CreateTarget(inferior_exe_path) Target = self.dbg.CreateTarget(inferior_exe_path)
byte_order = Target.GetByteOrder() byte_order = Target.GetByteOrder()
# Read value for each register. # Read value for each register.
reg_index = 0 reg_index = 0
for reg_info in reg_infos: for reg_info in reg_infos:
# Skip registers that don't have a register set. For x86, these are # Skip registers that don't have a register set. For x86, these are
# the DRx registers, which have no LLDB-kind register number and thus # the DRx registers, which have no LLDB-kind register number and thus
▲ Show 20 Lines • Show All 1,003 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/gdbremote_testcase.py

Show First 20 Lines • Show All 477 Lines • ▼ Show 20 Lines def launch_process_for_attach(
self, self,
inferior_args=None, inferior_args=None,
sleep_seconds=3, sleep_seconds=3,
exe_path=None): exe_path=None):
# We're going to start a child process that the debug monitor stub can later attach to. # We're going to start a child process that the debug monitor stub can later attach to.
# This process needs to be started so that it just hangs around for a while. We'll # This process needs to be started so that it just hangs around for a while. We'll
# have it sleep. # have it sleep.
if not exe_path: if not exe_path:
exe_path = os.path.abspath("a.out") exe_path = self.getBuildArtifact("a.out")
args = [] args = []
if inferior_args: if inferior_args:
args.extend(inferior_args) args.extend(inferior_args)
if sleep_seconds: if sleep_seconds:
args.append("sleep:%d" % sleep_seconds) args.append("sleep:%d" % sleep_seconds)
inferior = self.spawnSubprocess(exe_path, args) inferior = self.spawnSubprocess(exe_path, args)
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines def prep_debug_monitor_and_inferior(
if self._inferior_startup == self._STARTUP_ATTACH: if self._inferior_startup == self._STARTUP_ATTACH:
# In this case, we want the stub to attach via the command # In this case, we want the stub to attach via the command
# line, so set the command line attach pid here. # line, so set the command line attach pid here.
attach_pid = inferior.pid attach_pid = inferior.pid
if self._inferior_startup == self._STARTUP_LAUNCH: if self._inferior_startup == self._STARTUP_LAUNCH:
# Build launch args # Build launch args
if not inferior_exe_path: if not inferior_exe_path:
inferior_exe_path = os.path.abspath("a.out") inferior_exe_path = self.getBuildArtifact("a.out")
if lldb.remote_platform: if lldb.remote_platform:
remote_path = lldbutil.append_to_process_working_directory( remote_path = lldbutil.append_to_process_working_directory(
os.path.basename(inferior_exe_path)) os.path.basename(inferior_exe_path))
remote_file_spec = lldb.SBFileSpec(remote_path, False) remote_file_spec = lldb.SBFileSpec(remote_path, False)
err = lldb.remote_platform.Install(lldb.SBFileSpec( err = lldb.remote_platform.Install(lldb.SBFileSpec(
inferior_exe_path, True), remote_file_spec) inferior_exe_path, True), remote_file_spec)
if err.Fail(): if err.Fail():
▲ Show 20 Lines • Show All 1,044 Lines • ▼ Show 20 Lines def single_step_only_steps_one_instruction(
self.assertTrue(state_reached) self.assertTrue(state_reached)
self.assertEqual(step_count, expected_step_count) self.assertEqual(step_count, expected_step_count)
def maybe_strict_output_regex(self, regex): def maybe_strict_output_regex(self, regex):
return '.*' + regex + \ return '.*' + regex + \
'.*' if lldbplatformutil.hasChattyStderr(self) else '^' + regex + '$' '.*' if lldbplatformutil.hasChattyStderr(self) else '^' + regex + '$'
def install_and_create_launch_args(self): def install_and_create_launch_args(self):
exe_path = os.path.abspath('a.out') exe_path = self.getBuildArtifact("a.out")
if not lldb.remote_platform: if not lldb.remote_platform:
return [exe_path] return [exe_path]
remote_path = lldbutil.append_to_process_working_directory( remote_path = lldbutil.append_to_process_working_directory(
os.path.basename(exe_path)) os.path.basename(exe_path))
remote_file_spec = lldb.SBFileSpec(remote_path, False) remote_file_spec = lldb.SBFileSpec(remote_path, False)
err = lldb.remote_platform.Install(lldb.SBFileSpec(exe_path, True), err = lldb.remote_platform.Install(lldb.SBFileSpec(exe_path, True),
remote_file_spec) remote_file_spec)
if err.Fail(): if err.Fail():
raise Exception("remote_platform.Install('%s', '%s') failed: %s" % raise Exception("remote_platform.Install('%s', '%s') failed: %s" %
(exe_path, remote_path, err)) (exe_path, remote_path, err))
return [remote_path] return [remote_path]

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/platform-process-connect/TestPlatformProcessConnect.py

Show All 14 Linesclass TestPlatformProcessConnect(gdbremote_testcase.GdbRemoteTestCaseBase):
@no_debug_info_test @no_debug_info_test
@skipIf(remote=False) @skipIf(remote=False)
@expectedFailureAll(hostoslist=["windows"], triple='.*-android') @expectedFailureAll(hostoslist=["windows"], triple='.*-android')
def test_platform_process_connect(self): def test_platform_process_connect(self):
self.build() self.build()
self.init_llgs_test(False) self.init_llgs_test(False)
working_dir = lldb.remote_platform.GetWorkingDirectory() working_dir = lldb.remote_platform.GetWorkingDirectory()
err = lldb.remote_platform.Put( src = lldb.SBFileSpec(self.getBuildArtifact("a.out"))
lldb.SBFileSpec( dest = lldb.SBFileSpec(os.path.join(working_dir, "a.out"))
os.path.join( err = lldb.remote_platform.Put(src, dest)
os.getcwd(), "a.out")), lldb.SBFileSpec(
os.path.join(
working_dir, "a.out")))
if err.Fail(): if err.Fail():
raise RuntimeError( raise RuntimeError(
"Unable copy '%s' to '%s'.\n>>> %s" % "Unable copy '%s' to '%s'.\n>>> %s" %
(f, wd, err.GetCString())) (f, wd, err.GetCString()))
m = re.search("^(.*)://([^:/]*)", configuration.lldb_platform_url) m = re.search("^(.*)://([^:/]*)", configuration.lldb_platform_url)
protocol = m.group(1) protocol = m.group(1)
hostname = m.group(2) hostname = m.group(2)
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/types/TestRecursiveTypes.py

Show All 38 Linesclass RecursiveTypesTestCase(TestBase):
def test_recursive_type_2(self): def test_recursive_type_2(self):
"""Test that recursive structs are displayed correctly.""" """Test that recursive structs are displayed correctly."""
self.build(dictionary=self.d2) self.build(dictionary=self.d2)
self.setTearDownCleanup(dictionary=self.d2) self.setTearDownCleanup(dictionary=self.d2)
self.print_struct() self.print_struct()
def print_struct(self): def print_struct(self):
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, self,
"recursive_type_main.cpp", "recursive_type_main.cpp",
self.line, self.line,
num_expected_locations=-1, num_expected_locations=-1,
loc_exact=True) loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.expect("print tpi", RUN_SUCCEEDED) self.expect("print tpi", RUN_SUCCEEDED)
self.expect("print *tpi", RUN_SUCCEEDED) self.expect("print *tpi", RUN_SUCCEEDED)

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

Show First 20 Lines • Show All 77 Lines • ▼ Show 20 Lines def generate_main_cpp(self, version=0):
# 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
def do_add_dsym_with_error(self, exe_name): def do_add_dsym_with_error(self, exe_name):
"""Test that the 'add-dsym' command informs the user about failures.""" """Test that the 'add-dsym' command informs the user about failures."""
self.runCmd("file " + exe_name, CURRENT_EXECUTABLE_SET) exe_path = self.getBuildArtifact(exe_name)
self.runCmd("file " + exe_path, CURRENT_EXECUTABLE_SET)
wrong_path = os.path.join("%s.dSYM" % exe_name, "Contents") wrong_path = os.path.join("%s.dSYM" % exe_name, "Contents")
self.expect("add-dsym " + wrong_path, error=True, self.expect("add-dsym " + wrong_path, error=True,
substrs=['invalid module path']) substrs=['invalid module path'])
right_path = os.path.join( right_path = os.path.join(
"%s.dSYM" % "%s.dSYM" %
exe_name, exe_path,
"Contents", "Contents",
"Resources", "Resources",
"DWARF", "DWARF",
exe_name) exe_name)
self.expect("add-dsym " + right_path, error=True, self.expect("add-dsym " + right_path, error=True,
substrs=['symbol file', 'does not match']) substrs=['symbol file', 'does not match'])
def do_add_dsym_with_success(self, exe_name): def do_add_dsym_with_success(self, exe_name):
"""Test that the 'add-dsym' command informs the user about success.""" """Test that the 'add-dsym' command informs the user about success."""
self.runCmd("file " + exe_name, CURRENT_EXECUTABLE_SET) exe_path = self.getBuildArtifact(exe_name)
self.runCmd("file " + exe_path, CURRENT_EXECUTABLE_SET)
# This time, the UUID should match and we expect some feedback from # This time, the UUID should match and we expect some feedback from
# lldb. # lldb.
right_path = os.path.join( right_path = os.path.join(
"%s.dSYM" % "%s.dSYM" %
exe_name, exe_path,
"Contents", "Contents",
"Resources", "Resources",
"DWARF", "DWARF",
exe_name) exe_name)
self.expect("add-dsym " + right_path, self.expect("add-dsym " + right_path,
substrs=['symbol file', 'has been added to']) substrs=['symbol file', 'has been added to'])
def do_add_dsym_with_dSYM_bundle(self, exe_name): def do_add_dsym_with_dSYM_bundle(self, exe_name):
"""Test that the 'add-dsym' command informs the user about success when loading files in bundles.""" """Test that the 'add-dsym' command informs the user about success when loading files in bundles."""
self.runCmd("file " + exe_name, CURRENT_EXECUTABLE_SET) exe_path = self.getBuildArtifact(exe_name)
self.runCmd("file " + exe_path, CURRENT_EXECUTABLE_SET)
# This time, the UUID should be found inside the bundle # This time, the UUID should be found inside the bundle
right_path = "%s.dSYM" % exe_name right_path = "%s.dSYM" % exe_path
self.expect("add-dsym " + right_path, self.expect("add-dsym " + right_path,
substrs=['symbol file', 'has been added to']) substrs=['symbol file', 'has been added to'])