This is an archive of the discontinued LLVM Phabricator instance.

Differential D127340

[lldb] Replace getBuildArtifact("a.out") with getTestExecutable()
Needs ReviewPublic

Authored by JDevlieghere on Jun 8 2022, 1:12 PM.
This revision needs review, but there are no reviewers specified.

Details

Reviewers
None
Summary
find . -type f -exec sed -i.bak "s/getBuildArtifact(\"a.out\")/getTestExecutable()/g" '{}' \;

Diff Detail

Event Timeline

JDevlieghere created this revision.Jun 8 2022, 1:12 PM
Herald added a project: Restricted Project. · View Herald TranscriptJun 8 2022, 1:12 PM
Herald added subscribers: arphaman, emaste. · View Herald Transcript
JDevlieghere requested review of this revision.Jun 8 2022, 1:12 PM
Harbormaster completed remote builds in B168665: Diff 435306.Jun 8 2022, 1:13 PM
JDevlieghere updated this revision to Diff 435314.Jun 8 2022, 1:45 PM
Harbormaster completed remote builds in B168670: Diff 435314.Jun 8 2022, 1:45 PM

Revision Contents

PathSize
lldb/
packages/
Python/
lldbsuite/
test/
builders/
9 lines
12 lines
18 lines
make/
3 lines
test/
API/
api/
check_public_api_headers/
4 lines
arm/
breakpoint-it/
4 lines
breakpoint-thumb-codesection/
2 lines
benchmarks/
continue/
2 lines
libcxxlist/
2 lines
libcxxmap/
2 lines
commands/
apropos/
with-process/
2 lines
command/
nested_alias/
2 lines
script/
2 lines
expression/
formatters/
2 lines
ir-interpreter-phi-nodes/
2 lines
ir-interpreter/
2 lines
multiline-completion/
2 lines
options/
2 lines
persist_objc_pointeetype/
2 lines
persistent_ptr_update/
2 lines
persistent_types/
2 lines
2 lines
po_verbosity/
2 lines
radar_8638051/
2 lines
radar_9531204/
2 lines
radar_9673664/
2 lines
test/
4 lines
4 lines
top-level/
2 lines
two-files/
2 lines
frame/
diagnose/
array/
2 lines
bad-reference/
2 lines
complicated-expression/
2 lines
dereference-argument/
2 lines
dereference-function-return/
2 lines
dereference-this/
2 lines
inheritance/
2 lines
local-variable/
2 lines
virtual-method-call/
2 lines
recognizer/
8 lines
gui/
basic/
2 lines
basicdebug/
2 lines
breakpoints/
2 lines
expand-threads-tree/
2 lines
viewlarge/
2 lines
log/
basic/
2 lines
memory/
write/
2 lines
platform/
connect/
2 lines
process/
launch/
6 lines
register/
register/
aarch64_dynamic_regset/
2 lines
aarch64_sve_registers/
rw_access_dynamic_resize/
2 lines
rw_access_static_config/
4 lines
register_command/
4 lines
settings/
14 lines
quoting/
2 lines
statistics/
basic/
4 lines
target/
auto-install-main-executable/
2 lines
basic/
12 lines
create-deps/
10 lines
create-no-such-arch/
2 lines
modules/
search-paths/
insert/
2 lines
trace/
multiple-threads/
12 lines
watchpoints/
multi_watchpoint_slots/
2 lines
watch_tagged_addr/
2 lines
watchpoint_on_vectors/
4 lines
watchpoint_set_command/
2 lines
watchpoint_size/
2 lines
driver/
batch_mode/
8 lines
functionalities/
archives/
2 lines
avoids-fd-leak/
4 lines
breakpoint/
breakpoint_callback_command_source/
2 lines
breakpoint_command/
6 lines
2 lines
breakpoint_conditions/
4 lines
breakpoint_ids/
2 lines
breakpoint_ignore_count/
2 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/
4 lines
debugbreak/
2 lines
dummy_target_breakpoints/
2 lines
global_constructor/
2 lines
hardware_breakpoints/
2 lines
hardware_breakpoint_on_multiple_threads/
2 lines
require_hw_breakpoints/
2 lines
write_memory_with_hw_breakpoint/
2 lines
inlined_breakpoints/
2 lines
move_nearest/
2 lines
objc/
2 lines
serialize/
2 lines
source_regexp/
4 lines
step_over_breakpoint/
2 lines
completion/
12 lines
conditional_break/
6 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/
cmtime/
2 lines
nsindexpath/
2 lines
nsstring/
2 lines
data-formatter-proper-plurals/
2 lines
data-formatter-ptr-to-array/
2 lines
data-formatter-python-synth/
2 lines
data-formatter-script/
2 lines
data-formatter-skip-summary/
2 lines
data-formatter-smart-array/
2 lines
data-formatter-stl/
generic/
list/
2 lines
loop/
2 lines
multimap/
2 lines
optional/
2 lines
unordered/
2 lines
libcxx/
atomic/
2 lines
function/
2 lines
initializerlist/
2 lines
iterator/
2 lines
map/
2 lines
string_view/
2 lines
vbool/
2 lines
libstdcpp/
iterator/
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
deleted-executable/
2 lines
dyld-exec-linux/
2 lines
dyld-launch-linux/
4 lines
dynamic_value_child_count/
2 lines
exec/
4 lines
fat_archives/
2 lines
find-line-entry/
2 lines
gdb_remote_client/
2 lines
inferior-assert/
12 lines
inferior-changed/
2 lines
inferior-crashing/
8 lines
14 lines
recursive-inferior/
8 lines
6 lines
inline-stepping/
6 lines
jitloader_gdb/
2 lines
limit-debug-info/
6 lines
load_after_attach/
2 lines
load_unload/
12 lines
location-list-lookup/
2 lines
longjmp/
2 lines
memory-region/
2 lines
memory/
cache/
2 lines
find/
2 lines
tag/
2 lines
module_cache/
bsd/
2 lines
simple_exe/
2 lines
mtc/
simple/
2 lines
non-overlapping-index-variable-i/
2 lines
plugins/
python_os_plugin/
4 lines
postmortem/
minidump/
4 lines
pre_run_dylibs/
2 lines
process_crash_info/
4 lines
process_group/
2 lines
process_save_core/
6 lines
process_save_core_minidump/
2 lines
progress_reporting/
2 lines
ptr_refs/
2 lines
recursion/
2 lines
rerun/
2 lines
return-value/
6 lines
scripted_process/
4 lines
2 lines
set-data/
2 lines
signal/
2 lines
handle-abrt/
2 lines
handle-segv/
2 lines
raise/
2 lines
stats_api/
2 lines
step-avoids-no-debug/
2 lines
tail_call_frames/
cross_dso/
2 lines
cross_object/
2 lines
sbapi_support/
2 lines
thread_step_out_or_return/
2 lines
target-new-solib-notifications/
2 lines
thread/
break_after_join/
2 lines
concurrent_events/
exit/
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_until/
2 lines
thread_exit/
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_lookup/
2 lines
ubsan/
basic/
2 lines
user-expression/
2 lines
unwind/
aarch64_unwind_pac/
2 lines
ehframe/
2 lines
noreturn/
2 lines
sigtramp/
2 lines
zeroth_frame/
2 lines
value_md5_crash/
2 lines
iohandler/
completion/
2 lines
sigint/
2 lines
stdio/
2 lines
lang/
c/
anonymous/
4 lines
array_types/
4 lines
blocks/
2 lines
conflicting-symbol/
4 lines
const_variables/
2 lines
find_struct_type/
2 lines
forward/
2 lines
function_types/
2 lines
global_variables/
4 lines
local_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
unicode/
2 lines
unions/
2 lines
cpp/
alignas_base_class/
2 lines
breakpoint-commands/
2 lines
char1632_t/
2 lines
class-template-non-type-parameter-pack/
2 lines
class-template-type-parameter-pack/
2 lines
class_static/
6 lines
class_types/
12 lines
2 lines
dynamic-value/
2 lines
elaborated-types/
2 lines
enum_types/
2 lines
exceptions/
2 lines
frame-var-anon-unions/
2 lines
global_operators/
2 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
non-type-template-param/
2 lines
nsimport/
2 lines
pointer_to_member_type_depending_on_parent_size/
2 lines
reference-to-outer-type/
2 lines
rvalue-references/
2 lines
signed_types/
2 lines
static_member_type_depending_on_parent_size/
2 lines
template-arguments/
2 lines
template/
2 lines
this/
2 lines
thread_local/
2 lines
mixed/
2 lines
objc/
blocks/
2 lines
conflicting-definition/
2 lines
exceptions/
6 lines
forward-decl/
2 lines
foundation/
2 lines
4 lines
8 lines
2 lines
2 lines
global_ptrs/
2 lines
hidden-ivars/
2 lines
ivar-IMP/
2 lines
modules-auto-import/
2 lines
modules-incomplete/
2 lines
modules-inline-functions/
2 lines
modules/
2 lines
objc++/
2 lines
objc-baseclass-sbtype/
2 lines
objc-checker/
2 lines
objc-class-method/
2 lines
objc-dynamic-value/
2 lines
objc-ivar-offsets/
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/
2 lines
self/
2 lines
single-entry-dictionary/
2 lines
objcxx/
objc-builtin-types/
2 lines
linux/
aarch64/
mte_memory_region/
2 lines
mte_tag_access/
2 lines
mte_tag_faults/
2 lines
non_address_bit_memory_access/
2 lines
tagged_memory_access/
2 lines
tagged_memory_region/
2 lines
unwind_signal/
2 lines
add-symbols/
2 lines
builtin_trap/
2 lines
mix-dwo-and-regular-objects/
2 lines
thread/
create_during_instruction_step/
2 lines
lua_api/
2 lines
macosx/
add-dsym/
2 lines
2 lines
corefile-default-ptrauth/
2 lines
debugserver-exit-code/
2 lines
duplicate-archive-members/
2 lines
dyld-trie-symbols/
2 lines
indirect_symbol/
2 lines
lc-note/
addrable-bits/
2 lines
firmware-corefile/
2 lines
kern-ver-str/
2 lines
nslog/
2 lines
order/
2 lines
queues/
4 lines
safe-to-func-call/
2 lines
simulator/
2 lines
skinny-corefile/
2 lines
thread-names/
2 lines
python_api/
breakpoint/
4 lines
debugger/
6 lines
event/
6 lines
findvalue_duplist/
2 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
module_section/
6 lines
name_lookup/
2 lines
objc_type/
2 lines
process/
12 lines
sbdata/
2 lines
sbmodule/
2 lines
sbplatform/
2 lines
sbvalue_persist/
2 lines
signals/
2 lines
symbol-context/
2 lines
two-files/
4 lines
target/
8 lines
thread/
4 lines
value/
empty_class/
2 lines
watchpoint/
2 lines
2 lines
2 lines
watchlocation/
2 lines
4 lines
qemu/
10 lines
repl/
clang/
2 lines
source-manager/
8 lines
symbol_ondemand/
breakpoint_language/
4 lines
breakpoint_source_regex/
2 lines
shared_library/
2 lines
tools/
lldb-server/
10 lines
lldb-vscode/
attach/
10 lines
breakpoint-events/
2 lines
breakpoint/
8 lines
2 lines
4 lines
completions/
2 lines
console/
2 lines
2 lines
correct-thread/
2 lines
disconnect/
4 lines
evaluate/
2 lines
launch/
26 lines
module/
2 lines
optimized/
4 lines
runInTerminal/
2 lines
stackTrace/
2 lines
step/
2 lines
stop-hooks/
2 lines
variables/
6 lines
types/
2 lines

Diff 435314

lldb/packages/Python/lldbsuite/test/builders/builder.py

Show First 20 Lines • Show All 114 Lines • ▼ Show 20 Lines def getModuleCacheSpec(self):
Helper function to return the key-value string to specify the clang Helper function to return the key-value string to specify the clang
module cache used for the make system. module cache used for the make system.
""" """
if configuration.clang_module_cache_dir: if configuration.clang_module_cache_dir:
return ["CLANG_MODULE_CACHE_DIR={}".format( return ["CLANG_MODULE_CACHE_DIR={}".format(
configuration.clang_module_cache_dir)] configuration.clang_module_cache_dir)]
return [] return []
def getExecutable(self, test_exe):
if test_exe:
return ["EXE_NAME={}".format(test_exe)]
return []
def _getDebugInfoArgs(self, debug_info): def _getDebugInfoArgs(self, debug_info):
if debug_info is None: if debug_info is None:
return [] return []
if debug_info == "dwarf": if debug_info == "dwarf":
return ["MAKE_DSYM=NO"] return ["MAKE_DSYM=NO"]
if debug_info == "dwo": if debug_info == "dwo":
return ["MAKE_DSYM=NO", "MAKE_DWO=YES"] return ["MAKE_DSYM=NO", "MAKE_DWO=YES"]
if debug_info == "gmodules": if debug_info == "gmodules":
return ["MAKE_DSYM=NO", "MAKE_GMODULES=YES"] return ["MAKE_DSYM=NO", "MAKE_GMODULES=YES"]
return None return None
def getBuildCommand(self, debug_info, architecture=None, compiler=None, def getBuildCommand(self, debug_info, architecture=None, compiler=None,
dictionary=None, testdir=None, testname=None): dictionary=None, testdir=None, testname=None, testexe=None):
debug_info_args = self._getDebugInfoArgs(debug_info) debug_info_args = self._getDebugInfoArgs(debug_info)
if debug_info_args is None: if debug_info_args is None:
return None return None
command_parts = [ command_parts = [
self.getMake(testdir, testname), debug_info_args, ["all"], self.getMake(testdir, testname), debug_info_args, ["all"],
self.getArchCFlags(architecture), self.getArchSpec(architecture), self.getArchCFlags(architecture), self.getArchSpec(architecture),
self.getCCSpec(compiler), self.getExtraMakeArgs(), self.getCCSpec(compiler), self.getExtraMakeArgs(),
self.getSDKRootSpec(), self.getModuleCacheSpec(), self.getSDKRootSpec(), self.getModuleCacheSpec(),
self.getCmdLine(dictionary)] self.getExecutable(testexe), self.getCmdLine(dictionary)]
command = list(itertools.chain(*command_parts)) command = list(itertools.chain(*command_parts))
return command return command
def cleanup(self, dictionary=None): def cleanup(self, dictionary=None):
"""Perform a platform-specific cleanup after the test.""" """Perform a platform-specific cleanup after the test."""
return True return True

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

Show First 20 Lines • Show All 695 Lines • ▼ Show 20 Linesclass Base(unittest2.TestCase):
def makeBuildDir(self): def makeBuildDir(self):
"""Create the test-specific working directory, deleting any previous """Create the test-specific working directory, deleting any previous
contents.""" contents."""
bdir = self.getBuildDir() bdir = self.getBuildDir()
if os.path.isdir(bdir): if os.path.isdir(bdir):
shutil.rmtree(bdir) shutil.rmtree(bdir)
lldbutil.mkdir_p(bdir) lldbutil.mkdir_p(bdir)
def getBuildArtifact(self): def getBuildArtifact(self, name):
"""Return absolute path to an artifact in the test's build directory.""" """Return absolute path to an artifact in the test's build directory."""
return os.path.join(self.getBuildDir(), name) return os.path.join(self.getBuildDir(), name)
def getSourcePath(self, name): def getSourcePath(self, name):
"""Return absolute path to a file in the test's source directory.""" """Return absolute path to a file in the test's source directory."""
return os.path.join(self.getSourceDir(), name) return os.path.join(self.getSourceDir(), name)
def getTestExecutableName(self):
return "a.out"
def getTestExecutable(self):
"""Return absolute path to the test executable."""
return os.path.join(self.getBuildDir(), self.getTestExecutableName())
@classmethod @classmethod
def setUpCommands(cls): def setUpCommands(cls):
commands = [ commands = [
# First of all, clear all settings to have clean state of global properties. # First of all, clear all settings to have clean state of global properties.
"settings clear -all", "settings clear -all",
# Disable Spotlight lookup. The testsuite creates # Disable Spotlight lookup. The testsuite creates
# different binaries with the same UUID, because they only # different binaries with the same UUID, because they only
▲ Show 20 Lines • Show All 695 Lines • ▼ Show 20 Lines def build(
if debug_info is None: if debug_info is None:
debug_info = self.getDebugInfo() debug_info = self.getDebugInfo()
dictionary = lldbplatformutil.finalize_build_dictionary(dictionary) dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
testdir = self.mydir testdir = self.mydir
testname = self.getBuildDirBasename() testname = self.getBuildDirBasename()
testexe = self.getTestExecutableName()
module = builder_module() module = builder_module()
command = builder_module().getBuildCommand(debug_info, architecture, command = builder_module().getBuildCommand(debug_info, architecture,
compiler, dictionary, testdir, testname) compiler, dictionary, testdir, testname, testexe)
if command is None: if command is None:
raise Exception("Don't know how to build binary") raise Exception("Don't know how to build binary")
self.runBuildCommand(command) self.runBuildCommand(command)
def runBuildCommand(self, command): def runBuildCommand(self, command):
self.trace(seven.join_for_shell(command)) self.trace(seven.join_for_shell(command))
try: try:
▲ Show 20 Lines • Show All 1,141 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 735 Lines • ▼ Show 20 Linesdef check_breakpoint(
expected_locations = None, expected_locations = None,
expected_resolved_count = None, expected_resolved_count = None,
expected_hit_count = None, expected_hit_count = None,
location_id = None, location_id = None,
expected_location_resolved = True, expected_location_resolved = True,
expected_location_hit_count = None): expected_location_hit_count = None):
""" """
Test breakpoint or breakpoint location. Test breakpoint or breakpoint location.
Breakpoint resolved count is always checked. If not specified the assumption is that all locations Breakpoint resolved count is always checked. If not specified the assumption is that all locations
should be resolved. should be resolved.
To test a breakpoint location, breakpoint number (bpno) and location_id must be set. In this case To test a breakpoint location, breakpoint number (bpno) and location_id must be set. In this case
the resolved count for a breakpoint is not tested by default. The location is expected to be resolved, the resolved count for a breakpoint is not tested by default. The location is expected to be resolved,
unless expected_location_resolved is set to False. unless expected_location_resolved is set to False.
test - test context test - test context
bpno - breakpoint number to test bpno - breakpoint number to test
expected_locations - expected number of locations for this breakpoint. If 'None' this parameter is not tested. expected_locations - expected number of locations for this breakpoint. If 'None' this parameter is not tested.
expected_resolved_count - expected resolved locations number for the breakpoint. If 'None' - all locations should be resolved. expected_resolved_count - expected resolved locations number for the breakpoint. If 'None' - all locations should be resolved.
expected_hit_count - expected hit count for this breakpoint. If 'None' this parameter is not tested. expected_hit_count - expected hit count for this breakpoint. If 'None' this parameter is not tested.
▲ Show 20 Lines • Show All 139 Lines • ▼ Show 20 Lines 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
# Helper functions for run_to_{source,name}_breakpoint: # Helper functions for run_to_{source,name}_breakpoint:
def run_to_breakpoint_make_target(test, exe_name = "a.out", in_cwd = True): def run_to_breakpoint_make_target(test, exe_name = None, in_cwd=True):
if in_cwd: if exe_name:
exe = test.getBuildArtifact(exe_name) exe = test.getBuildArtifact(exe_name)
else:
exe = test.getTestExecutable()
# 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 environment variables for the inferior. # Set environment variables for the inferior.
if lldbtest_config.inferior_env: if lldbtest_config.inferior_env:
test.runCmd('settings set target.env-vars {}'.format( test.runCmd('settings set target.env-vars {}'.format(
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines if only_one_thread:
test.assertEqual(num_threads, 1, "Expected 1 thread to stop at breakpoint, %d did."%(num_threads)) test.assertEqual(num_threads, 1, "Expected 1 thread to stop at breakpoint, %d did."%(num_threads))
else: else:
test.assertGreater(num_threads, 0, "No threads stopped at breakpoint") test.assertGreater(num_threads, 0, "No threads stopped at breakpoint")
thread = threads[0] thread = threads[0]
return (target, process, thread, bkpt) return (target, process, thread, bkpt)
def run_to_name_breakpoint (test, bkpt_name, launch_info = None, def run_to_name_breakpoint (test, bkpt_name, launch_info = None,
exe_name = "a.out", exe_name = None,
bkpt_module = None, bkpt_module = None,
in_cwd = True, in_cwd = True,
only_one_thread = True, only_one_thread = True,
extra_images = None): extra_images = None):
"""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 name on bkpt_name restricted to bkpt_module. a breakpoint set by name on bkpt_name restricted to bkpt_module.
If you want to pass in launch arguments or environment If you want to pass in launch arguments or environment
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Linesdef run_to_source_breakpoint(test, bkpt_pattern, source_spec,
if has_locations_before_run: if has_locations_before_run:
test.assertTrue(breakpoint.GetNumLocations() > 0, test.assertTrue(breakpoint.GetNumLocations() > 0,
'No locations found for source breakpoint: "%s", file: "%s", dir: "%s"' 'No locations found for source breakpoint: "%s", file: "%s", dir: "%s"'
%(bkpt_pattern, source_spec.GetFilename(), source_spec.GetDirectory())) %(bkpt_pattern, source_spec.GetFilename(), source_spec.GetDirectory()))
return run_to_breakpoint_do_run(test, target, breakpoint, launch_info, return run_to_breakpoint_do_run(test, target, breakpoint, launch_info,
only_one_thread, extra_images) only_one_thread, extra_images)
def run_to_line_breakpoint(test, source_spec, line_number, column = 0, def run_to_line_breakpoint(test, source_spec, line_number, column = 0,
launch_info = None, exe_name = "a.out", launch_info = None, exe_name = None,
bkpt_module = None, bkpt_module = None,
in_cwd = True, in_cwd = True,
only_one_thread = True, only_one_thread = True,
extra_images = None): extra_images = None):
"""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_spec, line_number(, column)). a breakpoint set by (source_spec, line_number(, column)).
The rest of the behavior is the same as run_to_name_breakpoint. The rest of the behavior is the same as run_to_name_breakpoint.
▲ Show 20 Lines • Show All 512 Lines • ▼ Show 20 Linesdef set_actions_for_signal(testcase, signal_name, pass_action, stop_action, notify_action, expect_success=True):
return_obj = lldb.SBCommandReturnObject() return_obj = lldb.SBCommandReturnObject()
command = "process handle {0}".format(signal_name) command = "process handle {0}".format(signal_name)
if pass_action != None: if pass_action != None:
command += " -p {0}".format(pass_action) command += " -p {0}".format(pass_action)
if stop_action != None: if stop_action != None:
command += " -s {0}".format(stop_action) command += " -s {0}".format(stop_action)
if notify_action != None: if notify_action != None:
command +=" -n {0}".format(notify_action) command +=" -n {0}".format(notify_action)
testcase.dbg.GetCommandInterpreter().HandleCommand(command, return_obj) testcase.dbg.GetCommandInterpreter().HandleCommand(command, return_obj)
testcase.assertEqual(expect_success, testcase.assertEqual(expect_success,
return_obj.Succeeded(), return_obj.Succeeded(),
"Setting signal handling for {0} worked as expected".format(signal_name)) "Setting signal handling for {0} worked as expected".format(signal_name))
class PrintableRegex(object): class PrintableRegex(object):
def __init__(self, text): def __init__(self, text):
self.regex = re.compile(text) self.regex = re.compile(text)
self.text = text self.text = text
▲ Show 20 Lines • Show All 108 Lines • Show Last 20 Lines

lldb/packages/Python/lldbsuite/test/make/Makefile.rules

Show First 20 Lines • Show All 279 Lines • ▼ Show 20 Lines
LDFLAGS ?= $(CFLAGS) LDFLAGS ?= $(CFLAGS)
LDFLAGS += $(LD_EXTRAS) $(ARCH_LDFLAGS) LDFLAGS += $(LD_EXTRAS) $(ARCH_LDFLAGS)
ifeq (,$(filter $(OS), Windows_NT Android Darwin)) ifeq (,$(filter $(OS), Windows_NT Android Darwin))
ifneq (,$(filter YES,$(ENABLE_THREADS))) ifneq (,$(filter YES,$(ENABLE_THREADS)))
LDFLAGS += -pthread LDFLAGS += -pthread
endif endif
endif endif
OBJECTS = OBJECTS =
EXE ?= a.out EXE_NAME ?= a.out
EXE ?= $(EXE_NAME)
ifneq "$(FRAMEWORK)" "" ifneq "$(FRAMEWORK)" ""
DYLIB_NAME ?= $(FRAMEWORK).framework/Versions/A/$(FRAMEWORK) DYLIB_NAME ?= $(FRAMEWORK).framework/Versions/A/$(FRAMEWORK)
DYLIB_FILENAME ?= $(FRAMEWORK).framework/Versions/A/$(FRAMEWORK) DYLIB_FILENAME ?= $(FRAMEWORK).framework/Versions/A/$(FRAMEWORK)
endif endif
ifneq "$(DYLIB_NAME)" "" ifneq "$(DYLIB_NAME)" ""
ifeq "$(OS)" "Darwin" ifeq "$(OS)" "Darwin"
▲ Show 20 Lines • Show All 340 Lines • Show Last 20 Lines

lldb/test/API/api/check_public_api_headers/TestPublicAPIHeaders.py

Show All 26 Lines def test_sb_api_directory(self):
# 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.")
exe_name = self.getBuildArtifact("a.out") exe_name = self.getTestExecutable()
self.buildDriver(self.source, exe_name) self.buildDriver(self.source, exe_name)
self.sanity_check_executable(exe_name) self.sanity_check_executable(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_name = self.getBuildArtifact("a.out") exe_name = self.getTestExecutable()
exe = self.getBuildArtifact(exe_name) exe = self.getBuildArtifact(exe_name)
self.runCmd("file %s" % exe, CURRENT_EXECUTABLE_SET) self.runCmd("file %s" % exe, CURRENT_EXECUTABLE_SET)
# This test uses a generated source file, so it's in the build directory. # This test uses a generated source file, so it's in the build directory.
self.line_to_break = line_number( self.line_to_break = line_number(
self.getBuildArtifact(self.source), '// Set breakpoint here.') self.getBuildArtifact(self.source), '// Set breakpoint here.')
env_cmd = "settings set target.env-vars %s=%s" % ( env_cmd = "settings set target.env-vars %s=%s" % (
Show All 20 Lines

lldb/test/API/arm/breakpoint-it/TestBreakpointIt.py

Show All 13 Linesclass 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"]))
@skipIf(archs=["arm64", "arm64e", "arm64_32"]) @skipIf(archs=["arm64", "arm64e", "arm64_32"])
def test_false(self): def test_false(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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"]))
@skipIf(archs=["arm64", "arm64e", "arm64_32"]) @skipIf(archs=["arm64", "arm64e", "arm64_32"])
def test_true(self): def test_true(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/arm/breakpoint-thumb-codesection/TestBreakpointThumbCodesection.py

Show All 13 Linesclass TestBreakpointThumbCodesection(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipIf(archs=no_match(["arm"])) @skipIf(archs=no_match(["arm"]))
@skipIf(archs=["arm64"]) @skipIf(archs=["arm64"])
@skipIfDarwinEmbedded # codegen on darwin always defaults to thumb for armv7/armv7k targets @skipIfDarwinEmbedded # codegen on darwin always defaults to thumb for armv7/armv7k targets
def test_breakpoint(self): def test_breakpoint(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
line = line_number('main.c', '// Set break point at this line.') line = line_number('main.c', '// Set break point at this line.')
self.runCmd("target create %s" % exe) self.runCmd("target create %s" % exe)
bpid = lldbutil.run_break_set_by_file_and_line(self, "main.c", line) bpid = lldbutil.run_break_set_by_file_and_line(self, "main.c", line)
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), "Process is not stopped at breakpoint") self.process(), bpid), "Process is not stopped at breakpoint")
self.process().Continue() self.process().Continue()
self.assertEqual(self.process().GetState(), lldb.eStateExited, PROCESS_EXITED) self.assertEqual(self.process().GetState(), lldb.eStateExited, PROCESS_EXITED)

lldb/test/API/benchmarks/continue/TestBenchmarkContinue.py

Show All 22 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 "+self.getBuildArtifact("a.out"), self.runCmd("file "+self.getTestExecutable(),
CURRENT_EXECUTABLE_SET) 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)
Show All 33 Lines

lldb/test/API/benchmarks/libcxxlist/TestBenchmarkLibcxxList.py

Show All 22 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 " + self.getBuildArtifact("a.out"), self.runCmd("file " + self.getTestExecutable(),
CURRENT_EXECUTABLE_SET) 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)
Show All 26 Lines

lldb/test/API/benchmarks/libcxxmap/TestBenchmarkLibcxxMap.py

Show All 22 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 " +self.getBuildArtifact("a.out"), self.runCmd("file " +self.getTestExecutable(),
CURRENT_EXECUTABLE_SET) 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)
Show All 26 Lines

lldb/test/API/commands/apropos/with-process/TestAproposWithProcess.py

Show All 17 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 command.""" """Test that apropos env doesn't crash trying to touch the process plugin command."""
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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)
# 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'])
# The breakpoint should have a hit count of 1. # The breakpoint should have a hit count of 1.
lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1) lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
self.runCmd('apropos env') self.runCmd('apropos env')

lldb/test/API/commands/command/nested_alias/TestNestedAlias.py

Show All 17 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 20 Lines • Show All 71 Lines • Show Last 20 Lines

lldb/test/API/commands/command/script/TestCommandScript.py

Show All 35 Lines def pycmd_tests(self):
self.expect("ofoobar", substrs=["All good"]) self.expect("ofoobar", substrs=["All good"])
self.expect("ofoobar4", substrs=["All good"]) self.expect("ofoobar4", substrs=["All good"])
# 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 131 Lines • Show Last 20 Lines

lldb/test/API/commands/expression/formatters/TestFormatters.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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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 246 Lines • Show Last 20 Lines

lldb/test/API/commands/expression/ir-interpreter-phi-nodes/TestIRInterpreterPHINodes.py

Show All 9 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/commands/expression/ir-interpreter/TestIRInterpreter.py

Show All 26 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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 47 Lines • Show Last 20 Lines

lldb/test/API/commands/expression/multiline-completion/TestMultilineCompletion.py

Show All 30 Linesclass MultilineCompletionTest(PExpectTest):
@skipIfAsan @skipIfAsan
@skipIfEditlineSupportMissing @skipIfEditlineSupportMissing
@expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr49408') @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr49408')
@skipIf(oslist=["linux"], archs=["arm", "aarch64"]) @skipIf(oslist=["linux"], archs=["arm", "aarch64"])
def test_basic_completion(self): def test_basic_completion(self):
"""Test that we can complete a simple multiline expression""" """Test that we can complete a simple multiline expression"""
self.build() self.build()
self.launch(executable=self.getBuildArtifact("a.out"), dimensions=(100,500)) self.launch(executable=self.getTestExecutable(), dimensions=(100,500))
self.expect("b main", substrs=["Breakpoint 1", "address ="]) self.expect("b main", substrs=["Breakpoint 1", "address ="])
self.expect("run", substrs=["stop reason = breakpoint 1"]) self.expect("run", substrs=["stop reason = breakpoint 1"])
self.start_expression_editor() self.start_expression_editor()
self.child.send("to_\t") self.child.send("to_\t")
# editline might move the cursor back to the start of the line via \r # editline might move the cursor back to the start of the line via \r
# and then back to its original position. # and then back to its original position.
self.child.expect(re.compile(b"to_(\r" + self.cursor_forward_escape_seq(len(" 1: to_")) + b")?complete")) self.child.expect(re.compile(b"to_(\r" + self.cursor_forward_escape_seq(len(" 1: to_")) + b")?complete"))
Show All 15 Lines

lldb/test/API/commands/expression/options/TestExprOptions.py

Show All 20 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 = self.getBuildArtifact("a.out") self.exe = self.getTestExecutable()
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 20 Lines • Show All 53 Lines • Show Last 20 Lines

lldb/test/API/commands/expression/persist_objc_pointeetype/TestPersistObjCPointeeType.py

Show All 27 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/commands/expression/persistent_ptr_update/TestPersistentPtrUpdate.py

Show All 17 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/commands/expression/persistent_types/TestNestedPersistentTypes.py

Show All 12 Lines
class NestedPersistentTypesTestCase(TestBase): class NestedPersistentTypesTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/commands/expression/persistent_types/TestPersistentTypes.py

Show All 12 Lines
class PersistenttypesTestCase(TestBase): class PersistenttypesTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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 63 Lines • Show Last 20 Lines

lldb/test/API/commands/expression/po_verbosity/TestPoVerbosity.py

Show All 30 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/commands/expression/radar_8638051/Test8638051.py

Show All 10 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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_expr("val", result_type="int", result_value="1") self.expect_expr("val", result_type="int", result_value="1")
self.expect_expr("*(&val)", result_type="int", result_value="1") self.expect_expr("*(&val)", result_type="int", result_value="1")
# rdar://problem/8638051 # rdar://problem/8638051
# lldb expression command: Could this crash be avoided # lldb expression command: Could this crash be avoided
self.expect("expression &val", self.expect("expression &val",
startstr="(int *) $2 = ") startstr="(int *) $2 = ")
# (int *) $2 = 0x.... # (int *) $2 = 0x....

lldb/test/API/commands/expression/radar_9531204/TestPrintfAfterUp.py

Show All 13 Linesclass Radar9531204TestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
# rdar://problem/9531204 # rdar://problem/9531204
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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/commands/expression/radar_9673664/TestExprHelpExamples.py

Show All 19 Lines def setUp(self):
# Find the line number to break inside main(). # Find the line number to break inside main().
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.')
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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/commands/expression/test/TestExprs.py

Show All 36 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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)
@expectedFailure( @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 118 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
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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/commands/expression/test/TestExprs2.py

Show All 20 Lines def setUp(self):
self.line = line_number( self.line = line_number(
'main.cpp', 'main.cpp',
'// Please test many expressions while stopped at this line:') '// Please test many expressions while stopped at this line:')
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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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 17 Lines def test_more_expr_commands(self):
# (int) $5 = 6 # (int) $5 = 6
@skipIfLinux @skipIfLinux
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489")
def test_expr_symbols(self): def test_expr_symbols(self):
"""Test symbols.""" """Test symbols."""
self.build() self.build()
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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)
# Do anonymous symbols work? # Do anonymous symbols work?
self.expect("expression ((char**)environ)[0]", self.expect("expression ((char**)environ)[0]",
startstr="(char *) $0 = 0x") startstr="(char *) $0 = 0x")
# (char *) $1 = 0x00007fff5fbff298 "Apple_PubSub_Socket_Render=/tmp/launch-7AEsUD/Render" # (char *) $1 = 0x00007fff5fbff298 "Apple_PubSub_Socket_Render=/tmp/launch-7AEsUD/Render"

lldb/test/API/commands/expression/top-level/TestTopLevelExprs.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 top-level expressions.""" """Test top-level expressions."""
self.build() self.build()
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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 " + self.getBuildArtifact("dummy"), self.runCmd("file " + self.getBuildArtifact("dummy"),
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

lldb/test/API/commands/expression/two-files/TestObjCTypeQueryFromOtherCompileUnit.py

Show All 21 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'.")
@add_test_categories(["objc"]) @add_test_categories(["objc"])
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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/commands/frame/diagnose/array/TestArray.py

Show All 10 Lines
class TestArray(TestBase): class TestArray(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipUnlessDarwin @skipUnlessDarwin
@skipIf(archs=no_match(['x86_64'])) # <rdar://problem/33842388> frame diagnose doesn't work for armv7 or arm64 @skipIf(archs=no_match(['x86_64'])) # <rdar://problem/33842388> frame diagnose doesn't work for armv7 or arm64
def test_array(self): def test_array(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/commands/frame/diagnose/bad-reference/TestBadReference.py

Show All 11 Lines
class TestBadReference(TestBase): class TestBadReference(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipUnlessDarwin @skipUnlessDarwin
@skipIf(archs=no_match(['x86_64'])) # <rdar://problem/33842388> frame diagnose doesn't work for armv7 or arm64 @skipIf(archs=no_match(['x86_64'])) # <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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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", self.expect("frame diagnose", "Crash diagnosis was accurate",
substrs=["f->b"]) substrs=["f->b"])

lldb/test/API/commands/frame/diagnose/complicated-expression/TestComplicatedExpression.py

Show All 11 Lines
class TestDiagnoseDereferenceArgument(TestBase): class TestDiagnoseDereferenceArgument(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipUnlessDarwin @skipUnlessDarwin
@skipIf(archs=no_match(['x86_64'])) # <rdar://problem/33842388> frame diagnose doesn't work for armv7 or arm64 @skipIf(archs=no_match(['x86_64'])) # <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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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=["f->b->d"]) substrs=["f->b->d"])

lldb/test/API/commands/frame/diagnose/dereference-argument/TestDiagnoseDereferenceArgument.py

Show All 11 Lines
class TestDiagnoseDereferenceArgument(TestBase): class TestDiagnoseDereferenceArgument(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipUnlessDarwin @skipUnlessDarwin
@skipIf(archs=no_match(['x86_64'])) # <rdar://problem/33842388> frame diagnose doesn't work for armv7 or arm64 @skipIf(archs=no_match(['x86_64'])) # <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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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=["f->b->d"]) substrs=["f->b->d"])

lldb/test/API/commands/frame/diagnose/dereference-function-return/TestDiagnoseDereferenceFunctionReturn.py

Show All 12 Linesclass TestDiagnoseDereferenceFunctionReturn(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipUnlessDarwin @skipUnlessDarwin
@skipIf(archs=no_match(['x86_64'])) # <rdar://problem/33842388> frame diagnose doesn't work for armv7 or arm64 @skipIf(archs=no_match(['x86_64'])) # <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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/commands/frame/diagnose/dereference-this/TestDiagnoseDereferenceThis.py

Show All 11 Lines
class TestDiagnoseDereferenceThis(TestBase): class TestDiagnoseDereferenceThis(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipUnlessDarwin @skipUnlessDarwin
@skipIf(archs=no_match(['x86_64'])) # <rdar://problem/33842388> frame diagnose doesn't work for armv7 or arm64 @skipIf(archs=no_match(['x86_64'])) # <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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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=["this->a"]) substrs=["this->a"])

lldb/test/API/commands/frame/diagnose/inheritance/TestDiagnoseInheritance.py

Show All 11 Lines
class TestDiagnoseInheritance(TestBase): class TestDiagnoseInheritance(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipUnlessDarwin @skipUnlessDarwin
@skipIf(archs=no_match(['x86_64'])) # <rdar://problem/33842388> frame diagnose doesn't work for armv7 or arm64 @skipIf(archs=no_match(['x86_64'])) # <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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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", self.expect("frame diagnose", "Crash diagnosis was accurate",
substrs=["d"]) substrs=["d"])

lldb/test/API/commands/frame/diagnose/local-variable/TestLocalVariable.py

Show All 11 Lines
class TestLocalVariable(TestBase): class TestLocalVariable(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipUnlessDarwin @skipUnlessDarwin
@skipIf(archs=no_match(['x86_64'])) # <rdar://problem/33842388> frame diagnose doesn't work for armv7 or arm64 @skipIf(archs=no_match(['x86_64'])) # <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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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", self.expect("frame diagnose", "Crash diagnosis was accurate",
substrs=["myInt"]) substrs=["myInt"])

lldb/test/API/commands/frame/diagnose/virtual-method-call/TestDiagnoseDereferenceVirtualMethodCall.py

Show All 11 Lines
class TestDiagnoseVirtualMethodCall(TestBase): class TestDiagnoseVirtualMethodCall(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipUnlessDarwin @skipUnlessDarwin
@skipIf(archs=no_match(['x86_64'])) # <rdar://problem/33842388> frame diagnose doesn't work for armv7 or arm64 @skipIf(archs=no_match(['x86_64'])) # <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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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", self.expect("frame diagnose", "Crash diagnosis was accurate",
substrs=["foo"]) substrs=["foo"])

lldb/test/API/commands/frame/recognizer/TestFrameRecognizer.py

Show All 12 Lines
class FrameRecognizerTestCase(TestBase): class FrameRecognizerTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
@skipUnlessDarwin @skipUnlessDarwin
def test_frame_recognizer_1(self): def test_frame_recognizer_1(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# Clear internal & plugins recognizers that get initialized at launch # Clear internal & plugins recognizers that get initialized at launch
self.runCmd("frame recognizer clear") self.runCmd("frame recognizer clear")
self.runCmd("command script import " + os.path.join(self.getSourceDir(), "recognizer.py")) self.runCmd("command script import " + os.path.join(self.getSourceDir(), "recognizer.py"))
self.expect("frame recognizer list", self.expect("frame recognizer list",
substrs=['no matching results found.']) substrs=['no matching results found.'])
▲ Show 20 Lines • Show All 97 Lines • ▼ Show 20 Lines def test_frame_recognizer_1(self):
self.expect("frame variable -t *a", self.expect("frame variable -t *a",
substrs=['*a = 78']) substrs=['*a = 78'])
""" """
@skipUnlessDarwin @skipUnlessDarwin
def test_frame_recognizer_multi_symbol(self): def test_frame_recognizer_multi_symbol(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# Clear internal & plugins recognizers that get initialized at launch # Clear internal & plugins recognizers that get initialized at launch
self.runCmd("frame recognizer clear") self.runCmd("frame recognizer clear")
self.runCmd("command script import " + os.path.join(self.getSourceDir(), "recognizer.py")) self.runCmd("command script import " + os.path.join(self.getSourceDir(), "recognizer.py"))
self.expect("frame recognizer list", self.expect("frame recognizer list",
substrs=['no matching results found.']) substrs=['no matching results found.'])
Show All 15 Lines def test_frame_recognizer_multi_symbol(self):
frame = thread.GetSelectedFrame() frame = thread.GetSelectedFrame()
self.expect("frame recognizer info 0", self.expect("frame recognizer info 0",
substrs=['frame 0 is recognized by recognizer.MyFrameRecognizer']) substrs=['frame 0 is recognized by recognizer.MyFrameRecognizer'])
@skipUnlessDarwin @skipUnlessDarwin
def test_frame_recognizer_target_specific(self): def test_frame_recognizer_target_specific(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# Clear internal & plugins recognizers that get initialized at launch # Clear internal & plugins recognizers that get initialized at launch
self.runCmd("frame recognizer clear") self.runCmd("frame recognizer clear")
# Create a target. # Create a target.
target, process, thread, _ = lldbutil.run_to_name_breakpoint(self, "foo", target, process, thread, _ = lldbutil.run_to_name_breakpoint(self, "foo",
exe_name = exe) exe_name = exe)
Show All 27 Lines def test_frame_recognizer_target_specific(self):
# Now the new target should also recognize the frame. # Now the new target should also recognize the frame.
self.expect("frame recognizer info 0", self.expect("frame recognizer info 0",
substrs=['frame 0 is recognized by recognizer.MyFrameRecognizer']) substrs=['frame 0 is recognized by recognizer.MyFrameRecognizer'])
@skipUnlessDarwin @skipUnlessDarwin
def test_frame_recognizer_not_only_first_instruction(self): def test_frame_recognizer_not_only_first_instruction(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# Clear internal & plugins recognizers that get initialized at launch. # Clear internal & plugins recognizers that get initialized at launch.
self.runCmd("frame recognizer clear") self.runCmd("frame recognizer clear")
self.runCmd("command script import " + os.path.join(self.getSourceDir(), "recognizer.py")) self.runCmd("command script import " + os.path.join(self.getSourceDir(), "recognizer.py"))
self.expect("frame recognizer list", self.expect("frame recognizer list",
substrs=['no matching results found.']) substrs=['no matching results found.'])
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

lldb/test/API/commands/gui/basic/TestGuiBasic.py

Show All 13 Linesclass BasicGuiCommandTest(PExpectTest):
# PExpect uses many timeouts internally and doesn't play well # PExpect uses many timeouts internally and doesn't play well
# under ASAN on a loaded machine.. # under ASAN on a loaded machine..
@skipIfAsan @skipIfAsan
@skipIfCursesSupportMissing @skipIfCursesSupportMissing
@skipIf(oslist=["linux"], archs=["arm", "aarch64"]) @skipIf(oslist=["linux"], archs=["arm", "aarch64"])
def test_gui(self): def test_gui(self):
self.build() self.build()
self.launch(executable=self.getBuildArtifact("a.out"), dimensions=(100,500)) self.launch(executable=self.getTestExecutable(), dimensions=(100,500))
self.expect('br set -f main.c -p "// Break here"', substrs=["Breakpoint 1", "address ="]) self.expect('br set -f main.c -p "// Break here"', substrs=["Breakpoint 1", "address ="])
self.expect("run", substrs=["stop reason ="]) self.expect("run", substrs=["stop reason ="])
escape_key = chr(27).encode() escape_key = chr(27).encode()
# Start the GUI. # Start the GUI.
self.child.sendline("gui") self.child.sendline("gui")
Show All 25 Lines

lldb/test/API/commands/gui/basicdebug/TestGuiBasicDebug.py

Show All 13 Linesclass TestGuiBasicDebugCommandTest(PExpectTest):
# PExpect uses many timeouts internally and doesn't play well # PExpect uses many timeouts internally and doesn't play well
# under ASAN on a loaded machine.. # under ASAN on a loaded machine..
@skipIfAsan @skipIfAsan
@skipIf(bugnumber="llvm.org/pr51833") @skipIf(bugnumber="llvm.org/pr51833")
@skipIfCursesSupportMissing @skipIfCursesSupportMissing
def test_gui(self): def test_gui(self):
self.build() self.build()
self.launch(executable=self.getBuildArtifact("a.out"), dimensions=(100,500)) self.launch(executable=self.getTestExecutable(), dimensions=(100,500))
self.expect('br set -f main.c -p "// Break here"', substrs=["Breakpoint 1", "address ="]) self.expect('br set -f main.c -p "// Break here"', substrs=["Breakpoint 1", "address ="])
self.expect("run", substrs=["stop reason ="]) self.expect("run", substrs=["stop reason ="])
escape_key = chr(27).encode() escape_key = chr(27).encode()
# Start the GUI. # Start the GUI.
self.child.sendline("gui") self.child.sendline("gui")
Show All 31 Lines

lldb/test/API/commands/gui/breakpoints/TestGuiBreakpoints.py

Show All 13 Linesclass TestGuiBasicDebugCommandTest(PExpectTest):
# PExpect uses many timeouts internally and doesn't play well # PExpect uses many timeouts internally and doesn't play well
# under ASAN on a loaded machine.. # under ASAN on a loaded machine..
@skipIfAsan @skipIfAsan
@skipIfCursesSupportMissing @skipIfCursesSupportMissing
@skipIf(oslist=["linux"], archs=["arm", "aarch64"]) @skipIf(oslist=["linux"], archs=["arm", "aarch64"])
def test_gui(self): def test_gui(self):
self.build() self.build()
self.launch(executable=self.getBuildArtifact("a.out"), dimensions=(100,500)) self.launch(executable=self.getTestExecutable(), dimensions=(100,500))
self.expect('br set -o true -f main.c -p "// First break here"', substrs=["Breakpoint 1", "address ="]) self.expect('br set -o true -f main.c -p "// First break here"', substrs=["Breakpoint 1", "address ="])
self.expect("run", substrs=["stop reason ="]) self.expect("run", substrs=["stop reason ="])
self.child.sendline("breakpoint list") self.child.sendline("breakpoint list")
self.child.expect_exact("No breakpoints currently set.") self.child.expect_exact("No breakpoints currently set.")
escape_key = chr(27).encode() escape_key = chr(27).encode()
down_key = chr(27)+'OB' # for vt100 terminal (lldbexpect sets TERM=vt100) down_key = chr(27)+'OB' # for vt100 terminal (lldbexpect sets TERM=vt100)
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

lldb/test/API/commands/gui/expand-threads-tree/TestGuiExpandThreadsTree.py

Show All 15 Linesclass TestGuiExpandThreadsTree(PExpectTest):
# PExpect uses many timeouts internally and doesn't play well # PExpect uses many timeouts internally and doesn't play well
# under ASAN on a loaded machine.. # under ASAN on a loaded machine..
@skipIfAsan @skipIfAsan
@skipIfCursesSupportMissing @skipIfCursesSupportMissing
@skipIf(oslist=["linux"], archs=["arm", "aarch64"]) @skipIf(oslist=["linux"], archs=["arm", "aarch64"])
def test_gui(self): def test_gui(self):
self.build() self.build()
self.launch(executable=self.getBuildArtifact("a.out"), dimensions=(100,500)) self.launch(executable=self.getTestExecutable(), dimensions=(100,500))
self.expect("breakpoint set -n break_here", substrs=["Breakpoint 1", "address ="]) self.expect("breakpoint set -n break_here", substrs=["Breakpoint 1", "address ="])
self.expect("run", substrs=["stop reason ="]) self.expect("run", substrs=["stop reason ="])
escape_key = chr(27).encode() escape_key = chr(27).encode()
# Start the GUI and close the welcome window. # Start the GUI and close the welcome window.
self.child.sendline("gui") self.child.sendline("gui")
self.child.send(escape_key) self.child.send(escape_key)
Show All 24 Lines

lldb/test/API/commands/gui/viewlarge/TestGuiViewLarge.py

Show All 16 Linesclass GuiViewLargeCommandTest(PExpectTest):
@skipIfCursesSupportMissing @skipIfCursesSupportMissing
@skipIfRemote # "run" command will not work correctly for remote debug @skipIfRemote # "run" command will not work correctly for remote debug
@expectedFailureNetBSD @expectedFailureNetBSD
@skipIf(oslist=["linux"], archs=["arm", "aarch64"]) @skipIf(oslist=["linux"], archs=["arm", "aarch64"])
def test_gui(self): def test_gui(self):
self.build() self.build()
# Limit columns to 80, so that long lines will not be displayed completely. # Limit columns to 80, so that long lines will not be displayed completely.
self.launch(executable=self.getBuildArtifact("a.out"), dimensions=(100,80)) self.launch(executable=self.getTestExecutable(), dimensions=(100,80))
self.expect('br set -f main.c -p "// Break here"', substrs=["Breakpoint 1", "address ="]) self.expect('br set -f main.c -p "// Break here"', substrs=["Breakpoint 1", "address ="])
self.expect("run", substrs=["stop reason ="]) self.expect("run", substrs=["stop reason ="])
escape_key = chr(27).encode() escape_key = chr(27).encode()
left_key = chr(27)+'OD' # for vt100 terminal (lldbexpect sets TERM=vt100) left_key = chr(27)+'OD' # for vt100 terminal (lldbexpect sets TERM=vt100)
right_key = chr(27)+'OC' right_key = chr(27)+'OC'
ctrl_l = chr(12) ctrl_l = chr(12)
Show All 37 Lines

lldb/test/API/commands/log/basic/TestLogging.py

Show All 17 Linesclass LogTestCase(TestBase):
def setUp(self): def setUp(self):
super(LogTestCase, self).setUp() super(LogTestCase, self).setUp()
self.log_file = self.getBuildArtifact("log-file.txt") self.log_file = self.getBuildArtifact("log-file.txt")
def test_file_writing(self): def test_file_writing(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
self.expect("file " + exe, self.expect("file " + exe,
patterns=["Current executable set to .*a.out"]) patterns=["Current executable set to .*a.out"])
if (os.path.exists(self.log_file)): if (os.path.exists(self.log_file)):
os.remove(self.log_file) os.remove(self.log_file)
# By default, Debugger::EnableLog() will set log options to # By default, Debugger::EnableLog() will set log options to
# PREPEND_THREAD_NAME + OPTION_THREADSAFE. We don't want the # PREPEND_THREAD_NAME + OPTION_THREADSAFE. We don't want the
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

lldb/test/API/commands/memory/write/TestMemoryWrite.py

Show All 15 Linesclass MemoryWriteTestCase(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 build_run_stop(self): def build_run_stop(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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(self, lldbutil.run_break_set_by_file_and_line(self,
"main.c", "main.c",
self.line, self.line,
num_expected_locations=1, num_expected_locations=1,
loc_exact=True) loc_exact=True)
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

lldb/test/API/commands/platform/connect/TestPlatformConnect.py

Show All 22 Lines def test_platform_process_connect(self):
port_file = self.getBuildArtifact("port") port_file = self.getBuildArtifact("port")
commandline_args = [ commandline_args = [
"platform", "platform",
"--listen", "--listen",
listen_url, listen_url,
"--socket-file", "--socket-file",
port_file, port_file,
"--", "--",
self.getBuildArtifact("a.out"), self.getTestExecutable(),
"foo"] "foo"]
self.spawnSubprocess( self.spawnSubprocess(
lldbgdbserverutils.get_lldb_server_exe(), lldbgdbserverutils.get_lldb_server_exe(),
commandline_args) commandline_args)
socket_id = lldbutil.wait_for_file_on_target(self, port_file) socket_id = lldbutil.wait_for_file_on_target(self, port_file)
new_platform = lldb.SBPlatform("remote-" + self.getPlatform()) new_platform = lldb.SBPlatform("remote-" + self.getPlatform())
Show All 14 Lines

lldb/test/API/commands/process/launch/TestProcessLaunch.py

Show All 26 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)
@skipIfRemote @skipIfRemote
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
self.expect("file " + exe, self.expect("file " + exe,
patterns=["Current executable set to .*a.out"]) patterns=["Current executable set to .*a.out"])
in_file = os.path.join(self.getSourceDir(), "input-file.txt") in_file = os.path.join(self.getSourceDir(), "input-file.txt")
out_file = lldbutil.append_to_process_working_directory(self, "output-test.out") out_file = lldbutil.append_to_process_working_directory(self, "output-test.out")
err_file = lldbutil.append_to_process_working_directory(self, "output-test.err") err_file = lldbutil.append_to_process_working_directory(self, "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 All 40 Linesclass ProcessLaunchTestCase(TestBase):
@skipIfRemote @skipIfRemote
@expectedFailureAll(oslist=["freebsd", "linux"], bugnumber="llvm.org/pr20265") @expectedFailureAll(oslist=["freebsd", "linux"], bugnumber="llvm.org/pr20265")
@expectedFailureNetBSD @expectedFailureNetBSD
def test_set_working_dir_nonexisting(self): def test_set_working_dir_nonexisting(self):
"""Test that '-w dir' fails to set the working dir when running the inferior with a dir which doesn't exist.""" """Test that '-w dir' fails to set the working dir when running the inferior with a dir which doesn't exist."""
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 = self.getBuildArtifact(mywd) my_working_dir_path = self.getBuildArtifact(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 All 10 Lines def test_set_working_dir_nonexisting(self):
invalid_dir_path]) invalid_dir_path])
@skipIfRemote @skipIfRemote
def test_set_working_dir_existing(self): def test_set_working_dir_existing(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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 = self.getBuildArtifact(mywd) my_working_dir_path = self.getBuildArtifact(mywd)
lldbutil.mkdir_p(my_working_dir_path) lldbutil.mkdir_p(my_working_dir_path)
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

lldb/test/API/commands/register/register/aarch64_dynamic_regset/TestArm64DynamicRegsets.py

Show First 20 Lines • Show All 68 Lines • ▼ Show 20 Linesclass RegisterCommandsTestCase(TestBase):
@no_debug_info_test @no_debug_info_test
@skipIf(archs=no_match(["aarch64"])) @skipIf(archs=no_match(["aarch64"]))
@skipIf(oslist=no_match(['linux'])) @skipIf(oslist=no_match(['linux']))
def test_aarch64_dynamic_regset_config(self): def test_aarch64_dynamic_regset_config(self):
"""Test AArch64 Dynamic Register sets configuration.""" """Test AArch64 Dynamic Register sets configuration."""
self.build() self.build()
self.line = line_number('main.c', '// Set a break point here.') self.line = line_number('main.c', '// Set a break point here.')
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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) self, "main.c", self.line, num_expected_locations=1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT,
substrs=["stop reason = breakpoint 1."]) substrs=["stop reason = breakpoint 1."])
Show All 24 Lines

lldb/test/API/commands/register/register/aarch64_sve_registers/rw_access_dynamic_resize/TestSVEThreadedDynamic.py

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Linesclass RegisterCommandsTestCase(TestBase):
@no_debug_info_test @no_debug_info_test
@skipIf(archs=no_match(["aarch64"])) @skipIf(archs=no_match(["aarch64"]))
@skipIf(oslist=no_match(['linux'])) @skipIf(oslist=no_match(['linux']))
def test_sve_registers_dynamic_config(self): def test_sve_registers_dynamic_config(self):
"""Test AArch64 SVE registers multi-threaded dynamic resize. """ """Test AArch64 SVE registers multi-threaded dynamic resize. """
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
if not self.isAArch64SVE(): if not self.isAArch64SVE():
self.skipTest('SVE registers must be supported.') self.skipTest('SVE registers must be supported.')
main_thread_stop_line = line_number( main_thread_stop_line = line_number(
"main.c", "// Break in main thread") "main.c", "// Break in main thread")
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

lldb/test/API/commands/register/register/aarch64_sve_registers/rw_access_static_config/TestSVERegisters.py

Show First 20 Lines • Show All 66 Lines • ▼ Show 20 Linesclass RegisterCommandsTestCase(TestBase):
@no_debug_info_test @no_debug_info_test
@skipIf(archs=no_match(["aarch64"])) @skipIf(archs=no_match(["aarch64"]))
@skipIf(oslist=no_match(['linux'])) @skipIf(oslist=no_match(['linux']))
def test_sve_registers_configuration(self): def test_sve_registers_configuration(self):
"""Test AArch64 SVE registers size configuration.""" """Test AArch64 SVE registers size configuration."""
self.build() self.build()
self.line = line_number('main.c', '// Set a break point here.') self.line = line_number('main.c', '// Set a break point here.')
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
if not self.isAArch64SVE(): if not self.isAArch64SVE():
self.skipTest('SVE registers must be supported.') self.skipTest('SVE registers must be supported.')
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) self, "main.c", self.line, num_expected_locations=1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 38 Linesclass RegisterCommandsTestCase(TestBase):
@no_debug_info_test @no_debug_info_test
@skipIf(archs=no_match(["aarch64"])) @skipIf(archs=no_match(["aarch64"]))
@skipIf(oslist=no_match(['linux'])) @skipIf(oslist=no_match(['linux']))
def test_sve_registers_read_write(self): def test_sve_registers_read_write(self):
"""Test AArch64 SVE registers read and write.""" """Test AArch64 SVE registers read and write."""
self.build() self.build()
self.line = line_number('main.c', '// Set a break point here.') self.line = line_number('main.c', '// Set a break point here.')
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
if not self.isAArch64SVE(): if not self.isAArch64SVE():
self.skipTest('SVE registers must be supported.') self.skipTest('SVE registers must be supported.')
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) self, "main.c", self.line, num_expected_locations=1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 40 Lines

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

Show First 20 Lines • Show All 127 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 315 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", self.expect("register read rax",
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# Spawn a new process # Spawn a new process
pid = self.spawnSubprocess(exe, ['wait_for_attach']).pid pid = self.spawnSubprocess(exe, ['wait_for_attach']).pid
if self.TraceOn(): if self.TraceOn():
print("pid of spawned process: %d" % pid) print("pid of spawned process: %d" % pid)
self.runCmd("process attach -p %d" % pid) self.runCmd("process attach -p %d" % pid)
Show All 37 Lines

lldb/test/API/commands/settings/TestSettings.py

Show All 23 Lines def test_apropos_should_also_search_settings_description(self):
substrs=["target.env-vars", substrs=["target.env-vars",
"environment variables", "environment variables",
"executable's environment"]) "executable's environment"])
def test_set_interpreter_repeat_prev_command(self): def test_set_interpreter_repeat_prev_command(self):
"""Test the `interpreter.repeat-previous-command` setting.""" """Test the `interpreter.repeat-previous-command` setting."""
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
setting = "interpreter.repeat-previous-command" setting = "interpreter.repeat-previous-command"
def cleanup(setting): def cleanup(setting):
self.runCmd( self.runCmd(
"settings clear %s" % "settings clear %s" %
setting, check=False) setting, check=False)
▲ Show 20 Lines • Show All 101 Lines • ▼ Show 20 Lines def test_set_term_width(self):
substrs=["term-width (int) = 70"]) substrs=["term-width (int) = 70"])
# rdar://problem/10712130 # rdar://problem/10712130
@skipIf(oslist=["windows"], bugnumber="llvm.org/pr44431") @skipIf(oslist=["windows"], bugnumber="llvm.org/pr44431")
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 20 Lines def test_set_frame_format(self):
RUN_SUCCEEDED) RUN_SUCCEEDED)
self.expect("thread backtrace", self.expect("thread backtrace",
substrs=["`main", self.getSourceDir()]) substrs=["`main", self.getSourceDir()])
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 33 Lines def do_test_run_args_and_env_vars(self, use_launchsimple):
# 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')
self.addTearDownHook( self.addTearDownHook(
lambda: self.runCmd("settings clear target.env-vars")) lambda: self.runCmd("settings clear target.env-vars"))
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
target = self.dbg.GetTargetAtIndex(0) target = self.dbg.GetTargetAtIndex(0)
launch_info = target.GetLaunchInfo() launch_info = target.GetLaunchInfo()
found_env_var = False found_env_var = False
for i in range(0, launch_info.GetNumEnvironmentEntries()): for i in range(0, launch_info.GetNumEnvironmentEntries()):
if launch_info.GetEnvironmentEntryAtIndex(i) == "MY_ENV_VAR=YES": if launch_info.GetEnvironmentEntryAtIndex(i) == "MY_ENV_VAR=YES":
found_env_var = True found_env_var = True
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Lines def test_pass_host_env_vars(self):
os.environ["MY_HOST_ENV_VAR2"] = "VAR2" os.environ["MY_HOST_ENV_VAR2"] = "VAR2"
# This is the function to unset the two env variables set above. # This is the function to unset the two env variables set above.
def unset_env_variables(): def unset_env_variables():
os.environ.pop("MY_HOST_ENV_VAR1") os.environ.pop("MY_HOST_ENV_VAR1")
os.environ.pop("MY_HOST_ENV_VAR2") os.environ.pop("MY_HOST_ENV_VAR2")
self.addTearDownHook(unset_env_variables) self.addTearDownHook(unset_env_variables)
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 20 Lines • Show All 69 Lines • ▼ Show 20 Lines def test_pass_host_env_vars(self):
substrs=[ substrs=[
"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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 '{0}'".format( self.runCmd("settings set target.error-path '{0}'".format(
lldbutil.append_to_process_working_directory(self, "stderr.txt"))) lldbutil.append_to_process_working_directory(self, "stderr.txt")))
self.runCmd("settings set target.output-path '{0}".format( self.runCmd("settings set target.output-path '{0}".format(
lldbutil.append_to_process_working_directory(self, "stdout.txt"))) lldbutil.append_to_process_working_directory(self, "stdout.txt")))
# And add hooks to restore the original settings during tearDown(). # And add hooks to restore the original settings during tearDown().
▲ Show 20 Lines • Show All 353 Lines • Show Last 20 Lines

lldb/test/API/commands/settings/quoting/TestQuoting.py

Show All 15 Linesclass SettingsCommandTestCase(TestBase):
@classmethod @classmethod
def classCleanup(cls): def classCleanup(cls):
"""Cleanup the test byproducts.""" """Cleanup the test byproducts."""
cls.RemoveTempFile(SettingsCommandTestCase.output_file_name) cls.RemoveTempFile(SettingsCommandTestCase.output_file_name)
@no_debug_info_test @no_debug_info_test
def test(self): def test(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# No quotes. # No quotes.
self.expect_args("a b c", "a\0b\0c\0") self.expect_args("a b c", "a\0b\0c\0")
# Single quotes. # Single quotes.
self.expect_args("'a b c'", "a b c\0") self.expect_args("'a b c'", "a b c\0")
# Double quotes. # Double quotes.
self.expect_args('"a b c"', "a b c\0") self.expect_args('"a b c"', "a b c\0")
Show All 39 Lines

lldb/test/API/commands/statistics/basic/TestStats.py

Show First 20 Lines • Show All 258 Lines • ▼ Show 20 Lines def test_default_with_run(self):
self.assertGreater(stats['launchOrAttachTime'], 0.0) self.assertGreater(stats['launchOrAttachTime'], 0.0)
self.assertGreater(stats['targetCreateTime'], 0.0) self.assertGreater(stats['targetCreateTime'], 0.0)
def test_memory(self): def test_memory(self):
""" """
Test "statistics dump" and the memory information. Test "statistics dump" and the memory information.
""" """
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
target = self.createTestTarget(file_path=exe) target = self.createTestTarget(file_path=exe)
debug_stats = self.get_stats() debug_stats = self.get_stats()
debug_stat_keys = [ debug_stat_keys = [
'memory', 'memory',
'modules', 'modules',
'targets', 'targets',
'totalSymbolTableParseTime', 'totalSymbolTableParseTime',
'totalSymbolTableIndexTime', 'totalSymbolTableIndexTime',
Show All 36 Lines def find_module_by_id_in_metrics(self, id, stats):
return module return module
return None return None
def test_modules(self): def test_modules(self):
""" """
Test "statistics dump" and the module information. Test "statistics dump" and the module information.
""" """
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
target = self.createTestTarget(file_path=exe) target = self.createTestTarget(file_path=exe)
debug_stats = self.get_stats() debug_stats = self.get_stats()
debug_stat_keys = [ debug_stat_keys = [
'memory', 'memory',
'modules', 'modules',
'targets', 'targets',
'totalSymbolTableParseTime', 'totalSymbolTableParseTime',
'totalSymbolTableIndexTime', 'totalSymbolTableIndexTime',
▲ Show 20 Lines • Show All 226 Lines • Show Last 20 Lines

lldb/test/API/commands/target/auto-install-main-executable/TestAutoInstallMainExecutable.py

Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Lines def test_target_auto_install_main_executable(self):
# Disable the auto install. # Disable the auto install.
self.runCmd("settings set target.auto-install-main-executable false") self.runCmd("settings set target.auto-install-main-executable false")
self.expect("settings show target.auto-install-main-executable", self.expect("settings show target.auto-install-main-executable",
substrs=["target.auto-install-main-executable (boolean) = false"]) substrs=["target.auto-install-main-executable (boolean) = false"])
# Create the target with the original file. # Create the target with the original file.
self.runCmd("target create --remote-file %s %s "% self.runCmd("target create --remote-file %s %s "%
(dest.fullpath, (dest.fullpath,
self.getBuildArtifact("a.out"))) self.getTestExecutable()))
self.expect("process launch", substrs=["exited with status = 74"]) self.expect("process launch", substrs=["exited with status = 74"])

lldb/test/API/commands/target/basic/TestTargetCommand.py

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines def test_target_variable_command_no_fail(self):
d = {'C_SOURCES': 'globals.c', 'EXE': self.getBuildArtifact('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 = self.getBuildArtifact("a.out") exe_a = self.getTestExecutable()
exe_b = self.getBuildArtifact("b.out") exe_b = self.getBuildArtifact("b.out")
exe_c = self.getBuildArtifact("c.out") exe_c = self.getBuildArtifact("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 All 36 Lines def do_target_command(self):
self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT,
substrs=['stop reason = breakpoint', 'b.c:%d' % self.line_b substrs=['stop reason = breakpoint', 'b.c:%d' % self.line_b
]) ])
self.runCmd("target list") self.runCmd("target list")
@no_debug_info_test @no_debug_info_test
def test_target_create_invalid_arch(self): def test_target_create_invalid_arch(self):
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
self.expect("target create {} --arch doesntexist".format(exe), error=True, self.expect("target create {} --arch doesntexist".format(exe), error=True,
patterns=["error: invalid triple 'doesntexist'"]) patterns=["error: invalid triple 'doesntexist'"])
@no_debug_info_test @no_debug_info_test
def test_target_create_platform(self): def test_target_create_platform(self):
self.buildB() self.buildB()
exe = self.getBuildArtifact("b.out") exe = self.getBuildArtifact("b.out")
self.expect("target create {} --platform host".format(exe)) self.expect("target create {} --platform host".format(exe))
▲ Show 20 Lines • Show All 257 Lines • ▼ Show 20 Lines def test_target_create_unreadable_sym_file(self):
tf = tempfile.NamedTemporaryFile() tf = tempfile.NamedTemporaryFile()
os.chmod(tf.name, stat.S_IWRITE) os.chmod(tf.name, stat.S_IWRITE)
self.expect("target create -s '" + tf.name + "' no_exe", error=True, self.expect("target create -s '" + tf.name + "' no_exe", error=True,
substrs=["Cannot open '", "': Permission denied"]) substrs=["Cannot open '", "': Permission denied"])
@no_debug_info_test @no_debug_info_test
def test_target_delete_all(self): def test_target_delete_all(self):
self.buildAll() self.buildAll()
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), CURRENT_EXECUTABLE_SET)
self.runCmd("file " + self.getBuildArtifact("b.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("b.out"), CURRENT_EXECUTABLE_SET)
self.expect("target delete --all") self.expect("target delete --all")
self.expect("target list", substrs=["No targets."]) self.expect("target list", substrs=["No targets."])
@no_debug_info_test @no_debug_info_test
def test_target_delete_by_index(self): def test_target_delete_by_index(self):
self.buildAll() self.buildAll()
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), CURRENT_EXECUTABLE_SET)
self.runCmd("file " + self.getBuildArtifact("b.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("b.out"), CURRENT_EXECUTABLE_SET)
self.runCmd("file " + self.getBuildArtifact("c.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("c.out"), CURRENT_EXECUTABLE_SET)
self.expect("target delete 3", error=True, self.expect("target delete 3", error=True,
substrs=["target index 3 is out of range, valid target indexes are 0 - 2"]) substrs=["target index 3 is out of range, valid target indexes are 0 - 2"])
self.runCmd("target delete 1") self.runCmd("target delete 1")
self.expect("target list", matching=False, substrs=["b.out"]) self.expect("target list", matching=False, substrs=["b.out"])
self.runCmd("target delete 1") self.runCmd("target delete 1")
self.expect("target list", matching=False, substrs=["c.out"]) self.expect("target list", matching=False, substrs=["c.out"])
self.expect("target delete 1", error=True, self.expect("target delete 1", error=True,
substrs=["target index 1 is out of range, the only valid index is 0"]) substrs=["target index 1 is out of range, the only valid index is 0"])
self.runCmd("target delete 0") self.runCmd("target delete 0")
self.expect("target list", matching=False, substrs=["a.out"]) self.expect("target list", matching=False, substrs=["a.out"])
self.expect("target delete 0", error=True, substrs=["no targets to delete"]) self.expect("target delete 0", error=True, substrs=["no targets to delete"])
self.expect("target delete 1", error=True, substrs=["no targets to delete"]) self.expect("target delete 1", error=True, substrs=["no targets to delete"])
@no_debug_info_test @no_debug_info_test
def test_target_delete_by_index_multiple(self): def test_target_delete_by_index_multiple(self):
self.buildAll() self.buildAll()
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), CURRENT_EXECUTABLE_SET)
self.runCmd("file " + self.getBuildArtifact("b.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("b.out"), CURRENT_EXECUTABLE_SET)
self.runCmd("file " + self.getBuildArtifact("c.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("c.out"), CURRENT_EXECUTABLE_SET)
self.expect("target delete 0 1 2 3", error=True, self.expect("target delete 0 1 2 3", error=True,
substrs=["target index 3 is out of range, valid target indexes are 0 - 2"]) substrs=["target index 3 is out of range, valid target indexes are 0 - 2"])
self.expect("target list", substrs=["a.out", "b.out", "c.out"]) self.expect("target list", substrs=["a.out", "b.out", "c.out"])
self.runCmd("target delete 0 1 2") self.runCmd("target delete 0 1 2")
self.expect("target list", matching=False, substrs=["a.out", "c.out"]) self.expect("target list", matching=False, substrs=["a.out", "c.out"])
@no_debug_info_test @no_debug_info_test
def test_target_delete_selected(self): def test_target_delete_selected(self):
self.buildAll() self.buildAll()
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), CURRENT_EXECUTABLE_SET)
self.runCmd("file " + self.getBuildArtifact("b.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("b.out"), CURRENT_EXECUTABLE_SET)
self.runCmd("file " + self.getBuildArtifact("c.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getBuildArtifact("c.out"), CURRENT_EXECUTABLE_SET)
self.runCmd("target select 1") self.runCmd("target select 1")
self.runCmd("target delete") self.runCmd("target delete")
self.expect("target list", matching=False, substrs=["b.out"]) self.expect("target list", matching=False, substrs=["b.out"])
self.runCmd("target delete") self.runCmd("target delete")
self.runCmd("target delete") self.runCmd("target delete")
self.expect("target list", substrs=["No targets."]) self.expect("target list", substrs=["No targets."])
Show All 31 Lines

lldb/test/API/commands/target/create-deps/TestTargetCreateDeps.py

Show All 29 Lines def has_exactly_one_image(self, matching, msg=""):
"image list", msg, matching=should_match, substrs=['[ 1]']) "image list", msg, matching=should_match, substrs=['[ 1]'])
@expectedFailureAll(oslist=["freebsd", "linux", "netbsd"], @expectedFailureAll(oslist=["freebsd", "linux", "netbsd"],
bugnumber='llvm.org/pr48372', bugnumber='llvm.org/pr48372',
triple=no_match(".*-android")) triple=no_match(".*-android"))
def test_dependents_implicit_default_exe(self): def test_dependents_implicit_default_exe(self):
"""Test default behavior""" """Test default behavior"""
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
self.runCmd("target create " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("target create " + exe, CURRENT_EXECUTABLE_SET)
self.has_exactly_one_image(False) self.has_exactly_one_image(False)
@expectedFailureAll(oslist=["freebsd", "linux", "netbsd"], @expectedFailureAll(oslist=["freebsd", "linux", "netbsd"],
bugnumber='llvm.org/pr48372', bugnumber='llvm.org/pr48372',
triple=no_match(".*-android")) triple=no_match(".*-android"))
def test_dependents_explicit_default_exe(self): def test_dependents_explicit_default_exe(self):
"""Test default behavior""" """Test default behavior"""
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
self.runCmd("target create -ddefault " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("target create -ddefault " + exe, CURRENT_EXECUTABLE_SET)
self.has_exactly_one_image(False) self.has_exactly_one_image(False)
def test_dependents_explicit_true_exe(self): def test_dependents_explicit_true_exe(self):
"""Test default behavior""" """Test default behavior"""
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
self.runCmd("target create -dtrue " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("target create -dtrue " + exe, CURRENT_EXECUTABLE_SET)
self.has_exactly_one_image(True) self.has_exactly_one_image(True)
@expectedFailureAll(oslist=["freebsd", "linux", "netbsd"], @expectedFailureAll(oslist=["freebsd", "linux", "netbsd"],
bugnumber='llvm.org/pr48372', bugnumber='llvm.org/pr48372',
triple=no_match(".*-android")) triple=no_match(".*-android"))
def test_dependents_explicit_false_exe(self): def test_dependents_explicit_false_exe(self):
"""Test default behavior""" """Test default behavior"""
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
self.runCmd("target create -dfalse " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("target create -dfalse " + exe, CURRENT_EXECUTABLE_SET)
self.has_exactly_one_image(False) self.has_exactly_one_image(False)
def test_dependents_implicit_false_exe(self): def test_dependents_implicit_false_exe(self):
"""Test default behavior""" """Test default behavior"""
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
self.runCmd("target create -d " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("target create -d " + exe, CURRENT_EXECUTABLE_SET)
self.has_exactly_one_image(True) self.has_exactly_one_image(True)
@expectedFailureAndroid # android will return mutiple images @expectedFailureAndroid # android will return mutiple images
def test_dependents_implicit_default_lib(self): def test_dependents_implicit_default_lib(self):
ctx = self.platformContext ctx = self.platformContext
dylibName = ctx.shlib_prefix + 'load_a.' + ctx.shlib_extension dylibName = ctx.shlib_prefix + 'load_a.' + ctx.shlib_extension
lib = self.getBuildArtifact(dylibName) lib = self.getBuildArtifact(dylibName)
Show All 33 Lines

lldb/test/API/commands/target/create-no-such-arch/TestNoSuchArch.py

Show All 9 Lines
class NoSuchArchTestCase(TestBase): class NoSuchArchTestCase(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()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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 create --arch nothingtoseehere %s" % "target create --arch nothingtoseehere %s" %
(exe), error=True, substrs=["error: invalid triple 'nothingtoseehere'"]) (exe), error=True, substrs=["error: invalid triple 'nothingtoseehere'"])
# 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/test/API/commands/target/modules/search-paths/insert/TestTargetModulesSearchpathsInsert.py

import lldb import lldb
from lldbsuite.test.lldbtest import * from lldbsuite.test.lldbtest import *
from lldbsuite.test.decorators import * from lldbsuite.test.decorators import *
import lldbsuite.test.lldbutil as lldbutil import lldbsuite.test.lldbutil as lldbutil
class TestCase(TestBase): class TestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@no_debug_info_test @no_debug_info_test
def test_invalid_arg(self): def test_invalid_arg(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
self.expect("target create %s" % (exe)) self.expect("target create %s" % (exe))
self.expect("target modules search-paths insert -1 a b", error=True, self.expect("target modules search-paths insert -1 a b", error=True,
startstr="error: <index> parameter is not an integer: '-1'.") startstr="error: <index> parameter is not an integer: '-1'.")
self.expect("target modules search-paths insert abcdefx a b", error=True, self.expect("target modules search-paths insert abcdefx a b", error=True,
startstr="error: <index> parameter is not an integer: 'abcdefx'.") startstr="error: <index> parameter is not an integer: 'abcdefx'.")

lldb/test/API/commands/trace/multiple-threads/TestTraceStartStopMultipleThreads.py

import lldb import lldb
from intelpt_testcase import * from intelpt_testcase import *
from lldbsuite.test.lldbtest import * from lldbsuite.test.lldbtest import *
from lldbsuite.test import lldbutil from lldbsuite.test import lldbutil
from lldbsuite.test.decorators import * from lldbsuite.test.decorators import *
class TestTraceStartStopMultipleThreads(TraceIntelPTTestCaseBase): class TestTraceStartStopMultipleThreads(TraceIntelPTTestCaseBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipIf(oslist=no_match(['linux']), archs=no_match(['i386', 'x86_64'])) @skipIf(oslist=no_match(['linux']), archs=no_match(['i386', 'x86_64']))
@testSBAPIAndCommands @testSBAPIAndCommands
def testStartMultipleLiveThreads(self): def testStartMultipleLiveThreads(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
self.dbg.CreateTarget(exe) self.dbg.CreateTarget(exe)
self.expect("b main") self.expect("b main")
self.expect("b 6") self.expect("b 6")
self.expect("b 11") self.expect("b 11")
self.expect("r") self.expect("r")
self.traceStartProcess() self.traceStartProcess()
self.expect("continue") self.expect("continue")
self.expect("thread trace dump instructions", substrs=['main.cpp:9']) self.expect("thread trace dump instructions", substrs=['main.cpp:9'])
# We'll see here the second thread # We'll see here the second thread
self.expect("continue") self.expect("continue")
self.expect("thread trace dump instructions", substrs=['main.cpp:4']) self.expect("thread trace dump instructions", substrs=['main.cpp:4'])
self.traceStopProcess() self.traceStopProcess()
@skipIf(oslist=no_match(['linux']), archs=no_match(['i386', 'x86_64'])) @skipIf(oslist=no_match(['linux']), archs=no_match(['i386', 'x86_64']))
@testSBAPIAndCommands @testSBAPIAndCommands
def testStartMultipleLiveThreadsWithStops(self): def testStartMultipleLiveThreadsWithStops(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
self.dbg.CreateTarget(exe) self.dbg.CreateTarget(exe)
self.expect("b main") self.expect("b main")
self.expect("b 6") self.expect("b 6")
self.expect("b 11") self.expect("b 11")
self.expect("r") self.expect("r")
Show All 20 Lines def testStartMultipleLiveThreadsWithStops(self):
self.expect("thread trace dump instructions 2", substrs=['not traced']) self.expect("thread trace dump instructions 2", substrs=['not traced'])
self.traceStopProcess() self.traceStopProcess()
@skipIf(oslist=no_match(['linux']), archs=no_match(['i386', 'x86_64'])) @skipIf(oslist=no_match(['linux']), archs=no_match(['i386', 'x86_64']))
@testSBAPIAndCommands @testSBAPIAndCommands
def testStartMultipleLiveThreadsWithStops(self): def testStartMultipleLiveThreadsWithStops(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
self.dbg.CreateTarget(exe) self.dbg.CreateTarget(exe)
self.expect("b main") self.expect("b main")
self.expect("b 6") self.expect("b 6")
self.expect("b 11") self.expect("b 11")
self.expect("r") self.expect("r")
Show All 19 Lines def testStartMultipleLiveThreadsWithStops(self):
self.expect("thread trace dump instructions 1", substrs=['not traced']) self.expect("thread trace dump instructions 1", substrs=['not traced'])
self.expect("thread trace dump instructions 2", substrs=['not traced']) self.expect("thread trace dump instructions 2", substrs=['not traced'])
self.traceStopProcess() self.traceStopProcess()
@skipIf(oslist=no_match(['linux']), archs=no_match(['i386', 'x86_64'])) @skipIf(oslist=no_match(['linux']), archs=no_match(['i386', 'x86_64']))
def testStartMultipleLiveThreadsWithThreadStartAll(self): def testStartMultipleLiveThreadsWithThreadStartAll(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.expect("b main") self.expect("b main")
self.expect("b 6") self.expect("b 6")
self.expect("b 11") self.expect("b 11")
self.expect("r") self.expect("r")
Show All 16 Lines def testStartMultipleLiveThreadsWithThreadStartAll(self):
self.expect("thread trace dump instructions 3", substrs=['not traced']) self.expect("thread trace dump instructions 3", substrs=['not traced'])
self.expect("thread trace dump instructions 1", substrs=['not traced']) self.expect("thread trace dump instructions 1", substrs=['not traced'])
self.expect("thread trace dump instructions 2", substrs=['not traced']) self.expect("thread trace dump instructions 2", substrs=['not traced'])
@skipIf(oslist=no_match(['linux']), archs=no_match(['i386', 'x86_64'])) @skipIf(oslist=no_match(['linux']), archs=no_match(['i386', 'x86_64']))
@testSBAPIAndCommands @testSBAPIAndCommands
def testStartMultipleLiveThreadsWithSmallTotalLimit(self): def testStartMultipleLiveThreadsWithSmallTotalLimit(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
self.dbg.CreateTarget(exe) self.dbg.CreateTarget(exe)
self.expect("b main") self.expect("b main")
self.expect("r") self.expect("r")
# trace the entire process with enough total size for 1 thread trace # trace the entire process with enough total size for 1 thread trace
self.traceStartProcess(processBufferSizeLimit=5000) self.traceStartProcess(processBufferSizeLimit=5000)
# we get the stop event when trace 2 appears and can't be traced # we get the stop event when trace 2 appears and can't be traced
self.expect("c", substrs=['Thread', "can't be traced"]) self.expect("c", substrs=['Thread', "can't be traced"])
# we get the stop event when trace 3 appears and can't be traced # we get the stop event when trace 3 appears and can't be traced
self.expect("c", substrs=['Thread', "can't be traced"]) self.expect("c", substrs=['Thread', "can't be traced"])
self.traceStopProcess() self.traceStopProcess()
@skipIf(oslist=no_match(['linux']), archs=no_match(['i386', 'x86_64'])) @skipIf(oslist=no_match(['linux']), archs=no_match(['i386', 'x86_64']))
@testSBAPIAndCommands @testSBAPIAndCommands
def testStartPerCoreSession(self): def testStartPerCoreSession(self):
self.skipIfPerCoreTracingIsNotSupported() self.skipIfPerCoreTracingIsNotSupported()
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
self.dbg.CreateTarget(exe) self.dbg.CreateTarget(exe)
self.expect("b main") self.expect("b main")
self.expect("r") self.expect("r")
# We should fail if we hit the total buffer limit. Useful if the number # We should fail if we hit the total buffer limit. Useful if the number
# of cores is huge. # of cores is huge.
self.traceStartProcess(error="True", processBufferSizeLimit=100, self.traceStartProcess(error="True", processBufferSizeLimit=100,
Show All 26 Lines

lldb/test/API/commands/watchpoints/multi_watchpoint_slots/TestWatchpointMultipleSlots.py

Show All 18 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 = self.getBuildArtifact("a.out") self.exe_name = self.getTestExecutable()
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/test/API/commands/watchpoints/watch_tagged_addr/TestWatchTaggedAddress.py

Show All 21 Lines def setUp(self):
# Set source filename. # Set source filename.
self.source = 'main.c' self.source = 'main.c'
# Invoke the default build rule. # Invoke the default build rule.
self.build() self.build()
# Get the path of the executable # Get the path of the executable
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# Create a target by the debugger. # Create a target by the debugger.
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
@skipIf(archs=no_match(["aarch64"])) @skipIf(archs=no_match(["aarch64"]))
@skipIf(oslist=no_match(['linux'])) @skipIf(oslist=no_match(['linux']))
def test_watch_hit_tagged_ptr_access(self): def test_watch_hit_tagged_ptr_access(self):
""" """
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

lldb/test/API/commands/watchpoints/watchpoint_on_vectors/TestValueOfVectorVariable.py

Show All 11 Lines
class TestValueOfVectorVariableTestCase(TestBase): class TestValueOfVectorVariableTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
def test_value_of_vector_variable_using_watchpoint_set(self): def test_value_of_vector_variable_using_watchpoint_set(self):
"""Test verify displayed value of vector variable.""" """Test verify displayed value of vector variable."""
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
d = {'C_SOURCES': self.source, 'EXE': exe} d = {'C_SOURCES': self.source, 'EXE': exe}
self.build(dictionary=d) self.build(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=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'
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/commands/watchpoints/watchpoint_set_command/TestWatchLocationWithWatchSet.py

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines @skipIf(
'arm'], 'arm'],
bugnumber="llvm.org/pr26031") bugnumber="llvm.org/pr26031")
@skipIfWindows # This test is flaky on Windows @skipIfWindows # This test is flaky 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 59 Lines • Show Last 20 Lines

lldb/test/API/commands/watchpoints/watchpoint_size/TestWatchpointSizes.py

Show All 19 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 = self.getBuildArtifact("a.out") self.exe_name = self.getTestExecutable()
self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name} self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
# 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):
"""Test to selectively watch different bytes in a 8-byte array.""" """Test to selectively watch different bytes in a 8-byte array."""
self.run_watchpoint_size_test('byteArray', 8, '1') self.run_watchpoint_size_test('byteArray', 8, '1')
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

lldb/test/API/driver/batch_mode/TestBatchMode.py

Show All 16 Linesclass DriverBatchModeTest(PExpectTest):
source = 'main.c' source = 'main.c'
@skipIf(oslist=["linux"], archs=["arm", "aarch64"]) # Randomly fails on buildbot @skipIf(oslist=["linux"], archs=["arm", "aarch64"]) # Randomly fails on buildbot
@expectedFlakeyFreeBSD("llvm.org/pr25172 fails rarely on the buildbot") @expectedFlakeyFreeBSD("llvm.org/pr25172 fails rarely on the buildbot")
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()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# Pass CRASH so the process will crash and stop in batch mode. # Pass CRASH so the process will crash and stop in batch mode.
extra_args = ['-b', extra_args = ['-b',
'-o', 'break set -n main', '-o', 'break set -n main',
'-o', 'run', '-o', 'run',
'-o', 'continue', '-o', 'continue',
'-k', 'frame var touch_me_not', '-k', 'frame var touch_me_not',
'--', 'CRASH', '--', 'CRASH',
Show All 14 Lines def test_batch_mode_run_crash(self):
self.expect("frame variable touch_me_not", substrs=['(char *) touch_me_not']) self.expect("frame variable touch_me_not", substrs=['(char *) touch_me_not'])
@skipIf(oslist=["linux"], archs=["arm", "aarch64"]) # Randomly fails on buildbot @skipIf(oslist=["linux"], archs=["arm", "aarch64"]) # Randomly fails on buildbot
@expectedFlakeyFreeBSD("llvm.org/pr25172 fails rarely on the buildbot") @expectedFlakeyFreeBSD("llvm.org/pr25172 fails rarely on the buildbot")
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()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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:
extra_args = ['-b', extra_args = ['-b',
'-o', 'break set -n main', '-o', 'break set -n main',
'-o', 'run', '-o', 'run',
'-o', 'continue', '-o', 'continue',
'--', 'NOCRASH', '--', 'NOCRASH',
] ]
Show All 13 Lines def test_batch_mode_run_exit(self):
child.expect(pexpect.EOF) child.expect(pexpect.EOF)
@skipIf(oslist=["linux"], archs=["arm", "aarch64"]) # Randomly fails on buildbot @skipIf(oslist=["linux"], archs=["arm", "aarch64"]) # Randomly fails on buildbot
@expectedFlakeyFreeBSD("llvm.org/pr25172 fails rarely on the buildbot") @expectedFlakeyFreeBSD("llvm.org/pr25172 fails rarely on the buildbot")
def test_batch_mode_launch_stop_at_entry(self): def test_batch_mode_launch_stop_at_entry(self):
"""Test that the lldb driver's batch mode works correctly for process launch.""" """Test that the lldb driver's batch mode works correctly for process launch."""
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# Launch with the option '--stop-at-entry' stops with a signal (usually SIGSTOP) # Launch with the option '--stop-at-entry' stops with a signal (usually SIGSTOP)
# that should be suppressed since it doesn't imply a crash and # that should be suppressed since it doesn't imply a crash and
# this is not a reason to exit batch mode. # this is not a reason to exit batch mode.
extra_args = ['-b', extra_args = ['-b',
'-o', 'process launch --stop-at-entry', '-o', 'process launch --stop-at-entry',
'-o', 'continue', '-o', 'continue',
] ]
Show All 20 Linesclass DriverBatchModeTest(PExpectTest):
@skipIf(oslist=["linux"], archs=["arm", "aarch64"]) # Randomly fails on buildbot @skipIf(oslist=["linux"], archs=["arm", "aarch64"]) # Randomly fails on buildbot
@expectedFlakeyFreeBSD("llvm.org/pr25172 fails rarely on the buildbot") @expectedFlakeyFreeBSD("llvm.org/pr25172 fails rarely on the buildbot")
@expectedFailureNetBSD @expectedFailureNetBSD
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()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# Start up the process by hand, attach to it, and wait for its completion. # 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.
import pexpect import pexpect
self.victim = pexpect.spawn('%s WAIT' % (exe)) self.victim = pexpect.spawn('%s WAIT' % (exe))
Show All 33 Lines

lldb/test/API/functionalities/archives/TestBSDArchives.py

Show All 23 Linesclass BSDArchivesTestCase(TestBase):
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr24527. Makefile.rules doesn't know how to build static libs on Windows") bugnumber="llvm.org/pr24527. Makefile.rules doesn't know how to build static libs on Windows")
@expectedFailureAll(remote=True) @expectedFailureAll(remote=True)
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 22 Lines

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

Show All 28 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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())
self.assertTrue(process, PROCESS_IS_VALID) self.assertTrue(process, PROCESS_IS_VALID)
self.assertEqual( self.assertEqual(
process.GetState(), lldb.eStateExited, process.GetState(), lldb.eStateExited,
"Process should have exited.") "Process should have exited.")
self.assertEqual( self.assertEqual(
process.GetExitStatus(), 0, process.GetExitStatus(), 0,
"Process returned non-zero status. Were incorrect file descriptors passed?") "Process returned non-zero status. Were incorrect file descriptors passed?")
# The check for descriptor leakage needs to be implemented differently # The check for descriptor leakage needs to be implemented differently
# here. # here.
@skipIfWindows @skipIfWindows
@skipIfTargetAndroid() # Android have some other file descriptors open by the shell @skipIfTargetAndroid() # Android have some other file descriptors open by the shell
@skipIfDarwinEmbedded # <rdar://problem/33888742> # debugserver on ios has an extra fd open on launch @skipIfDarwinEmbedded # <rdar://problem/33888742> # debugserver on ios has an extra fd open on launch
def test_fd_leak_multitarget(self): def test_fd_leak_multitarget(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/breakpoint/breakpoint_callback_command_source/TestBreakpointCallbackCommandSource.py

Show All 17 Linesclass BreakpointCallbackCommandSource(PExpectTest):
# PExpect uses many timeouts internally and doesn't play well # PExpect uses many timeouts internally and doesn't play well
# under ASAN on a loaded machine.. # under ASAN on a loaded machine..
@skipIfAsan @skipIfAsan
@skipIfEditlineSupportMissing @skipIfEditlineSupportMissing
@skipIf(oslist=["linux"], archs=["arm", "aarch64"]) @skipIf(oslist=["linux"], archs=["arm", "aarch64"])
@skipIf(oslist=["freebsd"], bugnumber="llvm.org/pr48316") @skipIf(oslist=["freebsd"], bugnumber="llvm.org/pr48316")
def test_breakpoint_callback_command_source(self): def test_breakpoint_callback_command_source(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
self.launch(exe) self.launch(exe)
self.expect("b main", substrs=["Breakpoint 1"]) self.expect("b main", substrs=["Breakpoint 1"])
self.child.send("breakpoint command add -s python\n") self.child.send("breakpoint command add -s python\n")
self.child.send( self.child.send(
"frame.GetThread().GetProcess().GetTarget().GetDebugger().HandleCommand('command source -s true {}')\n" "frame.GetThread().GetProcess().GetTarget().GetDebugger().HandleCommand('command source -s true {}')\n"
.format(self.file_to_source)) .format(self.file_to_source))
self.child.send("DONE\n") self.child.send("DONE\n")
self.expect_prompt() self.expect_prompt()
self.expect("run", substrs=["Process", "stopped"]) self.expect("run", substrs=["Process", "stopped"])
self.expect("script print(foo)", substrs=["95126"]) self.expect("script print(foo)", substrs=["95126"])

lldb/test/API/functionalities/breakpoint/breakpoint_command/TestBreakpointCommand.py

Show All 39 Lines def setUp(self):
# 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 test_delete_all_breakpoints(self): def test_delete_all_breakpoints(self):
"""Test that deleting all breakpoints works.""" """Test that deleting all breakpoints works."""
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_symbol(self, "main") lldbutil.run_break_set_by_symbol(self, "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)
self.runCmd("breakpoint delete") self.runCmd("breakpoint delete")
self.runCmd("process continue") self.runCmd("process continue")
self.expect("process status", PROCESS_STOPPED, self.expect("process status", PROCESS_STOPPED,
patterns=['Process .* exited with status = 0']) patterns=['Process .* exited with status = 0'])
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 167 Lines • ▼ Show 20 Lines def breakpoint_command_sequence(self):
substrs=['stopped', substrs=['stopped',
'stop reason = breakpoint']) 'stop reason = breakpoint'])
# The breakpoint should have a hit count of 2. # The breakpoint should have a hit count of 2.
lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 2) lldbutil.check_breakpoint(self, bpno = 1, expected_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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 'import side_effect; side_effect.frame = str(frame); side_effect.bp_loc = str(bp_loc)' 1") self.runCmd("breakpoint command add -s python -o 'import side_effect; side_effect.frame = str(frame); side_effect.bp_loc = str(bp_loc)' 1")
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

lldb/test/API/functionalities/breakpoint/breakpoint_command/TestRegexpBreakCommand.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.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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/breakpoint/breakpoint_conditions/TestBreakpointConditions.py

Show All 39 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 120 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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.trace("breakpoint:", breakpoint) self.trace("breakpoint:", breakpoint)
Show All 26 Lines

lldb/test/API/functionalities/breakpoint/breakpoint_ids/TestBreakpointIDs.py

Show All 10 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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.assertEquals(bpno, 1, "First breakpoint number is 1.") self.assertEquals(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/test/API/functionalities/breakpoint/breakpoint_ignore_count/TestBreakpointIgnoreCount.py

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 20 Lines • Show All 113 Lines • Show Last 20 Lines

lldb/test/API/functionalities/breakpoint/breakpoint_in_delayslot/TestAvoidBreakpointInDelaySlot.py

Show All 13 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 51 Lines • Show Last 20 Lines

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

Show All 20 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/breakpoint/breakpoint_locations/TestBreakpointLocations.py

Show All 31 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 145 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 49 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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(self.getSourceDir(), "main.c")) self.main_file_spec = lldb.SBFileSpec(os.path.join(self.getSourceDir(), "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 304 Lines • Show Last 20 Lines

lldb/test/API/functionalities/breakpoint/breakpoint_options/TestBreakpointOptions.py

Show All 20 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/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'
@skipIfNetBSD @skipIfNetBSD
def test_breakpoint_set_restart(self): def test_breakpoint_set_restart(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 23 Lines

lldb/test/API/functionalities/breakpoint/cpp/TestCPPBreakpointLocations.py

Show All 37 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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()', 'aa::cc::func1()', 'b::c::func1()']}, {'name': 'func1', 'loc_names': ['a::c::func1()', 'aa::cc::func1()', 'b::c::func1()']},
{'name': 'func2', 'loc_names': ['a::c::func2()', 'aa::cc::func2()', 'c::d::func2()']}, {'name': 'func2', 'loc_names': ['a::c::func2()', 'aa::cc::func2()', 'c::d::func2()']},
{'name': 'func3', 'loc_names': ['a::c::func3()', 'aa::cc::func3()', 'b::c::func3()', 'c::d::func3()']}, {'name': 'func3', 'loc_names': ['a::c::func3()', 'aa::cc::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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/breakpoint/cpp_exception/TestCPPExceptionBreakpoint.py

Show All 29 Lines def test_dummy_target_cpp_exception_breakpoint(self):
self.do_dummy_target_cpp_exception_bkpt() self.do_dummy_target_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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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(
exception_bkpt.IsValid(), exception_bkpt.IsValid(),
"Created exception breakpoint.") "Created exception breakpoint.")
process = self.target.LaunchSimple( process = self.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)
thread_list = lldbutil.get_threads_stopped_at_breakpoint( thread_list = lldbutil.get_threads_stopped_at_breakpoint(
process, exception_bkpt) process, exception_bkpt)
self.assertEquals(len(thread_list), 1, self.assertEquals(len(thread_list), 1,
"One thread stopped at the exception breakpoint.") "One thread stopped at the exception breakpoint.")
def do_dummy_target_cpp_exception_bkpt(self): def do_dummy_target_cpp_exception_bkpt(self):
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
error = lldb.SBError() error = lldb.SBError()
dummy_exception_bkpt = self.dbg.GetDummyTarget().BreakpointCreateForException( dummy_exception_bkpt = self.dbg.GetDummyTarget().BreakpointCreateForException(
lldb.eLanguageTypeC_plus_plus, False, True) lldb.eLanguageTypeC_plus_plus, False, True)
self.assertTrue( self.assertTrue(
dummy_exception_bkpt.IsValid(), dummy_exception_bkpt.IsValid(),
"Created exception breakpoint in dummy target.") "Created exception breakpoint in dummy target.")
Show All 16 Lines

lldb/test/API/functionalities/breakpoint/debugbreak/TestDebugBreak.py

Show All 12 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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/test/API/functionalities/breakpoint/dummy_target_breakpoints/TestBreakpointsWithNoTargets.py

Show All 37 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/breakpoint/global_constructor/TestBreakpointInGlobalConstructor.py

Show All 14 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(self.getBuildArtifact("a.out")) target = self.dbg.CreateTarget(self.getTestExecutable())
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(
Show All 14 Lines

lldb/test/API/functionalities/breakpoint/hardware_breakpoints/base.py

""" """
Base class for hardware breakpoints tests. Base class for hardware breakpoints tests.
""" """
from lldbsuite.test.lldbtest import * from lldbsuite.test.lldbtest import *
class HardwareBreakpointTestBase(TestBase): class HardwareBreakpointTestBase(TestBase):
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
def supports_hw_breakpoints(self): def supports_hw_breakpoints(self):
self.build() self.build()
self.runCmd("file " + self.getBuildArtifact("a.out"), self.runCmd("file " + self.getTestExecutable(),
CURRENT_EXECUTABLE_SET) CURRENT_EXECUTABLE_SET)
self.runCmd("breakpoint set -b main --hardware") self.runCmd("breakpoint set -b main --hardware")
self.runCmd("run") self.runCmd("run")
if 'stopped' in self.res.GetOutput(): if 'stopped' in self.res.GetOutput():
return 'Hardware breakpoints are supported' return 'Hardware breakpoints are supported'
return None return None

lldb/test/API/functionalities/breakpoint/hardware_breakpoints/hardware_breakpoint_on_multiple_threads/TestHWBreakMultiThread.py

Show All 36 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("file " + self.getBuildArtifact("a.out"), self.runCmd("file " + self.getTestExecutable(),
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 58 Lines • Show Last 20 Lines

lldb/test/API/functionalities/breakpoint/hardware_breakpoints/require_hw_breakpoints/TestRequireHWBreakpoints.py

Show All 14 Linesclass BreakpointLocationsTestCase(HardwareBreakpointTestBase):
@skipIf(oslist=["linux"], archs=["arm"]) @skipIf(oslist=["linux"], archs=["arm"])
def supports_hw_breakpoints(self): def supports_hw_breakpoints(self):
return super().supports_hw_breakpoints() return super().supports_hw_breakpoints()
def test_breakpoint(self): def test_breakpoint(self):
"""Test regular breakpoints when hardware breakpoints are required.""" """Test regular breakpoints when hardware breakpoints are required."""
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.runCmd("settings set target.require-hardware-breakpoint true") self.runCmd("settings set target.require-hardware-breakpoint true")
breakpoint = target.BreakpointCreateByLocation("main.c", 1) breakpoint = target.BreakpointCreateByLocation("main.c", 1)
self.assertTrue(breakpoint.IsHardware()) self.assertTrue(breakpoint.IsHardware())
@expectedFailureIfFn(supports_hw_breakpoints) @expectedFailureIfFn(supports_hw_breakpoints)
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

lldb/test/API/functionalities/breakpoint/hardware_breakpoints/write_memory_with_hw_breakpoint/TestWriteMemoryWithHWBreakpoint.py

Show All 14 Linesclass WriteMemoryWithHWBreakpoint(HardwareBreakpointTestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def does_not_support_hw_breakpoints(self): def does_not_support_hw_breakpoints(self):
return not super().supports_hw_breakpoints() return not super().supports_hw_breakpoints()
@skipTestIfFn(does_not_support_hw_breakpoints) @skipTestIfFn(does_not_support_hw_breakpoints)
def test_copy_memory_with_hw_break(self): def test_copy_memory_with_hw_break(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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)
# Run the program and stop at entry. # Run the program and stop at entry.
self.expect("process launch --stop-at-entry", self.expect("process launch --stop-at-entry",
patterns=["Process .* launched: .*a.out"]) patterns=["Process .* launched: .*a.out"])
Show All 20 Lines

lldb/test/API/functionalities/breakpoint/inlined_breakpoints/TestInlinedBreakpoints.py

Show All 24 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/breakpoint/move_nearest/TestMoveNearest.py

Show All 20 Lines def setUp(self):
self.line_between = line_number('main.cpp', "// BR_Between") self.line_between = line_number('main.cpp', "// BR_Between")
print("BR_Between found at", self.line_between) print("BR_Between found at", self.line_between)
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(self.getBuildArtifact("a.out")) target = self.dbg.CreateTarget(self.getTestExecutable())
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 32 Lines

lldb/test/API/functionalities/breakpoint/objc/TestObjCBreakpoints.py

Show First 20 Lines • Show All 64 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/breakpoint/serialize/TestBreakpointSerialization.py

Show First 20 Lines • Show All 91 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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 303 Lines • Show Last 20 Lines

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

Show All 19 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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.assertEquals(line_entry.line, a_func_line, self.assertEquals(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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/breakpoint/step_over_breakpoint/TestStepOverBreakpoint.py

Show All 14 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 86 Lines • Show Last 20 Lines

lldb/test/API/functionalities/completion/TestCompletion.py

Show First 20 Lines • Show All 131 Lines • ▼ Show 20 Linesclass CommandLineCompletionTestCase(TestBase):
@skipIfRemote @skipIfRemote
def test_common_completion_process_pid_and_name(self): def test_common_completion_process_pid_and_name(self):
# The LLDB process itself and the process already attached to are both # The LLDB process itself and the process already attached to are both
# ignored by the process discovery mechanism, thus we need a process known # ignored by the process discovery mechanism, thus we need a process known
# to us here. # to us here.
self.build() self.build()
server = self.spawnSubprocess( server = self.spawnSubprocess(
self.getBuildArtifact("a.out"), self.getTestExecutable(),
["-x"], # Arg "-x" makes the subprocess wait for input thus it won't be terminated too early ["-x"], # Arg "-x" makes the subprocess wait for input thus it won't be terminated too early
install_remote=False) install_remote=False)
self.assertIsNotNone(server) self.assertIsNotNone(server)
pid = server.pid pid = server.pid
self.completions_contain('process attach -p ', [str(pid)]) self.completions_contain('process attach -p ', [str(pid)])
self.completions_contain('platform process attach -p ', [str(pid)]) self.completions_contain('platform process attach -p ', [str(pid)])
self.completions_contain('platform process info ', [str(pid)]) self.completions_contain('platform process info ', [str(pid)])
▲ Show 20 Lines • Show All 280 Lines • ▼ Show 20 Lines def test_target_space(self):
'modules', 'modules',
'select', 'select',
'stop-hook', 'stop-hook',
'variable']) 'variable'])
def test_target_modules_dump_line_table(self): def test_target_modules_dump_line_table(self):
"""Tests source file completion by completing the line-table argument.""" """Tests source file completion by completing the line-table argument."""
self.build() self.build()
self.dbg.CreateTarget(self.getBuildArtifact("a.out")) self.dbg.CreateTarget(self.getTestExecutable())
self.complete_from_to('target modules dump line-table main.cp', self.complete_from_to('target modules dump line-table main.cp',
['main.cpp']) ['main.cpp'])
def test_target_modules_load_aout(self): def test_target_modules_load_aout(self):
"""Tests modules completion by completing the target modules load argument.""" """Tests modules completion by completing the target modules load argument."""
self.build() self.build()
self.dbg.CreateTarget(self.getBuildArtifact("a.out")) self.dbg.CreateTarget(self.getTestExecutable())
self.complete_from_to('target modules load a.ou', self.complete_from_to('target modules load a.ou',
['a.out']) ['a.out'])
def test_target_modules_search_paths_insert(self): def test_target_modules_search_paths_insert(self):
# Completion won't work without a valid target. # Completion won't work without a valid target.
self.complete_from_to("target modules search-paths insert ", "target modules search-paths insert ") self.complete_from_to("target modules search-paths insert ", "target modules search-paths insert ")
self.build() self.build()
target = self.dbg.CreateTarget(self.getBuildArtifact('a.out')) target = self.dbg.CreateTarget(self.getBuildArtifact('a.out'))
▲ Show 20 Lines • Show All 118 Lines • ▼ Show 20 Lines def test_frame_recognizer_delete(self):
self.check_completion_with_desc('frame recognizer delete ', [['0', 'py_class, module module_name, symbol recognizer_name']]) self.check_completion_with_desc('frame recognizer delete ', [['0', 'py_class, module module_name, symbol recognizer_name']])
def test_platform_install_local_file(self): def test_platform_install_local_file(self):
self.complete_from_to('platform target-install main.cp', 'platform target-install main.cpp') self.complete_from_to('platform target-install main.cp', 'platform target-install main.cpp')
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489")
def test_symbol_name(self): def test_symbol_name(self):
self.build() self.build()
self.dbg.CreateTarget(self.getBuildArtifact("a.out")) self.dbg.CreateTarget(self.getTestExecutable())
self.complete_from_to('breakpoint set -n Fo', self.complete_from_to('breakpoint set -n Fo',
'breakpoint set -n Foo::Bar(int,\\ int)', 'breakpoint set -n Foo::Bar(int,\\ int)',
turn_off_re_match=True) turn_off_re_match=True)
# No completion for Qu because the candidate is # No completion for Qu because the candidate is
# (anonymous namespace)::Quux(). # (anonymous namespace)::Quux().
self.complete_from_to('breakpoint set -n Qu', '') self.complete_from_to('breakpoint set -n Qu', '')
def test_completion_type_formatter_delete(self): def test_completion_type_formatter_delete(self):
▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Linesclass CommandLineCompletionTestCase(TestBase):
def test_common_completion_target_stophook_ids(self): def test_common_completion_target_stophook_ids(self):
subcommands = ['delete', 'enable', 'disable'] subcommands = ['delete', 'enable', 'disable']
for subcommand in subcommands: for subcommand in subcommands:
self.complete_from_to('target stop-hook ' + subcommand + ' ', self.complete_from_to('target stop-hook ' + subcommand + ' ',
'target stop-hook ' + subcommand + ' ') 'target stop-hook ' + subcommand + ' ')
self.build() self.build()
self.dbg.CreateTarget(self.getBuildArtifact("a.out")) self.dbg.CreateTarget(self.getTestExecutable())
self.runCmd('target stop-hook add test DONE') self.runCmd('target stop-hook add test DONE')
for subcommand in subcommands: for subcommand in subcommands:
self.complete_from_to('target stop-hook ' + subcommand + ' ', self.complete_from_to('target stop-hook ' + subcommand + ' ',
'target stop-hook ' + subcommand + ' 1') 'target stop-hook ' + subcommand + ' 1')
# Completion should work only on the first argument. # Completion should work only on the first argument.
for subcommand in subcommands: for subcommand in subcommands:
self.complete_from_to('target stop-hook ' + subcommand + ' 1 ', self.complete_from_to('target stop-hook ' + subcommand + ' 1 ',
'target stop-hook ' + subcommand + ' 1 ') 'target stop-hook ' + subcommand + ' 1 ')
def test_common_completion_type_language(self): def test_common_completion_type_language(self):
self.complete_from_to('type category -l ', ['c']) self.complete_from_to('type category -l ', ['c'])
def test_target_modules_load_dash_u(self): def test_target_modules_load_dash_u(self):
self.build() self.build()
target = self.dbg.CreateTarget(self.getBuildArtifact("a.out")) target = self.dbg.CreateTarget(self.getTestExecutable())
self.complete_from_to('target modules load -u ', [target.GetModuleAtIndex(0).GetUUIDString()]) self.complete_from_to('target modules load -u ', [target.GetModuleAtIndex(0).GetUUIDString()])
def test_complete_breakpoint_with_ids(self): def test_complete_breakpoint_with_ids(self):
"""These breakpoint subcommands should be completed with a list of breakpoint ids""" """These breakpoint subcommands should be completed with a list of breakpoint ids"""
subcommands = ['enable', 'disable', 'delete', 'modify', 'name add', 'name delete', 'write'] subcommands = ['enable', 'disable', 'delete', 'modify', 'name add', 'name delete', 'write']
# The tab completion here is unavailable without a target # The tab completion here is unavailable without a target
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

lldb/test/API/functionalities/conditional_break/TestConditionalBreak.py

Show All 27 Linesclass ConditionalBreakTestCase(TestBase):
def test_with_command(self): def test_with_command(self):
"""Simulate a user using lldb commands to break on c() if called from a().""" """Simulate a user using lldb commands to break on c() if called from a()."""
self.build() self.build()
self.simulate_conditional_break_by_user() self.simulate_conditional_break_by_user()
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 " + self.getBuildArtifact("a.out") command from .lldb file, for the sake of # Separate out the "file " + self.getTestExecutable() command from .lldb file, for the sake of
# remote testsuite. # remote testsuite.
self.runCmd("file " + self.getBuildArtifact("a.out")) self.runCmd("file " + self.getTestExecutable())
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/test/API/functionalities/data-formatter/boolreference/TestFormattersBoolRefPtr.py

Show All 22 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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 50 Lines • Show Last 20 Lines

lldb/test/API/functionalities/data-formatter/compactvectors/TestCompactVectors.py

Show All 18 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/data-formatter-advanced/TestDataFormatterAdv.py

Show All 16 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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 317 Lines • Show Last 20 Lines

lldb/test/API/functionalities/data-formatter/data-formatter-categories/TestDataFormatterCategories.py

Show All 16 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.')
@expectedFlakeyNetBSD @expectedFlakeyNetBSD
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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/data-formatter-cpp/TestDataFormatterCpp.py

Show All 17 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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 255 Lines • Show Last 20 Lines

lldb/test/API/functionalities/data-formatter/data-formatter-disabling/TestDataFormatterDisabling.py

Show All 20 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/data-formatter-enum-format/TestDataFormatterEnumFormat.py

Show All 16 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/data-formatter-globals/TestDataFormatterGlobals.py

Show All 17 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/data-formatter-named-summaries/TestDataFormatterNamedSummaries.py

Show All 16 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/data-formatter-objc/cmtime/TestDataFormatterCMTime.py

# encoding: utf-8 # encoding: utf-8
import lldb import lldb
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
class CMTimeDataFormatterTestCase(TestBase): class CMTimeDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipUnlessDarwin @skipUnlessDarwin
def test_nsindexpath_with_run_command(self): def test_nsindexpath_with_run_command(self):
"""Test formatters for CMTime.""" """Test formatters for CMTime."""
self.build() self.build()
self.runCmd("file " + self.getBuildArtifact("a.out"), self.runCmd("file " + self.getTestExecutable(),
CURRENT_EXECUTABLE_SET) CURRENT_EXECUTABLE_SET)
line = line_number('main.m', '// break here') line = line_number('main.m', '// break here')
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 28 Lines

lldb/test/API/functionalities/data-formatter/data-formatter-objc/nsindexpath/TestDataFormatterNSIndexPath.py

Show All 11 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/data-formatter-objc/nsstring/TestDataFormatterNSString.py

Show All 11 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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 94 Lines • Show Last 20 Lines

lldb/test/API/functionalities/data-formatter/data-formatter-proper-plurals/TestFormattersOneIsSingular.py

Show All 22 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/data-formatter-ptr-to-array/TestPtrToArrayFormatting.py

Show All 20 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/data-formatter-python-synth/TestDataFormatterPythonSynth.py

Show First 20 Lines • Show All 258 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/data-formatter-script/TestDataFormatterScript.py

Show All 20 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/data-formatter-skip-summary/TestDataFormatterSkipSummary.py

Show All 23 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/data-formatter-smart-array/TestDataFormatterSmartArray.py

Show All 21 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/data-formatter-stl/generic/list/TestDataFormatterGenericList.py

Show All 23 Lines def setUp(self):
self.optional_line = line_number( self.optional_line = line_number(
'main.cpp', '// Optional break point at this line.') 'main.cpp', '// Optional break point at this line.')
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.')
def do_test_with_run_command(self, stdlib_type): def do_test_with_run_command(self, stdlib_type):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.build(dictionary={stdlib_type: "1"}) self.build(dictionary={stdlib_type: "1"})
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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 226 Lines • Show Last 20 Lines

lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/list/loop/TestDataFormatterGenericListLoop.py

Show All 14 Lines
class GenericListDataFormatterTestCase(TestBase): class GenericListDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
def do_test_with_run_command(self, stdlib_type): def do_test_with_run_command(self, stdlib_type):
self.build(dictionary={stdlib_type: "1"}) self.build(dictionary={stdlib_type: "1"})
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 Linesclass GenericListDataFormatterTestCase(TestBase):
@add_test_categories(["libstdcxx"]) @add_test_categories(["libstdcxx"])
def test_with_run_command_libstdcpp(self): def test_with_run_command_libstdcpp(self):
self.do_test_with_run_command(USE_LIBSTDCPP) self.do_test_with_run_command(USE_LIBSTDCPP)
@add_test_categories(["libc++"]) @add_test_categories(["libc++"])
def test_with_run_command_libcpp(self): def test_with_run_command_libcpp(self):
self.do_test_with_run_command(USE_LIBCPP) self.do_test_with_run_command(USE_LIBCPP)
No newline at end of file No newline at end of file

lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/multimap/TestDataFormatterGenericMultiMap.py

Show All 36 Lines def check(self, var_name, size):
for i in range(size): for i in range(size):
child = var.GetChildAtIndex(i) child = var.GetChildAtIndex(i)
children.append(ValueCheck(value=child.GetValue())) children.append(ValueCheck(value=child.GetValue()))
self.expect_var_path(var_name, type=self.getVariableType(var_name), children=children) self.expect_var_path(var_name, type=self.getVariableType(var_name), children=children)
def do_test_with_run_command(self, stdlib_type): def do_test_with_run_command(self, stdlib_type):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.build(dictionary={stdlib_type: "1"}) self.build(dictionary={stdlib_type: "1"})
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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 285 Lines • Show Last 20 Lines

lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/optional/TestDataFormatterGenericOptional.py

Show All 16 Lines def do_test_with_run_command(self, stdlib_type):
def cleanup(): def cleanup():
self.runCmd('type format clear', check=False) self.runCmd('type format clear', check=False)
self.runCmd('type summary clear', check=False) self.runCmd('type summary clear', check=False)
self.runCmd('type filter clear', check=False) self.runCmd('type filter clear', check=False)
self.runCmd('type synth clear', check=False) self.runCmd('type synth clear', check=False)
self.addTearDownHook(cleanup) self.addTearDownHook(cleanup)
self.build(dictionary={stdlib_type: "1"}) self.build(dictionary={stdlib_type: "1"})
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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 56 Lines • Show Last 20 Lines

lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/unordered/TestDataFormatterGenericUnordered.py

Show All 9 Linesclass GenericUnorderedDataFormatterTestCase(TestBase):
def setUp(self): def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
self.namespace = 'std' self.namespace = 'std'
def do_test_with_run_command(self, stdlib_type): def do_test_with_run_command(self, stdlib_type):
self.build(dictionary={stdlib_type: "1"}) self.build(dictionary={stdlib_type: "1"})
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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 60 Lines • Show Last 20 Lines

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

Show All 20 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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 35 Lines

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/function/TestLibCxxFunction.py

Show All 30 Lines def run_frame_var_check_cache_use(self, variable, result_to_match, skip_find_function=False):
matching=False, matching=False,
substrs=["lldb_private::CompileUnit::FindFunction"]) substrs=["lldb_private::CompileUnit::FindFunction"])
@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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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 25 Lines

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/initializerlist/TestInitializerList.py

Show All 12 Lines
class InitializerListTestCase(TestBase): class InitializerListTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@add_test_categories(["libc++"]) @add_test_categories(["libc++"])
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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/iterator/TestDataFormatterLibccIterator.py

Show All 19 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.')
self.namespace = 'std' self.namespace = 'std'
@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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/map/TestDataFormatterLibccMap.py

Show All 22 Lines def check_pair(self, first_value, second_value):
pair_children = [ValueCheck(name="first", value=first_value), pair_children = [ValueCheck(name="first", value=first_value),
ValueCheck(name="second", value=second_value)] ValueCheck(name="second", value=second_value)]
return ValueCheck(children=pair_children) return ValueCheck(children=pair_children)
@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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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 264 Lines • Show Last 20 Lines

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/string_view/TestDataFormatterLibcxxStringView.py

Show All 24 Linesclass LibcxxStringViewDataFormatterTestCase(TestBase):
@add_test_categories(["libc++"]) @add_test_categories(["libc++"])
@expectedFailureAll(bugnumber="llvm.org/pr36109", debug_info="gmodules", triple=".*-android") @expectedFailureAll(bugnumber="llvm.org/pr36109", debug_info="gmodules", triple=".*-android")
# Inline namespace is randomly ignored as Clang due to broken lookup inside # Inline namespace is randomly ignored as Clang due to broken lookup inside
# the std namespace. # the std namespace.
@expectedFailureAll(debug_info="gmodules") @expectedFailureAll(debug_info="gmodules")
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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.line1, num_expected_locations=-1) self, "main.cpp", self.line1, 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)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
▲ Show 20 Lines • Show All 148 Lines • Show Last 20 Lines

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/vbool/TestDataFormatterLibcxxVBool.py

Show All 18 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/data-formatter-stl/libstdcpp/iterator/TestDataFormatterStdIterator.py

Show All 19 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.')
@add_test_categories(["libstdcxx"]) @add_test_categories(["libstdcxx"])
@expectedFailureAll(bugnumber="llvm.org/pr50861", compiler="gcc") @expectedFailureAll(bugnumber="llvm.org/pr50861", compiler="gcc")
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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/data-formatter-stl/libstdcpp/map/TestDataFormatterStdMap.py

Show All 19 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.')
@add_test_categories(["libstdcxx"]) @add_test_categories(["libstdcxx"])
@expectedFailureAll(bugnumber="llvm.org/pr50861", compiler="gcc") @expectedFailureAll(bugnumber="llvm.org/pr50861", compiler="gcc")
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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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 260 Lines • Show Last 20 Lines

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libstdcpp/smart_ptr/TestDataFormatterStdSmartPtr.py

Show All 10 Lines
class StdSmartPtrDataFormatterTestCase(TestBase): class StdSmartPtrDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@add_test_categories(["libstdcxx"]) @add_test_categories(["libstdcxx"])
@expectedFailureAll(bugnumber="llvm.org/pr50861", compiler="gcc") @expectedFailureAll(bugnumber="llvm.org/pr50861", compiler="gcc")
def test_with_run_command(self): def test_with_run_command(self):
self.build() self.build()
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/data-formatter-stl/libstdcpp/string/TestDataFormatterStdString.py

Show All 20 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.')
@add_test_categories(["libstdcxx"]) @add_test_categories(["libstdcxx"])
@expectedFailureAll(bugnumber="llvm.org/pr50861", compiler="gcc") @expectedFailureAll(bugnumber="llvm.org/pr50861", compiler="gcc")
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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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 48 Lines • Show Last 20 Lines

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libstdcpp/tuple/TestDataFormatterStdTuple.py

Show All 10 Lines
class StdTupleDataFormatterTestCase(TestBase): class StdTupleDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@add_test_categories(["libstdcxx"]) @add_test_categories(["libstdcxx"])
@expectedFailureAll(bugnumber="llvm.org/pr50861", compiler="gcc") @expectedFailureAll(bugnumber="llvm.org/pr50861", compiler="gcc")
def test_with_run_command(self): def test_with_run_command(self):
self.build() self.build()
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/data-formatter-stl/libstdcpp/unique_ptr/TestDataFormatterStdUniquePtr.py

Show All 11 Lines
class StdUniquePtrDataFormatterTestCase(TestBase): class StdUniquePtrDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@add_test_categories(["libstdcxx"]) @add_test_categories(["libstdcxx"])
@expectedFailureAll(bugnumber="llvm.org/pr50861", compiler="gcc") @expectedFailureAll(bugnumber="llvm.org/pr50861", compiler="gcc")
@skipIf(oslist=["linux"], archs=["arm", "aarch64"]) @skipIf(oslist=["linux"], archs=["arm", "aarch64"])
def test_with_run_command(self): def test_with_run_command(self):
self.build() self.build()
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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 38 Linesclass StdUniquePtrDataFormatterTestCase(TestBase):
@skipIfwatchOS # libstdcpp not ported to watchos @skipIfwatchOS # libstdcpp not ported to watchos
@skipIf(oslist=["linux"], archs=["arm", "aarch64"]) @skipIf(oslist=["linux"], archs=["arm", "aarch64"])
@add_test_categories(["libstdcxx"]) @add_test_categories(["libstdcxx"])
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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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 12 Lines

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libstdcpp/vbool/TestDataFormatterStdVBool.py

Show All 18 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(["libstdcxx"]) @add_test_categories(["libstdcxx"])
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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/data-formatter-stl/libstdcpp/vector/TestDataFormatterStdVector.py

Show All 19 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.')
@add_test_categories(["libstdcxx"]) @add_test_categories(["libstdcxx"])
@expectedFailureAll(bugnumber="llvm.org/pr50861", compiler="gcc") @expectedFailureAll(bugnumber="llvm.org/pr50861", compiler="gcc")
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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/data-formatter-synth/TestDataFormatterSynth.py

Show All 16 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/data-formatter-synthtype/TestDataFormatterSynthType.py

Show All 17 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', 'break here') self.line = line_number('main.cpp', 'break here')
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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/data-formatter-synthval/TestDataFormatterSynthVal.py

Show All 19 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(bugnumber="llvm.org/pr50814", compiler="gcc") @expectedFailureAll(bugnumber="llvm.org/pr50814", compiler="gcc")
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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/format-propagation/TestFormatPropagation.py

Show All 17 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/frameformat_smallstruct/TestFrameFormatSmallStruct.py

Show All 16 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/hexcaps/TestDataFormatterHexCaps.py

Show All 16 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/language_category_updates/TestDataFormatterLanguageCategoryUpdates.py

Show All 29 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/nsarraysynth/TestNSArraySynthetic.py

Show All 18 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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 80 Lines • Show Last 20 Lines

lldb/test/API/functionalities/data-formatter/nsdictionarysynth/TestNSDictionarySynthetic.py

Show All 35 Lines def test_rdar11988289_with_run_command_no_const(self):
'-fno-constant-nsnumber-literals ' + '-fno-constant-nsnumber-literals ' +
'-fno-constant-nsarray-literals ' + '-fno-constant-nsarray-literals ' +
'-fno-constant-nsdictionary-literals' '-fno-constant-nsdictionary-literals'
} }
self.build(dictionary=disable_constant_classes) self.build(dictionary=disable_constant_classes)
self.run_tests() self.run_tests()
def run_tests(self): def run_tests(self):
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/nssetsynth/TestNSSetSynthetic.py

Show All 35 Lines def test_rdar12529957_with_run_command_no_const(self):
'-fno-constant-nsnumber-literals ' + '-fno-constant-nsnumber-literals ' +
'-fno-constant-nsarray-literals ' + '-fno-constant-nsarray-literals ' +
'-fno-constant-nsdictionary-literals' '-fno-constant-nsdictionary-literals'
} }
self.build(dictionary=disable_constant_classes) self.build(dictionary=disable_constant_classes)
self.run_tests() self.run_tests()
def run_tests(self): def run_tests(self):
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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 78 Lines • Show Last 20 Lines

lldb/test/API/functionalities/data-formatter/ostypeformatting/TestFormattersOsType.py

Show All 18 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/parray/TestPrintArray.py

Show All 21 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/poarray/TestPrintObjectArray.py

Show All 36 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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 70 Lines • Show Last 20 Lines

lldb/test/API/functionalities/data-formatter/ptr_ref_typedef/TestPtrRef2Typedef.py

Show All 16 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/pyobjsynthprovider/TestPyObjSynthProvider.py

Show All 22 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/refpointer-recursion/TestDataFormatterRefPtrRecursion.py

Show All 16 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/summary-string-onfail/Test-rdar-9974002.py

Show All 21 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/synthcapping/TestSyntheticCapping.py

Show All 17 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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 56 Lines • Show Last 20 Lines

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

Show All 18 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/type_summary_list_script/TestTypeSummaryListScript.py

Show All 21 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/user-format-vs-summary/TestUserFormatVsSummary.py

Show All 16 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/var-in-aggregate-misuse/TestVarInAggregateMisuse.py

Show All 16 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/varscript_formatting/TestDataFormatterVarScriptFormatting.py

Show All 17 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 using Python synthetic children provider.""" """Test using Python synthetic children provider."""
self.build() self.build()
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/data-formatter/vector-types/TestVectorTypesFormatting.py

Show All 20 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/dead-strip/TestDeadStrip.py

Show All 12 Lines
class DeadStripTestCase(TestBase): class DeadStripTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr44429") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr44429")
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 27 Lines

lldb/test/API/functionalities/deleted-executable/TestDeletedExecutable.py

Show All 15 Linesclass TestDeletedExecutable(TestBase):
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
@skipIfWindows # cannot delete a running executable @skipIfWindows # cannot delete a running executable
@expectedFailureAll(oslist=["linux"], @expectedFailureAll(oslist=["linux"],
triple=no_match('aarch64-.*-android')) triple=no_match('aarch64-.*-android'))
# determining the architecture of the process fails # determining the architecture of the process fails
def test(self): def test(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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(self, pid_file_path = lldbutil.append_to_process_working_directory(self,
"token_pid_%d" % (int(os.getpid()))) "token_pid_%d" % (int(os.getpid())))
self.addTearDownHook( self.addTearDownHook(
lambda: self.run_platform_command( lambda: self.run_platform_command(
"rm %s" % "rm %s" %
(pid_file_path))) (pid_file_path)))
Show All 12 Lines

lldb/test/API/functionalities/dyld-exec-linux/TestDyldExecLinux.py

Show All 14 Linesclass TestLinux64ExecViaDynamicLoader(TestBase):
@skipIf(oslist=no_match(['linux'])) @skipIf(oslist=no_match(['linux']))
@no_debug_info_test @no_debug_info_test
@skipIf(oslist=["linux"], archs=["arm"]) @skipIf(oslist=["linux"], archs=["arm"])
def test(self): def test(self):
self.build() self.build()
# Extracts path of the interpreter. # Extracts path of the interpreter.
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
spec = lldb.SBModuleSpec() spec = lldb.SBModuleSpec()
spec.SetFileSpec(lldb.SBFileSpec(exe)) spec.SetFileSpec(lldb.SBFileSpec(exe))
interp_section = lldb.SBModule(spec).FindSection(".interp") interp_section = lldb.SBModule(spec).FindSection(".interp")
if not interp_section: if not interp_section:
return return
section_data = interp_section.GetSectionData() section_data = interp_section.GetSectionData()
error = lldb.SBError() error = lldb.SBError()
Show All 30 Lines

lldb/test/API/functionalities/dyld-launch-linux/TestDyldLaunchLinux.py

Show All 13 Linesclass TestLinux64LaunchingViaDynamicLoader(TestBase):
@skipIf(oslist=no_match(['linux'])) @skipIf(oslist=no_match(['linux']))
@no_debug_info_test @no_debug_info_test
@skipIf(oslist=["linux"], archs=["arm"]) @skipIf(oslist=["linux"], archs=["arm"])
def test(self): def test(self):
self.build() self.build()
# Extracts path of the interpreter. # Extracts path of the interpreter.
spec = lldb.SBModuleSpec() spec = lldb.SBModuleSpec()
spec.SetFileSpec(lldb.SBFileSpec(self.getBuildArtifact("a.out"))) spec.SetFileSpec(lldb.SBFileSpec(self.getTestExecutable()))
interp_section = lldb.SBModule(spec).FindSection(".interp") interp_section = lldb.SBModule(spec).FindSection(".interp")
if not interp_section: if not interp_section:
return return
section_data = interp_section.GetSectionData() section_data = interp_section.GetSectionData()
error = lldb.SBError() error = lldb.SBError()
exe = section_data.GetString(error,0) exe = section_data.GetString(error,0)
if error.Fail(): if error.Fail():
return return
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Set breakpoints both on shared library function as well as on # Set breakpoints both on shared library function as well as on
# main. Both of them will be pending breakpoints. # main. Both of them will be pending breakpoints.
breakpoint_main = target.BreakpointCreateBySourceRegex("// Break here", lldb.SBFileSpec("main.cpp")) breakpoint_main = target.BreakpointCreateBySourceRegex("// Break here", lldb.SBFileSpec("main.cpp"))
breakpoint_shared_library = target.BreakpointCreateBySourceRegex("get_signal_crash", lldb.SBFileSpec("signal_file.cpp")) breakpoint_shared_library = target.BreakpointCreateBySourceRegex("get_signal_crash", lldb.SBFileSpec("signal_file.cpp"))
launch_info = lldb.SBLaunchInfo([ "--library-path", self.get_process_working_directory(), self.getBuildArtifact("a.out")]) launch_info = lldb.SBLaunchInfo([ "--library-path", self.get_process_working_directory(), self.getTestExecutable()])
launch_info.SetWorkingDirectory(self.get_process_working_directory()) launch_info.SetWorkingDirectory(self.get_process_working_directory())
error = lldb.SBError() error = lldb.SBError()
process = target.Launch(launch_info, error) process = target.Launch(launch_info, error)
self.assertSuccess(error) self.assertSuccess(error)
# Stopped on main here. # Stopped on main here.
self.assertEqual(process.GetState(), lldb.eStateStopped) self.assertEqual(process.GetState(), lldb.eStateStopped)
thread = process.GetSelectedThread() thread = process.GetSelectedThread()
Show All 12 Lines

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

Show All 29 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() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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/test/API/functionalities/exec/TestExec.py

Show All 32 Linesclass ExecTestCase(TestBase):
@expectedFailureNetBSD @expectedFailureNetBSD
@skipIfAsan # rdar://problem/43756823 @skipIfAsan # rdar://problem/43756823
@skipIfWindows @skipIfWindows
def test_skipping_exec (self): def test_skipping_exec (self):
self.do_test(True) self.do_test(True)
def do_test(self, skip_exec): def do_test(self, skip_exec):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
secondprog = self.getBuildArtifact("secondprog") secondprog = self.getBuildArtifact("secondprog")
# 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
breakpoint1 = target.BreakpointCreateBySourceRegex( breakpoint1 = target.BreakpointCreateBySourceRegex(
'Set breakpoint 1 here', lldb.SBFileSpec("main.cpp", False)) 'Set breakpoint 1 here', lldb.SBFileSpec("main.cpp", False))
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 Linesclass ExecTestCase(TestBase):
@skipIfWindows @skipIfWindows
def test_correct_thread_plan_state_before_exec(self): def test_correct_thread_plan_state_before_exec(self):
''' '''
In this test we make sure that the Thread* cache in the ThreadPlans In this test we make sure that the Thread* cache in the ThreadPlans
is cleared correctly when performing exec is cleared correctly when performing exec
''' '''
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
(target, process, thread, breakpoint1) = lldbutil.run_to_source_breakpoint( (target, process, thread, breakpoint1) = lldbutil.run_to_source_breakpoint(
self, 'Set breakpoint 1 here', lldb.SBFileSpec('main.cpp', False)) self, 'Set breakpoint 1 here', lldb.SBFileSpec('main.cpp', False))
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.assertEqual(process.GetState(), lldb.eStateStopped, self.assertEqual(process.GetState(), lldb.eStateStopped,
STOPPED_DUE_TO_BREAKPOINT) STOPPED_DUE_TO_BREAKPOINT)
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

lldb/test/API/functionalities/fat_archives/TestFatArchives.py

Show All 24 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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/test/API/functionalities/find-line-entry/TestFindLineEntry.py

""" """
Test that SBCompileUnit::FindLineEntryIndex works correctly. Test that SBCompileUnit::FindLineEntryIndex works correctly.
""" """
import lldb import lldb
import lldbsuite.test.lldbutil as lldbutil import lldbsuite.test.lldbutil as lldbutil
from lldbsuite.test.lldbtest import * from lldbsuite.test.lldbtest import *
class FindLineEntry(TestBase): class FindLineEntry(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def test_compile_unit_find_line_entry_index(self): def test_compile_unit_find_line_entry_index(self):
""" Test the CompileUnit LineEntryIndex lookup API """ """ Test the CompileUnit LineEntryIndex lookup API """
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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")
self.file = lldb.SBFileSpec("main.c") self.file = lldb.SBFileSpec("main.c")
sc_list = self.target.FindCompileUnits(self.file) sc_list = self.target.FindCompileUnits(self.file)
self.assertEqual(len(sc_list), 1) self.assertEqual(len(sc_list), 1)
cu = sc_list[0].GetCompileUnit() cu = sc_list[0].GetCompileUnit()
self.assertTrue(cu.IsValid(), "CompileUnit is not valid") self.assertTrue(cu.IsValid(), "CompileUnit is not valid")
Show All 9 Lines

lldb/test/API/functionalities/gdb_remote_client/TestPlatformKill.py

Show All 9 Linesclass TestPlatformKill(GDBRemoteTestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipIfRemote @skipIfRemote
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr52451") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr52451")
def test_kill_different_platform(self): def test_kill_different_platform(self):
"""Test connecting to a remote linux platform""" """Test connecting to a remote linux platform"""
self.build(dictionary={"CXX_SOURCES":"sleep.cpp"}) self.build(dictionary={"CXX_SOURCES":"sleep.cpp"})
host_process = self.spawnSubprocess(self.getBuildArtifact("a.out")) host_process = self.spawnSubprocess(self.getTestExecutable())
# Create a fake remote process with the same PID as host_process # Create a fake remote process with the same PID as host_process
class MyResponder(MockGDBServerResponder): class MyResponder(MockGDBServerResponder):
def __init__(self): def __init__(self):
MockGDBServerResponder.__init__(self) MockGDBServerResponder.__init__(self)
self.got_kill = False self.got_kill = False
def qC(self): def qC(self):
Show All 25 Lines

lldb/test/API/functionalities/inferior-assert/TestInferiorAssert.py

Show First 20 Lines • Show All 120 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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",
patterns=[stop_reason], patterns=[stop_reason],
substrs=['main', 'argc', 'argv']) substrs=['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",
patterns=[stop_reason], patterns=[stop_reason],
substrs=['main.c:%d' % self.line]) substrs=['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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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()
# change current frame to frame 0, since recognizer might have selected # change current frame to frame 0, since recognizer might have selected
# different frame. # different frame.
self.runCmd("frame select 0", RUN_SUCCEEDED) self.runCmd("frame select 0", RUN_SUCCEEDED)
# 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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/test/API/functionalities/inferior-changed/TestInferiorChanged.py

Show All 33 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 = self.getBuildArtifact("a.out") self.exe = self.getTestExecutable()
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/test/API/functionalities/inferior-crashing/TestInferiorCrashing.py

Show First 20 Lines • Show All 52 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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'])

lldb/test/API/functionalities/inferior-crashing/TestInferiorCrashingStep.py

Show First 20 Lines • Show All 73 Lines • ▼ Show 20 Linesclass CrashingInferiorStepTestCase(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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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( self.expect(
"thread list", "thread list",
STOPPED_DUE_TO_EXC_BAD_ACCESS, STOPPED_DUE_TO_EXC_BAD_ACCESS,
substrs=['stopped', stop_reason]) substrs=['stopped', stop_reason])
# And it should report the correct line number. # And it should report the correct line number.
self.expect( self.expect(
"thread backtrace all", "thread backtrace all",
substrs=[stop_reason, 'main.c:%d' % self.line]) substrs=[stop_reason, '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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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(None, None, process = target.LaunchSimple(None, None,
self.get_process_working_directory()) 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()))
threads = lldbutil.get_crashed_threads(self, process) threads = lldbutil.get_crashed_threads(self, process)
self.assertEqual( self.assertEqual(
len(threads), 1, len(threads), 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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", startstr='(int) $0 = 1') self.expect("p argc", startstr='(int) $0 = 1')
self.expect("p hello_world", substrs=['Hello']) self.expect("p hello_world", 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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( self.expect(
"thread list", "thread list",
STOPPED_DUE_TO_BREAKPOINT, STOPPED_DUE_TO_BREAKPOINT,
Show All 12 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", substrs=['main.c:%d' % self.line]) self.expect("thread backtrace all", substrs=['main.c:%d' % self.line])
@expectedFailureNetBSD @expectedFailureNetBSD
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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", substrs=['Process', expected_state]) self.expect("next", 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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]", substrs=['a.out']) self.expect("p argv[0]", substrs=['a.out'])
self.runCmd("next") self.runCmd("next")
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]", substrs=['a.out']) self.expect("p argv[0]", substrs=['a.out'])

lldb/test/API/functionalities/inferior-crashing/recursive-inferior/TestRecursiveInferior.py

Show First 20 Lines • Show All 49 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 18 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 =')

lldb/test/API/functionalities/inferior-crashing/recursive-inferior/TestRecursiveInferiorStep.py

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Linesclass CrashingRecursiveInferiorStepTestCase(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_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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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( self.expect(
"thread list", "thread list",
STOPPED_DUE_TO_BREAKPOINT, STOPPED_DUE_TO_BREAKPOINT,
Show All 10 Lines def recursive_inferior_crashing_step(self):
# crashing. # crashing.
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", substrs=['main.c:%d' % self.line]) self.expect("thread backtrace all", 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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", substrs=['Process', expected_state]) self.expect("next", 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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", startstr='(char *) $0 = 0x0') self.expect("p null", startstr='(char *) $0 = 0x0')
self.runCmd("next") self.runCmd("next")
# 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 step. # of the inferior after a step.
self.expect("p null", startstr='(char *) $1 = 0x0') self.expect("p null", startstr='(char *) $1 = 0x0')
self.check_stop_reason() self.check_stop_reason()

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

Show First 20 Lines • Show All 136 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/jitloader_gdb/TestJITLoaderGDB.py

Show All 14 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")
@expectedFailure("llvm.org/pr24702") @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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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())
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

lldb/test/API/functionalities/limit-debug-info/TestLimitDebugInfo.py

Show All 31 Linesclass LimitDebugInfoTestCase(TestBase):
@skipIf(bugnumber="pr46284", debug_info="gmodules") @skipIf(bugnumber="pr46284", debug_info="gmodules")
@skipIfWindows # Clang emits type info even with -flimit-debug-info @skipIfWindows # Clang emits type info even with -flimit-debug-info
# Requires DW_CC_pass_by_* attributes from Clang 7 to correctly call # Requires DW_CC_pass_by_* attributes from Clang 7 to correctly call
# by-value functions. # by-value functions.
@skipIf(compiler="clang", compiler_version=['<', '7.0']) @skipIf(compiler="clang", compiler_version=['<', '7.0'])
def test_one_and_two_debug(self): def test_one_and_two_debug(self):
self.build() self.build()
target = self.dbg.CreateTarget(self.getBuildArtifact("a.out")) target = self.dbg.CreateTarget(self.getTestExecutable())
self._check_debug_info_is_limited(target) self._check_debug_info_is_limited(target)
lldbutil.run_to_name_breakpoint(self, "main", lldbutil.run_to_name_breakpoint(self, "main",
extra_images=["one", "two"]) extra_images=["one", "two"])
# But when other shared libraries are loaded, we should be able to see # But when other shared libraries are loaded, we should be able to see
# all members. # all members.
Show All 22 Linesclass LimitDebugInfoTestCase(TestBase):
@skipIf(bugnumber="pr46284", debug_info="gmodules") @skipIf(bugnumber="pr46284", debug_info="gmodules")
@skipIfWindows # Clang emits type info even with -flimit-debug-info @skipIfWindows # Clang emits type info even with -flimit-debug-info
# Requires DW_CC_pass_by_* attributes from Clang 7 to correctly call # Requires DW_CC_pass_by_* attributes from Clang 7 to correctly call
# by-value functions. # by-value functions.
@skipIf(compiler="clang", compiler_version=['<', '7.0']) @skipIf(compiler="clang", compiler_version=['<', '7.0'])
def test_two_debug(self): def test_two_debug(self):
self.build(dictionary=dict(STRIP_ONE="1")) self.build(dictionary=dict(STRIP_ONE="1"))
target = self.dbg.CreateTarget(self.getBuildArtifact("a.out")) target = self.dbg.CreateTarget(self.getTestExecutable())
self._check_debug_info_is_limited(target) self._check_debug_info_is_limited(target)
lldbutil.run_to_name_breakpoint(self, "main", lldbutil.run_to_name_breakpoint(self, "main",
extra_images=["one", "two"]) extra_images=["one", "two"])
# This time, we should only see the members from the second library. # This time, we should only see the members from the second library.
self.expect_expr("inherits_from_one.member", result_value="47") self.expect_expr("inherits_from_one.member", result_value="47")
Show All 26 Linesclass LimitDebugInfoTestCase(TestBase):
@skipIf(bugnumber="pr46284", debug_info="gmodules") @skipIf(bugnumber="pr46284", debug_info="gmodules")
@skipIfWindows # Clang emits type info even with -flimit-debug-info @skipIfWindows # Clang emits type info even with -flimit-debug-info
# Requires DW_CC_pass_by_* attributes from Clang 7 to correctly call # Requires DW_CC_pass_by_* attributes from Clang 7 to correctly call
# by-value functions. # by-value functions.
@skipIf(compiler="clang", compiler_version=['<', '7.0']) @skipIf(compiler="clang", compiler_version=['<', '7.0'])
def test_one_debug(self): def test_one_debug(self):
self.build(dictionary=dict(STRIP_TWO="1")) self.build(dictionary=dict(STRIP_TWO="1"))
target = self.dbg.CreateTarget(self.getBuildArtifact("a.out")) target = self.dbg.CreateTarget(self.getTestExecutable())
self._check_debug_info_is_limited(target) self._check_debug_info_is_limited(target)
lldbutil.run_to_name_breakpoint(self, "main", lldbutil.run_to_name_breakpoint(self, "main",
extra_images=["one", "two"]) extra_images=["one", "two"])
# In this case we should only see the members from the second library. # In this case we should only see the members from the second library.
# Note that we cannot see inherits_from_two.one because without debug # Note that we cannot see inherits_from_two.one because without debug
Show All 29 Lines

lldb/test/API/functionalities/load_after_attach/TestLoadAfterAttach.py

Show All 9 Linesclass TestCase(TestBase):
@skipIfRemote @skipIfRemote
def test_load_after_attach(self): def test_load_after_attach(self):
self.build() self.build()
ctx = self.platformContext ctx = self.platformContext
lib_name = ctx.shlib_prefix + 'lib_b.' + ctx.shlib_extension lib_name = ctx.shlib_prefix + 'lib_b.' + ctx.shlib_extension
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
lib = self.getBuildArtifact(lib_name) lib = self.getBuildArtifact(lib_name)
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
environment = self.registerSharedLibrariesWithTarget(target, ["lib_b"]) environment = self.registerSharedLibrariesWithTarget(target, ["lib_b"])
# Spawn a new process. # Spawn a new process.
# use realpath to workaround llvm.org/pr48376 # use realpath to workaround llvm.org/pr48376
# Pass path to solib for dlopen to properly locate the library. # Pass path to solib for dlopen to properly locate the library.
Show All 32 Lines

lldb/test/API/functionalities/load_unload/TestLoadUnload.py

Show First 20 Lines • Show All 99 Lines • ▼ Show 20 Lines def test_modules_search_paths(self):
else: else:
dylibName = 'libloadunload_d.so' dylibName = 'libloadunload_d.so'
# The directory with the dynamic library we did not link to. # The directory with the dynamic library we did not link to.
new_dir = os.path.join(self.getBuildDir(), "hidden") new_dir = os.path.join(self.getBuildDir(), "hidden")
old_dylib = os.path.join(self.getBuildDir(), dylibName) old_dylib = os.path.join(self.getBuildDir(), dylibName)
new_dylib = os.path.join(new_dir, dylibName) new_dylib = os.path.join(new_dir, dylibName)
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 30 Linesclass LoadUnloadTestCase(TestBase):
@expectedFailureAll(oslist=["freebsd", "linux", "netbsd"]) @expectedFailureAll(oslist=["freebsd", "linux", "netbsd"])
@expectedFailureAndroid # wrong source file shows up for hidden library @expectedFailureAndroid # wrong source file shows up for hidden library
@skipIfWindows # Windows doesn't have dlopen and friends, dynamic libraries work differently @skipIfWindows # Windows doesn't have dlopen and friends, dynamic libraries work differently
@skipIfDarwinEmbedded @skipIfDarwinEmbedded
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."""
self.copy_shlibs_to_remote(hidden_dir=True) self.copy_shlibs_to_remote(hidden_dir=True)
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 51 Lines • ▼ Show 20 Linesclass LoadUnloadTestCase(TestBase):
def test_lldb_process_load_and_unload_commands_with_svr4(self): def test_lldb_process_load_and_unload_commands_with_svr4(self):
self.setSvr4Support(True) self.setSvr4Support(True)
self.run_lldb_process_load_and_unload_commands() self.run_lldb_process_load_and_unload_commands()
def run_lldb_process_load_and_unload_commands(self): def run_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."""
self.copy_shlibs_to_remote() self.copy_shlibs_to_remote()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 72 Lines • ▼ Show 20 Linesclass LoadUnloadTestCase(TestBase):
def test_load_unload_with_svr4(self): def test_load_unload_with_svr4(self):
self.setSvr4Support(True) self.setSvr4Support(True)
self.run_load_unload() self.run_load_unload()
def run_load_unload(self): def run_load_unload(self):
"""Test breakpoint by name works correctly with dlopen'ing.""" """Test breakpoint by name works correctly with dlopen'ing."""
self.copy_shlibs_to_remote() self.copy_shlibs_to_remote()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 27 Linesclass LoadUnloadTestCase(TestBase):
def test_step_over_load_with_svr4(self): def test_step_over_load_with_svr4(self):
self.setSvr4Support(True) self.setSvr4Support(True)
self.run_step_over_load() self.run_step_over_load()
def run_step_over_load(self): def run_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."""
self.copy_shlibs_to_remote() self.copy_shlibs_to_remote()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 13 Linesclass LoadUnloadTestCase(TestBase):
# We can't find a breakpoint location for d_init before launching because # We can't find a breakpoint location for d_init before launching because
# executable dependencies are resolved relative to the debuggers PWD. Bug? # executable dependencies are resolved relative to the debuggers PWD. Bug?
@expectedFailureAll(oslist=["freebsd", "linux", "netbsd"], triple=no_match('aarch64-.*-android')) @expectedFailureAll(oslist=["freebsd", "linux", "netbsd"], triple=no_match('aarch64-.*-android'))
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.copy_shlibs_to_remote() self.copy_shlibs_to_remote()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/location-list-lookup/TestLocationListLookup.py

Show All 11 Linesclass LocationListLookupTestCase(TestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
@skipIf(oslist=["linux"], archs=["arm"]) @skipIf(oslist=["linux"], archs=["arm"])
def test_loclist(self): def test_loclist(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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)
self.dbg.SetAsync(False) self.dbg.SetAsync(False)
li = lldb.SBLaunchInfo(["a.out"]) li = lldb.SBLaunchInfo(["a.out"])
error = lldb.SBError() error = lldb.SBError()
Show All 13 Lines

lldb/test/API/functionalities/longjmp/TestLongjmp.py

Show All 36 Linesclass LongjmpTestCase(TestBase):
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
@expectedFlakeyNetBSD @expectedFlakeyNetBSD
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/memory-region/TestMemoryRegion.py

Show All 27 Lines def test_help(self):
self.expect("help memory region", self.expect("help memory region",
substrs=["memory region <address-expression>", substrs=["memory region <address-expression>",
"memory region -a"]) "memory region -a"])
def test(self): def test(self):
self.build() self.build()
# Set breakpoint in main and run # Set breakpoint in main and run
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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)
interp = self.dbg.GetCommandInterpreter() interp = self.dbg.GetCommandInterpreter()
result = lldb.SBCommandReturnObject() result = lldb.SBCommandReturnObject()
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

lldb/test/API/functionalities/memory/cache/TestMemoryCache.py

Show All 18 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.')
@skipIfWindows # This is flakey on Windows: llvm.org/pr38373 @skipIfWindows # This is flakey on Windows: llvm.org/pr38373
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 26 Lines

lldb/test/API/functionalities/memory/find/TestMemoryFind.py

Show All 17 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_memory_find(self): def test_memory_find(self):
"""Test the 'memory find' command.""" """Test the 'memory find' command."""
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 20 Lines • Show All 42 Lines • Show Last 20 Lines

lldb/test/API/functionalities/memory/tag/TestMemoryTag.py

Show All 16 Linesclass MemoryTagTestCase(TestBase):
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
def test_memory_tag_read_unsupported(self): def test_memory_tag_read_unsupported(self):
"""Test that "memory tag read" errors on unsupported platforms""" """Test that "memory tag read" errors on unsupported platforms"""
if self.isAArch64MTE(): if self.isAArch64MTE():
self.skipTest("Requires a target without AArch64 MTE.") self.skipTest("Requires a target without AArch64 MTE.")
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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", lldbutil.run_break_set_by_file_and_line(self, "main.cpp",
line_number('main.cpp', '// Breakpoint here'), line_number('main.cpp', '// Breakpoint here'),
num_expected_locations=1) num_expected_locations=1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
# If you're on AArch64 you could have MTE but the remote process # If you're on AArch64 you could have MTE but the remote process
Show All 9 Lines

lldb/test/API/functionalities/module_cache/bsd/TestModuleCacheBSD.py

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Lines def test(self):
original a.o original a.o
We do this to test that we can correctly cache duplicate .o files We do this to test that we can correctly cache duplicate .o files
that appear in .a files. that appear in .a files.
This test only works on darwin because of the way DWARF is stored This test only works on darwin because of the way DWARF is stored
where the debug map will refer to .o files inside of .a files. where the debug map will refer to .o files inside of .a files.
""" """
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# Create a module with no depedencies. # Create a module with no depedencies.
target = self.createTestTarget(load_dependent_modules=False) target = self.createTestTarget(load_dependent_modules=False)
self.runCmd('breakpoint set -f a.c -l %d' % (self.line_a)) self.runCmd('breakpoint set -f a.c -l %d' % (self.line_a))
self.runCmd('breakpoint set -f b.c -l %d' % (self.line_b)) self.runCmd('breakpoint set -f b.c -l %d' % (self.line_b))
self.runCmd('breakpoint set -f c.c -l %d' % (self.line_c)) self.runCmd('breakpoint set -f c.c -l %d' % (self.line_c))
Show All 26 Lines

lldb/test/API/functionalities/module_cache/simple_exe/TestModuleCacheSimple.py

Show All 38 Lines def test(self):
This will test that if we enable the module cache, we have a This will test that if we enable the module cache, we have a
corresponding index cache entry for the symbol table for the corresponding index cache entry for the symbol table for the
executable. It also removes the executable, rebuilds so that the executable. It also removes the executable, rebuilds so that the
modification time of the binary gets updated, and then creates a new modification time of the binary gets updated, and then creates a new
target and should cause the cache to get updated so the cache file target and should cause the cache to get updated so the cache file
should get an updated modification time. should get an updated modification time.
""" """
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# Create a module with no depedencies. # Create a module with no depedencies.
target = self.createTestTarget(load_dependent_modules=False) target = self.createTestTarget(load_dependent_modules=False)
# Get the executable module and get the number of symbols to make # Get the executable module and get the number of symbols to make
# sure the symbol table gets parsed and cached. The module cache is # sure the symbol table gets parsed and cached. The module cache is
# enabled in the setUp() function. # enabled in the setUp() function.
main_module = target.GetModuleAtIndex(0) main_module = target.GetModuleAtIndex(0)
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

lldb/test/API/functionalities/mtc/simple/TestMTCSimple.py

Show All 24 Lines def test(self):
self.mtc_tests() self.mtc_tests()
@skipIf(archs=['i386']) @skipIf(archs=['i386'])
@skipIf(compiler="clang", compiler_version=['<', '9.0']) @skipIf(compiler="clang", compiler_version=['<', '9.0'])
def mtc_tests(self): def mtc_tests(self):
self.assertNotEqual(self.mtc_dylib_path, "") self.assertNotEqual(self.mtc_dylib_path, "")
# Load the test # Load the test
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 25 Lines

lldb/test/API/functionalities/non-overlapping-index-variable-i/TestIndexVariable.py

Show All 16 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.runCmd("file " + self.getBuildArtifact("a.out"), self.runCmd("file " + self.getTestExecutable(),
CURRENT_EXECUTABLE_SET) CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, self,
self.source, self.source,
self.line_to_break, self.line_to_break,
num_expected_locations=1, num_expected_locations=1,
loc_exact=True) loc_exact=True)
Show All 14 Lines

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

Show All 36 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.
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
python_os_plugin_path = os.path.join(self.getSourceDir(), python_os_plugin_path = os.path.join(self.getSourceDir(),
"operating_system.py") "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.
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
python_os_plugin_path = os.path.join(self.getSourceDir(), python_os_plugin_path = os.path.join(self.getSourceDir(),
"operating_system2.py") "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 58 Lines • Show Last 20 Lines

lldb/test/API/functionalities/postmortem/minidump/TestMiniDump.py

Show First 20 Lines • Show All 106 Lines • ▼ Show 20 Lines def test_stack_info_in_mini_dump(self):
self.assertTrue(frame.IsValid()) self.assertTrue(frame.IsValid())
self.assertEqual(frame.GetPC(), pc_list[i]) self.assertEqual(frame.GetPC(), pc_list[i])
self.assertTrue(frame.GetModule().IsValid()) self.assertTrue(frame.GetModule().IsValid())
@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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
core = self.getBuildArtifact("core.dmp") core = self.getBuildArtifact("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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
core = self.getBuildArtifact("core.dmp") core = self.getBuildArtifact("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/test/API/functionalities/pre_run_dylibs/TestPreRunDylibs.py

Show All 9 Linesclass TestPreRunLibraries(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
@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(self.getBuildArtifact("a.out")) target = self.dbg.CreateTarget(self.getTestExecutable())
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/test/API/functionalities/process_crash_info/TestProcessCrashInfo.py

Show All 25 Lines def tearDown(self):
TestBase.tearDown(self) TestBase.tearDown(self)
@skipIfAsan # The test process intentionally double-frees. @skipIfAsan # The test process intentionally double-frees.
@skipUnlessDarwin @skipUnlessDarwin
def test_cli(self): def test_cli(self):
"""Test that `process status --verbose` fetches the extended crash """Test that `process status --verbose` fetches the extended crash
information dictionary from the command-line properly.""" information dictionary from the command-line properly."""
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
self.expect("file " + exe, self.expect("file " + exe,
patterns=["Current executable set to .*a.out"]) patterns=["Current executable set to .*a.out"])
self.expect('process launch', self.expect('process launch',
patterns=["Process .* launched: .*a.out"]) patterns=["Process .* launched: .*a.out"])
self.expect('process status --verbose', self.expect('process status --verbose',
patterns=["\"message\".*pointer being freed was not allocated"]) patterns=["\"message\".*pointer being freed was not allocated"])
@skipIfAsan # The test process intentionally hits a memory bug. @skipIfAsan # The test process intentionally hits a memory bug.
@skipUnlessDarwin @skipUnlessDarwin
def test_api(self): def test_api(self):
"""Test that lldb can fetch a crashed process' extended crash information """Test that lldb can fetch a crashed process' extended crash information
dictionary from the api properly.""" dictionary from the api properly."""
self.build() self.build()
target = self.dbg.CreateTarget(self.getBuildArtifact("a.out")) target = self.dbg.CreateTarget(self.getTestExecutable())
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
target.LaunchSimple(None, None, os.getcwd()) target.LaunchSimple(None, None, os.getcwd())
stream = lldb.SBStream() stream = lldb.SBStream()
self.assertTrue(stream) self.assertTrue(stream)
process = target.GetProcess() process = target.GetProcess()
Show All 32 Lines

lldb/test/API/functionalities/process_group/TestChangeProcessGroup.py

Show All 22 Linesclass ChangeProcessGroupTestCase(TestBase):
@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])
@expectedFailureNetBSD @expectedFailureNetBSD
@skipIftvOS # fork not available on tvOS. @skipIftvOS # fork not available on tvOS.
@skipIfwatchOS # fork not available on watchOS. @skipIfwatchOS # fork not available on watchOS.
def test_setpgid(self): def test_setpgid(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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(self, pid_file_path = lldbutil.append_to_process_working_directory(self,
"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/test/API/functionalities/process_save_core/TestProcessSaveCore.py

Show All 13 Linesclass ProcessSaveCoreTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipIfRemote @skipIfRemote
@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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
core = self.getBuildArtifact("core.dmp") core = self.getBuildArtifact("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())
@skipIfRemote @skipIfRemote
@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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
core = self.getBuildArtifact("core.dmp") core = self.getBuildArtifact("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 17 Lines def test_save_windows_mini_dump(self):
# Clean up the mini dump file. # Clean up the mini dump file.
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)
@skipUnlessPlatform(["freebsd", "netbsd"]) @skipUnlessPlatform(["freebsd", "netbsd"])
def test_save_core_via_process_plugin(self): def test_save_core_via_process_plugin(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
core = self.getBuildArtifact("a.out.core") core = self.getBuildArtifact("a.out.core")
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 15 Lines

lldb/test/API/functionalities/process_save_core_minidump/TestProcessSaveCoreMinidump.py

Show All 13 Linesclass ProcessSaveCoreMinidumpTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipUnlessArch("x86_64") @skipUnlessArch("x86_64")
@skipUnlessPlatform(["linux"]) @skipUnlessPlatform(["linux"])
def test_save_linux_mini_dump(self): def test_save_linux_mini_dump(self):
"""Test that we can save a Linux mini dump.""" """Test that we can save a Linux mini dump."""
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
core = self.getBuildArtifact("core.dmp") core = self.getBuildArtifact("core.dmp")
try: try:
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.assertEqual(process.GetState(), lldb.eStateStopped) self.assertEqual(process.GetState(), lldb.eStateStopped)
# get neccessary data for the verification phase # get neccessary data for the verification phase
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

lldb/test/API/functionalities/progress_reporting/TestTrimmedProgressReporting.py

Show All 19 Lines def do_test(self, term_width, pattern_list):
self.build() self.build()
# Start with a small window # Start with a small window
self.launch(use_colors=True) self.launch(use_colors=True)
self.expect("set set show-progress true") self.expect("set set show-progress true")
self.expect("set show show-progress", substrs=["show-progress (boolean) = true"]) self.expect("set show show-progress", substrs=["show-progress (boolean) = true"])
self.expect("set set term-width " + str(term_width)) self.expect("set set term-width " + str(term_width))
self.expect("set show term-width", substrs=["term-width (int) = " + str(term_width)]) self.expect("set show term-width", substrs=["term-width (int) = " + str(term_width)])
self.child.send("file " + self.getBuildArtifact("a.out") + "\n") self.child.send("file " + self.getTestExecutable() + "\n")
self.child.expect(pattern_list) self.child.expect(pattern_list)
# PExpect uses many timeouts internally and doesn't play well # PExpect uses many timeouts internally and doesn't play well
# under ASAN on a loaded machine.. # under ASAN on a loaded machine..
@skipIfAsan @skipIfAsan
@skipUnlessDarwin @skipUnlessDarwin
@skipIfEditlineSupportMissing @skipIfEditlineSupportMissing
Show All 14 Lines

lldb/test/API/functionalities/ptr_refs/TestPtrRefs.py

Show All 12 Linesclass TestPtrRefs(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipIfAsan # The output looks different under ASAN. @skipIfAsan # The output looks different under ASAN.
@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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/recursion/TestValueObjectRecursion.py

Show All 19 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.')
@no_debug_info_test @no_debug_info_test
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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/functionalities/rerun/TestRerun.py

Show All 9 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/return-value/TestReturnValue.py

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
(self.target, self.process, thread, inner_sint_bkpt) = lldbutil.run_to_name_breakpoint(self, "inner_sint", exe_name = exe) (self.target, self.process, thread, inner_sint_bkpt) = lldbutil.run_to_name_breakpoint(self, "inner_sint", exe_name = exe)
error = lldb.SBError() error = lldb.SBError()
# inner_sint returns the variable value, so capture that here: # inner_sint returns the variable value, so capture that here:
in_int = thread.GetFrameAtIndex(0).FindVariable( in_int = thread.GetFrameAtIndex(0).FindVariable(
"value").GetValueAsSigned(error) "value").GetValueAsSigned(error)
self.assertSuccess(error) self.assertSuccess(error)
▲ Show 20 Lines • Show All 111 Lines • ▼ Show 20 Lines @expectedFailureAll(
compiler_version=[ compiler_version=[
"<=", "<=",
"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"], archs=["i[3-6]86", "x86_64"], bugnumber="llvm.org/pr24778") @expectedFailureAll(oslist=["windows"], archs=["i[3-6]86", "x86_64"], bugnumber="llvm.org/pr24778")
def test_vector_values(self): def test_vector_values(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 All 10 Lines def test_vector_values(self):
if not self.affected_by_pr44132(): if not self.affected_by_pr44132():
self.return_and_test_struct_value("return_ext_vector_size_float32_8") self.return_and_test_struct_value("return_ext_vector_size_float32_8")
# limit the nested struct and class tests to only x86_64 # limit the nested struct and class tests to only x86_64
@skipIf(archs=no_match(['x86_64'])) @skipIf(archs=no_match(['x86_64']))
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
def test_for_cpp_support(self): def test_for_cpp_support(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
(self.target, self.process, thread, inner_sint_bkpt) = lldbutil.run_to_name_breakpoint(self, "inner_sint", exe_name = exe) (self.target, self.process, thread, inner_sint_bkpt) = lldbutil.run_to_name_breakpoint(self, "inner_sint", exe_name = exe)
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)
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

lldb/test/API/functionalities/scripted_process/TestScriptedProcess.py

Show First 20 Lines • Show All 61 Lines • ▼ Show 20 Lines def test_invalid_scripted_register_context(self):
os.environ['SKIP_SCRIPTED_PROCESS_LAUNCH'] = '1' os.environ['SKIP_SCRIPTED_PROCESS_LAUNCH'] = '1'
def cleanup(): def cleanup():
del os.environ["SKIP_SCRIPTED_PROCESS_LAUNCH"] del os.environ["SKIP_SCRIPTED_PROCESS_LAUNCH"]
self.addTearDownHook(cleanup) self.addTearDownHook(cleanup)
self.runCmd("settings set target.load-script-from-symbol-file true") self.runCmd("settings set target.load-script-from-symbol-file true")
self.move_blueprint_to_dsym('invalid_scripted_process.py') self.move_blueprint_to_dsym('invalid_scripted_process.py')
target = self.dbg.CreateTarget(self.getBuildArtifact("a.out")) target = self.dbg.CreateTarget(self.getTestExecutable())
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
log_file = self.getBuildArtifact('thread.log') log_file = self.getBuildArtifact('thread.log')
self.runCmd("log enable lldb thread -f " + log_file) self.runCmd("log enable lldb thread -f " + log_file)
self.assertTrue(os.path.isfile(log_file)) self.assertTrue(os.path.isfile(log_file))
launch_info = lldb.SBLaunchInfo(None) launch_info = lldb.SBLaunchInfo(None)
launch_info.SetProcessPluginName("ScriptedProcess") launch_info.SetProcessPluginName("ScriptedProcess")
launch_info.SetScriptedProcessClassName("a_out.InvalidScriptedProcess") launch_info.SetScriptedProcessClassName("a_out.InvalidScriptedProcess")
Show All 13 Linesclass ScriptedProcesTestCase(TestBase):
@skipUnlessDarwin @skipUnlessDarwin
def test_scripted_process_and_scripted_thread(self): def test_scripted_process_and_scripted_thread(self):
"""Test that we can launch an lldb scripted process using the SBAPI, """Test that we can launch an lldb scripted process using the SBAPI,
check its process ID, read string from memory, check scripted thread check its process ID, read string from memory, check scripted thread
id, name stop reason and register context. id, name stop reason and register context.
""" """
self.build() self.build()
target = self.dbg.CreateTarget(self.getBuildArtifact("a.out")) target = self.dbg.CreateTarget(self.getTestExecutable())
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
os.environ['SKIP_SCRIPTED_PROCESS_LAUNCH'] = '1' os.environ['SKIP_SCRIPTED_PROCESS_LAUNCH'] = '1'
def cleanup(): def cleanup():
del os.environ["SKIP_SCRIPTED_PROCESS_LAUNCH"] del os.environ["SKIP_SCRIPTED_PROCESS_LAUNCH"]
self.addTearDownHook(cleanup) self.addTearDownHook(cleanup)
scripted_process_example_relpath = 'dummy_scripted_process.py' scripted_process_example_relpath = 'dummy_scripted_process.py'
Show All 40 Lines

lldb/test/API/functionalities/scripted_process/TestStackCoreScriptedProcess.py

Show All 39 Linesclass StackCoreScriptedProcesTestCase(TestBase):
@skipUnlessDarwin @skipUnlessDarwin
@skipIfOutOfTreeDebugserver @skipIfOutOfTreeDebugserver
@skipIfRemote @skipIfRemote
def test_launch_scripted_process_stack_frames(self): def test_launch_scripted_process_stack_frames(self):
"""Test that we can launch an lldb scripted process from the command """Test that we can launch an lldb scripted process from the command
line, check its process ID and read string from memory.""" line, check its process ID and read string from memory."""
self.build() self.build()
target = self.dbg.CreateTarget(self.getBuildArtifact("a.out")) target = self.dbg.CreateTarget(self.getTestExecutable())
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
main_module = self.get_module_with_name(target, 'a.out') main_module = self.get_module_with_name(target, 'a.out')
self.assertTrue(main_module, "Invalid main module.") self.assertTrue(main_module, "Invalid main module.")
error = target.SetModuleLoadAddress(main_module, 0) error = target.SetModuleLoadAddress(main_module, 0)
self.assertSuccess(error, "Reloading main module at offset 0 failed.") self.assertSuccess(error, "Reloading main module at offset 0 failed.")
scripted_dylib = self.get_module_with_name(target, 'libbaz.dylib') scripted_dylib = self.get_module_with_name(target, 'libbaz.dylib')
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

lldb/test/API/functionalities/set-data/TestSetData.py

Show All 12 Lines
class SetDataTestCase(TestBase): class SetDataTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@add_test_categories(["objc"]) @add_test_categories(["objc"])
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/signal/TestSendSignal.py

Show All 17 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', 'Put breakpoint here') self.line = line_number('main.c', 'Put breakpoint here')
@expectedFailureNetBSD(bugnumber='llvm.org/pr43959') @expectedFailureNetBSD(bugnumber='llvm.org/pr43959')
@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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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 79 Lines • Show Last 20 Lines

lldb/test/API/functionalities/signal/handle-abrt/TestHandleAbort.py

Show All 16 Linesclass HandleAbortTestCase(TestBase):
@skipIfWindows # signals do not exist on Windows @skipIfWindows # signals do not exist on Windows
@expectedFailureNetBSD @expectedFailureNetBSD
def test_inferior_handle_sigabrt(self): def test_inferior_handle_sigabrt(self):
"""Inferior calls abort() and handles the resultant SIGABRT. """Inferior calls abort() and handles the resultant SIGABRT.
Stopped at a breakpoint in the handler, verify that the backtrace Stopped at a breakpoint in the handler, verify that the backtrace
includes the function that called abort().""" includes the function that called abort()."""
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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 37 Lines

lldb/test/API/functionalities/signal/handle-segv/TestHandleSegv.py

Show All 12 Linesclass 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
@expectedFailureNetBSD @expectedFailureNetBSD
def test_inferior_handle_sigsegv(self): def test_inferior_handle_sigsegv(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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/test/API/functionalities/signal/raise/TestRaise.py

Show First 20 Lines • Show All 56 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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")
self.default_pass = "" self.default_pass = ""
self.default_stop = "" self.default_stop = ""
self.default_notify = "" self.default_notify = ""
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

lldb/test/API/functionalities/stats_api/TestStatisticsAPI.py

# Test the SBAPI for GetStatistics() # Test the SBAPI for GetStatistics()
import json import json
import lldb import lldb
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
class TestStatsAPI(TestBase): class TestStatsAPI(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
def test_stats_api(self): def test_stats_api(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
# Test enabling/disabling stats # Test enabling/disabling stats
self.assertFalse(target.GetCollectingStats()) self.assertFalse(target.GetCollectingStats())
target.SetCollectingStats(True) target.SetCollectingStats(True)
self.assertTrue(target.GetCollectingStats()) self.assertTrue(target.GetCollectingStats())
target.SetCollectingStats(False) target.SetCollectingStats(False)
self.assertFalse(target.GetCollectingStats()) self.assertFalse(target.GetCollectingStats())
Show All 25 Lines

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

Show First 20 Lines • Show All 83 Lines • ▼ Show 20 Linesclass StepAvoidsNoDebugTestCase(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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/tail_call_frames/cross_dso/TestCrossDSOTailCalls.py

Show All 15 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
@skipIf(compiler="clang", compiler_version=['<', '10.0']) @skipIf(compiler="clang", compiler_version=['<', '10.0'])
@skipIf(dwarf_version=['<', '4']) @skipIf(dwarf_version=['<', '4'])
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr26265") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr26265")
@expectedFailureAll(archs=['arm', 'aarch64'], bugnumber="llvm.org/PR44561") @expectedFailureAll(archs=['arm', 'aarch64'], bugnumber="llvm.org/PR44561")
def test_cross_dso_tail_calls(self): def test_cross_dso_tail_calls(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
target = self.dbg.CreateTarget(exe) 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'])
Show All 33 Lines

lldb/test/API/functionalities/tail_call_frames/cross_object/TestCrossObjectTailCalls.py

Show All 15 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
@skipIf(compiler="clang", compiler_version=['<', '10.0']) @skipIf(compiler="clang", compiler_version=['<', '10.0'])
@skipIf(dwarf_version=['<', '4']) @skipIf(dwarf_version=['<', '4'])
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr26265") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr26265")
@expectedFailureAll(archs=['arm', 'aarch64'], bugnumber="llvm.org/PR44561") @expectedFailureAll(archs=['arm', 'aarch64'], bugnumber="llvm.org/PR44561")
def test_cross_object_tail_calls(self): def test_cross_object_tail_calls(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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_source_regexp(self, '// break here', lldbutil.run_break_set_by_source_regexp(self, '// break here',
extra_options='-f Two.c') extra_options='-f Two.c')
process = target.LaunchSimple( process = target.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
Show All 28 Lines

lldb/test/API/functionalities/tail_call_frames/sbapi_support/TestTailCallFrameSBAPI.py

Show All 12 Linesclass TestTailCallFrameSBAPI(TestBase):
@skipIf(compiler="clang", compiler_version=['<', '10.0']) @skipIf(compiler="clang", compiler_version=['<', '10.0'])
@skipIf(dwarf_version=['<', '4']) @skipIf(dwarf_version=['<', '4'])
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr26265") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr26265")
def test_tail_call_frame_sbapi(self): def test_tail_call_frame_sbapi(self):
self.build() self.build()
self.do_test() self.do_test()
def do_test(self): def do_test(self):
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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.BreakpointCreateBySourceRegex("break here", breakpoint = target.BreakpointCreateBySourceRegex("break here",
lldb.SBFileSpec("main.cpp")) lldb.SBFileSpec("main.cpp"))
self.assertTrue(breakpoint and self.assertTrue(breakpoint and
Show All 36 Lines

lldb/test/API/functionalities/tail_call_frames/thread_step_out_or_return/TestSteppingOutWithArtificialFrames.py

Show All 10 Linesclass TestArtificialFrameThreadStepOut1(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
# If your test case doesn't stress debug info, then # If your test case doesn't stress debug info, then
# set this to true. That way it won't be run once for # set this to true. That way it won't be run once for
# each debug info format. # each debug info format.
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
def prepare_thread(self): def prepare_thread(self):
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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.BreakpointCreateBySourceRegex("break here", breakpoint = target.BreakpointCreateBySourceRegex("break here",
lldb.SBFileSpec("main.cpp")) lldb.SBFileSpec("main.cpp"))
self.assertTrue(breakpoint and self.assertTrue(breakpoint and
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

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

Show All 24 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', '// breakpoint') self.line = line_number('main.cpp', '// breakpoint')
def test_launch_notifications(self): def test_launch_notifications(self):
"""Test that lldb broadcasts newly loaded libraries in batches.""" """Test that lldb broadcasts newly loaded libraries in batches."""
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
self.dbg.SetAsync(False) self.dbg.SetAsync(False)
listener = self.dbg.GetListener() listener = self.dbg.GetListener()
listener.StartListeningForEventClass( listener.StartListeningForEventClass(
self.dbg, self.dbg,
lldb.SBTarget.GetBroadcasterClassName(), lldb.SBTarget.GetBroadcasterClassName(),
lldb.SBTarget.eBroadcastBitModulesLoaded | lldb.SBTarget.eBroadcastBitModulesUnloaded) lldb.SBTarget.eBroadcastBitModulesLoaded | lldb.SBTarget.eBroadcastBitModulesUnloaded)
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

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

Show All 28 Linesclass BreakpointAfterJoinTestCase(TestBase):
@expectedFailureAll( @expectedFailureAll(
oslist=["freebsd"], oslist=["freebsd"],
bugnumber="llvm.org/pr18190 thread states not properly maintained") bugnumber="llvm.org/pr18190 thread states not properly maintained")
@expectedFailureNetBSD @expectedFailureNetBSD
def test(self): def test(self):
"""Test breakpoint handling after a thread join.""" """Test breakpoint handling after a thread join."""
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/thread/concurrent_events/exit/TestConcurrentThreadExit.py

Show All 11 Lines
class ConcurrentThreadExitTestCase(TestBase): class ConcurrentThreadExitTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
@skipIf(oslist=no_match(["linux"])) @skipIf(oslist=no_match(["linux"]))
def test(self): def test(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.expect("run", substrs=["exited with status = 47"]) self.expect("run", substrs=["exited with status = 47"])

lldb/test/API/functionalities/thread/crash_during_step/TestCrashDuringStep.py

Show All 18 Lines def setUp(self):
self.breakpoint = line_number('main.cpp', '// Set breakpoint here') self.breakpoint = line_number('main.cpp', '// Set breakpoint here')
# 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'))
@skipIf(oslist=['windows'], archs=['aarch64']) @skipIf(oslist=['windows'], archs=['aarch64'])
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() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/thread/create_after_attach/TestCreateAfterAttach.py

Show All 23 Linesclass CreateAfterAttachTestCase(TestBase):
# Occasionally hangs on Windows, may be same as other issues. # Occasionally hangs on Windows, may be same as other issues.
@skipIfWindows @skipIfWindows
@skipIfiOSSimulator @skipIfiOSSimulator
@expectedFailureNetBSD @expectedFailureNetBSD
def test_create_after_attach(self): def test_create_after_attach(self):
"""Test thread creation after process attach.""" """Test thread creation after process attach."""
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# Spawn a new process # Spawn a new process
# use realpath to workaround llvm.org/pr48376 # use realpath to workaround llvm.org/pr48376
popen = self.spawnSubprocess(os.path.realpath(exe)) popen = self.spawnSubprocess(os.path.realpath(exe))
pid = popen.pid pid = popen.pid
# Attach to the spawned process # Attach to the spawned process
self.runCmd("process attach -p " + str(pid)) self.runCmd("process attach -p " + str(pid))
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

lldb/test/API/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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/thread/exit_during_break/TestExitDuringBreak.py

Show All 17 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number for our breakpoint. # Find the line number for our breakpoint.
self.breakpoint = line_number('main.cpp', '// Set breakpoint here') self.breakpoint = line_number('main.cpp', '// Set breakpoint here')
def test(self): def test(self):
"""Test thread exit during breakpoint handling.""" """Test thread exit during breakpoint handling."""
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/thread/exit_during_step/TestExitDuringStep.py

Show First 20 Lines • Show All 44 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/thread/jump/TestThreadJump.py

Show All 11 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() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 50 Lines • Show Last 20 Lines

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

Show All 28 Linesclass MultipleBreakpointTestCase(TestBase):
@expectedFailureAll( @expectedFailureAll(
oslist=["freebsd"], oslist=["freebsd"],
bugnumber="llvm.org/pr18190 thread states not properly maintained") bugnumber="llvm.org/pr18190 thread states not properly maintained")
@skipIfWindows # This is flakey on Windows: llvm.org/pr24668, llvm.org/pr38373 @skipIfWindows # This is flakey on Windows: llvm.org/pr24668, llvm.org/pr38373
@expectedFailureNetBSD @expectedFailureNetBSD
def test(self): def test(self):
"""Test simultaneous breakpoints in multiple threads.""" """Test simultaneous breakpoints in multiple threads."""
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/thread/num_threads/TestNumThreads.py

Show All 19 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', '// thread3-before-lock') self.thread3_before_lock_line = line_number('main.cpp', '// thread3-before-lock')
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 23 Lines def test_number_of_threads(self):
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
@skipIfWindows # This is flakey on Windows: llvm.org/pr37658, llvm.org/pr38373 @skipIfWindows # This is flakey on Windows: llvm.org/pr37658, llvm.org/pr38373
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 48 Lines • Show Last 20 Lines

lldb/test/API/functionalities/thread/state/TestThreadStates.py

Show First 20 Lines • Show All 64 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 Linesclass ThreadStateTestCase(TestBase):
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr24668: Breakpoints not resolved correctly") bugnumber="llvm.org/pr24668: Breakpoints not resolved correctly")
@skipIfDarwin # llvm.org/pr15824 thread states not properly maintained and <rdar://problem/28557237> @skipIfDarwin # llvm.org/pr15824 thread states not properly maintained and <rdar://problem/28557237>
@no_debug_info_test @no_debug_info_test
def test_process_interrupt(self): def test_process_interrupt(self):
"""Test process interrupt and continue.""" """Test process interrupt and continue."""
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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.
bpno = lldbutil.run_break_set_by_file_and_line( bpno = 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 27 Lines def test_process_interrupt(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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/thread/step_until/TestStepUntil.py

Show All 17 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/thread/thread_exit/TestThreadExit.py

Show All 21 Lines def setUp(self):
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')
@skipIfWindows # This is flakey on Windows: llvm.org/pr38373 @skipIfWindows # This is flakey on Windows: llvm.org/pr38373
def test(self): def test(self):
"""Test thread exit handling.""" """Test thread exit handling."""
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/thread/thread_specific_break_plus_condition/TestThreadSpecificBpPlusCondition.py

Show All 18 Linesclass ThreadSpecificBreakPlusConditionTestCase(TestBase):
@skipIfDarwin @skipIfDarwin
# hits break in another thread in testrun # hits break in another thread in testrun
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@expectedFlakeyNetBSD @expectedFlakeyNetBSD
@skipIfWindows # This test is flaky on Windows @skipIfWindows # This test is flaky on Windows
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/tsan/cpp_global_location/TestTsanCPPGlobalLocation.py

Show All 19 Linesclass TsanCPPGlobalLocationTestCase(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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/tsan/global_location/TestTsanGlobalLocation.py

Show All 19 Linesclass TsanGlobalLocationTestCase(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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/tsan/multiple/TestTsanMultiple.py

Show All 20 Linesclass TsanMultipleTestCase(TestBase):
@skipIfRemote @skipIfRemote
@skipUnlessThreadSanitizer @skipUnlessThreadSanitizer
@add_test_categories(["objc"]) @add_test_categories(["objc"])
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/tsan/thread_leak/TestTsanThreadLeak.py

Show All 18 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/tsan/thread_numbers/TestTsanThreadNumbers.py

Show All 19 Linesclass TsanThreadNumbersTestCase(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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/tty/TestTerminal.py

Show All 28 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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.assertEqual(process.GetState(), lldb.eStateExited) self.assertEqual(process.GetState(), lldb.eStateExited)

lldb/test/API/functionalities/type_lookup/TestTypeLookup.py

Show All 19 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
self.registerSanitizerLibrariesWithTarget(target) self.registerSanitizerLibrariesWithTarget(target)
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 53 Lines • Show Last 20 Lines

lldb/test/API/functionalities/ubsan/user-expression/TestUbsanUserExpression.py

Show All 18 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
self.registerSanitizerLibrariesWithTarget(target) self.registerSanitizerLibrariesWithTarget(target)
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/test/API/functionalities/unwind/aarch64_unwind_pac/TestAArch64UnwindPAC.py

Show All 16 Lines def test(self):
"""Test that we can backtrace correctly when AArch64 PAC is enabled""" """Test that we can backtrace correctly when AArch64 PAC is enabled"""
if not self.isAArch64PAuth(): if not self.isAArch64PAuth():
self.skipTest('Target must support Pointer Authentication.') self.skipTest('Target must support Pointer Authentication.')
self.build() self.build()
self.line = line_number('main.c', '// Frame func_c') self.line = line_number('main.c', '// Frame func_c')
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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) self, "main.c", self.line, num_expected_locations=1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT,
substrs=["stop reason = breakpoint 1."]) substrs=["stop reason = breakpoint 1."])
Show All 14 Lines

lldb/test/API/functionalities/unwind/ehframe/TestEhFrameUnwind.py

Show All 14 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/unwind/noreturn/TestNoreturnUnwind.py

Show All 17 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/unwind/sigtramp/TestSigtrampUnwind.py

Show All 17 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(archs=["arm64"], bugnumber="<rdar://problem/34006863>") # lldb skips 1 frame on arm64 above _sigtramp @expectedFailureAll(archs=["arm64"], 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/functionalities/unwind/zeroth_frame/TestZerothFrame.py

Show All 35 Linesclass ZerothFrame(TestBase):
def test(self): def test(self):
""" """
Test that line information is recalculated properly for a frame when it moves Test that line information is recalculated properly for a frame when it moves
from the middle of the backtrace to a zero index. from the middle of the backtrace to a zero index.
""" """
self.build() self.build()
self.setTearDownCleanup() self.setTearDownCleanup()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
bp1_line = line_number('main.c', '// Set breakpoint 1 here') bp1_line = line_number('main.c', '// Set breakpoint 1 here')
bp2_line = line_number('main.c', '// Set breakpoint 2 here') bp2_line = line_number('main.c', '// Set breakpoint 2 here')
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, self,
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

lldb/test/API/functionalities/value_md5_crash/TestValueMD5Crash.py

Show All 18 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/iohandler/completion/TestIOHandlerCompletion.py

Show All 15 Linesclass IOHandlerCompletionTest(PExpectTest):
# PExpect uses many timeouts internally and doesn't play well # PExpect uses many timeouts internally and doesn't play well
# under ASAN on a loaded machine.. # under ASAN on a loaded machine..
@skipIfAsan @skipIfAsan
@skipIfEditlineSupportMissing @skipIfEditlineSupportMissing
@expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr49408') @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr49408')
@skipIf(oslist=["linux"], archs=["arm", "aarch64"]) @skipIf(oslist=["linux"], archs=["arm", "aarch64"])
def test_completion(self): def test_completion(self):
self.build() self.build()
self.launch(dimensions=(100,500), executable=self.getBuildArtifact("a.out")) self.launch(dimensions=(100,500), executable=self.getTestExecutable())
# Start tab completion, go to the next page and then display all with 'a'. # Start tab completion, go to the next page and then display all with 'a'.
self.child.send("\t\ta") self.child.send("\t\ta")
self.child.expect_exact("register") self.child.expect_exact("register")
# Try tab completing regi to register. # Try tab completing regi to register.
self.child.send("regi\t") self.child.send("regi\t")
# editline might move the cursor back to the start of the line and # editline might move the cursor back to the start of the line and
Show All 40 Lines

lldb/test/API/iohandler/sigint/TestProcessIOHandlerInterrupt.py

Show All 11 Lines
class TestCase(PExpectTest): class TestCase(PExpectTest):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipIf(compiler="clang", compiler_version=['<', '11.0']) @skipIf(compiler="clang", compiler_version=['<', '11.0'])
@skipIf(oslist=["linux"], archs=["arm", "aarch64"]) @skipIf(oslist=["linux"], archs=["arm", "aarch64"])
def test(self): def test(self):
self.build(dictionary={"CXX_SOURCES":"cat.cpp"}) self.build(dictionary={"CXX_SOURCES":"cat.cpp"})
self.launch(executable=self.getBuildArtifact("a.out")) self.launch(executable=self.getTestExecutable())
self.child.sendline("process launch") self.child.sendline("process launch")
self.child.expect("Process .* launched") self.child.expect("Process .* launched")
self.child.sendline("Hello cat") self.child.sendline("Hello cat")
self.child.expect_exact("read: Hello cat") self.child.expect_exact("read: Hello cat")
self.child.sendintr() self.child.sendintr()
Show All 16 Lines

lldb/test/API/iohandler/stdio/TestIOHandlerProcessSTDIO.py

import lldb import lldb
from lldbsuite.test.decorators import * from lldbsuite.test.decorators import *
from lldbsuite.test.lldbtest import * from lldbsuite.test.lldbtest import *
from lldbsuite.test.lldbpexpect import PExpectTest from lldbsuite.test.lldbpexpect import PExpectTest
class TestIOHandlerProcessSTDIO(PExpectTest): class TestIOHandlerProcessSTDIO(PExpectTest):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
# PExpect uses many timeouts internally and doesn't play well # PExpect uses many timeouts internally and doesn't play well
# under ASAN on a loaded machine.. # under ASAN on a loaded machine..
@skipIfAsan @skipIfAsan
@skipIf(oslist=["linux"], archs=["arm", "aarch64"]) @skipIf(oslist=["linux"], archs=["arm", "aarch64"])
def test(self): def test(self):
self.build() self.build()
self.launch(executable=self.getBuildArtifact("a.out")) self.launch(executable=self.getTestExecutable())
self.child.sendline("run") self.child.sendline("run")
self.child.send("foo\n") self.child.send("foo\n")
self.child.expect_exact("stdout: foo") self.child.expect_exact("stdout: foo")
self.child.send("bar\n") self.child.send("bar\n")
self.child.expect_exact("stdout: bar") self.child.expect_exact("stdout: bar")
self.child.send("baz\n") self.child.send("baz\n")
self.child.expect_exact("stdout: baz") self.child.expect_exact("stdout: baz")
self.child.sendcontrol('d') self.child.sendcontrol('d')
self.quit() self.quit()

lldb/test/API/lang/c/anonymous/TestAnonymous.py

Show First 20 Lines • Show All 78 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 12 Lines

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

Show All 15 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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):
VARIABLES_DISPLAYED_CORRECTLY, VARIABLES_DISPLAYED_CORRECTLY,
startstr='(long[6])') startstr='(long[6])')
@expectedFailureNetBSD @expectedFailureNetBSD
@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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 134 Lines • Show Last 20 Lines

lldb/test/API/lang/c/blocks/TestBlocks.py

Show All 18 Lines def setUp(self):
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.'))
self.lines.append(line_number('main.c', '// Set breakpoint 2 here.')) self.lines.append(line_number('main.c', '// Set breakpoint 2 here.'))
def launch_common(self): def launch_common(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 51 Lines • Show Last 20 Lines

lldb/test/API/lang/c/conflicting-symbol/TestConflictingSymbol.py

Show All 15 Linesclass TestConflictingSymbols(TestBase):
def setUp(self): def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
lldbutil.mkdir_p(self.getBuildArtifact("One")) lldbutil.mkdir_p(self.getBuildArtifact("One"))
lldbutil.mkdir_p(self.getBuildArtifact("Two")) lldbutil.mkdir_p(self.getBuildArtifact("Two"))
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489")
def test_conflicting_symbols(self): def test_conflicting_symbols(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
target = self.dbg.CreateTarget(exe) 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'])
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Lines def test_conflicting_symbols(self):
error=True, error=True,
substrs=[ substrs=[
"Multiple internal symbols"]) "Multiple internal symbols"])
@expectedFailureAll(bugnumber="llvm.org/pr35043") @expectedFailureAll(bugnumber="llvm.org/pr35043")
@skipIfWindows # This test is "passing" on Windows, but it is a false positive. @skipIfWindows # This test is "passing" on Windows, but it is a false positive.
def test_shadowed(self): def test_shadowed(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
target = self.dbg.CreateTarget(exe) 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'])
Show All 17 Lines

lldb/test/API/lang/c/const_variables/TestConstVariables.py

Show All 14 Linesclass ConstVariableTestCase(TestBase):
@expectedFailureAll(oslist=["freebsd", "linux"], compiler="icc") @expectedFailureAll(oslist=["freebsd", "linux"], compiler="icc")
@expectedFailureAll(archs=['mips', 'mipsel', 'mips64', 'mips64el']) @expectedFailureAll(archs=['mips', 'mipsel', 'mips64', 'mips64el'])
@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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 26 Lines

lldb/test/API/lang/c/find_struct_type/TestFindStructTypes.py

Show All 19 Linesclass TestFindTypesOnStructType(TestBase):
def test_find_types_struct_type(self): def test_find_types_struct_type(self):
"""Make sure FindTypes actually finds 'struct typename' not just 'typename'.""" """Make sure FindTypes actually finds 'struct typename' not just 'typename'."""
self.build() self.build()
self.do_test() self.do_test()
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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/test/API/lang/c/forward/TestForwardDeclaration.py

Show All 9 Lines
class ForwardDeclarationTestCase(TestBase): class ForwardDeclarationTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def do_test(self, dictionary=None): def do_test(self, dictionary=None):
"""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(dictionary=dictionary) self.build(dictionary=dictionary)
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 39 Lines

lldb/test/API/lang/c/function_types/TestFunctionTypes.py

Show First 20 Lines • Show All 61 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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.
lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1) lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)

lldb/test/API/lang/c/global_variables/TestGlobalVariables.py

Show All 22 Linesclass GlobalVariablesTestCase(TestBase):
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24764") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24764")
@expectedFailureDarwin(archs=["arm64", "arm64e"]) # <rdar://problem/37773624> @expectedFailureDarwin(archs=["arm64", "arm64e"]) # <rdar://problem/37773624>
def test_without_process(self): def test_without_process(self):
"""Test that static initialized variables can be inspected without """Test that static initialized variables can be inspected without
process.""" process."""
self.build() self.build()
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(self.getBuildArtifact("a.out")) target = self.dbg.CreateTarget(self.getTestExecutable())
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
self.expect("target variable g_ptr", VARIABLES_DISPLAYED_CORRECTLY, self.expect("target variable g_ptr", VARIABLES_DISPLAYED_CORRECTLY,
substrs=['(int *)']) substrs=['(int *)'])
self.expect("target variable *g_ptr", VARIABLES_DISPLAYED_CORRECTLY, self.expect("target variable *g_ptr", VARIABLES_DISPLAYED_CORRECTLY,
substrs=['42']) substrs=['42'])
@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(self.getBuildArtifact("a.out")) target = self.dbg.CreateTarget(self.getTestExecutable())
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 67 Lines • Show Last 20 Lines

lldb/test/API/lang/c/local_variables/TestLocalVariables.py

Show All 24 Lines def setUp(self):
self.source, '// Set break point at this line.') self.source, '// Set break point at this line.')
@skipIfWindows @skipIfWindows
def test_c_local_variables(self): def test_c_local_variables(self):
"""Test local variable value.""" """Test local variable value."""
self.build() self.build()
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(self.getBuildArtifact("a.out")) target = self.dbg.CreateTarget(self.getTestExecutable())
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)
# 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 All 13 Lines

lldb/test/API/lang/c/modules/TestCModules.py

Show All 18 Lines @expectedFailureAll(
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"])
@expectedFailureNetBSD @expectedFailureNetBSD
def test_expr(self): def test_expr(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 54 Lines • Show Last 20 Lines

lldb/test/API/lang/c/register_variables/TestRegisterVariables.py

Show All 26 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 150 Lines • Show Last 20 Lines

lldb/test/API/lang/c/set_values/TestSetValues.py

Show All 19 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 102 Lines • Show Last 20 Lines

lldb/test/API/lang/c/shared_lib/TestSharedLib.py

Show First 20 Lines • Show All 64 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(self.getBuildArtifact("a.out")) target = self.dbg.CreateTarget(self.getTestExecutable())
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 17 Lines

lldb/test/API/lang/c/shared_lib_stripped_symbols/TestSharedLibStrippedSymbols.py

Show First 20 Lines • Show All 55 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(self.getBuildArtifact("a.out")) target = self.dbg.CreateTarget(self.getTestExecutable())
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 15 Lines

lldb/test/API/lang/c/step-target/TestStepTarget.py

Show All 15 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 89 Lines • Show Last 20 Lines

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

Show All 20 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"], archs=no_match(["i386", "x86_64"])) @expectedFailureAll(oslist=["linux"], archs=no_match(["i386", "x86_64"]))
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24777") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24777")
@expectedFailureNetBSD @expectedFailureNetBSD
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/lang/c/stepping/TestThreadStepping.py

Show All 23 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/lang/c/strings/TestCStrings.py

""" """
Tests that C strings work as expected in expressions Tests that C strings work as expected in expressions
""" """
import lldb import lldb
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
class CStringsTestCase(TestBase): class CStringsTestCase(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 C strings work as expected in expressions""" """Tests that C strings work as expected in expressions"""
self.build() self.build()
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/lang/c/tls_globals/TestTlsGlobals.py

Show All 40 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/lang/c/typedef/Testtypedef.py

Show All 14 Linesclass TypedefTestCase(TestBase):
@expectedFailureAll(compiler="clang", bugnumber="llvm.org/pr19238") @expectedFailureAll(compiler="clang", bugnumber="llvm.org/pr19238")
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/lang/c/unicode/TestUnicodeSymbols.py

# coding=utf8 # coding=utf8
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
from lldbsuite.test.decorators import * from lldbsuite.test.decorators import *
class TestUnicodeSymbols(TestBase): class TestUnicodeSymbols(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipIf(compiler="clang", compiler_version=['<', '7.0']) @skipIf(compiler="clang", compiler_version=['<', '7.0'])
def test_union_members(self): def test_union_members(self):
self.build() self.build()
spec = lldb.SBModuleSpec() spec = lldb.SBModuleSpec()
spec.SetFileSpec(lldb.SBFileSpec(self.getBuildArtifact("a.out"))) spec.SetFileSpec(lldb.SBFileSpec(self.getTestExecutable()))
module = lldb.SBModule(spec) module = lldb.SBModule(spec)
self.assertTrue(module.IsValid()) self.assertTrue(module.IsValid())
mytype = module.FindFirstType("foobár") mytype = module.FindFirstType("foobár")
self.assertTrue(mytype.IsValid()) self.assertTrue(mytype.IsValid())
self.assertTrue(mytype.IsPointerType()) self.assertTrue(mytype.IsPointerType())

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

Show All 39 Linesclass TestUnionMembers(TestBase):
def _load_exe(self): def _load_exe(self):
self.build() self.build()
src_file = os.path.join(self.getSourceDir(), "main.c") src_file = os.path.join(self.getSourceDir(), "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 = self.getBuildArtifact("a.out") exe_path = self.getTestExecutable()
# 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/test/API/lang/cpp/alignas_base_class/TestAlignAsBaseClass.py

import lldb import lldb
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
class TestCase(TestBase): class TestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@no_debug_info_test @no_debug_info_test
def test(self): def test(self):
self.build() self.build()
self.dbg.CreateTarget(self.getBuildArtifact("a.out")) self.dbg.CreateTarget(self.getTestExecutable())
# The offset of f2 should be 8 because of `alignas(8)`. # The offset of f2 should be 8 because of `alignas(8)`.
self.expect_expr("(intptr_t)&d3g.f2 - (intptr_t)&d3g", result_value="8") self.expect_expr("(intptr_t)&d3g.f2 - (intptr_t)&d3g", result_value="8")

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

Show All 26 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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/test/API/lang/cpp/char1632_t/TestChar1632T.py

Show All 23 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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 75 Lines • Show Last 20 Lines

lldb/test/API/lang/cpp/class-template-non-type-parameter-pack/TestClassTemplateNonTypeParameterPack.py

import lldb import lldb
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
class TestCaseClassTemplateNonTypeParameterPack(TestBase): class TestCaseClassTemplateNonTypeParameterPack(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@expectedFailureAll(oslist=["windows"], archs=["i[3-6]86", "x86_64"]) # Fails to read memory from target. @expectedFailureAll(oslist=["windows"], archs=["i[3-6]86", "x86_64"]) # Fails to read memory from target.
@no_debug_info_test @no_debug_info_test
def test(self): def test(self):
self.build() self.build()
self.dbg.CreateTarget(self.getBuildArtifact("a.out")) self.dbg.CreateTarget(self.getTestExecutable())
self.expect_expr("emptyNonTypePack", result_type="NonTypePack<>", self.expect_expr("emptyNonTypePack", result_type="NonTypePack<>",
result_children=[ValueCheck(name="a", type="int")]) result_children=[ValueCheck(name="a", type="int")])
self.expect_expr("oneElemNonTypePack", result_type="NonTypePack<1>", self.expect_expr("oneElemNonTypePack", result_type="NonTypePack<1>",
result_children=[ValueCheck(name="a", type="int")]) result_children=[ValueCheck(name="a", type="int")])
self.expect_expr("twoElemNonTypePack", result_type="NonTypePack<1, 2>", self.expect_expr("twoElemNonTypePack", result_type="NonTypePack<1, 2>",
result_children=[ValueCheck(name="a", type="int")]) result_children=[ValueCheck(name="a", type="int")])
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

lldb/test/API/lang/cpp/class-template-type-parameter-pack/TestClassTemplateTypeParameterPack.py

import lldb import lldb
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
class TestCaseClassTemplateTypeParameterPack(TestBase): class TestCaseClassTemplateTypeParameterPack(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@expectedFailureAll(oslist=["windows"], archs=["i[3-6]86", "x86_64"]) # Fails to read memory from target. @expectedFailureAll(oslist=["windows"], archs=["i[3-6]86", "x86_64"]) # Fails to read memory from target.
@no_debug_info_test @no_debug_info_test
def test(self): def test(self):
self.build() self.build()
self.dbg.CreateTarget(self.getBuildArtifact("a.out")) self.dbg.CreateTarget(self.getTestExecutable())
self.expect_expr("emptyTypePack", result_type="TypePack<>", self.expect_expr("emptyTypePack", result_type="TypePack<>",
result_children=[ValueCheck(name="a", type="int")]) result_children=[ValueCheck(name="a", type="int")])
self.expect_expr("oneElemTypePack", result_type="TypePack<int>", self.expect_expr("oneElemTypePack", result_type="TypePack<int>",
result_children=[ValueCheck(name="a", type="int")]) result_children=[ValueCheck(name="a", type="int")])
self.expect_expr("twoElemTypePack", result_type="TypePack<int, float>", self.expect_expr("twoElemTypePack", result_type="TypePack<int, float>",
result_children=[ValueCheck(name="a", type="int")]) result_children=[ValueCheck(name="a", type="int")])
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

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

Show All 17 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 file and class static variables display correctly.""" """Test that file and class static variables display correctly."""
self.build() self.build()
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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 @expectedFailureAll(
compiler_version=["<", "3.9"], compiler_version=["<", "3.9"],
bugnumber='llvm.org/pr20550') bugnumber='llvm.org/pr20550')
def test_with_run_command_complete(self): def test_with_run_command_complete(self):
""" """
Test that file and class static variables display correctly with Test that file and class static variables display correctly with
complete debug information. complete debug information.
""" """
self.build() self.build()
target = self.dbg.CreateTarget(self.getBuildArtifact("a.out")) target = self.dbg.CreateTarget(self.getTestExecutable())
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Global variables are no longer displayed with the "frame variable" # Global variables are no longer displayed with the "frame variable"
# command. # command.
self.expect( self.expect(
'target variable A::g_points', 'target variable A::g_points',
VARIABLES_DISPLAYED_CORRECTLY, VARIABLES_DISPLAYED_CORRECTLY,
patterns=[ patterns=[
Show All 26 Lines @expectedFailureAll(
compiler=["clang"], compiler=["clang"],
compiler_version=["<", "3.9"], compiler_version=["<", "3.9"],
bugnumber='llvm.org/pr20550') bugnumber='llvm.org/pr20550')
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24764") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24764")
@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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/lang/cpp/class_types/TestClassTypes.py

Show All 16 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 19 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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.path.dirname(self.getBuildArtifact("a.out")) self.assertTrue(fsDir == os.path.dirname(self.getTestExecutable())
and fsFile == "a.out", 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)
Show All 31 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.assertEqual(breakpoint.GetHitCount(), 1, BREAKPOINT_HIT_ONCE) self.assertEqual(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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 39 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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.path.dirname(self.getBuildArtifact("a.out")) self.assertTrue(fsDir == os.path.dirname(self.getTestExecutable())
and fsFile == "a.out", 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)
Show All 27 Lines

lldb/test/API/lang/cpp/class_types/TestClassTypesDisassembly.py

Show First 20 Lines • Show All 71 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/lang/cpp/dynamic-value/TestDynamicValue.py

Show All 27 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() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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/test/API/lang/cpp/elaborated-types/TestElaboratedTypes.py

""" """
Test elaborated types (e.g. Clang's ElaboratedType or TemplateType sugar). Test elaborated types (e.g. Clang's ElaboratedType or TemplateType sugar).
""" """
import lldb import lldb
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
class TestCase(TestBase): class TestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@no_debug_info_test @no_debug_info_test
def test(self): def test(self):
self.build() self.build()
self.dbg.CreateTarget(self.getBuildArtifact("a.out")) self.dbg.CreateTarget(self.getTestExecutable())
# Add a type formatter for 'Struct'. # Add a type formatter for 'Struct'.
self.expect("type summary add Struct --summary-string '(summary x=${var.x})'") self.expect("type summary add Struct --summary-string '(summary x=${var.x})'")
# Check that creating an expr with an elaborated type ('::Struct') # Check that creating an expr with an elaborated type ('::Struct')
# triggers our formatter for 'Struct' while keeping the elaborated type # triggers our formatter for 'Struct' while keeping the elaborated type
# as the display type. # as the display type.
result = self.expect_expr("::Struct s; s.x = 4; s", result = self.expect_expr("::Struct s; s.x = 4; s",
result_type="::Struct", result_type="::Struct",
Show All 15 Lines

lldb/test/API/lang/cpp/enum_types/TestCPP11EnumTypes.py

Show All 34 Lines def check_enum(self, suffix):
self.expect_expr("var_above_" + suffix, result_type=enum_name, result_value="203") self.expect_expr("var_above_" + suffix, result_type=enum_name, result_value="203")
else: else:
self.expect_expr("var_below_" + suffix, result_type=enum_name, result_value="-3") self.expect_expr("var_below_" + suffix, result_type=enum_name, result_value="-3")
self.expect_expr("var_above_" + suffix, result_type=enum_name, result_value="1") self.expect_expr("var_above_" + suffix, result_type=enum_name, result_value="1")
@skipIf(dwarf_version=['<', '4']) @skipIf(dwarf_version=['<', '4'])
def test(self): def test(self):
self.build() self.build()
target = self.dbg.CreateTarget(self.getBuildArtifact("a.out")) target = self.dbg.CreateTarget(self.getTestExecutable())
self.check_enum("uc") self.check_enum("uc")
self.check_enum("c") self.check_enum("c")
self.check_enum("us") self.check_enum("us")
self.check_enum("s") self.check_enum("s")
self.check_enum("ui") self.check_enum("ui")
self.check_enum("i") self.check_enum("i")
self.check_enum("ul") self.check_enum("ul")
self.check_enum("l") self.check_enum("l")
self.check_enum("ull") self.check_enum("ull")
self.check_enum("ll") self.check_enum("ll")

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

Show All 21 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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/test/API/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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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()
if process.GetByteOrder() == lldb.eByteOrderLittle: if process.GetByteOrder() == lldb.eByteOrderLittle:
self.expect('frame variable -f x i', substrs=['ffffff41']) self.expect('frame variable -f x i', substrs=['ffffff41'])
else: else:
self.expect('frame variable -f x i', substrs=['41ffff00']) self.expect('frame variable -f x i', substrs=['41ffff00'])
self.expect('frame variable c', substrs=["'A"]) self.expect('frame variable c', substrs=["'A"])

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

Show All 14 Lines def prepare_executable_and_get_frame(self):
self.build() self.build()
# 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
exe_path = self.getBuildArtifact("a.out") exe_path = self.getTestExecutable()
# 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 62 Lines • Show Last 20 Lines

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

Show All 13 Linesclass TestWithGmodulesDebugInfo(TestBase):
def test_specialized_typedef_from_pch(self): def test_specialized_typedef_from_pch(self):
self.build() self.build()
src_file = os.path.join(self.getSourceDir(), "main.cpp") src_file = os.path.join(self.getSourceDir(), "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 = self.getBuildArtifact("a.out") exe_path = self.getTestExecutable()
# 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 64 Lines • Show Last 20 Lines

lldb/test/API/lang/cpp/inlines/TestInlines.py

Show All 29 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 11 Lines

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

Show All 11 Linesclass TestWithLimitDebugInfo(TestBase):
def test_limit_debug_info(self): def test_limit_debug_info(self):
self.build() self.build()
src_file = os.path.join(self.getSourceDir(), "main.cpp") src_file = os.path.join(self.getSourceDir(), "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 = self.getBuildArtifact("a.out") exe_path = self.getTestExecutable()
# 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 29 Lines

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

Show First 20 Lines • Show All 231 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 = self.getBuildArtifact("a.out") exe_path = self.getTestExecutable()
# 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 37 Lines

lldb/test/API/lang/cpp/namespace/TestNamespace.py

Show All 22 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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 91 Lines • Show Last 20 Lines

lldb/test/API/lang/cpp/namespace/TestNamespaceLookup.py

Show All 36 Lines def runToBkpt(self, command):
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'])
@skipIfWindows # This is flakey on Windows: llvm.org/pr38373 @skipIfWindows # This is flakey on Windows: llvm.org/pr38373
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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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")
@expectedFailure("lldb scope lookup of functions bugs") @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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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 21 Lines def test_function_scope_lookup_with_run_command(self):
# before functions. # before functions.
self.expect("expr -- foo()", startstr="(int) $2 = 42") self.expect("expr -- foo()", startstr="(int) $2 = 42")
@expectedFailure("lldb file scope lookup bugs") @expectedFailure("lldb file scope lookup bugs")
@skipIfWindows # This is flakey on Windows: llvm.org/pr38373 @skipIfWindows # This is flakey on Windows: llvm.org/pr38373
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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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")
@skipIfWindows # This is flakey on Windows: llvm.org/pr38373 @skipIfWindows # This is flakey on Windows: llvm.org/pr38373
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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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)
# Run to BP_before_using_directive at global scope before using # Run to BP_before_using_directive at global scope before using
# declaration # declaration
self.runToBkpt("run") self.runToBkpt("run")
# Evaluate func() - should call ::func() # Evaluate func() - should call ::func()
self.expect("expr -- func()", startstr="(int) $0 = 1") self.expect("expr -- func()", startstr="(int) $0 = 1")
# 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
# entries in DWARF - may need to add checks for compiler versions here. # entries in DWARF - may need to add checks for compiler versions here.
@skipIf( @skipIf(
compiler="gcc", compiler="gcc",
oslist=["linux"], oslist=["linux"],
debug_info=["dwo"]) # Skip to avoid crash debug_info=["dwo"]) # Skip to avoid crash
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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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")
@expectedFailure( @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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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")
@expectedFailure("lldb scope lookup ambiguity after using bugs") @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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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 func() - should get error: ambiguous # Evaluate func() - should get error: ambiguous
# FIXME: This test fails because lldb removes duplicates if they have # FIXME: This test fails because lldb removes duplicates if they have
# the same type. # the same type.
self.expect("expr -- func()", startstr="error") self.expect("expr -- func()", startstr="error")
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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/lang/cpp/namespace_definitions/TestNamespaceDefinitions.py

Show All 37 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(self.getBuildArtifact("a.out")) target = self.dbg.CreateTarget(self.getTestExecutable())
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 15 Lines

lldb/test/API/lang/cpp/non-type-template-param/TestCppNonTypeTemplateParam.py

import lldb import lldb
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
class TestCase(TestBase): class TestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@no_debug_info_test @no_debug_info_test
def test(self): def test(self):
self.build() self.build()
self.dbg.CreateTarget(self.getBuildArtifact("a.out")) self.dbg.CreateTarget(self.getTestExecutable())
self.expect_expr("myArray", result_type="array<3>", result_children=[ self.expect_expr("myArray", result_type="array<3>", result_children=[
ValueCheck(name="Arr", type="int[3]") ValueCheck(name="Arr", type="int[3]")
]) ])

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

Show All 15 Lines def test_with_run_command(self):
self.build() self.build()
# Get main source file # Get main source file
src_file = os.path.join(self.getSourceDir(), "main.cpp") src_file = os.path.join(self.getSourceDir(), "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
exe_path = self.getBuildArtifact("a.out") exe_path = self.getTestExecutable()
# 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/test/API/lang/cpp/pointer_to_member_type_depending_on_parent_size/TestPointerToMemberTypeDependingOnParentSize.py

Show All 17 Lines def test(self):
""" """
This tests a pointer-to-member member which class part is the This tests a pointer-to-member member which class part is the
surrounding class. LLDB should *not* try to generate the record layout surrounding class. LLDB should *not* try to generate the record layout
of the class when parsing pointer-to-member types while parsing debug of the class when parsing pointer-to-member types while parsing debug
info (as the references class might not be complete when the type is info (as the references class might not be complete when the type is
parsed). parsed).
""" """
self.build() self.build()
self.dbg.CreateTarget(self.getBuildArtifact("a.out")) self.dbg.CreateTarget(self.getTestExecutable())
# Force the record layout for 'ToLayout' to be generated by printing # Force the record layout for 'ToLayout' to be generated by printing
# a value of it's type. # a value of it's type.
self.expect("target variable test_var") self.expect("target variable test_var")

lldb/test/API/lang/cpp/reference-to-outer-type/TestCppReferenceToOuterClass.py

import lldb import lldb
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
class TestCase(TestBase): class TestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@expectedFailure("The fix for this was reverted due to llvm.org/PR52257") @expectedFailure("The fix for this was reverted due to llvm.org/PR52257")
def test(self): def test(self):
self.build() self.build()
self.dbg.CreateTarget(self.getBuildArtifact("a.out")) self.dbg.CreateTarget(self.getTestExecutable())
test_var = self.expect_expr("test_var", result_type="In") test_var = self.expect_expr("test_var", result_type="In")
nested_member = test_var.GetChildMemberWithName('NestedClassMember') nested_member = test_var.GetChildMemberWithName('NestedClassMember')
self.assertEqual("Outer::NestedClass", self.assertEqual("Outer::NestedClass",
nested_member.GetType().GetName()) nested_member.GetType().GetName())

lldb/test/API/lang/cpp/rvalue-references/TestRvalueReferences.py

Show All 13 Linesclass RvalueReferencesTestCase(TestBase):
# rdar://problem/11479676 # rdar://problem/11479676
@expectedFailureAll( @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.")
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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/lang/cpp/signed_types/TestSignedTypes.py

Show All 25 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(self.getBuildArtifact("a.out")) target = self.dbg.CreateTarget(self.getTestExecutable())
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 23 Lines

lldb/test/API/lang/cpp/static_member_type_depending_on_parent_size/TestStaticMemberTypeDependingOnParentSize.py

Show All 9 Linesclass TestCase(TestBase):
@no_debug_info_test @no_debug_info_test
def test(self): def test(self):
""" """
This tests a static member with a type which size depends on the This tests a static member with a type which size depends on the
surrounding class. LLDB should *not* try to generate the record layout surrounding class. LLDB should *not* try to generate the record layout
for those types while parsing the members from debug info. for those types while parsing the members from debug info.
""" """
self.build() self.build()
self.dbg.CreateTarget(self.getBuildArtifact("a.out")) self.dbg.CreateTarget(self.getTestExecutable())
# Force the record layout for 'ToLayout' to be generated by printing # Force the record layout for 'ToLayout' to be generated by printing
# a value of it's type. # a value of it's type.
self.expect("target variable test_var") self.expect("target variable test_var")

lldb/test/API/lang/cpp/template-arguments/TestCppTemplateArguments.py

import lldb import lldb
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
class TestCase(TestBase): class TestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@no_debug_info_test @no_debug_info_test
def test(self): def test(self):
self.build() self.build()
self.dbg.CreateTarget(self.getBuildArtifact("a.out")) self.dbg.CreateTarget(self.getTestExecutable())
value = self.expect_expr("temp1", result_type="C<int, 2>") value = self.expect_expr("temp1", result_type="C<int, 2>")
template_type = value.GetType() template_type = value.GetType()
self.assertEqual(template_type.GetNumberOfTemplateArguments(), 2) self.assertEqual(template_type.GetNumberOfTemplateArguments(), 2)
# Check a type argument. # Check a type argument.
self.assertEqual(template_type.GetTemplateArgumentKind(0), lldb.eTemplateArgumentKindType) self.assertEqual(template_type.GetTemplateArgumentKind(0), lldb.eTemplateArgumentKindType)
self.assertEqual(template_type.GetTemplateArgumentType(0).GetName(), "int") self.assertEqual(template_type.GetTemplateArgumentType(0).GetName(), "int")
Show All 9 Lines

lldb/test/API/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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 128 Lines • Show Last 20 Lines

lldb/test/API/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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/lang/cpp/thread_local/TestThreadLocal.py

Show All 10 Linesclass PlatformProcessCrashInfoTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@expectedFailureAll(oslist=["windows", "linux", "freebsd", "netbsd"]) @expectedFailureAll(oslist=["windows", "linux", "freebsd", "netbsd"])
def test_thread_local(self): def test_thread_local(self):
# Set a breakpoint on the first instruction of the main function, # Set a breakpoint on the first instruction of the main function,
# before the TLS initialization has run. # before the TLS initialization has run.
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
(target, process, _, _) = \ (target, process, _, _) = \
lldbutil.run_to_source_breakpoint(self, "Set breakpoint here", lldbutil.run_to_source_breakpoint(self, "Set breakpoint here",
lldb.SBFileSpec("main.cpp")) lldb.SBFileSpec("main.cpp"))
self.expect_expr("tl_local_int + 1", self.expect_expr("tl_local_int + 1",
result_type="int", result_value="323") result_type="int", result_value="323")
self.expect_expr("*tl_local_ptr + 2", self.expect_expr("*tl_local_ptr + 2",
result_type="int", result_value="324") result_type="int", result_value="324")
Show All 27 Lines

lldb/test/API/lang/mixed/TestMixedLanguages.py

"""Test that lldb works correctly on compile units form different languages.""" """Test that lldb works correctly on compile units form different languages."""
import re import re
import lldb import lldb
from lldbsuite.test.lldbtest import * from lldbsuite.test.lldbtest import *
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/lang/objc/blocks/TestObjCIvarsInBlocks.py

Show All 20 Linesclass TestObjCIvarsInBlocks(TestBase):
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@skipIf(dwarf_version=['<', '4']) @skipIf(dwarf_version=['<', '4'])
@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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/lang/objc/conflicting-definition/TestConflictingDefinition.py

Show All 35 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/lang/objc/exceptions/TestObjCExceptions.py

Show All 12 Lines
class ObjCExceptionsTestCase(TestBase): class ObjCExceptionsTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def test_objc_exceptions_at_throw(self): def test_objc_exceptions_at_throw(self):
self.build() self.build()
target = self.dbg.CreateTarget(self.getBuildArtifact("a.out")) target = self.dbg.CreateTarget(self.getTestExecutable())
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
launch_info = lldb.SBLaunchInfo(["a.out", "0"]) launch_info = lldb.SBLaunchInfo(["a.out", "0"])
launch_info.SetLaunchFlags(lldb.eLaunchFlagInheritTCCFromParent) launch_info.SetLaunchFlags(lldb.eLaunchFlagInheritTCCFromParent)
lldbutil.run_to_name_breakpoint(self, "objc_exception_throw", launch_info=launch_info) lldbutil.run_to_name_breakpoint(self, "objc_exception_throw", launch_info=launch_info)
self.expect("thread list", self.expect("thread list",
substrs=['stopped', 'stop reason = hit Objective-C exception']) substrs=['stopped', 'stop reason = hit Objective-C exception'])
▲ Show 20 Lines • Show All 93 Lines • ▼ Show 20 Lines def test_objc_exceptions_at_throw(self):
pcs = [i.unsigned for i in children] pcs = [i.unsigned for i in children]
names = [target.ResolveSymbolContextForAddress(lldb.SBAddress(pc, target), lldb.eSymbolContextSymbol).GetSymbol().name for pc in pcs] names = [target.ResolveSymbolContextForAddress(lldb.SBAddress(pc, target), lldb.eSymbolContextSymbol).GetSymbol().name for pc in pcs]
for n in ["objc_exception_throw", "foo(int)", "main"]: for n in ["objc_exception_throw", "foo(int)", "main"]:
self.assertIn(n, names, "%s is in the exception backtrace (%s)" % (n, names)) self.assertIn(n, names, "%s is in the exception backtrace (%s)" % (n, names))
def test_objc_exceptions_at_abort(self): def test_objc_exceptions_at_abort(self):
self.build() self.build()
target = self.dbg.CreateTarget(self.getBuildArtifact("a.out")) target = self.dbg.CreateTarget(self.getTestExecutable())
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
self.runCmd("run 0") self.runCmd("run 0")
# We should be stopped at pthread_kill because of an unhandled exception # We should be stopped at pthread_kill because of an unhandled exception
self.expect("thread list", self.expect("thread list",
substrs=['stopped', 'stop reason = signal SIGABRT']) substrs=['stopped', 'stop reason = signal SIGABRT'])
Show All 39 Lines def test_objc_exceptions_at_abort(self):
history_thread = thread.GetCurrentExceptionBacktrace() history_thread = thread.GetCurrentExceptionBacktrace()
self.assertGreaterEqual(history_thread.num_frames, 4) self.assertGreaterEqual(history_thread.num_frames, 4)
for n in ["objc_exception_throw", "foo(int)", "rethrow(int)", "main"]: for n in ["objc_exception_throw", "foo(int)", "rethrow(int)", "main"]:
self.assertEqual(len([f for f in history_thread.frames if f.GetFunctionName() == n]), 1) self.assertEqual(len([f for f in history_thread.frames if f.GetFunctionName() == n]), 1)
def test_cxx_exceptions_at_abort(self): def test_cxx_exceptions_at_abort(self):
self.build() self.build()
target = self.dbg.CreateTarget(self.getBuildArtifact("a.out")) target = self.dbg.CreateTarget(self.getTestExecutable())
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
self.runCmd("run 2") self.runCmd("run 2")
# We should be stopped at pthread_kill because of an unhandled exception # We should be stopped at pthread_kill because of an unhandled exception
self.expect("thread list", self.expect("thread list",
substrs=['stopped', 'stop reason = signal SIGABRT']) substrs=['stopped', 'stop reason = signal SIGABRT'])
Show All 9 Lines

lldb/test/API/lang/objc/forward-decl/TestForwardDecl.py

Show All 18 Lines def setUp(self):
self.source = 'main.m' self.source = 'main.m'
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"]
def do_test(self, dictionary=None): def do_test(self, dictionary=None):
self.build(dictionary=dictionary) self.build(dictionary=dictionary)
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(self.getBuildArtifact("a.out")) target = self.dbg.CreateTarget(self.getTestExecutable())
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 31 Lines

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

Show All 22 Lines def setUp(self):
self.main_source = "const-strings.m" self.main_source = "const-strings.m"
self.line = line_number(self.main_source, '// Set breakpoint here.') self.line = line_number(self.main_source, '// Set breakpoint here.')
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/lang/objc/foundation/TestFoundationDisassembly.py

Show All 19 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(self.getBuildArtifact("a.out")) target = self.dbg.CreateTarget(self.getTestExecutable())
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 26 Lines def test_foundation_disasm(self):
self.runCmd('disassemble --force -n "%s"' % func) self.runCmd('disassemble --force -n "%s"' % func)
@skipIfAsan @skipIfAsan
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(self.getBuildArtifact("a.out")) target = self.dbg.CreateTarget(self.getTestExecutable())
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Stop at +[NSString stringWithFormat:]. # Stop at +[NSString stringWithFormat:].
symbol_name = "+[NSString stringWithFormat:]" symbol_name = "+[NSString stringWithFormat:]"
break_results = lldbutil.run_break_set_command( break_results = lldbutil.run_break_set_command(
self, "_regexp-break %s" % (symbol_name)) self, "_regexp-break %s" % (symbol_name))
lldbutil.check_breakpoint_result( lldbutil.check_breakpoint_result(
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

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

Show All 26 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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.assertEqual( self.assertEqual(
str_value, my_str_value, str_value, my_str_value,
"Got the correct value for my->str") "Got the correct value for my->str")
def test_expression_lookups_objc(self): def test_expression_lookups_objc(self):
"""Test running an expression detect spurious debug info lookups (DWARF).""" """Test running an expression detect spurious debug info lookups (DWARF)."""
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/lang/objc/foundation/TestRuntimeTypes.py

Show All 15 Linesclass RuntimeTypesTestCase(TestBase):
@expectedFailureAll( @expectedFailureAll(
oslist=["macosx"], oslist=["macosx"],
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'."""
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/lang/objc/foundation/TestSymbolTable.py

Show All 22 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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())
self.assertTrue(process, PROCESS_IS_VALID) self.assertTrue(process, PROCESS_IS_VALID)
Show All 23 Lines

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

Show All 15 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
self.main_source = lldb.SBFileSpec("main.m") self.main_source = lldb.SBFileSpec("main.m")
@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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/lang/objc/hidden-ivars/TestHiddenIvars.py

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Lines def test_frame_variable_across_modules(self):
VARIABLES_DISPLAYED_CORRECTLY, VARIABLES_DISPLAYED_CORRECTLY,
substrs=["= 3"]) substrs=["= 3"])
def common_setup(self, strip): def common_setup(self, strip):
if strip: if strip:
exe = self.getBuildArtifact("stripped/a.out") exe = self.getBuildArtifact("stripped/a.out")
else: else:
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Create the breakpoint inside function 'main'. # Create the breakpoint inside function 'main'.
breakpoint = target.BreakpointCreateByLocation(self.source, self.line) breakpoint = target.BreakpointCreateByLocation(self.source, self.line)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
▲ Show 20 Lines • Show All 134 Lines • Show Last 20 Lines

lldb/test/API/lang/objc/ivar-IMP/TestObjCiVarIMP.py

Show All 14 Linesclass ObjCiVarIMPTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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/test/API/lang/objc/modules-auto-import/TestModulesAutoImport.py

Show All 17 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.m', '// Set breakpoint 0 here.') self.line = line_number('main.m', '// Set breakpoint 0 here.')
@skipIf(macos_version=["<", "10.12"]) @skipIf(macos_version=["<", "10.12"])
def test_expr(self): def test_expr(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 12 Lines

lldb/test/API/lang/objc/modules-incomplete/TestIncompleteModules.py

Show All 16 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.m', '// Set breakpoint 0 here.') self.line = line_number('main.m', '// Set breakpoint 0 here.')
@skipIf(debug_info=no_match(["gmodules"])) @skipIf(debug_info=no_match(["gmodules"]))
def test_expr(self): def test_expr(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.m", self.line, num_expected_locations=1, loc_exact=True) self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
# 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/test/API/lang/objc/modules-inline-functions/TestModulesInlineFunctions.py

Show All 12 Lines
class ModulesInlineFunctionsTestCase(TestBase): class ModulesInlineFunctionsTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipIf(macos_version=["<", "10.12"], debug_info=no_match(["gmodules"])) @skipIf(macos_version=["<", "10.12"], debug_info=no_match(["gmodules"]))
def test_expr(self): def test_expr(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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_to_source_breakpoint( lldbutil.run_to_source_breakpoint(
self, '// Set breakpoint here.', lldb.SBFileSpec('main.m')) self, '// Set breakpoint here.', lldb.SBFileSpec('main.m'))
self.runCmd( self.runCmd(
"settings set target.clang-module-search-paths \"" + "settings set target.clang-module-search-paths \"" +
self.getSourceDir() + self.getSourceDir() +
"\"") "\"")
self.expect("expr @import myModule; 3", VARIABLES_DISPLAYED_CORRECTLY, self.expect("expr @import myModule; 3", VARIABLES_DISPLAYED_CORRECTLY,
substrs=["int", "3"]) substrs=["int", "3"])
self.expect("expr isInline(2)", VARIABLES_DISPLAYED_CORRECTLY, self.expect("expr isInline(2)", VARIABLES_DISPLAYED_CORRECTLY,
substrs=["4"]) substrs=["4"])

lldb/test/API/lang/objc/modules/TestObjCModules.py

Show All 17 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.m', '// Set breakpoint 0 here.') self.line = line_number('main.m', '// Set breakpoint 0 here.')
@skipIf(macos_version=["<", "10.12"]) @skipIf(macos_version=["<", "10.12"])
def test_expr(self): def test_expr(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 45 Lines • Show Last 20 Lines

lldb/test/API/lang/objc/objc++/TestObjCXX.py

Show All 14 Linesclass ObjCXXTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/lang/objc/objc-baseclass-sbtype/TestObjCBaseClassSBType.py

Show All 22 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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/test/API/lang/objc/objc-checker/TestObjCCheckers.py

Show All 24 Linesclass ObjCCheckerTestCase(TestBase):
@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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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 48 Lines • Show Last 20 Lines

lldb/test/API/lang/objc/objc-class-method/TestObjCClassMethod.py

Show All 19 Lines def setUp(self):
self.main_source = "class.m" self.main_source = "class.m"
self.break_line = line_number( self.break_line = line_number(
self.main_source, '// Set breakpoint here.') self.main_source, '// Set breakpoint here.')
@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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/lang/objc/objc-dynamic-value/TestObjCDynamicValue.py

Show All 32 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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/test/API/lang/objc/objc-ivar-offsets/TestObjCIvarOffsets.py

Show All 18 Lines def setUp(self):
self.main_source = "main.m" self.main_source = "main.m"
self.stop_line = line_number( self.stop_line = line_number(
self.main_source, '// Set breakpoint here.') self.main_source, '// Set breakpoint here.')
@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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/lang/objc/objc-optimized/TestObjcOptimized.py

Show All 24 Linesclass ObjcOptimizedTestCase(TestBase):
myclass = "MyClass" myclass = "MyClass"
mymethod = "description" mymethod = "description"
method_spec = "-[%s %s]" % (myclass, mymethod) method_spec = "-[%s %s]" % (myclass, mymethod)
@expectedFailureAll(remote=True) @expectedFailureAll(remote=True)
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/lang/objc/objc-property/TestObjCProperty.py

Show All 22 Linesclass ObjCPropertyTestCase(TestBase):
@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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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 105 Lines • Show Last 20 Lines

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

Show All 24 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/lang/objc/objc-static-method/TestObjCStaticMethod.py

Show All 19 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.')
@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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/lang/objc/objc-stepping/TestObjCStepping.py

Show All 27 Lines def setUp(self):
self.main_source, '// SourceBase returnsStruct start line.') self.main_source, '// SourceBase returnsStruct start line.')
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.')
@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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/lang/objc/objc-struct-argument/TestObjCStructArgument.py

Show All 19 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.')
@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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/lang/objc/objc-struct-return/TestObjCStructReturn.py

Show All 18 Lines def setUp(self):
self.main_source = "test.m" self.main_source = "test.m"
self.break_line = line_number( self.break_line = line_number(
self.main_source, '// Set breakpoint here.') self.main_source, '// Set breakpoint here.')
@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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/lang/objc/objc-super/TestObjCSuper.py

Show All 18 Lines def setUp(self):
self.main_source = "class.m" self.main_source = "class.m"
self.break_line = line_number( self.break_line = line_number(
self.main_source, '// Set breakpoint here.') self.main_source, '// Set breakpoint here.')
@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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/lang/objc/ptr_refs/TestPtrRefsObjC.py

Show All 11 Lines
class TestPtrRefsObjC(TestBase): class TestPtrRefsObjC(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipIfAsan # The output looks different under ASAN. @skipIfAsan # The output looks different under ASAN.
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/lang/objc/self/TestObjCSelf.py

""" """
Tests that ObjC member variables are available where they should be. Tests that ObjC member variables are available where they should be.
""" """
import lldb import lldb
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
class ObjCSelfTestCase(TestBase): class ObjCSelfTestCase(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 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/lang/objc/single-entry-dictionary/TestObjCSingleEntryDictionary.py

Show All 36 Lines def test_single_entry_dict_no_const(self):
'-fno-constant-nsnumber-literals ' + '-fno-constant-nsnumber-literals ' +
'-fno-constant-nsarray-literals ' + '-fno-constant-nsarray-literals ' +
'-fno-constant-nsdictionary-literals' '-fno-constant-nsdictionary-literals'
} }
self.build(dictionary=disable_constant_classes) self.build(dictionary=disable_constant_classes)
self.run_tests() self.run_tests()
def run_tests(self): def run_tests(self):
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 37 Lines

lldb/test/API/lang/objcxx/objc-builtin-types/TestObjCBuiltinTypes.py

Show All 16 Lines def setUp(self):
self.main_source = "main.cpp" self.main_source = "main.cpp"
self.break_line = line_number( self.break_line = line_number(
self.main_source, '// Set breakpoint here.') self.main_source, '// Set breakpoint here.')
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 27 Lines

lldb/test/API/linux/aarch64/mte_memory_region/TestAArch64LinuxMTEMemoryRegion.py

Show All 25 Lines def test_mte_regions(self):
# This test assumes that we have /proc/<PID>/smaps files # This test assumes that we have /proc/<PID>/smaps files
# that include "VmFlags:" lines. # that include "VmFlags:" lines.
# AArch64 kernel config defaults to enabling smaps with # AArch64 kernel config defaults to enabling smaps with
# PROC_PAGE_MONITOR and "VmFlags" was added in kernel 3.8, # PROC_PAGE_MONITOR and "VmFlags" was added in kernel 3.8,
# before MTE was supported at all. # before MTE was supported at all.
self.build() self.build()
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line(self, "main.c", lldbutil.run_break_set_by_file_and_line(self, "main.c",
line_number('main.c', '// Set break point at this line.'), line_number('main.c', '// Set break point at this line.'),
num_expected_locations=1) num_expected_locations=1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
if self.process().GetState() == lldb.eStateExited: if self.process().GetState() == lldb.eStateExited:
Show All 11 Lines

lldb/test/API/linux/aarch64/mte_tag_access/TestAArch64LinuxMTEMemoryTagAccess.py

Show All 20 Lines def setup_mte_test(self):
self.skipTest('Target must support MTE.') self.skipTest('Target must support MTE.')
# Required to check that commands remove non-address bits # Required to check that commands remove non-address bits
# other than the memory tags. # other than the memory tags.
if not self.isAArch64PAuth(): if not self.isAArch64PAuth():
self.skipTest('Target must support pointer authentication') self.skipTest('Target must support pointer authentication')
self.build() self.build()
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line(self, "main.c", lldbutil.run_break_set_by_file_and_line(self, "main.c",
line_number('main.c', '// Breakpoint here'), line_number('main.c', '// Breakpoint here'),
num_expected_locations=1) num_expected_locations=1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
if self.process().GetState() == lldb.eStateExited: if self.process().GetState() == lldb.eStateExited:
▲ Show 20 Lines • Show All 437 Lines • Show Last 20 Lines

lldb/test/API/linux/aarch64/mte_tag_faults/TestAArch64LinuxMTEMemoryTagFaults.py

Show All 14 Linesclass AArch64LinuxMTEMemoryTagFaultsTestCase(TestBase):
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
def setup_mte_test(self, fault_type): def setup_mte_test(self, fault_type):
if not self.isAArch64MTE(): if not self.isAArch64MTE():
self.skipTest('Target must support MTE.') self.skipTest('Target must support MTE.')
self.build() self.build()
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line(self, "main.c", lldbutil.run_break_set_by_file_and_line(self, "main.c",
line_number('main.c', '// Breakpoint here'), line_number('main.c', '// Breakpoint here'),
num_expected_locations=1) num_expected_locations=1)
self.runCmd("run {}".format(fault_type), RUN_SUCCEEDED) self.runCmd("run {}".format(fault_type), RUN_SUCCEEDED)
if self.process().GetState() == lldb.eStateExited: if self.process().GetState() == lldb.eStateExited:
Show All 31 Lines

lldb/test/API/linux/aarch64/non_address_bit_memory_access/TestAArch64LinuxNonAddressBitMemoryAccess.py

Show All 19 Linesclass AArch64LinuxNonAddressBitMemoryAccessTestCase(TestBase):
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
def setup_test(self): def setup_test(self):
if not self.isAArch64PAuth(): if not self.isAArch64PAuth():
self.skipTest('Target must support pointer authentication.') self.skipTest('Target must support pointer authentication.')
self.build() self.build()
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line(self, "main.c", lldbutil.run_break_set_by_file_and_line(self, "main.c",
line_number('main.c', '// Set break point at this line.'), line_number('main.c', '// Set break point at this line.'),
num_expected_locations=1) num_expected_locations=1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
if self.process().GetState() == lldb.eStateExited: if self.process().GetState() == lldb.eStateExited:
▲ Show 20 Lines • Show All 198 Lines • Show Last 20 Lines

lldb/test/API/linux/aarch64/tagged_memory_access/TestAArch64LinuxTaggedMemoryAccess.py

Show All 16 Lines
class AArch64LinuxTaggedMemoryReadTestCase(TestBase): class AArch64LinuxTaggedMemoryReadTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
def setup_test(self): def setup_test(self):
self.build() self.build()
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line(self, "main.c", lldbutil.run_break_set_by_file_and_line(self, "main.c",
line_number('main.c', '// Set break point at this line.'), line_number('main.c', '// Set break point at this line.'),
num_expected_locations=1) num_expected_locations=1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
if self.process().GetState() == lldb.eStateExited: if self.process().GetState() == lldb.eStateExited:
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

lldb/test/API/linux/aarch64/tagged_memory_region/TestAArch64LinuxTaggedMemoryRegion.py

Show All 16 Linesclass AArch64LinuxTaggedMemoryRegionTestCase(TestBase):
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
# AArch64 Linux always enables the top byte ignore feature # AArch64 Linux always enables the top byte ignore feature
@skipUnlessArch("aarch64") @skipUnlessArch("aarch64")
@skipUnlessPlatform(["linux"]) @skipUnlessPlatform(["linux"])
def test_mte_regions(self): def test_mte_regions(self):
self.build() self.build()
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line(self, "main.c", lldbutil.run_break_set_by_file_and_line(self, "main.c",
line_number('main.c', '// Set break point at this line.'), line_number('main.c', '// Set break point at this line.'),
num_expected_locations=1) num_expected_locations=1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
if self.process().GetState() == lldb.eStateExited: if self.process().GetState() == lldb.eStateExited:
Show All 37 Lines

lldb/test/API/linux/aarch64/unwind_signal/TestUnwindSignal.py

Show All 15 Linesclass UnwindSignalTestCase(TestBase):
@skipUnlessArch("aarch64") @skipUnlessArch("aarch64")
@skipUnlessPlatform(["linux"]) @skipUnlessPlatform(["linux"])
def test_unwind_signal(self): def test_unwind_signal(self):
"""Inferior calls sigill() and handles the resultant SIGILL. """Inferior calls sigill() and handles the resultant SIGILL.
Stopped at a breakpoint in the handler, check that we can unwind Stopped at a breakpoint in the handler, check that we can unwind
back to sigill() and get the expected register contents there.""" back to sigill() and get the expected register contents there."""
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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())
self.assertTrue(process, PROCESS_IS_VALID) self.assertTrue(process, PROCESS_IS_VALID)
self.assertEqual(process.GetState(), lldb.eStateStopped) self.assertEqual(process.GetState(), lldb.eStateStopped)
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

lldb/test/API/linux/add-symbols/TestTargetSymbolsAddCommand.py

Show All 38 Lines def test_target_symbols_add(self):
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 %s %s" % self.runCmd("target symbols add -s %s %s" %
(exe, self.getBuildArtifact("a.out"))) (exe, self.getTestExecutable()))
# 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/test/API/linux/builtin_trap/TestBuiltinTrap.py

Show All 22 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(archs=['aarch64'], oslist=no_match(['freebsd', 'linux'])) @expectedFailureAll(archs=['aarch64'], oslist=no_match(['freebsd', 'linux']))
@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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/linux/mix-dwo-and-regular-objects/TestMixedDwarfBinary.py

Show All 11 Linesclass TestMixedDwarfBinary(TestBase):
@add_test_categories(["dwo"]) @add_test_categories(["dwo"])
@skipUnlessPlatform(["linux"]) @skipUnlessPlatform(["linux"])
def test_mixed_dwarf(self): def test_mixed_dwarf(self):
"""Test that 'frame variable' works """Test that 'frame variable' works
for the executable built from two source files compiled for the executable built from two source files compiled
with/whithout -gsplit-dwarf correspondingly.""" with/whithout -gsplit-dwarf correspondingly."""
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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("g", "a.out") main_bp = self.target.BreakpointCreateByName("g", "a.out")
self.assertTrue(main_bp, VALID_BREAKPOINT) self.assertTrue(main_bp, VALID_BREAKPOINT)
self.process = self.target.LaunchSimple( self.process = self.target.LaunchSimple(
Show All 13 Lines

lldb/test/API/linux/thread/create_during_instruction_step/TestCreateDuringInstructionStep.py

Show All 14 Linesclass CreateDuringInstructionStepTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
@skipUnlessPlatform(['linux']) @skipUnlessPlatform(['linux'])
@expectedFailureAndroid('llvm.org/pr24737', archs=['arm']) @expectedFailureAndroid('llvm.org/pr24737', archs=['arm'])
@skipIf(oslist=["linux"], archs=["arm", "aarch64"], bugnumber="llvm.org/pr24737") @skipIf(oslist=["linux"], archs=["arm", "aarch64"], bugnumber="llvm.org/pr24737")
def test_step_inst(self): def test_step_inst(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/lua_api/TestLuaAPI.py

Show First 20 Lines • Show All 152 Lines • ▼ Show 20 Linesclass TestLuaAPI(TestBase):
def test_lua_api(self): def test_lua_api(self):
if "LUA_EXECUTABLE" not in os.environ or len(os.environ["LUA_EXECUTABLE"]) == 0: if "LUA_EXECUTABLE" not in os.environ or len(os.environ["LUA_EXECUTABLE"]) == 0:
self.skipTest("Lua API tests could not find Lua executable.") self.skipTest("Lua API tests could not find Lua executable.")
return return
lua_executable = os.environ["LUA_EXECUTABLE"] lua_executable = os.environ["LUA_EXECUTABLE"]
self.build() self.build()
test_exe = self.getBuildArtifact("a.out") test_exe = self.getTestExecutable()
test_output = self.getBuildArtifact("output") test_output = self.getBuildArtifact("output")
test_input = self.getBuildArtifact("input") test_input = self.getBuildArtifact("input")
lua_lldb_cpath = "%s/lua/5.3/?.so" % configuration.lldb_libs_dir lua_lldb_cpath = "%s/lua/5.3/?.so" % configuration.lldb_libs_dir
lua_prelude = "package.cpath = '%s;' .. package.cpath" % lua_lldb_cpath lua_prelude = "package.cpath = '%s;' .. package.cpath" % lua_lldb_cpath
lua_env = { lua_env = {
Show All 17 Lines

lldb/test/API/macosx/add-dsym/TestAddDsymDownload.py

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines def create_dsym_for_uuid(self):
for l in shell_cmds: for l in shell_cmds:
writer.write(l + '\n') writer.write(l + '\n')
os.chmod(self.dsym_for_uuid, 0o755) os.chmod(self.dsym_for_uuid, 0o755)
def setUp(self): def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
self.source = 'main.c' self.source = 'main.c'
self.exe = self.getBuildArtifact("a.out") self.exe = self.getTestExecutable()
self.dsym = os.path.join( self.dsym = os.path.join(
self.getBuildDir(), self.getBuildDir(),
"hide.app/Contents/a.out.dSYM/Contents/Resources/DWARF/", "hide.app/Contents/a.out.dSYM/Contents/Resources/DWARF/",
os.path.basename(self.exe)) os.path.basename(self.exe))
self.dsym_for_uuid = self.getBuildArtifact("dsym-for-uuid.sh") self.dsym_for_uuid = self.getBuildArtifact("dsym-for-uuid.sh")
self.build(debug_info="dsym") self.build(debug_info="dsym")
self.assertTrue(os.path.exists(self.exe)) self.assertTrue(os.path.exists(self.exe))
Show All 40 Lines

lldb/test/API/macosx/add-dsym/TestAddDsymMidExecutionCommand.py

Show All 16 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.build(debug_info="dsym") self.build(debug_info="dsym")
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
self.target = self.dbg.CreateTarget(exe) self.target = self.dbg.CreateTarget(exe)
self.assertTrue(self.target, VALID_TARGET) self.assertTrue(self.target, VALID_TARGET)
main_bp = self.target.BreakpointCreateByName("main", "a.out") main_bp = self.target.BreakpointCreateByName("main", "a.out")
self.assertTrue(main_bp, VALID_BREAKPOINT) self.assertTrue(main_bp, VALID_BREAKPOINT)
self.runCmd("settings set target.disable-aslr false") self.runCmd("settings set target.disable-aslr false")
Show All 13 Lines

lldb/test/API/macosx/corefile-default-ptrauth/TestCorefileDefaultPtrauth.py

Show All 15 Linesclass TestCorefileDefaultPtrauth(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipIf(debug_info=no_match(["dsym"]), bugnumber="This test is looking explicitly for a dSYM") @skipIf(debug_info=no_match(["dsym"]), bugnumber="This test is looking explicitly for a dSYM")
@skipIf(archs=no_match(['arm64','arm64e'])) @skipIf(archs=no_match(['arm64','arm64e']))
@skipUnlessDarwin @skipUnlessDarwin
@skipIfRemote @skipIfRemote
def test_lc_note(self): def test_lc_note(self):
self.build() self.build()
self.test_exe = self.getBuildArtifact("a.out") self.test_exe = self.getTestExecutable()
self.create_corefile = self.getBuildArtifact("create-corefile") self.create_corefile = self.getBuildArtifact("create-corefile")
self.corefile = self.getBuildArtifact("core") self.corefile = self.getBuildArtifact("core")
### Create our corefile ### Create our corefile
retcode = call(self.create_corefile + " " + self.test_exe + " " + self.corefile, shell=True) retcode = call(self.create_corefile + " " + self.test_exe + " " + self.corefile, shell=True)
## This corefile has no metadata telling us how many bits are ## This corefile has no metadata telling us how many bits are
## used for ptrauth signed function pointers. We will need lldb ## used for ptrauth signed function pointers. We will need lldb
Show All 21 Lines

lldb/test/API/macosx/debugserver-exit-code/TestDebugServerExitCode.py

Show All 10 Linesclass TestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@no_debug_info_test @no_debug_info_test
@skipUnlessDarwin @skipUnlessDarwin
@skipIfOutOfTreeDebugserver @skipIfOutOfTreeDebugserver
def test_abort(self): def test_abort(self):
self.build() self.build()
target = self.dbg.CreateTarget(self.getBuildArtifact("a.out")) target = self.dbg.CreateTarget(self.getTestExecutable())
process = target.LaunchSimple(None, None, None) process = target.LaunchSimple(None, None, None)
# Continue until process is terminated. # Continue until process is terminated.
process.Continue() process.Continue()
# Test for the abort signal code. # Test for the abort signal code.
self.assertEqual(process.GetExitStatus(), 6) self.assertEqual(process.GetExitStatus(), 6)
# Test for the exit code description. # Test for the exit code description.
self.assertEqual(process.GetExitDescription(), self.assertEqual(process.GetExitDescription(),
"Terminated due to signal 6") "Terminated due to signal 6")

lldb/test/API/macosx/duplicate-archive-members/TestDuplicateMembers.py

Show All 13 Linesclass BSDArchivesTestCase(TestBase):
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr24527. Makefile.rules doesn't know how to build static libs on Windows") bugnumber="llvm.org/pr24527. Makefile.rules doesn't know how to build static libs on Windows")
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break on a() and b() symbols # Break on a() and b() symbols
lldbutil.run_break_set_by_symbol( lldbutil.run_break_set_by_symbol(
self, "a", sym_exact=True) self, "a", sym_exact=True)
lldbutil.run_break_set_by_symbol( lldbutil.run_break_set_by_symbol(
self, "b", sym_exact=True) self, "b", sym_exact=True)
Show All 22 Lines

lldb/test/API/macosx/dyld-trie-symbols/TestDyldTrieSymbols.py

Show All 13 Linesclass DyldTrieSymbolsTestCase(TestBase):
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
@skipIfRemote @skipIfRemote
@skipUnlessDarwin @skipUnlessDarwin
def test_dyld_trie_symbols(self): def test_dyld_trie_symbols(self):
"""Test that we make create symbol table entries from the dyld trie data structure.""" """Test that we make create symbol table entries from the dyld trie data structure."""
self.build() self.build()
unstripped_exe = self.getBuildArtifact("a.out") unstripped_exe = self.getTestExecutable()
stripped_exe = self.getBuildArtifact("a.out-stripped") stripped_exe = self.getBuildArtifact("a.out-stripped")
unstripped_target = self.dbg.CreateTarget(unstripped_exe) unstripped_target = self.dbg.CreateTarget(unstripped_exe)
self.assertTrue(unstripped_target.IsValid(), "Got a vaid stripped target.") self.assertTrue(unstripped_target.IsValid(), "Got a vaid stripped target.")
# Verify that the expected symbols are present in an unstripped # Verify that the expected symbols are present in an unstripped
# binary, and that we didn't duplicate the entries in the symbol # binary, and that we didn't duplicate the entries in the symbol
# table. # table.
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

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

Show All 17 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
lib1 = self.getBuildArtifact('libindirect.dylib') lib1 = self.getBuildArtifact('libindirect.dylib')
lib2 = self.getBuildArtifact('libreexport.dylib') lib2 = self.getBuildArtifact('libreexport.dylib')
self.registerSharedLibrariesWithTarget(target, [lib1, lib2]) self.registerSharedLibrariesWithTarget(target, [lib1, lib2])
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

lldb/test/API/macosx/lc-note/addrable-bits/TestAddrableBitsCorefile.py

Show All 13 Lines
class TestAddrableBitsCorefile(TestBase): class TestAddrableBitsCorefile(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
def initial_setup(self): def initial_setup(self):
self.build() self.build()
self.exe = self.getBuildArtifact("a.out") self.exe = self.getTestExecutable()
self.corefile = self.getBuildArtifact("corefile") self.corefile = self.getBuildArtifact("corefile")
@skipIf(archs=no_match(['arm64e'])) @skipIf(archs=no_match(['arm64e']))
@skipUnlessDarwin @skipUnlessDarwin
def test_lc_note_addrable_bits(self): def test_lc_note_addrable_bits(self):
self.initial_setup() self.initial_setup()
self.target = self.dbg.CreateTarget(self.exe) self.target = self.dbg.CreateTarget(self.exe)
Show All 29 Lines

lldb/test/API/macosx/lc-note/firmware-corefile/TestFirmwareCorefiles.py

Show First 20 Lines • Show All 155 Lines • ▼ Show 20 Linesclass TestFirmwareCorefiles(TestBase):
@skipIf(debug_info=no_match(["dsym"]), bugnumber="This test is looking explicitly for a dSYM") @skipIf(debug_info=no_match(["dsym"]), bugnumber="This test is looking explicitly for a dSYM")
@skipIf(archs=no_match(['x86_64', 'arm64', 'arm64e', 'aarch64'])) @skipIf(archs=no_match(['x86_64', 'arm64', 'arm64e', 'aarch64']))
@skipIfRemote @skipIfRemote
@skipUnlessDarwin @skipUnlessDarwin
def test_lc_note_main_bin_spec_os_plugin(self): def test_lc_note_main_bin_spec_os_plugin(self):
self.build() self.build()
aout_exe = self.getBuildArtifact("a.out") aout_exe = self.getTestExecutable()
aout_exe_basename = "a.out" aout_exe_basename = "a.out"
create_corefile = self.getBuildArtifact("create-empty-corefile") create_corefile = self.getBuildArtifact("create-empty-corefile")
binspec_corefile_addr = self.getBuildArtifact("binspec-addr.core") binspec_corefile_addr = self.getBuildArtifact("binspec-addr.core")
slide = 0x70000000000 slide = 0x70000000000
### Create our corefile ### Create our corefile
# 0xffffffffffffffff means load address unknown # 0xffffffffffffffff means load address unknown
▲ Show 20 Lines • Show All 110 Lines • Show Last 20 Lines

lldb/test/API/macosx/lc-note/kern-ver-str/TestKernVerStrLCNOTE.py

Show All 15 Linesclass TestKernVerStrLCNOTE(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipIf(debug_info=no_match(["dsym"]), bugnumber="This test is looking explicitly for a dSYM") @skipIf(debug_info=no_match(["dsym"]), bugnumber="This test is looking explicitly for a dSYM")
@skipIf(archs=no_match(['x86_64'])) @skipIf(archs=no_match(['x86_64']))
@skipUnlessDarwin @skipUnlessDarwin
def test_lc_note(self): def test_lc_note(self):
self.build() self.build()
self.test_exe = self.getBuildArtifact("a.out") self.test_exe = self.getTestExecutable()
self.create_corefile = self.getBuildArtifact("create-empty-corefile") self.create_corefile = self.getBuildArtifact("create-empty-corefile")
self.dsym_for_uuid = self.getBuildArtifact("dsym-for-uuid.sh") self.dsym_for_uuid = self.getBuildArtifact("dsym-for-uuid.sh")
self.corefile = self.getBuildArtifact("core") self.corefile = self.getBuildArtifact("core")
## We can hook in our dsym-for-uuid shell script to lldb with this env ## We can hook in our dsym-for-uuid shell script to lldb with this env
## var instead of requiring a defaults write. ## var instead of requiring a defaults write.
os.environ['LLDB_APPLE_DSYMFORUUID_EXECUTABLE'] = self.dsym_for_uuid os.environ['LLDB_APPLE_DSYMFORUUID_EXECUTABLE'] = self.dsym_for_uuid
self.addTearDownHook(lambda: os.environ.pop('LLDB_APPLE_DSYMFORUUID_EXECUTABLE', None)) self.addTearDownHook(lambda: os.environ.pop('LLDB_APPLE_DSYMFORUUID_EXECUTABLE', None))
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

lldb/test/API/macosx/nslog/TestDarwinNSLogOutput.py

Show All 29 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 = self.getBuildArtifact("a.out") self.exe_name = self.getTestExecutable()
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 = line_number(self.source, '// break here') self.line = 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 105 Lines • Show Last 20 Lines

lldb/test/API/macosx/order/TestOrderFile.py

Show All 13 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 %s" % exe) 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/test/API/macosx/queues/TestQueues.py

Show First 20 Lines • Show All 120 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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, self.get_process_working_directory()) [], None, self.get_process_working_directory())
▲ Show 20 Lines • Show All 111 Lines • ▼ Show 20 Lines def queues(self):
"Get QoS printable string for background QoS thread") "Get QoS printable string for background QoS thread")
self.assertEqual( self.assertEqual(
stream.GetData(), "Background", stream.GetData(), "Background",
"background QoS thread name is valid") "background QoS thread name is valid")
@skipIfDarwin # rdar://50379398 @skipIfDarwin # rdar://50379398
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 110 Lines • Show Last 20 Lines

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

Show All 11 Linesclass TestSafeFuncCalls(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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("main.c") self.main_source_spec = lldb.SBFileSpec("main.c")
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 26 Lines

lldb/test/API/macosx/simulator/TestSimulatorPlatform.py

import lldb import lldb
from lldbsuite.test.lldbtest import * from lldbsuite.test.lldbtest import *
from lldbsuite.test.decorators import * from lldbsuite.test.decorators import *
import lldbsuite.test.lldbutil as lldbutil import lldbsuite.test.lldbutil as lldbutil
import json import json
import unittest2 import unittest2
class TestSimulatorPlatformLaunching(TestBase): class TestSimulatorPlatformLaunching(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
def check_load_commands(self, expected_load_command): def check_load_commands(self, expected_load_command):
"""sanity check the built binary for the expected number of load commands""" """sanity check the built binary for the expected number of load commands"""
load_cmds = subprocess.check_output( load_cmds = subprocess.check_output(
['otool', '-l', self.getBuildArtifact("a.out")] ['otool', '-l', self.getTestExecutable()]
).decode("utf-8") ).decode("utf-8")
found = 0 found = 0
for line in load_cmds.split('\n'): for line in load_cmds.split('\n'):
if expected_load_command in line: if expected_load_command in line:
found += 1 found += 1
self.assertEquals( self.assertEquals(
found, 1, "wrong number of load commands for {}".format( found, 1, "wrong number of load commands for {}".format(
expected_load_command)) expected_load_command))
▲ Show 20 Lines • Show All 207 Lines • Show Last 20 Lines

lldb/test/API/macosx/skinny-corefile/TestSkinnyCorefile.py

Show All 16 Linesclass TestSkinnyCorefile(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipIfOutOfTreeDebugserver # newer debugserver required for these qMemoryRegionInfo types @skipIfOutOfTreeDebugserver # newer debugserver required for these qMemoryRegionInfo types
@skipIf(debug_info=no_match(["dsym"]), bugnumber="This test is looking explicitly for a dSYM") @skipIf(debug_info=no_match(["dsym"]), bugnumber="This test is looking explicitly for a dSYM")
@skipUnlessDarwin @skipUnlessDarwin
@skipIfRemote @skipIfRemote
def test_lc_note(self): def test_lc_note(self):
self.build() self.build()
self.aout_exe = self.getBuildArtifact("a.out") self.aout_exe = self.getTestExecutable()
self.aout_dsym = self.getBuildArtifact("a.out.dSYM") self.aout_dsym = self.getBuildArtifact("a.out.dSYM")
self.to_be_removed_dylib = self.getBuildArtifact("libto-be-removed.dylib") self.to_be_removed_dylib = self.getBuildArtifact("libto-be-removed.dylib")
self.to_be_removed_dsym = self.getBuildArtifact("libto-be-removed.dylib.dSYM") self.to_be_removed_dsym = self.getBuildArtifact("libto-be-removed.dylib.dSYM")
self.corefile = self.getBuildArtifact("process.core") self.corefile = self.getBuildArtifact("process.core")
self.dsym_for_uuid = self.getBuildArtifact("dsym-for-uuid.sh") self.dsym_for_uuid = self.getBuildArtifact("dsym-for-uuid.sh")
# After the corefile is created, we'll move a.out and a.out.dSYM # After the corefile is created, we'll move a.out and a.out.dSYM
# into hide.noindex and lldb will have to use the # into hide.noindex and lldb will have to use the
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

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

Show All 11 Linesclass TestInterruptThreadNames(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
launch_info = target.GetLaunchInfo() launch_info = target.GetLaunchInfo()
error = lldb.SBError() error = lldb.SBError()
self.dbg.SetAsync(True) self.dbg.SetAsync(True)
process = target.Launch(launch_info, error) process = target.Launch(launch_info, error)
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines

lldb/test/API/python_api/breakpoint/TestBreakpointAPI.py

Show All 10 Lines
class BreakpointAPITestCase(TestBase): class BreakpointAPITestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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')
self.trace("breakpoint:", breakpoint) self.trace("breakpoint:", breakpoint)
Show All 16 Lines def test_breakpoint_is_valid(self):
not breakpoint, not breakpoint,
"Breakpoint we deleted is no longer valid.") "Breakpoint we deleted is no longer valid.")
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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')
self.trace("breakpoint:", breakpoint) self.trace("breakpoint:", breakpoint)
Show All 12 Lines

lldb/test/API/python_api/debugger/TestDebuggerAPI.py

Show All 40 Lines def test_debugger_delete_invalid_target(self):
target = lldb.SBTarget() target = lldb.SBTarget()
self.assertFalse(target.IsValid()) self.assertFalse(target.IsValid())
self.dbg.DeleteTarget(target) self.dbg.DeleteTarget(target)
def test_debugger_internal_variables(self): def test_debugger_internal_variables(self):
"""Ensure that SBDebugger reachs the same instance of properties """Ensure that SBDebugger reachs the same instance of properties
regardless CommandInterpreter's context initialization""" regardless CommandInterpreter's context initialization"""
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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)
property_name = "target.process.memory-cache-line-size" property_name = "target.process.memory-cache-line-size"
def get_cache_line_size(): def get_cache_line_size():
Show All 31 Lines def test_debugger_internal_variables(self):
# Run any command to initialize CommandInterpreter's execution context. # Run any command to initialize CommandInterpreter's execution context.
self.runCmd("target list") self.runCmd("target list")
# Test the local property again, is it set to new_cache_line_size? # Test the local property again, is it set to new_cache_line_size?
self.assertEqual(get_cache_line_size(), new_cache_line_size) self.assertEqual(get_cache_line_size(), new_cache_line_size)
def test_CreateTarget_platform(self): def test_CreateTarget_platform(self):
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
self.yaml2obj("elf.yaml", exe) self.yaml2obj("elf.yaml", exe)
error = lldb.SBError() error = lldb.SBError()
target1 = self.dbg.CreateTarget(exe, None, "remote-linux", target1 = self.dbg.CreateTarget(exe, None, "remote-linux",
False, error) False, error)
self.assertSuccess(error) self.assertSuccess(error)
platform1 = target1.GetPlatform() platform1 = target1.GetPlatform()
platform1.SetWorkingDirectory("/foo/bar") platform1.SetWorkingDirectory("/foo/bar")
Show All 9 Lines def test_CreateTarget_platform(self):
self.dbg.SetSelectedPlatform(lldb.SBPlatform("remote-windows")) self.dbg.SetSelectedPlatform(lldb.SBPlatform("remote-windows"))
target3 = self.dbg.CreateTarget(exe, None, "remote-linux", target3 = self.dbg.CreateTarget(exe, None, "remote-linux",
False, error) False, error)
self.assertSuccess(error) self.assertSuccess(error)
platform3 = target3.GetPlatform() platform3 = target3.GetPlatform()
self.assertIsNone(platform3.GetWorkingDirectory()) self.assertIsNone(platform3.GetWorkingDirectory())
def test_CreateTarget_arch(self): def test_CreateTarget_arch(self):
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
if lldbplatformutil.getHostPlatform() == 'linux': if lldbplatformutil.getHostPlatform() == 'linux':
self.yaml2obj("macho.yaml", exe) self.yaml2obj("macho.yaml", exe)
arch = "x86_64-apple-macosx" arch = "x86_64-apple-macosx"
expected_platform = "remote-macosx" expected_platform = "remote-macosx"
else: else:
self.yaml2obj("elf.yaml", exe) self.yaml2obj("elf.yaml", exe)
arch = "x86_64-pc-linux" arch = "x86_64-pc-linux"
expected_platform = "remote-linux" expected_platform = "remote-linux"
Show All 19 Lines

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

Show All 27 Linesclass EventAPITestCase(TestBase):
@expectedFailureAll( @expectedFailureAll(
oslist=["linux"], oslist=["linux"],
bugnumber="llvm.org/pr23730 Flaky, fails ~1/10 cases") bugnumber="llvm.org/pr23730 Flaky, fails ~1/10 cases")
@skipIfWindows # This is flakey on Windows AND when it fails, it hangs: llvm.org/pr38373 @skipIfWindows # This is flakey on Windows AND when it fails, it hangs: llvm.org/pr38373
@skipIfNetBSD @skipIfNetBSD
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 73 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?
@expectedFlakeyLinux("llvm.org/pr23730") # Flaky, fails ~1/100 cases @expectedFlakeyLinux("llvm.org/pr23730") # Flaky, fails ~1/100 cases
@skipIfWindows # This is flakey on Windows AND when it fails, it hangs: llvm.org/pr38373 @skipIfWindows # This is flakey on Windows AND when it fails, it hangs: llvm.org/pr38373
@skipIfNetBSD @skipIfNetBSD
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 64 Lines • ▼ Show 20 Lines @expectedFailureAll(
oslist=["linux"], oslist=["linux"],
bugnumber="llvm.org/pr23617 Flaky, fails ~1/10 cases") bugnumber="llvm.org/pr23617 Flaky, fails ~1/10 cases")
@skipIfWindows # This is flakey on Windows AND when it fails, it hangs: llvm.org/pr38373 @skipIfWindows # This is flakey on Windows AND when it fails, it hangs: llvm.org/pr38373
@expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr48417") @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr48417")
@expectedFailureNetBSD @expectedFailureNetBSD
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 101 Lines • Show Last 20 Lines

lldb/test/API/python_api/findvalue_duplist/TestSBFrameFindValue.py

Show All 12 Linesclass SBFrameFindValueTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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/test/API/python_api/formatters/TestFormattersSBAPI.py

Show All 19 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.')
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 " + self.getBuildArtifact("a.out"), self.runCmd("file " + self.getTestExecutable(),
CURRENT_EXECUTABLE_SET) 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,
loc_exact=True) loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
▲ Show 20 Lines • Show All 462 Lines • Show Last 20 Lines

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

Show All 13 Lines
class FrameAPITestCase(TestBase): class FrameAPITestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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.trace("breakpoint:", breakpoint) self.trace("breakpoint:", breakpoint)
▲ Show 20 Lines • Show All 86 Lines • ▼ Show 20 Lines def test_get_arg_vals_for_call_stack(self):
self.expect(session.getvalue(), "Argument values displayed correctly", self.expect(session.getvalue(), "Argument values displayed correctly",
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')"])
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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.trace("breakpoint:", breakpoint) self.trace("breakpoint:", breakpoint)
Show All 24 Lines def test_frame_api_boundary_condition(self):
print("val1:", val1) print("val1:", val1)
print("val2:", val2) print("val2:", val2)
frame.EvaluateExpression(None) frame.EvaluateExpression(None)
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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.trace("breakpoint:", breakpoint) self.trace("breakpoint:", breakpoint)
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

lldb/test/API/python_api/frame/get-variables/TestGetVariables.py

Show First 20 Lines • Show All 43 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/python_api/frame/inlines/TestInlinedFrame.py

Show All 22 Lines def setUp(self):
self.first_stop = line_number( self.first_stop = line_number(
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.')
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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')
self.trace("breakpoint:", breakpoint) self.trace("breakpoint:", breakpoint)
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

lldb/test/API/python_api/function_symbol/TestDisasmAPI.py

Show All 22 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.')
@expectedFailureAll(oslist=["windows"], bugnumber='llvm.org/pr21765') @expectedFailureAll(oslist=["windows"], bugnumber='llvm.org/pr21765')
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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 79 Lines • Show Last 20 Lines

lldb/test/API/python_api/function_symbol/TestSymbolAPI.py

Show All 22 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.')
@expectedFailureAll(oslist=["windows"], bugnumber='llvm.org/pr21765') @expectedFailureAll(oslist=["windows"], bugnumber='llvm.org/pr21765')
def test(self): def test(self):
"""Exercise some SBSymbol and SBAddress APIs.""" """Exercise some SBSymbol and SBAddress APIs."""
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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/test/API/python_api/interpreter/TestCommandInterpreterAPI.py

Show All 17 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
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.')
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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 20 Lines • Show All 55 Lines • Show Last 20 Lines

lldb/test/API/python_api/lldbutil/frame/TestFrameUtils.py

Show All 19 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.c', self.line = line_number('main.c',
"// Find the line number here.") "// Find the line number here.")
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/python_api/lldbutil/iter/TestLLDBIterator.py

Show All 20 Lines def setUp(self):
# Find the line numbers to break inside main(). # Find the line numbers to break inside main().
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.')
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 18 Lines def test_lldb_iter_module(self):
print("mine[%d]='%s'" % (i, get_description(mine[i]))) print("mine[%d]='%s'" % (i, get_description(mine[i])))
self.assertEqual( self.assertEqual(
yours[i], mine[i], yours[i], mine[i],
"UUID+FileSpec of yours[{0}] and mine[{0}] matches".format(i)) "UUID+FileSpec of yours[{0}] and mine[{0}] matches".format(i))
def test_lldb_iter_breakpoint(self): def test_lldb_iter_breakpoint(self):
"""Test breakpoint_iter works correctly for SBTarget -> SBBreakpoint.""" """Test breakpoint_iter works correctly for SBTarget -> SBBreakpoint."""
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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.assertEqual(yours[i], mine[i], self.assertEqual(yours[i], mine[i],
"ID of yours[{0}] and mine[{0}] matches".format(i)) "ID of yours[{0}] and mine[{0}] matches".format(i))
@skipIfWindows # This test is flaky on Windows @skipIfWindows # This test is flaky on Windows
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/python_api/lldbutil/iter/TestRegistersIterator.py

Show All 19 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.line1 = line_number( self.line1 = line_number(
'main.cpp', '// Set break point at this line.') 'main.cpp', '// Set break point at this line.')
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/python_api/module_section/TestModuleAndSection.py

Show All 16 Linesclass ModuleAndSectionAPIsTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
# 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)])
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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):
INDENT2 + INDENT2 +
"symbol type: %s" % "symbol type: %s" %
symbol_type_to_str( symbol_type_to_str(
sym.GetType())) sym.GetType()))
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 23 Lines def test_module_and_section_boundary_condition(self):
sec1 = None sec1 = None
if sec1: if sec1:
sec1.FindSubSection(None) sec1.FindSubSection(None)
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 39 Lines

lldb/test/API/python_api/name_lookup/TestNameLookup.py

Show All 18 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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/test/API/python_api/objc_type/TestObjCType.py

Show All 17 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
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')
@add_test_categories(['objc', 'pyapi']) @add_test_categories(['objc', 'pyapi'])
def test(self): def test(self):
"""Test SBType for ObjC classes.""" """Test SBType for ObjC classes."""
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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/test/API/python_api/process/TestProcessAPI.py

Show All 20 Lines def setUp(self):
# Find the line number to break inside main(). # Find the line number to break inside main().
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'.")
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 80 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")
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 41 Lines • ▼ Show 20 Lines def test_write_memory(self):
content, content,
"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')
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 80 Lines • ▼ Show 20 Lines def test_access_my_int(self):
# Dump the memory content.... # Dump the memory content....
if self.TraceOn(): if self.TraceOn():
for i in content: for i in content:
print("byte:", i) print("byte:", i)
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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")
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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)
@no_debug_info_test @no_debug_info_test
@skipIfRemote @skipIfRemote
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 = target.GetLaunchInfo() launch_info = target.GetLaunchInfo()
launch_info.SetWorkingDirectory(self.get_process_working_directory()) launch_info.SetWorkingDirectory(self.get_process_working_directory())
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines def test_byte_order_and_address_byte_size_with_ownership(self):
data.SetDataWithOwnership(error, addr_data, lldb.eByteOrderBig, 8) data.SetDataWithOwnership(error, addr_data, lldb.eByteOrderBig, 8)
del addr_data del addr_data
addr = data.GetAddress(error, 0) addr = data.GetAddress(error, 0)
self.assertEqual(addr, 0x1122334455667788); self.assertEqual(addr, 0x1122334455667788);
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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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 466 Lines • Show Last 20 Lines

lldb/test/API/python_api/sbmodule/TestSBModule.py

Show All 31 Lines def test_module_is_file_backed(self):
main_module = target.GetModuleAtIndex(0) main_module = target.GetModuleAtIndex(0)
self.assertEqual(main_module.GetFileSpec().GetFilename(), "a.out") self.assertEqual(main_module.GetFileSpec().GetFilename(), "a.out")
self.assertTrue(main_module.IsFileBacked(), self.assertTrue(main_module.IsFileBacked(),
"The module should be backed by a file on disk") "The module should be backed by a file on disk")
self.dbg.DeleteTarget(target) self.dbg.DeleteTarget(target)
self.assertEqual(self.dbg.GetNumTargets(), 0) self.assertEqual(self.dbg.GetNumTargets(), 0)
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
background_process = subprocess.Popen([exe]) background_process = subprocess.Popen([exe])
self.assertTrue(background_process, "process is not valid") self.assertTrue(background_process, "process is not valid")
self.background_pid = background_process.pid self.background_pid = background_process.pid
os.unlink(exe) os.unlink(exe)
target = self.dbg.CreateTarget('') target = self.dbg.CreateTarget('')
self.assertEqual(self.dbg.GetNumTargets(), 1) self.assertEqual(self.dbg.GetNumTargets(), 1)
error = lldb.SBError() error = lldb.SBError()
Show All 11 Lines

lldb/test/API/python_api/sbplatform/TestSBPlatform.py

Show All 11 Linesclass SBPlatformAPICase(TestBase):
def test_run(self): def test_run(self):
self.build() self.build()
plat = lldb.SBPlatform.GetHostPlatform() plat = lldb.SBPlatform.GetHostPlatform()
os.environ["MY_TEST_ENV_VAR"]="SBPlatformAPICase.test_run" os.environ["MY_TEST_ENV_VAR"]="SBPlatformAPICase.test_run"
def cleanup(): def cleanup():
del os.environ["MY_TEST_ENV_VAR"] del os.environ["MY_TEST_ENV_VAR"]
self.addTearDownHook(cleanup) self.addTearDownHook(cleanup)
cmd = lldb.SBPlatformShellCommand(self.getBuildArtifact("a.out")) cmd = lldb.SBPlatformShellCommand(self.getTestExecutable())
self.assertSuccess(plat.Run(cmd)) self.assertSuccess(plat.Run(cmd))
self.assertIn("MY_TEST_ENV_VAR=SBPlatformAPICase.test_run", cmd.GetOutput()) self.assertIn("MY_TEST_ENV_VAR=SBPlatformAPICase.test_run", cmd.GetOutput())
def test_SetSDKRoot(self): def test_SetSDKRoot(self):
plat = lldb.SBPlatform("remote-linux") # arbitrary choice plat = lldb.SBPlatform("remote-linux") # arbitrary choice
self.assertTrue(plat) self.assertTrue(plat)
plat.SetSDKRoot(self.getBuildDir()) plat.SetSDKRoot(self.getBuildDir())
self.dbg.SetSelectedPlatform(plat) self.dbg.SetSelectedPlatform(plat)
Show All 25 Lines

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

Show All 12 Linesclass SBValuePersistTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
@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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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/test/API/python_api/signals/TestSignalsAPI.py

Show All 13 Lines
class SignalsAPITestCase(TestBase): class SignalsAPITestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
@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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/python_api/symbol-context/TestSymbolContext.py

Show All 19 Lines def setUp(self):
# Find the line number to of function 'c'. # Find the line number to of function 'c'.
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.')
@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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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', exe) breakpoint = target.BreakpointCreateByName('c', exe)
self.assertTrue(breakpoint and breakpoint.GetNumLocations() == 1, self.assertTrue(breakpoint and breakpoint.GetNumLocations() == 1,
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

lldb/test/API/python_api/symbol-context/two-files/TestSymbolContextTwoFiles.py

Show All 12 Lines
class SymbolContextTwoFilesTestCase(TestBase): class SymbolContextTwoFilesTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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())
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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)
self.assertTrue(breakpoint1.IsValid()) self.assertTrue(breakpoint1.IsValid())
Show All 27 Lines

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

Show First 20 Lines • Show All 310 Lines • ▼ Show 20 Lines def find_functions(self, exe_name):
for sc in list: for sc in list:
self.assertEqual( self.assertEqual(
sc.GetModule().GetFileSpec().GetFilename(), exe_name) sc.GetModule().GetFileSpec().GetFilename(), exe_name)
self.assertEqual(sc.GetSymbol().GetName(), 'c') self.assertEqual(sc.GetSymbol().GetName(), 'c')
def get_description(self): def get_description(self):
"""Exercise SBTarget.GetDescription() API.""" """Exercise SBTarget.GetDescription() API."""
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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 13 Lines def get_description(self):
self.expect(desc, exe=False, self.expect(desc, exe=False,
substrs=['Target', 'Module', 'a.out', 'Breakpoint']) substrs=['Target', 'Module', 'a.out', 'Breakpoint'])
@skipIfRemote @skipIfRemote
@no_debug_info_test @no_debug_info_test
def test_launch_new_process_and_redirect_stdout(self): def test_launch_new_process_and_redirect_stdout(self):
"""Exercise SBTarget.Launch() API with redirected stdout.""" """Exercise SBTarget.Launch() API with redirected stdout."""
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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 41 Lines • ▼ Show 20 Lines def test_launch_new_process_and_redirect_stdout(self):
with open(local_path, 'r') as f: with open(local_path, 'r') as f:
output = f.read() output = f.read()
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 SBTarget.ResolveSymbolContextForAddress() API.""" """Exercise SBTarget.ResolveSymbolContextForAddress() API."""
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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 66 Lines • ▼ Show 20 Lines def resolve_symbol_context_with_address(self):
desc2 = get_description(symbol2) desc2 = get_description(symbol2)
self.assertTrue(desc1 and desc2 and desc1 == desc2, self.assertTrue(desc1 and desc2 and desc1 == desc2,
"The two addresses should resolve to the same symbol") "The two addresses should resolve to the same symbol")
@skipIfRemote @skipIfRemote
def test_default_arch(self): def test_default_arch(self):
""" Test the other two target create methods using LLDB_ARCH_DEFAULT. """ """ Test the other two target create methods using LLDB_ARCH_DEFAULT. """
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
target = self.dbg.CreateTargetWithFileAndArch(exe, lldb.LLDB_ARCH_DEFAULT) target = self.dbg.CreateTargetWithFileAndArch(exe, lldb.LLDB_ARCH_DEFAULT)
self.assertTrue(target.IsValid(), "Default arch made a valid target.") self.assertTrue(target.IsValid(), "Default arch made a valid target.")
# This should also work with the target's triple: # This should also work with the target's triple:
target2 = self.dbg.CreateTargetWithFileAndArch(exe, target.GetTriple()) target2 = self.dbg.CreateTargetWithFileAndArch(exe, target.GetTriple())
self.assertTrue(target2.IsValid(), "Round trip with triple works") self.assertTrue(target2.IsValid(), "Round trip with triple works")
# And this triple should work for the FileAndTriple API: # And this triple should work for the FileAndTriple API:
target3 = self.dbg.CreateTargetWithFileAndTargetTriple(exe, target.GetTriple()) target3 = self.dbg.CreateTargetWithFileAndTargetTriple(exe, target.GetTriple())
self.assertTrue(target3.IsValid()) self.assertTrue(target3.IsValid())
Show All 25 Lines

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

Show First 20 Lines • Show All 66 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
# compiled from main2.cpp. # compiled 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 9 Lines def get_process(self):
self.runCmd("process status") self.runCmd("process status")
proc_of_thread = thread.GetProcess() proc_of_thread = thread.GetProcess()
self.trace("proc_of_thread:", proc_of_thread) self.trace("proc_of_thread:", proc_of_thread)
self.assertEqual(proc_of_thread.GetProcessID(), process.GetProcessID()) self.assertEqual(proc_of_thread.GetProcessID(), process.GetProcessID())
def get_stop_description(self): def get_stop_description(self):
"""Test Python SBThread.GetStopDescription() API.""" """Test Python SBThread.GetStopDescription() API."""
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 167 Lines • Show Last 20 Lines

lldb/test/API/python_api/value/empty_class/TestValueAPIEmptyClass.py

import lldb import lldb
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
class ValueAPIEmptyClassTestCase(TestBase): class ValueAPIEmptyClassTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def test(self): def test(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/python_api/watchpoint/TestSetWatchpoint.py

Show All 24 Lines def setUp(self):
self.line = line_number( self.line = line_number(
self.source, '// Set break point at this line.') self.source, '// Set break point at this line.')
# 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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/test/API/python_api/watchpoint/TestWatchpointIgnoreCount.py

Show All 31 Linesclass WatchpointIgnoreCountTestCase(TestBase):
def affected_by_radar_93863107(self): def affected_by_radar_93863107(self):
return (self.getArchitecture() in ['arm64', 'arm64e']) and self.platformIsDarwin() return (self.getArchitecture() in ['arm64', 'arm64e']) and self.platformIsDarwin()
# 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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 51 Lines • Show Last 20 Lines

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

Show All 27 Lines def setUp(self):
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.')
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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/test/API/python_api/watchpoint/watchlocation/TestSetWatchlocation.py

Show All 26 Lines def setUp(self):
self.source, '// Set break point at this line.') self.source, '// Set break point at this line.')
# This is for verifying that watch location works. # This is for verifying that watch location works.
self.violating_func = "do_bad_thing_with_location" self.violating_func = "do_bad_thing_with_location"
@skipIfWindows # This test is flaky on Windows @skipIfWindows # This test is flaky 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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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/test/API/python_api/watchpoint/watchlocation/TestTargetWatchAddress.py

Show All 24 Lines def setUp(self):
self.line = line_number( self.line = line_number(
self.source, '// Set break point at this line.') self.source, '// Set break point at this line.')
# This is for verifying that watch location works. # This is for verifying that watch location works.
self.violating_func = "do_bad_thing_with_location" self.violating_func = "do_bad_thing_with_location"
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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 20 Lines def test_watch_address(self):
# This finishes our test. # This finishes our test.
# 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
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# 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/test/API/qemu/TestQemuLaunch.py

Show All 39 Lines def setUp(self):
""").format(exec=sys.executable, path=sys.path, """).format(exec=sys.executable, path=sys.path,
source=self.getSourcePath("qemu.py"))) source=self.getSourcePath("qemu.py")))
self.set_emulator_setting("architecture", self.getArchitecture()) self.set_emulator_setting("architecture", self.getArchitecture())
self.set_emulator_setting("emulator-path", emulator) self.set_emulator_setting("emulator-path", emulator)
def _create_target(self): def _create_target(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# Create a target using our platform # Create a target using our platform
error = lldb.SBError() error = lldb.SBError()
target = self.dbg.CreateTarget(exe, '', 'qemu-user', False, error) target = self.dbg.CreateTarget(exe, '', 'qemu-user', False, error)
self.assertSuccess(error) self.assertSuccess(error)
self.assertEqual(target.GetPlatform().GetName(), "qemu-user") self.assertEqual(target.GetPlatform().GetName(), "qemu-user")
return target return target
Show All 16 Lines def _run_and_get_state(self, target=None, info=None):
# Verify the qemu invocation parameters. # Verify the qemu invocation parameters.
with open(self.getBuildArtifact("state.log")) as s: with open(self.getBuildArtifact("state.log")) as s:
return json.load(s) return json.load(s)
def test_basic_launch(self): def test_basic_launch(self):
state = self._run_and_get_state() state = self._run_and_get_state()
self.assertEqual(state["program"], self.getBuildArtifact("a.out")) self.assertEqual(state["program"], self.getTestExecutable())
self.assertEqual(state["args"], self.assertEqual(state["args"],
["dump:" + self.getBuildArtifact("state.log")]) ["dump:" + self.getBuildArtifact("state.log")])
def test_stdio_pty(self): def test_stdio_pty(self):
target = self._create_target() target = self._create_target()
info = target.GetLaunchInfo() info = target.GetLaunchInfo()
info.SetArguments([ info.SetArguments([
Show All 23 Lines def test_stdio_pty(self):
self.assertEqual(process.GetSTDOUT(1000), self.assertEqual(process.GetSTDOUT(1000),
"STDIN CONTENT\r\nSTDOUT CONTENT\r\nSTDERR CONTENT\r\n") "STDIN CONTENT\r\nSTDOUT CONTENT\r\nSTDERR CONTENT\r\n")
with open(self.getBuildArtifact("state.log")) as s: with open(self.getBuildArtifact("state.log")) as s:
state = json.load(s) state = json.load(s)
self.assertEqual(state["stdin"], "STDIN CONTENT\n") self.assertEqual(state["stdin"], "STDIN CONTENT\n")
def test_stdio_redirect(self): def test_stdio_redirect(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
# Create a target using our platform # Create a target using our platform
error = lldb.SBError() error = lldb.SBError()
target = self.dbg.CreateTarget(exe, '', 'qemu-user', False, error) target = self.dbg.CreateTarget(exe, '', 'qemu-user', False, error)
self.assertSuccess(error) self.assertSuccess(error)
info = lldb.SBLaunchInfo([ info = lldb.SBLaunchInfo([
"stdin:stdin", "stdin:stdin",
Show All 33 Lines def test_find_in_PATH(self):
os.environ["PATH"] = (self.getBuildDir() + os.environ["PATH"] = (self.getBuildDir() +
self.platformContext.shlib_path_separator + original_path) self.platformContext.shlib_path_separator + original_path)
def cleanup(): def cleanup():
os.environ["PATH"] = original_path os.environ["PATH"] = original_path
self.addTearDownHook(cleanup) self.addTearDownHook(cleanup)
state = self._run_and_get_state() state = self._run_and_get_state()
self.assertEqual(state["program"], self.getBuildArtifact("a.out")) self.assertEqual(state["program"], self.getTestExecutable())
self.assertEqual(state["args"], self.assertEqual(state["args"],
["dump:" + self.getBuildArtifact("state.log")]) ["dump:" + self.getBuildArtifact("state.log")])
def test_bad_emulator_path(self): def test_bad_emulator_path(self):
self.set_emulator_setting("emulator-path", self.set_emulator_setting("emulator-path",
self.getBuildArtifact("nonexistent.file")) self.getBuildArtifact("nonexistent.file"))
target = self._create_target() target = self._create_target()
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines def test_env_vars(self):
self.assertEqual(state["environ"]["QEMU_UNSET_ENV"], self.assertEqual(state["environ"]["QEMU_UNSET_ENV"],
"%s,%s,QEMU_SET_ENV,QEMU_UNSET_ENV" % (var(3), var(4))) "%s,%s,QEMU_SET_ENV,QEMU_UNSET_ENV" % (var(3), var(4)))
def test_arg0(self): def test_arg0(self):
target = self._create_target() target = self._create_target()
self.runCmd("settings set target.arg0 ARG0") self.runCmd("settings set target.arg0 ARG0")
state = self._run_and_get_state(target) state = self._run_and_get_state(target)
self.assertEqual(state["program"], self.getBuildArtifact("a.out")) self.assertEqual(state["program"], self.getTestExecutable())
self.assertEqual(state["0"], "ARG0") self.assertEqual(state["0"], "ARG0")
def test_sysroot(self): def test_sysroot(self):
sysroot = self.getBuildArtifact("sysroot") sysroot = self.getBuildArtifact("sysroot")
self.runCmd("platform select qemu-user --sysroot %s" % sysroot) self.runCmd("platform select qemu-user --sysroot %s" % sysroot)
state = self._run_and_get_state() state = self._run_and_get_state()
self.assertEqual(state["environ"]["QEMU_LD_PREFIX"], sysroot) self.assertEqual(state["environ"]["QEMU_LD_PREFIX"], sysroot)
self.assertIn("QEMU_LD_PREFIX", self.assertIn("QEMU_LD_PREFIX",
state["environ"]["QEMU_UNSET_ENV"].split(",")) state["environ"]["QEMU_UNSET_ENV"].split(","))

lldb/test/API/repl/clang/TestClangREPL.py

Show All 23 Linesclass TestCase(PExpectTest):
@skipIfAsan @skipIfAsan
@skipIf(oslist=["linux"], archs=["arm", "aarch64"]) # Randomly fails on buildbot @skipIf(oslist=["linux"], archs=["arm", "aarch64"]) # Randomly fails on buildbot
@skipIfEditlineSupportMissing @skipIfEditlineSupportMissing
def test_basic_completion(self): def test_basic_completion(self):
"""Test that we can complete a simple multiline expression""" """Test that we can complete a simple multiline expression"""
self.build() self.build()
self.current_repl_line_number = 1 self.current_repl_line_number = 1
self.launch(executable=self.getBuildArtifact("a.out"), dimensions=(100,500)) self.launch(executable=self.getTestExecutable(), dimensions=(100,500))
# Try launching the REPL before we have a running target. # Try launching the REPL before we have a running target.
self.expect("expression --repl -l c --", substrs=["REPL requires a running target process."]) self.expect("expression --repl -l c --", substrs=["REPL requires a running target process."])
self.expect("b main", substrs=["Breakpoint 1", "address ="]) self.expect("b main", substrs=["Breakpoint 1", "address ="])
self.expect("run", substrs=["stop reason = breakpoint 1"]) self.expect("run", substrs=["stop reason = breakpoint 1"])
# Start the REPL. # Start the REPL.
self.child.send("expression --repl -l c --\n") self.child.send("expression --repl -l c --\n")
Show All 15 Lines

lldb/test/API/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, needle_regex, highlight_source=False): def do_display_source_python_api(self, use_color, needle_regex, highlight_source=False):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 70 Lines • ▼ Show 20 Lines def test_display_source_python_ansi_terminal_syntax_highlighting(self):
# Test that we didn't color unrelated identifiers. # Test that we didn't color unrelated identifiers.
self.do_display_source_python_api(use_color, r" main\(", syntax_highlighting) self.do_display_source_python_api(use_color, r" main\(", syntax_highlighting)
self.do_display_source_python_api(use_color, r"\);", syntax_highlighting) self.do_display_source_python_api(use_color, r"\);", syntax_highlighting)
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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.
hidden = self.getBuildArtifact("hidden") hidden = self.getBuildArtifact("hidden")
lldbutil.mkdir_p(hidden) lldbutil.mkdir_p(hidden)
main_c_hidden = os.path.join(hidden, "main-copy.c") main_c_hidden = os.path.join(hidden, "main-copy.c")
os.rename(self.file, main_c_hidden) os.rename(self.file, main_c_hidden)
Show All 17 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'])
@skipIf(oslist=["windows"], bugnumber="llvm.org/pr44431") @skipIf(oslist=["windows"], bugnumber="llvm.org/pr44431")
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 = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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-copy.c", self.line, num_expected_locations=1, loc_exact=True) self, "main-copy.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 62 Lines • ▼ Show 20 Lines def test_set_breakpoint_with_absolute_path(self):
hidden = self.getBuildArtifact("hidden") hidden = self.getBuildArtifact("hidden")
lldbutil.mkdir_p(hidden) lldbutil.mkdir_p(hidden)
# 'make -C' has resolved current directory to its realpath form. # 'make -C' has resolved current directory to its realpath form.
builddir_real = os.path.realpath(self.getBuildDir()) builddir_real = os.path.realpath(self.getBuildDir())
hidden_real = os.path.realpath(hidden) hidden_real = os.path.realpath(hidden)
self.runCmd("settings set target.source-map %s %s" % self.runCmd("settings set target.source-map %s %s" %
(builddir_real, hidden_real)) (builddir_real, hidden_real))
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
main = os.path.join(builddir_real, "hidden", "main-copy.c") main = os.path.join(builddir_real, "hidden", "main-copy.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)
Show All 21 Lines

lldb/test/API/symbol_ondemand/breakpoint_language/TestBreakpointLanguageOnDemand.py

Show All 25 Lines 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()
# Load symbols on-demand # Load symbols on-demand
self.runCmd("settings set symbols.load-on-demand true") self.runCmd("settings set symbols.load-on-demand true")
# Create a target by the debugger. # Create a target by the debugger.
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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 29 Lines 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()
# Load symbols on-demand # Load symbols on-demand
self.runCmd("settings set symbols.load-on-demand true") self.runCmd("settings set symbols.load-on-demand true")
# Create a target by the debugger. # Create a target by the debugger.
exe = self.getBuildArtifact("a.out") exe = self.getTestExecutable()
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/test/API/symbol_ondemand/breakpoint_source_regex/TestSourceTextRegexBreakpoint.py

Show All 14 Linesclass TestSourceTextRegexBreakpoint(TestBase):
@skipIfWindows @skipIfWindows
def test_with_run_command(self): def test_with_run_command(self):
self.build() self.build()
# Load symbols on-demand # Load symbols on-demand
self.runCmd("settings set symbols.load-on-demand true") self.runCmd("settings set symbols.load-on-demand true")
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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'])
frame = self.frame() frame = self.frame()
self.assertTrue(frame.IsValid()) self.assertTrue(frame.IsValid())
self.assertEqual(frame.GetLineEntry().GetFileSpec().GetFilename(), "main.cpp") self.assertEqual(frame.GetLineEntry().GetFileSpec().GetFilename(), "main.cpp")
self.assertEqual(frame.GetLineEntry().GetLine(), 4) self.assertEqual(frame.GetLineEntry().GetLine(), 4)

lldb/test/API/symbol_ondemand/shared_library/TestSharedLibOnDemand.py

Show All 20 Lines def setUp(self):
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)
self.runCmd("settings set symbols.load-on-demand true") self.runCmd("settings set symbols.load-on-demand true")
# Create a target by the debugger. # Create a target by the debugger.
self.target = self.dbg.CreateTarget(self.getBuildArtifact("a.out")) self.target = self.dbg.CreateTarget(self.getTestExecutable())
self.assertTrue(self.target, VALID_TARGET) self.assertTrue(self.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
self.environment = self.registerSharedLibrariesWithTarget( self.environment = self.registerSharedLibrariesWithTarget(
self.target, self.shlib_names self.target, self.shlib_names
) )
▲ Show 20 Lines • Show All 123 Lines • Show Last 20 Lines

lldb/test/API/tools/lldb-server/TestLldbGdbServer.py

Show First 20 Lines • Show All 1,207 Lines • ▼ Show 20 Lines def test_P_and_p_thread_suffix_work(self):
# Make sure we read back what we wrote. # Make sure we read back what we wrote.
self.assertEqual(read_value, expected_reg_values[thread_index]) self.assertEqual(read_value, expected_reg_values[thread_index])
thread_index += 1 thread_index += 1
@skipIfWindows # No pty support to test any inferior output @skipIfWindows # No pty support to test any inferior output
@add_test_categories(["llgs"]) @add_test_categories(["llgs"])
def test_launch_via_A(self): def test_launch_via_A(self):
self.build() self.build()
exe_path = self.getBuildArtifact("a.out") exe_path = self.getTestExecutable()
args = [exe_path, "stderr:arg1", "stderr:arg2", "stderr:arg3"] args = [exe_path, "stderr:arg1", "stderr:arg2", "stderr:arg3"]
hex_args = [binascii.b2a_hex(x.encode()).decode() for x in args] hex_args = [binascii.b2a_hex(x.encode()).decode() for x in args]
server = self.connect_to_debug_monitor() server = self.connect_to_debug_monitor()
self.assertIsNotNone(server) self.assertIsNotNone(server)
self.do_handshake() self.do_handshake()
# NB: strictly speaking we should use %x here but this packet # NB: strictly speaking we should use %x here but this packet
# is deprecated, so no point in changing lldb-server's expectations # is deprecated, so no point in changing lldb-server's expectations
self.test_sequence.add_log_lines( self.test_sequence.add_log_lines(
["read packet: $A %d,0,%s,%d,1,%s,%d,2,%s,%d,3,%s#00" % ["read packet: $A %d,0,%s,%d,1,%s,%d,2,%s,%d,3,%s#00" %
tuple(itertools.chain.from_iterable( tuple(itertools.chain.from_iterable(
[(len(x), x) for x in hex_args])), [(len(x), x) for x in hex_args])),
"send packet: $OK#00", "send packet: $OK#00",
"read packet: $c#00", "read packet: $c#00",
"send packet: $W00#00"], "send packet: $W00#00"],
True) True)
context = self.expect_gdbremote_sequence() context = self.expect_gdbremote_sequence()
self.assertEqual(context["O_content"], self.assertEqual(context["O_content"],
b'arg1\r\narg2\r\narg3\r\n') b'arg1\r\narg2\r\narg3\r\n')
@skipIfWindows # No pty support to test any inferior output @skipIfWindows # No pty support to test any inferior output
@add_test_categories(["llgs"]) @add_test_categories(["llgs"])
def test_launch_via_vRun(self): def test_launch_via_vRun(self):
self.build() self.build()
exe_path = self.getBuildArtifact("a.out") exe_path = self.getTestExecutable()
args = [exe_path, "stderr:arg1", "stderr:arg2", "stderr:arg3"] args = [exe_path, "stderr:arg1", "stderr:arg2", "stderr:arg3"]
hex_args = [binascii.b2a_hex(x.encode()).decode() for x in args] hex_args = [binascii.b2a_hex(x.encode()).decode() for x in args]
server = self.connect_to_debug_monitor() server = self.connect_to_debug_monitor()
self.assertIsNotNone(server) self.assertIsNotNone(server)
self.do_handshake() self.do_handshake()
self.test_sequence.add_log_lines( self.test_sequence.add_log_lines(
["read packet: $vRun;%s;%s;%s;%s#00" % tuple(hex_args), ["read packet: $vRun;%s;%s;%s;%s#00" % tuple(hex_args),
{"direction": "send", {"direction": "send",
"regex": r"^\$T([0-9a-fA-F]+)"}, "regex": r"^\$T([0-9a-fA-F]+)"},
"read packet: $c#00", "read packet: $c#00",
"send packet: $W00#00"], "send packet: $W00#00"],
True) True)
context = self.expect_gdbremote_sequence() context = self.expect_gdbremote_sequence()
self.assertEqual(context["O_content"], self.assertEqual(context["O_content"],
b'arg1\r\narg2\r\narg3\r\n') b'arg1\r\narg2\r\narg3\r\n')
@add_test_categories(["llgs"]) @add_test_categories(["llgs"])
def test_launch_via_vRun_no_args(self): def test_launch_via_vRun_no_args(self):
self.build() self.build()
exe_path = self.getBuildArtifact("a.out") exe_path = self.getTestExecutable()
hex_path = binascii.b2a_hex(exe_path.encode()).decode() hex_path = binascii.b2a_hex(exe_path.encode()).decode()
server = self.connect_to_debug_monitor() server = self.connect_to_debug_monitor()
self.assertIsNotNone(server) self.assertIsNotNone(server)
self.do_handshake() self.do_handshake()
self.test_sequence.add_log_lines( self.test_sequence.add_log_lines(
["read packet: $vRun;%s#00" % (hex_path,), ["read packet: $vRun;%s#00" % (hex_path,),
{"direction": "send", {"direction": "send",
"regex": r"^\$T([0-9a-fA-F]+)"}, "regex": r"^\$T([0-9a-fA-F]+)"},
"read packet: $c#00", "read packet: $c#00",
"send packet: $W00#00"], "send packet: $W00#00"],
True) True)
self.expect_gdbremote_sequence() self.expect_gdbremote_sequence()
@skipIfWindows # No pty support to test any inferior output @skipIfWindows # No pty support to test any inferior output
@add_test_categories(["llgs"]) @add_test_categories(["llgs"])
def test_QEnvironment(self): def test_QEnvironment(self):
self.build() self.build()
exe_path = self.getBuildArtifact("a.out") exe_path = self.getTestExecutable()
env = {"FOO": "test", "BAR": "a=z"} env = {"FOO": "test", "BAR": "a=z"}
args = [exe_path, "print-env:FOO", "print-env:BAR"] args = [exe_path, "print-env:FOO", "print-env:BAR"]
hex_args = [binascii.b2a_hex(x.encode()).decode() for x in args] hex_args = [binascii.b2a_hex(x.encode()).decode() for x in args]
server = self.connect_to_debug_monitor() server = self.connect_to_debug_monitor()
self.assertIsNotNone(server) self.assertIsNotNone(server)
self.do_handshake() self.do_handshake()
Show All 11 Lines def test_QEnvironment(self):
True) True)
context = self.expect_gdbremote_sequence() context = self.expect_gdbremote_sequence()
self.assertEqual(context["O_content"], b"test\r\na=z\r\n") self.assertEqual(context["O_content"], b"test\r\na=z\r\n")
@skipIfWindows # No pty support to test any inferior output @skipIfWindows # No pty support to test any inferior output
@add_test_categories(["llgs"]) @add_test_categories(["llgs"])
def test_QEnvironmentHexEncoded(self): def test_QEnvironmentHexEncoded(self):
self.build() self.build()
exe_path = self.getBuildArtifact("a.out") exe_path = self.getTestExecutable()
env = {"FOO": "test", "BAR": "a=z", "BAZ": "a*}#z"} env = {"FOO": "test", "BAR": "a=z", "BAZ": "a*}#z"}
args = [exe_path, "print-env:FOO", "print-env:BAR", "print-env:BAZ"] args = [exe_path, "print-env:FOO", "print-env:BAR", "print-env:BAZ"]
hex_args = [binascii.b2a_hex(x.encode()).decode() for x in args] hex_args = [binascii.b2a_hex(x.encode()).decode() for x in args]
server = self.connect_to_debug_monitor() server = self.connect_to_debug_monitor()
self.assertIsNotNone(server) self.assertIsNotNone(server)
self.do_handshake() self.do_handshake()
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

lldb/test/API/tools/lldb-vscode/attach/TestVSCode_attach.py

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Linesclass TestVSCode_attach(lldbvscode_testcase.VSCodeTestCaseBase):
@skipIfWindows @skipIfWindows
@skipIfNetBSD # Hangs on NetBSD as well @skipIfNetBSD # Hangs on NetBSD as well
@skipIfRemote @skipIfRemote
def test_by_pid(self): def test_by_pid(self):
''' '''
Tests attaching to a process by process ID. Tests attaching to a process by process ID.
''' '''
self.build_and_create_debug_adaptor() self.build_and_create_debug_adaptor()
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
self.process = subprocess.Popen([program], self.process = subprocess.Popen([program],
stdin=subprocess.PIPE, stdin=subprocess.PIPE,
stdout=subprocess.PIPE, stdout=subprocess.PIPE,
stderr=subprocess.PIPE) stderr=subprocess.PIPE)
self.attach(pid=self.process.pid) self.attach(pid=self.process.pid)
self.set_and_hit_breakpoint(continueToExit=True) self.set_and_hit_breakpoint(continueToExit=True)
@skipIfWindows @skipIfWindows
@skipIfNetBSD # Hangs on NetBSD as well @skipIfNetBSD # Hangs on NetBSD as well
@skipIfRemote @skipIfRemote
def test_by_name(self): def test_by_name(self):
''' '''
Tests attaching to a process by process name. Tests attaching to a process by process name.
''' '''
self.build_and_create_debug_adaptor() self.build_and_create_debug_adaptor()
orig_program = self.getBuildArtifact("a.out") orig_program = self.getTestExecutable()
# Since we are going to attach by process name, we need a unique # Since we are going to attach by process name, we need a unique
# process name that has minimal chance to match a process that is # process name that has minimal chance to match a process that is
# already running. To do this we use tempfile.mktemp() to give us a # already running. To do this we use tempfile.mktemp() to give us a
# full path to a location where we can copy our executable. We then # full path to a location where we can copy our executable. We then
# run this copy to ensure we don't get the error "more that one # run this copy to ensure we don't get the error "more that one
# process matches 'a.out'". # process matches 'a.out'".
program = tempfile.mktemp() program = tempfile.mktemp()
shutil.copyfile(orig_program, program) shutil.copyfile(orig_program, program)
Show All 22 Linesclass TestVSCode_attach(lldbvscode_testcase.VSCodeTestCaseBase):
@skipIfNetBSD # Hangs on NetBSD as well @skipIfNetBSD # Hangs on NetBSD as well
def test_by_name_waitFor(self): def test_by_name_waitFor(self):
''' '''
Tests attaching to a process by process name and waiting for the Tests attaching to a process by process name and waiting for the
next instance of a process to be launched, ingoring all current next instance of a process to be launched, ingoring all current
ones. ones.
''' '''
self.build_and_create_debug_adaptor() self.build_and_create_debug_adaptor()
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
self.spawn_thread = threading.Thread(target=spawn_and_wait, self.spawn_thread = threading.Thread(target=spawn_and_wait,
args=(program, 1.0,)) args=(program, 1.0,))
self.spawn_thread.start() self.spawn_thread.start()
self.attach(program=program, waitFor=True) self.attach(program=program, waitFor=True)
self.set_and_hit_breakpoint(continueToExit=True) self.set_and_hit_breakpoint(continueToExit=True)
@skipIfWindows @skipIfWindows
@skipIfDarwin @skipIfDarwin
Show All 16 Lines def test_commands(self):
"attachCommands" are a list of LLDB commands that get executed and "attachCommands" are a list of LLDB commands that get executed and
must have a valid process in the selected target in LLDB after must have a valid process in the selected target in LLDB after
they are done executing. This allows custom commands to create any they are done executing. This allows custom commands to create any
kind of debug session. kind of debug session.
"terminateCommands" are a list of LLDB commands that get executed when "terminateCommands" are a list of LLDB commands that get executed when
the debugger session terminates. the debugger session terminates.
''' '''
self.build_and_create_debug_adaptor() self.build_and_create_debug_adaptor()
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
# Here we just create a target and launch the process as a way to test # Here we just create a target and launch the process as a way to test
# if we are able to use attach commands to create any kind of a target # if we are able to use attach commands to create any kind of a target
# and use it for debugging # and use it for debugging
attachCommands = [ attachCommands = [
'target create -d "%s"' % (program), 'target create -d "%s"' % (program),
'process launch --stop-at-entry' 'process launch --stop-at-entry'
] ]
initCommands = ['target list', 'platform list'] initCommands = ['target list', 'platform list']
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Linesclass TestVSCode_attach(lldbvscode_testcase.VSCodeTestCaseBase):
@skipIfNetBSD # Hangs on NetBSD as well @skipIfNetBSD # Hangs on NetBSD as well
@skipIf(archs=["arm", "aarch64"]) # Example of a flaky run http://lab.llvm.org:8011/builders/lldb-aarch64-ubuntu/builds/5517/steps/test/logs/stdio @skipIf(archs=["arm", "aarch64"]) # Example of a flaky run http://lab.llvm.org:8011/builders/lldb-aarch64-ubuntu/builds/5517/steps/test/logs/stdio
def test_terminate_commands(self): def test_terminate_commands(self):
''' '''
Tests that the "terminateCommands", that can be passed during Tests that the "terminateCommands", that can be passed during
attach, are run when the debugger is disconnected. attach, are run when the debugger is disconnected.
''' '''
self.build_and_create_debug_adaptor() self.build_and_create_debug_adaptor()
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
# Here we just create a target and launch the process as a way to test # Here we just create a target and launch the process as a way to test
# if we are able to use attach commands to create any kind of a target # if we are able to use attach commands to create any kind of a target
# and use it for debugging # and use it for debugging
attachCommands = [ attachCommands = [
'target create -d "%s"' % (program), 'target create -d "%s"' % (program),
'process launch --stop-at-entry' 'process launch --stop-at-entry'
] ]
terminateCommands = ['expr 4+2'] terminateCommands = ['expr 4+2']
Show All 10 Lines

lldb/test/API/tools/lldb-vscode/breakpoint-events/TestVSCode_breakpointEvents.py

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines def test_breakpoint_events(self):
foo_source_path = os.path.join(os.getcwd(), foo_source_basename) foo_source_path = os.path.join(os.getcwd(), foo_source_basename)
main_bp_line = line_number('main.cpp', 'main breakpoint 1') main_bp_line = line_number('main.cpp', 'main breakpoint 1')
foo_bp1_line = line_number('foo.cpp', 'foo breakpoint 1') foo_bp1_line = line_number('foo.cpp', 'foo breakpoint 1')
foo_bp2_line = line_number('foo.cpp', 'foo breakpoint 2') foo_bp2_line = line_number('foo.cpp', 'foo breakpoint 2')
# Visual Studio Code Debug Adaptors have no way to specify the file # Visual Studio Code Debug Adaptors have no way to specify the file
# without launching or attaching to a process, so we must start a # without launching or attaching to a process, so we must start a
# process in order to be able to set breakpoints. # process in order to be able to set breakpoints.
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
# Set a breakpoint after creating the target by running a command line # Set a breakpoint after creating the target by running a command line
# command. It will eventually resolve and cause a breakpoint changed # command. It will eventually resolve and cause a breakpoint changed
# event to be sent to lldb-vscode. We want to make sure we don't send a # event to be sent to lldb-vscode. We want to make sure we don't send a
# breakpoint any breakpoints that were set from the command line. # breakpoint any breakpoints that were set from the command line.
# Breakpoints that are set via the VS code DAP packets will be # Breakpoints that are set via the VS code DAP packets will be
# registered and marked with a special keyword to ensure we deliver # registered and marked with a special keyword to ensure we deliver
# breakpoint events for these breakpoints but not for ones that are not # breakpoint events for these breakpoints but not for ones that are not
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

lldb/test/API/tools/lldb-vscode/breakpoint/TestVSCode_setBreakpoints.py

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines def test_source_map(self):
os.mkdir(new_main_folder) os.mkdir(new_main_folder)
os.mkdir(new_other_folder) os.mkdir(new_other_folder)
shutil.move(self.main_path, new_main_path) shutil.move(self.main_path, new_main_path)
shutil.move(other_path, new_other_path) shutil.move(other_path, new_other_path)
main_line = line_number('main.cpp', 'break 12') main_line = line_number('main.cpp', 'break 12')
other_line = line_number('other.c', 'break other') other_line = line_number('other.c', 'break other')
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
source_map = [ source_map = [
[source_folder, new_main_folder], [source_folder, new_main_folder],
[source_folder, new_other_folder], [source_folder, new_other_folder],
] ]
self.launch(program, sourceMap=source_map) self.launch(program, sourceMap=source_map)
# breakpoint in main.cpp # breakpoint in main.cpp
response = self.vscode.request_setBreakpoints(new_main_path, [main_line]) response = self.vscode.request_setBreakpoints(new_main_path, [main_line])
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines def test_set_and_clear(self):
first_line = line_number('main.cpp', 'break 12') first_line = line_number('main.cpp', 'break 12')
second_line = line_number('main.cpp', 'break 13') second_line = line_number('main.cpp', 'break 13')
third_line = line_number('main.cpp', 'break 14') third_line = line_number('main.cpp', 'break 14')
lines = [first_line, third_line, second_line] lines = [first_line, third_line, second_line]
# Visual Studio Code Debug Adaptors have no way to specify the file # Visual Studio Code Debug Adaptors have no way to specify the file
# without launching or attaching to a process, so we must start a # without launching or attaching to a process, so we must start a
# process in order to be able to set breakpoints. # process in order to be able to set breakpoints.
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
self.build_and_launch(program) self.build_and_launch(program)
# Set 3 breakpoints and verify that they got set correctly # Set 3 breakpoints and verify that they got set correctly
response = self.vscode.request_setBreakpoints(self.main_path, lines) response = self.vscode.request_setBreakpoints(self.main_path, lines)
line_to_id = {} line_to_id = {}
if response: if response:
breakpoints = response['body']['breakpoints'] breakpoints = response['body']['breakpoints']
self.assertEquals(len(breakpoints), len(lines), self.assertEquals(len(breakpoints), len(lines),
▲ Show 20 Lines • Show All 104 Lines • ▼ Show 20 Lines def test_clear_breakpoints_unset_breakpoints(self):
breakpoints by omitting the breakpoints array instead of sending an breakpoints by omitting the breakpoints array instead of sending an
empty one.''' empty one.'''
lines = [line_number('main.cpp', 'break 12'), lines = [line_number('main.cpp', 'break 12'),
line_number('main.cpp', 'break 13')] line_number('main.cpp', 'break 13')]
# Visual Studio Code Debug Adaptors have no way to specify the file # Visual Studio Code Debug Adaptors have no way to specify the file
# without launching or attaching to a process, so we must start a # without launching or attaching to a process, so we must start a
# process in order to be able to set breakpoints. # process in order to be able to set breakpoints.
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
self.build_and_launch(program) self.build_and_launch(program)
# Set one breakpoint and verify that it got set correctly. # Set one breakpoint and verify that it got set correctly.
response = self.vscode.request_setBreakpoints(self.main_path, lines) response = self.vscode.request_setBreakpoints(self.main_path, lines)
line_to_id = {} line_to_id = {}
breakpoints = response['body']['breakpoints'] breakpoints = response['body']['breakpoints']
self.assertEquals(len(breakpoints), len(lines), self.assertEquals(len(breakpoints), len(lines),
"expect %u source breakpoints" % (len(lines))) "expect %u source breakpoints" % (len(lines)))
Show All 20 Linesclass TestVSCode_setBreakpoints(lldbvscode_testcase.VSCodeTestCaseBase):
@skipIfWindows @skipIfWindows
@skipIfRemote @skipIfRemote
def test_functionality(self): def test_functionality(self):
'''Tests hitting breakpoints and the functionality of a single '''Tests hitting breakpoints and the functionality of a single
breakpoint, like 'conditions' and 'hitCondition' settings.''' breakpoint, like 'conditions' and 'hitCondition' settings.'''
loop_line = line_number('main.cpp', '// break loop') loop_line = line_number('main.cpp', '// break loop')
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
self.build_and_launch(program) self.build_and_launch(program)
# Set a breakpoint at the loop line with no condition and no # Set a breakpoint at the loop line with no condition and no
# hitCondition # hitCondition
breakpoint_ids = self.set_source_breakpoints(self.main_path, [loop_line]) breakpoint_ids = self.set_source_breakpoints(self.main_path, [loop_line])
self.assertEquals(len(breakpoint_ids), 1, "expect one breakpoint") self.assertEquals(len(breakpoint_ids), 1, "expect one breakpoint")
self.vscode.request_continue() self.vscode.request_continue()
# Verify we hit the breakpoint we just set # Verify we hit the breakpoint we just set
Show All 39 Lines

lldb/test/API/tools/lldb-vscode/breakpoint/TestVSCode_setExceptionBreakpoints.py

Show All 29 Lines def test_functionality(self):
removed. This exception tests this setting and clearing and makes removed. This exception tests this setting and clearing and makes
sure things happen correctly. It doesn't test hitting breakpoints sure things happen correctly. It doesn't test hitting breakpoints
and the functionality of each breakpoint, like 'conditions' and and the functionality of each breakpoint, like 'conditions' and
x'hitCondition' settings. x'hitCondition' settings.
''' '''
# Visual Studio Code Debug Adaptors have no way to specify the file # Visual Studio Code Debug Adaptors have no way to specify the file
# without launching or attaching to a process, so we must start a # without launching or attaching to a process, so we must start a
# process in order to be able to set breakpoints. # process in order to be able to set breakpoints.
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
self.build_and_launch(program) self.build_and_launch(program)
filters = ['cpp_throw', 'cpp_catch'] filters = ['cpp_throw', 'cpp_catch']
response = self.vscode.request_setExceptionBreakpoints(filters) response = self.vscode.request_setExceptionBreakpoints(filters)
if response: if response:
self.assertTrue(response['success']) self.assertTrue(response['success'])
self.continue_to_exception_breakpoint('C++ Throw') self.continue_to_exception_breakpoint('C++ Throw')
self.continue_to_exception_breakpoint('C++ Catch') self.continue_to_exception_breakpoint('C++ Catch')

lldb/test/API/tools/lldb-vscode/breakpoint/TestVSCode_setFunctionBreakpoints.py

Show All 28 Lines def test_set_and_clear(self):
and are not in the current request must be removed. This function and are not in the current request must be removed. This function
tests this setting and clearing and makes sure things happen tests this setting and clearing and makes sure things happen
correctly. It doesn't test hitting breakpoints and the functionality correctly. It doesn't test hitting breakpoints and the functionality
of each breakpoint, like 'conditions' and 'hitCondition' settings. of each breakpoint, like 'conditions' and 'hitCondition' settings.
''' '''
# Visual Studio Code Debug Adaptors have no way to specify the file # Visual Studio Code Debug Adaptors have no way to specify the file
# without launching or attaching to a process, so we must start a # without launching or attaching to a process, so we must start a
# process in order to be able to set breakpoints. # process in order to be able to set breakpoints.
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
self.build_and_launch(program) self.build_and_launch(program)
bp_id_12 = None bp_id_12 = None
functions = ['twelve'] functions = ['twelve']
# Set a function breakpoint at 'twelve' # Set a function breakpoint at 'twelve'
response = self.vscode.request_setFunctionBreakpoints(functions) response = self.vscode.request_setFunctionBreakpoints(functions)
if response: if response:
breakpoints = response['body']['breakpoints'] breakpoints = response['body']['breakpoints']
self.assertEquals(len(breakpoints), len(functions), self.assertEquals(len(breakpoints), len(functions),
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines def test_set_and_clear(self):
"expect %u source breakpoints" % (len(functions))) "expect %u source breakpoints" % (len(functions)))
@skipIfWindows @skipIfWindows
@skipIfRemote @skipIfRemote
def test_functionality(self): def test_functionality(self):
'''Tests hitting breakpoints and the functionality of a single '''Tests hitting breakpoints and the functionality of a single
breakpoint, like 'conditions' and 'hitCondition' settings.''' breakpoint, like 'conditions' and 'hitCondition' settings.'''
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
self.build_and_launch(program) self.build_and_launch(program)
# Set a breakpoint on "twelve" with no condition and no hitCondition # Set a breakpoint on "twelve" with no condition and no hitCondition
functions = ['twelve'] functions = ['twelve']
breakpoint_ids = self.set_function_breakpoints(functions) breakpoint_ids = self.set_function_breakpoints(functions)
self.assertEquals(len(breakpoint_ids), len(functions), self.assertEquals(len(breakpoint_ids), len(functions),
"expect one breakpoint") "expect one breakpoint")
Show All 37 Lines

lldb/test/API/tools/lldb-vscode/completions/TestVSCode_completions.py

Show All 22 Lines def verify_completions(self, actual_list, expected_list, not_expected_list=[]):
self.assertNotIn(not_expected_item, actual_list) self.assertNotIn(not_expected_item, actual_list)
@skipIfWindows @skipIfWindows
@skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
def test_completions(self): def test_completions(self):
""" """
Tests the completion request at different breakpoints Tests the completion request at different breakpoints
""" """
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
self.build_and_launch(program) self.build_and_launch(program)
source = "main.cpp" source = "main.cpp"
breakpoint1_line = line_number(source, "// breakpoint 1") breakpoint1_line = line_number(source, "// breakpoint 1")
breakpoint2_line = line_number(source, "// breakpoint 2") breakpoint2_line = line_number(source, "// breakpoint 2")
breakpoint_ids = self.set_source_breakpoints( breakpoint_ids = self.set_source_breakpoints(
source, [breakpoint1_line, breakpoint2_line] source, [breakpoint1_line, breakpoint2_line]
) )
self.continue_to_next_stop() self.continue_to_next_stop()
▲ Show 20 Lines • Show All 149 Lines • Show Last 20 Lines

lldb/test/API/tools/lldb-vscode/console/TestVSCode_console.py

Show All 34 Lines def test_scopes_variables_setVariable_evaluate(self):
for the latest "scopes" request that it receives. for the latest "scopes" request that it receives.
The LLDB command interpreter needs to have the right thread and The LLDB command interpreter needs to have the right thread and
frame selected so that commands executed in the debug console act frame selected so that commands executed in the debug console act
on the right scope. This applies both to the expressions that are on the right scope. This applies both to the expressions that are
evaluated and the lldb commands that start with the backtick evaluated and the lldb commands that start with the backtick
character. character.
''' '''
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
self.build_and_launch(program) self.build_and_launch(program)
source = 'main.cpp' source = 'main.cpp'
breakpoint1_line = line_number(source, '// breakpoint 1') breakpoint1_line = line_number(source, '// breakpoint 1')
lines = [breakpoint1_line] lines = [breakpoint1_line]
# Set breakpoint in the thread function so we can step the threads # Set breakpoint in the thread function so we can step the threads
breakpoint_ids = self.set_source_breakpoints(source, lines) breakpoint_ids = self.set_source_breakpoints(source, lines)
self.assertEqual(len(breakpoint_ids), len(lines), self.assertEqual(len(breakpoint_ids), len(lines),
"expect correct number of breakpoints") "expect correct number of breakpoints")
Show All 19 Lines

lldb/test/API/tools/lldb-vscode/console/TestVSCode_redirection_to_console.py

Show All 14 Linesclass TestVSCode_redirection_to_console(lldbvscode_testcase.VSCodeTestCaseBase):
@skipIfRemote @skipIfRemote
def test(self): def test(self):
""" """
Without proper stderr and stdout redirection, the following code would throw an Without proper stderr and stdout redirection, the following code would throw an
exception, like the following: exception, like the following:
Exception: unexpected malformed message from lldb-vscode Exception: unexpected malformed message from lldb-vscode
""" """
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
self.build_and_launch( self.build_and_launch(
program, program,
lldbVSCodeEnv={"LLDB_VSCODE_TEST_STDOUT_STDERR_REDIRECTION": ""}) lldbVSCodeEnv={"LLDB_VSCODE_TEST_STDOUT_STDERR_REDIRECTION": ""})
source = 'main.cpp' source = 'main.cpp'
breakpoint1_line = line_number(source, '// breakpoint 1') breakpoint1_line = line_number(source, '// breakpoint 1')
breakpoint_ids = self.set_source_breakpoints(source, [breakpoint1_line]) breakpoint_ids = self.set_source_breakpoints(source, [breakpoint1_line])
self.assertEqual(len(breakpoint_ids), 1, self.assertEqual(len(breakpoint_ids), 1,
"expect correct number of breakpoints") "expect correct number of breakpoints")
self.continue_to_breakpoints(breakpoint_ids) self.continue_to_breakpoints(breakpoint_ids)
self.assertIn('argc', json.dumps(self.vscode.get_local_variables(frameIndex=1))) self.assertIn('argc', json.dumps(self.vscode.get_local_variables(frameIndex=1)))

lldb/test/API/tools/lldb-vscode/correct-thread/TestVSCode_correct_thread.py

Show All 19 Linesclass TestVSCode_correct_thread(lldbvscode_testcase.VSCodeTestCaseBase):
@skipIfRemote @skipIfRemote
def test_correct_thread(self): def test_correct_thread(self):
''' '''
Tests that the correct thread is selected if we continue from Tests that the correct thread is selected if we continue from
a thread that goes away and hit a breakpoint in another thread. a thread that goes away and hit a breakpoint in another thread.
In this case, the selected thread should be the thread that In this case, the selected thread should be the thread that
just hit the breakpoint, and not the first thread in the list. just hit the breakpoint, and not the first thread in the list.
''' '''
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
self.build_and_launch(program) self.build_and_launch(program)
source = 'main.c' source = 'main.c'
breakpoint_line = line_number(source, '// break here') breakpoint_line = line_number(source, '// break here')
lines = [breakpoint_line] lines = [breakpoint_line]
# Set breakpoint in the thread function # Set breakpoint in the thread function
breakpoint_ids = self.set_source_breakpoints(source, lines) breakpoint_ids = self.set_source_breakpoints(source, lines)
self.assertEqual(len(breakpoint_ids), len(lines), self.assertEqual(len(breakpoint_ids), len(lines),
"expect correct number of breakpoints") "expect correct number of breakpoints")
Show All 11 Lines

lldb/test/API/tools/lldb-vscode/disconnect/TestVSCode_disconnect.py

Show All 29 Linesclass TestVSCode_launch(lldbvscode_testcase.VSCodeTestCaseBase):
@skipIfWindows @skipIfWindows
@skipIfRemote @skipIfRemote
def test_launch(self): def test_launch(self):
""" """
This test launches a process that would creates a file, but we disconnect This test launches a process that would creates a file, but we disconnect
before the file is created, which terminates the process and thus the file is not before the file is created, which terminates the process and thus the file is not
created. created.
""" """
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
self.build_and_launch(program, disconnectAutomatically=False) self.build_and_launch(program, disconnectAutomatically=False)
# We set a breakpoint right before the side effect file is created # We set a breakpoint right before the side effect file is created
self.set_source_breakpoints(self.source, [line_number(self.source, '// breakpoint')]) self.set_source_breakpoints(self.source, [line_number(self.source, '// breakpoint')])
self.continue_to_next_stop() self.continue_to_next_stop()
self.vscode.request_disconnect() self.vscode.request_disconnect()
# verify we didn't produce the side effect file # verify we didn't produce the side effect file
time.sleep(1) time.sleep(1)
self.assertFalse(os.path.exists(program + ".side_effect")) self.assertFalse(os.path.exists(program + ".side_effect"))
@skipIfDarwin @skipIfDarwin
@skipIfWindows @skipIfWindows
@skipIfRemote @skipIfRemote
@expectedFailureNetBSD @expectedFailureNetBSD
def test_attach(self): def test_attach(self):
""" """
This test attaches to a process that creates a file. We attach and disconnect This test attaches to a process that creates a file. We attach and disconnect
before the file is created, and as the process is not terminated upon disconnection, before the file is created, and as the process is not terminated upon disconnection,
the file is created anyway. the file is created anyway.
""" """
self.build_and_create_debug_adaptor() self.build_and_create_debug_adaptor()
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
# Use a file as a synchronization point between test and inferior. # Use a file as a synchronization point between test and inferior.
sync_file_path = lldbutil.append_to_process_working_directory(self, sync_file_path = lldbutil.append_to_process_working_directory(self,
"sync_file_%d" % (int(time.time()))) "sync_file_%d" % (int(time.time())))
self.addTearDownHook( self.addTearDownHook(
lambda: self.run_platform_command( lambda: self.run_platform_command(
"rm %s" % "rm %s" %
(sync_file_path))) (sync_file_path)))
Show All 15 Lines

lldb/test/API/tools/lldb-vscode/evaluate/TestVSCode_evaluate.py

Show All 25 Linesclass TestVSCode_variables(lldbvscode_testcase.VSCodeTestCaseBase):
def isExpressionParsedExpected(self): def isExpressionParsedExpected(self):
return self.context != "hover" return self.context != "hover"
def run_test_evaluate_expressions(self, context=None): def run_test_evaluate_expressions(self, context=None):
""" """
Tests the evaluate expression request at different breakpoints Tests the evaluate expression request at different breakpoints
""" """
self.context = context self.context = context
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
self.build_and_launch(program) self.build_and_launch(program)
source = "main.cpp" source = "main.cpp"
self.set_source_breakpoints( self.set_source_breakpoints(
source, source,
[ [
line_number(source, "// breakpoint 1"), line_number(source, "// breakpoint 1"),
line_number(source, "// breakpoint 2"), line_number(source, "// breakpoint 2"),
line_number(source, "// breakpoint 3"), line_number(source, "// breakpoint 3"),
▲ Show 20 Lines • Show All 133 Lines • Show Last 20 Lines

lldb/test/API/tools/lldb-vscode/launch/TestVSCode_launch.py

Show All 19 Linesclass TestVSCode_launch(lldbvscode_testcase.VSCodeTestCaseBase):
@skipIfWindows @skipIfWindows
@skipIfDarwin # Flaky @skipIfDarwin # Flaky
@skipIfRemote @skipIfRemote
def test_default(self): def test_default(self):
''' '''
Tests the default launch of a simple program. No arguments, Tests the default launch of a simple program. No arguments,
environment, or anything else is specified. environment, or anything else is specified.
''' '''
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
self.build_and_launch(program) self.build_and_launch(program)
self.continue_to_exit() self.continue_to_exit()
# Now get the STDOUT and verify our program argument is correct # Now get the STDOUT and verify our program argument is correct
output = self.get_stdout() output = self.get_stdout()
self.assertTrue(output and len(output) > 0, self.assertTrue(output and len(output) > 0,
"expect program output") "expect program output")
lines = output.splitlines() lines = output.splitlines()
self.assertIn(program, lines[0], self.assertIn(program, lines[0],
Show All 26 Linesclass TestVSCode_launch(lldbvscode_testcase.VSCodeTestCaseBase):
@skipIfWindows @skipIfWindows
@skipIfRemote @skipIfRemote
def test_stopOnEntry(self): def test_stopOnEntry(self):
''' '''
Tests the default launch of a simple program that stops at the Tests the default launch of a simple program that stops at the
entry point instead of continuing. entry point instead of continuing.
''' '''
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
self.build_and_launch(program, stopOnEntry=True) self.build_and_launch(program, stopOnEntry=True)
self.set_function_breakpoints(['main']) self.set_function_breakpoints(['main'])
stopped_events = self.continue_to_next_stop() stopped_events = self.continue_to_next_stop()
for stopped_event in stopped_events: for stopped_event in stopped_events:
if 'body' in stopped_event: if 'body' in stopped_event:
body = stopped_event['body'] body = stopped_event['body']
if 'reason' in body: if 'reason' in body:
reason = body['reason'] reason = body['reason']
self.assertTrue( self.assertTrue(
reason != 'breakpoint', reason != 'breakpoint',
'verify stop isn\'t "main" breakpoint') 'verify stop isn\'t "main" breakpoint')
@skipIfWindows @skipIfWindows
@skipIfRemote @skipIfRemote
def test_cwd(self): def test_cwd(self):
''' '''
Tests the default launch of a simple program with a current working Tests the default launch of a simple program with a current working
directory. directory.
''' '''
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
program_parent_dir = os.path.realpath( program_parent_dir = os.path.realpath(
os.path.dirname(os.path.dirname(program))) os.path.dirname(os.path.dirname(program)))
self.build_and_launch(program, self.build_and_launch(program,
cwd=program_parent_dir) cwd=program_parent_dir)
self.continue_to_exit() self.continue_to_exit()
# Now get the STDOUT and verify our program argument is correct # Now get the STDOUT and verify our program argument is correct
output = self.get_stdout() output = self.get_stdout()
self.assertTrue(output and len(output) > 0, self.assertTrue(output and len(output) > 0,
Show All 11 Linesclass TestVSCode_launch(lldbvscode_testcase.VSCodeTestCaseBase):
@skipIfWindows @skipIfWindows
@skipIfRemote @skipIfRemote
def test_debuggerRoot(self): def test_debuggerRoot(self):
''' '''
Tests the "debuggerRoot" will change the working directory of Tests the "debuggerRoot" will change the working directory of
the lldb-vscode debug adaptor. the lldb-vscode debug adaptor.
''' '''
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
program_parent_dir = os.path.realpath( program_parent_dir = os.path.realpath(
os.path.dirname(os.path.dirname(program))) os.path.dirname(os.path.dirname(program)))
commands = ['platform shell echo cwd = $PWD'] commands = ['platform shell echo cwd = $PWD']
self.build_and_launch(program, self.build_and_launch(program,
debuggerRoot=program_parent_dir, debuggerRoot=program_parent_dir,
initCommands=commands) initCommands=commands)
output = self.get_console() output = self.get_console()
self.assertTrue(output and len(output) > 0, self.assertTrue(output and len(output) > 0,
Show All 11 Lines def test_debuggerRoot(self):
self.continue_to_exit() self.continue_to_exit()
@skipIfWindows @skipIfWindows
@skipIfRemote @skipIfRemote
def test_sourcePath(self): def test_sourcePath(self):
''' '''
Tests the "sourcePath" will set the target.source-map. Tests the "sourcePath" will set the target.source-map.
''' '''
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
program_dir = os.path.dirname(program) program_dir = os.path.dirname(program)
self.build_and_launch(program, self.build_and_launch(program,
sourcePath=program_dir) sourcePath=program_dir)
output = self.get_console() output = self.get_console()
self.assertTrue(output and len(output) > 0, self.assertTrue(output and len(output) > 0,
"expect console output") "expect console output")
lines = output.splitlines() lines = output.splitlines()
prefix = '(lldb) settings set target.source-map "." ' prefix = '(lldb) settings set target.source-map "." '
Show All 9 Lines def test_sourcePath(self):
self.continue_to_exit() self.continue_to_exit()
@skipIfWindows @skipIfWindows
@skipIfRemote @skipIfRemote
def test_disableSTDIO(self): def test_disableSTDIO(self):
''' '''
Tests the default launch of a simple program with STDIO disabled. Tests the default launch of a simple program with STDIO disabled.
''' '''
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
self.build_and_launch(program, self.build_and_launch(program,
disableSTDIO=True) disableSTDIO=True)
self.continue_to_exit() self.continue_to_exit()
# Now get the STDOUT and verify our program argument is correct # Now get the STDOUT and verify our program argument is correct
output = self.get_stdout() output = self.get_stdout()
self.assertEquals(output, None, self.assertEquals(output, None,
"expect no program output") "expect no program output")
@skipIfWindows @skipIfWindows
@skipIfLinux # shell argument expansion doesn't seem to work on Linux @skipIfLinux # shell argument expansion doesn't seem to work on Linux
@expectedFailureAll(oslist=["freebsd", "netbsd"], @expectedFailureAll(oslist=["freebsd", "netbsd"],
bugnumber="llvm.org/pr48349") bugnumber="llvm.org/pr48349")
@skipIfRemote @skipIfRemote
def test_shellExpandArguments_enabled(self): def test_shellExpandArguments_enabled(self):
''' '''
Tests the default launch of a simple program with shell expansion Tests the default launch of a simple program with shell expansion
enabled. enabled.
''' '''
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
program_dir = os.path.dirname(program) program_dir = os.path.dirname(program)
glob = os.path.join(program_dir, '*.out') glob = os.path.join(program_dir, '*.out')
self.build_and_launch(program, args=[glob], shellExpandArguments=True) self.build_and_launch(program, args=[glob], shellExpandArguments=True)
self.continue_to_exit() self.continue_to_exit()
# Now get the STDOUT and verify our program argument is correct # Now get the STDOUT and verify our program argument is correct
output = self.get_stdout() output = self.get_stdout()
self.assertTrue(output and len(output) > 0, self.assertTrue(output and len(output) > 0,
"expect no program output") "expect no program output")
lines = output.splitlines() lines = output.splitlines()
for line in lines: for line in lines:
quote_path = '"%s"' % (program) quote_path = '"%s"' % (program)
if line.startswith("arg[1] ="): if line.startswith("arg[1] ="):
self.assertIn(quote_path, line, self.assertIn(quote_path, line,
'verify "%s" expanded to "%s"' % ( 'verify "%s" expanded to "%s"' % (
glob, program)) glob, program))
@skipIfWindows @skipIfWindows
@skipIfRemote @skipIfRemote
def test_shellExpandArguments_disabled(self): def test_shellExpandArguments_disabled(self):
''' '''
Tests the default launch of a simple program with shell expansion Tests the default launch of a simple program with shell expansion
disabled. disabled.
''' '''
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
program_dir = os.path.dirname(program) program_dir = os.path.dirname(program)
glob = os.path.join(program_dir, '*.out') glob = os.path.join(program_dir, '*.out')
self.build_and_launch(program, self.build_and_launch(program,
args=[glob], args=[glob],
shellExpandArguments=False) shellExpandArguments=False)
self.continue_to_exit() self.continue_to_exit()
# Now get the STDOUT and verify our program argument is correct # Now get the STDOUT and verify our program argument is correct
output = self.get_stdout() output = self.get_stdout()
self.assertTrue(output and len(output) > 0, self.assertTrue(output and len(output) > 0,
"expect no program output") "expect no program output")
lines = output.splitlines() lines = output.splitlines()
for line in lines: for line in lines:
quote_path = '"%s"' % (glob) quote_path = '"%s"' % (glob)
if line.startswith("arg[1] ="): if line.startswith("arg[1] ="):
self.assertIn(quote_path, line, self.assertIn(quote_path, line,
'verify "%s" stayed to "%s"' % ( 'verify "%s" stayed to "%s"' % (
glob, glob)) glob, glob))
@skipIfWindows @skipIfWindows
@skipIfRemote @skipIfRemote
def test_args(self): def test_args(self):
''' '''
Tests launch of a simple program with arguments Tests launch of a simple program with arguments
''' '''
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
args = ["one", "with space", "'with single quotes'", args = ["one", "with space", "'with single quotes'",
'"with double quotes"'] '"with double quotes"']
self.build_and_launch(program, self.build_and_launch(program,
args=args) args=args)
self.continue_to_exit() self.continue_to_exit()
# Now get the STDOUT and verify our arguments got passed correctly # Now get the STDOUT and verify our arguments got passed correctly
output = self.get_stdout() output = self.get_stdout()
Show All 9 Lines def test_args(self):
'arg[%i] "%s" not in "%s"' % (i+1, quoted_arg, lines[i])) 'arg[%i] "%s" not in "%s"' % (i+1, quoted_arg, lines[i]))
@skipIfWindows @skipIfWindows
@skipIfRemote @skipIfRemote
def test_environment(self): def test_environment(self):
''' '''
Tests launch of a simple program with environment variables Tests launch of a simple program with environment variables
''' '''
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
env = ["NO_VALUE", "WITH_VALUE=BAR", "EMPTY_VALUE=", env = ["NO_VALUE", "WITH_VALUE=BAR", "EMPTY_VALUE=",
"SPACE=Hello World"] "SPACE=Hello World"]
self.build_and_launch(program, self.build_and_launch(program,
env=env) env=env)
self.continue_to_exit() self.continue_to_exit()
# Now get the STDOUT and verify our arguments got passed correctly # Now get the STDOUT and verify our arguments got passed correctly
output = self.get_stdout() output = self.get_stdout()
Show All 30 Lines def test_commands(self):
after the target has been created and before the launch. after the target has been created and before the launch.
"stopCommands" are a list of LLDB commands that get executed each "stopCommands" are a list of LLDB commands that get executed each
time the program stops. time the program stops.
"exitCommands" are a list of LLDB commands that get executed when "exitCommands" are a list of LLDB commands that get executed when
the process exits the process exits
"terminateCommands" are a list of LLDB commands that get executed when "terminateCommands" are a list of LLDB commands that get executed when
the debugger session terminates. the debugger session terminates.
''' '''
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
initCommands = ['target list', 'platform list'] initCommands = ['target list', 'platform list']
preRunCommands = ['image list a.out', 'image dump sections a.out'] preRunCommands = ['image list a.out', 'image dump sections a.out']
postRunCommands = ['help trace', 'help process trace'] postRunCommands = ['help trace', 'help process trace']
stopCommands = ['frame variable', 'bt'] stopCommands = ['frame variable', 'bt']
exitCommands = ['expr 2+3', 'expr 3+4'] exitCommands = ['expr 2+3', 'expr 3+4']
terminateCommands = ['expr 4+2'] terminateCommands = ['expr 4+2']
self.build_and_launch(program, self.build_and_launch(program,
initCommands=initCommands, initCommands=initCommands,
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Linesclass TestVSCode_launch(lldbvscode_testcase.VSCodeTestCaseBase):
@skipIfWindows @skipIfWindows
@skipIfRemote @skipIfRemote
def test_extra_launch_commands(self): def test_extra_launch_commands(self):
''' '''
Tests the "launchCommands" with extra launching settings Tests the "launchCommands" with extra launching settings
''' '''
self.build_and_create_debug_adaptor() self.build_and_create_debug_adaptor()
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
source = 'main.c' source = 'main.c'
first_line = line_number(source, '// breakpoint 1') first_line = line_number(source, '// breakpoint 1')
second_line = line_number(source, '// breakpoint 2') second_line = line_number(source, '// breakpoint 2')
# Set target binary and 2 breakpoints # Set target binary and 2 breakpoints
# then we can varify the "launchCommands" get run # then we can varify the "launchCommands" get run
# also we can verify that "stopCommands" get run as the # also we can verify that "stopCommands" get run as the
# breakpoints get hit # breakpoints get hit
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Linesclass TestVSCode_launch(lldbvscode_testcase.VSCodeTestCaseBase):
@skipIfDarwin @skipIfDarwin
@skipIf(archs=["arm", "aarch64"]) # Example of a flaky run http://lab.llvm.org:8011/builders/lldb-aarch64-ubuntu/builds/5540/steps/test/logs/stdio @skipIf(archs=["arm", "aarch64"]) # Example of a flaky run http://lab.llvm.org:8011/builders/lldb-aarch64-ubuntu/builds/5540/steps/test/logs/stdio
def test_terminate_commands(self): def test_terminate_commands(self):
''' '''
Tests that the "terminateCommands", that can be passed during Tests that the "terminateCommands", that can be passed during
launch, are run when the debugger is disconnected. launch, are run when the debugger is disconnected.
''' '''
self.build_and_create_debug_adaptor() self.build_and_create_debug_adaptor()
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
terminateCommands = ['expr 4+2'] terminateCommands = ['expr 4+2']
self.launch(program=program, self.launch(program=program,
terminateCommands=terminateCommands) terminateCommands=terminateCommands)
self.get_console() self.get_console()
# Once it's disconnected the console should contain the # Once it's disconnected the console should contain the
# "terminateCommands" # "terminateCommands"
self.vscode.request_disconnect(terminateDebuggee=True) self.vscode.request_disconnect(terminateDebuggee=True)
output = self.collect_console(duration=1.0) output = self.collect_console(duration=1.0)
self.verify_commands('terminateCommands', output, terminateCommands) self.verify_commands('terminateCommands', output, terminateCommands)

lldb/test/API/tools/lldb-vscode/module/TestVSCode_module.py

Show First 20 Lines • Show All 74 Lines • ▼ Show 20 Lines def test_modules_dsym(self):
will have DWARF sections added to the module, so we will expect a size. will have DWARF sections added to the module, so we will expect a size.
''' '''
return self.run_test("a.out.dSYM", expect_debug_info_size=True) return self.run_test("a.out.dSYM", expect_debug_info_size=True)
@skipIfWindows @skipIfWindows
@skipIfRemote @skipIfRemote
@expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr49418") @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr49418")
def test_compile_units(self): def test_compile_units(self):
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
self.build_and_launch(program) self.build_and_launch(program)
source = "main.cpp" source = "main.cpp"
main_source_path = self.getSourcePath(source) main_source_path = self.getSourcePath(source)
breakpoint1_line = line_number(source, '// breakpoint 1') breakpoint1_line = line_number(source, '// breakpoint 1')
lines = [breakpoint1_line] lines = [breakpoint1_line]
breakpoint_ids = self.set_source_breakpoints(source, lines) breakpoint_ids = self.set_source_breakpoints(source, lines)
self.continue_to_breakpoints(breakpoint_ids) self.continue_to_breakpoints(breakpoint_ids)
moduleId = self.vscode.get_modules()['a.out']['id'] moduleId = self.vscode.get_modules()['a.out']['id']
response = self.vscode.request_compileUnits(moduleId) response = self.vscode.request_compileUnits(moduleId)
self.assertTrue(response['body']) self.assertTrue(response['body'])
self.assertEqual(len(response['body']['compileUnits']), 1, self.assertEqual(len(response['body']['compileUnits']), 1,
'Only one source file should exist') 'Only one source file should exist')
self.assertEqual(response['body']['compileUnits'][0]['compileUnitPath'], main_source_path, self.assertEqual(response['body']['compileUnits'][0]['compileUnitPath'], main_source_path,
'Real path to main.cpp matches') 'Real path to main.cpp matches')

lldb/test/API/tools/lldb-vscode/optimized/TestVSCode_optimized.py

Show All 14 Lines
class TestVSCode_optimized(lldbvscode_testcase.VSCodeTestCaseBase): class TestVSCode_optimized(lldbvscode_testcase.VSCodeTestCaseBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipIfWindows @skipIfWindows
@skipIfRemote @skipIfRemote
def test_stack_frame_name(self): def test_stack_frame_name(self):
''' Test optimized frame has special name suffix. ''' Test optimized frame has special name suffix.
''' '''
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
self.build_and_launch(program) self.build_and_launch(program)
source = 'main.cpp' source = 'main.cpp'
breakpoint_line = line_number(source, '// breakpoint 1') breakpoint_line = line_number(source, '// breakpoint 1')
lines = [breakpoint_line] lines = [breakpoint_line]
breakpoint_ids = self.set_source_breakpoints(source, lines) breakpoint_ids = self.set_source_breakpoints(source, lines)
self.assertEqual(len(breakpoint_ids), len(lines), self.assertEqual(len(breakpoint_ids), len(lines),
"expect correct number of breakpoints") "expect correct number of breakpoints")
self.continue_to_breakpoints(breakpoint_ids) self.continue_to_breakpoints(breakpoint_ids)
leaf_frame = self.vscode.get_stackFrame(frameIndex=0) leaf_frame = self.vscode.get_stackFrame(frameIndex=0)
self.assertTrue(leaf_frame['name'].endswith(' [opt]')) self.assertTrue(leaf_frame['name'].endswith(' [opt]'))
parent_frame = self.vscode.get_stackFrame(frameIndex=1) parent_frame = self.vscode.get_stackFrame(frameIndex=1)
self.assertTrue(parent_frame['name'].endswith(' [opt]')) self.assertTrue(parent_frame['name'].endswith(' [opt]'))
@skipIfWindows @skipIfWindows
@skipIfRemote @skipIfRemote
def test_optimized_variable(self): def test_optimized_variable(self):
''' Test optimized variable value contains error. ''' Test optimized variable value contains error.
''' '''
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
self.build_and_launch(program) self.build_and_launch(program)
source = 'main.cpp' source = 'main.cpp'
breakpoint_line = line_number(source, '// breakpoint 2') breakpoint_line = line_number(source, '// breakpoint 2')
lines = [breakpoint_line] lines = [breakpoint_line]
# Set breakpoint in the thread function so we can step the threads # Set breakpoint in the thread function so we can step the threads
breakpoint_ids = self.set_source_breakpoints(source, lines) breakpoint_ids = self.set_source_breakpoints(source, lines)
self.assertEqual(len(breakpoint_ids), len(lines), self.assertEqual(len(breakpoint_ids), len(lines),
"expect correct number of breakpoints") "expect correct number of breakpoints")
self.continue_to_breakpoints(breakpoint_ids) self.continue_to_breakpoints(breakpoint_ids)
optimized_variable = self.vscode.get_local_variable('optimized') optimized_variable = self.vscode.get_local_variable('optimized')
self.assertTrue(optimized_variable['value'].startswith('<error:')) self.assertTrue(optimized_variable['value'].startswith('<error:'))

lldb/test/API/tools/lldb-vscode/runInTerminal/TestVSCode_runInTerminal.py

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Linesclass TestVSCode_runInTerminal(lldbvscode_testcase.VSCodeTestCaseBase):
@skipIf(archs=no_match(['x86_64'])) @skipIf(archs=no_match(['x86_64']))
def test_runInTerminal(self): def test_runInTerminal(self):
if not self.isTestSupported(): if not self.isTestSupported():
return return
''' '''
Tests the "runInTerminal" reverse request. It makes sure that the IDE can Tests the "runInTerminal" reverse request. It makes sure that the IDE can
launch the inferior with the correct environment variables and arguments. launch the inferior with the correct environment variables and arguments.
''' '''
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
source = 'main.c' source = 'main.c'
self.build_and_launch( self.build_and_launch(
program, stopOnEntry=True, runInTerminal=True, args=["foobar"], program, stopOnEntry=True, runInTerminal=True, args=["foobar"],
env=["FOO=bar"]) env=["FOO=bar"])
breakpoint_line = line_number(source, '// breakpoint') breakpoint_line = line_number(source, '// breakpoint')
self.set_source_breakpoints(source, [breakpoint_line]) self.set_source_breakpoints(source, [breakpoint_line])
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

lldb/test/API/tools/lldb-vscode/stackTrace/TestVSCode_stackTrace.py

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Lines def verify_stackFrame(self, frame_idx, stackFrame):
expected_line)) expected_line))
@skipIfWindows @skipIfWindows
@skipIfRemote @skipIfRemote
def test_stackTrace(self): def test_stackTrace(self):
''' '''
Tests the 'stackTrace' packet and all its variants. Tests the 'stackTrace' packet and all its variants.
''' '''
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
self.build_and_launch(program) self.build_and_launch(program)
source = 'main.c' source = 'main.c'
self.source_path = os.path.join(os.getcwd(), source) self.source_path = os.path.join(os.getcwd(), source)
self.recurse_end = line_number(source, 'recurse end') self.recurse_end = line_number(source, 'recurse end')
self.recurse_call = line_number(source, 'recurse call') self.recurse_call = line_number(source, 'recurse call')
self.recurse_invocation = line_number(source, 'recurse invocation') self.recurse_invocation = line_number(source, 'recurse invocation')
lines = [self.recurse_end] lines = [self.recurse_end]
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

lldb/test/API/tools/lldb-vscode/step/TestVSCode_step.py

Show All 15 Linesclass TestVSCode_step(lldbvscode_testcase.VSCodeTestCaseBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipIfWindows @skipIfWindows
@skipIfRemote @skipIfRemote
def test_step(self): def test_step(self):
''' '''
Tests the stepping in/out/over in threads. Tests the stepping in/out/over in threads.
''' '''
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
self.build_and_launch(program) self.build_and_launch(program)
source = 'main.cpp' source = 'main.cpp'
# source_path = os.path.join(os.getcwd(), source) # source_path = os.path.join(os.getcwd(), source)
breakpoint1_line = line_number(source, '// breakpoint 1') breakpoint1_line = line_number(source, '// breakpoint 1')
lines = [breakpoint1_line] lines = [breakpoint1_line]
# Set breakpoint in the thread function so we can step the threads # Set breakpoint in the thread function so we can step the threads
breakpoint_ids = self.set_source_breakpoints(source, lines) breakpoint_ids = self.set_source_breakpoints(source, lines)
self.assertEqual(len(breakpoint_ids), len(lines), self.assertEqual(len(breakpoint_ids), len(lines),
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

lldb/test/API/tools/lldb-vscode/stop-hooks/TestVSCode_stop_hooks.py

Show All 12 Linesclass TestVSCode_stop_hooks(lldbvscode_testcase.VSCodeTestCaseBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipIfRemote @skipIfRemote
def test_stop_hooks_before_run(self): def test_stop_hooks_before_run(self):
''' '''
Test that there is no race condition between lldb-vscode and Test that there is no race condition between lldb-vscode and
stop hooks executor stop hooks executor
''' '''
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
preRunCommands = ['target stop-hook add -o help'] preRunCommands = ['target stop-hook add -o help']
self.build_and_launch(program, stopOnEntry=True, preRunCommands=preRunCommands) self.build_and_launch(program, stopOnEntry=True, preRunCommands=preRunCommands)
# The first stop is on entry. # The first stop is on entry.
self.continue_to_next_stop() self.continue_to_next_stop()
breakpoint_ids = self.set_function_breakpoints(['main']) breakpoint_ids = self.set_function_breakpoints(['main'])
# This request hangs if the race happens, because, in that case, the # This request hangs if the race happens, because, in that case, the
# command interpreter is in synchronous mode while lldb-vscode expects # command interpreter is in synchronous mode while lldb-vscode expects
# it to be in asynchronous mode, so, the process doesn't send the stop # it to be in asynchronous mode, so, the process doesn't send the stop
# event to "lldb.Debugger" listener (which is monitored by lldb-vscode). # event to "lldb.Debugger" listener (which is monitored by lldb-vscode).
self.continue_to_breakpoints(breakpoint_ids) self.continue_to_breakpoints(breakpoint_ids)
self.continue_to_exit() self.continue_to_exit()

lldb/test/API/tools/lldb-vscode/variables/TestVSCode_variables.py

Show First 20 Lines • Show All 83 Lines • ▼ Show 20 Linesclass TestVSCode_variables(lldbvscode_testcase.VSCodeTestCaseBase):
@skipIfWindows @skipIfWindows
@skipIfRemote @skipIfRemote
def test_scopes_variables_setVariable_evaluate(self): def test_scopes_variables_setVariable_evaluate(self):
''' '''
Tests the "scopes", "variables", "setVariable", and "evaluate" Tests the "scopes", "variables", "setVariable", and "evaluate"
packets. packets.
''' '''
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
self.build_and_launch(program) self.build_and_launch(program)
source = 'main.cpp' source = 'main.cpp'
breakpoint1_line = line_number(source, '// breakpoint 1') breakpoint1_line = line_number(source, '// breakpoint 1')
lines = [breakpoint1_line] lines = [breakpoint1_line]
# Set breakpoint in the thread function so we can step the threads # Set breakpoint in the thread function so we can step the threads
breakpoint_ids = self.set_source_breakpoints(source, lines) breakpoint_ids = self.set_source_breakpoints(source, lines)
self.assertEqual(len(breakpoint_ids), len(lines), self.assertEqual(len(breakpoint_ids), len(lines),
"expect correct number of breakpoints") "expect correct number of breakpoints")
▲ Show 20 Lines • Show All 193 Lines • ▼ Show 20 Linesclass TestVSCode_variables(lldbvscode_testcase.VSCodeTestCaseBase):
@skipIfWindows @skipIfWindows
@skipIfRemote @skipIfRemote
def test_scopes_and_evaluate_expansion(self): def test_scopes_and_evaluate_expansion(self):
""" """
Tests the evaluated expression expands successfully after "scopes" packets Tests the evaluated expression expands successfully after "scopes" packets
and permanent expressions persist. and permanent expressions persist.
""" """
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
self.build_and_launch(program) self.build_and_launch(program)
source = "main.cpp" source = "main.cpp"
breakpoint1_line = line_number(source, "// breakpoint 1") breakpoint1_line = line_number(source, "// breakpoint 1")
lines = [breakpoint1_line] lines = [breakpoint1_line]
# Set breakpoint in the thread function so we can step the threads # Set breakpoint in the thread function so we can step the threads
breakpoint_ids = self.set_source_breakpoints(source, lines) breakpoint_ids = self.set_source_breakpoints(source, lines)
self.assertEqual( self.assertEqual(
len(breakpoint_ids), len(lines), "expect correct number of breakpoints" len(breakpoint_ids), len(lines), "expect correct number of breakpoints"
▲ Show 20 Lines • Show All 125 Lines • ▼ Show 20 Linesclass TestVSCode_variables(lldbvscode_testcase.VSCodeTestCaseBase):
@skipIfWindows @skipIfWindows
@skipIfRemote @skipIfRemote
def test_indexedVariables(self): def test_indexedVariables(self):
""" """
Tests that arrays and lldb.SBValue objects that have synthetic child Tests that arrays and lldb.SBValue objects that have synthetic child
providers have "indexedVariables" key/value pairs. This helps the IDE providers have "indexedVariables" key/value pairs. This helps the IDE
not to fetch too many children all at once. not to fetch too many children all at once.
""" """
program = self.getBuildArtifact("a.out") program = self.getTestExecutable()
self.build_and_launch(program) self.build_and_launch(program)
source = "main.cpp" source = "main.cpp"
breakpoint1_line = line_number(source, "// breakpoint 4") breakpoint1_line = line_number(source, "// breakpoint 4")
lines = [breakpoint1_line] lines = [breakpoint1_line]
# Set breakpoint in the thread function so we can step the threads # Set breakpoint in the thread function so we can step the threads
breakpoint_ids = self.set_source_breakpoints(source, lines) breakpoint_ids = self.set_source_breakpoints(source, lines)
self.assertEqual( self.assertEqual(
len(breakpoint_ids), len(lines), "expect correct number of breakpoints" len(breakpoint_ids), len(lines), "expect correct number of breakpoints"
Show All 14 Lines

lldb/test/API/types/TestRecursiveTypes.py

Show All 33 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 " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.getTestExecutable(), 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.runCmd("print tpi") self.runCmd("print tpi")
self.runCmd("print *tpi") self.runCmd("print *tpi")