This is an archive of the discontinued LLVM Phabricator instance.

Differential D9948

[TestBase.runCmd] Better error message when runCmd fails.
ClosedPublic

Authored by sivachandra on May 22 2015, 3:03 PM.

Details

Reviewers
clayborg
Commits
rG3154aa23f31f: [TestBase.runCmd] Better error message when runCmd fails.
rLLDB238363: [TestBase.runCmd] Better error message when runCmd fails.
rL238363: [TestBase.runCmd] Better error message when runCmd fails.
Summary

Before:

AssertionError: False is not True : Process is launched successfully

After:

AssertionError: False is not True : Command 'run a.out' failed.
>>> error: invalid target, create a target using the 'target create' command
>>> Process could not be launched successfully

Diff Detail

Event Timeline

sivachandra updated this revision to Diff 26354.May 22 2015, 3:03 PM
sivachandra retitled this revision from to [TestBase.runCmd] Better error message when runCmd fails..
sivachandra updated this object.
sivachandra edited the test plan for this revision. (Show Details)
vharron accepted this revision.May 22 2015, 3:49 PM
vharron added a reviewer: vharron.
vharron edited edge metadata.
This revision is now accepted and ready to land.May 22 2015, 3:49 PM
vharron removed a reviewer: vharron.May 22 2015, 3:49 PM
This revision now requires review to proceed.May 22 2015, 3:49 PM
vharron added a subscriber: vharron.May 22 2015, 3:50 PM

I removed my approval, waiting for feedback from others.

sivachandra added a reviewer: clayborg.May 22 2015, 3:58 PM
sivachandra added a subscriber: Unknown Object (MLST).
sivachandra added a comment.May 26 2015, 10:10 AM

Ping?

clayborg accepted this revision.May 26 2015, 3:40 PM
clayborg edited edge metadata.

Looks good.

This revision is now accepted and ready to land.May 26 2015, 3:40 PM
sivachandra closed this revision.May 27 2015, 3:31 PM
sivachandra added a comment.Jul 1 2015, 5:13 PM

I don't mind if you revert it.

My personal opinion, my change made the failure message more useful atleast for someone who was reading buildbot logs. Before I landed this, I did ask on lldb-dev if such a change was OK: http://lists.cs.uiuc.edu/pipermail/lldb-dev/2015-May/007545.html

I also agree that all such 'kinds' of failure messages should be changed in a similar fashion. My personal opinion again, there are far too many to attempt to change all at one go. My change was a small step and at a place which was hurting me the most.

Revision Contents

PathSize
test/
api/
check_public_api_headers/
2 lines
benchmarks/
continue/
2 lines
expression_command/
call-function/
2 lines
2 lines
formatters/
2 lines
persist_objc_pointeetype/
2 lines
persistent_ptr_update/
2 lines
persistent_types/
2 lines
persistent_variables/
2 lines
po_verbosity/
2 lines
radar_8638051/
2 lines
radar_9531204/
2 lines
radar_9673664/
2 lines
test/
4 lines
2 lines
two-files/
2 lines
functionalities/
archives/
2 lines
breakpoint/
breakpoint_command/
6 lines
2 lines
breakpoint_conditions/
4 lines
breakpoint_ignore_count/
4 lines
breakpoint_locations/
4 lines
breakpoint_options/
2 lines
dummy_target_breakpoints/
2 lines
inlined_breakpoints/
2 lines
conditional_break/
2 lines
data-formatter/
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-named-summaries/
2 lines
data-formatter-objc/
12 lines
data-formatter-python-synth/
4 lines
data-formatter-script/
2 lines
data-formatter-skip-summary/
2 lines
data-formatter-smart-array/
2 lines
data-formatter-stl/
libcxx/
initializerlist/
2 lines
iterator/
2 lines
list/
2 lines
map/
2 lines
multimap/
2 lines
multiset/
2 lines
set/
2 lines
string/
2 lines
unordered/
2 lines
vbool/
2 lines
vector/
2 lines
libstdcpp/
iterator/
2 lines
list/
4 lines
map/
2 lines
string/
2 lines
vbool/
2 lines
vector/
2 lines
data-formatter-synth/
2 lines
data-formatter-synthval/
2 lines
format-propagation/
2 lines
frameformat_smallstruct/
2 lines
ptr_ref_typedef/
2 lines
rdar-10449092/
2 lines
rdar-10642615/
2 lines
rdar-10887661/
2 lines
rdar-11086338/
2 lines
rdar-11628688/
2 lines
rdar-11773899/
2 lines
rdar-11988289/
2 lines
rdar-12437442/
2 lines
rdar-12529957/
2 lines
rdar-13338477/
2 lines
rdar-3534688/
2 lines
rdar-9973865/
2 lines
rdar-9973992/
2 lines
rdar-9974002/
2 lines
refpointer-recursion/
2 lines
user-format-vs-summary/
2 lines
varscript_formatting/
2 lines
vector-types/
2 lines
dead-strip/
2 lines
inferior-assert/
8 lines
inferior-changed/
6 lines
inferior-crashing/
12 lines
recursive-inferior/
12 lines
load_unload/
6 lines
longjmp/
14 lines
memory/
read/
2 lines
non-overlapping-index-variable-i/
2 lines
recursion/
2 lines
register/
4 lines
set-data/
2 lines
target_command/
6 lines
thread/
2 lines
break_after_join/
2 lines
concurrent_events/
2 lines
create_during_step/
2 lines
exit_during_break/
2 lines
exit_during_step/
2 lines
jump/
2 lines
multi_break/
2 lines
state/
10 lines
step_out/
2 lines
thread_exit/
2 lines
type_completion/
2 lines
value_md5_crash/
2 lines
watchpoint/
hello_watchlocation/
2 lines
hello_watchpoint/
2 lines
multiple_threads/
4 lines
variable_out_of_scope/
2 lines
watchpoint_commands/
16 lines
command/
4 lines
2 lines
condition/
2 lines
watchpoint_set_command/
2 lines
2 lines
lang/
c/
array_types/
2 lines
bitfields/
2 lines
blocks/
4 lines
const_variables/
2 lines
enum_types/
2 lines
forward/
2 lines
function_types/
2 lines
modules/
2 lines
register_variables/
2 lines
set_values/
2 lines
stepping/
2 lines
strings/
2 lines
tls_globals/
4 lines
cpp/
bool/
2 lines
call-function/
2 lines
class_static/
2 lines
class_types/
4 lines
2 lines
enum_types/
2 lines
namespace/
4 lines
overloaded-functions/
2 lines
rvalue-references/
2 lines
static_members/
2 lines
static_methods/
2 lines
stl/
2 lines
2 lines
this/
2 lines
unique-types/
2 lines
unsigned_types/
2 lines
objc/
foundation/
2 lines
2 lines
6 lines
12 lines
2 lines
hidden-ivars/
2 lines
modules-auto-import/
2 lines
modules-incomplete/
2 lines
modules-inline-functions/
2 lines
modules/
2 lines
objc++/
2 lines
objc-dyn-sbtype/
2 lines
objc-new-syntax/
2 lines
objc-optimized/
2 lines
radar-9691614/
2 lines
rdar-10967107/
2 lines
rdar-11355592/
2 lines
rdar-12408181/
2 lines
real-definition/
8 lines
self/
2 lines
linux/
builtin_trap/
4 lines
22 lines
macosx/
universal/
4 lines
python_api/
formatters/
4 lines
rdar-12481949/
2 lines
sbdata/
2 lines
sbvalue_persist/
2 lines
value_var_update/
2 lines
settings/
6 lines
source-manager/
2 lines
types/
4 lines
6 lines

Diff 26354

test/api/check_public_api_headers/TestPublicAPIHeaders.py

Show First 20 Lines • Show All 73 Lines • ▼ Show 20 Lines def sanity_check_executable(self, exe_name):
env_cmd = "settings set target.env-vars %s=%s" %(self.dylibPath, self.getLLDBLibraryEnvVal()) env_cmd = "settings set target.env-vars %s=%s" %(self.dylibPath, self.getLLDBLibraryEnvVal())
if self.TraceOn(): if self.TraceOn():
print "Set environment to: ", env_cmd print "Set environment to: ", env_cmd
self.runCmd(env_cmd) self.runCmd(env_cmd)
self.addTearDownHook(lambda: self.runCmd("settings remove target.env-vars %s" % self.dylibPath)) self.addTearDownHook(lambda: self.runCmd("settings remove target.env-vars %s" % self.dylibPath))
lldbutil.run_break_set_by_file_and_line (self, self.source, self.line_to_break, num_expected_locations = -1) lldbutil.run_break_set_by_file_and_line (self, self.source, self.line_to_break, num_expected_locations = -1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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.runCmd('frame variable') self.runCmd('frame variable')
if __name__ == '__main__': if __name__ == '__main__':
import atexit import atexit
lldb.SBDebugger.Initialize() lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate()) atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main() unittest2.main()

test/benchmarks/continue/TestBenchmarkContinue.py

Show All 31 Lines def setUp(self):
BenchBase.setUp(self) BenchBase.setUp(self)
def data_formatter_commands(self): def data_formatter_commands(self):
"""Benchmark different ways to continue a process""" """Benchmark different ways to continue a process"""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
bkpt = self.target().FindBreakpointByID(lldbutil.run_break_set_by_source_regexp (self, "// break here")) bkpt = self.target().FindBreakpointByID(lldbutil.run_break_set_by_source_regexp (self, "// break here"))
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
Show All 30 Lines

test/expression_command/call-function/TestCallStdStringFunction.py

Show All 36 Linesclass ExprCommandCallFunctionTestCase(TestBase):
def call_function(self): def call_function(self):
"""Test calling std::String member function.""" """Test calling std::String member function."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
# Some versions of GCC encode two locations for the 'return' statement in main.cpp # Some versions of GCC encode two locations for the 'return' statement in main.cpp
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
self.expect("print str", self.expect("print str",
substrs = ['Hello world']) substrs = ['Hello world'])
# Calling this function now succeeds, but we follow the typedef return type through to # Calling this function now succeeds, but we follow the typedef return type through to
# const char *, and thus don't invoke the Summary formatter. # const char *, and thus don't invoke the Summary formatter.
self.expect("print str.c_str()", self.expect("print str.c_str()",
substrs = ['Hello world']) substrs = ['Hello world'])
if __name__ == '__main__': if __name__ == '__main__':
import atexit import atexit
lldb.SBDebugger.Initialize() lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate()) atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main() unittest2.main()

test/expression_command/call-function/TestCallStopAndContinue.py

Show All 36 Linesclass ExprCommandCallStopContinueTestCase(TestBase):
def call_function(self): def call_function(self):
"""Test gathering result from interrupted function call.""" """Test gathering result from interrupted function call."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
# Some versions of GCC encode two locations for the 'return' statement in main.cpp # Some versions of GCC encode two locations for the 'return' statement in main.cpp
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.func_line, num_expected_locations=-1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.func_line, num_expected_locations=-1, loc_exact=True)
self.expect("expr -i false -- returnsFive()", error=True, self.expect("expr -i false -- returnsFive()", error=True,
substrs = ['Execution was interrupted, reason: breakpoint']) substrs = ['Execution was interrupted, reason: breakpoint'])
self.runCmd("continue", "Continue completed") self.runCmd("continue", "Continue completed")
self.expect ("thread list", self.expect ("thread list",
substrs = ['stop reason = User Expression thread plan', substrs = ['stop reason = User Expression thread plan',
r'Completed expression: (Five) $0 = (number = 5, name = "five")']) r'Completed expression: (Five) $0 = (number = 5, name = "five")'])
if __name__ == '__main__': if __name__ == '__main__':
import atexit import atexit
lldb.SBDebugger.Initialize() lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate()) atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main() unittest2.main()

test/expression_command/formatters/TestFormatters.py

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines def do_my_test(self):
# Execute the cleanup function during test case tear down. # Execute the cleanup function during test case tear down.
self.addTearDownHook(cleanup) self.addTearDownHook(cleanup)
"""Test expr + formatters for good interoperability.""" """Test expr + formatters for good interoperability."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
self.runCmd("script import formatters") self.runCmd("script import formatters")
self.runCmd("script import foosynth") self.runCmd("script import foosynth")
self.runCmd("frame variable foo1 --show-types") self.runCmd("frame variable foo1 --show-types")
self.runCmd("frame variable foo1.b --show-types") self.runCmd("frame variable foo1.b --show-types")
self.runCmd("frame variable foo1.b.b_ref --show-types") self.runCmd("frame variable foo1.b.b_ref --show-types")
self.expect("expression --show-types -- *(new foo(47))", self.expect("expression --show-types -- *(new foo(47))",
▲ Show 20 Lines • Show All 116 Lines • Show Last 20 Lines

test/expression_command/persist_objc_pointeetype/TestPersistObjCPointeeType.py

Show All 38 Lines def do_my_test(self):
# Execute the cleanup function during test case tear down. # Execute the cleanup function during test case tear down.
self.addTearDownHook(cleanup) self.addTearDownHook(cleanup)
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
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'])
if __name__ == '__main__': if __name__ == '__main__':
import atexit import atexit
lldb.SBDebugger.Initialize() lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate()) atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main() unittest2.main()

test/expression_command/persistent_ptr_update/TestPersistentPtrUpdate.py

Show All 34 Lines def do_my_test(self):
# Execute the cleanup function during test case tear down. # Execute the cleanup function during test case tear down.
self.addTearDownHook(cleanup) self.addTearDownHook(cleanup)
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
self.runCmd('break set -p here') self.runCmd('break set -p here')
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
self.runCmd("expr void* $foo = nullptr") self.runCmd("expr void* $foo = nullptr")
self.runCmd("continue") self.runCmd("continue")
self.expect("expr $foo", substrs=['$foo','0x0']) self.expect("expr $foo", substrs=['$foo','0x0'])
if __name__ == '__main__': if __name__ == '__main__':
import atexit import atexit
lldb.SBDebugger.Initialize() lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate()) atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main() unittest2.main()

test/expression_command/persistent_types/TestPersistentTypes.py

Show All 13 Linesclass PersistenttypesTestCase(TestBase):
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.buildDefault() self.buildDefault()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
self.runCmd("breakpoint set --name main") self.runCmd("breakpoint set --name main")
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
self.runCmd("expression struct $foo { int a; int b; };") self.runCmd("expression struct $foo { int a; int b; };")
self.expect("expression struct $foo $my_foo; $my_foo.a = 2; $my_foo.b = 3;", self.expect("expression struct $foo $my_foo; $my_foo.a = 2; $my_foo.b = 3;",
startstr = "(int) $0 = 3") startstr = "(int) $0 = 3")
self.expect("expression $my_foo", self.expect("expression $my_foo",
substrs = ['a = 2', 'b = 3']) substrs = ['a = 2', 'b = 3'])
Show All 21 Lines

test/expression_command/persistent_variables/TestPersistentVariables.py

Show All 13 Linesclass PersistentVariablesTestCase(TestBase):
def test_persistent_variables(self): def test_persistent_variables(self):
"""Test that lldb persistent variables works correctly.""" """Test that lldb persistent variables works correctly."""
self.buildDefault() self.buildDefault()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
self.runCmd("breakpoint set --source-pattern-regexp break") self.runCmd("breakpoint set --source-pattern-regexp break")
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
self.runCmd("expression int $i = i") self.runCmd("expression int $i = i")
self.expect("expression $i == i", self.expect("expression $i == i",
startstr = "(bool) $0 = true") startstr = "(bool) $0 = true")
self.expect("expression $i + 1", self.expect("expression $i + 1",
startstr = "(int) $1 = 6") startstr = "(int) $1 = 6")
Show All 27 Lines

test/expression_command/po_verbosity/TestPoVerbosity.py

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Lines def do_my_test(self):
# Execute the cleanup function during test case tear down. # Execute the cleanup function during test case tear down.
self.addTearDownHook(cleanup) self.addTearDownHook(cleanup)
"""Test expr + formatters for good interoperability.""" """Test expr + formatters for good interoperability."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
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;'])
self.expect("expr -O -vfull -- foo", self.expect("expr -O -vfull -- foo",
substrs = ['(id) $',' = 0x', '1 = 2','2 = 3;']) substrs = ['(id) $',' = 0x', '1 = 2','2 = 3;'])
self.expect("expr -O -- foo",matching=False, self.expect("expr -O -- foo",matching=False,
substrs = ['(id) $']) substrs = ['(id) $'])
Show All 17 Lines

test/expression_command/radar_8638051/Test8638051.py

Show All 13 Linesclass Radar8638051TestCase(TestBase):
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.buildDefault() self.buildDefault()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
self.runCmd("breakpoint set -n c") self.runCmd("breakpoint set -n c")
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
self.expect("expression val", self.expect("expression val",
startstr = "(int) $0 = 1") startstr = "(int) $0 = 1")
# (int) $0 = 1 # (int) $0 = 1
self.expect("expression *(&val)", self.expect("expression *(&val)",
startstr = "(int) $1 = 1") startstr = "(int) $1 = 1")
# (int) $1 = 1 # (int) $1 = 1
Show All 13 Lines

test/expression_command/radar_9531204/TestPrintfAfterUp.py

Show All 15 Linesclass Radar9531204TestCase(TestBase):
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.buildDefault() self.buildDefault()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_symbol (self, 'foo', sym_exact=True, num_expected_locations=1) lldbutil.run_break_set_by_symbol (self, 'foo', sym_exact=True, num_expected_locations=1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
self.runCmd("frame variable") self.runCmd("frame variable")
# This works fine. # This works fine.
self.runCmd('expression (int)printf("value is: %d.\\n", value);') self.runCmd('expression (int)printf("value is: %d.\\n", value);')
# rdar://problem/9531204 # rdar://problem/9531204
# "Error dematerializing struct" error when evaluating expressions "up" on the stack # "Error dematerializing struct" error when evaluating expressions "up" on the stack
Show All 13 Lines

test/expression_command/radar_9673664/TestExprHelpExamples.py

Show All 22 Linesclass Radar9673644TestCase(TestBase):
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.buildDefault() self.buildDefault()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, self.main_source, self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, self.main_source, self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# rdar://problem/9673664 lldb expression evaluation problem # rdar://problem/9673664 lldb expression evaluation problem
self.expect('expr char c[] = "foo"; c[0]', self.expect('expr char c[] = "foo"; c[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'
if __name__ == '__main__': if __name__ == '__main__':
import atexit import atexit
lldb.SBDebugger.Initialize() lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate()) atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main() unittest2.main()

test/expression_command/test/TestExprs.py

Show All 35 Linesclass BasicExprCommandsTestCase(TestBase):
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.buildDefault() self.buildDefault()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=False) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=False)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
@unittest2.expectedFailure("llvm.org/pr17135 <rdar://problem/14874559> APFloat::toString does not identify the correct (i.e. least) precision.") @unittest2.expectedFailure("llvm.org/pr17135 <rdar://problem/14874559> APFloat::toString does not identify the correct (i.e. least) precision.")
def test_floating_point_expr_commands(self): def test_floating_point_expr_commands(self):
self.build_and_run() self.build_and_run()
self.expect("expression 2.234f", self.expect("expression 2.234f",
patterns = ["\(float\) \$.* = 2\.234"]) patterns = ["\(float\) \$.* = 2\.234"])
# (float) $2 = 2.234 # (float) $2 = 2.234
▲ Show 20 Lines • Show All 143 Lines • ▼ Show 20 Linesclass BasicExprCommandsTestCase(TestBase):
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.buildDefault() self.buildDefault()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line(self, "main.cpp", self.line, num_expected_locations=1,loc_exact=False) lldbutil.run_break_set_by_file_and_line(self, "main.cpp", self.line, num_expected_locations=1,loc_exact=False)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# runCmd: expression 'a' # runCmd: expression 'a'
# output: (char) $0 = 'a' # output: (char) $0 = 'a'
self.expect("expression 'a'", self.expect("expression 'a'",
substrs = ['(char) $', substrs = ['(char) $',
"'a'"]) "'a'"])
# runCmd: expression (int) printf ("\n\n\tHello there!\n") # runCmd: expression (int) printf ("\n\n\tHello there!\n")
Show All 36 Lines

test/expression_command/test/TestExprs2.py

Show All 21 Linesclass ExprCommands2TestCase(TestBase):
def test_more_expr_commands(self): def test_more_expr_commands(self):
"""Test some more expression commands.""" """Test some more expression commands."""
self.buildDefault() self.buildDefault()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line(self, "main.cpp", self.line, num_expected_locations=1,loc_exact=False) lldbutil.run_break_set_by_file_and_line(self, "main.cpp", self.line, num_expected_locations=1,loc_exact=False)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# Does static casting work? # Does static casting work?
self.expect("expression (int*)argv", self.expect("expression (int*)argv",
startstr = "(int *) $0 = 0x") startstr = "(int *) $0 = 0x")
# (int *) $0 = 0x00007fff5fbff258 # (int *) $0 = 0x00007fff5fbff258
# Do anonymous symbols work? # Do anonymous symbols work?
self.expect("expression ((char**)environ)[0]", self.expect("expression ((char**)environ)[0]",
Show All 25 Lines

test/expression_command/two-files/TestObjCTypeQueryFromOtherCompileUnit.py

Show All 34 Lines def test_with_dwarf(self):
self.type_query_from_other_cu() self.type_query_from_other_cu()
def type_query_from_other_cu(self): def type_query_from_other_cu(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.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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
if __name__ == '__main__': if __name__ == '__main__':
import atexit import atexit
lldb.SBDebugger.Initialize() lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate()) atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main() unittest2.main()

test/functionalities/archives/TestBSDArchives.py

Show All 23 Linesclass BSDArchivesTestCase(TestBase):
def break_inside_bsd_archives(self): def break_inside_bsd_archives(self):
"""Break inside a() and b() defined within libfoo.a.""" """Break inside a() and b() defined within libfoo.a."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside a() by file and line first. # Break inside a() by file and line first.
lldbutil.run_break_set_by_file_and_line (self, "a.c", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "a.c", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# Break at a(int) first. # Break at a(int) first.
self.expect("frame variable", VARIABLES_DISPLAYED_CORRECTLY, self.expect("frame variable", VARIABLES_DISPLAYED_CORRECTLY,
Show All 23 Lines

test/functionalities/breakpoint/breakpoint_command/TestBreakpointCommand.py

Show First 20 Lines • Show All 105 Lines • ▼ Show 20 Lines def breakpoint_command_sequence(self):
# Now try a source regex breakpoint: # Now try a source regex breakpoint:
lldbutil.run_break_set_by_source_regexp (self, r"is about to return [12]0", extra_options="-f a.c -f b.c", num_expected_locations=2) lldbutil.run_break_set_by_source_regexp (self, r"is about to return [12]0", extra_options="-f a.c -f b.c", num_expected_locations=2)
lldbutil.run_break_set_by_source_regexp (self, r"is about to return [12]0", extra_options="-f a.c", num_expected_locations=1) lldbutil.run_break_set_by_source_regexp (self, r"is about to return [12]0", extra_options="-f a.c", num_expected_locations=1)
# Run the program. Remove 'output.txt' if it exists. # Run the program. Remove 'output.txt' if it exists.
self.RemoveTempFile("output.txt") self.RemoveTempFile("output.txt")
self.RemoveTempFile("output2.txt") self.RemoveTempFile("output2.txt")
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# Check that the file 'output.txt' exists and contains the string "lldb". # Check that the file 'output.txt' exists and contains the string "lldb".
# The 'output.txt' file should now exist. # The 'output.txt' file should now exist.
self.assertTrue(os.path.isfile("output.txt"), self.assertTrue(os.path.isfile("output.txt"),
"'output.txt' exists due to breakpoint command for breakpoint 2.") "'output.txt' exists due to breakpoint command for breakpoint 2.")
self.assertTrue(os.path.isfile("output2.txt"), self.assertTrue(os.path.isfile("output2.txt"),
"'output2.txt' exists due to breakpoint command for breakpoint 3.") "'output2.txt' exists due to breakpoint command for breakpoint 3.")
Show All 33 Lines def breakpoint_command_sequence(self):
"hit count = 1"]) "hit count = 1"])
# Not breakpoint 2. # Not breakpoint 2.
self.expect("breakpoint list -f", "No more breakpoint 2", matching=False, self.expect("breakpoint list -f", "No more breakpoint 2", matching=False,
substrs = ["2: file = 'main.c', line = %d, exact_match = 0, locations = 1, resolved = 1" % substrs = ["2: file = 'main.c', line = %d, exact_match = 0, locations = 1, resolved = 1" %
self.line]) self.line])
# Run the program again, with breakpoint 1 remaining. # Run the program again, with breakpoint 1 remaining.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# We should be stopped again due to breakpoint 1. # We should be stopped again due to breakpoint 1.
# 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'])
Show All 13 Lines def breakpoint_command_script_parameters (self):
self.runCmd("breakpoint command add -s python -o 'here = open(\"output-2.txt\", \"w\"); print >> here, frame; print >> here, bp_loc; here.close()' 1") self.runCmd("breakpoint command add -s python -o 'here = open(\"output-2.txt\", \"w\"); print >> here, frame; print >> here, bp_loc; here.close()' 1")
# Remove 'output-2.txt' if it already exists. # Remove 'output-2.txt' if it already exists.
if (os.path.exists('output-2.txt')): if (os.path.exists('output-2.txt')):
os.remove ('output-2.txt') os.remove ('output-2.txt')
# Run program, hit breakpoint, and hopefully write out new version of 'output-2.txt' # Run program, hit breakpoint, and hopefully write out new version of 'output-2.txt'
self.runCmd ("run", RUN_SUCCEEDED) self.runCmd ("run", RUN_FAILED)
# Check that the file 'output.txt' exists and contains the string "lldb". # Check that the file 'output.txt' exists and contains the string "lldb".
# The 'output-2.txt' file should now exist. # The 'output-2.txt' file should now exist.
self.assertTrue(os.path.isfile("output-2.txt"), self.assertTrue(os.path.isfile("output-2.txt"),
"'output-2.txt' exists due to breakpoint command for breakpoint 1.") "'output-2.txt' exists due to breakpoint command for breakpoint 1.")
# Read the output file produced by running the program. # Read the output file produced by running the program.
Show All 15 Lines

test/functionalities/breakpoint/breakpoint_command/TestRegexpBreakCommand.py

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Lines def regexp_break_command(self):
break_results = lldbutil.run_break_set_command (self, "b %s:%d" % (self.source, self.line)) break_results = lldbutil.run_break_set_command (self, "b %s:%d" % (self.source, self.line))
lldbutil.check_breakpoint_result (self, break_results, file_name='main.c', line_number=self.line, num_locations=1) lldbutil.check_breakpoint_result (self, break_results, file_name='main.c', line_number=self.line, num_locations=1)
# Check breakpoint with full file path. # Check breakpoint with full file path.
full_path = os.path.join(os.getcwd(), self.source) full_path = os.path.join(os.getcwd(), self.source)
break_results = lldbutil.run_break_set_command (self, "b %s:%d" % (full_path, self.line)) break_results = lldbutil.run_break_set_command (self, "b %s:%d" % (full_path, self.line))
lldbutil.check_breakpoint_result (self, break_results, file_name='main.c', line_number=self.line, num_locations=1) lldbutil.check_breakpoint_result (self, break_results, file_name='main.c', line_number=self.line, num_locations=1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
if __name__ == '__main__': if __name__ == '__main__':
import atexit import atexit
lldb.SBDebugger.Initialize() lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate()) atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main() unittest2.main()

test/functionalities/breakpoint/breakpoint_conditions/TestBreakpointConditions.py

Show First 20 Lines • Show All 73 Lines • ▼ Show 20 Lines def breakpoint_conditions(self, inline=False):
else: else:
# Create a breakpoint by function name 'c'. # Create a breakpoint by function name 'c'.
lldbutil.run_break_set_by_symbol (self, "c", num_expected_locations=1, sym_exact=True) lldbutil.run_break_set_by_symbol (self, "c", num_expected_locations=1, sym_exact=True)
# And set a condition on the breakpoint to stop on when 'val == 3'. # And set a condition on the breakpoint to stop on when 'val == 3'.
self.runCmd("breakpoint modify -c 'val == 3' 1") self.runCmd("breakpoint modify -c 'val == 3' 1")
# Now run the program. # Now run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# The process should be stopped at this point. # The process should be stopped at this point.
self.expect("process status", PROCESS_STOPPED, self.expect("process status", PROCESS_STOPPED,
patterns = ['Process .* stopped']) patterns = ['Process .* stopped'])
# 'frame variable --show-types val' should return 3 due to breakpoint condition. # 'frame variable --show-types val' should return 3 due to breakpoint condition.
self.expect("frame variable --show-types val", VARIABLES_DISPLAYED_CORRECTLY, self.expect("frame variable --show-types val", VARIABLES_DISPLAYED_CORRECTLY,
startstr = '(int) val = 3') startstr = '(int) val = 3')
Show All 14 Lines def breakpoint_conditions(self, inline=False):
# Test that "breakpoint modify -c ''" clears the condition for the last # Test that "breakpoint modify -c ''" clears the condition for the last
# created breakpoint, so that when the breakpoint hits, val == 1. # created breakpoint, so that when the breakpoint hits, val == 1.
self.runCmd("process kill") self.runCmd("process kill")
self.runCmd("breakpoint modify -c ''") self.runCmd("breakpoint modify -c ''")
self.expect("breakpoint list -f", BREAKPOINT_STATE_CORRECT, matching=False, self.expect("breakpoint list -f", BREAKPOINT_STATE_CORRECT, matching=False,
substrs = ["Condition:"]) substrs = ["Condition:"])
# Now run the program again. # Now run the program again.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# The process should be stopped at this point. # The process should be stopped at this point.
self.expect("process status", PROCESS_STOPPED, self.expect("process status", PROCESS_STOPPED,
patterns = ['Process .* stopped']) patterns = ['Process .* stopped'])
# 'frame variable --show-types val' should return 1 since it is the first breakpoint hit. # 'frame variable --show-types val' should return 1 since it is the first breakpoint hit.
self.expect("frame variable --show-types val", VARIABLES_DISPLAYED_CORRECTLY, self.expect("frame variable --show-types val", VARIABLES_DISPLAYED_CORRECTLY,
startstr = '(int) val = 1') startstr = '(int) val = 1')
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

test/functionalities/breakpoint/breakpoint_ignore_count/TestBreakpointIgnoreCount.py

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines def breakpoint_ignore_count(self):
"""Exercise breakpoint ignore count with 'breakpoint set -i <count>'.""" """Exercise breakpoint ignore count with 'breakpoint set -i <count>'."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Create a breakpoint in main.c at line1. # Create a breakpoint in main.c at line1.
lldbutil.run_break_set_by_file_and_line (self, 'main.c', self.line1, extra_options='-i 1', num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, 'main.c', self.line1, extra_options='-i 1', num_expected_locations=1, loc_exact=True)
# Now run the program. # Now run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# The process should be stopped at this point. # The process should be stopped at this point.
self.expect("process status", PROCESS_STOPPED, self.expect("process status", PROCESS_STOPPED,
patterns = ['Process .* stopped']) patterns = ['Process .* stopped'])
# Also check the hit count, which should be 2, due to ignore count of 1. # Also check the hit count, which should be 2, due to ignore count of 1.
self.expect("breakpoint list -f", BREAKPOINT_HIT_THRICE, self.expect("breakpoint list -f", BREAKPOINT_HIT_THRICE,
substrs = ["resolved = 1", substrs = ["resolved = 1",
"hit count = 2"]) "hit count = 2"])
# The frame #0 should correspond to main.c:37, the executable statement # The frame #0 should correspond to main.c:37, the executable statement
# in function name 'c'. And frame #2 should point to main.c:45. # in function name 'c'. And frame #2 should point to main.c:45.
self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT_IGNORE_COUNT, self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT_IGNORE_COUNT,
#substrs = ["stop reason = breakpoint"], #substrs = ["stop reason = breakpoint"],
patterns = ["frame #0.*main.c:%d" % self.line1, patterns = ["frame #0.*main.c:%d" % self.line1,
"frame #2.*main.c:%d" % self.line2]) "frame #2.*main.c:%d" % self.line2])
# continue -i 1 is the same as setting the ignore count to 1 again, try that: # continue -i 1 is the same as setting the ignore count to 1 again, try that:
# Now run the program. # Now run the program.
self.runCmd("process continue -i 1", RUN_SUCCEEDED) self.runCmd("process continue -i 1", RUN_FAILED)
# The process should be stopped at this point. # The process should be stopped at this point.
self.expect("process status", PROCESS_STOPPED, self.expect("process status", PROCESS_STOPPED,
patterns = ['Process .* stopped']) patterns = ['Process .* stopped'])
# Also check the hit count, which should be 2, due to ignore count of 1. # Also check the hit count, which should be 2, due to ignore count of 1.
self.expect("breakpoint list -f", BREAKPOINT_HIT_THRICE, self.expect("breakpoint list -f", BREAKPOINT_HIT_THRICE,
substrs = ["resolved = 1", substrs = ["resolved = 1",
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

test/functionalities/breakpoint/breakpoint_locations/TestBreakpointLocations.py

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines def breakpoint_locations_test(self):
error=True, error=True,
startstr = "error: '3' is not a valid breakpoint ID.") startstr = "error: '3' is not a valid breakpoint ID.")
# The 'breakpoint disable 1.*' command should disable all 3 locations. # The 'breakpoint disable 1.*' command should disable all 3 locations.
self.expect("breakpoint disable 1.*", "All 3 breakpoint locatons disabled correctly", self.expect("breakpoint disable 1.*", "All 3 breakpoint locatons disabled correctly",
startstr = "3 breakpoints disabled.") startstr = "3 breakpoints disabled.")
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# We should not stopped on any breakpoint at all. # We should not stopped on any breakpoint at all.
self.expect("process status", "No stopping on any disabled breakpoint", self.expect("process status", "No stopping on any disabled breakpoint",
patterns = ["^Process [0-9]+ exited with status = 0"]) patterns = ["^Process [0-9]+ exited with status = 0"])
# The 'breakpoint enable 1.*' command should enable all 3 breakpoints. # The 'breakpoint enable 1.*' command should enable all 3 breakpoints.
self.expect("breakpoint enable 1.*", "All 3 breakpoint locatons enabled correctly", self.expect("breakpoint enable 1.*", "All 3 breakpoint locatons enabled correctly",
startstr = "3 breakpoints enabled.") startstr = "3 breakpoints enabled.")
# The 'breakpoint disable 1.1' command should disable 1 location. # The 'breakpoint disable 1.1' command should disable 1 location.
self.expect("breakpoint disable 1.1", "1 breakpoint locatons disabled correctly", self.expect("breakpoint disable 1.1", "1 breakpoint locatons disabled correctly",
startstr = "1 breakpoints disabled.") startstr = "1 breakpoints disabled.")
# Run the program againt. We should stop on the two breakpoint locations. # Run the program againt. We should stop on the two breakpoint locations.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# Stopped once. # Stopped once.
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."])
# Continue the program, there should be another stop. # Continue the program, there should be another stop.
self.runCmd("process continue") self.runCmd("process continue")
Show All 16 Lines

test/functionalities/breakpoint/breakpoint_options/TestBreakpointOptions.py

Show All 38 Lines def breakpoint_options_test(self):
# This should create a breakpoint with 1 locations. # This should create a breakpoint with 1 locations.
lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, extra_options = "-K 1", num_expected_locations = 1) lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, extra_options = "-K 1", num_expected_locations = 1)
lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, extra_options = "-K 0", num_expected_locations = 1) lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, extra_options = "-K 0", num_expected_locations = 1)
# This should create a breakpoint 0 locations. # This should create a breakpoint 0 locations.
lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, extra_options = "-m 0", num_expected_locations = 0) lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, extra_options = "-m 0", num_expected_locations = 0)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# Stopped once. # Stopped once.
self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT,
substrs = ["stop reason = breakpoint 2."]) substrs = ["stop reason = breakpoint 2."])
# Check the list of breakpoint. # Check the list of breakpoint.
self.expect("breakpoint list -f", "Breakpoint locations shown correctly", self.expect("breakpoint list -f", "Breakpoint locations shown correctly",
substrs = ["1: file = 'main.c', line = %d, exact_match = 0, locations = 1" % self.line, substrs = ["1: file = 'main.c', line = %d, exact_match = 0, locations = 1" % self.line,
Show All 22 Lines

test/functionalities/breakpoint/dummy_target_breakpoints/TestBreakpointsWithNoTargets.py

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines def dummy_breakpoint_test(self):
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("breakpoint list -f", "Breakpoint locations shown correctly", self.expect("breakpoint list -f", "Breakpoint locations shown correctly",
substrs = ["1: file = 'main.c', line = %d, exact_match = 0, locations = 1" % self.line, substrs = ["1: file = 'main.c', line = %d, exact_match = 0, locations = 1" % self.line,
"2: file = 'main.c', line = %d, exact_match = 0, locations = 1" % self.line2]) "2: file = 'main.c', line = %d, exact_match = 0, locations = 1" % self.line2])
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# Stopped once. # Stopped once.
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."])
# Continue the program, there should be another stop. # Continue the program, there should be another stop.
self.runCmd("process continue") self.runCmd("process continue")
Show All 9 Lines

test/functionalities/breakpoint/inlined_breakpoints/TestInlinedBreakpoints.py

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines def inlined_breakpoints(self):
# Now enable breakpoints in implementation files and see the breakpoint set succeed # Now enable breakpoints in implementation files and see the breakpoint set succeed
self.runCmd('settings set target.inline-breakpoint-strategy always') self.runCmd('settings set target.inline-breakpoint-strategy always')
# And add hooks to restore the settings during tearDown(). # And add hooks to restore the settings during tearDown().
self.addTearDownHook( self.addTearDownHook(
lambda: self.runCmd("settings set target.inline-breakpoint-strategy always")) lambda: self.runCmd("settings set target.inline-breakpoint-strategy always"))
lldbutil.run_break_set_by_file_and_line (self, "basic_type.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "basic_type.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
# And it should break at basic_type.cpp:176. # And it should break at basic_type.cpp:176.
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',
'basic_type.cpp:%d' % self.line]) 'basic_type.cpp:%d' % self.line])
if __name__ == '__main__': if __name__ == '__main__':
import atexit import atexit
lldb.SBDebugger.Initialize() lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate()) atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main() unittest2.main()

test/functionalities/conditional_break/TestConditionalBreak.py

Show First 20 Lines • Show All 117 Lines • ▼ Show 20 Lines def simulate_conditional_break_by_user(self):
# remote testsuite. # remote testsuite.
self.runCmd("file a.out") self.runCmd("file a.out")
self.runCmd("command source .lldb") self.runCmd("command source .lldb")
self.runCmd ("break list") self.runCmd ("break list")
if self.TraceOn(): if self.TraceOn():
print "About to run." print "About to run."
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
self.runCmd ("break list") self.runCmd ("break list")
if self.TraceOn(): if self.TraceOn():
print "Done running" print "Done running"
# 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

test/functionalities/data-formatter/data-formatter-advanced/TestDataFormatterAdv.py

Show All 31 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 data_formatter_commands(self): def data_formatter_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
▲ Show 20 Lines • Show All 253 Lines • Show Last 20 Lines

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

Show All 31 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 data_formatter_commands(self): def data_formatter_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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 (most of these categories do not # clean slate for the next test case (most of these categories do not
▲ Show 20 Lines • Show All 295 Lines • Show Last 20 Lines

test/functionalities/data-formatter/data-formatter-cpp/TestDataFormatterCpp.py

Show All 31 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 data_formatter_commands(self): def data_formatter_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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", self.expect("frame variable",
substrs = ['(Speed) SPILookHex = 5.55' # Speed by default is 5.55. substrs = ['(Speed) SPILookHex = 5.55' # Speed by default is 5.55.
▲ Show 20 Lines • Show All 231 Lines • Show Last 20 Lines

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

Show All 31 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 data_formatter_commands(self): def data_formatter_commands(self):
"""Check that we can properly disable all data formatter categories.""" """Check that we can properly disable all data formatter categories."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

test/functionalities/data-formatter/data-formatter-enum-format/TestDataFormatterEnumFormat.py

Show All 31 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 data_formatter_commands(self): def data_formatter_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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", self.expect("frame variable",
substrs = ['(Foo) f = Case45', substrs = ['(Foo) f = Case45',
Show All 32 Lines

test/functionalities/data-formatter/data-formatter-named-summaries/TestDataFormatterNamedSummaries.py

Show All 31 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 data_formatter_commands(self): def data_formatter_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

test/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjC.py

Show First 20 Lines • Show All 225 Lines • ▼ Show 20 Lines def setUp(self):
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 rdar11106605_commands(self): def rdar11106605_commands(self):
"""Check that Unicode characters come out of CFString summary correctly.""" """Check that Unicode characters come out of CFString summary correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
Show All 14 Linesclass ObjCDataFormatterTestCase(TestBase):
def plain_data_formatter_commands(self): def plain_data_formatter_commands(self):
"""Test basic ObjC formatting behavior.""" """Test basic ObjC formatting behavior."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines def plain_data_formatter_commands(self):
substrs = ['(Class) myclass5 = nil']) substrs = ['(Class) myclass5 = nil'])
def appkit_common_data_formatters_command(self): def appkit_common_data_formatters_command(self):
"""Test formatters for AppKit classes.""" """Test formatters for AppKit classes."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Linesclass ObjCDataFormatterTestCase(TestBase):
def expr_objc_data_formatter_commands(self): def expr_objc_data_formatter_commands(self):
"""Test common cases of expression parser <--> formatters interaction.""" """Test common cases of expression parser <--> formatters interaction."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
Show All 26 Linesclass ObjCDataFormatterTestCase(TestBase):
def cf_data_formatter_commands(self): def cf_data_formatter_commands(self):
"""Test formatters for Core OSX frameworks.""" """Test formatters for Core OSX frameworks."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
Show All 39 Linesclass ObjCDataFormatterTestCase(TestBase):
def kvo_data_formatter_commands(self): def kvo_data_formatter_commands(self):
"""Test the behavior of formatters when KVO is in use.""" """Test the behavior of formatters when KVO is in use."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
Show All 33 Lines

test/functionalities/data-formatter/data-formatter-python-synth/TestDataFormatterPythonSynth.py

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines def setUp(self):
self.line3 = line_number('main.cpp', '// Set second cast break point at this line.') self.line3 = line_number('main.cpp', '// Set second cast break point at this line.')
def data_formatter_commands(self): def data_formatter_commands(self):
"""Test using Python synthetic children provider.""" """Test using Python synthetic children provider."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
▲ Show 20 Lines • Show All 139 Lines • ▼ Show 20 Linesclass PythonSynthDataFormatterTestCase(TestBase):
def rdar10960550_formatter_commands(self): def rdar10960550_formatter_commands(self):
"""Test that synthetic children persist stoppoints.""" """Test that synthetic children persist stoppoints."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
# The second breakpoint is on a multi-line expression, so the comment can't be on the right line... # The second breakpoint is on a multi-line expression, so the comment can't be on the right line...
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line2, num_expected_locations=1, loc_exact=False) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line2, num_expected_locations=1, loc_exact=False)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line3, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line3, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

test/functionalities/data-formatter/data-formatter-script/TestDataFormatterScript.py

Show All 31 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 data_formatter_commands(self): def data_formatter_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
▲ Show 20 Lines • Show All 134 Lines • Show Last 20 Lines

test/functionalities/data-formatter/data-formatter-skip-summary/TestDataFormatterSkipSummary.py

Show All 34 Linesclass SkipSummaryDataFormatterTestCase(TestBase):
def data_formatter_commands(self): def data_formatter_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
#import lldbutil #import lldbutil
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
▲ Show 20 Lines • Show All 135 Lines • Show Last 20 Lines

test/functionalities/data-formatter/data-formatter-smart-array/TestDataFormatterSmartArray.py

Show All 31 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 data_formatter_commands(self): def data_formatter_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
▲ Show 20 Lines • Show All 311 Lines • Show Last 20 Lines

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

Show All 32 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
def data_formatter_commands(self): def data_formatter_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
bkpt = self.target().FindBreakpointByID(lldbutil.run_break_set_by_source_regexp (self, "Set break point at this line.")) bkpt = self.target().FindBreakpointByID(lldbutil.run_break_set_by_source_regexp (self, "Set break point at this line."))
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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 ili", substrs = ['[1] = 2','[4] = 5']) self.expect("frame variable ili", substrs = ['[1] = 2','[4] = 5'])
self.expect("frame variable ils", substrs = ['[4] = "surprise it is a long string!! yay!!"']) self.expect("frame variable ils", substrs = ['[4] = "surprise it is a long string!! yay!!"'])
self.expect('image list', substrs = self.getLibcPlusPlusLibs()) self.expect('image list', substrs = self.getLibcPlusPlusLibs())
if __name__ == '__main__': if __name__ == '__main__':
import atexit import atexit
lldb.SBDebugger.Initialize() lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate()) atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main() unittest2.main()

test/functionalities/data-formatter/data-formatter-stl/libcxx/iterator/TestDataFormatterLibccIterator.py

Show All 33 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 data_formatter_commands(self): def data_formatter_commands(self):
"""Test that libc++ iterators format properly.""" """Test that libc++ iterators format properly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
Show All 29 Lines

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

Show All 35 Linesclass LibcxxListDataFormatterTestCase(TestBase):
def data_formatter_commands(self): def data_formatter_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line2, num_expected_locations=-1) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line2, num_expected_locations=-1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
▲ Show 20 Lines • Show All 128 Lines • Show Last 20 Lines

test/functionalities/data-formatter/data-formatter-stl/libcxx/map/TestDataFormatterLibccMap.py

Show All 31 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
def data_formatter_commands(self): def data_formatter_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
bkpt = self.target().FindBreakpointByID(lldbutil.run_break_set_by_source_regexp (self, "Set break point at this line.")) bkpt = self.target().FindBreakpointByID(lldbutil.run_break_set_by_source_regexp (self, "Set break point at this line."))
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
▲ Show 20 Lines • Show All 267 Lines • Show Last 20 Lines

test/functionalities/data-formatter/data-formatter-stl/libcxx/multimap/TestDataFormatterLibccMultiMap.py

Show All 31 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
def data_formatter_commands(self): def data_formatter_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
bkpt = self.target().FindBreakpointByID(lldbutil.run_break_set_by_source_regexp (self, "Set break point at this line.")) bkpt = self.target().FindBreakpointByID(lldbutil.run_break_set_by_source_regexp (self, "Set break point at this line."))
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
▲ Show 20 Lines • Show All 267 Lines • Show Last 20 Lines

test/functionalities/data-formatter/data-formatter-stl/libcxx/multiset/TestDataFormatterLibcxxMultiSet.py

Show All 31 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
def data_formatter_commands(self): def data_formatter_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
bkpt = self.target().FindBreakpointByID(lldbutil.run_break_set_by_source_regexp (self, "Set break point at this line.")) bkpt = self.target().FindBreakpointByID(lldbutil.run_break_set_by_source_regexp (self, "Set break point at this line."))
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
Show All 38 Lines

test/functionalities/data-formatter/data-formatter-stl/libcxx/set/TestDataFormatterLibcxxSet.py

Show All 31 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
def data_formatter_commands(self): def data_formatter_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
bkpt = self.target().FindBreakpointByID(lldbutil.run_break_set_by_source_regexp (self, "Set break point at this line.")) bkpt = self.target().FindBreakpointByID(lldbutil.run_break_set_by_source_regexp (self, "Set break point at this line."))
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
Show All 38 Lines

test/functionalities/data-formatter/data-formatter-stl/libcxx/string/TestDataFormatterLibcxxString.py

Show All 34 Lines def setUp(self):
self.line = line_number('main.cpp', '// Set break point at this line.') self.line = line_number('main.cpp', '// Set break point at this line.')
def data_formatter_commands(self): def data_formatter_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

test/functionalities/data-formatter/data-formatter-stl/libcxx/unordered/TestDataFormatterUnordered.py

Show All 34 Lines def look_for_content_and_continue(self,var_name,substrs):
self.runCmd("continue") self.runCmd("continue")
def data_formatter_commands(self): def data_formatter_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_source_regexp (self, "Set break point at this line.") lldbutil.run_break_set_by_source_regexp (self, "Set break point at this line.")
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
Show All 24 Lines

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

Show All 33 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 data_formatter_commands(self): def data_formatter_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
Show All 21 Lines

test/functionalities/data-formatter/data-formatter-stl/libcxx/vector/TestDataFormatterLibcxxVector.py

Show All 31 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
def data_formatter_commands(self): def data_formatter_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
bkpt = self.target().FindBreakpointByID(lldbutil.run_break_set_by_source_regexp (self, "break here")) bkpt = self.target().FindBreakpointByID(lldbutil.run_break_set_by_source_regexp (self, "break here"))
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
▲ Show 20 Lines • Show All 149 Lines • Show Last 20 Lines

test/functionalities/data-formatter/data-formatter-stl/libstdcpp/iterator/TestDataFormatterStdIterator.py

Show All 33 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 data_formatter_commands(self): def data_formatter_commands(self):
"""Test that libstdcpp iterators format properly.""" """Test that libstdcpp iterators format properly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
Show All 27 Lines

test/functionalities/data-formatter/data-formatter-stl/libstdcpp/list/TestDataFormatterStdList.py

Show All 34 Lines def setUp(self):
self.final_line = line_number('main.cpp', '// Set final break point at this line.') self.final_line = line_number('main.cpp', '// Set final break point at this line.')
def data_formatter_commands(self): def data_formatter_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
▲ Show 20 Lines • Show All 105 Lines • ▼ Show 20 Lines def data_formatter_commands(self):
self.runCmd("n") self.runCmd("n")
self.expect("frame variable text_list", self.expect("frame variable text_list",
substrs = ['size=0', substrs = ['size=0',
'{}']) '{}'])
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.final_line, num_expected_locations=-1) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.final_line, num_expected_locations=-1)
self.runCmd("c", RUN_SUCCEEDED) self.runCmd("c", RUN_FAILED)
# 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 text_list", self.expect("frame variable text_list",
substrs = ['size=4', substrs = ['size=4',
Show All 30 Lines

test/functionalities/data-formatter/data-formatter-stl/libstdcpp/map/TestDataFormatterStdMap.py

Show All 34 Lines def setUp(self):
self.line = line_number('main.cpp', '// Set break point at this line.') self.line = line_number('main.cpp', '// Set break point at this line.')
def data_formatter_commands(self): def data_formatter_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_source_regexp (self, "Set break point at this line.") lldbutil.run_break_set_by_source_regexp (self, "Set break point at this line.")
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
▲ Show 20 Lines • Show All 286 Lines • Show Last 20 Lines

test/functionalities/data-formatter/data-formatter-stl/libstdcpp/string/TestDataFormatterStdString.py

Show All 33 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 data_formatter_commands(self): def data_formatter_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
Show All 31 Lines

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

Show All 36 Linesclass StdVBoolDataFormatterTestCase(TestBase):
@expectedFailureIcc # llvm.org/pr15301: lldb does not print the correct sizes of STL containers when building with ICC @expectedFailureIcc # llvm.org/pr15301: lldb does not print the correct sizes of STL containers when building with ICC
def data_formatter_commands(self): def data_formatter_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
Show All 21 Lines

test/functionalities/data-formatter/data-formatter-stl/libstdcpp/vector/TestDataFormatterStdVector.py

Show All 33 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 data_formatter_commands(self): def data_formatter_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_source_regexp (self, "Set break point at this line.") lldbutil.run_break_set_by_source_regexp (self, "Set break point at this line.")
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
▲ Show 20 Lines • Show All 171 Lines • Show Last 20 Lines

test/functionalities/data-formatter/data-formatter-synth/TestDataFormatterSynth.py

Show All 32 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 data_formatter_commands(self): def data_formatter_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
▲ Show 20 Lines • Show All 167 Lines • Show Last 20 Lines

test/functionalities/data-formatter/data-formatter-synthval/TestDataFormatterSynthVal.py

Show All 33 Lines def setUp(self):
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 using Python synthetic children provider to provide a value.""" """Test using Python synthetic children provider to provide a value."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

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

Show All 33 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 propagate_test_commands(self): def propagate_test_commands(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.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

test/functionalities/data-formatter/frameformat_smallstruct/TestFrameFormatSmallStruct.py

Show All 31 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 data_formatter_commands(self): def data_formatter_commands(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.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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))'])
if __name__ == '__main__': if __name__ == '__main__':
import atexit import atexit
lldb.SBDebugger.Initialize() lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate()) atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main() unittest2.main()

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

Show All 31 Lines def setUp(self):
self.line = line_number('main.cpp', '// Set breakpoint here') self.line = line_number('main.cpp', '// Set breakpoint here')
def data_formatter_commands(self): def data_formatter_commands(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.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
Show All 24 Lines

test/functionalities/data-formatter/rdar-10449092/Test-rdar-10449092.py

Show All 32 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 data_formatter_commands(self): def data_formatter_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

test/functionalities/data-formatter/rdar-10642615/Test-rdar-10642615.py

Show All 33 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 data_formatter_commands(self): def data_formatter_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
Show All 24 Lines

test/functionalities/data-formatter/rdar-10887661/TestRdar10887661.py

Show All 33 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 capping_test_commands(self): def capping_test_commands(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.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

test/functionalities/data-formatter/rdar-11086338/TestRdar11086338.py

Show All 33 Lines def setUp(self):
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 rdar11086338_tester(self): def rdar11086338_tester(self):
"""Test that NSArray reports its synthetic children properly.""" """Test that NSArray reports its synthetic children properly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
Show All 33 Lines

test/functionalities/data-formatter/rdar-11628688/TestFormattersBoolRefPtr.py

Show All 33 Lines def setUp(self):
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 ostype_data_formatter_commands(self): def ostype_data_formatter_commands(self):
"""Test the formatters we use for OSType.""" """Test the formatters we use for OSType."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.mm", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.mm", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
Show All 18 Lines

test/functionalities/data-formatter/rdar-11773899/TestFormattersBoolRefPtr.py

Show All 33 Lines def setUp(self):
self.line = line_number('main.mm', '// Set break point at this line.') self.line = line_number('main.mm', '// Set break point at this line.')
def boolrefptr_data_formatter_commands(self): def boolrefptr_data_formatter_commands(self):
"""Test the formatters we use for BOOL& and BOOL* in Objective-C.""" """Test the formatters we use for BOOL& and BOOL* in Objective-C."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.mm", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.mm", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
Show All 34 Lines

test/functionalities/data-formatter/rdar-11988289/TestRdar 11988289.py

Show All 33 Lines def setUp(self):
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 rdar11988289_tester(self): def rdar11988289_tester(self):
"""Test that NSDictionary reports its synthetic children properly.""" """Test that NSDictionary reports its synthetic children properly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
Show All 35 Lines

test/functionalities/data-formatter/rdar-12437442/TestRdar12437442.py

Show All 33 Lines def setUp(self):
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 rdar12437442_tester(self): def rdar12437442_tester(self):
"""Test that we update SBValues correctly as dynamic types change.""" """Test that we update SBValues correctly as dynamic types change."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
Show All 40 Lines

test/functionalities/data-formatter/rdar-12529957/TestRdar12529957.py

Show All 33 Lines def setUp(self):
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 rdar12529957_tester(self): def rdar12529957_tester(self):
"""Test that NSSet reports its synthetic children properly.""" """Test that NSSet reports its synthetic children properly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
Show All 39 Lines

test/functionalities/data-formatter/rdar-13338477/Test-rdar-13338477.py

Show All 32 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 data_formatter_commands(self): def data_formatter_commands(self):
"""Test that LLDB handles the clang typeclass Paren correctly.""" """Test that LLDB handles the clang typeclass Paren correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
Show All 21 Lines

test/functionalities/data-formatter/rdar-3534688/TestFormattersOneIsSingular.py

Show All 33 Lines def setUp(self):
self.line = line_number('main.m', '// Set break point at this line.') self.line = line_number('main.m', '// Set break point at this line.')
def oneness_data_formatter_commands(self): def oneness_data_formatter_commands(self):
"""Test that 1 item is not as reported as 1 items.""" """Test that 1 item is not as reported as 1 items."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

test/functionalities/data-formatter/rdar-9973865/Test-rdar-9973865.py

Show All 33 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 data_formatter_commands(self): def data_formatter_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
Show All 27 Lines

test/functionalities/data-formatter/rdar-9973992/Test-rdar-9973992.py

Show All 32 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 data_formatter_commands(self): def data_formatter_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

test/functionalities/data-formatter/rdar-9974002/Test-rdar-9974002.py

Show All 35 Lines 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."""
if "clang" in self.getCompiler() and "3.4" in self.getCompilerVersion(): if "clang" in self.getCompiler() and "3.4" in self.getCompilerVersion():
self.skipTest("llvm.org/pr16214 -- clang emits partial DWARF for structures referenced via typedef") self.skipTest("llvm.org/pr16214 -- clang emits partial DWARF for structures referenced via typedef")
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines

test/functionalities/data-formatter/refpointer-recursion/TestDataFormatterRefPtrRecursion.py

Show All 31 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 data_formatter_commands(self): def data_formatter_commands(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.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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']);
if __name__ == '__main__': if __name__ == '__main__':
import atexit import atexit
lldb.SBDebugger.Initialize() lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate()) atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main() unittest2.main()

test/functionalities/data-formatter/user-format-vs-summary/TestUserFormatVsSummary.py

Show All 31 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 data_formatter_commands(self): def data_formatter_commands(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.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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 p1", substrs = ['(Pair) p1 = (x = 3, y = -3)']); self.expect("frame variable p1", substrs = ['(Pair) p1 = (x = 3, y = -3)']);
Show All 26 Lines

test/functionalities/data-formatter/varscript_formatting/TestDataFormatterVarScriptFormatting.py

Show All 33 Lines def setUp(self):
self.line = line_number('main.cpp', ' // Set breakpoint here.') self.line = line_number('main.cpp', ' // Set breakpoint here.')
def data_formatter_commands(self): def data_formatter_commands(self):
"""Test using Python synthetic children provider.""" """Test using Python synthetic children provider."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
Show All 21 Lines

test/functionalities/data-formatter/vector-types/TestVectorTypesFormatting.py

Show All 34 Lines def setUp(self):
self.line = line_number('main.cpp', '// break here') self.line = line_number('main.cpp', '// break here')
def propagate_test_commands(self): def propagate_test_commands(self):
"""Check that vector types format properly""" """Check that vector types format properly"""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
Show All 37 Lines

test/functionalities/dead-strip/TestDeadStrip.py

Show All 34 Lines def dead_strip(self):
lldbutil.run_break_set_by_symbol (self, "f1", num_expected_locations=1, module_name="a.out") lldbutil.run_break_set_by_symbol (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 (self, "f2", num_expected_locations=0, module_name="a.out") lldbutil.run_break_set_by_symbol (self, "f2", num_expected_locations=0, module_name="a.out")
# Break by function name f3 (live code). # Break by function name f3 (live code).
lldbutil.run_break_set_by_symbol (self, "f3", num_expected_locations=1, module_name="a.out") lldbutil.run_break_set_by_symbol (self, "f3", num_expected_locations=1, module_name="a.out")
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# The stop reason of the thread should be breakpoint (breakpoint #1). # The stop reason of the thread should be breakpoint (breakpoint #1).
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped', substrs = ['stopped',
'a.out`f1', 'a.out`f1',
'stop reason = breakpoint']) 'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1. # The breakpoint should have a hit count of 1.
Show All 21 Lines

test/functionalities/inferior-assert/TestInferiorAssert.py

Show First 20 Lines • Show All 99 Lines • ▼ Show 20 Lines def setUp(self):
# Find the line number of the call to assert. # Find the line number of the call to assert.
self.line = line_number('main.c', '// Assert here.') self.line = line_number('main.c', '// Assert here.')
def inferior_asserting(self): def inferior_asserting(self):
"""Inferior asserts upon launching; lldb should catch the event and stop.""" """Inferior asserts upon launching; lldb should catch the event and stop."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
stop_reason = self.check_stop_reason() stop_reason = self.check_stop_reason()
# And it should report a backtrace that includes the assert site. # And it should report a backtrace that includes the assert site.
self.expect("thread backtrace all", self.expect("thread backtrace all",
substrs = [stop_reason, 'main', 'argc', 'argv']) substrs = [stop_reason, 'main', 'argc', 'argv'])
# And it should report the correct line number. # And it should report the correct line number.
self.expect("thread backtrace all", self.expect("thread backtrace all",
Show All 23 Lines def inferior_asserting_python(self):
if self.TraceOn(): if self.TraceOn():
lldbutil.print_stacktrace(thread) lldbutil.print_stacktrace(thread)
def inferior_asserting_registers(self): def inferior_asserting_registers(self):
"""Test that lldb can read registers after asserting.""" """Test that lldb can read registers after asserting."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
self.check_stop_reason() self.check_stop_reason()
# lldb should be able to read from registers from the inferior after asserting. # lldb should be able to read from registers from the inferior after asserting.
lldbplatformutil.check_first_register_readable(self) lldbplatformutil.check_first_register_readable(self)
def inferior_asserting_disassemble(self): def inferior_asserting_disassemble(self):
"""Test that lldb can disassemble frames after asserting.""" """Test that lldb can disassemble frames after asserting."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
Show All 11 Lines def inferior_asserting_disassemble(self):
thread = process.GetThreadAtIndex(0) thread = process.GetThreadAtIndex(0)
self.assertTrue(thread.IsValid(), "current thread is valid") self.assertTrue(thread.IsValid(), "current thread is valid")
# lldb should be able to disassemble frames from the inferior after asserting. # lldb should be able to disassemble frames from the inferior after asserting.
for frame in thread: for frame in thread:
self.assertTrue(frame.IsValid(), "current frame is valid") self.assertTrue(frame.IsValid(), "current frame is valid")
self.runCmd("frame select " + str(frame.GetFrameID()), RUN_SUCCEEDED) self.runCmd("frame select " + str(frame.GetFrameID()), RUN_FAILED)
# Don't expect the function name to be in the disassembly as the assert # Don't expect the function name to be in the disassembly as the assert
# function might be a no-return function where the PC is past the end # function might be a no-return function where the PC is past the end
# of the function and in the next function. We also can't back the PC up # of the function and in the next function. We also can't back the PC up
# because we don't know how much to back it up by on targets with opcodes # because we don't know how much to back it up by on targets with opcodes
# that have differing sizes # that have differing sizes
pc_backup_offset = 1 pc_backup_offset = 1
if frame.GetFrameID() == 0: if frame.GetFrameID() == 0:
pc_backup_offset = 0 pc_backup_offset = 0
self.expect("disassemble -a %s" % (frame.GetPC() - pc_backup_offset), self.expect("disassemble -a %s" % (frame.GetPC() - pc_backup_offset),
substrs = ['<+0>: ']) substrs = ['<+0>: '])
def check_expr_in_main(self, thread): def check_expr_in_main(self, thread):
depth = thread.GetNumFrames() depth = thread.GetNumFrames()
for i in range(depth): for i in range(depth):
frame = thread.GetFrameAtIndex(i) frame = thread.GetFrameAtIndex(i)
self.assertTrue(frame.IsValid(), "current frame is valid") self.assertTrue(frame.IsValid(), "current frame is valid")
if self.TraceOn(): if self.TraceOn():
print "Checking if function %s is main" % frame.GetFunctionName() print "Checking if function %s is main" % frame.GetFunctionName()
if 'main' == frame.GetFunctionName(): if 'main' == frame.GetFunctionName():
frame_id = frame.GetFrameID() frame_id = frame.GetFrameID()
self.runCmd("frame select " + str(frame_id), RUN_SUCCEEDED) self.runCmd("frame select " + str(frame_id), RUN_FAILED)
self.expect("p argc", substrs = ['(int)', ' = 1']) self.expect("p argc", substrs = ['(int)', ' = 1'])
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):
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

test/functionalities/inferior-changed/TestInferiorChanged.py

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines def setUp(self):
self.line1 = line_number('main.c', '// Crash here.') self.line1 = line_number('main.c', '// Crash here.')
self.line2 = line_number('main2.c', '// Not crash here.') self.line2 = line_number('main2.c', '// Not crash here.')
def inferior_crashing(self): def inferior_crashing(self):
"""Inferior crashes upon launching; lldb should catch the event and stop.""" """Inferior crashes upon launching; lldb should catch the event and stop."""
self.exe = os.path.join(os.getcwd(), "a.out") self.exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + self.exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + self.exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
if self.platformIsDarwin(): if self.platformIsDarwin():
stop_reason = 'stop reason = EXC_BAD_ACCESS' stop_reason = 'stop reason = EXC_BAD_ACCESS'
else: else:
stop_reason = 'stop reason = invalid address' stop_reason = 'stop reason = invalid address'
# The stop reason of the thread should be a bad access exception. # The stop reason of the thread should be a bad access exception.
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.line1]) 'main.c:%d' % self.line1])
def inferior_not_crashing(self): def inferior_not_crashing(self):
"""Test lldb reloads the inferior after it was changed during the session.""" """Test lldb reloads the inferior after it was changed during the session."""
self.runCmd("process kill") self.runCmd("process kill")
# Prod the lldb-platform that we have a newly built inferior ready. # Prod the lldb-platform that we have a newly built inferior ready.
if lldb.lldbtest_remote_sandbox: if lldb.lldbtest_remote_sandbox:
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_FAILED)
self.runCmd("process status") self.runCmd("process status")
if self.platformIsDarwin(): if self.platformIsDarwin():
stop_reason = 'EXC_BAD_ACCESS' stop_reason = 'EXC_BAD_ACCESS'
else: else:
stop_reason = 'invalid address' stop_reason = 'invalid address'
if stop_reason in self.res.GetOutput(): if stop_reason in self.res.GetOutput():
self.fail("Inferior changed, but lldb did not perform a reload") self.fail("Inferior changed, but lldb did not perform a reload")
# Break inside the main. # Break inside the main.
lldbutil.run_break_set_by_file_and_line (self, "main2.c", self.line2, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main2.c", self.line2, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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.runCmd("frame variable int_ptr") self.runCmd("frame variable int_ptr")
self.expect("frame variable *int_ptr", self.expect("frame variable *int_ptr",
Show All 10 Lines

test/functionalities/inferior-crashing/TestInferiorCrashing.py

Show First 20 Lines • Show All 109 Lines • ▼ Show 20 Lines def setUp(self):
# Find the line number of the crash. # Find the line number of the crash.
self.line = line_number('main.c', '// Crash here.') self.line = line_number('main.c', '// Crash here.')
def inferior_crashing(self): def inferior_crashing(self):
"""Inferior crashes upon launching; lldb should catch the event and stop.""" """Inferior crashes upon launching; lldb should catch the event and stop."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
stop_reason = self.check_stop_reason() stop_reason = self.check_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):
Show All 19 Lines def inferior_crashing_python(self):
if self.TraceOn(): if self.TraceOn():
lldbutil.print_stacktrace(thread) lldbutil.print_stacktrace(thread)
def inferior_crashing_registers(self): def inferior_crashing_registers(self):
"""Test that lldb can read registers after crashing.""" """Test that lldb can read registers after crashing."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
self.check_stop_reason() self.check_stop_reason()
# lldb should be able to read from registers from the inferior after crashing. # lldb should be able to read from registers from the inferior after crashing.
lldbplatformutil.check_first_register_readable(self) lldbplatformutil.check_first_register_readable(self)
def inferior_crashing_expr(self): def inferior_crashing_expr(self):
"""Test that the lldb expression interpreter can read symbols after crashing.""" """Test that the lldb expression interpreter can read symbols after crashing."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
self.check_stop_reason() self.check_stop_reason()
# The lldb expression interpreter should be able to read from addresses of the inferior after a crash. # The lldb expression interpreter should be able to read from addresses of the inferior after a crash.
self.expect("p argc", self.expect("p argc",
startstr = '(int) $0 = 1') startstr = '(int) $0 = 1')
self.expect("p hello_world", self.expect("p hello_world",
substrs = ['Hello']) substrs = ['Hello'])
def inferior_crashing_step(self): def inferior_crashing_step(self):
"""Test that lldb functions correctly after stepping through a crash.""" """Test that lldb functions correctly after stepping through a crash."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.set_breakpoint(self.line) self.set_breakpoint(self.line)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['main.c:%d' % self.line, substrs = ['main.c:%d' % self.line,
'stop reason = breakpoint']) 'stop reason = breakpoint'])
self.runCmd("next") self.runCmd("next")
stop_reason = self.check_stop_reason() stop_reason = self.check_stop_reason()
Show All 11 Lines def inferior_crashing_step(self):
substrs = [stop_reason, substrs = [stop_reason,
'main.c:%d' % self.line]) 'main.c:%d' % self.line])
def inferior_crashing_step_after_break(self): def inferior_crashing_step_after_break(self):
"""Test that lldb behaves correctly when stepping after a crash.""" """Test that lldb behaves correctly when stepping after a crash."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
self.check_stop_reason() self.check_stop_reason()
self.runCmd("next") self.runCmd("next")
self.check_stop_reason() self.check_stop_reason()
def inferior_crashing_expr_step_expr(self): def inferior_crashing_expr_step_expr(self):
"""Test that lldb expressions work before and after stepping after a crash.""" """Test that lldb expressions work before and after stepping after a crash."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
self.check_stop_reason() self.check_stop_reason()
# The lldb expression interpreter should be able to read from addresses of the inferior after a crash. # The lldb expression interpreter should be able to read from addresses of the inferior after a crash.
self.expect("p argv[0]", self.expect("p argv[0]",
substrs = ['a.out']) substrs = ['a.out'])
self.runCmd("next") self.runCmd("next")
self.check_stop_reason() self.check_stop_reason()
Show All 11 Lines

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

Show First 20 Lines • Show All 105 Lines • ▼ Show 20 Lines def setUp(self):
# Find the line number of the crash. # Find the line number of the crash.
self.line = line_number('main.c', '// Crash here.') self.line = line_number('main.c', '// Crash here.')
def recursive_inferior_crashing(self): def recursive_inferior_crashing(self):
"""Inferior crashes upon launching; lldb should catch the event and stop.""" """Inferior crashes upon launching; lldb should catch the event and stop."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
stop_reason = self.check_stop_reason() stop_reason = self.check_stop_reason()
# And it should report a backtrace that includes main and the crash site. # And it should report a backtrace that includes main and the crash site.
self.expect("thread backtrace all", self.expect("thread backtrace all",
substrs = [stop_reason, 'main', 'argc', 'argv', 'recursive_function']) substrs = [stop_reason, 'main', 'argc', 'argv', 'recursive_function'])
# 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",
Show All 23 Lines def recursive_inferior_crashing_python(self):
if self.TraceOn(): if self.TraceOn():
lldbutil.print_stacktrace(thread) lldbutil.print_stacktrace(thread)
def recursive_inferior_crashing_registers(self): def recursive_inferior_crashing_registers(self):
"""Test that lldb can read registers after crashing.""" """Test that lldb can read registers after crashing."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
self.check_stop_reason() self.check_stop_reason()
# lldb should be able to read from registers from the inferior after crashing. # lldb should be able to read from registers from the inferior after crashing.
lldbplatformutil.check_first_register_readable(self) lldbplatformutil.check_first_register_readable(self)
def recursive_inferior_crashing_expr(self): def recursive_inferior_crashing_expr(self):
"""Test that the lldb expression interpreter can read symbols after crashing.""" """Test that the lldb expression interpreter can read symbols after crashing."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
self.check_stop_reason() self.check_stop_reason()
# The lldb expression interpreter should be able to read from addresses of the inferior after a crash. # The lldb expression interpreter should be able to read from addresses of the inferior after a crash.
self.expect("p i", self.expect("p i",
startstr = '(int) $0 =') startstr = '(int) $0 =')
def recursive_inferior_crashing_step(self): def recursive_inferior_crashing_step(self):
"""Test that lldb functions correctly after stepping through a crash.""" """Test that lldb functions correctly after stepping through a crash."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.set_breakpoint(self.line) self.set_breakpoint(self.line)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['main.c:%d' % self.line, substrs = ['main.c:%d' % self.line,
'stop reason = breakpoint']) 'stop reason = breakpoint'])
self.runCmd("next") self.runCmd("next")
stop_reason = self.check_stop_reason() stop_reason = self.check_stop_reason()
Show All 9 Lines def recursive_inferior_crashing_step(self):
substrs = [stop_reason, substrs = [stop_reason,
'main.c:%d' % self.line]) 'main.c:%d' % self.line])
def recursive_inferior_crashing_step_after_break(self): def recursive_inferior_crashing_step_after_break(self):
"""Test that lldb behaves correctly when stepping after a crash.""" """Test that lldb behaves correctly when stepping after a crash."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
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() or self.getPlatform() == "linux": if self.platformIsDarwin() or self.getPlatform() == "linux":
expected_state = 'stopped' # TODO: Determine why 'next' and 'continue' have no effect after a crash. expected_state = 'stopped' # TODO: Determine why 'next' and 'continue' have no effect after a crash.
self.expect("next", self.expect("next",
substrs = ['Process', expected_state]) substrs = ['Process', expected_state])
if expected_state == 'exited': if expected_state == 'exited':
self.expect("thread list", error=True,substrs = ['Process must be launched']) self.expect("thread list", error=True,substrs = ['Process must be launched'])
else: else:
self.check_stop_reason() self.check_stop_reason()
def recursive_inferior_crashing_expr_step_expr(self): def recursive_inferior_crashing_expr_step_expr(self):
"""Test that lldb expressions work before and after stepping after a crash.""" """Test that lldb expressions work before and after stepping after a crash."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
self.check_stop_reason() self.check_stop_reason()
# The lldb expression interpreter should be able to read from addresses of the inferior after a crash. # The lldb expression interpreter should be able to read from addresses of the inferior after a crash.
self.expect("p null", self.expect("p null",
startstr = '(char *) $0 = 0x0') startstr = '(char *) $0 = 0x0')
self.runCmd("next") self.runCmd("next")
Show All 11 Lines

test/functionalities/load_unload/TestLoadUnload.py

Show First 20 Lines • Show All 151 Lines • ▼ Show 20 Lines def test_lldb_process_load_and_unload_commands(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break at main.c before the call to dlopen(). # Break at main.c 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 (self, "main.c", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# Make sure that a_function does not exist at this point. # Make sure that a_function does not exist at this point.
self.expect("image lookup -n a_function", "a_function should not exist yet", self.expect("image lookup -n a_function", "a_function should not exist yet",
error=True, matching=False, error=True, matching=False,
patterns = ["1 match found .* %s" % self.mydir]) patterns = ["1 match found .* %s" % self.mydir])
if self.platformIsDarwin(): if self.platformIsDarwin():
dylibName = 'libloadunload_a.dylib' dylibName = 'libloadunload_a.dylib'
Show All 34 Lines def test_load_unload(self):
self.buildDefault() self.buildDefault()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break by function name a_function (not yet loaded). # Break by function name a_function (not yet loaded).
lldbutil.run_break_set_by_symbol (self, "a_function", num_expected_locations=0) lldbutil.run_break_set_by_symbol (self, "a_function", num_expected_locations=0)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# The stop reason of the thread should be breakpoint and at a_function. # The stop reason of the thread should be breakpoint and at a_function.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped', substrs = ['stopped',
'a_function', 'a_function',
'stop reason = breakpoint']) 'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1. # The breakpoint should have a hit count of 1.
Show All 24 Lines def test_step_over_load (self):
self.buildDefault() self.buildDefault()
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break by function name a_function (not yet loaded). # Break by function name a_function (not yet loaded).
lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# The stop reason of the thread should be breakpoint and at a_function. # The stop reason of the thread should be breakpoint and at a_function.
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.runCmd("thread step-over", "Stepping over function that loads library") self.runCmd("thread step-over", "Stepping over function that loads library")
Show All 10 Lines

test/functionalities/longjmp/TestLongjmp.py

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Linesclass LongjmpTestCase(TestBase):
def start_test(self, symbol): def start_test(self, symbol):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break in main(). # Break in main().
lldbutil.run_break_set_by_symbol (self, symbol, num_expected_locations=-1) lldbutil.run_break_set_by_symbol (self, symbol, num_expected_locations=-1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
def check_status(self): def check_status(self):
# Note: Depending on the generated mapping of DWARF to assembly, # Note: Depending on the generated mapping of DWARF to assembly,
# the process may have stopped or exited. # the process may have stopped or exited.
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 step_out(self): def step_out(self):
self.start_test("do_jump") self.start_test("do_jump")
self.runCmd("thread step-out", RUN_SUCCEEDED) self.runCmd("thread step-out", RUN_FAILED)
self.check_status() self.check_status()
def step_over(self): def step_over(self):
self.start_test("do_jump") self.start_test("do_jump")
self.runCmd("thread step-over", RUN_SUCCEEDED) self.runCmd("thread step-over", RUN_FAILED)
self.runCmd("thread step-over", RUN_SUCCEEDED) self.runCmd("thread step-over", RUN_FAILED)
self.check_status() self.check_status()
def step_back_out(self): def step_back_out(self):
self.start_test("main") self.start_test("main")
self.runCmd("thread step-over", RUN_SUCCEEDED) self.runCmd("thread step-over", RUN_FAILED)
self.runCmd("thread step-in", RUN_SUCCEEDED) self.runCmd("thread step-in", RUN_FAILED)
self.runCmd("thread step-out", RUN_SUCCEEDED) self.runCmd("thread step-out", RUN_FAILED)
self.check_status() self.check_status()
if __name__ == '__main__': if __name__ == '__main__':
import atexit import atexit
lldb.SBDebugger.Initialize() lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate()) atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main() unittest2.main()

test/functionalities/memory/read/TestMemoryRead.py

Show All 35 Linesclass MemoryReadTestCase(TestBase):
def memory_read_command(self): def memory_read_command(self):
"""Test the 'memory read' command with plain and vector formats.""" """Test the 'memory read' command with plain and vector formats."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break in main() aftre the variables are assigned values. # Break in main() aftre the variables are assigned values.
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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.
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
substrs = [' resolved, hit count = 1']) substrs = [' resolved, hit count = 1'])
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

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

Show All 23 Linesclass NonOverlappingIndexVariableCase(TestBase):
def eval_index_variable_i(self, exe_name): def eval_index_variable_i(self, exe_name):
"""Test expressions of variable 'i' which appears in two for loops.""" """Test expressions of variable 'i' which appears in two for loops."""
exe = os.path.join(os.getcwd(), exe_name) exe = os.path.join(os.getcwd(), exe_name)
self.runCmd("file %s" % exe, CURRENT_EXECUTABLE_SET) self.runCmd("file %s" % exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, self.source, self.line_to_break, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, self.source, self.line_to_break, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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.runCmd('frame variable i') self.runCmd('frame variable i')
self.runCmd('expr i') self.runCmd('expr i')
Show All 10 Lines

test/functionalities/recursion/TestValueObjectRecursion.py

Show All 31 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 recursive_vo_commands(self): def recursive_vo_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
Show All 26 Lines

test/functionalities/register/TestRegisters.py

Show First 20 Lines • Show All 69 Lines • ▼ Show 20 Linesclass RegisterCommandsTestCase(TestBase):
def common_setup(self): def common_setup(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break in main(). # Break in main().
lldbutil.run_break_set_by_symbol (self, "main", num_expected_locations=-1) lldbutil.run_break_set_by_symbol (self, "main", num_expected_locations=-1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
def remove_log(self): def remove_log(self):
""" Remove the temporary log file generated by some tests.""" """ Remove the temporary log file generated by some tests."""
if os.path.exists(self.log_file): if os.path.exists(self.log_file):
Show All 10 Lines def log_enable(self, category):
if sys.platform.startswith("freebsd"): if sys.platform.startswith("freebsd"):
self.platform = "freebsd" self.platform = "freebsd"
if sys.platform.startswith("linux"): if sys.platform.startswith("linux"):
self.platform = "linux" self.platform = "linux"
if self.platform != "": if self.platform != "":
self.log_file = os.path.join(os.getcwd(), 'TestRegisters.log') self.log_file = os.path.join(os.getcwd(), 'TestRegisters.log')
self.runCmd("log enable " + self.platform + " " + str(category) + " registers -v -f " + self.log_file, RUN_SUCCEEDED) self.runCmd("log enable " + self.platform + " " + str(category) + " registers -v -f " + self.log_file, RUN_FAILED)
if not self.has_teardown: if not self.has_teardown:
self.has_teardown = True self.has_teardown = True
self.addTearDownHook(self.remove_log) self.addTearDownHook(self.remove_log)
def register_commands(self): def register_commands(self):
"""Test commands related to registers, in particular vector registers.""" """Test commands related to registers, in particular vector registers."""
self.common_setup() self.common_setup()
▲ Show 20 Lines • Show All 171 Lines • Show Last 20 Lines

test/functionalities/set-data/TestSetData.py

Show All 21 Linesclass SetDataTestCase(TestBase):
def setData(self): def setData(self):
"""Test setting objc breakpoints using '_regexp-break' and 'breakpoint set'.""" """Test setting objc breakpoints using '_regexp-break' and 'breakpoint set'."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("br s -p First"); self.runCmd("br s -p First");
self.runCmd("br s -p Second"); self.runCmd("br s -p Second");
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
self.expect("p myFoo.x", VARIABLES_DISPLAYED_CORRECTLY, self.expect("p myFoo.x", VARIABLES_DISPLAYED_CORRECTLY,
substrs = ['2']) substrs = ['2'])
process = self.dbg.GetSelectedTarget().GetProcess() process = self.dbg.GetSelectedTarget().GetProcess()
frame = process.GetSelectedThread().GetFrameAtIndex(0) frame = process.GetSelectedThread().GetFrameAtIndex(0)
x = frame.FindVariable("myFoo").GetChildMemberWithName("x") x = frame.FindVariable("myFoo").GetChildMemberWithName("x")
Show All 32 Lines

test/functionalities/target_command/TestTargetCommand.py

Show First 20 Lines • Show All 76 Lines • ▼ Show 20 Lines def do_target_command(self):
match = pattern.search(line) match = pattern.search(line)
if match: if match:
# We will start from (index + 1) .... # We will start from (index + 1) ....
base = int(match.group(1), 10) + 1 base = int(match.group(1), 10) + 1
#print "base is:", base #print "base is:", base
break; break;
self.runCmd("target create " + exe_a, CURRENT_EXECUTABLE_SET) self.runCmd("target create " + exe_a, CURRENT_EXECUTABLE_SET)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
self.runCmd("target create " + exe_b, CURRENT_EXECUTABLE_SET) self.runCmd("target create " + exe_b, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, 'b.c', self.line_b, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, 'b.c', self.line_b, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
self.runCmd("target create " + exe_c, CURRENT_EXECUTABLE_SET) self.runCmd("target create " + exe_c, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, 'c.c', self.line_c, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, 'c.c', self.line_c, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
self.runCmd("target list") self.runCmd("target list")
self.runCmd("target select %d" % base) self.runCmd("target select %d" % base)
self.runCmd("thread backtrace") self.runCmd("thread backtrace")
self.runCmd("target select %d" % (base + 2)) self.runCmd("target select %d" % (base + 2))
self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT,
▲ Show 20 Lines • Show All 106 Lines • Show Last 20 Lines

test/functionalities/thread/TestNumThreads.py

Show All 38 Lines def number_of_threads_test(self):
# This should create a breakpoint with 1 location. # This should create a breakpoint with 1 location.
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1)
# The breakpoint list should show 3 locations. # The breakpoint list should show 3 locations.
self.expect("breakpoint list -f", "Breakpoint location shown correctly", self.expect("breakpoint list -f", "Breakpoint location shown correctly",
substrs = ["1: file = 'main.cpp', line = %d, exact_match = 0, locations = 1" % self.line]) substrs = ["1: file = 'main.cpp', line = %d, exact_match = 0, locations = 1" % self.line])
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# Stopped once. # Stopped once.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ["stop reason = breakpoint 1."]) substrs = ["stop reason = breakpoint 1."])
# Get the target process # Get the target process
target = self.dbg.GetSelectedTarget() target = self.dbg.GetSelectedTarget()
process = target.GetProcess() process = target.GetProcess()
Show All 13 Lines

test/functionalities/thread/break_after_join/TestBreakAfterJoin.py

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Lines def breakpoint_after_join_test(self):
# 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 (self, "main.cpp", self.breakpoint, num_expected_locations=1) lldbutil.run_break_set_by_file_and_line (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("breakpoint list -f", "Breakpoint location shown correctly", self.expect("breakpoint list -f", "Breakpoint location shown correctly",
substrs = ["1: file = 'main.cpp', line = %d, locations = 1" % self.breakpoint]) substrs = ["1: file = 'main.cpp', line = %d, locations = 1" % self.breakpoint])
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# Get the target process # Get the target process
target = self.dbg.GetSelectedTarget() target = self.dbg.GetSelectedTarget()
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

test/functionalities/thread/concurrent_events/TestConcurrentEvents.py

Show First 20 Lines • Show All 419 Lines • ▼ Show 20 Lines def do_thread_actions(self,
# Set the thread breakpoint # Set the thread breakpoint
if num_breakpoint_threads + num_delay_breakpoint_threads > 0: if num_breakpoint_threads + num_delay_breakpoint_threads > 0:
self.thread_breakpoint = self.add_breakpoint(self.thread_breakpoint_line, expected_bps) self.thread_breakpoint = self.add_breakpoint(self.thread_breakpoint_line, expected_bps)
# Verify breakpoints # Verify breakpoints
self.expect("breakpoint list -f", "Breakpoint locations shown correctly", substrs = expected_bps) self.expect("breakpoint list -f", "Breakpoint locations shown correctly", substrs = expected_bps)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# Check we are at line self.setup_breakpoint # Check we are at line self.setup_breakpoint
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."])
# Initialize the (single) watchpoint on the global variable (g_watchme) # Initialize the (single) watchpoint on the global variable (g_watchme)
if num_watchpoint_threads + num_delay_watchpoint_threads > 0: if num_watchpoint_threads + num_delay_watchpoint_threads > 0:
self.runCmd("watchpoint set variable g_watchme") self.runCmd("watchpoint set variable g_watchme")
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

test/functionalities/thread/create_during_step/TestCreateDuringStep.py

Show First 20 Lines • Show All 89 Lines • ▼ Show 20 Lines def create_during_step_base(self, step_cmd, step_stop_reason):
# This should create a breakpoint in the stepping thread. # This should create a breakpoint in the stepping thread.
self.bp_num = lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.breakpoint, num_expected_locations=1) self.bp_num = lldbutil.run_break_set_by_file_and_line (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("breakpoint list -f", "Breakpoint location shown correctly", self.expect("breakpoint list -f", "Breakpoint location shown correctly",
substrs = ["1: file = 'main.cpp', line = %d, locations = 1" % self.breakpoint]) substrs = ["1: file = 'main.cpp', line = %d, locations = 1" % self.breakpoint])
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# Get the target process # Get the target process
target = self.dbg.GetSelectedTarget() target = self.dbg.GetSelectedTarget()
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

test/functionalities/thread/exit_during_break/TestExitDuringBreak.py

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Lines def exit_during_breakpoint_test(self):
# 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 (self, "main.cpp", self.breakpoint, num_expected_locations=1) lldbutil.run_break_set_by_file_and_line (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("breakpoint list -f", "Breakpoint location shown correctly", self.expect("breakpoint list -f", "Breakpoint location shown correctly",
substrs = ["1: file = 'main.cpp', line = %d, locations = 1" % self.breakpoint]) substrs = ["1: file = 'main.cpp', line = %d, locations = 1" % self.breakpoint])
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# Get the target process # Get the target process
target = self.dbg.GetSelectedTarget() target = self.dbg.GetSelectedTarget()
Show All 37 Lines

test/functionalities/thread/exit_during_step/TestExitDuringStep.py

Show First 20 Lines • Show All 103 Lines • ▼ Show 20 Lines def exit_during_step_base(self, step_cmd, step_stop_reason, test_thread_state):
# 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, "main.cpp", self.breakpoint, num_expected_locations=1) self.bp_num = lldbutil.run_break_set_by_file_and_line (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("breakpoint list -f", "Breakpoint location shown correctly", self.expect("breakpoint list -f", "Breakpoint location shown correctly",
substrs = ["1: file = 'main.cpp', line = %d, exact_match = 0, locations = 1" % self.breakpoint]) substrs = ["1: file = 'main.cpp', line = %d, exact_match = 0, locations = 1" % self.breakpoint])
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# Get the target process # Get the target process
target = self.dbg.GetSelectedTarget() target = self.dbg.GetSelectedTarget()
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

test/functionalities/thread/jump/TestThreadJump.py

Show All 40 Lines def thread_jump_test(self):
# 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')
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.mark3, num_expected_locations=1) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.mark3, num_expected_locations=1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# The stop reason of the thread should be breakpoint 1. # The stop reason of the thread should be breakpoint 1.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT + " 1", self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT + " 1",
substrs = ['stopped', substrs = ['stopped',
'* thread #1', '* thread #1',
'stop reason = breakpoint 1']) 'stop reason = breakpoint 1'])
self.do_min_test(self.mark3, self.mark1, "i", "4"); # Try the int path, force it to return 'a' self.do_min_test(self.mark3, self.mark1, "i", "4"); # Try the int path, force it to return 'a'
Show All 18 Lines

test/functionalities/thread/multi_break/TestMultipleBreakpoints.py

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Lines def multiple_breakpoint_test(self):
# 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 (self, "main.cpp", self.breakpoint, num_expected_locations=1) lldbutil.run_break_set_by_file_and_line (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("breakpoint list -f", "Breakpoint location shown correctly", self.expect("breakpoint list -f", "Breakpoint location shown correctly",
substrs = ["1: file = 'main.cpp', line = %d, locations = 1" % self.breakpoint]) substrs = ["1: file = 'main.cpp', line = %d, locations = 1" % self.breakpoint])
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
# The breakpoint may be hit in either thread 2 or thread 3. # The breakpoint may be hit in either thread 2 or thread 3.
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'])
# Get the target process # Get the target process
Show All 33 Lines

test/functionalities/thread/state/TestThreadStates.py

Show First 20 Lines • Show All 99 Lines • ▼ Show 20 Lines def thread_state_after_breakpoint_test(self):
# 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 (self, "main.c", self.break_1, num_expected_locations=1) lldbutil.run_break_set_by_file_and_line (self, "main.c", self.break_1, num_expected_locations=1)
# The breakpoint list should show 1 breakpoint with 1 location. # The breakpoint list should show 1 breakpoint with 1 location.
self.expect("breakpoint list -f", "Breakpoint location shown correctly", self.expect("breakpoint list -f", "Breakpoint location shown correctly",
substrs = ["1: file = 'main.c', line = %d, locations = 1" % self.break_1]) substrs = ["1: file = 'main.c', line = %d, locations = 1" % self.break_1])
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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',
'* thread #1', '* thread #1',
'stop reason = breakpoint']) 'stop reason = breakpoint'])
# Get the target process # Get the target process
Show All 24 Lines def thread_state_after_continue_test(self):
lldbutil.run_break_set_by_file_and_line (self, "main.c", self.break_1, num_expected_locations=1) lldbutil.run_break_set_by_file_and_line (self, "main.c", self.break_1, num_expected_locations=1)
lldbutil.run_break_set_by_file_and_line (self, "main.c", self.break_2, num_expected_locations=1) lldbutil.run_break_set_by_file_and_line (self, "main.c", self.break_2, num_expected_locations=1)
# The breakpoint list should show 1 breakpoints with 1 location. # The breakpoint list should show 1 breakpoints with 1 location.
self.expect("breakpoint list -f", "Breakpoint location shown correctly", self.expect("breakpoint list -f", "Breakpoint location shown correctly",
substrs = ["1: file = 'main.c', line = %d, exact_match = 0, locations = 1" % self.break_1]) substrs = ["1: file = 'main.c', line = %d, exact_match = 0, locations = 1" % self.break_1])
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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',
'* thread #1', '* thread #1',
'stop reason = breakpoint']) 'stop reason = breakpoint'])
# Get the target process # Get the target process
Show All 32 Lines def thread_state_after_expression_test(self):
lldbutil.run_break_set_by_file_and_line (self, "main.c", self.break_1, num_expected_locations=1) lldbutil.run_break_set_by_file_and_line (self, "main.c", self.break_1, num_expected_locations=1)
lldbutil.run_break_set_by_file_and_line (self, "main.c", self.break_2, num_expected_locations=1) lldbutil.run_break_set_by_file_and_line (self, "main.c", self.break_2, num_expected_locations=1)
# The breakpoint list should show 1 breakpoints with 1 location. # The breakpoint list should show 1 breakpoints with 1 location.
self.expect("breakpoint list -f", "Breakpoint location shown correctly", self.expect("breakpoint list -f", "Breakpoint location shown correctly",
substrs = ["1: file = 'main.c', line = %d, locations = 1" % self.break_1]) substrs = ["1: file = 'main.c', line = %d, locations = 1" % self.break_1])
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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',
'* thread #1', '* thread #1',
'stop reason = breakpoint']) 'stop reason = breakpoint'])
# Get the target process # Get the target process
Show All 27 Lines def process_interrupt_test(self):
# 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 (self, "main.c", self.break_1, num_expected_locations=1) lldbutil.run_break_set_by_file_and_line (self, "main.c", self.break_1, num_expected_locations=1)
# The breakpoint list should show 1 breakpoints with 1 location. # The breakpoint list should show 1 breakpoints with 1 location.
self.expect("breakpoint list -f", "Breakpoint location shown correctly", self.expect("breakpoint list -f", "Breakpoint location shown correctly",
substrs = ["1: file = 'main.c', line = %d, locations = 1" % self.break_1]) substrs = ["1: file = 'main.c', line = %d, locations = 1" % self.break_1])
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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',
'* thread #1', '* thread #1',
'stop reason = breakpoint']) 'stop reason = breakpoint'])
# Get the target process # Get the target process
Show All 38 Lines def thread_states_test(self):
lldbutil.run_break_set_by_file_and_line (self, "main.c", self.break_2, num_expected_locations=1) lldbutil.run_break_set_by_file_and_line (self, "main.c", self.break_2, num_expected_locations=1)
# The breakpoint list should show 2 breakpoints with 1 location each. # The breakpoint list should show 2 breakpoints with 1 location each.
self.expect("breakpoint list -f", "Breakpoint location shown correctly", self.expect("breakpoint list -f", "Breakpoint location shown correctly",
substrs = ["1: file = 'main.c', line = %d, locations = 1" % self.break_1, substrs = ["1: file = 'main.c', line = %d, locations = 1" % self.break_1,
"2: file = 'main.c', line = %d, locations = 1" % self.break_2]) "2: file = 'main.c', line = %d, locations = 1" % self.break_2])
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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',
'* thread #1', '* thread #1',
'stop reason = breakpoint']) 'stop reason = breakpoint'])
# Get the target process # Get the target process
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

test/functionalities/thread/step_out/TestThreadStepOut.py

Show First 20 Lines • Show All 107 Lines • ▼ Show 20 Lines def step_out_test(self, step_out_func):
# 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 (self, "main.cpp", self.breakpoint, num_expected_locations=1) lldbutil.run_break_set_by_file_and_line (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("breakpoint list -f", "Breakpoint location shown correctly", self.expect("breakpoint list -f", "Breakpoint location shown correctly",
substrs = ["1: file = 'main.cpp', line = %d, exact_match = 0, locations = 1" % self.breakpoint]) substrs = ["1: file = 'main.cpp', line = %d, exact_match = 0, locations = 1" % self.breakpoint])
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# Get the target process # Get the target process
self.inferior_target = self.dbg.GetSelectedTarget() self.inferior_target = self.dbg.GetSelectedTarget()
self.inferior_process = self.inferior_target.GetProcess() self.inferior_process = self.inferior_target.GetProcess()
# Get the number of threads, ensure we see all three. # Get the number of threads, ensure we see all three.
num_threads = self.inferior_process.GetNumThreads() num_threads = self.inferior_process.GetNumThreads()
self.assertEqual(num_threads, 3, 'Number of expected threads and actual threads do not match.') self.assertEqual(num_threads, 3, 'Number of expected threads and actual threads do not match.')
Show All 28 Lines

test/functionalities/thread/thread_exit/TestThreadExit.py

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines def thread_exit_test(self):
# The breakpoint list should show 1 locations. # The breakpoint list should show 1 locations.
self.expect("breakpoint list -f", "Breakpoint location shown correctly", self.expect("breakpoint list -f", "Breakpoint location shown correctly",
substrs = ["1: file = 'main.cpp', line = %d, exact_match = 0, locations = 1" % self.break_1, substrs = ["1: file = 'main.cpp', line = %d, exact_match = 0, locations = 1" % self.break_1,
"2: file = 'main.cpp', line = %d, exact_match = 0, locations = 1" % self.break_2, "2: file = 'main.cpp', line = %d, exact_match = 0, locations = 1" % self.break_2,
"3: file = 'main.cpp', line = %d, exact_match = 0, locations = 1" % self.break_3, "3: file = 'main.cpp', line = %d, exact_match = 0, locations = 1" % self.break_3,
"4: file = 'main.cpp', line = %d, exact_match = 0, locations = 1" % self.break_4]) "4: file = 'main.cpp', line = %d, exact_match = 0, locations = 1" % self.break_4])
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# The stop reason of the thread should be breakpoint 1. # The stop reason of the thread should be breakpoint 1.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT + " 1", self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT + " 1",
substrs = ['stopped', substrs = ['stopped',
'* thread #1', '* thread #1',
'stop reason = breakpoint 1', 'stop reason = breakpoint 1',
'thread #2']) 'thread #2'])
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

test/functionalities/type_completion/TestTypeCompletion.py

Show All 31 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
def type_completion_commands(self): def type_completion_commands(self):
"""Check that types only get completed when necessary.""" """Check that types only get completed when necessary."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_source_regexp (self, "// Set break point at this line.") lldbutil.run_break_set_by_source_regexp (self, "// Set break point at this line.")
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

test/functionalities/value_md5_crash/TestValueMD5Crash.py

Show All 31 Lines def setUp(self):
self.line = line_number('main.cpp', '// break here') self.line = line_number('main.cpp', '// break here')
def doThings(self): def doThings(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.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
value = self.frame().FindVariable("a") value = self.frame().FindVariable("a")
value.SetPreferDynamicValue(lldb.eDynamicCanRunTarget) value.SetPreferDynamicValue(lldb.eDynamicCanRunTarget)
Show All 17 Lines

test/functionalities/watchpoint/hello_watchlocation/TestWatchLocation.py

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines def hello_watchlocation(self):
"""Test watching a location with '-s size' option.""" """Test watching a location with '-s size' option."""
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line (self, None, self.line, num_expected_locations=1, loc_exact=False) lldbutil.run_break_set_by_file_and_line (self, None, self.line, num_expected_locations=1, loc_exact=False)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# We should be stopped again due to the breakpoint. # We should be stopped again due to the breakpoint.
# 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'])
# Now let's set a write-type watchpoint pointed to by 'g_char_ptr'. # Now let's set a write-type watchpoint pointed to by 'g_char_ptr'.
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

test/functionalities/watchpoint/hello_watchpoint/TestMyFirstWatchpoint.py

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines def hello_watchpoint(self):
"""Test a simple sequence of watchpoint creation and watchpoint hit.""" """Test a simple sequence of watchpoint creation and watchpoint hit."""
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line (self, None, self.line, num_expected_locations=1) lldbutil.run_break_set_by_file_and_line (self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# We should be stopped again due to the breakpoint. # We should be stopped again due to the breakpoint.
# 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'])
# Now let's set a write-type watchpoint for 'global'. # Now let's set a write-type watchpoint for 'global'.
Show All 36 Lines

test/functionalities/watchpoint/multiple_threads/TestWatchpointMultipleThreads.py

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Linesclass WatchpointForMultipleThreadsTestCase(TestBase):
def hello_multiple_threads(self): def hello_multiple_threads(self):
"""Test that lldb watchpoint works for multiple threads.""" """Test that lldb watchpoint works for multiple threads."""
self.runCmd("file %s" % os.path.join(os.getcwd(), 'a.out'), CURRENT_EXECUTABLE_SET) self.runCmd("file %s" % os.path.join(os.getcwd(), 'a.out'), 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 (self, None, self.first_stop, num_expected_locations=1) lldbutil.run_break_set_by_file_and_line (self, None, self.first_stop, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# We should be stopped again due to the breakpoint. # We should be stopped again due to the breakpoint.
# 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'])
# Now let's set a write-type watchpoint for variable 'g_val'. # Now let's set a write-type watchpoint for variable 'g_val'.
Show All 27 Linesclass WatchpointForMultipleThreadsTestCase(TestBase):
def hello_multiple_threads_wp_set_and_then_delete(self): def hello_multiple_threads_wp_set_and_then_delete(self):
"""Test that lldb watchpoint works for multiple threads, and after the watchpoint is deleted, the watchpoint event should no longer fires.""" """Test that lldb watchpoint works for multiple threads, and after the watchpoint is deleted, the watchpoint event should no longer fires."""
self.runCmd("file %s" % os.path.join(os.getcwd(), 'a.out'), CURRENT_EXECUTABLE_SET) self.runCmd("file %s" % os.path.join(os.getcwd(), 'a.out'), 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 (self, None, self.first_stop, num_expected_locations=1) lldbutil.run_break_set_by_file_and_line (self, None, self.first_stop, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# We should be stopped again due to the breakpoint. # We should be stopped again due to the breakpoint.
# 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'])
# Now let's set a write-type watchpoint for variable 'g_val'. # Now let's set a write-type watchpoint for variable 'g_val'.
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

test/functionalities/watchpoint/variable_out_of_scope/TestWatchedVarHitWhenInScope.py

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines def watched_var(self):
"""Test a simple sequence of watchpoint creation and watchpoint hit.""" """Test a simple sequence of watchpoint creation and watchpoint hit."""
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped in main. # Add a breakpoint to set a watchpoint when stopped in main.
lldbutil.run_break_set_by_symbol (self, "main", num_expected_locations=-1) lldbutil.run_break_set_by_symbol (self, "main", num_expected_locations=-1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# We should be stopped again due to the breakpoint. # We should be stopped again due to the breakpoint.
# 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'])
# Now let's set a watchpoint for 'c.a'. # Now let's set a watchpoint for 'c.a'.
Show All 34 Lines

test/functionalities/watchpoint/watchpoint_commands/TestWatchpointCommands.py

Show First 20 Lines • Show All 104 Lines • ▼ Show 20 Lines def normal_read_write_watchpoint(self):
"""Do read_write watchpoint and expect to stop two times.""" """Do read_write watchpoint and expect to stop two times."""
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line (self, None, self.line, num_expected_locations=1) lldbutil.run_break_set_by_file_and_line (self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# We should be stopped again due to the breakpoint. # We should be stopped again due to the breakpoint.
# 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'])
# Now let's set a read_write-type watchpoint for 'global'. # Now let's set a read_write-type watchpoint for 'global'.
Show All 38 Lines def delete_read_write_watchpoint(self):
"""Do delete watchpoint immediately and expect not to stop for watchpoint.""" """Do delete watchpoint immediately and expect not to stop for watchpoint."""
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line (self, None, self.line, num_expected_locations=1) lldbutil.run_break_set_by_file_and_line (self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# We should be stopped again due to the breakpoint. # We should be stopped again due to the breakpoint.
# 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'])
# Now let's set a read_write-type watchpoint for 'global'. # Now let's set a read_write-type watchpoint for 'global'.
Show All 23 Lines def ignore_read_write_watchpoint(self):
"""Test watchpoint ignore count and expect to not to stop at all.""" """Test watchpoint ignore count and expect to not to stop at all."""
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line (self, None, self.line, num_expected_locations=1) lldbutil.run_break_set_by_file_and_line (self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# We should be stopped again due to the breakpoint. # We should be stopped again due to the breakpoint.
# 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'])
# Now let's set a read_write-type watchpoint for 'global'. # Now let's set a read_write-type watchpoint for 'global'.
Show All 27 Lines def read_write_watchpoint_disable_after_first_stop(self):
"""Do read_write watchpoint but disable it after the first stop.""" """Do read_write watchpoint but disable it after the first stop."""
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line (self, "main.m") lldbutil.run_break_set_by_file_and_line (self, "main.m")
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# We should be stopped again due to the breakpoint. # We should be stopped again due to the breakpoint.
# 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'])
# Now let's set a read_write-type watchpoint for 'global'. # Now let's set a read_write-type watchpoint for 'global'.
Show All 38 Lines def delete_read_write_watchpoint(self):
"""Do delete watchpoint immediately and expect not to stop for watchpoint.""" """Do delete watchpoint immediately and expect not to stop for watchpoint."""
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line (self, None, self.line, num_expected_locations=1) lldbutil.run_break_set_by_file_and_line (self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# We should be stopped again due to the breakpoint. # We should be stopped again due to the breakpoint.
# 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'])
# Now let's set a read_write-type watchpoint for 'global'. # Now let's set a read_write-type watchpoint for 'global'.
Show All 23 Lines def ignore_read_write_watchpoint(self):
"""Test watchpoint ignore count and expect to not to stop at all.""" """Test watchpoint ignore count and expect to not to stop at all."""
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line (self, None, self.line, num_expected_locations=1) lldbutil.run_break_set_by_file_and_line (self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# We should be stopped again due to the breakpoint. # We should be stopped again due to the breakpoint.
# 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'])
# Now let's set a read_write-type watchpoint for 'global'. # Now let's set a read_write-type watchpoint for 'global'.
Show All 27 Lines def read_write_watchpoint_disable_after_first_stop(self):
"""Do read_write watchpoint but disable it after the first stop.""" """Do read_write watchpoint but disable it after the first stop."""
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line (self, None, self.line, num_expected_locations=1) lldbutil.run_break_set_by_file_and_line (self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# We should be stopped again due to the breakpoint. # We should be stopped again due to the breakpoint.
# 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'])
# Now let's set a read_write-type watchpoint for 'global'. # Now let's set a read_write-type watchpoint for 'global'.
Show All 38 Lines def read_write_watchpoint_disable_then_enable(self):
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line (self, None, self.line, num_expected_locations=1) lldbutil.run_break_set_by_file_and_line (self, None, self.line, num_expected_locations=1)
lldbutil.run_break_set_by_file_and_line (self, None, self.line2, num_expected_locations=1) lldbutil.run_break_set_by_file_and_line (self, None, self.line2, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# We should be stopped again due to the breakpoint. # We should be stopped again due to the breakpoint.
# 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'])
# Now let's set a read_write-type watchpoint for 'global'. # Now let's set a read_write-type watchpoint for 'global'.
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

test/functionalities/watchpoint/watchpoint_commands/command/TestWatchpointCommandLLDB.py

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines def watchpoint_command(self):
"""Do 'watchpoint command add'.""" """Do 'watchpoint command add'."""
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line (self, None, self.line, num_expected_locations=1) lldbutil.run_break_set_by_file_and_line (self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# We should be stopped again due to the breakpoint. # We should be stopped again due to the breakpoint.
# 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'])
# Now let's set a write-type watchpoint for 'global'. # Now let's set a write-type watchpoint for 'global'.
Show All 32 Lines def watchpoint_command_can_disable_a_watchpoint(self):
"""Test that 'watchpoint command' action can disable a watchpoint after it is triggered.""" """Test that 'watchpoint command' action can disable a watchpoint after it is triggered."""
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line (self, None, self.line, num_expected_locations=1) lldbutil.run_break_set_by_file_and_line (self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# We should be stopped again due to the breakpoint. # We should be stopped again due to the breakpoint.
# 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'])
# Now let's set a write-type watchpoint for 'global'. # Now let's set a write-type watchpoint for 'global'.
Show All 39 Lines

test/functionalities/watchpoint/watchpoint_commands/command/TestWatchpointCommandPython.py

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines def watchpoint_command(self):
# 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 (self, None, self.line, num_expected_locations=1) lldbutil.run_break_set_by_file_and_line (self, None, self.line, num_expected_locations=1)
# self.expect("breakpoint set -l %d" % self.line, BREAKPOINT_CREATED, # self.expect("breakpoint set -l %d" % self.line, BREAKPOINT_CREATED,
# startstr = "Breakpoint created: 1: file ='%s', line = %d, locations = 1" % # startstr = "Breakpoint created: 1: file ='%s', line = %d, locations = 1" %
# (self.source, self.line))# # (self.source, self.line))#
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# We should be stopped again due to the breakpoint. # We should be stopped again due to the breakpoint.
# 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'])
# Now let's set a write-type watchpoint for 'global'. # Now let's set a write-type watchpoint for 'global'.
Show All 37 Lines

test/functionalities/watchpoint/watchpoint_commands/condition/TestWatchpointConditionCmd.py

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines def watchpoint_condition(self):
"""Do watchpoint condition 'global==5'.""" """Do watchpoint condition 'global==5'."""
exe = os.path.join(os.getcwd(), self.exe_name) exe = os.path.join(os.getcwd(), self.exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line (self, None, self.line, num_expected_locations=1) lldbutil.run_break_set_by_file_and_line (self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# We should be stopped again due to the breakpoint. # We should be stopped again due to the breakpoint.
# 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'])
# Now let's set a write-type watchpoint for 'global'. # Now let's set a write-type watchpoint for 'global'.
Show All 32 Lines

test/functionalities/watchpoint/watchpoint_set_command/TestWatchLocationWithWatchSet.py

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Lines def watchlocation_using_watchpoint_set(self):
"""Test watching a location with '-s size' option.""" """Test watching a location with '-s size' option."""
exe = os.path.join(os.getcwd(), 'a.out') exe = os.path.join(os.getcwd(), 'a.out')
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line (self, None, self.line, num_expected_locations=1) lldbutil.run_break_set_by_file_and_line (self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# We should be stopped again due to the breakpoint. # We should be stopped again due to the breakpoint.
# 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'])
# Now let's set a write-type watchpoint pointed to by 'g_char_ptr' and # Now let's set a write-type watchpoint pointed to by 'g_char_ptr' and
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

test/functionalities/watchpoint/watchpoint_set_command/TestWatchpointSetErrorCases.py

Show All 31 Lines def error_cases_with_watchpoint_set(self):
"""Test error cases with the 'watchpoint set' command.""" """Test error cases with the 'watchpoint set' command."""
exe = os.path.join(os.getcwd(), 'a.out') exe = os.path.join(os.getcwd(), 'a.out')
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line (self, None, self.line, num_expected_locations=1) lldbutil.run_break_set_by_file_and_line (self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# We should be stopped again due to the breakpoint. # We should be stopped again due to the breakpoint.
# 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'])
# Try some error conditions: # Try some error conditions:
Show All 27 Lines

test/lang/c/array_types/TestArrayTypes.py

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Linesclass ArrayTypesTestCase(TestBase):
def array_types(self): def array_types(self):
"""Test 'frame variable var_name' on some variables with array types.""" """Test 'frame variable var_name' on some variables with array types."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, num_expected_locations=1, loc_exact=False) lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, num_expected_locations=1, loc_exact=False)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# The test suite sometimes shows that the process has exited without stopping. # The test suite sometimes shows that the process has exited without stopping.
# #
# CC=clang ./dotest.py -v -t array_types # CC=clang ./dotest.py -v -t array_types
# ... # ...
# Process 76604 exited with status = 0 (0x00000000) # Process 76604 exited with status = 0 (0x00000000)
self.runCmd("process status") self.runCmd("process status")
▲ Show 20 Lines • Show All 161 Lines • Show Last 20 Lines

test/lang/c/bitfields/TestBitfields.py

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Linesclass BitfieldsTestCase(TestBase):
def bitfields_variable(self): def bitfields_variable(self):
"""Test 'frame variable ...' on a variable with bitfields.""" """Test 'frame variable ...' on a variable with bitfields."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the main. # Break inside the main.
lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped', substrs = ['stopped',
'stop reason = breakpoint']) 'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1. # The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
▲ Show 20 Lines • Show All 130 Lines • Show Last 20 Lines

test/lang/c/blocks/TestBlocks.py

Show All 37 Lines 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 (self, "main.c", line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.c", line, num_expected_locations=1, loc_exact=True)
def wait_for_breakpoint(self): def wait_for_breakpoint(self):
if self.is_started == False: if self.is_started == False:
self.is_started = True self.is_started = True
self.runCmd("process launch", RUN_SUCCEEDED) self.runCmd("process launch", RUN_FAILED)
else: else:
self.runCmd("process continue", RUN_SUCCEEDED) self.runCmd("process continue", RUN_FAILED)
# 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'])
def expr(self): def expr(self):
self.common_setup() self.common_setup()
Show All 20 Lines

test/lang/c/const_variables/TestConstVariables.py

Show All 30 Linesclass ConstVariableTestCase(TestBase):
def const_variable(self): def const_variable(self):
"""Test interpreted and JITted expressions on constant values.""" """Test interpreted and JITted expressions on constant values."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the main. # Break inside the main.
lldbutil.run_break_set_by_symbol (self, "main", num_expected_locations=1) lldbutil.run_break_set_by_symbol (self, "main", num_expected_locations=1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped', substrs = ['stopped',
'stop reason = breakpoint']) 'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1. # The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
Show All 23 Lines

test/lang/c/enum_types/TestEnumTypes.py

Show All 33 Linesclass EnumTypesTestCase(TestBase):
def image_lookup_for_enum_type(self): def image_lookup_for_enum_type(self):
"""Test 'image lookup -t days' and check for correct display.""" """Test 'image lookup -t days' and check for correct display."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the main. # Break inside the main.
bkpt_id = lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, num_expected_locations=1, loc_exact=True) bkpt_id = lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped', substrs = ['stopped',
'stop reason = breakpoint']) 'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1. # The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
Show All 37 Lines

test/lang/c/forward/TestForwardDeclaration.py

Show All 29 Linesclass ForwardDeclarationTestCase(TestBase):
def forward_declaration(self): def forward_declaration(self):
"""Display *bar_ptr when stopped on a function with forward declaration of struct bar.""" """Display *bar_ptr when stopped on a function with forward declaration of struct bar."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the foo function which takes a bar_ptr argument. # Break inside the foo function which takes a bar_ptr argument.
lldbutil.run_break_set_by_symbol (self, "foo", num_expected_locations=1, sym_exact=True) lldbutil.run_break_set_by_symbol (self, "foo", num_expected_locations=1, sym_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped', substrs = ['stopped',
'stop reason = breakpoint']) 'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1. # The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
Show All 21 Lines

test/lang/c/function_types/TestFunctionTypes.py

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Linesclass FunctionTypesTestCase(TestBase):
def runToBreakpoint(self): def runToBreakpoint(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the main. # Break inside the main.
lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped', substrs = ['stopped',
'stop reason = breakpoint']) 'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1. # The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

test/lang/c/modules/TestCModules.py

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Linesclass CModulesTestCase(TestBase):
def common_setup(self): def common_setup(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the foo function which takes a bar_ptr argument. # Break inside the foo function which takes a bar_ptr argument.
lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped', substrs = ['stopped',
'stop reason = breakpoint']) 'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1. # The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
Show All 25 Lines

test/lang/c/register_variables/TestRegisterVariables.py

Show All 34 Lines def const_variable(self):
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(self, "break", num_expected_locations=2) lldbutil.run_break_set_by_source_regexp(self, "break", num_expected_locations=2)
#################### ####################
# First breakpoint # First breakpoint
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped', substrs = ['stopped',
'stop reason = breakpoint']) 'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1. # The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
Show All 37 Lines

test/lang/c/set_values/TestSetValues.py

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines def set_values(self):
lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line2, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line2, num_expected_locations=1, loc_exact=True)
lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line3, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line3, num_expected_locations=1, loc_exact=True)
lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line4, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line4, num_expected_locations=1, loc_exact=True)
lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line5, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line5, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped', substrs = ['stopped',
'stop reason = breakpoint']) 'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1. # The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

test/lang/c/stepping/TestThreadStepping.py

Show All 38 Lines def thread_step_out(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."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Create a breakpoint inside function 'c'. # Create a breakpoint inside function 'c'.
lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line1, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (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_FAILED)
# The process should be stopped at this point. # The process should be stopped at this point.
self.expect("process status", PROCESS_STOPPED, self.expect("process status", PROCESS_STOPPED,
patterns = ['Process .* stopped']) patterns = ['Process .* stopped'])
# The frame #0 should correspond to main.c:32, the executable statement # The frame #0 should correspond to main.c:32, the executable statement
# in function name 'c'. And frame #3 should point to main.c:37. # in function name 'c'. And frame #3 should point to main.c:37.
self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT,
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

test/lang/c/strings/TestCStrings.py

Show All 28 Lines def set_breakpoint(self, line):
lldbutil.run_break_set_by_file_and_line (self, "main.c", line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.c", line, num_expected_locations=1, loc_exact=True)
def static_method_commands(self): def static_method_commands(self):
"""Tests that C strings work as expected in expressions""" """Tests that C strings work as expected in expressions"""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
self.set_breakpoint(line_number('main.c', '// breakpoint 1')) self.set_breakpoint(line_number('main.c', '// breakpoint 1'))
self.runCmd("process launch", RUN_SUCCEEDED) self.runCmd("process launch", RUN_FAILED)
self.expect("expression -- a[2]", self.expect("expression -- a[2]",
patterns = ["\((const )?char\) \$0 = 'c'"]) patterns = ["\((const )?char\) \$0 = 'c'"])
self.expect("expression -- z[2]", self.expect("expression -- z[2]",
startstr = "(const char) $1 = 'x'") startstr = "(const char) $1 = 'x'")
# On Linux, the expression below will test GNU indirect function calls. # On Linux, the expression below will test GNU indirect function calls.
Show All 31 Lines

test/lang/c/tls_globals/TestTlsGlobals.py

Show All 38 Linesclass TlsGlobalTestCase(TestBase):
def tls_globals(self): def tls_globals(self):
"""Test thread-local storage.""" """Test thread-local storage."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
line1 = line_number('main.c', '// thread breakpoint') line1 = line_number('main.c', '// thread breakpoint')
lldbutil.run_break_set_by_file_and_line (self, "main.c", line1, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.c", line1, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.runCmd("process status", "Get process status") self.runCmd("process status", "Get process status")
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'])
# BUG: sometimes lldb doesn't change threads to the stopped thread. # BUG: sometimes lldb doesn't change threads to the stopped thread.
# (unrelated to this test). # (unrelated to this test).
self.runCmd("thread select 2", "Change thread") self.runCmd("thread select 2", "Change thread")
# Check that TLS evaluates correctly within the thread. # Check that TLS evaluates correctly within the thread.
self.expect("expr var_static", VARIABLES_DISPLAYED_CORRECTLY, self.expect("expr var_static", VARIABLES_DISPLAYED_CORRECTLY,
patterns = ["\(int\) \$.* = 88"]) patterns = ["\(int\) \$.* = 88"])
self.expect("expr var_shared", VARIABLES_DISPLAYED_CORRECTLY, self.expect("expr var_shared", VARIABLES_DISPLAYED_CORRECTLY,
patterns = ["\(int\) \$.* = 66"]) patterns = ["\(int\) \$.* = 66"])
# Continue on the main thread # Continue on the main thread
line2 = line_number('main.c', '// main breakpoint') line2 = line_number('main.c', '// main breakpoint')
lldbutil.run_break_set_by_file_and_line (self, "main.c", line2, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.c", line2, num_expected_locations=1, loc_exact=True)
self.runCmd("continue", RUN_SUCCEEDED) self.runCmd("continue", RUN_FAILED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.runCmd("process status", "Get process status") self.runCmd("process status", "Get process status")
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'])
# BUG: sometimes lldb doesn't change threads to the stopped thread. # BUG: sometimes lldb doesn't change threads to the stopped thread.
Show All 14 Lines

test/lang/cpp/bool/TestCPPBool.py

Show All 30 Lines def set_breakpoint(self, line):
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", line, num_expected_locations=-1, loc_exact=False) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", line, num_expected_locations=-1, loc_exact=False)
def static_method_commands(self): def static_method_commands(self):
"""Test that bool types work in the expression parser""" """Test that bool types work in the expression parser"""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
self.set_breakpoint(line_number('main.cpp', '// breakpoint 1')) self.set_breakpoint(line_number('main.cpp', '// breakpoint 1'))
self.runCmd("process launch", RUN_SUCCEEDED) self.runCmd("process launch", RUN_FAILED)
self.expect("expression -- bool second_bool = my_bool; second_bool", self.expect("expression -- bool second_bool = my_bool; second_bool",
startstr = "(bool) $0 = false") startstr = "(bool) $0 = false")
self.expect("expression -- my_bool = true", self.expect("expression -- my_bool = true",
startstr = "(bool) $1 = true") startstr = "(bool) $1 = true")
if __name__ == '__main__': if __name__ == '__main__':
import atexit import atexit
lldb.SBDebugger.Initialize() lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate()) atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main() unittest2.main()

test/lang/cpp/call-function/TestCallCPPFunction.py

Show All 27 Lines def setUp(self):
self.line = line_number('main.cpp', '// breakpoint') self.line = line_number('main.cpp', '// breakpoint')
def call_cpp_function(self): def call_cpp_function(self):
"""Test calling a function by basename""" """Test calling a function by basename"""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("process launch", RUN_SUCCEEDED) self.runCmd("process launch", RUN_FAILED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", self.expect("thread list",
STOPPED_DUE_TO_BREAKPOINT, STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped', 'stop reason = breakpoint']) substrs = ['stopped', 'stop reason = breakpoint'])
self.expect("expression -- a_function_to_call()", self.expect("expression -- a_function_to_call()",
startstr = "(int) $0 = 0") startstr = "(int) $0 = 0")
if __name__ == '__main__': if __name__ == '__main__':
import atexit import atexit
lldb.SBDebugger.Initialize() lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate()) atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main() unittest2.main()

test/lang/cpp/class_static/TestStaticVariables.py

Show First 20 Lines • Show All 53 Lines • ▼ Show 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.')
def static_variable_commands(self): def static_variable_commands(self):
"""Test that that file and class static variables display correctly.""" """Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# global variables are no longer displayed with the "frame variable" command. # global variables are no longer displayed with the "frame variable" command.
self.expect('target variable A::g_points', VARIABLES_DISPLAYED_CORRECTLY, self.expect('target variable A::g_points', VARIABLES_DISPLAYED_CORRECTLY,
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

test/lang/cpp/class_types/TestClassTypes.py

Show First 20 Lines • Show All 87 Lines • ▼ Show 20 Linesclass ClassTypesTestCase(TestBase):
def class_types(self): def class_types(self):
"""Test 'frame variable this' when stopped on a class constructor.""" """Test 'frame variable this' when stopped on a class constructor."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break on the ctor function of class C. # Break on the ctor function of class C.
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# The test suite sometimes shows that the process has exited without stopping. # The test suite sometimes shows that the process has exited without stopping.
# #
# CC=clang ./dotest.py -v -t class_types # CC=clang ./dotest.py -v -t class_types
# ... # ...
# Process 76604 exited with status = 0 (0x00000000) # Process 76604 exited with status = 0 (0x00000000)
self.runCmd("process status") self.runCmd("process status")
▲ Show 20 Lines • Show All 79 Lines • ▼ Show 20 Lines def class_types_expr_parser(self):
# #
# 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'")
# Make the test case more robust by using line number to break, instead. # Make the test case more robust by using line number to break, instead.
lldbutil.run_break_set_by_file_and_line (self, None, self.line, num_expected_locations=-1) lldbutil.run_break_set_by_file_and_line (self, None, self.line, num_expected_locations=-1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped', substrs = ['stopped',
'stop reason = breakpoint']) 'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1. # The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

test/lang/cpp/class_types/TestClassTypesDisassembly.py

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Linesclass IterateFrameAndDisassembleTestCase(TestBase):
def breakOnCtor(self): def breakOnCtor(self):
"""Setup/run the program so it stops on C's constructor.""" """Setup/run the program so it stops on C's constructor."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break on the ctor function of class C. # Break on the ctor function of class C.
bpno = lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1) bpno = lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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 %d.'%(bpno)]) 'stop reason = breakpoint %d.'%(bpno)])
# This test was failing because we fail to put the C:: in front of constructore. # This test was failing because we fail to put the C:: in front of constructore.
# We should maybe make another testcase to cover that specifically, but we shouldn't # We should maybe make another testcase to cover that specifically, but we shouldn't
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

test/lang/cpp/enum_types/TestCPP11EnumTypes.py

Show First 20 Lines • Show All 122 Lines • ▼ Show 20 Linesclass CPP11EnumTypesTestCase(TestBase):
def image_lookup_for_enum_type(self): def image_lookup_for_enum_type(self):
"""Test C++11 enumeration class types.""" """Test C++11 enumeration class types."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the main. # Break inside the main.
bkpt_id = lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) bkpt_id = lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped', substrs = ['stopped',
'stop reason = breakpoint']) 'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1. # The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
Show All 37 Lines

test/lang/cpp/namespace/TestNamespace.py

Show All 35 Lines def setUp(self):
self.line_var_j = line_number('main.cpp', self.line_var_j = line_number('main.cpp',
'// Find the line number for named namespace variable j.') '// Find the line number for named namespace variable j.')
# And the line number to break at. # And the line number to break at.
self.line_break = line_number('main.cpp', self.line_break = line_number('main.cpp',
'// Set break point at this line.') '// Set break point at this line.')
def namespace_variable_commands(self): def namespace_variable_commands(self):
"""Test that anonymous and named namespace variables display correctly.""" """Test that anonymous and named namespace variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("run a.out", RUN_FAILED)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line_break, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line_break, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# On Mac OS X, gcc 4.2 emits the wrong debug info with respect to types. # On Mac OS X, gcc 4.2 emits the wrong debug info with respect to types.
slist = ['(int) a = 12', 'anon_uint', 'a_uint', 'b_uint', 'y_uint'] slist = ['(int) a = 12', 'anon_uint', 'a_uint', 'b_uint', 'y_uint']
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

test/lang/cpp/overloaded-functions/TestOverloadedFunctions.py

Show All 27 Lines def setUp(self):
self.line = line_number('main.cpp', '// breakpoint') self.line = line_number('main.cpp', '// breakpoint')
def static_method_commands(self): def static_method_commands(self):
"""Test that static methods are properly distinguished from regular methods""" """Test that static methods are properly distinguished from regular methods"""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("process launch", RUN_SUCCEEDED) self.runCmd("process launch", RUN_FAILED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", self.expect("thread list",
STOPPED_DUE_TO_BREAKPOINT, STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped', 'stop reason = breakpoint']) substrs = ['stopped', 'stop reason = breakpoint'])
self.expect("expression -- Dump(myB)", self.expect("expression -- Dump(myB)",
startstr = "(int) $0 = 2") startstr = "(int) $0 = 2")
Show All 9 Lines

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

Show All 33 Linesclass RvalueReferencesTestCase(TestBase):
def static_method_commands(self): def static_method_commands(self):
"""Test that rvalues are supported in the C++ expression parser""" """Test that rvalues are supported in the C++ expression parser"""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
self.set_breakpoint(line_number('main.cpp', '// breakpoint 1')) self.set_breakpoint(line_number('main.cpp', '// breakpoint 1'))
self.set_breakpoint(line_number('main.cpp', '// breakpoint 2')) self.set_breakpoint(line_number('main.cpp', '// breakpoint 2'))
self.runCmd("process launch", RUN_SUCCEEDED) self.runCmd("process launch", RUN_FAILED)
# 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)
self.expect("frame variable i", self.expect("frame variable i",
startstr = "(int &&", startstr = "(int &&",
substrs = ["i = 0x", "&i = 3"]) substrs = ["i = 0x", "&i = 3"])
self.expect("expression -- i", self.expect("expression -- i",
Show All 20 Lines

test/lang/cpp/static_members/TestCPPStaticMembers.py

Show All 31 Linesclass CPPStaticMembersTestCase(TestBase):
def static_member_commands(self): def static_member_commands(self):
"""Test that member variables have the correct layout, scope and qualifiers when stopped inside and outside C++ methods""" """Test that member variables have the correct layout, scope and qualifiers when stopped inside and outside C++ methods"""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
self.set_breakpoint(line_number('main.cpp', '// breakpoint 1')) self.set_breakpoint(line_number('main.cpp', '// breakpoint 1'))
self.set_breakpoint(line_number('main.cpp', '// breakpoint 2')) self.set_breakpoint(line_number('main.cpp', '// breakpoint 2'))
self.runCmd("process launch", RUN_SUCCEEDED) self.runCmd("process launch", RUN_FAILED)
self.expect("expression my_a.access()", self.expect("expression my_a.access()",
startstr = "(long) $0 = 10") startstr = "(long) $0 = 10")
self.expect("expression my_a.m_a", self.expect("expression my_a.m_a",
startstr = "(short) $1 = 1") startstr = "(short) $1 = 1")
# Note: SymbolFileDWARF::ParseChildMembers doesn't call AddFieldToRecordType, consistent with clang's AST layout. # Note: SymbolFileDWARF::ParseChildMembers doesn't call AddFieldToRecordType, consistent with clang's AST layout.
self.expect("expression my_a.s_d", self.expect("expression my_a.s_d",
Show All 27 Lines

test/lang/cpp/static_methods/TestCPPStaticMethods.py

Show All 27 Lines def setUp(self):
self.line = line_number('main.cpp', '// Break at this line') self.line = line_number('main.cpp', '// Break at this line')
def static_method_commands(self): def static_method_commands(self):
"""Test that static methods are properly distinguished from regular methods""" """Test that static methods are properly distinguished from regular methods"""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("process launch", RUN_SUCCEEDED) self.runCmd("process launch", RUN_FAILED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", self.expect("thread list",
STOPPED_DUE_TO_BREAKPOINT, STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped', 'stop reason = breakpoint']) substrs = ['stopped', 'stop reason = breakpoint'])
self.expect("expression -- A::getStaticValue()", self.expect("expression -- A::getStaticValue()",
startstr = "(int) $0 = 5") startstr = "(int) $0 = 5")
Show All 9 Lines

test/lang/cpp/stl/TestSTL.py

Show First 20 Lines • Show All 61 Lines • ▼ Show 20 Lines def step_stl_exprs(self):
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# rdar://problem/8543077 # rdar://problem/8543077
# test/stl: clang built binaries results in the breakpoint locations = 3, # test/stl: clang built binaries results in the breakpoint locations = 3,
# is this a problem with clang generated debug info? # is this a problem with clang generated debug info?
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# Stop at 'std::string hello_world ("Hello World!");'. # Stop at 'std::string hello_world ("Hello World!");'.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['main.cpp:%d' % self.line, substrs = ['main.cpp:%d' % self.line,
'stop reason = breakpoint']) 'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1. # The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

test/lang/cpp/stl/TestStdCXXDisassembly.py

Show All 28 Lines def test_stdcxx_disasm(self):
# rdar://problem/8543077 # rdar://problem/8543077
# test/stl: clang built binaries results in the breakpoint locations = 3, # test/stl: clang built binaries results in the breakpoint locations = 3,
# is this a problem with clang generated debug info? # is this a problem with clang generated debug info?
# #
# Break on line 13 of main.cpp. # Break on line 13 of main.cpp.
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# Now let's get the target as well as the process objects. # Now let's get the target as well as the process objects.
target = self.dbg.GetSelectedTarget() target = self.dbg.GetSelectedTarget()
process = target.GetProcess() process = target.GetProcess()
# The process should be in a 'stopped' state. # The process should be in a 'stopped' state.
self.expect(str(process), STOPPED_DUE_TO_BREAKPOINT, exe=False, self.expect(str(process), STOPPED_DUE_TO_BREAKPOINT, exe=False,
substrs = ["a.out", substrs = ["a.out",
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

test/lang/cpp/this/TestCPPThis.py

Show All 37 Lines def static_method_commands(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.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
self.set_breakpoint(line_number('main.cpp', '// breakpoint 1')) self.set_breakpoint(line_number('main.cpp', '// breakpoint 1'))
self.set_breakpoint(line_number('main.cpp', '// breakpoint 2')) self.set_breakpoint(line_number('main.cpp', '// breakpoint 2'))
self.set_breakpoint(line_number('main.cpp', '// breakpoint 3')) self.set_breakpoint(line_number('main.cpp', '// breakpoint 3'))
self.set_breakpoint(line_number('main.cpp', '// breakpoint 4')) self.set_breakpoint(line_number('main.cpp', '// breakpoint 4'))
self.runCmd("process launch", RUN_SUCCEEDED) self.runCmd("process launch", RUN_FAILED)
self.expect("expression -- m_a = 2", self.expect("expression -- m_a = 2",
startstr = "(int) $0 = 2") startstr = "(int) $0 = 2")
self.runCmd("process continue") self.runCmd("process continue")
# This would be disallowed if we enforced const. But we don't. # This would be disallowed if we enforced const. But we don't.
self.expect("expression -- m_a = 2", self.expect("expression -- m_a = 2",
Show All 20 Lines

test/lang/cpp/unique-types/TestUniqueTypes.py

Show All 37 Lines def unique_types(self):
compiler_basename = os.path.basename(compiler) compiler_basename = os.path.basename(compiler)
if "clang" in compiler_basename and int(self.getCompilerVersion().split('.')[0]) < 3: if "clang" in compiler_basename and int(self.getCompilerVersion().split('.')[0]) < 3:
self.skipTest("rdar://problem/9173060 lldb hangs while running unique-types for clang version < 3") self.skipTest("rdar://problem/9173060 lldb hangs while running unique-types for clang version < 3")
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# Do a "frame variable --show-types longs" and verify "long" is in each line of output. # Do a "frame variable --show-types longs" and verify "long" is in each line of output.
self.runCmd("frame variable --show-types longs") self.runCmd("frame variable --show-types longs")
Show All 24 Lines

test/lang/cpp/unsigned_types/TestUnsignedTypes.py

Show All 37 Lines def unsigned_types(self):
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# GCC puts a breakpoint on the last line of a multi-line expression, so # GCC puts a breakpoint on the last line of a multi-line expression, so
# if GCC is the target compiler, we cannot rely on an exact line match. # if GCC is the target compiler, we cannot rely on an exact line match.
need_exact = "gcc" not in self.getCompiler() need_exact = "gcc" not in self.getCompiler()
# Break on line 19 in main() aftre the variables are assigned values. # Break on line 19 in main() aftre the variables are assigned values.
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1, loc_exact=need_exact) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1, loc_exact=need_exact)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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.
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
substrs = [' resolved, hit count = 1']) substrs = [' resolved, hit count = 1'])
Show All 16 Lines

test/lang/objc/foundation/TestConstStrings.py

Show All 37 Linesclass ConstStringTestCase(TestBase):
def objc_const_strings(self): def objc_const_strings(self):
"""Test constant string generation amd comparison by the expression parser.""" """Test constant string generation amd comparison by the expression parser."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, self.main_source, self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, self.main_source, self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
self.expect("process status", STOPPED_DUE_TO_BREAKPOINT, self.expect("process status", STOPPED_DUE_TO_BREAKPOINT,
substrs = [" at %s:%d" % (self.main_source, self.line), substrs = [" at %s:%d" % (self.main_source, self.line),
"stop reason = breakpoint"]) "stop reason = breakpoint"])
self.expect('expression (int)[str compare:@"hello"]', self.expect('expression (int)[str compare:@"hello"]',
startstr = "(int) $0 = 0") startstr = "(int) $0 = 0")
self.expect('expression (int)[str compare:@"world"]', self.expect('expression (int)[str compare:@"world"]',
startstr = "(int) $1 = -1") startstr = "(int) $1 = -1")
Show All 14 Lines

test/lang/objc/foundation/TestFoundationDisassembly.py

Show First 20 Lines • Show All 94 Lines • ▼ Show 20 Lines def do_simple_disasm(self):
# Stop at the "description" selector. # Stop at the "description" selector.
lldbutil.run_break_set_by_selector (self, 'description', num_expected_locations=1, module_name='a.out') lldbutil.run_break_set_by_selector (self, 'description', num_expected_locations=1, module_name='a.out')
# Stop at -[NSAutoreleasePool release]. # Stop at -[NSAutoreleasePool release].
break_results = lldbutil.run_break_set_command (self, "_regexp-break -[NSAutoreleasePool release]") break_results = lldbutil.run_break_set_command (self, "_regexp-break -[NSAutoreleasePool release]")
lldbutil.check_breakpoint_result (self, break_results, symbol_name='-[NSAutoreleasePool release]', num_locations=1) lldbutil.check_breakpoint_result (self, break_results, symbol_name='-[NSAutoreleasePool release]', num_locations=1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# First stop is +[NSString stringWithFormat:]. # First stop is +[NSString stringWithFormat:].
self.expect("thread backtrace", "Stop at +[NSString stringWithFormat:]", self.expect("thread backtrace", "Stop at +[NSString stringWithFormat:]",
substrs = ["Foundation`+[NSString stringWithFormat:]"]) substrs = ["Foundation`+[NSString stringWithFormat:]"])
# Do the disassemble for the currently stopped function. # Do the disassemble for the currently stopped function.
self.runCmd("disassemble -f") self.runCmd("disassemble -f")
Show All 37 Lines

test/lang/objc/foundation/TestObjCMethods.py

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Lines def break_on_objc_methods(self):
# Stop at the "description" selector. # Stop at the "description" selector.
lldbutil.run_break_set_by_selector (self, 'description', num_expected_locations=1, module_name='a.out') lldbutil.run_break_set_by_selector (self, 'description', num_expected_locations=1, module_name='a.out')
# Stop at -[NSAutoreleasePool release]. # Stop at -[NSAutoreleasePool release].
break_results = lldbutil.run_break_set_command(self, "_regexp-break -[NSAutoreleasePool release]") break_results = lldbutil.run_break_set_command(self, "_regexp-break -[NSAutoreleasePool release]")
lldbutil.check_breakpoint_result (self, break_results, symbol_name='-[NSAutoreleasePool release]', num_locations=1) lldbutil.check_breakpoint_result (self, break_results, symbol_name='-[NSAutoreleasePool release]', num_locations=1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# First stop is +[NSString stringWithFormat:]. # First stop is +[NSString stringWithFormat:].
self.expect("thread backtrace", "Stop at +[NSString stringWithFormat:]", self.expect("thread backtrace", "Stop at +[NSString stringWithFormat:]",
substrs = ["Foundation`+[NSString stringWithFormat:]"]) substrs = ["Foundation`+[NSString stringWithFormat:]"])
self.runCmd("process continue") self.runCmd("process continue")
# Second stop is still +[NSString stringWithFormat:]. # Second stop is still +[NSString stringWithFormat:].
Show All 39 Linesclass FoundationTestCase(TestBase):
def expression_lookups_objc (self): def expression_lookups_objc (self):
"""Test running an expression and make sure we don't search all dwarf files for any internal names (anything that contains '__lldb').""" """Test running an expression and make sure we don't search all dwarf files for any internal names (anything that contains '__lldb')."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Stop at -[MyString initWithNSString:]. # Stop at -[MyString initWithNSString:].
lldbutil.run_break_set_by_symbol (self, '-[MyString initWithNSString:]', num_expected_locations=1, sym_exact=True) lldbutil.run_break_set_by_symbol (self, '-[MyString initWithNSString:]', num_expected_locations=1, sym_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
global file_index global file_index
# Log any DWARF lookups # Log any DWARF lookups
++file_index ++file_index
logfile = os.path.join(os.getcwd(), "dwarf-lookups-" + self.getArchitecture() + "-" + str(file_index) + ".txt") logfile = os.path.join(os.getcwd(), "dwarf-lookups-" + self.getArchitecture() + "-" + str(file_index) + ".txt")
self.runCmd("log enable -f %s dwarf lookups" % (logfile)) self.runCmd("log enable -f %s dwarf lookups" % (logfile))
self.runCmd("expr self") self.runCmd("expr self")
self.runCmd("log disable dwarf lookups") self.runCmd("log disable dwarf lookups")
Show All 29 Lines def data_type_and_expr_objc(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Stop at -[MyString description]. # Stop at -[MyString description].
lldbutil.run_break_set_by_symbol (self, '-[MyString description]', num_expected_locations=1, sym_exact=True) lldbutil.run_break_set_by_symbol (self, '-[MyString description]', num_expected_locations=1, sym_exact=True)
# self.expect("breakpoint set -n '-[MyString description]", BREAKPOINT_CREATED, # self.expect("breakpoint set -n '-[MyString description]", BREAKPOINT_CREATED,
# startstr = "Breakpoint created: 1: name = '-[MyString description]', locations = 1") # startstr = "Breakpoint created: 1: name = '-[MyString description]', locations = 1")
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# The backtrace should show we stop at -[MyString description]. # The backtrace should show we stop at -[MyString description].
self.expect("thread backtrace", "Stop at -[MyString description]", self.expect("thread backtrace", "Stop at -[MyString description]",
substrs = ["a.out`-[MyString description]"]) substrs = ["a.out`-[MyString description]"])
# Lookup objc data type MyString and evaluate some expressions. # Lookup objc data type MyString and evaluate some expressions.
self.expect("image lookup -t NSString", DATA_TYPES_DISPLAYED_CORRECTLY, self.expect("image lookup -t NSString", DATA_TYPES_DISPLAYED_CORRECTLY,
▲ Show 20 Lines • Show All 122 Lines • Show Last 20 Lines

test/lang/objc/foundation/TestObjCMethods2.py

Show First 20 Lines • Show All 101 Lines • ▼ Show 20 Lines def more_expr_objc(self):
"""More expression commands for objective-c.""" """More expression commands for objective-c."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Create a bunch of breakpoints. # Create a bunch of breakpoints.
for line in self.lines: for line in self.lines:
lldbutil.run_break_set_by_file_and_line (self, "main.m", line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.m", line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# Test_Selector: # Test_Selector:
self.runCmd("thread backtrace") self.runCmd("thread backtrace")
self.expect("expression (char *)sel_getName(sel)", self.expect("expression (char *)sel_getName(sel)",
substrs = ["(char *)", substrs = ["(char *)",
"length"]) "length"])
self.runCmd("process continue") self.runCmd("process continue")
Show All 18 Lines def NSArray_expr(self):
"""Test expression commands for NSArray.""" """Test expression commands for NSArray."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside Test_NSArray: # Break inside Test_NSArray:
line = self.lines[1] line = self.lines[1]
lldbutil.run_break_set_by_file_and_line (self, "main.m", line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.m", line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# Test_NSArray: # Test_NSArray:
self.runCmd("thread backtrace") self.runCmd("thread backtrace")
self.expect("expression (int)[nil_mutable_array count]", self.expect("expression (int)[nil_mutable_array count]",
patterns = ["\(int\) \$.* = 0"]) patterns = ["\(int\) \$.* = 0"])
self.expect("expression (int)[array1 count]", self.expect("expression (int)[array1 count]",
patterns = ["\(int\) \$.* = 3"]) patterns = ["\(int\) \$.* = 3"])
self.expect("expression (int)[array2 count]", self.expect("expression (int)[array2 count]",
patterns = ["\(int\) \$.* = 3"]) patterns = ["\(int\) \$.* = 3"])
self.expect("expression (int)array1.count", self.expect("expression (int)array1.count",
patterns = ["\(int\) \$.* = 3"]) patterns = ["\(int\) \$.* = 3"])
self.expect("expression (int)array2.count", self.expect("expression (int)array2.count",
patterns = ["\(int\) \$.* = 3"]) patterns = ["\(int\) \$.* = 3"])
self.runCmd("process continue") self.runCmd("process continue")
def NSString_expr(self): def NSString_expr(self):
"""Test expression commands for NSString.""" """Test expression commands for NSString."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside Test_NSString: # Break inside Test_NSString:
line = self.lines[2] line = self.lines[2]
lldbutil.run_break_set_by_file_and_line (self, "main.m", line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.m", line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# Test_NSString: # Test_NSString:
self.runCmd("thread backtrace") self.runCmd("thread backtrace")
self.expect("expression (int)[str length]", self.expect("expression (int)[str length]",
patterns = ["\(int\) \$.* ="]) patterns = ["\(int\) \$.* ="])
self.expect("expression (int)[str_id length]", self.expect("expression (int)[str_id length]",
patterns = ["\(int\) \$.* ="]) patterns = ["\(int\) \$.* ="])
self.expect("expression [str description]", self.expect("expression [str description]",
Show All 11 Lines def MyString_dump(self):
"""Test dump of a known Objective-C object by dereferencing it.""" """Test dump of a known Objective-C object by dereferencing it."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
line = self.lines[4] line = self.lines[4]
lldbutil.run_break_set_by_file_and_line (self, "main.m", line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.m", line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
self.expect("expression --show-types -- *my", self.expect("expression --show-types -- *my",
patterns = ["\(MyString\) \$.* = ", "\(MyBase\)", "\(NSObject\)", "\(Class\)"]) patterns = ["\(MyString\) \$.* = ", "\(MyBase\)", "\(NSObject\)", "\(Class\)"])
self.runCmd("process continue") self.runCmd("process continue")
def NSError_po(self): def NSError_po(self):
"""Test that po of the result of an unknown method doesn't require a cast.""" """Test that po of the result of an unknown method doesn't require a cast."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
line = self.lines[4] line = self.lines[4]
lldbutil.run_break_set_by_file_and_line (self, "main.m", line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.m", line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
self.expect("po [NSError errorWithDomain:@\"Hello\" code:35 userInfo:nil]", self.expect("po [NSError errorWithDomain:@\"Hello\" code:35 userInfo:nil]",
substrs = ["Error Domain=Hello", "Code=35", "be completed."]) substrs = ["Error Domain=Hello", "Code=35", "be completed."])
self.runCmd("process continue") self.runCmd("process continue")
def NSError_p(self): def NSError_p(self):
"""Test that p of the result of an unknown method does require a cast.""" """Test that p of the result of an unknown method does require a cast."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
line = self.lines[4] line = self.lines[4]
lldbutil.run_break_set_by_file_and_line (self, "main.m", line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.m", line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
self.expect("p [NSError thisMethodIsntImplemented:0]", self.expect("p [NSError thisMethodIsntImplemented:0]",
error = True, error = True,
patterns = ["no known method", "cast the message send to the method's return type"]) patterns = ["no known method", "cast the message send to the method's return type"])
self.runCmd("process continue") self.runCmd("process continue")
if __name__ == '__main__': if __name__ == '__main__':
import atexit import atexit
lldb.SBDebugger.Initialize() lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate()) atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main() unittest2.main()

test/lang/objc/foundation/TestRuntimeTypes.py

Show All 30 Linesclass RuntimeTypesTestCase(TestBase):
def runtime_types(self): def runtime_types(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Stop at -[MyString description]. # Stop at -[MyString description].
lldbutil.run_break_set_by_symbol (self, '-[MyString description]', num_expected_locations=1, sym_exact=True) lldbutil.run_break_set_by_symbol (self, '-[MyString description]', num_expected_locations=1, sym_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# The backtrace should show we stop at -[MyString description]. # The backtrace should show we stop at -[MyString description].
self.expect("thread backtrace", "Stop at -[MyString description]", self.expect("thread backtrace", "Stop at -[MyString description]",
substrs = ["a.out`-[MyString description]"]) substrs = ["a.out`-[MyString description]"])
# Use runtime information about NSString. # Use runtime information about NSString.
# The length property should be usable. # The length property should be usable.
Show All 15 Lines

test/lang/objc/hidden-ivars/TestHiddenIvars.py

Show First 20 Lines • Show All 116 Lines • ▼ Show 20 Lines def common_setup(self, strip):
self.assertTrue(process, PROCESS_IS_VALID) self.assertTrue(process, PROCESS_IS_VALID)
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the foo function which takes a bar_ptr argument. # Break inside the foo function which takes a bar_ptr argument.
lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped', substrs = ['stopped',
'stop reason = breakpoint']) 'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1. # The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

test/lang/objc/modules-auto-import/TestModulesAutoImport.py

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Linesclass ObjCModulesAutoImportTestCase(TestBase):
def common_setup(self): def common_setup(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the foo function which takes a bar_ptr argument. # Break inside the foo function which takes a bar_ptr argument.
lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped', substrs = ['stopped',
'stop reason = breakpoint']) 'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1. # The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
Show All 18 Lines

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

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Linesclass IncompleteModulesTestCase(TestBase):
def common_setup(self): def common_setup(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the foo function which takes a bar_ptr argument. # Break inside the foo function which takes a bar_ptr argument.
lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped', substrs = ['stopped',
'stop reason = breakpoint']) 'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1. # The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
Show All 27 Lines

test/lang/objc/modules-inline-functions/TestModulesInlineFunctions.py

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Linesclass ModulesInlineFunctionsTestCase(TestBase):
def common_setup(self): def common_setup(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the foo function which takes a bar_ptr argument. # Break inside the foo function which takes a bar_ptr argument.
lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped', substrs = ['stopped',
'stop reason = breakpoint']) 'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1. # The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
Show All 21 Lines

test/lang/objc/modules/TestObjCModules.py

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Linesclass ObjCModulesTestCase(TestBase):
def common_setup(self): def common_setup(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the foo function which takes a bar_ptr argument. # Break inside the foo function which takes a bar_ptr argument.
lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped', substrs = ['stopped',
'stop reason = breakpoint']) 'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1. # The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
Show All 34 Lines

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

Show All 30 Linesclass ObjCXXTestCase(TestBase):
def do_testObjCXXClasses(self): def do_testObjCXXClasses(self):
"""Test ivars of Objective-C++ classes""" """Test ivars of Objective-C++ classes"""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_source_regexp (self, 'breakpoint 1', num_expected_locations=1) lldbutil.run_break_set_by_source_regexp (self, 'breakpoint 1', num_expected_locations=1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
self.expect("expr f->f", "Found ivar in class", self.expect("expr f->f", "Found ivar in class",
substrs = ["= 3"]) substrs = ["= 3"])
if __name__ == '__main__': if __name__ == '__main__':
import atexit import atexit
lldb.SBDebugger.Initialize() lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate()) atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main() unittest2.main()

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

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Linesclass ObjCDynamicSBTypeTestCase(TestBase):
def dyn(self, exe_name): def dyn(self, exe_name):
"""Test that we are able to properly report a usable dynamic type.""" """Test that we are able to properly report a usable dynamic type."""
exe = os.path.join(os.getcwd(), exe_name) exe = os.path.join(os.getcwd(), exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, self.main_source, self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, self.main_source, self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
v_object = self.frame().FindVariable("object").GetDynamicValue(lldb.eDynamicCanRunTarget) v_object = self.frame().FindVariable("object").GetDynamicValue(lldb.eDynamicCanRunTarget)
v_base = self.frame().FindVariable("base").GetDynamicValue(lldb.eDynamicCanRunTarget) v_base = self.frame().FindVariable("base").GetDynamicValue(lldb.eDynamicCanRunTarget)
self.assertTrue(v_object.GetTypeName() == "MyDerivedClass *", "The NSObject is properly type-named") self.assertTrue(v_object.GetTypeName() == "MyDerivedClass *", "The NSObject is properly type-named")
self.assertTrue(v_base.GetTypeName() == "MyDerivedClass *", "The Base is properly type-named") self.assertTrue(v_base.GetTypeName() == "MyDerivedClass *", "The Base is properly type-named")
object_type = v_object.GetType() object_type = v_object.GetType()
base_type = v_base.GetType() base_type = v_base.GetType()
self.assertTrue(object_type.GetName() == "MyDerivedClass *", "The dynamic SBType for NSObject is for the correct type") self.assertTrue(object_type.GetName() == "MyDerivedClass *", "The dynamic SBType for NSObject is for the correct type")
Show All 20 Lines

test/lang/objc/objc-new-syntax/TestObjCNewSyntax.py

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Linesclass ObjCNewSyntaxTestCase(TestBase):
def common_setup(self): def common_setup(self):
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the foo function which takes a bar_ptr argument. # Break inside the foo function which takes a bar_ptr argument.
lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped', substrs = ['stopped',
'stop reason = breakpoint']) 'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1. # The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

test/lang/objc/objc-optimized/TestObjcOptimized.py

Show All 37 Linesclass ObjcOptimizedTestCase(TestBase):
def objc_optimized(self): def objc_optimized(self):
"""Test 'expr member' continues to work for optimized build.""" """Test 'expr member' continues to work for optimized build."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_symbol (self, self.method_spec, num_expected_locations=1, sym_exact=True) lldbutil.run_break_set_by_symbol (self, self.method_spec, num_expected_locations=1, sym_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT,
substrs = ["stop reason = breakpoint"], substrs = ["stop reason = breakpoint"],
patterns = ["frame.*0:.*%s %s" % (self.myclass, self.mymethod)]) patterns = ["frame.*0:.*%s %s" % (self.myclass, self.mymethod)])
self.expect('expression member', self.expect('expression member',
startstr = "(int) $0 = 5") startstr = "(int) $0 = 5")
# <rdar://problem/12693963> # <rdar://problem/12693963>
Show All 24 Lines

test/lang/objc/radar-9691614/TestObjCMethodReturningBOOL.py

Show All 39 Linesclass MethodReturningBOOLTestCase(TestBase):
def objc_method_ret_BOOL(self, exe_name): def objc_method_ret_BOOL(self, exe_name):
"""Test that objective-c method returning BOOL works correctly.""" """Test that objective-c method returning BOOL works correctly."""
exe = os.path.join(os.getcwd(), exe_name) exe = os.path.join(os.getcwd(), exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
self.expect("process status", STOPPED_DUE_TO_BREAKPOINT, self.expect("process status", STOPPED_DUE_TO_BREAKPOINT,
substrs = [" at %s:%d" % (self.main_source, self.line), substrs = [" at %s:%d" % (self.main_source, self.line),
"stop reason = breakpoint"]) "stop reason = breakpoint"])
# rdar://problem/9691614 # rdar://problem/9691614
self.runCmd('p (int)[my isValid]') self.runCmd('p (int)[my isValid]')
if __name__ == '__main__': if __name__ == '__main__':
import atexit import atexit
lldb.SBDebugger.Initialize() lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate()) atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main() unittest2.main()

test/lang/objc/rdar-10967107/TestRdar10967107.py

Show All 39 Linesclass Rdar10967107TestCase(TestBase):
def cfrange_diff_cfgregoriandate(self, exe_name): def cfrange_diff_cfgregoriandate(self, exe_name):
"""Test that CoreFoundation classes CFGregorianDate and CFRange are not improperly uniqued.""" """Test that CoreFoundation classes CFGregorianDate and CFRange are not improperly uniqued."""
exe = os.path.join(os.getcwd(), exe_name) exe = os.path.join(os.getcwd(), exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, self.main_source, self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, self.main_source, self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# check that each type is correctly bound to its list of children # check that each type is correctly bound to its list of children
self.expect("frame variable cf_greg_date --raw", substrs = ['year','month','day','hour','minute','second']) self.expect("frame variable cf_greg_date --raw", substrs = ['year','month','day','hour','minute','second'])
self.expect("frame variable cf_range --raw", substrs = ['location','length']) self.expect("frame variable cf_range --raw", substrs = ['location','length'])
# check that printing both does not somehow confuse LLDB # check that printing both does not somehow confuse LLDB
self.expect("frame variable --raw", substrs = ['year','month','day','hour','minute','second','location','length']) self.expect("frame variable --raw", substrs = ['year','month','day','hour','minute','second','location','length'])
if __name__ == '__main__': if __name__ == '__main__':
import atexit import atexit
lldb.SBDebugger.Initialize() lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate()) atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main() unittest2.main()

test/lang/objc/rdar-11355592/TestRdar11355592.py

Show All 39 Linesclass Rdar10967107TestCase(TestBase):
def charstar_dyntype(self, exe_name): def charstar_dyntype(self, exe_name):
"""Test that we do not attempt to make a dynamic type for a 'const char*'""" """Test that we do not attempt to make a dynamic type for a 'const char*'"""
exe = os.path.join(os.getcwd(), exe_name) exe = os.path.join(os.getcwd(), exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, self.main_source, self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, self.main_source, self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# check that we correctly see the const char*, even with dynamic types on # check that we correctly see the const char*, even with dynamic types on
self.expect("frame variable my_string", substrs = ['const char *']) self.expect("frame variable my_string", substrs = ['const char *'])
self.expect("frame variable my_string --dynamic-type run-target", substrs = ['const char *']) self.expect("frame variable my_string --dynamic-type run-target", substrs = ['const char *'])
# check that expr also gets it right # check that expr also gets it right
self.expect("expr my_string", substrs = ['const char *']) self.expect("expr my_string", substrs = ['const char *'])
self.expect("expr -d run -- my_string", substrs = ['const char *']) self.expect("expr -d run -- my_string", substrs = ['const char *'])
# but check that we get the real Foolie as such # but check that we get the real Foolie as such
self.expect("frame variable my_foolie", substrs = ['FoolMeOnce *']) self.expect("frame variable my_foolie", substrs = ['FoolMeOnce *'])
Show All 24 Lines

test/lang/objc/rdar-12408181/TestRdar12408181.py

Show All 39 Linesclass Rdar12408181TestCase(TestBase):
def nswindow_count(self, exe_name): def nswindow_count(self, exe_name):
"""Test that we are able to find out how many children NSWindow has.""" """Test that we are able to find out how many children NSWindow has."""
exe = os.path.join(os.getcwd(), exe_name) exe = os.path.join(os.getcwd(), exe_name)
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, self.main_source, self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, self.main_source, self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
window = self.frame().FindVariable("window") window = self.frame().FindVariable("window")
window_dynamic = window.GetDynamicValue(lldb.eDynamicCanRunTarget) window_dynamic = window.GetDynamicValue(lldb.eDynamicCanRunTarget)
self.assertTrue(window.GetNumChildren() > 1, "NSWindow (static) only has 1 child!") self.assertTrue(window.GetNumChildren() > 1, "NSWindow (static) only has 1 child!")
self.assertTrue(window_dynamic.GetNumChildren() > 1, "NSWindow (dynamic) only has 1 child!") self.assertTrue(window_dynamic.GetNumChildren() > 1, "NSWindow (dynamic) only has 1 child!")
self.assertTrue(window.GetChildAtIndex(0).IsValid(), "NSWindow (static) has an invalid child") self.assertTrue(window.GetChildAtIndex(0).IsValid(), "NSWindow (static) has an invalid child")
self.assertTrue(window_dynamic.GetChildAtIndex(0).IsValid(), "NSWindow (dynamic) has an invalid child") self.assertTrue(window_dynamic.GetChildAtIndex(0).IsValid(), "NSWindow (dynamic) has an invalid child")
if __name__ == '__main__': if __name__ == '__main__':
import atexit import atexit
lldb.SBDebugger.Initialize() lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate()) atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main() unittest2.main()

test/lang/objc/real-definition/TestRealDefinition.py

Show First 20 Lines • Show All 59 Lines • ▼ Show 20 Linesclass TestRealDefinition(TestBase):
def stop_at_interface(self): def stop_at_interface(self):
"""Test that we can find the implementation for an objective C type when we stop in the interface""" """Test that we can find the implementation for an objective C type when we stop in the interface"""
self.common_setup() self.common_setup()
line = line_number('Foo.m', '// Set breakpoint where Bar is an interface') line = line_number('Foo.m', '// Set breakpoint where Bar is an interface')
lldbutil.run_break_set_by_file_and_line (self, 'Foo.m', line, num_expected_locations=1, loc_exact=True); lldbutil.run_break_set_by_file_and_line (self, 'Foo.m', line, num_expected_locations=1, loc_exact=True);
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# Run and stop at Foo # Run and stop at Foo
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
substrs = [' resolved, hit count = 1']) substrs = [' resolved, hit count = 1'])
self.runCmd("continue", RUN_SUCCEEDED) self.runCmd("continue", RUN_FAILED)
# Run at stop at main # Run at stop at main
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
substrs = [' resolved, hit count = 1']) substrs = [' resolved, hit count = 1'])
# This should display correctly. # This should display correctly.
self.expect("frame variable foo->_bar->_hidden_ivar", VARIABLES_DISPLAYED_CORRECTLY, self.expect("frame variable foo->_bar->_hidden_ivar", VARIABLES_DISPLAYED_CORRECTLY,
substrs = ["(NSString *)", "foo->_bar->_hidden_ivar = 0x"]) substrs = ["(NSString *)", "foo->_bar->_hidden_ivar = 0x"])
def stop_at_implementation(self): def stop_at_implementation(self):
"""Test that we can find the implementation for an objective C type when we stop in the implementation""" """Test that we can find the implementation for an objective C type when we stop in the implementation"""
self.common_setup() self.common_setup()
line = line_number('Bar.m', '// Set breakpoint where Bar is an implementation') line = line_number('Bar.m', '// Set breakpoint where Bar is an implementation')
lldbutil.run_break_set_by_file_and_line (self, 'Bar.m', line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, 'Bar.m', line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# Run and stop at Foo # Run and stop at Foo
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
substrs = [' resolved, hit count = 1']) substrs = [' resolved, hit count = 1'])
self.runCmd("continue", RUN_SUCCEEDED) self.runCmd("continue", RUN_FAILED)
# Run at stop at main # Run at stop at main
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
substrs = [' resolved, hit count = 1']) substrs = [' resolved, hit count = 1'])
# This should display correctly. # This should display correctly.
self.expect("frame variable foo->_bar->_hidden_ivar", VARIABLES_DISPLAYED_CORRECTLY, self.expect("frame variable foo->_bar->_hidden_ivar", VARIABLES_DISPLAYED_CORRECTLY,
substrs = ["(NSString *)", "foo->_bar->_hidden_ivar = 0x"]) substrs = ["(NSString *)", "foo->_bar->_hidden_ivar = 0x"])
if __name__ == '__main__': if __name__ == '__main__':
import atexit import atexit
lldb.SBDebugger.Initialize() lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate()) atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main() unittest2.main()

test/lang/objc/self/TestObjCSelf.py

Show All 30 Linesclass ObjCSelfTestCase(TestBase):
def self_commands(self): def self_commands(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.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
self.set_breakpoint(line_number('main.m', '// breakpoint 1')) self.set_breakpoint(line_number('main.m', '// breakpoint 1'))
self.set_breakpoint(line_number('main.m', '// breakpoint 2')) self.set_breakpoint(line_number('main.m', '// breakpoint 2'))
self.runCmd("process launch", RUN_SUCCEEDED) self.runCmd("process launch", RUN_FAILED)
self.expect("expression -- m_a = 2", self.expect("expression -- m_a = 2",
startstr = "(int) $0 = 2") startstr = "(int) $0 = 2")
self.runCmd("process continue") self.runCmd("process continue")
# This would be disallowed if we enforced const. But we don't. # This would be disallowed if we enforced const. But we don't.
self.expect("expression -- m_a = 2", self.expect("expression -- m_a = 2",
Show All 10 Lines

test/linux/builtin_trap/TestBuiltinTrap.py

Show All 37 Lines def builtin_trap_unwind(self):
with a __builtin_trap intrinsic. with a __builtin_trap intrinsic.
""" """
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line,
num_expected_locations=1, num_expected_locations=1,
loc_exact=True) loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# print backtrace, expect both 'bar' and 'main' functions to be listed # print backtrace, expect both 'bar' and 'main' functions to be listed
self.expect('bt', substrs = ['bar', 'main']) self.expect('bt', substrs = ['bar', 'main'])
# go up one frame # go up one frame
self.runCmd("up", RUN_SUCCEEDED) self.runCmd("up", RUN_FAILED)
# evaluate a local # evaluate a local
self.expect('p foo', substrs = ['= 5']) self.expect('p foo', substrs = ['= 5'])
if __name__ == '__main__': if __name__ == '__main__':
import atexit import atexit
lldb.SBDebugger.Initialize() lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate()) atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main() unittest2.main()

test/lldbtest.py

Show First 20 Lines • Show All 81 Lines • ▼ Show 20 Lines
PROCESS_IS_VALID = "Process is valid" PROCESS_IS_VALID = "Process is valid"
PROCESS_KILLED = "Process is killed successfully" PROCESS_KILLED = "Process is killed successfully"
PROCESS_EXITED = "Process exited successfully" PROCESS_EXITED = "Process exited successfully"
PROCESS_STOPPED = "Process status should be stopped" PROCESS_STOPPED = "Process status should be stopped"
RUN_SUCCEEDED = "Process is launched successfully" RUN_FAILED = "Process could not be launched successfully"
RUN_COMPLETED = "Process exited successfully" RUN_COMPLETED = "Process exited successfully"
BACKTRACE_DISPLAYED_CORRECTLY = "Backtrace displayed correctly" BACKTRACE_DISPLAYED_CORRECTLY = "Backtrace displayed correctly"
BREAKPOINT_CREATED = "Breakpoint created successfully" BREAKPOINT_CREATED = "Breakpoint created successfully"
BREAKPOINT_STATE_CORRECT = "Breakpoint state is correct" BREAKPOINT_STATE_CORRECT = "Breakpoint state is correct"
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Lines
VALID_TYPE = "Got a valid type" VALID_TYPE = "Got a valid type"
VALID_VARIABLE = "Got a valid variable" VALID_VARIABLE = "Got a valid variable"
VARIABLES_DISPLAYED_CORRECTLY = "Variable(s) displayed correctly" VARIABLES_DISPLAYED_CORRECTLY = "Variable(s) displayed correctly"
WATCHPOINT_CREATED = "Watchpoint created successfully" WATCHPOINT_CREATED = "Watchpoint created successfully"
def CMD_MSG(str): def cmd_failure_message(cmd, res, msg=None):
'''A generic "Command '%s' returns successfully" message generator.''' """ Return a command failure message.
return "Command '%s' returns successfully" % str
Args:
cmd - The command which failed.
res - The command result of type SBCommandReturnObject.
msg - Additional failure message if any.
"""
err_msg = res.GetError()
full_msg = (err_msg or "") + (msg or "")
full_msg = (">>> %s" % full_msg.replace("\n", "\n>>> ")) if full_msg else ""
return "Command '%s' failed.\n%s" % (cmd, full_msg)
def COMPLETION_MSG(str_before, str_after): def COMPLETION_MSG(str_before, str_after):
'''A generic message generator for the completion mechanism.''' '''A generic message generator for the completion mechanism.'''
return "'%s' successfully completes to '%s'" % (str_before, str_after) return "'%s' successfully completes to '%s'" % (str_before, str_after)
def EXP_MSG(str, exe): def EXP_MSG(str, exe):
'''A generic "'%s' returns expected result" message generator if exe. '''A generic "'%s' returns expected result" message generator if exe.
Otherwise, it generates "'%s' matches expected result" message.''' Otherwise, it generates "'%s' matches expected result" message.'''
▲ Show 20 Lines • Show All 2,085 Lines • ▼ Show 20 Lines def runCmd(self, cmd, msg=None, check=True, trace=False, inHistory=False):
break break
elif running: elif running:
# For process launch, wait some time before possible next try. # For process launch, wait some time before possible next try.
time.sleep(self.timeWaitNextLaunch) time.sleep(self.timeWaitNextLaunch)
with recording(self, trace) as sbuf: with recording(self, trace) as sbuf:
print >> sbuf, "Command '" + cmd + "' failed!" print >> sbuf, "Command '" + cmd + "' failed!"
if check: if check:
self.assertTrue(self.res.Succeeded(), self.assertTrue(
msg if msg else CMD_MSG(cmd)) self.res.Succeeded(),
cmd_failure_message(cmd, self.res, msg))
def match (self, str, patterns, msg=None, trace=False, error=False, matching=True, exe=True): def match (self, str, patterns, msg=None, trace=False, error=False, matching=True, exe=True):
"""run command in str, and match the result against regexp in patterns returning the match object for the first matching pattern """run command in str, and match the result against regexp in patterns returning the match object for the first matching pattern
Otherwise, all the arguments have the same meanings as for the expect function""" Otherwise, all the arguments have the same meanings as for the expect function"""
trace = (True if traceAlways else trace) trace = (True if traceAlways else trace)
▲ Show 20 Lines • Show All 189 Lines • Show Last 20 Lines

test/macosx/universal/TestUniversal.py

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines def test_process_launch_for_universal(self):
self.expect("file " + exe, CURRENT_EXECUTABLE_SET, self.expect("file " + exe, CURRENT_EXECUTABLE_SET,
startstr = "Current executable set to ", startstr = "Current executable set to ",
substrs = ["testit' (x86_64)."]) substrs = ["testit' (x86_64)."])
# Break inside the main. # Break inside the main.
lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, num_expected_locations=1, loc_exact=True)
# We should be able to launch the x86_64 executable. # We should be able to launch the x86_64 executable.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# Check whether we have a 64-bit process launched. # Check whether we have a 64-bit process launched.
target = self.dbg.GetSelectedTarget() target = self.dbg.GetSelectedTarget()
process = target.GetProcess() process = target.GetProcess()
self.assertTrue(target and process and self.assertTrue(target and process and
self.invoke(process, 'GetAddressByteSize') == 8, self.invoke(process, 'GetAddressByteSize') == 8,
"64-bit process launched") "64-bit process launched")
frame = process.GetThreadAtIndex(0).GetFrameAtIndex(0) frame = process.GetThreadAtIndex(0).GetFrameAtIndex(0)
registers = print_registers(frame, string_buffer=True) registers = print_registers(frame, string_buffer=True)
self.expect(registers, exe=False, self.expect(registers, exe=False,
substrs = ['Name: rax']) substrs = ['Name: rax'])
self.runCmd("continue") self.runCmd("continue")
# Now specify i386 as the architecture for "testit". # Now specify i386 as the architecture for "testit".
self.expect("file -a i386 " + exe, CURRENT_EXECUTABLE_SET, self.expect("file -a i386 " + exe, CURRENT_EXECUTABLE_SET,
startstr = "Current executable set to ", startstr = "Current executable set to ",
substrs = ["testit' (i386)."]) substrs = ["testit' (i386)."])
# Break inside the main. # Break inside the main.
lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, num_expected_locations=1, loc_exact=True)
# We should be able to launch the i386 executable as well. # We should be able to launch the i386 executable as well.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# Check whether we have a 32-bit process launched. # Check whether we have a 32-bit process launched.
target = self.dbg.GetSelectedTarget() target = self.dbg.GetSelectedTarget()
process = target.GetProcess() process = target.GetProcess()
self.assertTrue(target and process, self.assertTrue(target and process,
"32-bit process launched") "32-bit process launched")
pointerSize = self.invoke(process, 'GetAddressByteSize') pointerSize = self.invoke(process, 'GetAddressByteSize')
Show All 16 Lines

test/python_api/formatters/TestFormattersSBAPI.py

Show All 39 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 formatters(self): def formatters(self):
"""Test Python APIs for working with formatters""" """Test Python APIs for working with formatters"""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
▲ Show 20 Lines • Show All 242 Lines • ▼ Show 20 Lines def formatters(self):
self.assertTrue(summary.GetData() == "hello static world", "wrong summary found for foo*") self.assertTrue(summary.GetData() == "hello static world", "wrong summary found for foo*")
def force_synth_off(self): def force_synth_off(self):
"""Test that one can have the public API return non-synthetic SBValues if desired""" """Test that one can have the public API return non-synthetic SBValues if desired"""
self.runCmd("file no_synth", CURRENT_EXECUTABLE_SET) self.runCmd("file no_synth", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
Show All 39 Lines

test/python_api/rdar-12481949/Test-rdar-12481949.py

Show All 32 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 rdar12481949_commands(self): def rdar12481949_commands(self):
"""Check that SBValue.GetValueAsSigned() does the right thing for a 32-bit -1.""" """Check that SBValue.GetValueAsSigned() does the right thing for a 32-bit -1."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
Show All 20 Lines

test/python_api/sbdata/TestSBData.py

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines def assert_data(self, func, arg, expected):
self.assertTrue(expected == result, "%s(error, %s) == %s != %s" % (func.__name__, arg, result, expected)) self.assertTrue(expected == result, "%s(error, %s) == %s != %s" % (func.__name__, arg, result, expected))
def data_api(self): def data_api(self):
"""Test the SBData APIs.""" """Test the SBData APIs."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
target = self.dbg.GetSelectedTarget() target = self.dbg.GetSelectedTarget()
▲ Show 20 Lines • Show All 276 Lines • Show Last 20 Lines

test/python_api/sbvalue_persist/TestSBValuePersist.py

Show All 31 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
def doTest(self): def doTest(self):
"""Test SBValue::Persist""" """Test SBValue::Persist"""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_source_regexp (self, "break here") lldbutil.run_break_set_by_source_regexp (self, "break here")
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
# 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.
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

test/python_api/value_var_update/TestValueVarUpdate.py

Show All 36 Linesclass HelloWorldTestCase(TestBase):
def do_test(self): def do_test(self):
"""Create target, breakpoint, launch a process, and then kill it.""" """Create target, breakpoint, launch a process, and then kill it."""
target = self.dbg.CreateTarget(self.exe) target = self.dbg.CreateTarget(self.exe)
breakpoint = target.BreakpointCreateBySourceRegex("break here", lldb.SBFileSpec("main.c")) breakpoint = target.BreakpointCreateBySourceRegex("break here", lldb.SBFileSpec("main.c"))
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# 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'])
i = self.frame().FindVariable("i") i = self.frame().FindVariable("i")
i_val = i.GetValueAsUnsigned(0) i_val = i.GetValueAsUnsigned(0)
Show All 25 Lines

test/settings/TestSettings.py

Show First 20 Lines • Show All 221 Lines • ▼ Show 20 Lines def pass_run_args_and_env_vars(self):
# 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"))
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# Read the output file produced by running the program. # Read the output file produced by running the program.
if lldb.remote_platform: if lldb.remote_platform:
self.runCmd('platform get-file "output2.txt" "output2.txt"') self.runCmd('platform get-file "output2.txt" "output2.txt"')
with open('output2.txt', 'r') as f: with open('output2.txt', 'r') as f:
output = f.read() output = f.read()
self.expect(output, exe=False, self.expect(output, exe=False,
Show All 19 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)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# Read the output file produced by running the program. # Read the output file produced by running the program.
if lldb.remote_platform: if lldb.remote_platform:
self.runCmd('platform get-file "output1.txt" "output1.txt"') self.runCmd('platform get-file "output1.txt" "output1.txt"')
with open('output1.txt', 'r') as f: with open('output1.txt', 'r') as f:
output = f.read() output = f.read()
self.expect(output, exe=False, self.expect(output, exe=False,
Show All 19 Lines def test_set_error_output_path(self):
self.expect("settings show target.error-path", self.expect("settings show target.error-path",
SETTING_MSG("target.error-path"), SETTING_MSG("target.error-path"),
substrs = ['target.error-path (file) = "stderr.txt"']) substrs = ['target.error-path (file) = "stderr.txt"'])
self.expect("settings show target.output-path", self.expect("settings show target.output-path",
SETTING_MSG("target.output-path"), SETTING_MSG("target.output-path"),
substrs = ['target.output-path (file) = "stdout.txt"']) substrs = ['target.output-path (file) = "stdout.txt"'])
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
if lldb.remote_platform: if lldb.remote_platform:
self.runCmd('platform get-file "stderr.txt" "stderr.txt"') self.runCmd('platform get-file "stderr.txt" "stderr.txt"')
self.runCmd('platform get-file "stdout.txt" "stdout.txt"') self.runCmd('platform get-file "stdout.txt" "stdout.txt"')
# The 'stderr.txt' file should now exist. # The 'stderr.txt' file should now exist.
self.assertTrue(os.path.isfile("stderr.txt"), self.assertTrue(os.path.isfile("stderr.txt"),
▲ Show 20 Lines • Show All 175 Lines • Show Last 20 Lines

test/source-manager/TestSourceManager.py

Show First 20 Lines • Show All 109 Lines • ▼ Show 20 Linesclass SourceManagerTestCase(TestBase):
def modify_source_file_while_debugging(self): def modify_source_file_while_debugging(self):
"""Modify a source file while debugging the executable.""" """Modify a source file while debugging the executable."""
exe = os.path.join(os.getcwd(), "a.out") exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped', substrs = ['stopped',
'main.c:%d' % self.line, 'main.c:%d' % self.line,
'stop reason = breakpoint']) 'stop reason = breakpoint'])
# Display some source code. # Display some source code.
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

test/types/AbstractBase.py

Show First 20 Lines • Show All 134 Lines • ▼ Show 20 Lines def generic_type_tester(self, exe_name, atoms, quotedDisplay=False, blockCaptured=False):
# Bring the program to the point where we can issue a series of # Bring the program to the point where we can issue a series of
# 'frame variable --show-types' command. # 'frame variable --show-types' command.
if blockCaptured: if blockCaptured:
break_line = line_number ("basic_type.cpp", "// Break here to test block captured variables.") break_line = line_number ("basic_type.cpp", "// Break here to test block captured variables.")
else: else:
break_line = line_number ("basic_type.cpp", "// Here is the line we will break on to check variables.") break_line = line_number ("basic_type.cpp", "// Here is the line we will break on to check variables.")
lldbutil.run_break_set_by_file_and_line (self, "basic_type.cpp", break_line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "basic_type.cpp", break_line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
self.expect("process status", STOPPED_DUE_TO_BREAKPOINT, self.expect("process status", STOPPED_DUE_TO_BREAKPOINT,
substrs = [" at basic_type.cpp:%d" % break_line, substrs = [" at basic_type.cpp:%d" % break_line,
"stop reason = breakpoint"]) "stop reason = breakpoint"])
#self.runCmd("frame variable --show-types") #self.runCmd("frame variable --show-types")
# Now iterate through the golden list, comparing against the output from # Now iterate through the golden list, comparing against the output from
# 'frame variable --show-types var'. # 'frame variable --show-types var'.
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Lines def generic_type_expr_tester(self, exe_name, atoms, quotedDisplay=False, blockCaptured=False):
# Bring the program to the point where we can issue a series of # Bring the program to the point where we can issue a series of
# 'expr' command. # 'expr' command.
if blockCaptured: if blockCaptured:
break_line = line_number ("basic_type.cpp", "// Break here to test block captured variables.") break_line = line_number ("basic_type.cpp", "// Break here to test block captured variables.")
else: else:
break_line = line_number ("basic_type.cpp", "// Here is the line we will break on to check variables.") break_line = line_number ("basic_type.cpp", "// Here is the line we will break on to check variables.")
lldbutil.run_break_set_by_file_and_line (self, "basic_type.cpp", break_line, num_expected_locations=1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "basic_type.cpp", break_line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
self.expect("process status", STOPPED_DUE_TO_BREAKPOINT, self.expect("process status", STOPPED_DUE_TO_BREAKPOINT,
substrs = [" at basic_type.cpp:%d" % break_line, substrs = [" at basic_type.cpp:%d" % break_line,
"stop reason = breakpoint"]) "stop reason = breakpoint"])
#self.runCmd("frame variable --show-types") #self.runCmd("frame variable --show-types")
# Now iterate through the golden list, comparing against the output from # Now iterate through the golden list, comparing against the output from
# 'expr var'. # 'expr var'.
Show All 28 Lines

test/types/TestRecursiveTypes.py

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines def test_recursive_dwarf_type_2(self):
self.buildDwarf(dictionary=self.d2) self.buildDwarf(dictionary=self.d2)
self.print_struct() self.print_struct()
def print_struct(self): def print_struct(self):
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line (self, "recursive_type_main.cpp", self.line, num_expected_locations=-1, loc_exact=True) lldbutil.run_break_set_by_file_and_line (self, "recursive_type_main.cpp", self.line, num_expected_locations=-1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_FAILED)
self.expect("print tpi", RUN_SUCCEEDED) self.expect("print tpi", RUN_FAILED)
self.expect("print *tpi", RUN_SUCCEEDED) self.expect("print *tpi", RUN_FAILED)
if __name__ == '__main__': if __name__ == '__main__':
import atexit import atexit
lldb.SBDebugger.Initialize() lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate()) atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main() unittest2.main()