This is an archive of the discontinued LLVM Phabricator instance.

Differential D8665

Replace sys.platform skips in tests with @skip decorators which check against remote platform.
ClosedPublic

Authored by flackr on Mar 27 2015, 10:06 AM.

Details

Reviewers
clayborg
tberghammer
Commits
rG13c7ad9cd245: Replace sys.platform skips in tests with @skip decorators which check against…
rLLDB233547: Replace sys.platform skips in tests with @skip decorators which check against…
rL233547: Replace sys.platform skips in tests with @skip decorators which check against…
Summary

Adds @skipIfPlatform and @skipUnlessPlatform decorators which will skip if / unless the target platform is in the provided platform list.

Diff Detail

Repository
rL LLVM

Event Timeline

flackr updated this revision to Diff 22803.Mar 27 2015, 10:06 AM
flackr retitled this revision from to Replace sys.platform skips in tests with @skip decorators which check against remote platform..
flackr updated this object.
flackr edited the test plan for this revision. (Show Details)
flackr added reviewers: clayborg, tberghammer.
flackr set the repository for this revision to rL LLVM.
flackr added a subscriber: Unknown Object (MLST).
clayborg accepted this revision.Mar 27 2015, 10:19 AM
clayborg edited edge metadata.

lgtm

This revision is now accepted and ready to land.Mar 27 2015, 10:19 AM
tberghammer accepted this revision.Mar 30 2015, 3:55 AM
tberghammer edited edge metadata.

lgtm

Closed by commit rL233547: Replace sys.platform skips in tests with @skip decorators which check against… (authored by flackr). · Explain WhyMar 30 2015, 7:16 AM
This revision was automatically updated to reflect the committed changes.
emaste added a subscriber: emaste.Mar 31 2015, 9:27 AM

This causes massive test run failures on FreeBSD because the triple OS component is 'freebsd10.1'

flackr added a comment.Mar 31 2015, 10:05 AM
In D8665#149727, @emaste wrote:

This causes massive test run failures on FreeBSD because the triple OS component is 'freebsd10.1'

I can update this to continue to do a prefix string check to ignore version number. Why do we have a version number in the OS component on freebsd but not the other platforms as far as I can tell?

emaste added a comment.Mar 31 2015, 10:14 AM
In D8665#149727, @emaste wrote:

This causes massive test run failures on FreeBSD because the triple OS component is 'freebsd10.1'

Fixed in rL233705

dawn added a subscriber: dawn.Apr 7 2015, 2:53 PM
dawn added a comment.Apr 7 2015, 3:07 PM

This change (committed in rev.233547) caused many tests to no longer run on our OSX Jenkins build. Since we check that a minimum number of tests run, our build is now failing. We run the tests using:

./dosep.py --options "-v --executable $INSTALLDIR/bin/lldb" 2>&1 | tee $INSTALLDIR/test_out.log || true

Tests which used to run (like test_NSString_expr_commands_with_dwarf (TestObjCMethods2.FoundationTestCase2) and 11 other tests in that same file) aren't reported as skipped - they are simply absent from the log.
Please rework this patch? Thank you.

ki.stfu mentioned this in rL233547: Replace sys.platform skips in tests with @skip decorators which check against….Apr 7 2015, 10:49 PM

Revision Contents

PathSize
test/
benchmarks/
continue/
2 lines
driver/
batch_mode/
2 lines
expression_command/
call-function/
2 lines
2 lines
call-restarts/
2 lines
call-throws/
4 lines
formatters/
2 lines
persist_objc_pointeetype/
4 lines
po_verbosity/
4 lines
timeout/
2 lines
two-files/
4 lines
functionalities/
abbreviation/
4 lines
2 lines
alias/
2 lines
asan/
2 lines
2 lines
breakpoint/
breakpoint_command/
2 lines
2 lines
2 lines
breakpoint_conditions/
12 lines
breakpoint_ids/
2 lines
breakpoint_ignore_count/
4 lines
breakpoint_locations/
2 lines
cpp/
2 lines
cpp_exception/
2 lines
dummy_target_breakpoints/
2 lines
inlined_breakpoints/
2 lines
objc/
2 lines
command_script/
2 lines
conditional_break/
4 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-globals/
2 lines
data-formatter-named-summaries/
2 lines
data-formatter-objc/
60 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/
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/
2 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/
4 lines
rdar-10887661/
2 lines
rdar-11086338/
4 lines
rdar-11628688/
4 lines
rdar-11773899/
4 lines
rdar-11988289/
4 lines
rdar-12437442/
4 lines
rdar-12529957/
4 lines
rdar-13338477/
2 lines
rdar-3534688/
4 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
disassembly/
2 lines
dynamic_value_child_count/
2 lines
embedded_interpreter/
2 lines
exec/
4 lines
expr-doesnt-deadlock/
2 lines
fat_archives/
2 lines
inferior-assert/
8 lines
inferior-changed/
2 lines
inferior-crashing/
12 lines
recursive-inferior/
12 lines
inline-stepping/
4 lines
launch_with_shellexpand/
2 lines
memory/
read/
2 lines
nosucharch/
4 lines
paths/
2 lines
plugins/
python_os_plugin/
2 lines
process_attach/
4 lines
process_launch/
4 lines
recursion/
2 lines
rerun/
2 lines
return-value/
2 lines
set-data/
2 lines
signal/
2 lines
step-avoids-no-debug/
6 lines
stop-hook/
2 lines
2 lines
multiple_threads/
2 lines
target_command/
4 lines
thread/
2 lines
break_after_join/
2 lines
create_after_attach/
2 lines
create_during_step/
6 lines
exit_during_break/
2 lines
exit_during_step/
8 lines
jump/
2 lines
multi_break/
2 lines
state/
10 lines
thread_exit/
2 lines
thread_specific_break/
2 lines
tty/
2 lines
type_completion/
2 lines
unwind/
noreturn/
2 lines
sigtramp/
4 lines
value_md5_crash/
2 lines
watchpoint/
hello_watchlocation/
2 lines
multiple_threads/
4 lines
step_over_watchpoint/
2 lines
watchpoint_commands/
10 lines
command/
4 lines
2 lines
condition/
2 lines
watchpoint_events/
2 lines
watchpoint_set_command/
2 lines
lang/
c/
array_types/
4 lines
bitfields/
8 lines
enum_types/
2 lines
forward/
2 lines
function_types/
4 lines
global_variables/
2 lines
set_values/
2 lines
stepping/
2 lines
2 lines
strings/
2 lines
tls_globals/
2 lines
cpp/
bool/
2 lines
breakpoints/
2 lines
call-function/
2 lines
char1632_t/
2 lines
class_static/
4 lines
class_types/
8 lines
4 lines
diamond/
2 lines
dynamic-value/
4 lines
2 lines
enum_types/
16 lines
exceptions/
2 lines
namespace/
2 lines
overloaded-functions/
2 lines
rdar12991846/
6 lines
rvalue-references/
2 lines
signed_types/
2 lines
static_members/
2 lines
static_methods/
2 lines
stl/
2 lines
this/
2 lines
unique-types/
2 lines
unsigned_types/
2 lines
virtual/
4 lines
wchar_t/
2 lines
objc/
blocks/
4 lines
forward-decl/
4 lines
foundation/
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
hidden-ivars/
16 lines
objc++/
2 lines
objc-baseclass-sbtype/
4 lines
objc-builtin-types/
2 lines
objc-checker/
4 lines
objc-class-method/
4 lines
objc-dyn-sbtype/
2 lines
objc-dynamic-value/
4 lines
objc-ivar-offsets/
4 lines
objc-ivar-stripped/
2 lines
objc-new-syntax/
2 lines
objc-optimized/
2 lines
objc-property/
4 lines
objc-static-method-stripped/
2 lines
objc-static-method/
4 lines
objc-stepping/
4 lines
objc-struct-return/
4 lines
objc-super/
4 lines
print-obj/
2 lines
radar-9691614/
2 lines
rdar-10967107/
2 lines
rdar-11355592/
2 lines
rdar-12408181/
2 lines
real-definition/
8 lines
self/
4 lines
linux/
builtin_trap/
2 lines
2 lines
105 lines
logging/
2 lines
macosx/
add-dsym/
2 lines
debug-info/
apple_types/
4 lines
indirect_symbol/
4 lines
order/
4 lines
queues/
4 lines
safe-to-func-call/
4 lines
universal/
8 lines
python_api/
breakpoint/
2 lines
class_members/
4 lines
event/
10 lines
findvalue_duplist/
2 lines
formatters/
2 lines
frame/
2 lines
inlines/
2 lines
function_symbol/
2 lines
2 lines
hello_world/
6 lines
interpreter/
2 lines
objc_type/
4 lines
process/
6 lines
io/
20 lines
rdar-12481949/
2 lines
sbdata/
2 lines
sbvalue_persist/
2 lines
section/
2 lines
symbol-context/
2 lines
target/
20 lines
thread/
10 lines
type/
2 lines
value/
2 lines
change_values/
2 lines
linked_list/
2 lines
value_var_update/
2 lines
watchpoint/
2 lines
2 lines
2 lines
condition/
2 lines
watchlocation/
2 lines
4 lines
settings/
2 lines
tools/
lldb-mi/
signal/
4 lines
stack/
2 lines
lldb-server/
8 lines
2 lines
types/
10 lines
10 lines
10 lines
42 lines
42 lines
warnings/
uuid/
2 lines

Diff 22803

test/benchmarks/continue/TestBenchmarkContinue.py

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbbench import * from lldbbench import *
import lldbutil import lldbutil
class TestBenchmarkContinue(BenchBase): class TestBenchmarkContinue(BenchBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@benchmarks_test @benchmarks_test
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Benchmark different ways to continue a process""" """Benchmark different ways to continue a process"""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@benchmarks_test @benchmarks_test
@skipIfLinux # No standard locations for libc++ on Linux, so skip for now @skipIfLinux # No standard locations for libc++ on Linux, so skip for now
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

test/driver/batch_mode/TestBatchMode.py

Show All 9 Lines
except: except:
pexpect = None pexpect = None
from lldbtest import * from lldbtest import *
class DriverBatchModeTest (TestBase): class DriverBatchModeTest (TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@unittest2.expectedFailure("<rdar://problem/18684124>, lldb doesn't reliably print the prompt when run under pexpect") @unittest2.expectedFailure("<rdar://problem/18684124>, lldb doesn't reliably print the prompt when run under pexpect")
@dsym_test @dsym_test
def test_driver_batch_mode_with_dsym(self): def test_driver_batch_mode_with_dsym(self):
"""Test that the lldb driver's batch mode works correctly.""" """Test that the lldb driver's batch mode works correctly."""
self.buildDsym() self.buildDsym()
self.setTearDownCleanup() self.setTearDownCleanup()
self.batch_mode () self.batch_mode ()
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

test/expression_command/call-function/TestCallStdStringFunction.py

Show All 12 Linesclass ExprCommandCallFunctionTestCase(TestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break for main.c. # Find the line number to break for main.c.
self.line = line_number('main.cpp', self.line = line_number('main.cpp',
'// Please test these expressions while stopped at this line:') '// Please test these expressions while stopped at this line:')
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
@expectedFailureDarwin(16361880) # <rdar://problem/16361880>, we get the result correctly, but fail to invoke the Summary formatter. @expectedFailureDarwin(16361880) # <rdar://problem/16361880>, we get the result correctly, but fail to invoke the Summary formatter.
def test_with_dsym(self): def test_with_dsym(self):
"""Test calling std::String member function.""" """Test calling std::String member function."""
self.buildDsym() self.buildDsym()
self.call_function() self.call_function()
@dwarf_test @dwarf_test
Show All 30 Lines

test/expression_command/call-function/TestCallStopAndContinue.py

Show All 14 Lines def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break for main.c. # Find the line number to break for main.c.
self.line = line_number('main.cpp', self.line = line_number('main.cpp',
'// Please test these expressions while stopped at this line:') '// Please test these expressions while stopped at this line:')
self.func_line = line_number ('main.cpp', self.func_line = line_number ('main.cpp',
'{ 5, "five" }') '{ 5, "five" }')
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
@expectedFailureDarwin("llvm.org/pr20274") # intermittent failure on MacOSX @expectedFailureDarwin("llvm.org/pr20274") # intermittent failure on MacOSX
def test_with_dsym(self): def test_with_dsym(self):
"""Test gathering result from interrupted function call.""" """Test gathering result from interrupted function call."""
self.buildDsym() self.buildDsym()
self.call_function() self.call_function()
@dwarf_test @dwarf_test
Show All 32 Lines

test/expression_command/call-restarts/TestCallThatRestarts.py

Show All 13 Linesclass ExprCommandThatRestartsTestCase(TestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
self.main_source = "lotta-signals.c" self.main_source = "lotta-signals.c"
self.main_source_spec = lldb.SBFileSpec (self.main_source) self.main_source_spec = lldb.SBFileSpec (self.main_source)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
@skipIfDarwin # llvm.org/pr19246: intermittent failure @skipIfDarwin # llvm.org/pr19246: intermittent failure
def test_with_dsym(self): def test_with_dsym(self):
"""Test calling std::String member function.""" """Test calling std::String member function."""
self.buildDsym() self.buildDsym()
self.call_function() self.call_function()
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 123 Lines • Show Last 20 Lines

test/expression_command/call-throws/TestCallThatThrows.py

Show All 13 Linesclass ExprCommandWithThrowTestCase(TestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
self.main_source = "call-throws.m" self.main_source = "call-throws.m"
self.main_source_spec = lldb.SBFileSpec (self.main_source) self.main_source_spec = lldb.SBFileSpec (self.main_source)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test calling a function that throws and ObjC exception.""" """Test calling a function that throws and ObjC exception."""
self.buildDsym() self.buildDsym()
self.call_function() self.call_function()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin due to ObjC test case") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_with_dwarf(self): def test_with_dwarf(self):
"""Test calling a function that throws and ObjC exception.""" """Test calling a function that throws and ObjC exception."""
self.buildDwarf() self.buildDwarf()
self.call_function() self.call_function()
def check_after_call (self): def check_after_call (self):
# Check that we are back where we were before: # Check that we are back where we were before:
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

test/expression_command/formatters/TestFormatters.py

Show All 12 Linesclass ExprFormattersTestCase(TestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break for main.cpp. # Find the line number to break for main.cpp.
self.line = line_number('main.cpp', self.line = line_number('main.cpp',
'// Stop here') '// Stop here')
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test expr + formatters for good interoperability.""" """Test expr + formatters for good interoperability."""
self.buildDsym() self.buildDsym()
self.do_my_test() self.do_my_test()
@expectedFailureFreeBSD('llvm.org/pr19011') # Newer Clang omits C1 complete object constructor @expectedFailureFreeBSD('llvm.org/pr19011') # Newer Clang omits C1 complete object constructor
@expectedFailureLinux('llvm.org/pr20230') @expectedFailureLinux('llvm.org/pr20230')
▲ Show 20 Lines • Show All 147 Lines • Show Last 20 Lines

test/expression_command/persist_objc_pointeetype/TestPersistObjCPointeeType.py

Show All 11 Linesclass PersistObjCPointeeType(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break for main.cpp. # Find the line number to break for main.cpp.
self.line = line_number('main.m','// break here') self.line = line_number('main.m','// break here')
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test that we can p *objcObject""" """Test that we can p *objcObject"""
self.buildDsym() self.buildDsym()
self.do_my_test() self.do_my_test()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin due to ObjC test case") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_with_dwarf(self): def test_with_dwarf(self):
"""Test that we can p *objcObject""" """Test that we can p *objcObject"""
self.buildDwarf() self.buildDwarf()
self.do_my_test() self.do_my_test()
def do_my_test(self): def do_my_test(self):
def cleanup(): def cleanup():
Show All 25 Lines

test/expression_command/po_verbosity/TestPoVerbosity.py

Show All 12 Linesclass PoVerbosityTestCase(TestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break for main.cpp. # Find the line number to break for main.cpp.
self.line = line_number('main.m', self.line = line_number('main.m',
'// Stop here') '// Stop here')
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test that the po command acts correctly.""" """Test that the po command acts correctly."""
self.buildDsym() self.buildDsym()
self.do_my_test() self.do_my_test()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin due to ObjC test case") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_with_dwarf(self): def test_with_dwarf(self):
"""Test that the po command acts correctly.""" """Test that the po command acts correctly."""
self.buildDwarf() self.buildDwarf()
self.do_my_test() self.do_my_test()
def do_my_test(self): def do_my_test(self):
Show All 40 Lines

test/expression_command/timeout/TestCallWithTimeout.py

Show All 13 Linesclass ExprCommandWithTimeoutsTestCase(TestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
self.main_source = "wait-a-while.cpp" self.main_source = "wait-a-while.cpp"
self.main_source_spec = lldb.SBFileSpec (self.main_source) self.main_source_spec = lldb.SBFileSpec (self.main_source)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test calling std::String member function.""" """Test calling std::String member function."""
self.buildDsym() self.buildDsym()
self.call_function() self.call_function()
@expectedFailureFreeBSD("llvm.org/pr19605") # fails on buildbot @expectedFailureFreeBSD("llvm.org/pr19605") # fails on buildbot
@expectedFailureLinux("llvm.org/pr20275") # fails intermittently on Linux @expectedFailureLinux("llvm.org/pr20275") # fails intermittently on Linux
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

test/expression_command/two-files/TestObjCTypeQueryFromOtherCompileUnit.py

Show All 14 Linesclass ObjCTypeQueryTestCase(TestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break for main.m. # Find the line number to break for main.m.
self.line = line_number('main.m', self.line = line_number('main.m',
"// Set breakpoint here, then do 'expr (NSArray*)array_token'.") "// Set breakpoint here, then do 'expr (NSArray*)array_token'.")
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(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.buildDsym() self.buildDsym()
self.type_query_from_other_cu() self.type_query_from_other_cu()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_with_dwarf(self): def test_with_dwarf(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.buildDwarf() self.buildDwarf()
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."""
Show All 17 Lines

test/functionalities/abbreviation/TestAbbreviations.py

""" """
Test some lldb command abbreviations. Test some lldb command abbreviations.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class AbbreviationsTestCase(TestBase): class AbbreviationsTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@expectedFailureFreeBSD("llvm.org/pr22611 thread race condition breaks prompt setting") @expectedFailureFreeBSD("llvm.org/pr22611 thread race condition breaks prompt setting")
@unittest2.skipIf(sys.platform.startswith("win32"), "one-shot script commands deadlock on Windows.") @skipIfWindows # one-shot script commands deadlock on Windows.
def test_nonrunning_command_abbreviations (self): def test_nonrunning_command_abbreviations (self):
self.expect("ap script", self.expect("ap script",
startstr = "The following built-in commands may relate to 'script':", startstr = "The following built-in commands may relate to 'script':",
substrs = ['breakpoint command add', substrs = ['breakpoint command add',
'breakpoint command list', 'breakpoint command list',
'breakpoint list', 'breakpoint list',
'command alias', 'command alias',
'expression', 'expression',
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines def test_nonrunning_command_abbreviations (self):
# We don't want to display the stdout if not in TraceOn() mode. # We don't want to display the stdout if not in TraceOn() mode.
if not self.TraceOn(): if not self.TraceOn():
self.HideStdout() self.HideStdout()
self.runCmd (r'''sc print "\n\n\tHello!\n"''') self.runCmd (r'''sc print "\n\n\tHello!\n"''')
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym (self): def test_with_dsym (self):
self.buildDsym () self.buildDsym ()
self.running_abbreviations () self.running_abbreviations ()
@dwarf_test @dwarf_test
@expectedFailureLinux # not related to abbreviations, "dis -f" output has int3 in it @expectedFailureLinux # not related to abbreviations, "dis -f" output has int3 in it
def test_with_dwarf (self): def test_with_dwarf (self):
▲ Show 20 Lines • Show All 100 Lines • Show Last 20 Lines

test/functionalities/abbreviation/TestCommonShortSpellings.py

""" """
Test some lldb command abbreviations to make sure the common short spellings of Test some lldb command abbreviations to make sure the common short spellings of
many commands remain available even after we add/delte commands in the future. many commands remain available even after we add/delte commands in the future.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class CommonShortSpellingsTestCase(TestBase): class CommonShortSpellingsTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym (self): def test_with_dsym (self):
self.buildDsym () self.buildDsym ()
self.run_abbrevs2 () self.run_abbrevs2 ()
@dwarf_test @dwarf_test
def test_with_dwarf (self): def test_with_dwarf (self):
self.buildDwarf () self.buildDwarf ()
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

test/functionalities/alias/TestAliases.py

""" """
Test lldb command aliases. Test lldb command aliases.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class AliasTestCase(TestBase): class AliasTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym (self): def test_with_dsym (self):
self.buildDsym () self.buildDsym ()
self.alias_tests () self.alias_tests ()
@dwarf_test @dwarf_test
def test_with_dwarf (self): def test_with_dwarf (self):
self.buildDwarf () self.buildDwarf ()
▲ Show 20 Lines • Show All 143 Lines • Show Last 20 Lines

test/functionalities/asan/TestMemoryHistory.py

Show All 13 Linesclass AsanTestCase(TestBase):
# The default compiler ("clang") may not support Address Sanitizer or it # The default compiler ("clang") may not support Address Sanitizer or it
# may not have the debugging API which was recently added, so we're calling # may not have the debugging API which was recently added, so we're calling
# self.useBuiltClang() to use clang from the llvm-build directory instead # self.useBuiltClang() to use clang from the llvm-build directory instead
@dsym_test @dsym_test
@skipIfRemote @skipIfRemote
@skipUnlessCompilerRt @skipUnlessCompilerRt
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
def test_with_dsym (self): def test_with_dsym (self):
compiler = self.findBuiltClang () compiler = self.findBuiltClang ()
self.buildDsym (None, compiler) self.buildDsym (None, compiler)
self.asan_tests () self.asan_tests ()
@dwarf_test @dwarf_test
@expectedFailureLinux # non-core functionality, need to reenable and fix later (DES 2014.11.07) @expectedFailureLinux # non-core functionality, need to reenable and fix later (DES 2014.11.07)
@skipIfFreeBSD # llvm.org/pr21136 runtimes not yet available by default @skipIfFreeBSD # llvm.org/pr21136 runtimes not yet available by default
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

test/functionalities/asan/TestReportData.py

Show All 14 Linesclass AsanTestReportDataCase(TestBase):
# The default compiler ("clang") may not support Address Sanitizer or it # The default compiler ("clang") may not support Address Sanitizer or it
# may not have the debugging API which was recently added, so we're calling # may not have the debugging API which was recently added, so we're calling
# self.useBuiltClang() to use clang from the llvm-build directory instead # self.useBuiltClang() to use clang from the llvm-build directory instead
@dsym_test @dsym_test
@skipIfRemote @skipIfRemote
@skipUnlessCompilerRt @skipUnlessCompilerRt
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
def test_with_dsym (self): def test_with_dsym (self):
compiler = self.findBuiltClang () compiler = self.findBuiltClang ()
self.buildDsym (None, compiler) self.buildDsym (None, compiler)
self.asan_tests () self.asan_tests ()
@dwarf_test @dwarf_test
@expectedFailureLinux # non-core functionality, need to reenable and fix later (DES 2014.11.07) @expectedFailureLinux # non-core functionality, need to reenable and fix later (DES 2014.11.07)
@skipIfFreeBSD # llvm.org/pr21136 runtimes not yet available by default @skipIfFreeBSD # llvm.org/pr21136 runtimes not yet available by default
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

test/functionalities/breakpoint/breakpoint_command/TestBreakpointCommand.py

Show All 12 Linesclass BreakpointCommandTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@classmethod @classmethod
def classCleanup(cls): def classCleanup(cls):
"""Cleanup the test byproduct of breakpoint_command_sequence(self).""" """Cleanup the test byproduct of breakpoint_command_sequence(self)."""
cls.RemoveTempFile("output.txt") cls.RemoveTempFile("output.txt")
cls.RemoveTempFile("output2.txt") cls.RemoveTempFile("output2.txt")
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test a sequence of breakpoint command add, list, and delete.""" """Test a sequence of breakpoint command add, list, and delete."""
self.buildDsym() self.buildDsym()
self.breakpoint_command_sequence() self.breakpoint_command_sequence()
self.breakpoint_command_script_parameters () self.breakpoint_command_script_parameters ()
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 188 Lines • Show Last 20 Lines

test/functionalities/breakpoint/breakpoint_command/TestBreakpointCommandsFromPython.py

""" """
Test that you can set breakpoint commands successfully with the Python API's: Test that you can set breakpoint commands successfully with the Python API's:
""" """
import os import os
import re import re
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
import sys import sys
from lldbtest import * from lldbtest import *
class PythonBreakpointCommandSettingTestCase(TestBase): class PythonBreakpointCommandSettingTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
my_var = 10 my_var = 10
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_step_out_with_dsym_python(self): def test_step_out_with_dsym_python(self):
"""Test stepping out using avoid-no-debug with dsyms.""" """Test stepping out using avoid-no-debug with dsyms."""
self.buildDsym() self.buildDsym()
self.do_set_python_command_from_python() self.do_set_python_command_from_python()
@python_api_test @python_api_test
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

test/functionalities/breakpoint/breakpoint_command/TestRegexpBreakCommand.py

""" """
Test _regexp-break command which uses regular expression matching to dispatch to other built in breakpoint commands. Test _regexp-break command which uses regular expression matching to dispatch to other built in breakpoint commands.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class RegexpBreakCommandTestCase(TestBase): class RegexpBreakCommandTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test _regexp-break command.""" """Test _regexp-break command."""
self.buildDsym() self.buildDsym()
self.regexp_break_command() self.regexp_break_command()
@dwarf_test @dwarf_test
def test_with_dwarf(self): def test_with_dwarf(self):
Show All 40 Lines

test/functionalities/breakpoint/breakpoint_conditions/TestBreakpointConditions.py

""" """
Test breakpoint conditions with 'breakpoint modify -c <expr> id'. Test breakpoint conditions with 'breakpoint modify -c <expr> id'.
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
from lldbtest import * from lldbtest import *
class BreakpointConditionsTestCase(TestBase): class BreakpointConditionsTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_breakpoint_condition_with_dsym_and_run_command(self): def test_breakpoint_condition_with_dsym_and_run_command(self):
"""Exercise breakpoint condition with 'breakpoint modify -c <expr> id'.""" """Exercise breakpoint condition with 'breakpoint modify -c <expr> id'."""
self.buildDsym() self.buildDsym()
self.breakpoint_conditions() self.breakpoint_conditions()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_breakpoint_condition_inline_with_dsym_and_run_command(self): def test_breakpoint_condition_inline_with_dsym_and_run_command(self):
"""Exercise breakpoint condition inline with 'breakpoint set'.""" """Exercise breakpoint condition inline with 'breakpoint set'."""
self.buildDsym() self.buildDsym()
self.breakpoint_conditions(inline=True) self.breakpoint_conditions(inline=True)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_breakpoint_condition_with_dsym_and_python_api(self): def test_breakpoint_condition_with_dsym_and_python_api(self):
"""Use Python APIs to set breakpoint conditions.""" """Use Python APIs to set breakpoint conditions."""
self.buildDsym() self.buildDsym()
self.breakpoint_conditions_python() self.breakpoint_conditions_python()
@dwarf_test @dwarf_test
@unittest2.skipIf(sys.platform.startswith("win32"), "Requires EE to support COFF on Windows (http://llvm.org/pr22232)") @skipIfWindows # Requires EE to support COFF on Windows (http://llvm.org/pr22232)
def test_breakpoint_condition_with_dwarf_and_run_command(self): def test_breakpoint_condition_with_dwarf_and_run_command(self):
"""Exercise breakpoint condition with 'breakpoint modify -c <expr> id'.""" """Exercise breakpoint condition with 'breakpoint modify -c <expr> id'."""
self.buildDwarf() self.buildDwarf()
self.breakpoint_conditions() self.breakpoint_conditions()
@dwarf_test @dwarf_test
@unittest2.skipIf(sys.platform.startswith("win32"), "Requires EE to support COFF on Windows (http://llvm.org/pr22232)") @skipIfWindows # Requires EE to support COFF on Windows (http://llvm.org/pr22232)
def test_breakpoint_condition_inline_with_dwarf_and_run_command(self): def test_breakpoint_condition_inline_with_dwarf_and_run_command(self):
"""Exercise breakpoint condition inline with 'breakpoint set'.""" """Exercise breakpoint condition inline with 'breakpoint set'."""
self.buildDwarf() self.buildDwarf()
self.breakpoint_conditions(inline=True) self.breakpoint_conditions(inline=True)
@python_api_test @python_api_test
@dwarf_test @dwarf_test
@unittest2.skipIf(sys.platform.startswith("win32"), "Requires EE to support COFF on Windows (http://llvm.org/pr22232)") @skipIfWindows # Requires EE to support COFF on Windows (http://llvm.org/pr22232)
def test_breakpoint_condition_with_dwarf_and_python_api(self): def test_breakpoint_condition_with_dwarf_and_python_api(self):
"""Use Python APIs to set breakpoint conditions.""" """Use Python APIs to set breakpoint conditions."""
self.buildDwarf() self.buildDwarf()
self.breakpoint_conditions_python() self.breakpoint_conditions_python()
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
▲ Show 20 Lines • Show All 140 Lines • Show Last 20 Lines

test/functionalities/breakpoint/breakpoint_ids/TestBreakpointIDs.py

""" """
Test lldb breakpoint ids. Test lldb breakpoint ids.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class BreakpointIDTestCase(TestBase): class BreakpointIDTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym (self): def test_with_dsym (self):
self.buildDsym () self.buildDsym ()
self.breakpoint_id_tests () self.breakpoint_id_tests ()
@dwarf_test @dwarf_test
def test_with_dwarf (self): def test_with_dwarf (self):
self.buildDwarf () self.buildDwarf ()
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

test/functionalities/breakpoint/breakpoint_ignore_count/TestBreakpointIgnoreCount.py

""" """
Test breakpoint ignore count features. Test breakpoint ignore count features.
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
from lldbtest import * from lldbtest import *
class BreakpointIgnoreCountTestCase(TestBase): class BreakpointIgnoreCountTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Exercise breakpoint ignore count with 'breakpoint set -i <count>'.""" """Exercise breakpoint ignore count with 'breakpoint set -i <count>'."""
self.buildDsym() self.buildDsym()
self.breakpoint_ignore_count() self.breakpoint_ignore_count()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym_and_python_api(self): def test_with_dsym_and_python_api(self):
"""Use Python APIs to set breakpoint ignore count.""" """Use Python APIs to set breakpoint ignore count."""
self.buildDsym() self.buildDsym()
self.breakpoint_ignore_count_python() self.breakpoint_ignore_count_python()
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 126 Lines • Show Last 20 Lines

test/functionalities/breakpoint/breakpoint_locations/TestBreakpointLocations.py

""" """
Test breakpoint commands for a breakpoint ID with multiple locations. Test breakpoint commands for a breakpoint ID with multiple locations.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class BreakpointLocationsTestCase(TestBase): class BreakpointLocationsTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test breakpoint enable/disable for a breakpoint ID with multiple locations.""" """Test breakpoint enable/disable for a breakpoint ID with multiple locations."""
self.buildDsym() self.buildDsym()
self.breakpoint_locations_test() self.breakpoint_locations_test()
@dwarf_test @dwarf_test
def test_with_dwarf(self): def test_with_dwarf(self):
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

test/functionalities/breakpoint/cpp/TestCPPBreakpoints.py

""" """
Test lldb breakpoint ids. Test lldb breakpoint ids.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class TestCPPBreakpoints(TestBase): class TestCPPBreakpoints(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym (self): def test_with_dsym (self):
self.buildDsym () self.buildDsym ()
self.breakpoint_id_tests () self.breakpoint_id_tests ()
@dwarf_test @dwarf_test
def test_with_dwarf (self): def test_with_dwarf (self):
self.buildDwarf () self.buildDwarf ()
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

test/functionalities/breakpoint/cpp_exception/TestCPPExceptionBreakpoint.py

""" """
Test that you can set breakpoint and hit the C++ language exception breakpoint Test that you can set breakpoint and hit the C++ language exception breakpoint
""" """
import os import os
import re import re
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
import sys import sys
from lldbtest import * from lldbtest import *
class TestCPPExceptionBreakpoint (TestBase): class TestCPPExceptionBreakpoint (TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
my_var = 10 my_var = 10
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_cpp_exception_breakpoint (self): def test_cpp_exception_breakpoint (self):
"""Test setting and hitting the C++ exception breakpoint.""" """Test setting and hitting the C++ exception breakpoint."""
self.buildDsym() self.buildDsym()
self.do_cpp_exception_bkpt () self.do_cpp_exception_bkpt ()
@python_api_test @python_api_test
Show All 33 Lines

test/functionalities/breakpoint/dummy_target_breakpoints/TestBreakpointsWithNoTargets.py

""" """
Test breakpoint commands set before we have a target Test breakpoint commands set before we have a target
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class BreakpointInDummyTarget (TestBase): class BreakpointInDummyTarget (TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test breakpoint set before we have a target. """ """Test breakpoint set before we have a target. """
self.buildDsym() self.buildDsym()
self.dummy_breakpoint_test() self.dummy_breakpoint_test()
@dwarf_test @dwarf_test
def test_with_dwarf(self): def test_with_dwarf(self):
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

test/functionalities/breakpoint/inlined_breakpoints/TestInlinedBreakpoints.py

""" """
Test that inlined breakpoints (breakpoint set on a file/line included from Test that inlined breakpoints (breakpoint set on a file/line included from
another source file) works correctly. another source file) works correctly.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class InlinedBreakpointsTestCase(TestBase): class InlinedBreakpointsTestCase(TestBase):
"""Bug fixed: rdar://problem/8464339""" """Bug fixed: rdar://problem/8464339"""
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test 'b basic_types.cpp:176' does break (where int.cpp includes basic_type.cpp).""" """Test 'b basic_types.cpp:176' does break (where int.cpp includes basic_type.cpp)."""
self.buildDsym() self.buildDsym()
self.inlined_breakpoints() self.inlined_breakpoints()
@expectedFailureFreeBSD("llvm.org/pr21142") @expectedFailureFreeBSD("llvm.org/pr21142")
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

test/functionalities/breakpoint/objc/TestObjCBreakpoints.py

""" """
Test that objective-c constant strings are generated correctly by the expression Test that objective-c constant strings are generated correctly by the expression
parser. parser.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
import shutil import shutil
import subprocess import subprocess
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
class TestObjCBreakpoints(TestBase): class TestObjCBreakpoints(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@dsym_test @dsym_test
def test_break_with_dsym(self): def test_break_with_dsym(self):
"""Test setting Objective C specific breakpoints (dSYM).""" """Test setting Objective C specific breakpoints (dSYM)."""
self.buildDsym() self.buildDsym()
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

test/functionalities/command_script/TestCommandScript.py

""" """
Test lldb Python commands. Test lldb Python commands.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
class CmdPythonTestCase(TestBase): class CmdPythonTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym (self): def test_with_dsym (self):
self.buildDsym () self.buildDsym ()
self.pycmd_tests () self.pycmd_tests ()
@dwarf_test @dwarf_test
def test_with_dwarf (self): def test_with_dwarf (self):
self.buildDwarf () self.buildDwarf ()
▲ Show 20 Lines • Show All 126 Lines • Show Last 20 Lines

test/functionalities/conditional_break/TestConditionalBreak.py

Show All 11 Lines
# lldb not able to digest the clang-generated debug info correctly with respect to function name # lldb not able to digest the clang-generated debug info correctly with respect to function name
# #
# This class currently fails for clang as well as llvm-gcc. # This class currently fails for clang as well as llvm-gcc.
class ConditionalBreakTestCase(TestBase): class ConditionalBreakTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym_python(self): def test_with_dsym_python(self):
"""Exercise some thread and frame APIs to break if c() is called by a().""" """Exercise some thread and frame APIs to break if c() is called by a()."""
self.buildDsym() self.buildDsym()
self.do_conditional_break() self.do_conditional_break()
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_with_dwarf_python(self): def test_with_dwarf_python(self):
"""Exercise some thread and frame APIs to break if c() is called by a().""" """Exercise some thread and frame APIs to break if c() is called by a()."""
self.buildDwarf() self.buildDwarf()
self.do_conditional_break() self.do_conditional_break()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_command(self): def test_with_dsym_command(self):
"""Simulate a user using lldb commands to break on c() if called from a().""" """Simulate a user using lldb commands to break on c() if called from a()."""
self.buildDsym() self.buildDsym()
self.simulate_conditional_break_by_user() self.simulate_conditional_break_by_user()
@dwarf_test @dwarf_test
def test_with_dwarf_command(self): def test_with_dwarf_command(self):
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class AdvDataFormatterTestCase(TestBase): class AdvDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
▲ Show 20 Lines • Show All 278 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class CategoriesDataFormatterTestCase(TestBase): class CategoriesDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
▲ Show 20 Lines • Show All 320 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class CppDataFormatterTestCase(TestBase): class CppDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
▲ Show 20 Lines • Show All 256 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class DataFormatterDisablingTestCase(TestBase): class DataFormatterDisablingTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class EnumFormatTestCase(TestBase): class EnumFormatTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

test/functionalities/data-formatter/data-formatter-globals/TestDataFormatterGlobals.py

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class GlobalsDataFormatterTestCase(TestBase): class GlobalsDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class NamedSummariesDataFormatterTestCase(TestBase): class NamedSummariesDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
▲ Show 20 Lines • Show All 115 Lines • Show Last 20 Lines

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

# encoding: utf-8 # encoding: utf-8
""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import datetime import datetime
import lldbutil import lldbutil
class ObjCDataFormatterTestCase(TestBase): class ObjCDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_plain_objc_with_dsym_and_run_command(self): def test_plain_objc_with_dsym_and_run_command(self):
"""Test basic ObjC formatting behavior.""" """Test basic ObjC formatting behavior."""
self.buildDsym() self.buildDsym()
self.plain_data_formatter_commands() self.plain_data_formatter_commands()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_plain_objc_with_dwarf_and_run_command(self): def test_plain_objc_with_dwarf_and_run_command(self):
"""Test basic ObjC formatting behavior.""" """Test basic ObjC formatting behavior."""
self.buildDwarf() self.buildDwarf()
self.plain_data_formatter_commands() self.plain_data_formatter_commands()
def appkit_tester_impl(self,builder,commands): def appkit_tester_impl(self,builder,commands):
builder() builder()
self.appkit_common_data_formatters_command() self.appkit_common_data_formatters_command()
commands() commands()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_nsnumber_with_dsym_and_run_command(self): def test_nsnumber_with_dsym_and_run_command(self):
"""Test formatters for NSNumber.""" """Test formatters for NSNumber."""
self.appkit_tester_impl(self.buildDsym,self.nsnumber_data_formatter_commands) self.appkit_tester_impl(self.buildDsym,self.nsnumber_data_formatter_commands)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_nsnumber_with_dwarf_and_run_command(self): def test_nsnumber_with_dwarf_and_run_command(self):
"""Test formatters for NSNumber.""" """Test formatters for NSNumber."""
self.appkit_tester_impl(self.buildDwarf,self.nsnumber_data_formatter_commands) self.appkit_tester_impl(self.buildDwarf,self.nsnumber_data_formatter_commands)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_nsstring_with_dsym_and_run_command(self): def test_nsstring_with_dsym_and_run_command(self):
"""Test formatters for NSString.""" """Test formatters for NSString."""
self.appkit_tester_impl(self.buildDsym,self.nsstring_data_formatter_commands) self.appkit_tester_impl(self.buildDsym,self.nsstring_data_formatter_commands)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_nsstring_with_dwarf_and_run_command(self): def test_nsstring_with_dwarf_and_run_command(self):
"""Test formatters for NSString.""" """Test formatters for NSString."""
self.appkit_tester_impl(self.buildDwarf,self.nsstring_data_formatter_commands) self.appkit_tester_impl(self.buildDwarf,self.nsstring_data_formatter_commands)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_nscontainers_with_dsym_and_run_command(self): def test_nscontainers_with_dsym_and_run_command(self):
"""Test formatters for NS container classes.""" """Test formatters for NS container classes."""
self.appkit_tester_impl(self.buildDsym,self.nscontainers_data_formatter_commands) self.appkit_tester_impl(self.buildDsym,self.nscontainers_data_formatter_commands)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_nscontainers_with_dwarf_and_run_command(self): def test_nscontainers_with_dwarf_and_run_command(self):
"""Test formatters for NS container classes.""" """Test formatters for NS container classes."""
self.appkit_tester_impl(self.buildDwarf,self.nscontainers_data_formatter_commands) self.appkit_tester_impl(self.buildDwarf,self.nscontainers_data_formatter_commands)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_nsdata_with_dsym_and_run_command(self): def test_nsdata_with_dsym_and_run_command(self):
"""Test formatters for NSData.""" """Test formatters for NSData."""
self.appkit_tester_impl(self.buildDsym,self.nsdata_data_formatter_commands) self.appkit_tester_impl(self.buildDsym,self.nsdata_data_formatter_commands)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_nsdata_with_dwarf_and_run_command(self): def test_nsdata_with_dwarf_and_run_command(self):
"""Test formatters for NSData.""" """Test formatters for NSData."""
self.appkit_tester_impl(self.buildDwarf,self.nsdata_data_formatter_commands) self.appkit_tester_impl(self.buildDwarf,self.nsdata_data_formatter_commands)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_nsurl_with_dsym_and_run_command(self): def test_nsurl_with_dsym_and_run_command(self):
"""Test formatters for NSURL.""" """Test formatters for NSURL."""
self.appkit_tester_impl(self.buildDsym,self.nsurl_data_formatter_commands) self.appkit_tester_impl(self.buildDsym,self.nsurl_data_formatter_commands)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_nsurl_with_dwarf_and_run_command(self): def test_nsurl_with_dwarf_and_run_command(self):
"""Test formatters for NSURL.""" """Test formatters for NSURL."""
self.appkit_tester_impl(self.buildDwarf,self.nsurl_data_formatter_commands) self.appkit_tester_impl(self.buildDwarf,self.nsurl_data_formatter_commands)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_nserror_with_dsym_and_run_command(self): def test_nserror_with_dsym_and_run_command(self):
"""Test formatters for NSError.""" """Test formatters for NSError."""
self.appkit_tester_impl(self.buildDsym,self.nserror_data_formatter_commands) self.appkit_tester_impl(self.buildDsym,self.nserror_data_formatter_commands)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_nserror_with_dwarf_and_run_command(self): def test_nserror_with_dwarf_and_run_command(self):
"""Test formatters for NSError.""" """Test formatters for NSError."""
self.appkit_tester_impl(self.buildDwarf,self.nserror_data_formatter_commands) self.appkit_tester_impl(self.buildDwarf,self.nserror_data_formatter_commands)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_nsbundle_with_dsym_and_run_command(self): def test_nsbundle_with_dsym_and_run_command(self):
"""Test formatters for NSBundle.""" """Test formatters for NSBundle."""
self.appkit_tester_impl(self.buildDsym,self.nsbundle_data_formatter_commands) self.appkit_tester_impl(self.buildDsym,self.nsbundle_data_formatter_commands)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_nsbundle_with_dwarf_and_run_command(self): def test_nsbundle_with_dwarf_and_run_command(self):
"""Test formatters for NSBundle.""" """Test formatters for NSBundle."""
self.appkit_tester_impl(self.buildDwarf,self.nsbundle_data_formatter_commands) self.appkit_tester_impl(self.buildDwarf,self.nsbundle_data_formatter_commands)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_nsexception_with_dsym_and_run_command(self): def test_nsexception_with_dsym_and_run_command(self):
"""Test formatters for NSException.""" """Test formatters for NSException."""
self.appkit_tester_impl(self.buildDsym,self.nsexception_data_formatter_commands) self.appkit_tester_impl(self.buildDsym,self.nsexception_data_formatter_commands)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_nsexception_with_dwarf_and_run_command(self): def test_nsexception_with_dwarf_and_run_command(self):
"""Test formatters for NSException.""" """Test formatters for NSException."""
self.appkit_tester_impl(self.buildDwarf,self.nsexception_data_formatter_commands) self.appkit_tester_impl(self.buildDwarf,self.nsexception_data_formatter_commands)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_nsmisc_with_dsym_and_run_command(self): def test_nsmisc_with_dsym_and_run_command(self):
"""Test formatters for misc NS classes.""" """Test formatters for misc NS classes."""
self.appkit_tester_impl(self.buildDsym,self.nsmisc_data_formatter_commands) self.appkit_tester_impl(self.buildDsym,self.nsmisc_data_formatter_commands)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_nsmisc_with_dwarf_and_run_command(self): def test_nsmisc_with_dwarf_and_run_command(self):
"""Test formatters for misc NS classes.""" """Test formatters for misc NS classes."""
self.appkit_tester_impl(self.buildDwarf,self.nsmisc_data_formatter_commands) self.appkit_tester_impl(self.buildDwarf,self.nsmisc_data_formatter_commands)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_nsdate_with_dsym_and_run_command(self): def test_nsdate_with_dsym_and_run_command(self):
"""Test formatters for NSDate.""" """Test formatters for NSDate."""
self.appkit_tester_impl(self.buildDsym,self.nsdate_data_formatter_commands) self.appkit_tester_impl(self.buildDsym,self.nsdate_data_formatter_commands)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_nsdate_with_dwarf_and_run_command(self): def test_nsdate_with_dwarf_and_run_command(self):
"""Test formatters for NSDate.""" """Test formatters for NSDate."""
self.appkit_tester_impl(self.buildDwarf,self.nsdate_data_formatter_commands) self.appkit_tester_impl(self.buildDwarf,self.nsdate_data_formatter_commands)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_coreframeworks_with_dsym_and_run_command(self): def test_coreframeworks_with_dsym_and_run_command(self):
"""Test formatters for Core OSX frameworks.""" """Test formatters for Core OSX frameworks."""
self.buildDsym() self.buildDsym()
self.cf_data_formatter_commands() self.cf_data_formatter_commands()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_coreframeworks_with_dwarf_and_run_command(self): def test_coreframeworks_with_dwarf_and_run_command(self):
"""Test formatters for Core OSX frameworks.""" """Test formatters for Core OSX frameworks."""
self.buildDwarf() self.buildDwarf()
self.cf_data_formatter_commands() self.cf_data_formatter_commands()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_kvo_with_dsym_and_run_command(self): def test_kvo_with_dsym_and_run_command(self):
"""Test the behavior of formatters when KVO is in use.""" """Test the behavior of formatters when KVO is in use."""
self.buildDsym() self.buildDsym()
self.kvo_data_formatter_commands() self.kvo_data_formatter_commands()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_kvo_with_dwarf_and_run_command(self): def test_kvo_with_dwarf_and_run_command(self):
"""Test the behavior of formatters when KVO is in use.""" """Test the behavior of formatters when KVO is in use."""
self.buildDwarf() self.buildDwarf()
self.kvo_data_formatter_commands() self.kvo_data_formatter_commands()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_rdar11106605_with_dsym_and_run_command(self): def test_rdar11106605_with_dsym_and_run_command(self):
"""Check that Unicode characters come out of CFString summary correctly.""" """Check that Unicode characters come out of CFString summary correctly."""
self.buildDsym() self.buildDsym()
self.rdar11106605_commands() self.rdar11106605_commands()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_rdar11106605_with_dwarf_and_run_command(self): def test_rdar11106605_with_dwarf_and_run_command(self):
"""Check that Unicode characters come out of CFString summary correctly.""" """Check that Unicode characters come out of CFString summary correctly."""
self.buildDwarf() self.buildDwarf()
self.rdar11106605_commands() self.rdar11106605_commands()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_expr_with_dsym_and_run_command(self): def test_expr_with_dsym_and_run_command(self):
"""Test common cases of expression parser <--> formatters interaction.""" """Test common cases of expression parser <--> formatters interaction."""
self.buildDsym() self.buildDsym()
self.expr_objc_data_formatter_commands() self.expr_objc_data_formatter_commands()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_expr_with_dwarf_and_run_command(self): def test_expr_with_dwarf_and_run_command(self):
"""Test common cases of expression parser <--> formatters interaction.""" """Test common cases of expression parser <--> formatters interaction."""
self.buildDwarf() self.buildDwarf()
self.expr_objc_data_formatter_commands() self.expr_objc_data_formatter_commands()
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
▲ Show 20 Lines • Show All 428 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class PythonSynthDataFormatterTestCase(TestBase): class PythonSynthDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@skipIfFreeBSD # llvm.org/pr20545 bogus output confuses buildbot parser @skipIfFreeBSD # llvm.org/pr20545 bogus output confuses buildbot parser
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDwarf() self.buildDwarf()
self.data_formatter_commands() self.data_formatter_commands()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_rdar10960550_with_dsym_and_run_command(self): def test_rdar10960550_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.rdar10960550_formatter_commands() self.rdar10960550_formatter_commands()
@dwarf_test @dwarf_test
def test_rdar10960550_with_dwarf_and_run_command(self): def test_rdar10960550_with_dwarf_and_run_command(self):
▲ Show 20 Lines • Show All 235 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class ScriptDataFormatterTestCase(TestBase): class ScriptDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
▲ Show 20 Lines • Show All 159 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class SkipSummaryDataFormatterTestCase(TestBase): class SkipSummaryDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@expectedFailureFreeBSD("llvm.org/pr20548") # fails to build on lab.llvm.org buildbot @expectedFailureFreeBSD("llvm.org/pr20548") # fails to build on lab.llvm.org buildbot
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 163 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class SmartArrayDataFormatterTestCase(TestBase): class SmartArrayDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
▲ Show 20 Lines • Show All 336 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class LibcxxIteratorDataFormatterTestCase(TestBase): class LibcxxIteratorDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@skipIfLinux # No standard locations for libc++ on Linux, so skip for now @skipIfLinux # No standard locations for libc++ on Linux, so skip for now
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class LibcxxListDataFormatterTestCase(TestBase): class LibcxxListDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@skipIfLinux # No standard locations for libc++ on Linux, so skip for now @skipIfLinux # No standard locations for libc++ on Linux, so skip for now
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 156 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class LibcxxMapDataFormatterTestCase(TestBase): class LibcxxMapDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@skipIfLinux # No standard locations for libc++ on Linux, so skip for now @skipIfLinux # No standard locations for libc++ on Linux, so skip for now
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 291 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class LibcxxMultiMapDataFormatterTestCase(TestBase): class LibcxxMultiMapDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@skipIfLinux # No standard locations for libc++ on Linux, so skip for now @skipIfLinux # No standard locations for libc++ on Linux, so skip for now
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 291 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class LibcxxMultiSetDataFormatterTestCase(TestBase): class LibcxxMultiSetDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@skipIfLinux # No standard locations for libc++ on Linux, so skip for now @skipIfLinux # No standard locations for libc++ on Linux, so skip for now
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class LibcxxSetDataFormatterTestCase(TestBase): class LibcxxSetDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@skipIfLinux # No standard locations for libc++ on Linux, so skip for now @skipIfLinux # No standard locations for libc++ on Linux, so skip for now
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

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

#coding=utf8 #coding=utf8
""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class LibcxxStringDataFormatterTestCase(TestBase): class LibcxxStringDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@skipIfLinux # No standard locations for libc++ on Linux, so skip for now @skipIfLinux # No standard locations for libc++ on Linux, so skip for now
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class LibcxxMultiMapDataFormatterTestCase(TestBase): class LibcxxMultiMapDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@skipIfLinux # No standard locations for libc++ on Linux, so skip for now @skipIfLinux # No standard locations for libc++ on Linux, so skip for now
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class LibcxxVBoolDataFormatterTestCase(TestBase): class LibcxxVBoolDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@skipIfLinux # No standard locations for libc++ on Linux, so skip for now @skipIfLinux # No standard locations for libc++ on Linux, so skip for now
@skipIfWindows # http://llvm.org/pr21800 @skipIfWindows # http://llvm.org/pr21800
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class LibcxxVectorDataFormatterTestCase(TestBase): class LibcxxVectorDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@skipIfLinux # No standard locations for libc++ on Linux, so skip for now @skipIfLinux # No standard locations for libc++ on Linux, so skip for now
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 173 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class StdIteratorDataFormatterTestCase(TestBase): class StdIteratorDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@dwarf_test @dwarf_test
@expectedFailureFreeBSD("llvm.org/pr20548") # fails to build on lab.llvm.org buildbot @expectedFailureFreeBSD("llvm.org/pr20548") # fails to build on lab.llvm.org buildbot
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class StdListDataFormatterTestCase(TestBase): class StdListDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@dwarf_test @dwarf_test
@expectedFailureFreeBSD("llvm.org/pr20548") # fails to build on lab.llvm.org buildbot @expectedFailureFreeBSD("llvm.org/pr20548") # fails to build on lab.llvm.org buildbot
▲ Show 20 Lines • Show All 180 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class StdMapDataFormatterTestCase(TestBase): class StdMapDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@expectedFailureIcc # llvm.org/pr15301: LLDB prints incorrect size of @expectedFailureIcc # llvm.org/pr15301: LLDB prints incorrect size of
# libstdc++ containers # libstdc++ containers
▲ Show 20 Lines • Show All 314 Lines • Show Last 20 Lines

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

#coding=utf8 #coding=utf8
""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class StdStringDataFormatterTestCase(TestBase): class StdStringDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@expectedFailureFreeBSD("llvm.org/pr20548") # fails to build on lab.llvm.org buildbot @expectedFailureFreeBSD("llvm.org/pr20548") # fails to build on lab.llvm.org buildbot
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class StdVBoolDataFormatterTestCase(TestBase): class StdVBoolDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
@skipIfDarwin @skipIfDarwin
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@expectedFailureFreeBSD("llvm.org/pr20548") # fails to build on lab.llvm.org buildbot @expectedFailureFreeBSD("llvm.org/pr20548") # fails to build on lab.llvm.org buildbot
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class StdVectorDataFormatterTestCase(TestBase): class StdVectorDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@dwarf_test @dwarf_test
@skipIfFreeBSD @skipIfFreeBSD
▲ Show 20 Lines • Show All 198 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class SynthDataFormatterTestCase(TestBase): class SynthDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
▲ Show 20 Lines • Show All 192 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class DataFormatterSynthValueTestCase(TestBase): class DataFormatterSynthValueTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test using Python synthetic children provider to provide a value.""" """Test using Python synthetic children provider to provide a value."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@skipIfFreeBSD # llvm.org/pr20545 bogus output confuses buildbot parser @skipIfFreeBSD # llvm.org/pr20545 bogus output confuses buildbot parser
@expectedFailureLinux # non-core functionality, need to reenable and fix @expectedFailureLinux # non-core functionality, need to reenable and fix
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

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

""" """
Check if changing Format on an SBValue correctly propagates that new format to children as it should Check if changing Format on an SBValue correctly propagates that new format to children as it should
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class FormatPropagationTestCase(TestBase): class FormatPropagationTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
# rdar://problem/14035604 # rdar://problem/14035604
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Check if changing Format on an SBValue correctly propagates that new format to children as it should""" """Check if changing Format on an SBValue correctly propagates that new format to children as it should"""
self.buildDsym() self.buildDsym()
self.propagate_test_commands() self.propagate_test_commands()
# rdar://problem/14035604 # rdar://problem/14035604
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

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

""" """
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.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class FrameFormatSmallStructTestCase(TestBase): class FrameFormatSmallStructTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test that the user can input a format but it will not prevail over summary format's choices.""" """Test that the user can input a format but it will not prevail over summary format's choices."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
Show All 30 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class PtrRef2TypedefTestCase(TestBase): class PtrRef2TypedefTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class Radar10449092DataFormatterTestCase(TestBase): class Radar10449092DataFormatterTestCase(TestBase):
# test for rdar://problem/10449092 () # test for rdar://problem/10449092 ()
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class Radar10642615DataFormatterTestCase(TestBase): class Radar10642615DataFormatterTestCase(TestBase):
# test for rdar://problem/10642615 () # test for rdar://problem/10642615 ()
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDwarf() self.buildDwarf()
self.data_formatter_commands() self.data_formatter_commands()
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

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

""" """
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
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class Rdar10887661TestCase(TestBase): class Rdar10887661TestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
# rdar://problem/10887661 # rdar://problem/10887661
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Check for an issue where capping does not work because the Target pointer appears to be changing behind our backs.""" """Check for an issue where capping does not work because the Target pointer appears to be changing behind our backs."""
self.buildDsym() self.buildDsym()
self.capping_test_commands() self.capping_test_commands()
# rdar://problem/10887661 # rdar://problem/10887661
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import datetime import datetime
import lldbutil import lldbutil
class DataFormatterRdar11086338TestCase(TestBase): class DataFormatterRdar11086338TestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_rdar11086338_with_dsym_and_run_command(self): def test_rdar11086338_with_dsym_and_run_command(self):
"""Test that NSArray reports its synthetic children properly.""" """Test that NSArray reports its synthetic children properly."""
self.buildDsym() self.buildDsym()
self.rdar11086338_tester() self.rdar11086338_tester()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_rdar11086338_with_dwarf_and_run_command(self): def test_rdar11086338_with_dwarf_and_run_command(self):
"""Test that NSArray reports its synthetic children properly.""" """Test that NSArray reports its synthetic children properly."""
self.buildDwarf() self.buildDwarf()
self.rdar11086338_tester() self.rdar11086338_tester()
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import datetime import datetime
import lldbutil import lldbutil
class DataFormatterOSTypeTestCase(TestBase): class DataFormatterOSTypeTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_ostype_with_dsym_and_run_command(self): def test_ostype_with_dsym_and_run_command(self):
"""Test the formatters we use for OSType.""" """Test the formatters we use for OSType."""
self.buildDsym() self.buildDsym()
self.ostype_data_formatter_commands() self.ostype_data_formatter_commands()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_ostype_with_dwarf_and_run_command(self): def test_ostype_with_dwarf_and_run_command(self):
"""Test the formatters we use for OSType.""" """Test the formatters we use for OSType."""
self.buildDwarf() self.buildDwarf()
self.ostype_data_formatter_commands() self.ostype_data_formatter_commands()
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
Show All 37 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import datetime import datetime
import lldbutil import lldbutil
class DataFormatterBoolRefPtr(TestBase): class DataFormatterBoolRefPtr(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_boolrefptr_with_dsym_and_run_command(self): def test_boolrefptr_with_dsym_and_run_command(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.buildDsym() self.buildDsym()
self.boolrefptr_data_formatter_commands() self.boolrefptr_data_formatter_commands()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_boolrefptr_with_dwarf_and_run_command(self): def test_boolrefptr_with_dwarf_and_run_command(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.buildDwarf() self.buildDwarf()
self.boolrefptr_data_formatter_commands() self.boolrefptr_data_formatter_commands()
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import datetime import datetime
import lldbutil import lldbutil
class DataFormatterRdar11988289TestCase(TestBase): class DataFormatterRdar11988289TestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_rdar11988289_with_dsym_and_run_command(self): def test_rdar11988289_with_dsym_and_run_command(self):
"""Test that NSDictionary reports its synthetic children properly.""" """Test that NSDictionary reports its synthetic children properly."""
self.buildDsym() self.buildDsym()
self.rdar11988289_tester() self.rdar11988289_tester()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_rdar11988289_with_dwarf_and_run_command(self): def test_rdar11988289_with_dwarf_and_run_command(self):
"""Test that NSDictionary reports its synthetic children properly.""" """Test that NSDictionary reports its synthetic children properly."""
self.buildDwarf() self.buildDwarf()
self.rdar11988289_tester() self.rdar11988289_tester()
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import datetime import datetime
import lldbutil import lldbutil
class DataFormatterRdar12437442TestCase(TestBase): class DataFormatterRdar12437442TestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_rdar12437442_with_dsym_and_run_command(self): def test_rdar12437442_with_dsym_and_run_command(self):
"""Test that we update SBValues correctly as dynamic types change.""" """Test that we update SBValues correctly as dynamic types change."""
self.buildDsym() self.buildDsym()
self.rdar12437442_tester() self.rdar12437442_tester()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_rdar12437442_with_dwarf_and_run_command(self): def test_rdar12437442_with_dwarf_and_run_command(self):
"""Test that we update SBValues correctly as dynamic types change.""" """Test that we update SBValues correctly as dynamic types change."""
self.buildDwarf() self.buildDwarf()
self.rdar12437442_tester() self.rdar12437442_tester()
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import datetime import datetime
import lldbutil import lldbutil
class DataFormatterRdar12529957TestCase(TestBase): class DataFormatterRdar12529957TestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_rdar12529957_with_dsym_and_run_command(self): def test_rdar12529957_with_dsym_and_run_command(self):
"""Test that NSSet reports its synthetic children properly.""" """Test that NSSet reports its synthetic children properly."""
self.buildDsym() self.buildDsym()
self.rdar12529957_tester() self.rdar12529957_tester()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_rdar12529957_with_dwarf_and_run_command(self): def test_rdar12529957_with_dwarf_and_run_command(self):
"""Test that NSSet reports its synthetic children properly.""" """Test that NSSet reports its synthetic children properly."""
self.buildDwarf() self.buildDwarf()
self.rdar12529957_tester() self.rdar12529957_tester()
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class Radar13338477DataFormatterTestCase(TestBase): class Radar13338477DataFormatterTestCase(TestBase):
# test for rdar://problem/13338477 () # test for rdar://problem/13338477 ()
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test that LLDB handles the clang typeclass Paren correctly.""" """Test that LLDB handles the clang typeclass Paren correctly."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import datetime import datetime
import lldbutil import lldbutil
class DataFormatterOneIsSingularTestCase(TestBase): class DataFormatterOneIsSingularTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_one_is_singular_with_dsym_and_run_command(self): def test_one_is_singular_with_dsym_and_run_command(self):
"""Test that 1 item is not as reported as 1 items.""" """Test that 1 item is not as reported as 1 items."""
self.buildDsym() self.buildDsym()
self.oneness_data_formatter_commands() self.oneness_data_formatter_commands()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_one_is_singular_with_dwarf_and_run_command(self): def test_one_is_singular_with_dwarf_and_run_command(self):
"""Test that 1 item is not as reported as 1 items.""" """Test that 1 item is not as reported as 1 items."""
self.buildDwarf() self.buildDwarf()
self.oneness_data_formatter_commands() self.oneness_data_formatter_commands()
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class Radar9973865DataFormatterTestCase(TestBase): class Radar9973865DataFormatterTestCase(TestBase):
# test for rdar://problem/9973865 (If you use "${var}" in the summary string for an aggregate type, the summary doesn't print for a pointer to that type) # test for rdar://problem/9973865 (If you use "${var}" in the summary string for an aggregate type, the summary doesn't print for a pointer to that type)
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class Radar9973992DataFormatterTestCase(TestBase): class Radar9973992DataFormatterTestCase(TestBase):
# test for rdar://problem/9973992 (What should we do for "${var}" in summaries of aggregate types?) # test for rdar://problem/9973992 (What should we do for "${var}" in summaries of aggregate types?)
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class Radar9974002DataFormatterTestCase(TestBase): class Radar9974002DataFormatterTestCase(TestBase):
# test for rdar://problem/9974002 () # test for rdar://problem/9974002 ()
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@dwarf_test @dwarf_test
@expectedFailureLinux("llvm.org/pr20232") @expectedFailureLinux("llvm.org/pr20232")
▲ Show 20 Lines • Show All 126 Lines • Show Last 20 Lines

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

""" """
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.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class DataFormatterRefPtrRecursionTestCase(TestBase): class DataFormatterRefPtrRecursionTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test that ValueObjectPrinter does not cause an infinite loop when a reference to a struct that contains a pointer to itself is printed.""" """Test that ValueObjectPrinter does not cause an infinite loop when a reference to a struct that contains a pointer to itself is printed."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
Show All 33 Lines

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

""" """
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.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class UserFormatVSSummaryTestCase(TestBase): class UserFormatVSSummaryTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test that the user can input a format but it will not prevail over summary format's choices.""" """Test that the user can input a format but it will not prevail over summary format's choices."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

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

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
import os.path import os.path
class PythonSynthDataFormatterTestCase(TestBase): class PythonSynthDataFormatterTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test data formatter commands.""" """Test data formatter commands."""
self.buildDsym() self.buildDsym()
self.data_formatter_commands() self.data_formatter_commands()
@skipIfFreeBSD # llvm.org/pr20545 bogus output confuses buildbot parser @skipIfFreeBSD # llvm.org/pr20545 bogus output confuses buildbot parser
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

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

""" """
Check that vector types format properly Check that vector types format properly
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class VectorTypesFormattingTestCase(TestBase): class VectorTypesFormattingTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
# rdar://problem/14035604 # rdar://problem/14035604
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Check that vector types format properly""" """Check that vector types format properly"""
self.buildDsym() self.buildDsym()
self.propagate_test_commands() self.propagate_test_commands()
# rdar://problem/14035604 # rdar://problem/14035604
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

test/functionalities/dead-strip/TestDeadStrip.py

""" """
Test that breakpoint works correctly in the presence of dead-code stripping. Test that breakpoint works correctly in the presence of dead-code stripping.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class DeadStripTestCase(TestBase): class DeadStripTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test breakpoint works correctly with dead-code stripping.""" """Test breakpoint works correctly with dead-code stripping."""
self.buildDsym() self.buildDsym()
self.dead_strip() self.dead_strip()
@skipIfFreeBSD # The -dead_strip linker option isn't supported on FreeBSD versions of ld. @skipIfFreeBSD # The -dead_strip linker option isn't supported on FreeBSD versions of ld.
@skipIfLinux # The -dead_strip linker option isn't supported on Linux versions of ld. @skipIfLinux # The -dead_strip linker option isn't supported on Linux versions of ld.
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

test/functionalities/disassembly/TestDisassembleBreakpoint.py

""" """
Test some lldb command abbreviations. Test some lldb command abbreviations.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class DisassemblyTestCase(TestBase): class DisassemblyTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym (self): def test_with_dsym (self):
self.buildDsym () self.buildDsym ()
self.disassemble_breakpoint () self.disassemble_breakpoint ()
@dwarf_test @dwarf_test
@expectedFailureLinux # llgs Handle_m returns target memory with breakpoints @expectedFailureLinux # llgs Handle_m returns target memory with breakpoints
def test_with_dwarf (self): def test_with_dwarf (self):
Show All 37 Lines

test/functionalities/dynamic_value_child_count/TestDynamicValueChildCount.py

""" """
Test that dynamic values update their child count correctly Test that dynamic values update their child count correctly
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
from lldbtest import * from lldbtest import *
class DynamicValueChildCountTestCase(TestBase): class DynamicValueChildCountTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
@expectedFailurei386("to be figured out") @expectedFailurei386("to be figured out")
def test_get_dynamic_vals_with_dsym(self): def test_get_dynamic_vals_with_dsym(self):
"""Test fetching C++ dynamic values from pointers & references.""" """Test fetching C++ dynamic values from pointers & references."""
self.buildDsym(dictionary=self.getBuildFlags()) self.buildDsym(dictionary=self.getBuildFlags())
self.do_get_dynamic_vals() self.do_get_dynamic_vals()
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

test/functionalities/embedded_interpreter/TestConvenienceVariables.py

"""Test convenience variables when you drop in from lldb prompt into an embedded interpreter.""" """Test convenience variables when you drop in from lldb prompt into an embedded interpreter."""
import os import os
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
class ConvenienceVariablesCase(TestBase): class ConvenienceVariablesCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
@skipIfRemote @skipIfRemote
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test convenience variables lldb.debugger, lldb.target, lldb.process, lldb.thread, and lldb.frame.""" """Test convenience variables lldb.debugger, lldb.target, lldb.process, lldb.thread, and lldb.frame."""
self.buildDsym() self.buildDsym()
self.convenience_variables() self.convenience_variables()
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

test/functionalities/exec/TestExec.py

Show All 16 Linesdef execute_command (command):
#print 'status = %u' % (exit_status) #print 'status = %u' % (exit_status)
return exit_status return exit_status
class ExecTestCase(TestBase): class ExecTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym (self): def test_with_dsym (self):
if self.getArchitecture() == 'x86_64': if self.getArchitecture() == 'x86_64':
source = os.path.join (os.getcwd(), "main.cpp") source = os.path.join (os.getcwd(), "main.cpp")
o_file = os.path.join (os.getcwd(), "main.o") o_file = os.path.join (os.getcwd(), "main.o")
execute_command ("'%s' -g -O0 -arch i386 -arch x86_64 '%s' -c -o '%s'" % (os.environ["CC"], source, o_file)) execute_command ("'%s' -g -O0 -arch i386 -arch x86_64 '%s' -c -o '%s'" % (os.environ["CC"], source, o_file))
execute_command ("'%s' -g -O0 -arch i386 -arch x86_64 '%s'" % (os.environ["CC"], o_file)) execute_command ("'%s' -g -O0 -arch i386 -arch x86_64 '%s'" % (os.environ["CC"], o_file))
else: else:
self.buildDsym() self.buildDsym()
self.do_test () self.do_test ()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_with_dwarf (self): def test_with_dwarf (self):
if self.getArchitecture() == 'x86_64': if self.getArchitecture() == 'x86_64':
source = os.path.join (os.getcwd(), "main.cpp") source = os.path.join (os.getcwd(), "main.cpp")
o_file = os.path.join (os.getcwd(), "main.o") o_file = os.path.join (os.getcwd(), "main.o")
dsym_path = os.path.join (os.getcwd(), "a.out.dSYM") dsym_path = os.path.join (os.getcwd(), "a.out.dSYM")
execute_command ("'%s' -g -O0 -arch i386 -arch x86_64 '%s' -c -o '%s'" % (os.environ["CC"], source, o_file)) execute_command ("'%s' -g -O0 -arch i386 -arch x86_64 '%s' -c -o '%s'" % (os.environ["CC"], source, o_file))
execute_command ("'%s' -g -O0 -arch i386 -arch x86_64 '%s'" % (os.environ["CC"], o_file)) execute_command ("'%s' -g -O0 -arch i386 -arch x86_64 '%s'" % (os.environ["CC"], o_file))
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

test/functionalities/expr-doesnt-deadlock/TestExprDoesntBlock.py

Show All 9 Lines
class ExprDoesntDeadlockTestCase(TestBase): class ExprDoesntDeadlockTestCase(TestBase):
def getCategories(self): def getCategories(self):
return ['basic_process'] return ['basic_process']
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test that expr will time out and allow other threads to run if it blocks - with dsym.""" """Test that expr will time out and allow other threads to run if it blocks - with dsym."""
self.buildDsym() self.buildDsym()
self.expr_doesnt_deadlock() self.expr_doesnt_deadlock()
@dwarf_test @dwarf_test
@expectedFailureFreeBSD('llvm.org/pr17946') @expectedFailureFreeBSD('llvm.org/pr17946')
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

test/functionalities/fat_archives/TestFatArchives.py

Show All 15 Linesdef execute_command (command):
# print output # print output
# print 'status = %u' % (exit_status) # print 'status = %u' % (exit_status)
return exit_status return exit_status
class FatArchiveTestCase(TestBase): class FatArchiveTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_with_dwarf (self): def test_with_dwarf (self):
if self.getArchitecture() == 'x86_64': if self.getArchitecture() == 'x86_64':
execute_command ("make CC='%s'" % (os.environ["CC"])) execute_command ("make CC='%s'" % (os.environ["CC"]))
self.main () self.main ()
else: else:
self.skipTest("This test requires x86_64 as the architecture for the inferior") self.skipTest("This test requires x86_64 as the architecture for the inferior")
Show All 31 Lines

test/functionalities/inferior-assert/TestInferiorAssert.py

"""Test that lldb functions correctly after the inferior has asserted.""" """Test that lldb functions correctly after the inferior has asserted."""
import os, time import os, time
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
from lldbtest import * from lldbtest import *
class AssertingInferiorTestCase(TestBase): class AssertingInferiorTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@unittest2.expectedFailure("rdar://15367233") @unittest2.expectedFailure("rdar://15367233")
def test_inferior_asserting_dsym(self): def test_inferior_asserting_dsym(self):
"""Test that lldb reliably catches the inferior asserting (command).""" """Test that lldb reliably catches the inferior asserting (command)."""
self.buildDsym() self.buildDsym()
self.inferior_asserting() self.inferior_asserting()
@expectedFailurei386("llvm.org/pr17384: lldb needs to be aware of linux-vdso.so to unwind stacks properly") @expectedFailurei386("llvm.org/pr17384: lldb needs to be aware of linux-vdso.so to unwind stacks properly")
@expectedFailureDarwin("rdar://15367233") @expectedFailureDarwin("rdar://15367233")
@expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows") @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
def test_inferior_asserting_dwarf(self): def test_inferior_asserting_dwarf(self):
"""Test that lldb reliably catches the inferior asserting (command).""" """Test that lldb reliably catches the inferior asserting (command)."""
self.buildDwarf() self.buildDwarf()
self.inferior_asserting() self.inferior_asserting()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
def test_inferior_asserting_registers_dsym(self): def test_inferior_asserting_registers_dsym(self):
"""Test that lldb reliably reads registers from the inferior after asserting (command).""" """Test that lldb reliably reads registers from the inferior after asserting (command)."""
self.buildDsym() self.buildDsym()
self.inferior_asserting_registers() self.inferior_asserting_registers()
@expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows") @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
def test_inferior_asserting_register_dwarf(self): def test_inferior_asserting_register_dwarf(self):
"""Test that lldb reliably reads registers from the inferior after asserting (command).""" """Test that lldb reliably reads registers from the inferior after asserting (command)."""
Show All 11 Linesclass AssertingInferiorTestCase(TestBase):
@python_api_test @python_api_test
@expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows") @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
def test_inferior_asserting_python(self): def test_inferior_asserting_python(self):
"""Test that lldb reliably catches the inferior asserting (Python API).""" """Test that lldb reliably catches the inferior asserting (Python API)."""
self.buildDefault() self.buildDefault()
self.inferior_asserting_python() self.inferior_asserting_python()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@unittest2.expectedFailure("rdar://15367233") @unittest2.expectedFailure("rdar://15367233")
def test_inferior_asserting_expr_dsym(self): def test_inferior_asserting_expr_dsym(self):
"""Test that the lldb expression interpreter can read from the inferior after asserting (command).""" """Test that the lldb expression interpreter can read from the inferior after asserting (command)."""
self.buildDsym() self.buildDsym()
self.inferior_asserting_expr() self.inferior_asserting_expr()
@expectedFailurei386('llvm.org/pr17384: lldb needs to be aware of linux-vdso.so to unwind stacks properly') @expectedFailurei386('llvm.org/pr17384: lldb needs to be aware of linux-vdso.so to unwind stacks properly')
@unittest2.expectedFailure("rdar://15367233") @unittest2.expectedFailure("rdar://15367233")
@expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows") @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
def test_inferior_asserting_expr_dwarf(self): def test_inferior_asserting_expr_dwarf(self):
"""Test that the lldb expression interpreter can read from the inferior after asserting (command).""" """Test that the lldb expression interpreter can read from the inferior after asserting (command)."""
self.buildDwarf() self.buildDwarf()
self.inferior_asserting_expr() self.inferior_asserting_expr()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@unittest2.expectedFailure("rdar://15367233") @unittest2.expectedFailure("rdar://15367233")
def test_inferior_asserting_step_dsym(self): def test_inferior_asserting_step_dsym(self):
"""Test that lldb functions correctly after stepping through a call to assert().""" """Test that lldb functions correctly after stepping through a call to assert()."""
self.buildDsym() self.buildDsym()
self.inferior_asserting_step() self.inferior_asserting_step()
@expectedFailurei386("llvm.org/pr17384: lldb needs to be aware of linux-vdso.so to unwind stacks properly") @expectedFailurei386("llvm.org/pr17384: lldb needs to be aware of linux-vdso.so to unwind stacks properly")
@expectedFailureDarwin("rdar://15367233") @expectedFailureDarwin("rdar://15367233")
▲ Show 20 Lines • Show All 195 Lines • Show Last 20 Lines

test/functionalities/inferior-changed/TestInferiorChanged.py

"""Test lldb reloads the inferior after it was changed during the session.""" """Test lldb reloads the inferior after it was changed during the session."""
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class ChangedInferiorTestCase(TestBase): class ChangedInferiorTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
def test_inferior_crashing_dsym(self): def test_inferior_crashing_dsym(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.buildDsym() self.buildDsym()
self.inferior_crashing() self.inferior_crashing()
self.cleanup() self.cleanup()
d = {'C_SOURCES': 'main2.c'} d = {'C_SOURCES': 'main2.c'}
self.buildDsym(dictionary=d) self.buildDsym(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

test/functionalities/inferior-crashing/TestInferiorCrashing.py

"""Test that lldb functions correctly after the inferior has crashed.""" """Test that lldb functions correctly after the inferior has crashed."""
import os, time import os, time
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
from lldbtest import * from lldbtest import *
class CrashingInferiorTestCase(TestBase): class CrashingInferiorTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
def test_inferior_crashing_dsym(self): def test_inferior_crashing_dsym(self):
"""Test that lldb reliably catches the inferior crashing (command).""" """Test that lldb reliably catches the inferior crashing (command)."""
self.buildDsym() self.buildDsym()
self.inferior_crashing() self.inferior_crashing()
def test_inferior_crashing_dwarf(self): def test_inferior_crashing_dwarf(self):
"""Test that lldb reliably catches the inferior crashing (command).""" """Test that lldb reliably catches the inferior crashing (command)."""
self.buildDwarf() self.buildDwarf()
self.inferior_crashing() self.inferior_crashing()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
def test_inferior_crashing_registers_dsym(self): def test_inferior_crashing_registers_dsym(self):
"""Test that lldb reliably reads registers from the inferior after crashing (command).""" """Test that lldb reliably reads registers from the inferior after crashing (command)."""
self.buildDsym() self.buildDsym()
self.inferior_crashing_registers() self.inferior_crashing_registers()
def test_inferior_crashing_register_dwarf(self): def test_inferior_crashing_register_dwarf(self):
"""Test that lldb reliably reads registers from the inferior after crashing (command).""" """Test that lldb reliably reads registers from the inferior after crashing (command)."""
self.buildDwarf() self.buildDwarf()
self.inferior_crashing_registers() self.inferior_crashing_registers()
@python_api_test @python_api_test
def test_inferior_crashing_python(self): def test_inferior_crashing_python(self):
"""Test that lldb reliably catches the inferior crashing (Python API).""" """Test that lldb reliably catches the inferior crashing (Python API)."""
self.buildDefault() self.buildDefault()
self.inferior_crashing_python() self.inferior_crashing_python()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
def test_inferior_crashing_expr_dsym(self): def test_inferior_crashing_expr_dsym(self):
"""Test that the lldb expression interpreter can read from the inferior after crashing (command).""" """Test that the lldb expression interpreter can read from the inferior after crashing (command)."""
self.buildDsym() self.buildDsym()
self.inferior_crashing_expr() self.inferior_crashing_expr()
def test_inferior_crashing_expr_dwarf(self): def test_inferior_crashing_expr_dwarf(self):
"""Test that the lldb expression interpreter can read from the inferior after crashing (command).""" """Test that the lldb expression interpreter can read from the inferior after crashing (command)."""
self.buildDwarf() self.buildDwarf()
self.inferior_crashing_expr() self.inferior_crashing_expr()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
def test_inferior_crashing_step_dsym(self): def test_inferior_crashing_step_dsym(self):
"""Test that lldb functions correctly after stepping through a crash.""" """Test that lldb functions correctly after stepping through a crash."""
self.buildDsym() self.buildDsym()
self.inferior_crashing_step() self.inferior_crashing_step()
def test_inferior_crashing_step_dwarf(self): def test_inferior_crashing_step_dwarf(self):
"""Test that stepping after a crash behaves correctly.""" """Test that stepping after a crash behaves correctly."""
self.buildDwarf() self.buildDwarf()
self.inferior_crashing_step() self.inferior_crashing_step()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
def test_inferior_crashing_step_after_break_dsym(self): def test_inferior_crashing_step_after_break_dsym(self):
"""Test that stepping after a crash behaves correctly.""" """Test that stepping after a crash behaves correctly."""
self.buildDsym() self.buildDsym()
self.inferior_crashing_step_after_break() self.inferior_crashing_step_after_break()
@skipIfFreeBSD # llvm.org/pr16684 @skipIfFreeBSD # llvm.org/pr16684
@expectedFailureLinux # due to llvm.org/pr15988 -- step over misbehaves after crash @expectedFailureLinux # due to llvm.org/pr15988 -- step over misbehaves after crash
def test_inferior_crashing_step_after_break_dwarf(self): def test_inferior_crashing_step_after_break_dwarf(self):
"""Test that lldb functions correctly after stepping through a crash.""" """Test that lldb functions correctly after stepping through a crash."""
self.buildDwarf() self.buildDwarf()
self.inferior_crashing_step_after_break() self.inferior_crashing_step_after_break()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
def test_inferior_crashing_expr_step_and_expr_dsym(self): def test_inferior_crashing_expr_step_and_expr_dsym(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."""
self.buildDsym() self.buildDsym()
self.inferior_crashing_expr_step_expr() self.inferior_crashing_expr_step_expr()
@expectedFailureFreeBSD('llvm.org/pr15989') # Couldn't allocate space for the stack frame @expectedFailureFreeBSD('llvm.org/pr15989') # Couldn't allocate space for the stack frame
@expectedFailureLinux # due to llvm.org/pr15989 -- expression fails after crash and step @expectedFailureLinux # due to llvm.org/pr15989 -- expression fails after crash and step
def test_inferior_crashing_expr_step_and_expr_dwarf(self): def test_inferior_crashing_expr_step_and_expr_dwarf(self):
▲ Show 20 Lines • Show All 158 Lines • Show Last 20 Lines

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

"""Test that lldb functions correctly after the inferior has crashed while in a recursive routine.""" """Test that lldb functions correctly after the inferior has crashed while in a recursive routine."""
import os, time import os, time
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
import sys import sys
from lldbtest import * from lldbtest import *
class CrashingRecursiveInferiorTestCase(TestBase): class CrashingRecursiveInferiorTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
def test_recursive_inferior_crashing_dsym(self): def test_recursive_inferior_crashing_dsym(self):
"""Test that lldb reliably catches the inferior crashing (command).""" """Test that lldb reliably catches the inferior crashing (command)."""
self.buildDsym() self.buildDsym()
self.recursive_inferior_crashing() self.recursive_inferior_crashing()
def test_recursive_inferior_crashing_dwarf(self): def test_recursive_inferior_crashing_dwarf(self):
"""Test that lldb reliably catches the inferior crashing (command).""" """Test that lldb reliably catches the inferior crashing (command)."""
self.buildDwarf() self.buildDwarf()
self.recursive_inferior_crashing() self.recursive_inferior_crashing()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
def test_recursive_inferior_crashing_registers_dsym(self): def test_recursive_inferior_crashing_registers_dsym(self):
"""Test that lldb reliably reads registers from the inferior after crashing (command).""" """Test that lldb reliably reads registers from the inferior after crashing (command)."""
self.buildDsym() self.buildDsym()
self.recursive_inferior_crashing_registers() self.recursive_inferior_crashing_registers()
def test_recursive_inferior_crashing_register_dwarf(self): def test_recursive_inferior_crashing_register_dwarf(self):
"""Test that lldb reliably reads registers from the inferior after crashing (command).""" """Test that lldb reliably reads registers from the inferior after crashing (command)."""
self.buildDwarf() self.buildDwarf()
self.recursive_inferior_crashing_registers() self.recursive_inferior_crashing_registers()
@python_api_test @python_api_test
def test_recursive_inferior_crashing_python(self): def test_recursive_inferior_crashing_python(self):
"""Test that lldb reliably catches the inferior crashing (Python API).""" """Test that lldb reliably catches the inferior crashing (Python API)."""
self.buildDefault() self.buildDefault()
self.recursive_inferior_crashing_python() self.recursive_inferior_crashing_python()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
def test_recursive_inferior_crashing_expr_dsym(self): def test_recursive_inferior_crashing_expr_dsym(self):
"""Test that the lldb expression interpreter can read from the inferior after crashing (command).""" """Test that the lldb expression interpreter can read from the inferior after crashing (command)."""
self.buildDsym() self.buildDsym()
self.recursive_inferior_crashing_expr() self.recursive_inferior_crashing_expr()
def test_recursive_inferior_crashing_expr_dwarf(self): def test_recursive_inferior_crashing_expr_dwarf(self):
"""Test that the lldb expression interpreter can read from the inferior after crashing (command).""" """Test that the lldb expression interpreter can read from the inferior after crashing (command)."""
self.buildDwarf() self.buildDwarf()
self.recursive_inferior_crashing_expr() self.recursive_inferior_crashing_expr()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
def test_recursive_inferior_crashing_step_dsym(self): def test_recursive_inferior_crashing_step_dsym(self):
"""Test that lldb functions correctly after stepping through a crash.""" """Test that lldb functions correctly after stepping through a crash."""
self.buildDsym() self.buildDsym()
self.recursive_inferior_crashing_step() self.recursive_inferior_crashing_step()
def test_recursive_inferior_crashing_step_dwarf(self): def test_recursive_inferior_crashing_step_dwarf(self):
"""Test that stepping after a crash behaves correctly.""" """Test that stepping after a crash behaves correctly."""
self.buildDwarf() self.buildDwarf()
self.recursive_inferior_crashing_step() self.recursive_inferior_crashing_step()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
def test_recursive_inferior_crashing_step_after_break_dsym(self): def test_recursive_inferior_crashing_step_after_break_dsym(self):
"""Test that stepping after a crash behaves correctly.""" """Test that stepping after a crash behaves correctly."""
self.buildDsym() self.buildDsym()
self.recursive_inferior_crashing_step_after_break() self.recursive_inferior_crashing_step_after_break()
@skipIfFreeBSD # llvm.org/pr16684 @skipIfFreeBSD # llvm.org/pr16684
@expectedFailureLinux('llvm.org/pr16684') @expectedFailureLinux('llvm.org/pr16684')
def test_recursive_inferior_crashing_step_after_break_dwarf(self): def test_recursive_inferior_crashing_step_after_break_dwarf(self):
"""Test that lldb functions correctly after stepping through a crash.""" """Test that lldb functions correctly after stepping through a crash."""
self.buildDwarf() self.buildDwarf()
self.recursive_inferior_crashing_step_after_break() self.recursive_inferior_crashing_step_after_break()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
def test_recursive_inferior_crashing_expr_step_and_expr_dsym(self): def test_recursive_inferior_crashing_expr_step_and_expr_dsym(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."""
self.buildDsym() self.buildDsym()
self.recursive_inferior_crashing_expr_step_expr() self.recursive_inferior_crashing_expr_step_expr()
@expectedFailureFreeBSD('llvm.org/pr15989') # Couldn't allocate space for the stack frame @expectedFailureFreeBSD('llvm.org/pr15989') # Couldn't allocate space for the stack frame
@expectedFailureLinux('llvm.org/pr15989') # Couldn't allocate space for the stack frame @expectedFailureLinux('llvm.org/pr15989') # Couldn't allocate space for the stack frame
def test_recursive_inferior_crashing_expr_step_and_expr_dwarf(self): def test_recursive_inferior_crashing_expr_step_and_expr_dwarf(self):
▲ Show 20 Lines • Show All 161 Lines • Show Last 20 Lines

test/functionalities/inline-stepping/TestInlineStepping.py

"""Test stepping over and into inlined functions.""" """Test stepping over and into inlined functions."""
import os, time, sys import os, time, sys
import unittest2 import unittest2
import lldb import lldb
import lldbutil import lldbutil
from lldbtest import * from lldbtest import *
class TestInlineStepping(TestBase): class TestInlineStepping(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym_and_python_api(self): def test_with_dsym_and_python_api(self):
"""Test stepping over and into inlined functions.""" """Test stepping over and into inlined functions."""
self.buildDsym() self.buildDsym()
self.inline_stepping() self.inline_stepping()
@python_api_test @python_api_test
@dwarf_test @dwarf_test
@expectedFailureFreeBSD('llvm.org/pr17214') @expectedFailureFreeBSD('llvm.org/pr17214')
@expectedFailureIcc # Not really a bug. ICC combines two inlined functions. @expectedFailureIcc # Not really a bug. ICC combines two inlined functions.
def test_with_dwarf_and_python_api(self): def test_with_dwarf_and_python_api(self):
"""Test stepping over and into inlined functions.""" """Test stepping over and into inlined functions."""
self.buildDwarf() self.buildDwarf()
self.inline_stepping() self.inline_stepping()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_step_over_with_dsym_and_python_api(self): def test_step_over_with_dsym_and_python_api(self):
"""Test stepping over and into inlined functions.""" """Test stepping over and into inlined functions."""
self.buildDsym() self.buildDsym()
self.inline_stepping_step_over() self.inline_stepping_step_over()
@python_api_test @python_api_test
▲ Show 20 Lines • Show All 213 Lines • Show Last 20 Lines

test/functionalities/launch_with_shellexpand/TestLaunchWithShellExpand.py

""" """
Test that argdumper is a viable launching strategy. Test that argdumper is a viable launching strategy.
""" """
import commands import commands
import lldb import lldb
import os import os
import time import time
import unittest2 import unittest2
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class LaunchWithShellExpandTestCase(TestBase): class LaunchWithShellExpandTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym (self): def test_with_dsym (self):
self.buildDsym() self.buildDsym()
self.do_test () self.do_test ()
@expectedFailureFreeBSD("llvm.org/pr22627 process launch w/ shell expansion not working") @expectedFailureFreeBSD("llvm.org/pr22627 process launch w/ shell expansion not working")
@expectedFailureLinux("llvm.org/pr22627 process launch w/ shell expansion not working") @expectedFailureLinux("llvm.org/pr22627 process launch w/ shell expansion not working")
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

test/functionalities/memory/read/TestMemoryRead.py

""" """
Test the 'memory read' command. Test the 'memory read' command.
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class MemoryReadTestCase(TestBase): class MemoryReadTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_memory_read_with_dsym(self): def test_memory_read_with_dsym(self):
"""Test the 'memory read' command with plain and vector formats.""" """Test the 'memory read' command with plain and vector formats."""
self.buildDsym() self.buildDsym()
self.memory_read_command() self.memory_read_command()
@dwarf_test @dwarf_test
def test_memory_read_with_dwarf(self): def test_memory_read_with_dwarf(self):
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

test/functionalities/nosucharch/TestNoSuchArch.py

""" """
Test that using a non-existent architecture name does not crash LLDB. Test that using a non-existent architecture name does not crash LLDB.
""" """
import lldb import lldb
import unittest2 import unittest2
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class NoSuchArchTestCase(TestBase): class NoSuchArchTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym (self): def test_with_dsym (self):
self.buildDsym() self.buildDsym()
self.do_test () self.do_test ()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_with_dwarf (self): def test_with_dwarf (self):
self.buildDwarf() self.buildDwarf()
self.do_test () self.do_test ()
def do_test (self): def do_test (self):
exe = os.path.join (os.getcwd(), "a.out") exe = os.path.join (os.getcwd(), "a.out")
Show All 19 Lines

test/functionalities/paths/TestPaths.py

Show All 28 Lines def test_paths (self):
self.assertTrue (f.GetFilename() == None); self.assertTrue (f.GetFilename() == None);
def test_filespec_resolve_doesnt_prepend_cwd_if_file_doesnt_exist (self): def test_filespec_resolve_doesnt_prepend_cwd_if_file_doesnt_exist (self):
file_only = lldb.SBFileSpec("VeryUnlikelToExistInTheCurrentWorkingDirectory", True) file_only = lldb.SBFileSpec("VeryUnlikelToExistInTheCurrentWorkingDirectory", True)
# SBFileSpec(path, True) should not prepend the current-working-directory to the # SBFileSpec(path, True) should not prepend the current-working-directory to the
# file path if it doesn't exist in the current directory. # file path if it doesn't exist in the current directory.
self.assertTrue (file_only.GetDirectory() == None) self.assertTrue (file_only.GetDirectory() == None)
@unittest2.skipUnless(sys.platform.startswith("win32"), "Test for windows only") @skipUnlessPlatform(["windows"])
def test_windows_double_slash (self): def test_windows_double_slash (self):
'''Test to check the path with double slash is handled correctly ''' '''Test to check the path with double slash is handled correctly '''
# Create a path and see if lldb gets the directory and file right # Create a path and see if lldb gets the directory and file right
fspec = lldb.SBFileSpec("C:\\dummy1\\dummy2//unknown_file", True); fspec = lldb.SBFileSpec("C:\\dummy1\\dummy2//unknown_file", True);
self.assertTrue (fspec.GetDirectory() == "C:/dummy1/dummy2"); self.assertTrue (fspec.GetDirectory() == "C:/dummy1/dummy2");
self.assertTrue (fspec.GetFilename() == "unknown_file"); self.assertTrue (fspec.GetFilename() == "unknown_file");
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/plugins/python_os_plugin/TestPythonOSPlugin.py

""" """
Test that the Python operating system plugin works correctly Test that the Python operating system plugin works correctly
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class PluginPythonOSPlugin(TestBase): class PluginPythonOSPlugin(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_python_os_plugin_dsym(self): def test_python_os_plugin_dsym(self):
"""Test that the Python operating system plugin works correctly""" """Test that the Python operating system plugin works correctly"""
self.buildDsym() self.buildDsym()
self.run_python_os_funcionality() self.run_python_os_funcionality()
@dwarf_test @dwarf_test
def test_python_os_plugin_dwarf(self): def test_python_os_plugin_dwarf(self):
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

test/functionalities/process_attach/TestProcessAttach.py

""" """
Test process attach. Test process attach.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
exe_name = "ProcessAttach" # Must match Makefile exe_name = "ProcessAttach" # Must match Makefile
class ProcessAttachTestCase(TestBase): class ProcessAttachTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_attach_to_process_by_id_with_dsym(self): def test_attach_to_process_by_id_with_dsym(self):
"""Test attach by process id""" """Test attach by process id"""
self.buildDsym() self.buildDsym()
self.process_attach_by_id() self.process_attach_by_id()
@dwarf_test @dwarf_test
def test_attach_to_process_by_id_with_dwarf(self): def test_attach_to_process_by_id_with_dwarf(self):
"""Test attach by process id""" """Test attach by process id"""
self.buildDwarf() self.buildDwarf()
self.process_attach_by_id() self.process_attach_by_id()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_attach_to_process_by_name_with_dsym(self): def test_attach_to_process_by_name_with_dsym(self):
"""Test attach by process name""" """Test attach by process name"""
self.buildDsym() self.buildDsym()
self.process_attach_by_name() self.process_attach_by_name()
@dwarf_test @dwarf_test
def test_attach_to_process_by_name_with_dwarf(self): def test_attach_to_process_by_name_with_dwarf(self):
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

test/functionalities/process_launch/TestProcessLaunch.py

Show All 12 Linesclass ProcessLaunchTestCase(TestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# disable "There is a running process, kill it and restart?" prompt # disable "There is a running process, kill it and restart?" prompt
self.runCmd("settings set auto-confirm true") self.runCmd("settings set auto-confirm true")
self.addTearDownHook(lambda: self.runCmd("settings clear auto-confirm")) self.addTearDownHook(lambda: self.runCmd("settings clear auto-confirm"))
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_io_with_dsym (self): def test_io_with_dsym (self):
"""Test that process launch I/O redirection flags work properly.""" """Test that process launch I/O redirection flags work properly."""
self.buildDsym () self.buildDsym ()
self.process_io_test () self.process_io_test ()
@dwarf_test @dwarf_test
def test_io_with_dwarf (self): def test_io_with_dwarf (self):
▲ Show 20 Lines • Show All 82 Lines • ▼ Show 20 Lines"
except OSError: except OSError:
pass pass
if not success: if not success:
self.fail (err_msg) self.fail (err_msg)
d = {'CXX_SOURCES' : 'print_cwd.cpp'} d = {'CXX_SOURCES' : 'print_cwd.cpp'}
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
@expectedFailureDarwin("llvm.org/pr20265") @expectedFailureDarwin("llvm.org/pr20265")
def test_set_working_dir_with_dsym (self): def test_set_working_dir_with_dsym (self):
"""Test that '-w dir' sets the working dir when running the inferior.""" """Test that '-w dir' sets the working dir when running the inferior."""
self.buildDsym(dictionary=self.d) self.buildDsym(dictionary=self.d)
self.setTearDownCleanup(self.d) self.setTearDownCleanup(self.d)
self.my_working_dir_test() self.my_working_dir_test()
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

test/functionalities/recursion/TestValueObjectRecursion.py

""" """
Test lldb data formatter subsystem. Test lldb data formatter subsystem.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class ValueObjectRecursionTestCase(TestBase): class ValueObjectRecursionTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test that deeply nested ValueObjects still work.""" """Test that deeply nested ValueObjects still work."""
self.buildDsym() self.buildDsym()
self.recursive_vo_commands() self.recursive_vo_commands()
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

test/functionalities/rerun/TestRerun.py

""" """
Test that argdumper is a viable launching strategy. Test that argdumper is a viable launching strategy.
""" """
import commands import commands
import lldb import lldb
import os import os
import time import time
import unittest2 import unittest2
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class TestRerun(TestBase): class TestRerun(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym (self): def test_with_dsym (self):
self.buildDsym() self.buildDsym()
self.do_test () self.do_test ()
@dwarf_test @dwarf_test
def test_with_dwarf (self): def test_with_dwarf (self):
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

test/functionalities/return-value/TestReturnValue.py

""" """
Test getting return-values correctly when stepping out Test getting return-values correctly when stepping out
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
from lldbtest import * from lldbtest import *
class ReturnValueTestCase(TestBase): class ReturnValueTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@expectedFailurei386 @expectedFailurei386
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym_python(self): def test_with_dsym_python(self):
"""Test getting return values from stepping out with dsyms.""" """Test getting return values from stepping out with dsyms."""
self.buildDsym() self.buildDsym()
self.do_return_value() self.do_return_value()
▲ Show 20 Lines • Show All 201 Lines • Show Last 20 Lines

test/functionalities/set-data/TestSetData.py

""" """
Set the contents of variables and registers using raw data Set the contents of variables and registers using raw data
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
class SetDataTestCase(TestBase): class SetDataTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@dsym_test @dsym_test
def test_set_data_dsym(self): def test_set_data_dsym(self):
"""Test setting the contents of variables and registers using raw data.""" """Test setting the contents of variables and registers using raw data."""
self.buildDsym() self.buildDsym()
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

test/functionalities/signal/TestSendSignal.py

"""Test that lldb command 'process signal SIGUSR1' to send a signal to the inferior works.""" """Test that lldb command 'process signal SIGUSR1' to send a signal to the inferior works."""
import os, time, signal import os, time, signal
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class SendSignalTestCase(TestBase): class SendSignalTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test that lldb command 'process signal SIGUSR1' sends a signal to the inferior process.""" """Test that lldb command 'process signal SIGUSR1' sends a signal to the inferior process."""
self.buildDsym() self.buildDsym()
self.send_signal() self.send_signal()
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

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

""" """
Test thread step-in, step-over and step-out work with the "Avoid no debug" option. Test thread step-in, step-over and step-out work with the "Avoid no debug" option.
""" """
import os import os
import re import re
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
import sys import sys
from lldbtest import * from lldbtest import *
class ReturnValueTestCase(TestBase): class ReturnValueTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_step_out_with_dsym_python(self): def test_step_out_with_dsym_python(self):
"""Test stepping out using avoid-no-debug with dsyms.""" """Test stepping out using avoid-no-debug with dsyms."""
self.buildDsym() self.buildDsym()
self.get_to_starting_point() self.get_to_starting_point()
self.do_step_out_past_nodebug() self.do_step_out_past_nodebug()
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_step_out_with_dwarf_python(self): def test_step_out_with_dwarf_python(self):
"""Test stepping out using avoid-no-debug with dsyms.""" """Test stepping out using avoid-no-debug with dsyms."""
self.buildDwarf() self.buildDwarf()
self.get_to_starting_point() self.get_to_starting_point()
self.do_step_out_past_nodebug() self.do_step_out_past_nodebug()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_step_over_with_dsym_python(self): def test_step_over_with_dsym_python(self):
"""Test stepping over using avoid-no-debug with dsyms.""" """Test stepping over using avoid-no-debug with dsyms."""
self.buildDsym() self.buildDsym()
self.get_to_starting_point() self.get_to_starting_point()
self.do_step_over_past_nodebug() self.do_step_over_past_nodebug()
@python_api_test @python_api_test
@dwarf_test @dwarf_test
@skipIfLinux # intermittent failure - llvm.org/pr19247 @skipIfLinux # intermittent failure - llvm.org/pr19247
def test_step_over_with_dwarf_python(self): def test_step_over_with_dwarf_python(self):
"""Test stepping over using avoid-no-debug with dwarf.""" """Test stepping over using avoid-no-debug with dwarf."""
self.buildDwarf() self.buildDwarf()
self.get_to_starting_point() self.get_to_starting_point()
self.do_step_over_past_nodebug() self.do_step_over_past_nodebug()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_step_in_with_dsym_python(self): def test_step_in_with_dsym_python(self):
"""Test stepping in using avoid-no-debug with dsyms.""" """Test stepping in using avoid-no-debug with dsyms."""
self.buildDsym() self.buildDsym()
self.get_to_starting_point() self.get_to_starting_point()
self.do_step_in_past_nodebug() self.do_step_in_past_nodebug()
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

test/functionalities/stop-hook/TestStopHookCmd.py

Show All 12 Linesclass StopHookCmdTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
# Regression test. # Regression test.
def test_not_crashing_if_no_target(self): def test_not_crashing_if_no_target(self):
"""target stop-hook list should not crash if no target has been set.""" """target stop-hook list should not crash if no target has been set."""
self.runCmd("target stop-hook list", check=False) self.runCmd("target stop-hook list", check=False)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test a sequence of target stop-hook commands.""" """Test a sequence of target stop-hook commands."""
self.buildDsym() self.buildDsym()
self.stop_hook_cmd_sequence() self.stop_hook_cmd_sequence()
@dwarf_test @dwarf_test
def test_with_dwarf(self): def test_with_dwarf(self):
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

test/functionalities/stop-hook/TestStopHookMechanism.py

""" """
Test lldb target stop-hook mechanism to see whether it fires off correctly . Test lldb target stop-hook mechanism to see whether it fires off correctly .
""" """
import os import os
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
class StopHookMechanismTestCase(TestBase): class StopHookMechanismTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test the stop-hook mechanism.""" """Test the stop-hook mechanism."""
self.buildDsym() self.buildDsym()
self.stop_hook_firing() self.stop_hook_firing()
@skipIfFreeBSD # llvm.org/pr15037 @skipIfFreeBSD # llvm.org/pr15037
@expectedFailureLinux('llvm.org/pr15037') # stop-hooks sometimes fail to fire on Linux @expectedFailureLinux('llvm.org/pr15037') # stop-hooks sometimes fail to fire on Linux
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

test/functionalities/stop-hook/multiple_threads/TestStopHookMultipleThreads.py

""" """
Test that lldb stop-hook works for multiple threads. Test that lldb stop-hook works for multiple threads.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
class StopHookForMultipleThreadsTestCase(TestBase): class StopHookForMultipleThreadsTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_stop_hook_multiple_threads_with_dsym(self): def test_stop_hook_multiple_threads_with_dsym(self):
"""Test that lldb stop-hook works for multiple threads.""" """Test that lldb stop-hook works for multiple threads."""
self.buildDsym(dictionary=self.d) self.buildDsym(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
self.stop_hook_multiple_threads() self.stop_hook_multiple_threads()
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

test/functionalities/target_command/TestTargetCommand.py

Show All 32 Lines def test_target_command_with_dwarf(self):
dc = {'C_SOURCES': 'c.c', 'EXE': 'c.out'} dc = {'C_SOURCES': 'c.c', 'EXE': 'c.out'}
self.buildDwarf(dictionary=dc) self.buildDwarf(dictionary=dc)
self.addTearDownCleanup(dictionary=dc) self.addTearDownCleanup(dictionary=dc)
self.do_target_command() self.do_target_command()
# rdar://problem/9763907 # rdar://problem/9763907
# 'target variable' command fails if the target program has been run # 'target variable' command fails if the target program has been run
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_target_variable_command_with_dsym(self): def test_target_variable_command_with_dsym(self):
"""Test 'target variable' command before and after starting the inferior.""" """Test 'target variable' command before and after starting the inferior."""
d = {'C_SOURCES': 'globals.c', 'EXE': 'globals'} d = {'C_SOURCES': 'globals.c', 'EXE': 'globals'}
self.buildDsym(dictionary=d) self.buildDsym(dictionary=d)
self.addTearDownCleanup(dictionary=d) self.addTearDownCleanup(dictionary=d)
self.do_target_variable_command('globals') self.do_target_variable_command('globals')
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_target_variable_command_with_dsym_no_fail(self): def test_target_variable_command_with_dsym_no_fail(self):
"""Test 'target variable' command before and after starting the inferior.""" """Test 'target variable' command before and after starting the inferior."""
d = {'C_SOURCES': 'globals.c', 'EXE': 'globals'} d = {'C_SOURCES': 'globals.c', 'EXE': 'globals'}
self.buildDsym(dictionary=d) self.buildDsym(dictionary=d)
self.addTearDownCleanup(dictionary=d) self.addTearDownCleanup(dictionary=d)
self.do_target_variable_command_no_fail('globals') self.do_target_variable_command_no_fail('globals')
▲ Show 20 Lines • Show All 148 Lines • Show Last 20 Lines

test/functionalities/thread/TestNumThreads.py

""" """
Test number of threads. Test number of threads.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class NumberOfThreadsTestCase(TestBase): class NumberOfThreadsTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test number of threads.""" """Test number of threads."""
self.buildDsym() self.buildDsym()
self.number_of_threads_test() self.number_of_threads_test()
@dwarf_test @dwarf_test
def test_with_dwarf(self): def test_with_dwarf(self):
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

test/functionalities/thread/break_after_join/TestBreakAfterJoin.py

""" """
Test number of threads. Test number of threads.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class BreakpointAfterJoinTestCase(TestBase): class BreakpointAfterJoinTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained @expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test breakpoint handling after a thread join.""" """Test breakpoint handling after a thread join."""
self.buildDsym(dictionary=self.getBuildFlags()) self.buildDsym(dictionary=self.getBuildFlags())
self.breakpoint_after_join_test() self.breakpoint_after_join_test()
@expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained @expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

test/functionalities/thread/create_after_attach/TestCreateAfterAttach.py

""" """
Test thread creation after process attach. Test thread creation after process attach.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class CreateAfterAttachTestCase(TestBase): class CreateAfterAttachTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_create_after_attach_with_dsym(self): def test_create_after_attach_with_dsym(self):
"""Test thread creation after process attach.""" """Test thread creation after process attach."""
self.buildDsym(dictionary=self.getBuildFlags(use_cpp11=False)) self.buildDsym(dictionary=self.getBuildFlags(use_cpp11=False))
self.create_after_attach(use_fork=False) self.create_after_attach(use_fork=False)
@skipIfFreeBSD # Hangs. May be the same as Linux issue llvm.org/pr16229 but @skipIfFreeBSD # Hangs. May be the same as Linux issue llvm.org/pr16229 but
# not yet investigated. Revisit once required functionality # not yet investigated. Revisit once required functionality
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines

test/functionalities/thread/create_during_step/TestCreateDuringStep.py

""" """
Test number of threads. Test number of threads.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class CreateDuringStepTestCase(TestBase): class CreateDuringStepTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained @expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained
@dsym_test @dsym_test
def test_step_inst_with_dsym(self): def test_step_inst_with_dsym(self):
"""Test thread creation during step-inst handling.""" """Test thread creation during step-inst handling."""
self.buildDsym(dictionary=self.getBuildFlags()) self.buildDsym(dictionary=self.getBuildFlags())
self.create_during_step_inst_test() self.create_during_step_inst_test()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained @expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained
@dsym_test @dsym_test
def test_step_over_with_dsym(self): def test_step_over_with_dsym(self):
"""Test thread creation during step-over handling.""" """Test thread creation during step-over handling."""
self.buildDsym(dictionary=self.getBuildFlags()) self.buildDsym(dictionary=self.getBuildFlags())
self.create_during_step_over_test() self.create_during_step_over_test()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained @expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained
@dsym_test @dsym_test
def test_step_in_with_dsym(self): def test_step_in_with_dsym(self):
"""Test thread creation during step-in handling.""" """Test thread creation during step-in handling."""
self.buildDsym(dictionary=self.getBuildFlags()) self.buildDsym(dictionary=self.getBuildFlags())
self.create_during_step_in_test() self.create_during_step_in_test()
@expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained @expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained
▲ Show 20 Lines • Show All 127 Lines • Show Last 20 Lines

test/functionalities/thread/exit_during_break/TestExitDuringBreak.py

""" """
Test number of threads. Test number of threads.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class ExitDuringBreakpointTestCase(TestBase): class ExitDuringBreakpointTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained @expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test thread exit during breakpoint handling.""" """Test thread exit during breakpoint handling."""
self.buildDsym(dictionary=self.getBuildFlags()) self.buildDsym(dictionary=self.getBuildFlags())
self.exit_during_breakpoint_test() self.exit_during_breakpoint_test()
@expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained @expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

test/functionalities/thread/exit_during_step/TestExitDuringStep.py

""" """
Test number of threads. Test number of threads.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class ExitDuringStepTestCase(TestBase): class ExitDuringStepTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained @expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained
@dsym_test @dsym_test
def test_thread_state_is_stopped_with_dsym(self): def test_thread_state_is_stopped_with_dsym(self):
"""Test thread exit during step handling.""" """Test thread exit during step handling."""
self.buildDsym(dictionary=self.getBuildFlags()) self.buildDsym(dictionary=self.getBuildFlags())
self.thread_state_is_stopped() self.thread_state_is_stopped()
@expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained @expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained
@expectedFailureFreeBSD("llvm.org/pr18190") # thread states not properly maintained @expectedFailureFreeBSD("llvm.org/pr18190") # thread states not properly maintained
@expectedFailureLLGS("llvm.org/pr15824") # thread states not properly maintained @expectedFailureLLGS("llvm.org/pr15824") # thread states not properly maintained
@dwarf_test @dwarf_test
def test_thread_state_is_stopped_with_dwarf(self): def test_thread_state_is_stopped_with_dwarf(self):
"""Test thread exit during step handling.""" """Test thread exit during step handling."""
self.buildDwarf(dictionary=self.getBuildFlags()) self.buildDwarf(dictionary=self.getBuildFlags())
self.thread_state_is_stopped() self.thread_state_is_stopped()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test thread exit during step handling.""" """Test thread exit during step handling."""
self.buildDsym(dictionary=self.getBuildFlags()) self.buildDsym(dictionary=self.getBuildFlags())
self.exit_during_step_inst_test() self.exit_during_step_inst_test()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_step_over_with_dsym(self): def test_step_over_with_dsym(self):
"""Test thread exit during step-over handling.""" """Test thread exit during step-over handling."""
self.buildDsym(dictionary=self.getBuildFlags()) self.buildDsym(dictionary=self.getBuildFlags())
self.exit_during_step_over_test() self.exit_during_step_over_test()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_step_in_with_dsym(self): def test_step_in_with_dsym(self):
"""Test thread exit during step-in handling.""" """Test thread exit during step-in handling."""
self.buildDsym(dictionary=self.getBuildFlags()) self.buildDsym(dictionary=self.getBuildFlags())
self.exit_during_step_in_test() self.exit_during_step_in_test()
@skipIfFreeBSD # llvm.org/pr21411: test is hanging @skipIfFreeBSD # llvm.org/pr21411: test is hanging
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

test/functionalities/thread/jump/TestThreadJump.py

""" """
Test jumping to different places. Test jumping to different places.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class ThreadJumpTestCase(TestBase): class ThreadJumpTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test thread jump handling.""" """Test thread jump handling."""
self.buildDsym(dictionary=self.getBuildFlags()) self.buildDsym(dictionary=self.getBuildFlags())
self.thread_jump_test() self.thread_jump_test()
@dwarf_test @dwarf_test
def test_with_dwarf(self): def test_with_dwarf(self):
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

test/functionalities/thread/multi_break/TestMultipleBreakpoints.py

""" """
Test number of threads. Test number of threads.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class MultipleBreakpointTestCase(TestBase): class MultipleBreakpointTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained @expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test simultaneous breakpoints in multiple threads.""" """Test simultaneous breakpoints in multiple threads."""
self.buildDsym(dictionary=self.getBuildFlags()) self.buildDsym(dictionary=self.getBuildFlags())
self.multiple_breakpoint_test() self.multiple_breakpoint_test()
@expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained @expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

test/functionalities/thread/state/TestThreadStates.py

""" """
Test thread states. Test thread states.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class ThreadStateTestCase(TestBase): class ThreadStateTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
@expectedFailureDarwin("rdar://15367566") @expectedFailureDarwin("rdar://15367566")
def test_state_after_breakpoint_with_dsym(self): def test_state_after_breakpoint_with_dsym(self):
"""Test thread state after breakpoint.""" """Test thread state after breakpoint."""
self.buildDsym(dictionary=self.getBuildFlags(use_cpp11=False)) self.buildDsym(dictionary=self.getBuildFlags(use_cpp11=False))
self.thread_state_after_breakpoint_test() self.thread_state_after_breakpoint_test()
@expectedFailureDarwin("rdar://15367566") @expectedFailureDarwin("rdar://15367566")
@expectedFailureFreeBSD('llvm.org/pr15824') @expectedFailureFreeBSD('llvm.org/pr15824')
@expectedFailureLLGS("llvm.org/pr15824") # thread states not properly maintained @expectedFailureLLGS("llvm.org/pr15824") # thread states not properly maintained
@dwarf_test @dwarf_test
def test_state_after_breakpoint_with_dwarf(self): def test_state_after_breakpoint_with_dwarf(self):
"""Test thread state after breakpoint.""" """Test thread state after breakpoint."""
self.buildDwarf(dictionary=self.getBuildFlags(use_cpp11=False)) self.buildDwarf(dictionary=self.getBuildFlags(use_cpp11=False))
self.thread_state_after_breakpoint_test() self.thread_state_after_breakpoint_test()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_state_after_continue_with_dsym(self): def test_state_after_continue_with_dsym(self):
"""Test thread state after continue.""" """Test thread state after continue."""
self.buildDsym(dictionary=self.getBuildFlags(use_cpp11=False)) self.buildDsym(dictionary=self.getBuildFlags(use_cpp11=False))
self.thread_state_after_continue_test() self.thread_state_after_continue_test()
@dwarf_test @dwarf_test
def test_state_after_continue_with_dwarf(self): def test_state_after_continue_with_dwarf(self):
"""Test thread state after continue.""" """Test thread state after continue."""
self.buildDwarf(dictionary=self.getBuildFlags(use_cpp11=False)) self.buildDwarf(dictionary=self.getBuildFlags(use_cpp11=False))
self.thread_state_after_continue_test() self.thread_state_after_continue_test()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_state_after_expression_with_dsym(self): def test_state_after_expression_with_dsym(self):
"""Test thread state after expression.""" """Test thread state after expression."""
self.buildDsym(dictionary=self.getBuildFlags(use_cpp11=False)) self.buildDsym(dictionary=self.getBuildFlags(use_cpp11=False))
self.thread_state_after_continue_test() self.thread_state_after_continue_test()
@dwarf_test @dwarf_test
def test_state_after_expression_with_dwarf(self): def test_state_after_expression_with_dwarf(self):
"""Test thread state after expression.""" """Test thread state after expression."""
self.buildDwarf(dictionary=self.getBuildFlags(use_cpp11=False)) self.buildDwarf(dictionary=self.getBuildFlags(use_cpp11=False))
self.thread_state_after_continue_test() self.thread_state_after_continue_test()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
@unittest2.expectedFailure("llvm.org/pr16172") # thread states not properly maintained @unittest2.expectedFailure("llvm.org/pr16172") # thread states not properly maintained
def test_process_interrupt_with_dsym(self): def test_process_interrupt_with_dsym(self):
"""Test process interrupt.""" """Test process interrupt."""
self.buildDsym(dictionary=self.getBuildFlags(use_cpp11=False)) self.buildDsym(dictionary=self.getBuildFlags(use_cpp11=False))
self.process_interrupt_test() self.process_interrupt_test()
@dwarf_test @dwarf_test
@unittest2.expectedFailure("llvm.org/pr16712") # thread states not properly maintained @unittest2.expectedFailure("llvm.org/pr16712") # thread states not properly maintained
def test_process_interrupt_with_dwarf(self): def test_process_interrupt_with_dwarf(self):
"""Test process interrupt.""" """Test process interrupt."""
self.buildDwarf(dictionary=self.getBuildFlags(use_cpp11=False)) self.buildDwarf(dictionary=self.getBuildFlags(use_cpp11=False))
self.process_interrupt_test() self.process_interrupt_test()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
@unittest2.expectedFailure("llvm.org/pr15824") # thread states not properly maintained @unittest2.expectedFailure("llvm.org/pr15824") # thread states not properly maintained
def test_process_state_with_dsym(self): def test_process_state_with_dsym(self):
"""Test thread states (comprehensive).""" """Test thread states (comprehensive)."""
self.buildDsym(dictionary=self.getBuildFlags(use_cpp11=False)) self.buildDsym(dictionary=self.getBuildFlags(use_cpp11=False))
self.thread_states_test() self.thread_states_test()
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 301 Lines • Show Last 20 Lines

test/functionalities/thread/thread_exit/TestThreadExit.py

""" """
Test number of threads. Test number of threads.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class ThreadExitTestCase(TestBase): class ThreadExitTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained @expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test thread exit handling.""" """Test thread exit handling."""
self.buildDsym(dictionary=self.getBuildFlags()) self.buildDsym(dictionary=self.getBuildFlags())
self.thread_exit_test() self.thread_exit_test()
@expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained @expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained
▲ Show 20 Lines • Show All 110 Lines • Show Last 20 Lines

test/functionalities/thread/thread_specific_break/TestThreadSpecificBreakpoint.py

""" """
Test that we obey thread conditioned breakpoints. Test that we obey thread conditioned breakpoints.
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
from lldbtest import * from lldbtest import *
class ThreadSpecificBreakTestCase(TestBase): class ThreadSpecificBreakTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym_python(self): def test_with_dsym_python(self):
"""Test that we obey thread conditioned breakpoints.""" """Test that we obey thread conditioned breakpoints."""
self.buildDsym() self.buildDsym()
self.do_thread_specific_break() self.do_thread_specific_break()
@expectedFailureFreeBSD('llvm.org/pr18522') # hits break in another thread in testrun @expectedFailureFreeBSD('llvm.org/pr18522') # hits break in another thread in testrun
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

test/functionalities/tty/TestTerminal.py

Show All 9 Lines
class LaunchInTerminalTestCase(TestBase): class LaunchInTerminalTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
# Darwin is the only platform that I know of that supports optionally launching # Darwin is the only platform that I know of that supports optionally launching
# a program in a separate terminal window. It would be great if other platforms # a program in a separate terminal window. It would be great if other platforms
# added support for this. # added support for this.
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
# If the test is being run under sudo, the spawned terminal won't retain that elevated # If the test is being run under sudo, the spawned terminal won't retain that elevated
# privilege so it can't open the socket to talk back to the test case # privilege so it can't open the socket to talk back to the test case
@unittest2.skipUnless(os.geteuid() != 0, "test cannot be run as root") @unittest2.skipUnless(os.geteuid() != 0, "test cannot be run as root")
# Do we need to disable this test if the testsuite is being run on a remote system? # Do we need to disable this test if the testsuite is being run on a remote system?
# This env var is only defined when the shell is running in a local mac terminal window # This env var is only defined when the shell is running in a local mac terminal window
Show All 19 Lines

test/functionalities/type_completion/TestTypeCompletion.py

""" """
Check that types only get completed when necessary. Check that types only get completed when necessary.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class TypeCompletionTestCase(TestBase): class TypeCompletionTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Check that types only get completed when necessary.""" """Check that types only get completed when necessary."""
self.buildDsym() self.buildDsym()
self.type_completion_commands() self.type_completion_commands()
@dwarf_test @dwarf_test
@expectedFailureIcc # often fails with 'NameAndAddress should be valid' @expectedFailureIcc # often fails with 'NameAndAddress should be valid'
▲ Show 20 Lines • Show All 115 Lines • Show Last 20 Lines

test/functionalities/unwind/noreturn/TestNoreturnUnwind.py

""" """
Test that we can backtrace correctly with 'noreturn' functions on the stack Test that we can backtrace correctly with 'noreturn' functions on the stack
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class NoreturnUnwind(TestBase): class NoreturnUnwind(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym (self): def test_with_dsym (self):
"""Test that we can backtrace correctly with 'noreturn' functions on the stack""" """Test that we can backtrace correctly with 'noreturn' functions on the stack"""
self.buildDsym() self.buildDsym()
self.setTearDownCleanup() self.setTearDownCleanup()
self.noreturn_unwind_tests() self.noreturn_unwind_tests()
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

test/functionalities/unwind/sigtramp/TestSigtrampUnwind.py

""" """
Test that we can backtrace correctly with 'sigtramp' functions on the stack Test that we can backtrace correctly with 'sigtramp' functions on the stack
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class SigtrampUnwind(TestBase): class SigtrampUnwind(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
# On different platforms the "_sigtramp" and "__kill" frames are likely to be different. # On different platforms the "_sigtramp" and "__kill" frames are likely to be different.
# This test could probably be adapted to run on linux/*bsd easily enough. # This test could probably be adapted to run on linux/*bsd easily enough.
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym (self): def test_with_dsym (self):
"""Test that we can backtrace correctly with _sigtramp on the stack""" """Test that we can backtrace correctly with _sigtramp on the stack"""
self.buildDsym() self.buildDsym()
self.setTearDownCleanup() self.setTearDownCleanup()
self.sigtramp_unwind_tests() self.sigtramp_unwind_tests()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_with_dwarf (self): def test_with_dwarf (self):
"""Test that we can backtrace correctly with _sigtramp on the stack""" """Test that we can backtrace correctly with _sigtramp on the stack"""
self.buildDwarf() self.buildDwarf()
self.setTearDownCleanup() self.setTearDownCleanup()
self.sigtramp_unwind_tests() self.sigtramp_unwind_tests()
def sigtramp_unwind_tests (self): def sigtramp_unwind_tests (self):
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

test/functionalities/value_md5_crash/TestValueMD5Crash.py

""" """
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.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class ValueMD5CrashTestCase(TestBase): class ValueMD5CrashTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Verify that the hash computing logic for ValueObject's values can't crash us.""" """Verify that the hash computing logic for ValueObject's values can't crash us."""
self.buildDsym() self.buildDsym()
self.doThings() self.doThings()
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

test/functionalities/watchpoint/hello_watchlocation/TestWatchLocation.py

""" """
Test lldb watchpoint that uses '-s size' to watch a pointed location with size. Test lldb watchpoint that uses '-s size' to watch a pointed location with size.
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class HelloWatchLocationTestCase(TestBase): class HelloWatchLocationTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_hello_watchlocation_with_dsym(self): def test_hello_watchlocation_with_dsym(self):
"""Test watching a location with '-s size' option.""" """Test watching a location with '-s size' option."""
self.buildDsym(dictionary=self.d) self.buildDsym(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
self.hello_watchlocation() self.hello_watchlocation()
@expectedFailureFreeBSD("llvm.org/pr18832") @expectedFailureFreeBSD("llvm.org/pr18832")
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

test/functionalities/watchpoint/multiple_threads/TestWatchpointMultipleThreads.py

""" """
Test that lldb watchpoint works for multiple threads. Test that lldb watchpoint works for multiple threads.
""" """
import os, time import os, time
import unittest2 import unittest2
import re import re
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class WatchpointForMultipleThreadsTestCase(TestBase): class WatchpointForMultipleThreadsTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_watchpoint_multiple_threads_with_dsym(self): def test_watchpoint_multiple_threads_with_dsym(self):
"""Test that lldb watchpoint works for multiple threads.""" """Test that lldb watchpoint works for multiple threads."""
self.buildDsym(dictionary=self.d) self.buildDsym(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
self.hello_multiple_threads() self.hello_multiple_threads()
@skipIfGcc # causes intermittent gcc debian buildbot failures, skip until we can investigate @skipIfGcc # causes intermittent gcc debian buildbot failures, skip until we can investigate
@expectedFailureLinux("llvm.org/pr20233") # note due to a @skipIfGcc above, this is going to check failure on Linux if using non-GCC (most likely clang) @expectedFailureLinux("llvm.org/pr20233") # note due to a @skipIfGcc above, this is going to check failure on Linux if using non-GCC (most likely clang)
@dwarf_test @dwarf_test
def test_watchpoint_multiple_threads_with_dwarf(self): def test_watchpoint_multiple_threads_with_dwarf(self):
"""Test that lldb watchpoint works for multiple threads.""" """Test that lldb watchpoint works for multiple threads."""
self.buildDwarf(dictionary=self.d) self.buildDwarf(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
self.hello_multiple_threads() self.hello_multiple_threads()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_watchpoint_multiple_threads_wp_set_and_then_delete_with_dsym(self): def test_watchpoint_multiple_threads_wp_set_and_then_delete_with_dsym(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.buildDsym(dictionary=self.d) self.buildDsym(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
self.hello_multiple_threads_wp_set_and_then_delete() self.hello_multiple_threads_wp_set_and_then_delete()
@skipIfGcc # causes intermittent gcc debian buildbot failures, skip until we can investigate @skipIfGcc # causes intermittent gcc debian buildbot failures, skip until we can investigate
▲ Show 20 Lines • Show All 122 Lines • Show Last 20 Lines

test/functionalities/watchpoint/step_over_watchpoint/TestStepOverWatchpoint.py

"""Test stepping over watchpoints.""" """Test stepping over watchpoints."""
import unittest2 import unittest2
import lldb import lldb
import lldbutil import lldbutil
from lldbtest import * from lldbtest import *
class TestStepOverWatchpoint(TestBase): class TestStepOverWatchpoint(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def getCategories(self): def getCategories(self):
return ['basic_process'] return ['basic_process']
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test stepping over watchpoints.""" """Test stepping over watchpoints."""
self.buildDsym() self.buildDsym()
self.step_over_watchpoint() self.step_over_watchpoint()
@dwarf_test @dwarf_test
def test_with_dwarf(self): def test_with_dwarf(self):
▲ Show 20 Lines • Show All 100 Lines • Show Last 20 Lines

test/functionalities/watchpoint/watchpoint_commands/TestWatchpointCommands.py

Show All 20 Lines def setUp(self):
self.line = line_number(self.source, '// Set break point at this line.') self.line = line_number(self.source, '// Set break point at this line.')
self.line2 = line_number(self.source, '// Set 2nd break point for disable_then_enable test case.') self.line2 = line_number(self.source, '// Set 2nd break point for disable_then_enable test case.')
# And the watchpoint variable declaration line number. # And the watchpoint variable declaration line number.
self.decl = line_number(self.source, '// Watchpoint variable declaration.') self.decl = line_number(self.source, '// Watchpoint variable declaration.')
# Build dictionary to have unique executable names for each test method. # Build dictionary to have unique executable names for each test method.
self.exe_name = self.testMethodName self.exe_name = self.testMethodName
self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name} self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_rw_watchpoint_with_dsym(self): def test_rw_watchpoint_with_dsym(self):
"""Test read_write watchpoint and expect to stop two times.""" """Test read_write watchpoint and expect to stop two times."""
self.buildDsym(dictionary=self.d) self.buildDsym(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
self.normal_read_write_watchpoint() self.normal_read_write_watchpoint()
@dwarf_test @dwarf_test
def test_rw_watchpoint_with_dwarf(self): def test_rw_watchpoint_with_dwarf(self):
"""Test read_write watchpoint and expect to stop two times.""" """Test read_write watchpoint and expect to stop two times."""
self.buildDwarf(dictionary=self.d) self.buildDwarf(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
self.normal_read_write_watchpoint() self.normal_read_write_watchpoint()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_rw_watchpoint_delete_with_dsym(self): def test_rw_watchpoint_delete_with_dsym(self):
"""Test delete watchpoint and expect not to stop for watchpoint.""" """Test delete watchpoint and expect not to stop for watchpoint."""
self.buildDsym(dictionary=self.d) self.buildDsym(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
self.delete_read_write_watchpoint() self.delete_read_write_watchpoint()
@dwarf_test @dwarf_test
def test_rw_watchpoint_delete_with_dwarf(self): def test_rw_watchpoint_delete_with_dwarf(self):
"""Test delete watchpoint and expect not to stop for watchpoint.""" """Test delete watchpoint and expect not to stop for watchpoint."""
self.buildDwarf(dictionary=self.d) self.buildDwarf(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
self.delete_read_write_watchpoint() self.delete_read_write_watchpoint()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_rw_watchpoint_set_ignore_count_with_dsym(self): def test_rw_watchpoint_set_ignore_count_with_dsym(self):
"""Test watchpoint ignore count and expect to not to stop at all.""" """Test watchpoint ignore count and expect to not to stop at all."""
self.buildDsym(dictionary=self.d) self.buildDsym(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
self.ignore_read_write_watchpoint() self.ignore_read_write_watchpoint()
@dwarf_test @dwarf_test
def test_rw_watchpoint_set_ignore_count_with_dwarf(self): def test_rw_watchpoint_set_ignore_count_with_dwarf(self):
"""Test watchpoint ignore count and expect to not to stop at all.""" """Test watchpoint ignore count and expect to not to stop at all."""
self.buildDwarf(dictionary=self.d) self.buildDwarf(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
self.ignore_read_write_watchpoint() self.ignore_read_write_watchpoint()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_rw_disable_after_first_stop_with_dsym(self): def test_rw_disable_after_first_stop_with_dsym(self):
"""Test read_write watchpoint but disable it after the first stop.""" """Test read_write watchpoint but disable it after the first stop."""
self.buildDsym(dictionary=self.d) self.buildDsym(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
self.read_write_watchpoint_disable_after_first_stop() self.read_write_watchpoint_disable_after_first_stop()
@dwarf_test @dwarf_test
def test_rw_disable_after_first_stop__with_dwarf(self): def test_rw_disable_after_first_stop__with_dwarf(self):
"""Test read_write watchpoint but disable it after the first stop.""" """Test read_write watchpoint but disable it after the first stop."""
self.buildDwarf(dictionary=self.d) self.buildDwarf(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
self.read_write_watchpoint_disable_after_first_stop() self.read_write_watchpoint_disable_after_first_stop()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_rw_disable_then_enable_with_dsym(self): def test_rw_disable_then_enable_with_dsym(self):
"""Test read_write watchpoint, disable initially, then enable it.""" """Test read_write watchpoint, disable initially, then enable it."""
self.buildDsym(dictionary=self.d) self.buildDsym(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
self.read_write_watchpoint_disable_then_enable() self.read_write_watchpoint_disable_then_enable()
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 409 Lines • Show Last 20 Lines

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

Show All 19 Lines def setUp(self):
# Find the line number to break inside main(). # Find the line number to break inside main().
self.line = line_number(self.source, '// Set break point at this line.') self.line = line_number(self.source, '// Set break point at this line.')
# And the watchpoint variable declaration line number. # And the watchpoint variable declaration line number.
self.decl = line_number(self.source, '// Watchpoint variable declaration.') self.decl = line_number(self.source, '// Watchpoint variable declaration.')
# Build dictionary to have unique executable names for each test method. # Build dictionary to have unique executable names for each test method.
self.exe_name = 'a%d.out' % self.test_number self.exe_name = 'a%d.out' % self.test_number
self.d = {'CXX_SOURCES': self.source, 'EXE': self.exe_name} self.d = {'CXX_SOURCES': self.source, 'EXE': self.exe_name}
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_watchpoint_command_with_dsym(self): def test_watchpoint_command_with_dsym(self):
"""Test 'watchpoint command'.""" """Test 'watchpoint command'."""
self.buildDsym(dictionary=self.d) self.buildDsym(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
self.watchpoint_command() self.watchpoint_command()
@dwarf_test @dwarf_test
def test_watchpoint_command_with_dwarf(self): def test_watchpoint_command_with_dwarf(self):
"""Test 'watchpoint command'.""" """Test 'watchpoint command'."""
self.buildDwarf(dictionary=self.d) self.buildDwarf(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
self.watchpoint_command() self.watchpoint_command()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_watchpoint_command_can_disable_a_watchpoint_with_dsym(self): def test_watchpoint_command_can_disable_a_watchpoint_with_dsym(self):
"""Test that 'watchpoint command' action can disable a watchpoint after it is triggered.""" """Test that 'watchpoint command' action can disable a watchpoint after it is triggered."""
self.buildDsym(dictionary=self.d) self.buildDsym(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
self.watchpoint_command_can_disable_a_watchpoint() self.watchpoint_command_can_disable_a_watchpoint()
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

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

Show All 19 Lines def setUp(self):
# Find the line number to break inside main(). # Find the line number to break inside main().
self.line = line_number(self.source, '// Set break point at this line.') self.line = line_number(self.source, '// Set break point at this line.')
# And the watchpoint variable declaration line number. # And the watchpoint variable declaration line number.
self.decl = line_number(self.source, '// Watchpoint variable declaration.') self.decl = line_number(self.source, '// Watchpoint variable declaration.')
# Build dictionary to have unique executable names for each test method. # Build dictionary to have unique executable names for each test method.
self.exe_name = self.testMethodName self.exe_name = self.testMethodName
self.d = {'CXX_SOURCES': self.source, 'EXE': self.exe_name} self.d = {'CXX_SOURCES': self.source, 'EXE': self.exe_name}
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_watchpoint_command_with_dsym(self): def test_watchpoint_command_with_dsym(self):
"""Test 'watchpoint command'.""" """Test 'watchpoint command'."""
self.buildDsym(dictionary=self.d) self.buildDsym(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
self.watchpoint_command() self.watchpoint_command()
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

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

Show All 19 Lines def setUp(self):
# Find the line number to break inside main(). # Find the line number to break inside main().
self.line = line_number(self.source, '// Set break point at this line.') self.line = line_number(self.source, '// Set break point at this line.')
# And the watchpoint variable declaration line number. # And the watchpoint variable declaration line number.
self.decl = line_number(self.source, '// Watchpoint variable declaration.') self.decl = line_number(self.source, '// Watchpoint variable declaration.')
# Build dictionary to have unique executable names for each test method. # Build dictionary to have unique executable names for each test method.
self.exe_name = self.testMethodName self.exe_name = self.testMethodName
self.d = {'CXX_SOURCES': self.source, 'EXE': self.exe_name} self.d = {'CXX_SOURCES': self.source, 'EXE': self.exe_name}
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_watchpoint_cond_with_dsym(self): def test_watchpoint_cond_with_dsym(self):
"""Test watchpoint condition.""" """Test watchpoint condition."""
self.buildDsym(dictionary=self.d) self.buildDsym(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
self.watchpoint_condition() self.watchpoint_condition()
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

test/functionalities/watchpoint/watchpoint_events/TestWatchpointEvents.py

"""Test that adding, deleting and modifying watchpoints sends the appropriate events.""" """Test that adding, deleting and modifying watchpoints sends the appropriate events."""
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
import lldbutil import lldbutil
from lldbtest import * from lldbtest import *
class TestWatchpointEvents (TestBase): class TestWatchpointEvents (TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym_and_python_api(self): def test_with_dsym_and_python_api(self):
"""Test that adding, deleting and modifying watchpoints sends the appropriate events.""" """Test that adding, deleting and modifying watchpoints sends the appropriate events."""
self.buildDsym() self.buildDsym()
self.step_over_stepping() self.step_over_stepping()
@python_api_test @python_api_test
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

test/functionalities/watchpoint/watchpoint_set_command/TestWatchLocationWithWatchSet.py

""" """
Test lldb watchpoint that uses 'watchpoint set -w write -s size' to watch a pointed location with size. Test lldb watchpoint that uses 'watchpoint set -w write -s size' to watch a pointed location with size.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class WatchLocationUsingWatchpointSetTestCase(TestBase): class WatchLocationUsingWatchpointSetTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_watchlocation_with_dsym_using_watchpoint_set(self): def test_watchlocation_with_dsym_using_watchpoint_set(self):
"""Test watching a location with 'watchpoint set expression -w write -s size' option.""" """Test watching a location with 'watchpoint set expression -w write -s size' option."""
self.buildDsym(dictionary=self.d) self.buildDsym(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
self.watchlocation_using_watchpoint_set() self.watchlocation_using_watchpoint_set()
@expectedFailureFreeBSD('llvm.org/pr18832') @expectedFailureFreeBSD('llvm.org/pr18832')
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

test/lang/c/array_types/TestArrayTypes.py

"""Test breakpoint by file/line number; and list variables with array types.""" """Test breakpoint by file/line number; and list variables with array types."""
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class ArrayTypesTestCase(TestBase): class ArrayTypesTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test 'frame variable var_name' on some variables with array types.""" """Test 'frame variable var_name' on some variables with array types."""
self.buildDsym() self.buildDsym()
self.array_types() self.array_types()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym_and_python_api(self): def test_with_dsym_and_python_api(self):
"""Use Python APIs to inspect variables with array types.""" """Use Python APIs to inspect variables with array types."""
self.buildDsym() self.buildDsym()
self.array_types_python() self.array_types_python()
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 195 Lines • Show Last 20 Lines

test/lang/c/bitfields/TestBitfields.py

"""Show bitfields and check that they display correctly.""" """Show bitfields and check that they display correctly."""
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class BitfieldsTestCase(TestBase): class BitfieldsTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test 'frame variable ...' on a variable with bitfields.""" """Test 'frame variable ...' on a variable with bitfields."""
self.buildDsym() self.buildDsym()
self.bitfields_variable() self.bitfields_variable()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym_and_python_api(self): def test_with_dsym_and_python_api(self):
"""Use Python APIs to inspect a bitfields variable.""" """Use Python APIs to inspect a bitfields variable."""
self.buildDsym() self.buildDsym()
self.bitfields_variable_python() self.bitfields_variable_python()
@dwarf_test @dwarf_test
@unittest2.skipIf(sys.platform.startswith("win32"), "BitFields exhibit crashes in record layout on Windows (http://llvm.org/pr21800)") @skipIfWindows # BitFields exhibit crashes in record layout on Windows (http://llvm.org/pr21800)
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
"""Test 'frame variable ...' on a variable with bitfields.""" """Test 'frame variable ...' on a variable with bitfields."""
self.buildDwarf() self.buildDwarf()
self.bitfields_variable() self.bitfields_variable()
@python_api_test @python_api_test
@dwarf_test @dwarf_test
@unittest2.skipIf(sys.platform.startswith("win32"), "BitFields exhibit crashes in record layout on Windows (http://llvm.org/pr21800)") @skipIfWindows # BitFields exhibit crashes in record layout on Windows (http://llvm.org/pr21800)
@expectedFailureGcc # GCC (4.6/4.7) generates incorrect code with unnamed bitfields. @expectedFailureGcc # GCC (4.6/4.7) generates incorrect code with unnamed bitfields.
def test_with_dwarf_and_python_api(self): def test_with_dwarf_and_python_api(self):
"""Use Python APIs to inspect a bitfields variable.""" """Use Python APIs to inspect a bitfields variable."""
self.buildDwarf() self.buildDwarf()
self.bitfields_variable_python() self.bitfields_variable_python()
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
▲ Show 20 Lines • Show All 155 Lines • Show Last 20 Lines

test/lang/c/enum_types/TestEnumTypes.py

"""Look up enum type information and check for correct display.""" """Look up enum type information and check for correct display."""
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class EnumTypesTestCase(TestBase): class EnumTypesTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test 'image lookup -t days' and check for correct display and enum value printing.""" """Test 'image lookup -t days' and check for correct display and enum value printing."""
self.buildDsym() self.buildDsym()
self.image_lookup_for_enum_type() self.image_lookup_for_enum_type()
# rdar://problem/8394746 # rdar://problem/8394746
# 'image lookup -t days' returns nothing with dwarf debug format. # 'image lookup -t days' returns nothing with dwarf debug format.
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

test/lang/c/forward/TestForwardDeclaration.py

"""Test that forward declaration of a data structure gets resolved correctly.""" """Test that forward declaration of a data structure gets resolved correctly."""
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class ForwardDeclarationTestCase(TestBase): class ForwardDeclarationTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Display *bar_ptr when stopped on a function with forward declaration of struct bar.""" """Display *bar_ptr when stopped on a function with forward declaration of struct bar."""
self.buildDsym() self.buildDsym()
self.forward_declaration() self.forward_declaration()
# rdar://problem/8648070 # rdar://problem/8648070
# 'expression *bar_ptr' seg faults # 'expression *bar_ptr' seg faults
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

test/lang/c/function_types/TestFunctionTypes.py

"""Test variable with function ptr type and that break on the function works.""" """Test variable with function ptr type and that break on the function works."""
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class FunctionTypesTestCase(TestBase): class FunctionTypesTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test 'callback' has function ptr type, then break on the function.""" """Test 'callback' has function ptr type, then break on the function."""
self.buildDsym() self.buildDsym()
self.function_types() self.function_types()
@dwarf_test @dwarf_test
def test_with_dwarf(self): def test_with_dwarf(self):
"""Test 'callback' has function ptr type, then break on the function.""" """Test 'callback' has function ptr type, then break on the function."""
self.buildDwarf() self.buildDwarf()
self.function_types() self.function_types()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_pointers_with_dsym(self): def test_pointers_with_dsym(self):
"""Test that a function pointer to 'printf' works and can be called.""" """Test that a function pointer to 'printf' works and can be called."""
self.buildDsym() self.buildDsym()
self.function_pointers() self.function_pointers()
@dwarf_test @dwarf_test
def test_pointers_with_dwarf(self): def test_pointers_with_dwarf(self):
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

test/lang/c/global_variables/TestGlobalVariables.py

"""Show global variables and check that they do indeed have global scopes.""" """Show global variables and check that they do indeed have global scopes."""
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class GlobalVariablesTestCase(TestBase): class GlobalVariablesTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test 'frame variable --scope --no-args' which omits args and shows scopes.""" """Test 'frame variable --scope --no-args' which omits args and shows scopes."""
self.buildDsym() self.buildDsym()
self.global_variables() self.global_variables()
@expectedFailureFreeBSD("llvm.org/21599 fails after editline rework") @expectedFailureFreeBSD("llvm.org/21599 fails after editline rework")
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

test/lang/c/set_values/TestSetValues.py

"""Test settings and readings of program variables.""" """Test settings and readings of program variables."""
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class SetValuesTestCase(TestBase): class SetValuesTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test settings and readings of program variables.""" """Test settings and readings of program variables."""
self.buildDsym() self.buildDsym()
self.set_values() self.set_values()
@dwarf_test @dwarf_test
def test_with_dwarf(self): def test_with_dwarf(self):
▲ Show 20 Lines • Show All 105 Lines • Show Last 20 Lines

test/lang/c/stepping/TestStepAndBreakpoints.py

"""Test stepping over vrs. hitting breakpoints & subsequent stepping in various forms.""" """Test stepping over vrs. hitting breakpoints & subsequent stepping in various forms."""
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
import lldbutil import lldbutil
from lldbtest import * from lldbtest import *
class TestCStepping(TestBase): class TestCStepping(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def getCategories(self): def getCategories(self):
return ['basic_process'] return ['basic_process']
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym_and_python_api(self): def test_with_dsym_and_python_api(self):
"""Test stepping over vrs. hitting breakpoints & subsequent stepping in various forms.""" """Test stepping over vrs. hitting breakpoints & subsequent stepping in various forms."""
self.buildDsym() self.buildDsym()
self.step_over_stepping() self.step_over_stepping()
@expectedFailureFreeBSD('llvm.org/pr17932') @expectedFailureFreeBSD('llvm.org/pr17932')
▲ Show 20 Lines • Show All 233 Lines • Show Last 20 Lines

test/lang/c/stepping/TestThreadStepping.py

""" """
Test thread stepping features in combination with frame select. Test thread stepping features in combination with frame select.
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class ThreadSteppingTestCase(TestBase): class ThreadSteppingTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_step_out_with_dsym_and_run_command(self): def test_step_out_with_dsym_and_run_command(self):
"""Exercise thread step-out and frame select followed by thread step-out.""" """Exercise thread step-out and frame select followed by thread step-out."""
self.buildDwarf() self.buildDwarf()
self.thread_step_out() self.thread_step_out()
@dwarf_test @dwarf_test
def test_step_out_with_dwarf_and_run_command(self): def test_step_out_with_dwarf_and_run_command(self):
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

test/lang/c/strings/TestCStrings.py

""" """
Tests that C strings work as expected in expressions Tests that C strings work as expected in expressions
""" """
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class CStringsTestCase(TestBase): class CStringsTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Tests that C strings work as expected in expressions""" """Tests that C strings work as expected in expressions"""
self.buildDsym() self.buildDsym()
self.static_method_commands() self.static_method_commands()
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

test/lang/c/tls_globals/TestTlsGlobals.py

"""Test that thread-local storage can be read correctly.""" """Test that thread-local storage can be read correctly."""
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class TlsGlobalTestCase(TestBase): class TlsGlobalTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
@unittest2.expectedFailure("rdar://7796742") @unittest2.expectedFailure("rdar://7796742")
def test_with_dsym(self): def test_with_dsym(self):
"""Test thread-local storage.""" """Test thread-local storage."""
self.buildDsym() self.buildDsym()
self.tls_globals() self.tls_globals()
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

test/lang/cpp/bool/TestCPPBool.py

""" """
Tests that bool types work Tests that bool types work
""" """
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class CPPBoolTestCase(TestBase): class CPPBoolTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test that bool types work in the expression parser""" """Test that bool types work in the expression parser"""
self.buildDsym() self.buildDsym()
self.static_method_commands() self.static_method_commands()
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
Show All 31 Lines

test/lang/cpp/breakpoints/TestCPPBreakpoints.py

""" """
Test lldb breakpoint command for CPP methods & functions in a namespace. Test lldb breakpoint command for CPP methods & functions in a namespace.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
class CPPBreakpointTestCase(TestBase): class CPPBreakpointTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test a sequence of breakpoint command add, list, and delete.""" """Test a sequence of breakpoint command add, list, and delete."""
self.buildDsym() self.buildDsym()
self.cpp_breakpoints() self.cpp_breakpoints()
@dwarf_test @dwarf_test
def test_with_dwarf(self): def test_with_dwarf(self):
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

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

""" """
Tests calling a function by basename Tests calling a function by basename
""" """
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class CallCPPFunctionTestCase(TestBase): class CallCPPFunctionTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test calling a function by basename""" """Test calling a function by basename"""
self.buildDsym() self.buildDsym()
self.call_cpp_function() self.call_cpp_function()
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
Show All 29 Lines

test/lang/cpp/char1632_t/TestChar1632T.py

# coding=utf8 # coding=utf8
""" """
Test that the C++11 support for char16_t and char32_t works correctly. Test that the C++11 support for char16_t and char32_t works correctly.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class Char1632TestCase(TestBase): class Char1632TestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test that the C++11 support for char16_t and char32_t works correctly.""" """Test that the C++11 support for char16_t and char32_t works correctly."""
self.buildDsym() self.buildDsym()
self.char1632() self.char1632()
@expectedFailureIcc # ICC (13.1) does not emit the DW_TAG_base_type for char16_t and char32_t. @expectedFailureIcc # ICC (13.1) does not emit the DW_TAG_base_type for char16_t and char32_t.
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

test/lang/cpp/class_static/TestStaticVariables.py

""" """
Test display and Python APIs on file and class static variables. Test display and Python APIs on file and class static variables.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class StaticVariableTestCase(TestBase): class StaticVariableTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
failing_compilers = ['clang', 'gcc'] failing_compilers = ['clang', 'gcc']
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test that file and class static variables display correctly.""" """Test that file and class static variables display correctly."""
self.buildDsym() self.buildDsym()
self.static_variable_commands() self.static_variable_commands()
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
"""Test that file and class static variables display correctly.""" """Test that file and class static variables display correctly."""
self.buildDwarf() self.buildDwarf()
self.static_variable_commands() self.static_variable_commands()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@expectedFailureClang(9980907) @expectedFailureClang(9980907)
@expectedFailureGcc(9980907) @expectedFailureGcc(9980907)
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym_and_python_api(self): def test_with_dsym_and_python_api(self):
"""Test Python APIs on file and class static variables.""" """Test Python APIs on file and class static variables."""
self.buildDsym() self.buildDsym()
self.static_variable_python() self.static_variable_python()
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines

test/lang/cpp/class_types/TestClassTypes.py

"""Test breakpoint on a class constructor; and variable list the this object.""" """Test breakpoint on a class constructor; and variable list the this object."""
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
import lldbutil import lldbutil
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class ClassTypesTestCase(TestBase): class ClassTypesTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
failing_compilers = ['clang', 'gcc'] failing_compilers = ['clang', 'gcc']
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test 'frame variable this' when stopped on a class constructor.""" """Test 'frame variable this' when stopped on a class constructor."""
self.buildDsym() self.buildDsym()
self.class_types() self.class_types()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym_and_python_api(self): def test_with_dsym_and_python_api(self):
"""Use Python APIs to create a breakpoint by (filespec, line).""" """Use Python APIs to create a breakpoint by (filespec, line)."""
self.buildDsym() self.buildDsym()
self.breakpoint_creation_by_filespec_python() self.breakpoint_creation_by_filespec_python()
# rdar://problem/8378863 # rdar://problem/8378863
# "frame variable this" returns # "frame variable this" returns
# error: unable to find any variables named 'this' # error: unable to find any variables named 'this'
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
"""Test 'frame variable this' when stopped on a class constructor.""" """Test 'frame variable this' when stopped on a class constructor."""
self.buildDwarf() self.buildDwarf()
self.class_types() self.class_types()
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_with_dwarf_and_python_api(self): def test_with_dwarf_and_python_api(self):
"""Use Python APIs to create a breakpoint by (filespec, line).""" """Use Python APIs to create a breakpoint by (filespec, line)."""
self.buildDwarf() self.buildDwarf()
self.breakpoint_creation_by_filespec_python() self.breakpoint_creation_by_filespec_python()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
# rdar://problem/8557478 # rdar://problem/8557478
# test/class_types test failures: runCmd: expr this->m_c_int # test/class_types test failures: runCmd: expr this->m_c_int
@dsym_test @dsym_test
def test_with_dsym_and_expr_parser(self): def test_with_dsym_and_expr_parser(self):
"""Test 'frame variable this' and 'expr this' when stopped inside a constructor.""" """Test 'frame variable this' and 'expr this' when stopped inside a constructor."""
self.buildDsym() self.buildDsym()
self.class_types_expr_parser() self.class_types_expr_parser()
# rdar://problem/8557478 # rdar://problem/8557478
# test/class_types test failures: runCmd: expr this->m_c_int # test/class_types test failures: runCmd: expr this->m_c_int
@dwarf_test @dwarf_test
def test_with_dwarf_and_expr_parser(self): def test_with_dwarf_and_expr_parser(self):
"""Test 'frame variable this' and 'expr this' when stopped inside a constructor.""" """Test 'frame variable this' and 'expr this' when stopped inside a constructor."""
self.buildDwarf() self.buildDwarf()
self.class_types_expr_parser() self.class_types_expr_parser()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
# rdar://problem/8557478 # rdar://problem/8557478
# test/class_types test failures: runCmd: expr this->m_c_int # test/class_types test failures: runCmd: expr this->m_c_int
@dsym_test @dsym_test
@expectedFailureDarwin(16362674) @expectedFailureDarwin(16362674)
def test_with_dsym_and_constructor_name(self): def test_with_dsym_and_constructor_name(self):
"""Test 'frame variable this' and 'expr this' when stopped inside a constructor.""" """Test 'frame variable this' and 'expr this' when stopped inside a constructor."""
self.buildDsym() self.buildDsym()
self.class_types_constructor_name() self.class_types_constructor_name()
▲ Show 20 Lines • Show All 213 Lines • Show Last 20 Lines

test/lang/cpp/class_types/TestClassTypesDisassembly.py

""" """
Test the lldb disassemble command on each call frame when stopped on C's ctor. Test the lldb disassemble command on each call frame when stopped on C's ctor.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class IterateFrameAndDisassembleTestCase(TestBase): class IterateFrameAndDisassembleTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
failing_compilers = ['clang', 'gcc'] failing_compilers = ['clang', 'gcc']
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Disassemble each call frame when stopped on C's constructor.""" """Disassemble each call frame when stopped on C's constructor."""
self.buildDsym() self.buildDsym()
self.disassemble_call_stack() self.disassemble_call_stack()
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
"""Disassemble each call frame when stopped on C's constructor.""" """Disassemble each call frame when stopped on C's constructor."""
self.buildDwarf() self.buildDwarf()
self.disassemble_call_stack() self.disassemble_call_stack()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym_and_python_api(self): def test_with_dsym_and_python_api(self):
"""Disassemble each call frame when stopped on C's constructor.""" """Disassemble each call frame when stopped on C's constructor."""
self.buildDsym() self.buildDsym()
self.disassemble_call_stack_python() self.disassemble_call_stack_python()
@python_api_test @python_api_test
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

test/lang/cpp/diamond/TestDiamond.py

""" """
Tests that bool types work Tests that bool types work
""" """
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class CPPTestDiamondInheritance(TestBase): class CPPTestDiamondInheritance(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test that virtual base classes work in when SBValue objects are used to explore the variable value""" """Test that virtual base classes work in when SBValue objects are used to explore the variable value"""
self.buildDsym() self.buildDsym()
self.diamong_inheritace() self.diamong_inheritace()
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

test/lang/cpp/dynamic-value/TestCppValueCast.py

""" """
Test lldb Python API SBValue::Cast(SBType) for C++ types. Test lldb Python API SBValue::Cast(SBType) for C++ types.
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
from lldbtest import * from lldbtest import *
class CppValueCastTestCase(TestBase): class CppValueCastTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.expectedFailure("rdar://problem/10808472 SBValue::Cast test case is failing (virtual inheritance)") @unittest2.expectedFailure("rdar://problem/10808472 SBValue::Cast test case is failing (virtual inheritance)")
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_value_cast_with_dsym_and_virtual_inheritance(self): def test_value_cast_with_dsym_and_virtual_inheritance(self):
"""Test SBValue::Cast(SBType) API for C++ types with virtual inheritance.""" """Test SBValue::Cast(SBType) API for C++ types with virtual inheritance."""
self.buildDsym(dictionary=self.d_virtual) self.buildDsym(dictionary=self.d_virtual)
self.setTearDownCleanup(dictionary=self.d_virtual) self.setTearDownCleanup(dictionary=self.d_virtual)
self.do_sbvalue_cast(self.exe_name) self.do_sbvalue_cast(self.exe_name)
@unittest2.expectedFailure("rdar://problem/10808472 SBValue::Cast test case is failing (virtual inheritance)") @unittest2.expectedFailure("rdar://problem/10808472 SBValue::Cast test case is failing (virtual inheritance)")
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_value_cast_with_dwarf_and_virtual_inheritance(self): def test_value_cast_with_dwarf_and_virtual_inheritance(self):
"""Test SBValue::Cast(SBType) API for C++ types with virtual inheritance.""" """Test SBValue::Cast(SBType) API for C++ types with virtual inheritance."""
self.buildDwarf(dictionary=self.d_virtual) self.buildDwarf(dictionary=self.d_virtual)
self.setTearDownCleanup(dictionary=self.d_virtual) self.setTearDownCleanup(dictionary=self.d_virtual)
self.do_sbvalue_cast(self.exe_name) self.do_sbvalue_cast(self.exe_name)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_value_cast_with_dsym_and_regular_inheritance(self): def test_value_cast_with_dsym_and_regular_inheritance(self):
"""Test SBValue::Cast(SBType) API for C++ types with regular inheritance.""" """Test SBValue::Cast(SBType) API for C++ types with regular inheritance."""
self.buildDsym(dictionary=self.d_regular) self.buildDsym(dictionary=self.d_regular)
self.setTearDownCleanup(dictionary=self.d_regular) self.setTearDownCleanup(dictionary=self.d_regular)
self.do_sbvalue_cast(self.exe_name) self.do_sbvalue_cast(self.exe_name)
▲ Show 20 Lines • Show All 110 Lines • Show Last 20 Lines

test/lang/cpp/dynamic-value/TestDynamicValue.py

""" """
Use lldb Python API to test dynamic values in C++ Use lldb Python API to test dynamic values in C++
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
from lldbtest import * from lldbtest import *
class DynamicValueTestCase(TestBase): class DynamicValueTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_get_dynamic_vals_with_dsym(self): def test_get_dynamic_vals_with_dsym(self):
"""Test fetching C++ dynamic values from pointers & references.""" """Test fetching C++ dynamic values from pointers & references."""
self.buildDsym(dictionary=self.getBuildFlags()) self.buildDsym(dictionary=self.getBuildFlags())
self.do_get_dynamic_vals() self.do_get_dynamic_vals()
@expectedFailureFreeBSD # FIXME: This needs to be root-caused. @expectedFailureFreeBSD # FIXME: This needs to be root-caused.
▲ Show 20 Lines • Show All 218 Lines • Show Last 20 Lines

test/lang/cpp/enum_types/TestCPP11EnumTypes.py

"""Look up enum type information and check for correct display.""" """Look up enum type information and check for correct display."""
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class CPP11EnumTypesTestCase(TestBase): class CPP11EnumTypesTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_int8_t(self): def test_with_dsym_int8_t(self):
"""Test C++11 enumeration class types as int8_t types.""" """Test C++11 enumeration class types as int8_t types."""
self.buildDsym(dictionary={'CFLAGS_EXTRAS': '"-DTEST_BLOCK_CAPTURED_VARS=int8_t"'}) self.buildDsym(dictionary={'CFLAGS_EXTRAS': '"-DTEST_BLOCK_CAPTURED_VARS=int8_t"'})
self.image_lookup_for_enum_type() self.image_lookup_for_enum_type()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_int16_t(self): def test_with_dsym_int16_t(self):
"""Test C++11 enumeration class types as int16_t types.""" """Test C++11 enumeration class types as int16_t types."""
self.buildDsym(dictionary={'CFLAGS_EXTRAS': '"-DTEST_BLOCK_CAPTURED_VARS=int16_t"'}) self.buildDsym(dictionary={'CFLAGS_EXTRAS': '"-DTEST_BLOCK_CAPTURED_VARS=int16_t"'})
self.image_lookup_for_enum_type() self.image_lookup_for_enum_type()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_int32_t(self): def test_with_dsym_int32_t(self):
"""Test C++11 enumeration class types as int32_t types.""" """Test C++11 enumeration class types as int32_t types."""
self.buildDsym(dictionary={'CFLAGS_EXTRAS': '"-DTEST_BLOCK_CAPTURED_VARS=int32_t"'}) self.buildDsym(dictionary={'CFLAGS_EXTRAS': '"-DTEST_BLOCK_CAPTURED_VARS=int32_t"'})
self.image_lookup_for_enum_type() self.image_lookup_for_enum_type()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_int64_t(self): def test_with_dsym_int64_t(self):
"""Test C++11 enumeration class types as int64_t types.""" """Test C++11 enumeration class types as int64_t types."""
self.buildDsym(dictionary={'CFLAGS_EXTRAS': '"-DTEST_BLOCK_CAPTURED_VARS=int64_t"'}) self.buildDsym(dictionary={'CFLAGS_EXTRAS': '"-DTEST_BLOCK_CAPTURED_VARS=int64_t"'})
self.image_lookup_for_enum_type() self.image_lookup_for_enum_type()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_uint8_t(self): def test_with_dsym_uint8_t(self):
"""Test C++11 enumeration class types as uint8_t types.""" """Test C++11 enumeration class types as uint8_t types."""
self.buildDsym(dictionary={'CFLAGS_EXTRAS': '"-DTEST_BLOCK_CAPTURED_VARS=uint8_t"'}) self.buildDsym(dictionary={'CFLAGS_EXTRAS': '"-DTEST_BLOCK_CAPTURED_VARS=uint8_t"'})
self.image_lookup_for_enum_type() self.image_lookup_for_enum_type()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_uint16_t(self): def test_with_dsym_uint16_t(self):
"""Test C++11 enumeration class types as uint16_t types.""" """Test C++11 enumeration class types as uint16_t types."""
self.buildDsym(dictionary={'CFLAGS_EXTRAS': '"-DTEST_BLOCK_CAPTURED_VARS=uint16_t"'}) self.buildDsym(dictionary={'CFLAGS_EXTRAS': '"-DTEST_BLOCK_CAPTURED_VARS=uint16_t"'})
self.image_lookup_for_enum_type() self.image_lookup_for_enum_type()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_uint32_t(self): def test_with_dsym_uint32_t(self):
"""Test C++11 enumeration class types as uint32_t types.""" """Test C++11 enumeration class types as uint32_t types."""
self.buildDsym(dictionary={'CFLAGS_EXTRAS': '"-DTEST_BLOCK_CAPTURED_VARS=uint32_t"'}) self.buildDsym(dictionary={'CFLAGS_EXTRAS': '"-DTEST_BLOCK_CAPTURED_VARS=uint32_t"'})
self.image_lookup_for_enum_type() self.image_lookup_for_enum_type()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_uint64_t(self): def test_with_dsym_uint64_t(self):
"""Test C++11 enumeration class types as uint64_t types.""" """Test C++11 enumeration class types as uint64_t types."""
self.buildDsym(dictionary={'CFLAGS_EXTRAS': '"-DTEST_BLOCK_CAPTURED_VARS=uint64_t"'}) self.buildDsym(dictionary={'CFLAGS_EXTRAS': '"-DTEST_BLOCK_CAPTURED_VARS=uint64_t"'})
self.image_lookup_for_enum_type() self.image_lookup_for_enum_type()
@dwarf_test @dwarf_test
def test_with_dwarf_int8_t(self): def test_with_dwarf_int8_t(self):
▲ Show 20 Lines • Show All 106 Lines • Show Last 20 Lines

test/lang/cpp/exceptions/TestCPPExceptionBreakpoints.py

""" """
Test lldb exception breakpoint command for CPP. Test lldb exception breakpoint command for CPP.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
import lldbutil import lldbutil
from lldbtest import * from lldbtest import *
class CPPBreakpointTestCase(TestBase): class CPPBreakpointTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test lldb exception breakpoint command for CPP.""" """Test lldb exception breakpoint command for CPP."""
self.buildDsym() self.buildDsym()
self.cpp_exceptions() self.cpp_exceptions()
@dwarf_test @dwarf_test
def test_with_dwarf(self): def test_with_dwarf(self):
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

test/lang/cpp/namespace/TestNamespace.py

""" """
Test the printing of anonymous and named namespace variables. Test the printing of anonymous and named namespace variables.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class NamespaceTestCase(TestBase): class NamespaceTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
# rdar://problem/8668674 # rdar://problem/8668674
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test that anonymous and named namespace variables display correctly.""" """Test that anonymous and named namespace variables display correctly."""
self.buildDsym() self.buildDsym()
self.namespace_variable_commands() self.namespace_variable_commands()
# rdar://problem/8668674 # rdar://problem/8668674
@expectedFailureGcc # llvm.org/pr15302: lldb does not print 'anonymous namespace' when the inferior is built with GCC (4.7) @expectedFailureGcc # llvm.org/pr15302: lldb does not print 'anonymous namespace' when the inferior is built with GCC (4.7)
▲ Show 20 Lines • Show All 100 Lines • Show Last 20 Lines

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

""" """
Tests that functions with the same name are resolved correctly. Tests that functions with the same name are resolved correctly.
""" """
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class CPPStaticMethodsTestCase(TestBase): class CPPStaticMethodsTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test that functions with the same name are resolved correctly""" """Test that functions with the same name are resolved correctly"""
self.buildDsym() self.buildDsym()
self.static_method_commands() self.static_method_commands()
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
Show All 32 Lines

test/lang/cpp/rdar12991846/TestRdar12991846.py

Show All 21 Lines
# [5] = e\0\0\0 # [5] = e\0\0\0
#} #}
class Rdar12991846TestCase(TestBase): class Rdar12991846TestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.expectedFailure("rdar://18684408") @unittest2.expectedFailure("rdar://18684408")
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_expr1_with_dsym(self): def test_expr1_with_dsym(self):
"""Test that the expression parser returns proper Unicode strings.""" """Test that the expression parser returns proper Unicode strings."""
self.buildDsym() self.buildDsym()
self.rdar12991846(expr=1) self.rdar12991846(expr=1)
@unittest2.expectedFailure("rdar://18684408") @unittest2.expectedFailure("rdar://18684408")
@dwarf_test @dwarf_test
def test_expr1_with_dwarf(self): def test_expr1_with_dwarf(self):
"""Test that the expression parser returns proper Unicode strings.""" """Test that the expression parser returns proper Unicode strings."""
self.buildDwarf() self.buildDwarf()
self.rdar12991846(expr=1) self.rdar12991846(expr=1)
@unittest2.expectedFailure("rdar://18684408") @unittest2.expectedFailure("rdar://18684408")
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_expr2_with_dsym(self): def test_expr2_with_dsym(self):
"""Test that the expression parser returns proper Unicode strings.""" """Test that the expression parser returns proper Unicode strings."""
self.buildDsym() self.buildDsym()
self.rdar12991846(expr=2) self.rdar12991846(expr=2)
@unittest2.expectedFailure("rdar://18684408") @unittest2.expectedFailure("rdar://18684408")
@dwarf_test @dwarf_test
def test_expr2_with_dwarf(self): def test_expr2_with_dwarf(self):
"""Test that the expression parser returns proper Unicode strings.""" """Test that the expression parser returns proper Unicode strings."""
self.buildDwarf() self.buildDwarf()
self.rdar12991846(expr=2) self.rdar12991846(expr=2)
@unittest2.expectedFailure("rdar://18684408") @unittest2.expectedFailure("rdar://18684408")
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_expr3_with_dsym(self): def test_expr3_with_dsym(self):
"""Test that the expression parser returns proper Unicode strings.""" """Test that the expression parser returns proper Unicode strings."""
self.buildDsym() self.buildDsym()
self.rdar12991846(expr=3) self.rdar12991846(expr=3)
@unittest2.expectedFailure("rdar://18684408") @unittest2.expectedFailure("rdar://18684408")
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

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

""" """
Tests that rvalue references are supported in C++ Tests that rvalue references are supported in C++
""" """
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class RvalueReferencesTestCase(TestBase): class RvalueReferencesTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@expectedFailureClang("rdar://problem/11479676") @expectedFailureClang("rdar://problem/11479676")
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test that rvalues are supported in the C++ expression parser""" """Test that rvalues are supported in the C++ expression parser"""
self.buildDsym() self.buildDsym()
self.static_method_commands() self.static_method_commands()
#rdar://problem/11479676 #rdar://problem/11479676
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

test/lang/cpp/signed_types/TestSignedTypes.py

""" """
Test that variables with signed types display correctly. Test that variables with signed types display correctly.
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class UnsignedTypesTestCase(TestBase): class UnsignedTypesTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test that variables with signed types display correctly.""" """Test that variables with signed types display correctly."""
self.buildDsym() self.buildDsym()
self.signed_types() self.signed_types()
@dwarf_test @dwarf_test
def test_with_dwarf(self): def test_with_dwarf(self):
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

test/lang/cpp/static_members/TestCPPStaticMembers.py

""" """
Tests that C++ member and static variables have correct layout and scope. Tests that C++ member and static variables have correct layout and scope.
""" """
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class CPPStaticMembersTestCase(TestBase): class CPPStaticMembersTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@unittest2.expectedFailure # llvm.org/pr15401 @unittest2.expectedFailure # llvm.org/pr15401
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test that member variables have the correct layout, scope and qualifiers when stopped inside and outside C++ methods""" """Test that member variables have the correct layout, scope and qualifiers when stopped inside and outside C++ methods"""
self.buildDsym() self.buildDsym()
self.static_member_commands() self.static_member_commands()
@unittest2.expectedFailure # llvm.org/pr15401 @unittest2.expectedFailure # llvm.org/pr15401
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

test/lang/cpp/static_methods/TestCPPStaticMethods.py

""" """
Tests expressions that distinguish between static and non-static methods. Tests expressions that distinguish between static and non-static methods.
""" """
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class CPPStaticMethodsTestCase(TestBase): class CPPStaticMethodsTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test that static methods are properly distinguished from regular methods""" """Test that static methods are properly distinguished from regular methods"""
self.buildDsym() self.buildDsym()
self.static_method_commands() self.static_method_commands()
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
Show All 32 Lines

test/lang/cpp/stl/TestSTL.py

""" """
Test some expressions involving STL data types. Test some expressions involving STL data types.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
import lldbutil import lldbutil
from lldbtest import * from lldbtest import *
class STLTestCase(TestBase): class STLTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
# rdar://problem/10400981 # rdar://problem/10400981
@unittest2.expectedFailure @unittest2.expectedFailure
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test some expressions involving STL data types.""" """Test some expressions involving STL data types."""
self.buildDsym() self.buildDsym()
self.step_stl_exprs() self.step_stl_exprs()
# rdar://problem/10400981 # rdar://problem/10400981
@unittest2.expectedFailure @unittest2.expectedFailure
▲ Show 20 Lines • Show All 123 Lines • Show Last 20 Lines

test/lang/cpp/this/TestCPPThis.py

""" """
Tests that C++ member and static variables are available where they should be. Tests that C++ member and static variables are available where they should be.
""" """
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class CPPThisTestCase(TestBase): class CPPThisTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
#rdar://problem/9962849 #rdar://problem/9962849
#@expectedFailureClang #@expectedFailureClang
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test that the appropriate member variables are available when stopped in C++ static, inline, and const methods""" """Test that the appropriate member variables are available when stopped in C++ static, inline, and const methods"""
self.buildDsym() self.buildDsym()
self.static_method_commands() self.static_method_commands()
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

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

""" """
Test that template instaniations of std::vector<long> and <short> in the same module have the correct types. Test that template instaniations of std::vector<long> and <short> in the same module have the correct types.
""" """
import unittest2 import unittest2
import lldb import lldb
import lldbutil import lldbutil
from lldbtest import * from lldbtest import *
class UniqueTypesTestCase(TestBase): class UniqueTypesTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test for unique types of std::vector<long> and std::vector<short>.""" """Test for unique types of std::vector<long> and std::vector<short>."""
self.buildDsym() self.buildDsym()
self.unique_types() self.unique_types()
@dwarf_test @dwarf_test
def test_with_dwarf(self): def test_with_dwarf(self):
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

test/lang/cpp/unsigned_types/TestUnsignedTypes.py

""" """
Test that variables with unsigned types display correctly. Test that variables with unsigned types display correctly.
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class UnsignedTypesTestCase(TestBase): class UnsignedTypesTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test that variables with unsigned types display correctly.""" """Test that variables with unsigned types display correctly."""
self.buildDsym() self.buildDsym()
self.unsigned_types() self.unsigned_types()
@dwarf_test @dwarf_test
def test_with_dwarf(self): def test_with_dwarf(self):
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

test/lang/cpp/virtual/TestVirtual.py

Show All 16 Linesclass CppVirtualMadness(TestBase):
# This is the pattern by design to match the "my_expr = 'value'" output from # This is the pattern by design to match the "my_expr = 'value'" output from
# printf() stmts (see main.cpp). # printf() stmts (see main.cpp).
pattern = re.compile("^([^=]*) = '([^=]*)'$") pattern = re.compile("^([^=]*) = '([^=]*)'$")
# Assert message. # Assert message.
PRINTF_OUTPUT_GROKKED = "The printf output from compiled code is parsed correctly" PRINTF_OUTPUT_GROKKED = "The printf output from compiled code is parsed correctly"
@unittest2.skipIf(sys.platform.startswith("win32"), "Process::GetSTDOUT unsupported on Windows. This test should be re-written to use stdout re-direction") @skipIfWindows # Process::GetSTDOUT unsupported on Windows. This test should be re-written to use stdout re-direction
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
def test_virtual_madness_dsym(self): def test_virtual_madness_dsym(self):
"""Test that expression works correctly with virtual inheritance as well as virtual function.""" """Test that expression works correctly with virtual inheritance as well as virtual function."""
self.buildDsym() self.buildDsym()
self.virtual_madness_test() self.virtual_madness_test()
@expectedFailureIcc('llvm.org/pr16808') # lldb does not call the correct virtual function with icc @expectedFailureIcc('llvm.org/pr16808') # lldb does not call the correct virtual function with icc
def test_virtual_madness_dwarf(self): def test_virtual_madness_dwarf(self):
"""Test that expression works correctly with virtual inheritance as well as virtual function.""" """Test that expression works correctly with virtual inheritance as well as virtual function."""
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

test/lang/cpp/wchar_t/TestCxxWCharT.py

#coding=utf8 #coding=utf8
""" """
Test that C++ supports wchar_t correctly. Test that C++ supports wchar_t correctly.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class CxxWCharTTestCase(TestBase): class CxxWCharTTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test that C++ supports wchar_t correctly.""" """Test that C++ supports wchar_t correctly."""
self.buildDsym() self.buildDsym()
self.wchar_t() self.wchar_t()
@dwarf_test @dwarf_test
def test_with_dwarf(self): def test_with_dwarf(self):
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

test/lang/objc/blocks/TestObjCIvarsInBlocks.py

"""Test printing ivars and ObjC objects captured in blocks that are made in methods of an ObjC class.""" """Test printing ivars and ObjC objects captured in blocks that are made in methods of an ObjC class."""
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class TestObjCIvarsInBlocks(TestBase): class TestObjCIvarsInBlocks(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
# This test requires the 2.0 runtime, so it will fail on i386. # This test requires the 2.0 runtime, so it will fail on i386.
@expectedFailurei386 @expectedFailurei386
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym_and_python_api(self): def test_with_dsym_and_python_api(self):
"""Test printing the ivars of the self when captured in blocks""" """Test printing the ivars of the self when captured in blocks"""
self.buildDsym() self.buildDsym()
self.ivars_in_blocks() self.ivars_in_blocks()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
# This test requires the 2.0 runtime, so it will fail on i386. # This test requires the 2.0 runtime, so it will fail on i386.
@expectedFailurei386 @expectedFailurei386
@dwarf_test @dwarf_test
def test_with_dwarf_and_python_api(self): def test_with_dwarf_and_python_api(self):
"""Test printing the ivars of the self when captured in blocks""" """Test printing the ivars of the self when captured in blocks"""
self.buildDwarf() self.buildDwarf()
self.ivars_in_blocks() self.ivars_in_blocks()
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

"""Test that a forward-declared class works when its complete definition is in a library""" """Test that a forward-declared class works when its complete definition is in a library"""
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class ForwardDeclTestCase(TestBase): class ForwardDeclTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_expr_with_dsym(self): def test_expr_with_dsym(self):
self.buildDsym() self.buildDsym()
self.expr() self.expr()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_expr_with_dwarf(self): def test_expr_with_dwarf(self):
self.buildDwarf() self.buildDwarf()
self.expr() self.expr()
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

test/lang/objc/foundation/TestConstStrings.py

""" """
Test that objective-c constant strings are generated correctly by the expression Test that objective-c constant strings are generated correctly by the expression
parser. parser.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
class ConstStringTestCase(TestBase): class ConstStringTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
d = {'OBJC_SOURCES': 'const-strings.m'} d = {'OBJC_SOURCES': 'const-strings.m'}
@dsym_test @dsym_test
def test_break_with_dsym(self): def test_break_with_dsym(self):
"""Test constant string generation amd comparison by the expression parser.""" """Test constant string generation amd comparison by the expression parser."""
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

test/lang/objc/foundation/TestFoundationDisassembly.py

""" """
Test the lldb disassemble command on foundation framework. Test the lldb disassemble command on foundation framework.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
class FoundationDisassembleTestCase(TestBase): class FoundationDisassembleTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
# rdar://problem/8504895 # rdar://problem/8504895
# Crash while doing 'disassemble -n "-[NSNumber descriptionWithLocale:]" # Crash while doing 'disassemble -n "-[NSNumber descriptionWithLocale:]"
@unittest2.skipIf(TestBase.skipLongRunningTest(), "Skip this long running test") @unittest2.skipIf(TestBase.skipLongRunningTest(), "Skip this long running test")
def test_foundation_disasm(self): def test_foundation_disasm(self):
▲ Show 20 Lines • Show All 129 Lines • Show Last 20 Lines

test/lang/objc/foundation/TestObjCMethods.py

""" """
Set breakpoints on objective-c class and instance methods in foundation. Set breakpoints on objective-c class and instance methods in foundation.
Also lookup objective-c data types and evaluate expressions. Also lookup objective-c data types and evaluate expressions.
""" """
import os, os.path, time import os, os.path, time
import unittest2 import unittest2
import lldb import lldb
import string import string
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
file_index = 0 file_index = 0
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
class FoundationTestCase(TestBase): class FoundationTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@dsym_test @dsym_test
def test_break_with_dsym(self): def test_break_with_dsym(self):
"""Test setting objc breakpoints using '_regexp-break' and 'breakpoint set'.""" """Test setting objc breakpoints using '_regexp-break' and 'breakpoint set'."""
self.buildDsym() self.buildDsym()
▲ Show 20 Lines • Show All 290 Lines • Show Last 20 Lines

test/lang/objc/foundation/TestObjCMethods2.py

""" """
Test more expression command sequences with objective-c. Test more expression command sequences with objective-c.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
class FoundationTestCase2(TestBase): class FoundationTestCase2(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@dsym_test @dsym_test
def test_more_expr_commands_with_dsym(self): def test_more_expr_commands_with_dsym(self):
"""More expression commands for objective-c.""" """More expression commands for objective-c."""
self.buildDsym() self.buildDsym()
▲ Show 20 Lines • Show All 220 Lines • Show Last 20 Lines

test/lang/objc/foundation/TestObjectDescriptionAPI.py

""" """
Test SBValue.GetObjectDescription() with the value from SBTarget.FindGlobalVariables(). Test SBValue.GetObjectDescription() with the value from SBTarget.FindGlobalVariables().
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
from lldbtest import * from lldbtest import *
class ObjectDescriptionAPITestCase(TestBase): class ObjectDescriptionAPITestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
# rdar://problem/10857337 # rdar://problem/10857337
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_find_global_variables_then_object_description_with_dsym(self): def test_find_global_variables_then_object_description_with_dsym(self):
"""Exercise SBTaget.FindGlobalVariables() API.""" """Exercise SBTaget.FindGlobalVariables() API."""
d = {'EXE': 'a.out'} d = {'EXE': 'a.out'}
self.buildDsym(dictionary=d) self.buildDsym(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
self.find_global_variables_then_object_description('a.out') self.find_global_variables_then_object_description('a.out')
# rdar://problem/10857337 # rdar://problem/10857337
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_find_global_variables_then_object_description_with_dwarf(self): def test_find_global_variables_then_object_description_with_dwarf(self):
"""Exercise SBTarget.FindGlobalVariables() API.""" """Exercise SBTarget.FindGlobalVariables() API."""
d = {'EXE': 'b.out'} d = {'EXE': 'b.out'}
self.buildDwarf(dictionary=d) self.buildDwarf(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
self.find_global_variables_then_object_description('b.out') self.find_global_variables_then_object_description('b.out')
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

test/lang/objc/foundation/TestRuntimeTypes.py

""" """
Test that Objective-C methods from the runtime work correctly. Test that Objective-C methods from the runtime work correctly.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
class RuntimeTypesTestCase(TestBase): class RuntimeTypesTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@dsym_test @dsym_test
def test_break_with_dsym(self): def test_break_with_dsym(self):
"""Test setting objc breakpoints using '_regexp-break' and 'breakpoint set'.""" """Test setting objc breakpoints using '_regexp-break' and 'breakpoint set'."""
# This only applies to the v2 runtime # This only applies to the v2 runtime
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

test/lang/objc/foundation/TestSymbolTable.py

""" """
Test symbol table access for main.m. Test symbol table access for main.m.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
class FoundationSymtabTestCase(TestBase): class FoundationSymtabTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
symbols_list = ['-[MyString initWithNSString:]', symbols_list = ['-[MyString initWithNSString:]',
'-[MyString dealloc]', '-[MyString dealloc]',
'-[MyString description]', '-[MyString description]',
'-[MyString descriptionPauses]', # synthesized property '-[MyString descriptionPauses]', # synthesized property
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

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

"""Test that hidden ivars in a shared library are visible from the main executable.""" """Test that hidden ivars in a shared library are visible from the main executable."""
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
import subprocess import subprocess
class HiddenIvarsTestCase(TestBase): class HiddenIvarsTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_expr_with_dsym(self): def test_expr_with_dsym(self):
if self.getArchitecture() == 'i386': if self.getArchitecture() == 'i386':
self.skipTest("requires modern objc runtime") self.skipTest("requires modern objc runtime")
else: else:
self.buildDsym() self.buildDsym()
self.expr(False) self.expr(False)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_expr_stripped_with_dsym(self): def test_expr_stripped_with_dsym(self):
if self.getArchitecture() == 'i386': if self.getArchitecture() == 'i386':
self.skipTest("requires modern objc runtime") self.skipTest("requires modern objc runtime")
else: else:
self.buildDsym() self.buildDsym()
self.expr(True) self.expr(True)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_expr_with_dwarf(self): def test_expr_with_dwarf(self):
if self.getArchitecture() == 'i386': if self.getArchitecture() == 'i386':
self.skipTest("requires modern objc runtime") self.skipTest("requires modern objc runtime")
else: else:
self.buildDwarf() self.buildDwarf()
self.expr(False) self.expr(False)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_frame_variable_with_dsym(self): def test_frame_variable_with_dsym(self):
if self.getArchitecture() == 'i386': if self.getArchitecture() == 'i386':
self.skipTest("requires modern objc runtime") self.skipTest("requires modern objc runtime")
else: else:
self.buildDsym() self.buildDsym()
self.frame_var(False) self.frame_var(False)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_frame_variable_stripped_with_dsym(self): def test_frame_variable_stripped_with_dsym(self):
if self.getArchitecture() == 'i386': if self.getArchitecture() == 'i386':
self.skipTest("requires modern objc runtime") self.skipTest("requires modern objc runtime")
else: else:
self.buildDsym() self.buildDsym()
self.frame_var(True) self.frame_var(True)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_frame_variable_with_dwarf(self): def test_frame_variable_with_dwarf(self):
if self.getArchitecture() == 'i386': if self.getArchitecture() == 'i386':
self.skipTest("requires modern objc runtime") self.skipTest("requires modern objc runtime")
else: else:
self.buildDwarf() self.buildDwarf()
self.frame_var(False) self.frame_var(False)
@unittest2.expectedFailure("rdar://18683637") @unittest2.expectedFailure("rdar://18683637")
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_frame_variable_across_modules_with_dsym(self): def test_frame_variable_across_modules_with_dsym(self):
if self.getArchitecture() == 'i386': if self.getArchitecture() == 'i386':
self.skipTest("requires modern objc runtime") self.skipTest("requires modern objc runtime")
else: else:
self.buildDsym() self.buildDsym()
self.frame_var_type_access_across_module() self.frame_var_type_access_across_module()
@unittest2.expectedFailure("rdar://18683637") @unittest2.expectedFailure("rdar://18683637")
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_frame_variable_across_modules_with_dwarf(self): def test_frame_variable_across_modules_with_dwarf(self):
if self.getArchitecture() == 'i386': if self.getArchitecture() == 'i386':
self.skipTest("requires modern objc runtime") self.skipTest("requires modern objc runtime")
else: else:
self.buildDwarf() self.buildDwarf()
self.frame_var_type_access_across_module() self.frame_var_type_access_across_module()
▲ Show 20 Lines • Show All 123 Lines • Show Last 20 Lines

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

Show All 14 Linesclass ObjCXXTestCase(TestBase):
@dsym_test @dsym_test
def test_break_with_dsym(self): def test_break_with_dsym(self):
"""Test ivars of Objective-C++ classes""" """Test ivars of Objective-C++ classes"""
if self.getArchitecture() == 'i386': if self.getArchitecture() == 'i386':
self.skipTest("requires Objective-C 2.0 runtime") self.skipTest("requires Objective-C 2.0 runtime")
self.buildDsym() self.buildDsym()
self.do_testObjCXXClasses() self.do_testObjCXXClasses()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_break_with_dwarf(self): def test_break_with_dwarf(self):
"""Test ivars of Objective-C++ classes""" """Test ivars of Objective-C++ classes"""
if self.getArchitecture() == 'i386': if self.getArchitecture() == 'i386':
self.skipTest("requires Objective-C 2.0 runtime") self.skipTest("requires Objective-C 2.0 runtime")
self.buildDwarf() self.buildDwarf()
self.do_testObjCXXClasses() self.do_testObjCXXClasses()
Show All 17 Lines

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

""" """
Use lldb Python API to test base class resolution for ObjC classes Use lldb Python API to test base class resolution for ObjC classes
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
from lldbtest import * from lldbtest import *
class ObjCDynamicValueTestCase(TestBase): class ObjCDynamicValueTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_get_baseclass_with_dsym(self): def test_get_baseclass_with_dsym(self):
"""Test fetching ObjC base class info.""" """Test fetching ObjC base class info."""
if self.getArchitecture() == 'i386': if self.getArchitecture() == 'i386':
# rdar://problem/9946499 # rdar://problem/9946499
self.skipTest("Dynamic types for ObjC V1 runtime not implemented") self.skipTest("Dynamic types for ObjC V1 runtime not implemented")
self.buildDsym() self.buildDsym()
self.do_get_baseclass_info() self.do_get_baseclass_info()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_get_baseclass_with_dwarf(self): def test_get_baseclass_with_dwarf(self):
"""Test fetching ObjC dynamic values.""" """Test fetching ObjC dynamic values."""
if self.getArchitecture() == 'i386': if self.getArchitecture() == 'i386':
# rdar://problem/9946499 # rdar://problem/9946499
self.skipTest("Dynamic types for ObjC V1 runtime not implemented") self.skipTest("Dynamic types for ObjC V1 runtime not implemented")
self.buildDwarf() self.buildDwarf()
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

test/lang/objc/objc-builtin-types/TestObjCBuiltinTypes.py

"""Test that the expression parser doesn't get confused by 'id' and 'Class'""" """Test that the expression parser doesn't get confused by 'id' and 'Class'"""
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
import lldbutil import lldbutil
from lldbtest import * from lldbtest import *
class TestObjCBuiltinTypes(TestBase): class TestObjCBuiltinTypes(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym_and_python_api(self): def test_with_dsym_and_python_api(self):
"""Test expression parser respect for ObjC built-in types.""" """Test expression parser respect for ObjC built-in types."""
self.buildDsym() self.buildDsym()
self.objc_builtin_types() self.objc_builtin_types()
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

test/lang/objc/objc-checker/TestObjCCheckers.py

""" """
Use lldb Python API to make sure the dynamic checkers are doing their jobs. Use lldb Python API to make sure the dynamic checkers are doing their jobs.
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
from lldbtest import * from lldbtest import *
class ObjCCheckerTestCase(TestBase): class ObjCCheckerTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_objc_checker_with_dsym(self): def test_objc_checker_with_dsym(self):
"""Test that checkers catch unrecognized selectors""" """Test that checkers catch unrecognized selectors"""
if self.getArchitecture() == 'i386': if self.getArchitecture() == 'i386':
self.skipTest("requires Objective-C 2.0 runtime") self.skipTest("requires Objective-C 2.0 runtime")
self.buildDsym() self.buildDsym()
self.do_test_checkers() self.do_test_checkers()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_objc_checker_with_dwarf(self): def test_objc_checker_with_dwarf(self):
"""Test that checkers catch unrecognized selectors""" """Test that checkers catch unrecognized selectors"""
if self.getArchitecture() == 'i386': if self.getArchitecture() == 'i386':
self.skipTest("requires Objective-C 2.0 runtime") self.skipTest("requires Objective-C 2.0 runtime")
self.buildDwarf() self.buildDwarf()
self.do_test_checkers() self.do_test_checkers()
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

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

"""Test calling functions in class methods.""" """Test calling functions in class methods."""
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
import lldbutil import lldbutil
from lldbtest import * from lldbtest import *
class TestObjCClassMethod(TestBase): class TestObjCClassMethod(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@expectedFailurei386 @expectedFailurei386
@dsym_test @dsym_test
def test_with_dsym_and_python_api(self): def test_with_dsym_and_python_api(self):
"""Test calling functions in class methods.""" """Test calling functions in class methods."""
self.buildDsym() self.buildDsym()
self.objc_class_method() self.objc_class_method()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@expectedFailurei386 @expectedFailurei386
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_with_dwarf_and_python_api(self): def test_with_dwarf_and_python_api(self):
"""Test calling functions in class methods.""" """Test calling functions in class methods."""
self.buildDwarf() self.buildDwarf()
self.objc_class_method() self.objc_class_method()
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

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

""" """
Test that we are able to properly report a usable dynamic type Test that we are able to properly report a usable dynamic type
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
class ObjCDynamicSBTypeTestCase(TestBase): class ObjCDynamicSBTypeTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@dsym_test @dsym_test
@skipIfi386 @skipIfi386
def test_dyn_with_dsym(self): def test_dyn_with_dsym(self):
"""Test that we are able to properly report a usable dynamic type.""" """Test that we are able to properly report a usable dynamic type."""
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

test/lang/objc/objc-dynamic-value/TestObjCDynamicValue.py

""" """
Use lldb Python API to test dynamic values in ObjC Use lldb Python API to test dynamic values in ObjC
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
from lldbtest import * from lldbtest import *
class ObjCDynamicValueTestCase(TestBase): class ObjCDynamicValueTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
@expectedFailureDarwin("llvm.org/pr20271 rdar://18684107") @expectedFailureDarwin("llvm.org/pr20271 rdar://18684107")
def test_get_dynamic_objc_vals_with_dsym(self): def test_get_dynamic_objc_vals_with_dsym(self):
"""Test fetching ObjC dynamic values.""" """Test fetching ObjC dynamic values."""
if self.getArchitecture() == 'i386': if self.getArchitecture() == 'i386':
# rdar://problem/9946499 # rdar://problem/9946499
self.skipTest("Dynamic types for ObjC V1 runtime not implemented") self.skipTest("Dynamic types for ObjC V1 runtime not implemented")
self.buildDsym() self.buildDsym()
self.do_get_dynamic_vals() self.do_get_dynamic_vals()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dwarf_test @dwarf_test
@expectedFailureDarwin("llvm.org/pr20271 rdar://18684107") @expectedFailureDarwin("llvm.org/pr20271 rdar://18684107")
def test_get_objc_dynamic_vals_with_dwarf(self): def test_get_objc_dynamic_vals_with_dwarf(self):
"""Test fetching ObjC dynamic values.""" """Test fetching ObjC dynamic values."""
if self.getArchitecture() == 'i386': if self.getArchitecture() == 'i386':
# rdar://problem/9946499 # rdar://problem/9946499
self.skipTest("Dynamic types for ObjC V1 runtime not implemented") self.skipTest("Dynamic types for ObjC V1 runtime not implemented")
▲ Show 20 Lines • Show All 160 Lines • Show Last 20 Lines

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

"""Test printing ObjC objects that use unbacked properties - so that the static ivar offsets are incorrect.""" """Test printing ObjC objects that use unbacked properties - so that the static ivar offsets are incorrect."""
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class TestObjCIvarOffsets(TestBase): class TestObjCIvarOffsets(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym_and_python_api(self): def test_with_dsym_and_python_api(self):
"""Test printing ObjC objects that use unbacked properties""" """Test printing ObjC objects that use unbacked properties"""
self.buildDsym() self.buildDsym()
self.objc_ivar_offsets() self.objc_ivar_offsets()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_with_dwarf_and_python_api(self): def test_with_dwarf_and_python_api(self):
"""Test printing ObjC objects that use unbacked properties""" """Test printing ObjC objects that use unbacked properties"""
self.buildDwarf() self.buildDwarf()
self.objc_ivar_offsets() self.objc_ivar_offsets()
def setUp(self): def setUp(self):
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

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

"""Test printing ObjC objects that use unbacked properties - so that the static ivar offsets are incorrect.""" """Test printing ObjC objects that use unbacked properties - so that the static ivar offsets are incorrect."""
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class TestObjCIvarStripped(TestBase): class TestObjCIvarStripped(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym_and_python_api(self): def test_with_dsym_and_python_api(self):
"""Test that we can find stripped Objective-C ivars in the runtime""" """Test that we can find stripped Objective-C ivars in the runtime"""
self.buildDsym() self.buildDsym()
self.objc_ivar_offsets() self.objc_ivar_offsets()
def setUp(self): def setUp(self):
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

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

"""Test that the Objective-C syntax for dictionary/array literals and indexing works""" """Test that the Objective-C syntax for dictionary/array literals and indexing works"""
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
import platform import platform
import lldbutil import lldbutil
from distutils.version import StrictVersion from distutils.version import StrictVersion
from lldbtest import * from lldbtest import *
class ObjCNewSyntaxTestCase(TestBase): class ObjCNewSyntaxTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_expr_with_dsym(self): def test_expr_with_dsym(self):
self.buildDsym() self.buildDsym()
self.expr() self.expr()
@dwarf_test @dwarf_test
@skipIfFreeBSD @skipIfFreeBSD
@skipIfLinux @skipIfLinux
▲ Show 20 Lines • Show All 104 Lines • Show Last 20 Lines

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

Show All 10 Lines
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
import re import re
# rdar://problem/9087739 # rdar://problem/9087739
# test failure: objc_optimized does not work for "-C clang -A i386" # test failure: objc_optimized does not work for "-C clang -A i386"
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
class ObjcOptimizedTestCase(TestBase): class ObjcOptimizedTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
myclass = "MyClass" myclass = "MyClass"
mymethod = "description" mymethod = "description"
method_spec = "-[%s %s]" % (myclass, mymethod) method_spec = "-[%s %s]" % (myclass, mymethod)
@dsym_test @dsym_test
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

test/lang/objc/objc-property/TestObjCProperty.py

""" """
Use lldb Python API to verify that expression evaluation for property references uses the correct getters and setters Use lldb Python API to verify that expression evaluation for property references uses the correct getters and setters
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
from lldbtest import * from lldbtest import *
class ObjCPropertyTestCase(TestBase): class ObjCPropertyTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_objc_properties_with_dsym(self): def test_objc_properties_with_dsym(self):
"""Test that expr uses the correct property getters and setters""" """Test that expr uses the correct property getters and setters"""
if self.getArchitecture() == 'i386': if self.getArchitecture() == 'i386':
self.skipTest("requires modern objc runtime") self.skipTest("requires modern objc runtime")
self.buildDsym() self.buildDsym()
self.do_test_properties() self.do_test_properties()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_objc_properties_with_dwarf(self): def test_objc_properties_with_dwarf(self):
"""Test that expr uses the correct property getters and setters""" """Test that expr uses the correct property getters and setters"""
if self.getArchitecture() == 'i386': if self.getArchitecture() == 'i386':
self.skipTest("requires modern objc runtime") self.skipTest("requires modern objc runtime")
self.buildDwarf() self.buildDwarf()
self.do_test_properties() self.do_test_properties()
▲ Show 20 Lines • Show All 104 Lines • Show Last 20 Lines

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

"""Test calling functions in static methods with a stripped binary.""" """Test calling functions in static methods with a stripped binary."""
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
import lldbutil import lldbutil
from lldbtest import * from lldbtest import *
class TestObjCStaticMethodStripped(TestBase): class TestObjCStaticMethodStripped(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
#<rdar://problem/12042992> #<rdar://problem/12042992>
@dsym_test @dsym_test
def test_with_dsym_and_python_api(self): def test_with_dsym_and_python_api(self):
"""Test calling functions in static methods with a stripped binary.""" """Test calling functions in static methods with a stripped binary."""
if self.getArchitecture() == 'i386': if self.getArchitecture() == 'i386':
self.skipTest("requires modern objc runtime") self.skipTest("requires modern objc runtime")
self.buildDsym() self.buildDsym()
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

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

"""Test calling functions in static methods.""" """Test calling functions in static methods."""
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
import lldbutil import lldbutil
from lldbtest import * from lldbtest import *
class TestObjCStaticMethod(TestBase): class TestObjCStaticMethod(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
#<rdar://problem/9745789> "expression" can't call functions in class methods #<rdar://problem/9745789> "expression" can't call functions in class methods
@dsym_test @dsym_test
def test_with_dsym_and_python_api(self): def test_with_dsym_and_python_api(self):
"""Test calling functions in static methods.""" """Test calling functions in static methods."""
self.buildDsym() self.buildDsym()
self.objc_static_method() self.objc_static_method()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
#<rdar://problem/9745789> "expression" can't call functions in class methods #<rdar://problem/9745789> "expression" can't call functions in class methods
@dwarf_test @dwarf_test
def test_with_dwarf_and_python_api(self): def test_with_dwarf_and_python_api(self):
"""Test calling functions in static methods.""" """Test calling functions in static methods."""
self.buildDwarf() self.buildDwarf()
self.objc_static_method() self.objc_static_method()
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

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

"""Test stepping through ObjC method dispatch in various forms.""" """Test stepping through ObjC method dispatch in various forms."""
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
import lldbutil import lldbutil
from lldbtest import * from lldbtest import *
class TestObjCStepping(TestBase): class TestObjCStepping(TestBase):
def getCategories (self): def getCategories (self):
return ['basic_process'] return ['basic_process']
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym_and_python_api(self): def test_with_dsym_and_python_api(self):
"""Test stepping through ObjC method dispatch in various forms.""" """Test stepping through ObjC method dispatch in various forms."""
self.buildDsym() self.buildDsym()
self.objc_stepping() self.objc_stepping()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_with_dwarf_and_python_api(self): def test_with_dwarf_and_python_api(self):
"""Test stepping through ObjC method dispatch in various forms.""" """Test stepping through ObjC method dispatch in various forms."""
self.buildDwarf() self.buildDwarf()
self.objc_stepping() self.objc_stepping()
def setUp(self): def setUp(self):
▲ Show 20 Lines • Show All 156 Lines • Show Last 20 Lines

test/lang/objc/objc-struct-return/TestObjCStructReturn.py

"""Test calling functions in class methods.""" """Test calling functions in class methods."""
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
import lldbutil import lldbutil
from lldbtest import * from lldbtest import *
class TestObjCClassMethod(TestBase): class TestObjCClassMethod(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym_and_python_api(self): def test_with_dsym_and_python_api(self):
"""Test calling functions in class methods.""" """Test calling functions in class methods."""
self.buildDsym() self.buildDsym()
self.objc_class_method() self.objc_class_method()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_with_dwarf_and_python_api(self): def test_with_dwarf_and_python_api(self):
"""Test calling functions in class methods.""" """Test calling functions in class methods."""
self.buildDwarf() self.buildDwarf()
self.objc_class_method() self.objc_class_method()
def setUp(self): def setUp(self):
Show All 40 Lines

test/lang/objc/objc-super/TestObjCSuper.py

"""Test calling methods on super.""" """Test calling methods on super."""
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
import lldbutil import lldbutil
from lldbtest import * from lldbtest import *
class TestObjCSuperMethod(TestBase): class TestObjCSuperMethod(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@expectedFailurei386 @expectedFailurei386
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym_and_python_api(self): def test_with_dsym_and_python_api(self):
"""Test calling methods on super.""" """Test calling methods on super."""
self.buildDsym() self.buildDsym()
self.objc_super() self.objc_super()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@expectedFailurei386 @expectedFailurei386
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_with_dwarf_and_python_api(self): def test_with_dwarf_and_python_api(self):
"""Test calling methods on super.""" """Test calling methods on super."""
self.buildDwarf() self.buildDwarf()
self.objc_super() self.objc_super()
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

test/lang/objc/print-obj/TestPrintObj.py

""" """
Test "print object" where another thread blocks the print object from making progress. Test "print object" where another thread blocks the print object from making progress.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
class PrintObjTestCase(TestBase): class PrintObjTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@dsym_test @dsym_test
def test_print_obj_with_dsym(self): def test_print_obj_with_dsym(self):
"""Test "print object" where another thread blocks the print object from making progress.""" """Test "print object" where another thread blocks the print object from making progress."""
d = {'EXE': 'a.out'} d = {'EXE': 'a.out'}
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

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

""" """
Test that objective-c method returning BOOL works correctly. Test that objective-c method returning BOOL works correctly.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
class MethodReturningBOOLTestCase(TestBase): class MethodReturningBOOLTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@dsym_test @dsym_test
def test_method_ret_BOOL_with_dsym(self): def test_method_ret_BOOL_with_dsym(self):
"""Test that objective-c method returning BOOL works correctly.""" """Test that objective-c method returning BOOL works correctly."""
d = {'EXE': self.exe_name} d = {'EXE': self.exe_name}
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

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

""" """
Test that CoreFoundation classes CFGregorianDate and CFRange are not improperly uniqued Test that CoreFoundation classes CFGregorianDate and CFRange are not improperly uniqued
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
class Rdar10967107TestCase(TestBase): class Rdar10967107TestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@dsym_test @dsym_test
def test_cfrange_diff_cfgregoriandate_with_dsym(self): def test_cfrange_diff_cfgregoriandate_with_dsym(self):
"""Test that CoreFoundation classes CFGregorianDate and CFRange are not improperly uniqued.""" """Test that CoreFoundation classes CFGregorianDate and CFRange are not improperly uniqued."""
d = {'EXE': self.exe_name} d = {'EXE': self.exe_name}
Show All 40 Lines

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

""" """
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*'
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
class Rdar10967107TestCase(TestBase): class Rdar10967107TestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@dsym_test @dsym_test
def test_charstar_dyntype_with_dsym(self): def test_charstar_dyntype_with_dsym(self):
"""Test that we do not attempt to make a dynamic type for a 'const char*'""" """Test that we do not attempt to make a dynamic type for a 'const char*'"""
d = {'EXE': self.exe_name} d = {'EXE': self.exe_name}
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

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

""" """
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
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
class Rdar12408181TestCase(TestBase): class Rdar12408181TestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@dsym_test @dsym_test
def test_nswindow_count_with_dsym(self): def test_nswindow_count_with_dsym(self):
"""Test that we are able to find out how many children NSWindow has.""" """Test that we are able to find out how many children NSWindow has."""
d = {'EXE': self.exe_name} d = {'EXE': self.exe_name}
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

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

"""Test that types defined in shared libraries work correctly.""" """Test that types defined in shared libraries work correctly."""
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class TestRealDefinition(TestBase): class TestRealDefinition(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_frame_var_after_stop_at_interface_with_dsym(self): def test_frame_var_after_stop_at_interface_with_dsym(self):
"""Test that we can find the implementation for an objective C type""" """Test that we can find the implementation for an objective C type"""
if self.getArchitecture() == 'i386': if self.getArchitecture() == 'i386':
self.skipTest("requires modern objc runtime") self.skipTest("requires modern objc runtime")
self.buildDsym() self.buildDsym()
self.stop_at_interface() self.stop_at_interface()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_frame_var_after_stop_at_interface_with_dwarf(self): def test_frame_var_after_stop_at_interface_with_dwarf(self):
"""Test that we can find the implementation for an objective C type""" """Test that we can find the implementation for an objective C type"""
if self.getArchitecture() == 'i386': if self.getArchitecture() == 'i386':
self.skipTest("requires modern objc runtime") self.skipTest("requires modern objc runtime")
self.buildDwarf() self.buildDwarf()
self.stop_at_interface() self.stop_at_interface()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_frame_var_after_stop_at_implementation_with_dsym(self): def test_frame_var_after_stop_at_implementation_with_dsym(self):
"""Test that we can find the implementation for an objective C type""" """Test that we can find the implementation for an objective C type"""
if self.getArchitecture() == 'i386': if self.getArchitecture() == 'i386':
self.skipTest("requires modern objc runtime") self.skipTest("requires modern objc runtime")
self.buildDsym() self.buildDsym()
self.stop_at_implementation() self.stop_at_implementation()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_frame_var_after_stop_at_implementation_with_dwarf(self): def test_frame_var_after_stop_at_implementation_with_dwarf(self):
"""Test that we can find the implementation for an objective C type""" """Test that we can find the implementation for an objective C type"""
if self.getArchitecture() == 'i386': if self.getArchitecture() == 'i386':
self.skipTest("requires modern objc runtime") self.skipTest("requires modern objc runtime")
self.buildDwarf() self.buildDwarf()
self.stop_at_implementation() self.stop_at_implementation()
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

test/lang/objc/self/TestObjCSelf.py

""" """
Tests that ObjC member variables are available where they should be. Tests that ObjC member variables are available where they should be.
""" """
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class ObjCSelfTestCase(TestBase): class ObjCSelfTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test that the appropriate member variables are available when stopped in Objective-C class and instance methods""" """Test that the appropriate member variables are available when stopped in Objective-C class and instance methods"""
self.buildDsym() self.buildDsym()
self.self_commands() self.self_commands()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
"""Test that the appropriate member variables are available when stopped in Objective-C class and instance methods""" """Test that the appropriate member variables are available when stopped in Objective-C class and instance methods"""
self.buildDwarf() self.buildDwarf()
self.self_commands() self.self_commands()
def setUp(self): def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
Show All 30 Lines

test/linux/builtin_trap/TestBuiltinTrap.py

""" """
Test lldb ability to unwind a stack with a function containing a call to the Test lldb ability to unwind a stack with a function containing a call to the
'__builtin_trap' intrinsic, which GCC (4.6) encodes to an illegal opcode. '__builtin_trap' intrinsic, which GCC (4.6) encodes to an illegal opcode.
""" """
import os import os
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class BuiltinTrapTestCase(TestBase): class BuiltinTrapTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test that LLDB handles a function with __builtin_trap correctly.""" """Test that LLDB handles a function with __builtin_trap correctly."""
self.buildDsym() self.buildDsym()
self.builtin_trap_unwind() self.builtin_trap_unwind()
@dwarf_test @dwarf_test
@expectedFailureGcc # llvm.org/pr15936: LLDB is omits a function that contains an @expectedFailureGcc # llvm.org/pr15936: LLDB is omits a function that contains an
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

test/lldbinline.py

Show First 20 Lines • Show All 108 Lines • ▼ Show 20 Lines def BuildMakefile(self):
if ('CXX_SOURCES' in categories.keys()): if ('CXX_SOURCES' in categories.keys()):
makefile.write("CXXFLAGS += -std=c++11\n") makefile.write("CXXFLAGS += -std=c++11\n")
makefile.write("include $(LEVEL)/Makefile.rules\n") makefile.write("include $(LEVEL)/Makefile.rules\n")
makefile.flush() makefile.flush()
makefile.close() makefile.close()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
def __test_with_dsym(self): def __test_with_dsym(self):
self.using_dsym = True self.using_dsym = True
self.BuildMakefile() self.BuildMakefile()
self.buildDsym() self.buildDsym()
self.do_test() self.do_test()
@expectedFailureGcc #xfail to get buildbot green, test failed with gcc4.8.2 @expectedFailureGcc #xfail to get buildbot green, test failed with gcc4.8.2
def __test_with_dwarf(self): def __test_with_dwarf(self):
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

test/lldbtest.py

Show First 20 Lines • Show All 580 Lines • ▼ Show 20 Lines
def expectedFailurei386(bugnumber=None): def expectedFailurei386(bugnumber=None):
if bugnumber: return expectedFailureArch('i386', bugnumber) if bugnumber: return expectedFailureArch('i386', bugnumber)
def expectedFailurex86_64(bugnumber=None): def expectedFailurex86_64(bugnumber=None):
if bugnumber: return expectedFailureArch('x86_64', bugnumber) if bugnumber: return expectedFailureArch('x86_64', bugnumber)
def expectedFailureOS(oslist, bugnumber=None, compilers=None): def expectedFailureOS(oslist, bugnumber=None, compilers=None):
def fn(self): def fn(self):
return (lldb.DBG.GetSelectedPlatform().GetTriple().split('-')[2] in oslist and return (self.getPlatform() in oslist and
self.expectedCompiler(compilers)) self.expectedCompiler(compilers))
if bugnumber: return expectedFailure(fn, bugnumber) if bugnumber: return expectedFailure(fn, bugnumber)
def expectedFailureDarwin(bugnumber=None, compilers=None): def expectedFailureDarwin(bugnumber=None, compilers=None):
# For legacy reasons, we support both "darwin" and "macosx" as OS X triples. # For legacy reasons, we support both "darwin" and "macosx" as OS X triples.
if bugnumber: return expectedFailureOS(['darwin', 'macosx'], bugnumber, compilers) if bugnumber: return expectedFailureOS(['darwin', 'macosx'], bugnumber, compilers)
def expectedFailureFreeBSD(bugnumber=None, compilers=None): def expectedFailureFreeBSD(bugnumber=None, compilers=None):
Show All 37 Lines def wrapper(*args, **kwargs):
from unittest2 import case from unittest2 import case
if lldb.remote_platform: if lldb.remote_platform:
self = args[0] self = args[0]
self.skipTest("skip on remote platform (deadlocks)") self.skipTest("skip on remote platform (deadlocks)")
else: else:
func(*args, **kwargs) func(*args, **kwargs)
return wrapper return wrapper
def skipIfFreeBSD(func):
"""Decorate the item to skip tests that should be skipped on FreeBSD."""
if isinstance(func, type) and issubclass(func, unittest2.TestCase):
raise Exception("@skipIfFreeBSD can only be used to decorate a test method")
@wraps(func)
def wrapper(*args, **kwargs):
from unittest2 import case
self = args[0]
platform = lldb.DBG.GetSelectedPlatform().GetTriple().split('-')[2]
if "freebsd" in platform:
self.skipTest("skip on FreeBSD")
else:
func(*args, **kwargs)
return wrapper
def skipIfLinux(func):
"""Decorate the item to skip tests that should be skipped on Linux."""
if isinstance(func, type) and issubclass(func, unittest2.TestCase):
raise Exception("@skipIfLinux can only be used to decorate a test method")
@wraps(func)
def wrapper(*args, **kwargs):
from unittest2 import case
self = args[0]
platform = lldb.DBG.GetSelectedPlatform().GetTriple().split('-')[2]
if "linux" in platform:
self.skipTest("skip on linux")
else:
func(*args, **kwargs)
return wrapper
def skipIfNoSBHeaders(func): def skipIfNoSBHeaders(func):
"""Decorate the item to mark tests that should be skipped when LLDB is built with no SB API headers.""" """Decorate the item to mark tests that should be skipped when LLDB is built with no SB API headers."""
if isinstance(func, type) and issubclass(func, unittest2.TestCase): if isinstance(func, type) and issubclass(func, unittest2.TestCase):
raise Exception("@skipIfNoSBHeaders can only be used to decorate a test method") raise Exception("@skipIfNoSBHeaders can only be used to decorate a test method")
@wraps(func) @wraps(func)
def wrapper(*args, **kwargs): def wrapper(*args, **kwargs):
from unittest2 import case from unittest2 import case
self = args[0] self = args[0]
if sys.platform.startswith("darwin"): if sys.platform.startswith("darwin"):
header = os.path.join(self.lib_dir, 'LLDB.framework', 'Versions','Current','Headers','LLDB.h') header = os.path.join(self.lib_dir, 'LLDB.framework', 'Versions','Current','Headers','LLDB.h')
else: else:
header = os.path.join(os.environ["LLDB_SRC"], "include", "lldb", "API", "LLDB.h") header = os.path.join(os.environ["LLDB_SRC"], "include", "lldb", "API", "LLDB.h")
platform = sys.platform platform = sys.platform
if not os.path.exists(header): if not os.path.exists(header):
self.skipTest("skip because LLDB.h header not found") self.skipTest("skip because LLDB.h header not found")
else: else:
func(*args, **kwargs) func(*args, **kwargs)
return wrapper return wrapper
def skipIfFreeBSD(func):
"""Decorate the item to skip tests that should be skipped on FreeBSD."""
return skipIfPlatform(["freebsd"])(func)
def skipIfDarwin(func):
"""Decorate the item to skip tests that should be skipped on Darwin."""
return skipIfPlatform(["darwin", "macosx"])(func)
def skipIfLinux(func):
"""Decorate the item to skip tests that should be skipped on Linux."""
return skipIfPlatform(["linux"])(func)
def skipIfWindows(func): def skipIfWindows(func):
"""Decorate the item to skip tests that should be skipped on Windows.""" """Decorate the item to skip tests that should be skipped on Windows."""
if isinstance(func, type) and issubclass(func, unittest2.TestCase): return skipIfPlatform(["windows"])(func)
raise Exception("@skipIfWindows can only be used to decorate a test method")
def skipUnlessDarwin(func):
"""Decorate the item to skip tests that should be skipped on any non Darwin platform."""
return skipUnlessPlatform(["darwin", "macosx"])(func)
def skipIfPlatform(oslist):
"""Decorate the item to skip tests if running on one of the listed platforms."""
def decorator(func):
@wraps(func) @wraps(func)
def wrapper(*args, **kwargs): def wrapper(*args, **kwargs):
from unittest2 import case from unittest2 import case
self = args[0] self = args[0]
platform = lldb.DBG.GetSelectedPlatform().GetTriple().split('-')[2] if self.getPlatform() in oslist:
if "windows" in platform: self.skipTest("skip on %s" % (", ".join(oslist)))
self.skipTest("skip on Windows")
else: else:
func(*args, **kwargs) func(*args, **kwargs)
return wrapper return wrapper
return decorator
def skipIfDarwin(func): def skipUnlessPlatform(oslist):
"""Decorate the item to skip tests that should be skipped on Darwin.""" """Decorate the item to skip tests unless running on one of the listed platforms."""
if isinstance(func, type) and issubclass(func, unittest2.TestCase): def decorator(func):
raise Exception("@skipIfDarwin can only be used to decorate a test method")
@wraps(func) @wraps(func)
def wrapper(*args, **kwargs): def wrapper(*args, **kwargs):
from unittest2 import case from unittest2 import case
self = args[0] self = args[0]
platform = lldb.DBG.GetSelectedPlatform().GetTriple().split('-')[2] if not (self.getPlatform() in oslist):
if "darwin" in platform or "macosx" in platform: self.skipTest("requires one of %s" % (", ".join(oslist)))
self.skipTest("skip on darwin")
else: else:
func(*args, **kwargs) func(*args, **kwargs)
return wrapper return wrapper
return decorator
def skipIfLinuxClang(func): def skipIfLinuxClang(func):
"""Decorate the item to skip tests that should be skipped if building on """Decorate the item to skip tests that should be skipped if building on
Linux with clang. Linux with clang.
""" """
if isinstance(func, type) and issubclass(func, unittest2.TestCase): if isinstance(func, type) and issubclass(func, unittest2.TestCase):
raise Exception("@skipIfLinuxClang can only be used to decorate a test method") raise Exception("@skipIfLinuxClang can only be used to decorate a test method")
@wraps(func) @wraps(func)
▲ Show 20 Lines • Show All 664 Lines • ▼ Show 20 Lines def getCompilerVersion(self):
compiler = self.getCompilerBinary() compiler = self.getCompilerBinary()
version_output = system([[which(compiler), "-v"]])[1] version_output = system([[which(compiler), "-v"]])[1]
for line in version_output.split(os.linesep): for line in version_output.split(os.linesep):
m = re.search('version ([0-9\.]+)', line) m = re.search('version ([0-9\.]+)', line)
if m: if m:
version = m.group(1) version = m.group(1)
return version return version
def getPlatform(self):
"""Returns the platform the test suite is running on."""
return lldb.DBG.GetSelectedPlatform().GetTriple().split('-')[2]
def isIntelCompiler(self): def isIntelCompiler(self):
""" Returns true if using an Intel (ICC) compiler, false otherwise. """ """ Returns true if using an Intel (ICC) compiler, false otherwise. """
return any([x in self.getCompiler() for x in ["icc", "icpc", "icl"]]) return any([x in self.getCompiler() for x in ["icc", "icpc", "icl"]])
def expectedCompilerVersion(self, compiler_version): def expectedCompilerVersion(self, compiler_version):
"""Returns True iff compiler_version[1] matches the current compiler version. """Returns True iff compiler_version[1] matches the current compiler version.
Use compiler_version[0] to specify the operator used to determine if a match has occurred. Use compiler_version[0] to specify the operator used to determine if a match has occurred.
Any operator other than the following defaults to an equality test: Any operator other than the following defaults to an equality test:
▲ Show 20 Lines • Show All 801 Lines • Show Last 20 Lines

test/logging/TestLogging.py

Show All 14 Linesclass LogTestCase(TestBase):
@classmethod @classmethod
def classCleanup(cls): def classCleanup(cls):
"""Cleanup the test byproducts.""" """Cleanup the test byproducts."""
cls.RemoveTempFile(cls.truncate_log_file) cls.RemoveTempFile(cls.truncate_log_file)
cls.RemoveTempFile(cls.append_log_file) cls.RemoveTempFile(cls.append_log_file)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym (self): def test_with_dsym (self):
self.buildDsym () self.buildDsym ()
self.command_log_tests ("dsym") self.command_log_tests ("dsym")
@dwarf_test @dwarf_test
def test_with_dwarf (self): def test_with_dwarf (self):
self.buildDwarf () self.buildDwarf ()
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

test/macosx/add-dsym/TestAddDsymMidExecutionCommand.py

"""Test that the 'add-dsym', aka 'target symbols add', succeeds in the middle of debug session.""" """Test that the 'add-dsym', aka 'target symbols add', succeeds in the middle of debug session."""
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
import sys import sys
from lldbtest import * from lldbtest import *
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
class AddDsymMidExecutionCommandCase(TestBase): class AddDsymMidExecutionCommandCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
self.source = 'main.c' self.source = 'main.c'
Show All 30 Lines

test/macosx/debug-info/apple_types/TestAppleTypesIsProduced.py

""" """
Test that clang produces the __apple accelerator tables, for example, __apple_types, correctly. Test that clang produces the __apple accelerator tables, for example, __apple_types, correctly.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
from lldbutil import symbol_type_to_str from lldbutil import symbol_type_to_str
class AppleTypesTestCase(TestBase): class AppleTypesTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
#rdar://problem/11166975 #rdar://problem/11166975
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
def test_debug_info_for_apple_types(self): def test_debug_info_for_apple_types(self):
"""Test that __apple_types section does get produced by clang.""" """Test that __apple_types section does get produced by clang."""
if not self.getCompiler().endswith('clang'): if not self.getCompiler().endswith('clang'):
self.skipTest("clang compiler only test") self.skipTest("clang compiler only test")
self.buildDefault() self.buildDefault()
self.apple_types(dot_o=True) self.apple_types(dot_o=True)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
def test_debug_info_for_apple_types_dsym(self): def test_debug_info_for_apple_types_dsym(self):
"""Test that __apple_types section does get produced by dsymutil. """Test that __apple_types section does get produced by dsymutil.
This is supposed to succeed even with rdar://problem/11166975.""" This is supposed to succeed even with rdar://problem/11166975."""
if not self.getCompiler().endswith('clang'): if not self.getCompiler().endswith('clang'):
self.skipTest("clang compiler only test") self.skipTest("clang compiler only test")
self.buildDsym() self.buildDsym()
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

test/macosx/indirect_symbol/TestIndirectSymbols.py

"""Test stepping and setting breakpoints in indirect and re-exported symbols.""" """Test stepping and setting breakpoints in indirect and re-exported symbols."""
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
import lldbutil import lldbutil
from lldbtest import * from lldbtest import *
class TestIndirectFunctions(TestBase): class TestIndirectFunctions(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym_and_python_api(self): def test_with_dsym_and_python_api(self):
"""Test stepping and setting breakpoints in indirect and re-exported symbols.""" """Test stepping and setting breakpoints in indirect and re-exported symbols."""
self.buildDsym() self.buildDsym()
self.indirect_stepping() self.indirect_stepping()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_with_dwarf_and_python_api(self): def test_with_dwarf_and_python_api(self):
"""Test stepping and setting breakpoints in indirect and re-exported symbols.""" """Test stepping and setting breakpoints in indirect and re-exported symbols."""
self.buildDwarf() self.buildDwarf()
self.indirect_stepping() self.indirect_stepping()
def setUp(self): def setUp(self):
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

test/macosx/order/TestOrderFile.py

""" """
Test that debug symbols have the correct order as specified by the order file. Test that debug symbols have the correct order as specified by the order file.
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
class OrderFileTestCase(TestBase): class OrderFileTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test debug symbols follow the correct order by the order file.""" """Test debug symbols follow the correct order by the order file."""
self.buildDsym() self.buildDsym()
self.order_file() self.order_file()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dwarf_test @dwarf_test
def test_with_dwarf(self): def test_with_dwarf(self):
"""Test debug symbols follow the correct order by the order file.""" """Test debug symbols follow the correct order by the order file."""
self.buildDwarf() self.buildDwarf()
self.order_file() self.order_file()
def order_file(self): def order_file(self):
"""Test debug symbols follow the correct order by the order file.""" """Test debug symbols follow the correct order by the order file."""
Show All 22 Lines

test/macosx/queues/TestQueues.py

"""Test queues inspection SB APIs.""" """Test queues inspection SB APIs."""
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
import lldbutil import lldbutil
from lldbtest import * from lldbtest import *
class TestQueues(TestBase): class TestQueues(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym_and_python_api(self): def test_with_dsym_and_python_api(self):
"""Test queues inspection SB APIs.""" """Test queues inspection SB APIs."""
self.buildDsym() self.buildDsym()
self.queues() self.queues()
self.queues_with_libBacktraceRecording() self.queues_with_libBacktraceRecording()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_with_dwarf_and_python_api(self): def test_with_dwarf_and_python_api(self):
"""Test queues inspection SB APIs.""" """Test queues inspection SB APIs."""
self.buildDwarf() self.buildDwarf()
self.queues() self.queues()
self.queues_with_libBacktraceRecording() self.queues_with_libBacktraceRecording()
▲ Show 20 Lines • Show All 180 Lines • Show Last 20 Lines

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

"""Test function call thread safety.""" """Test function call thread safety."""
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
import lldbutil import lldbutil
from lldbtest import * from lldbtest import *
class TestSafeFuncCalls(TestBase): class TestSafeFuncCalls(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym_and_python_api(self): def test_with_dsym_and_python_api(self):
"""Test function call thread safety.""" """Test function call thread safety."""
self.buildDsym() self.buildDsym()
self.function_call_safety_check() self.function_call_safety_check()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_with_dwarf_and_python_api(self): def test_with_dwarf_and_python_api(self):
"""Test function call thread safety.""" """Test function call thread safety."""
self.buildDwarf() self.buildDwarf()
self.function_call_safety_check() self.function_call_safety_check()
def setUp(self): def setUp(self):
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

test/macosx/universal/TestUniversal.py

Show All 11 Linesclass UniversalTestCase(TestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break inside main(). # Find the line number to break inside main().
self.line = line_number('main.c', '// Set break point at this line.') self.line = line_number('main.c', '// Set break point at this line.')
@python_api_test @python_api_test
@unittest2.skipUnless(sys.platform.startswith("darwin") and os.uname()[4] in ['i386', 'x86_64'], @skipUnlessDarwin
"requires Darwin & i386") @unittest2.skipUnless(os.uname()[4] in ['i386', 'x86_64'], "requires i386 or x86_64")
def test_sbdebugger_create_target_with_file_and_target_triple(self): def test_sbdebugger_create_target_with_file_and_target_triple(self):
"""Test the SBDebugger.CreateTargetWithFileAndTargetTriple() API.""" """Test the SBDebugger.CreateTargetWithFileAndTargetTriple() API."""
# Invoke the default build rule. # Invoke the default build rule.
self.buildDefault() self.buildDefault()
# Note that "testit" is a universal binary. # Note that "testit" is a universal binary.
exe = os.path.join(os.getcwd(), "testit") exe = os.path.join(os.getcwd(), "testit")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTargetWithFileAndTargetTriple(exe, "i386-apple-macosx") target = self.dbg.CreateTargetWithFileAndTargetTriple(exe, "i386-apple-macosx")
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Now launch the process, and do not stop at entry point. # Now launch the process, and do not stop at entry point.
process = target.LaunchSimple (None, None, self.get_process_working_directory()) process = target.LaunchSimple (None, None, self.get_process_working_directory())
self.assertTrue(process, PROCESS_IS_VALID) self.assertTrue(process, PROCESS_IS_VALID)
@unittest2.skipUnless(sys.platform.startswith("darwin") and os.uname()[4] in ['i386', 'x86_64'], @skipUnlessDarwin
"requires Darwin & i386") @unittest2.skipUnless(os.uname()[4] in ['i386', 'x86_64'], "requires i386 or x86_64")
def test_process_launch_for_universal(self): def test_process_launch_for_universal(self):
"""Test process launch of a universal binary.""" """Test process launch of a universal binary."""
from lldbutil import print_registers from lldbutil import print_registers
# Invoke the default build rule. # Invoke the default build rule.
self.buildDefault() self.buildDefault()
# Note that "testit" is a universal binary. # Note that "testit" is a universal binary.
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

test/python_api/breakpoint/TestBreakpointAPI.py

""" """
Test SBBreakpoint APIs. Test SBBreakpoint APIs.
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
from lldbtest import * from lldbtest import *
class BreakpointAPITestCase(TestBase): class BreakpointAPITestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_breakpoint_is_valid_with_dsym(self): def test_breakpoint_is_valid_with_dsym(self):
"""Make sure that if an SBBreakpoint gets deleted its IsValid returns false.""" """Make sure that if an SBBreakpoint gets deleted its IsValid returns false."""
self.buildDsym() self.buildDsym()
self.breakpoint_is_valid() self.breakpoint_is_valid()
@python_api_test @python_api_test
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

test/python_api/class_members/TestSBTypeClassMembers.py

""" """
Test SBType APIs to fetch member function types. Test SBType APIs to fetch member function types.
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
from lldbtest import * from lldbtest import *
class SBTypeMemberFunctionsTest(TestBase): class SBTypeMemberFunctionsTest(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test SBType APIs to fetch member function types.""" """Test SBType APIs to fetch member function types."""
d = {'EXE': self.exe_name} d = {'EXE': self.exe_name}
self.buildDsym(dictionary=d) self.buildDsym(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
self.type_api(self.exe_name) self.type_api(self.exe_name)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_with_dwarf(self): def test_with_dwarf(self):
"""Test SBType APIs to fetch member function types.""" """Test SBType APIs to fetch member function types."""
d = {'EXE': self.exe_name} d = {'EXE': self.exe_name}
self.buildDwarf(dictionary=d) self.buildDwarf(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
self.type_api(self.exe_name) self.type_api(self.exe_name)
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

test/python_api/event/TestEvents.py

""" """
Test lldb Python event APIs. Test lldb Python event APIs.
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
from lldbtest import * from lldbtest import *
class EventAPITestCase(TestBase): class EventAPITestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_listen_for_and_print_event_with_dsym(self): def test_listen_for_and_print_event_with_dsym(self):
"""Exercise SBEvent API.""" """Exercise SBEvent API."""
self.buildDsym() self.buildDsym()
self.do_listen_for_and_print_event() self.do_listen_for_and_print_event()
@unittest2.skipUnless((sys.platform.startswith("darwin") or @skipUnlessPlatform(["darwin", "macosx", "freebsd"])
sys.platform.startswith("freebsd")),
"requires Darwin or FreeBSD")
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_listen_for_and_print_event_with_dwarf(self): def test_listen_for_and_print_event_with_dwarf(self):
"""Exercise SBEvent API.""" """Exercise SBEvent API."""
self.buildDwarf() self.buildDwarf()
self.do_listen_for_and_print_event() self.do_listen_for_and_print_event()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_wait_for_event_with_dsym(self): def test_wait_for_event_with_dsym(self):
"""Exercise SBListener.WaitForEvent() API.""" """Exercise SBListener.WaitForEvent() API."""
self.buildDsym() self.buildDsym()
self.do_wait_for_event() self.do_wait_for_event()
@skipIfLinux # non-core functionality, need to reenable and fix later (DES 2014.11.07) @skipIfLinux # non-core functionality, need to reenable and fix later (DES 2014.11.07)
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_wait_for_event_with_dwarf(self): def test_wait_for_event_with_dwarf(self):
"""Exercise SBListener.WaitForEvent() API.""" """Exercise SBListener.WaitForEvent() API."""
self.buildDwarf() self.buildDwarf()
self.do_wait_for_event() self.do_wait_for_event()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_add_listener_to_broadcaster_with_dsym(self): def test_add_listener_to_broadcaster_with_dsym(self):
"""Exercise some SBBroadcaster APIs.""" """Exercise some SBBroadcaster APIs."""
self.buildDsym() self.buildDsym()
self.do_add_listener_to_broadcaster() self.do_add_listener_to_broadcaster()
@skipIfFreeBSD # llvm.org/pr21325 @skipIfFreeBSD # llvm.org/pr21325
▲ Show 20 Lines • Show All 262 Lines • Show Last 20 Lines

test/python_api/findvalue_duplist/TestSBFrameFindValue.py

"""Test that SBFrame::FindValue finds things but does not duplicate the entire variables list""" """Test that SBFrame::FindValue finds things but does not duplicate the entire variables list"""
import os, sys, time import os, sys, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class SBFrameFindValueTestCase(TestBase): class SBFrameFindValueTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym_formatters_api(self): def test_with_dsym_formatters_api(self):
"""Test that SBFrame::FindValue finds things but does not duplicate the entire variables list""" """Test that SBFrame::FindValue finds things but does not duplicate the entire variables list"""
self.buildDsym() self.buildDsym()
self.setTearDownCleanup() self.setTearDownCleanup()
self.commands() self.commands()
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

test/python_api/formatters/TestFormattersSBAPI.py

"""Test Python APIs for working with formatters""" """Test Python APIs for working with formatters"""
import os, sys, time import os, sys, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class SBFormattersAPITestCase(TestBase): class SBFormattersAPITestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym_formatters_api(self): def test_with_dsym_formatters_api(self):
"""Test Python APIs for working with formatters""" """Test Python APIs for working with formatters"""
self.buildDsym() self.buildDsym()
self.setTearDownCleanup() self.setTearDownCleanup()
self.formatters() self.formatters()
▲ Show 20 Lines • Show All 333 Lines • Show Last 20 Lines

test/python_api/frame/TestFrames.py

""" """
Use lldb Python SBFrame API to get the argument values of the call stacks. Use lldb Python SBFrame API to get the argument values of the call stacks.
And other SBFrame API tests. And other SBFrame API tests.
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
from lldbtest import * from lldbtest import *
class FrameAPITestCase(TestBase): class FrameAPITestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_get_arg_vals_for_call_stack_with_dsym(self): def test_get_arg_vals_for_call_stack_with_dsym(self):
"""Exercise SBFrame.GetVariables() API to get argument vals.""" """Exercise SBFrame.GetVariables() API to get argument vals."""
self.buildDsym() self.buildDsym()
self.do_get_arg_vals() self.do_get_arg_vals()
@python_api_test @python_api_test
▲ Show 20 Lines • Show All 202 Lines • Show Last 20 Lines

test/python_api/frame/inlines/TestInlinedFrame.py

""" """
Testlldb Python SBFrame APIs IsInlined() and GetFunctionName(). Testlldb Python SBFrame APIs IsInlined() and GetFunctionName().
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
from lldbtest import * from lldbtest import *
class InlinedFrameAPITestCase(TestBase): class InlinedFrameAPITestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_stop_at_outer_inline_with_dsym(self): def test_stop_at_outer_inline_with_dsym(self):
"""Exercise SBFrame.IsInlined() and SBFrame.GetFunctionName().""" """Exercise SBFrame.IsInlined() and SBFrame.GetFunctionName()."""
self.buildDsym() self.buildDsym()
self.do_stop_at_outer_inline() self.do_stop_at_outer_inline()
@python_api_test @python_api_test
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

test/python_api/function_symbol/TestDisasmAPI.py

""" """
Test retrieval of SBAddress from function/symbol, disassembly, and SBAddress APIs. Test retrieval of SBAddress from function/symbol, disassembly, and SBAddress APIs.
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
from lldbtest import * from lldbtest import *
class DisasmAPITestCase(TestBase): class DisasmAPITestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Exercise getting SBAddress objects, disassembly, and SBAddress APIs.""" """Exercise getting SBAddress objects, disassembly, and SBAddress APIs."""
self.buildDsym() self.buildDsym()
self.disasm_and_address_api() self.disasm_and_address_api()
@python_api_test @python_api_test
▲ Show 20 Lines • Show All 104 Lines • Show Last 20 Lines

test/python_api/function_symbol/TestSymbolAPI.py

""" """
Test newly added SBSymbol and SBAddress APIs. Test newly added SBSymbol and SBAddress APIs.
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
from lldbtest import * from lldbtest import *
class SymbolAPITestCase(TestBase): class SymbolAPITestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Exercise some SBSymbol and SBAddress APIs.""" """Exercise some SBSymbol and SBAddress APIs."""
self.buildDsym() self.buildDsym()
self.symbol_and_address_api() self.symbol_and_address_api()
@python_api_test @python_api_test
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

test/python_api/hello_world/TestHelloWorld.py

"""Test Python APIs for target (launch and attach), breakpoint, and process.""" """Test Python APIs for target (launch and attach), breakpoint, and process."""
import os, sys, time import os, sys, time
import unittest2 import unittest2
import lldb import lldb
import time import time
from lldbtest import * from lldbtest import *
class HelloWorldTestCase(TestBase): class HelloWorldTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym_and_process_launch_api(self): def test_with_dsym_and_process_launch_api(self):
"""Create target, breakpoint, launch a process, and then kill it. """Create target, breakpoint, launch a process, and then kill it.
Use dsym info and process launch API. Use dsym info and process launch API.
""" """
self.buildDsym(dictionary=self.d) self.buildDsym(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
self.hello_world_python() self.hello_world_python()
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_with_dwarf_and_process_launch_api(self): def test_with_dwarf_and_process_launch_api(self):
"""Create target, breakpoint, launch a process, and then kill it. """Create target, breakpoint, launch a process, and then kill it.
Use dwarf debug map and process launch API. Use dwarf debug map and process launch API.
""" """
self.buildDwarf(dictionary=self.d) self.buildDwarf(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
self.hello_world_python() self.hello_world_python()
@not_remote_testsuite_ready @not_remote_testsuite_ready
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym_and_attach_to_process_with_id_api(self): def test_with_dsym_and_attach_to_process_with_id_api(self):
"""Create target, spawn a process, and attach to it with process id. """Create target, spawn a process, and attach to it with process id.
Use dsym info and attach to process with id API. Use dsym info and attach to process with id API.
""" """
self.buildDsym(dictionary=self.d) self.buildDsym(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
self.hello_world_attach_with_id_api() self.hello_world_attach_with_id_api()
@python_api_test @python_api_test
@dwarf_test @dwarf_test
@expectedFailurei386 # llvm.org/pr17384: lldb needs to be aware of linux-vdso.so to unwind stacks properly @expectedFailurei386 # llvm.org/pr17384: lldb needs to be aware of linux-vdso.so to unwind stacks properly
def test_with_dwarf_and_attach_to_process_with_id_api(self): def test_with_dwarf_and_attach_to_process_with_id_api(self):
"""Create target, spawn a process, and attach to it with process id. """Create target, spawn a process, and attach to it with process id.
Use dwarf map (no dsym) and attach to process with id API. Use dwarf map (no dsym) and attach to process with id API.
""" """
self.buildDwarf(dictionary=self.d) self.buildDwarf(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
self.hello_world_attach_with_id_api() self.hello_world_attach_with_id_api()
@not_remote_testsuite_ready @not_remote_testsuite_ready
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym_and_attach_to_process_with_name_api(self): def test_with_dsym_and_attach_to_process_with_name_api(self):
"""Create target, spawn a process, and attach to it with process name. """Create target, spawn a process, and attach to it with process name.
Use dsym info and attach to process with name API. Use dsym info and attach to process with name API.
""" """
self.buildDsym(dictionary=self.d) self.buildDsym(dictionary=self.d)
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

test/python_api/interpreter/TestCommandInterpreterAPI.py

"""Test the SBCommandInterpreter APIs.""" """Test the SBCommandInterpreter APIs."""
import os import os
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
class CommandInterpreterAPICase(TestBase): class CommandInterpreterAPICase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym_and_process_launch_api(self): def test_with_dsym_and_process_launch_api(self):
"""Test the SBCommandInterpreter APIs.""" """Test the SBCommandInterpreter APIs."""
self.buildDsym() self.buildDsym()
self.command_interpreter_api() self.command_interpreter_api()
@python_api_test @python_api_test
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

test/python_api/objc_type/TestObjCType.py

""" """
Test SBType for ObjC classes. Test SBType for ObjC classes.
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
from lldbtest import * from lldbtest import *
class ObjCSBTypeTestCase(TestBase): class ObjCSBTypeTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test SBType for ObjC classes.""" """Test SBType for ObjC classes."""
self.buildDsym() self.buildDsym()
self.objc_sbtype_test() self.objc_sbtype_test()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_with_dwarf(self): def test_with_dwarf(self):
"""Test SBType for ObjC classes.""" """Test SBType for ObjC classes."""
self.buildDwarf() self.buildDwarf()
self.objc_sbtype_test() self.objc_sbtype_test()
def setUp(self): def setUp(self):
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

test/python_api/process/TestProcessAPI.py

""" """
Test SBProcess APIs, including ReadMemory(), WriteMemory(), and others. Test SBProcess APIs, including ReadMemory(), WriteMemory(), and others.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbutil import get_stopped_thread, state_type_to_str from lldbutil import get_stopped_thread, state_type_to_str
from lldbtest import * from lldbtest import *
class ProcessAPITestCase(TestBase): class ProcessAPITestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_read_memory_with_dsym(self): def test_read_memory_with_dsym(self):
"""Test Python SBProcess.ReadMemory() API.""" """Test Python SBProcess.ReadMemory() API."""
self.buildDsym() self.buildDsym()
self.read_memory() self.read_memory()
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_read_memory_with_dwarf(self): def test_read_memory_with_dwarf(self):
"""Test Python SBProcess.ReadMemory() API.""" """Test Python SBProcess.ReadMemory() API."""
self.buildDwarf() self.buildDwarf()
self.read_memory() self.read_memory()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_write_memory_with_dsym(self): def test_write_memory_with_dsym(self):
"""Test Python SBProcess.WriteMemory() API.""" """Test Python SBProcess.WriteMemory() API."""
self.buildDsym() self.buildDsym()
self.write_memory() self.write_memory()
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_write_memory_with_dwarf(self): def test_write_memory_with_dwarf(self):
"""Test Python SBProcess.WriteMemory() API.""" """Test Python SBProcess.WriteMemory() API."""
self.buildDwarf() self.buildDwarf()
self.write_memory() self.write_memory()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_access_my_int_with_dsym(self): def test_access_my_int_with_dsym(self):
"""Test access 'my_int' using Python SBProcess.GetByteOrder() and other APIs.""" """Test access 'my_int' using Python SBProcess.GetByteOrder() and other APIs."""
self.buildDsym() self.buildDsym()
self.access_my_int() self.access_my_int()
@python_api_test @python_api_test
▲ Show 20 Lines • Show All 286 Lines • Show Last 20 Lines

test/python_api/process/io/TestProcessIO.py

"""Test Python APIs for process IO.""" """Test Python APIs for process IO."""
import os, sys, time import os, sys, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class ProcessIOTestCase(TestBase): class ProcessIOTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "dsym requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_stdin_by_api_with_dsym(self): def test_stdin_by_api_with_dsym(self):
"""Exercise SBProcess.PutSTDIN().""" """Exercise SBProcess.PutSTDIN()."""
self.buildDsym() self.buildDsym()
self.do_stdin_by_api() self.do_stdin_by_api()
@unittest2.skipIf(sys.platform.startswith("win32"), "stdio manipulation unsupported on Windows") @skipIfWindows # stdio manipulation unsupported on Windows
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_stdin_by_api_with_dwarf(self): def test_stdin_by_api_with_dwarf(self):
"""Exercise SBProcess.PutSTDIN().""" """Exercise SBProcess.PutSTDIN()."""
self.buildDwarf() self.buildDwarf()
self.do_stdin_by_api() self.do_stdin_by_api()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "dsym requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_stdin_redirection_with_dsym(self): def test_stdin_redirection_with_dsym(self):
"""Exercise SBLaunchInfo::AddOpenFileAction() for STDIN without specifying STDOUT or STDERR.""" """Exercise SBLaunchInfo::AddOpenFileAction() for STDIN without specifying STDOUT or STDERR."""
self.buildDsym() self.buildDsym()
self.do_stdin_redirection() self.do_stdin_redirection()
@unittest2.skipIf(sys.platform.startswith("win32"), "stdio manipulation unsupported on Windows") @skipIfWindows # stdio manipulation unsupported on Windows
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_stdin_redirection_with_dwarf(self): def test_stdin_redirection_with_dwarf(self):
"""Exercise SBLaunchInfo::AddOpenFileAction() for STDIN without specifying STDOUT or STDERR.""" """Exercise SBLaunchInfo::AddOpenFileAction() for STDIN without specifying STDOUT or STDERR."""
self.buildDwarf() self.buildDwarf()
self.do_stdin_redirection() self.do_stdin_redirection()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "dsym requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_stdout_redirection_with_dsym(self): def test_stdout_redirection_with_dsym(self):
"""Exercise SBLaunchInfo::AddOpenFileAction() for STDOUT without specifying STDIN or STDERR.""" """Exercise SBLaunchInfo::AddOpenFileAction() for STDOUT without specifying STDIN or STDERR."""
self.buildDsym() self.buildDsym()
self.do_stdout_redirection() self.do_stdout_redirection()
@unittest2.skipIf(sys.platform.startswith("win32"), "stdio manipulation unsupported on Windows") @skipIfWindows # stdio manipulation unsupported on Windows
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_stdout_redirection_with_dwarf(self): def test_stdout_redirection_with_dwarf(self):
"""Exercise SBLaunchInfo::AddOpenFileAction() for STDOUT without specifying STDIN or STDERR.""" """Exercise SBLaunchInfo::AddOpenFileAction() for STDOUT without specifying STDIN or STDERR."""
self.buildDwarf() self.buildDwarf()
self.do_stdout_redirection() self.do_stdout_redirection()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "dsym requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_stderr_redirection_with_dsym(self): def test_stderr_redirection_with_dsym(self):
"""Exercise SBLaunchInfo::AddOpenFileAction() for STDERR without specifying STDIN or STDOUT.""" """Exercise SBLaunchInfo::AddOpenFileAction() for STDERR without specifying STDIN or STDOUT."""
self.buildDsym() self.buildDsym()
self.do_stderr_redirection() self.do_stderr_redirection()
@unittest2.skipIf(sys.platform.startswith("win32"), "stdio manipulation unsupported on Windows") @skipIfWindows # stdio manipulation unsupported on Windows
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_stderr_redirection_with_dwarf(self): def test_stderr_redirection_with_dwarf(self):
"""Exercise SBLaunchInfo::AddOpenFileAction() for STDERR without specifying STDIN or STDOUT.""" """Exercise SBLaunchInfo::AddOpenFileAction() for STDERR without specifying STDIN or STDOUT."""
self.buildDwarf() self.buildDwarf()
self.do_stderr_redirection() self.do_stderr_redirection()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "dsym requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_stdout_stderr_redirection_with_dsym(self): def test_stdout_stderr_redirection_with_dsym(self):
"""Exercise SBLaunchInfo::AddOpenFileAction() for STDOUT and STDERR without redirecting STDIN.""" """Exercise SBLaunchInfo::AddOpenFileAction() for STDOUT and STDERR without redirecting STDIN."""
self.buildDsym() self.buildDsym()
self.do_stdout_stderr_redirection() self.do_stdout_stderr_redirection()
@unittest2.skipIf(sys.platform.startswith("win32"), "stdio manipulation unsupported on Windows") @skipIfWindows # stdio manipulation unsupported on Windows
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_stdout_stderr_redirection_with_dwarf(self): def test_stdout_stderr_redirection_with_dwarf(self):
"""Exercise SBLaunchInfo::AddOpenFileAction() for STDOUT and STDERR without redirecting STDIN.""" """Exercise SBLaunchInfo::AddOpenFileAction() for STDOUT and STDERR without redirecting STDIN."""
self.buildDwarf() self.buildDwarf()
self.do_stdout_stderr_redirection() self.do_stdout_stderr_redirection()
def setUp(self): def setUp(self):
▲ Show 20 Lines • Show All 193 Lines • Show Last 20 Lines

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

""" """
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.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class Radar12481949DataFormatterTestCase(TestBase): class Radar12481949DataFormatterTestCase(TestBase):
# test for rdar://problem/12481949 # test for rdar://problem/12481949
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Check that SBValue.GetValueAsSigned() does the right thing for a 32-bit -1.""" """Check that SBValue.GetValueAsSigned() does the right thing for a 32-bit -1."""
self.buildDsym() self.buildDsym()
self.rdar12481949_commands() self.rdar12481949_commands()
@dwarf_test @dwarf_test
def test_with_dwarf_and_run_command(self): def test_with_dwarf_and_run_command(self):
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

test/python_api/sbdata/TestSBData.py

"""Test the SBData APIs.""" """Test the SBData APIs."""
import os import os
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
from math import fabs from math import fabs
import lldbutil import lldbutil
class SBDataAPICase(TestBase): class SBDataAPICase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test the SBData APIs.""" """Test the SBData APIs."""
self.buildDsym() self.buildDsym()
self.data_api() self.data_api()
@python_api_test @python_api_test
▲ Show 20 Lines • Show All 316 Lines • Show Last 20 Lines

test/python_api/sbvalue_persist/TestSBValuePersist.py

"""Test SBValue::Persist""" """Test SBValue::Persist"""
import os, sys, time import os, sys, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
import lldbutil import lldbutil
class SBValuePersistTestCase(TestBase): class SBValuePersistTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test SBValue::Persist""" """Test SBValue::Persist"""
self.buildDsym() self.buildDsym()
self.setTearDownCleanup() self.setTearDownCleanup()
self.doTest() self.doTest()
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

test/python_api/section/TestSectionAPI.py

""" """
Test SBSection APIs. Test SBSection APIs.
""" """
import unittest2 import unittest2
from lldbtest import * from lldbtest import *
class SectionAPITestCase(TestBase): class SectionAPITestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_get_target_byte_size_with_dsym(self): def test_get_target_byte_size_with_dsym(self):
d = {'EXE': 'a.out'} d = {'EXE': 'a.out'}
self.buildDsym(dictionary=d) self.buildDsym(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
target = self.create_simple_target('a.out') target = self.create_simple_target('a.out')
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

test/python_api/symbol-context/TestSymbolContext.py

""" """
Test SBSymbolContext APIs. Test SBSymbolContext APIs.
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
from lldbtest import * from lldbtest import *
class SymbolContextAPITestCase(TestBase): class SymbolContextAPITestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Exercise SBSymbolContext API extensively.""" """Exercise SBSymbolContext API extensively."""
self.buildDsym() self.buildDsym()
self.symbol_context() self.symbol_context()
@python_api_test @python_api_test
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

test/python_api/target/TestTargetAPI.py

""" """
Test SBTarget APIs. Test SBTarget APIs.
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
from lldbtest import * from lldbtest import *
class TargetAPITestCase(TestBase): class TargetAPITestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_find_global_variables_with_dsym(self): def test_find_global_variables_with_dsym(self):
"""Exercise SBTaget.FindGlobalVariables() API.""" """Exercise SBTaget.FindGlobalVariables() API."""
d = {'EXE': 'a.out'} d = {'EXE': 'a.out'}
self.buildDsym(dictionary=d) self.buildDsym(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
self.find_global_variables('a.out') self.find_global_variables('a.out')
Show All 9 Linesclass TargetAPITestCase(TestBase):
@dwarf_test @dwarf_test
def test_find_global_variables_with_dwarf(self): def test_find_global_variables_with_dwarf(self):
"""Exercise SBTarget.FindGlobalVariables() API.""" """Exercise SBTarget.FindGlobalVariables() API."""
d = {'EXE': 'b.out'} d = {'EXE': 'b.out'}
self.buildDwarf(dictionary=d) self.buildDwarf(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
self.find_global_variables('b.out') self.find_global_variables('b.out')
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_find_functions_with_dsym(self): def test_find_functions_with_dsym(self):
"""Exercise SBTaget.FindFunctions() API.""" """Exercise SBTaget.FindFunctions() API."""
d = {'EXE': 'a.out'} d = {'EXE': 'a.out'}
self.buildDsym(dictionary=d) self.buildDsym(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
self.find_functions('a.out') self.find_functions('a.out')
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_find_functions_with_dwarf(self): def test_find_functions_with_dwarf(self):
"""Exercise SBTarget.FindFunctions() API.""" """Exercise SBTarget.FindFunctions() API."""
d = {'EXE': 'b.out'} d = {'EXE': 'b.out'}
self.buildDwarf(dictionary=d) self.buildDwarf(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
self.find_functions('b.out') self.find_functions('b.out')
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_get_description_with_dsym(self): def test_get_description_with_dsym(self):
"""Exercise SBTaget.GetDescription() API.""" """Exercise SBTaget.GetDescription() API."""
self.buildDsym() self.buildDsym()
self.get_description() self.get_description()
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_get_description_with_dwarf(self): def test_get_description_with_dwarf(self):
"""Exercise SBTarget.GetDescription() API.""" """Exercise SBTarget.GetDescription() API."""
self.buildDwarf() self.buildDwarf()
self.get_description() self.get_description()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
@expectedFailureDarwin("llvm.org/pr20273") @expectedFailureDarwin("llvm.org/pr20273")
def test_launch_new_process_and_redirect_stdout_with_dsym(self): def test_launch_new_process_and_redirect_stdout_with_dsym(self):
"""Exercise SBTaget.Launch() API.""" """Exercise SBTaget.Launch() API."""
self.buildDsym() self.buildDsym()
self.launch_new_process_and_redirect_stdout() self.launch_new_process_and_redirect_stdout()
@python_api_test @python_api_test
@dwarf_test @dwarf_test
@expectedFailureDarwin("llvm.org/pr20273") @expectedFailureDarwin("llvm.org/pr20273")
def test_launch_new_process_and_redirect_stdout_with_dwarf(self): def test_launch_new_process_and_redirect_stdout_with_dwarf(self):
"""Exercise SBTarget.Launch() API.""" """Exercise SBTarget.Launch() API."""
self.buildDwarf() self.buildDwarf()
self.launch_new_process_and_redirect_stdout() self.launch_new_process_and_redirect_stdout()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_resolve_symbol_context_with_address_with_dsym(self): def test_resolve_symbol_context_with_address_with_dsym(self):
"""Exercise SBTaget.ResolveSymbolContextForAddress() API.""" """Exercise SBTaget.ResolveSymbolContextForAddress() API."""
self.buildDsym() self.buildDsym()
self.resolve_symbol_context_with_address() self.resolve_symbol_context_with_address()
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_resolve_symbol_context_with_address_with_dwarf(self): def test_resolve_symbol_context_with_address_with_dwarf(self):
"""Exercise SBTarget.ResolveSymbolContextForAddress() API.""" """Exercise SBTarget.ResolveSymbolContextForAddress() API."""
self.buildDwarf() self.buildDwarf()
self.resolve_symbol_context_with_address() self.resolve_symbol_context_with_address()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_get_platform_with_dsym(self): def test_get_platform_with_dsym(self):
d = {'EXE': 'a.out'} d = {'EXE': 'a.out'}
self.buildDsym(dictionary=d) self.buildDsym(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
target = self.create_simple_target('a.out') target = self.create_simple_target('a.out')
platform = target.platform platform = target.platform
self.assertTrue(platform, VALID_PLATFORM) self.assertTrue(platform, VALID_PLATFORM)
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_get_platform_with_dwarf(self): def test_get_platform_with_dwarf(self):
d = {'EXE': 'b.out'} d = {'EXE': 'b.out'}
self.buildDwarf(dictionary=d) self.buildDwarf(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
target = self.create_simple_target('b.out') target = self.create_simple_target('b.out')
platform = target.platform platform = target.platform
self.assertTrue(platform, VALID_PLATFORM) self.assertTrue(platform, VALID_PLATFORM)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_get_data_byte_size_with_dsym(self): def test_get_data_byte_size_with_dsym(self):
d = {'EXE': 'a.out'} d = {'EXE': 'a.out'}
self.buildDsym(dictionary=d) self.buildDsym(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
target = self.create_simple_target('a.out') target = self.create_simple_target('a.out')
self.assertEquals(target.data_byte_size, 1) self.assertEquals(target.data_byte_size, 1)
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_get_data_byte_size_with_dwarf(self): def test_get_data_byte_size_with_dwarf(self):
d = {'EXE': 'b.out'} d = {'EXE': 'b.out'}
self.buildDwarf(dictionary=d) self.buildDwarf(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
target = self.create_simple_target('b.out') target = self.create_simple_target('b.out')
self.assertEquals(target.data_byte_size, 1) self.assertEquals(target.data_byte_size, 1)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_get_code_byte_size_with_dsym(self): def test_get_code_byte_size_with_dsym(self):
d = {'EXE': 'a.out'} d = {'EXE': 'a.out'}
self.buildDsym(dictionary=d) self.buildDsym(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
target = self.create_simple_target('a.out') target = self.create_simple_target('a.out')
self.assertEquals(target.code_byte_size, 1) self.assertEquals(target.code_byte_size, 1)
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_get_code_byte_size_with_dwarf(self): def test_get_code_byte_size_with_dwarf(self):
d = {'EXE': 'b.out'} d = {'EXE': 'b.out'}
self.buildDwarf(dictionary=d) self.buildDwarf(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
target = self.create_simple_target('b.out') target = self.create_simple_target('b.out')
self.assertEquals(target.code_byte_size, 1) self.assertEquals(target.code_byte_size, 1)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_resolve_file_address_with_dsym(self): def test_resolve_file_address_with_dsym(self):
d = {'EXE': 'a.out'} d = {'EXE': 'a.out'}
self.buildDsym(dictionary=d) self.buildDsym(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
target = self.create_simple_target('a.out') target = self.create_simple_target('a.out')
self.resolve_file_address(target) self.resolve_file_address(target)
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_resolve_file_address_with_dwarf(self): def test_resolve_file_address_with_dwarf(self):
d = {'EXE': 'b.out'} d = {'EXE': 'b.out'}
self.buildDwarf(dictionary=d) self.buildDwarf(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
target = self.create_simple_target('b.out') target = self.create_simple_target('b.out')
self.resolve_file_address(target) self.resolve_file_address(target)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_read_memory_with_dsym(self): def test_read_memory_with_dsym(self):
d = {'EXE': 'a.out'} d = {'EXE': 'a.out'}
self.buildDsym(dictionary=d) self.buildDsym(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
target = self.create_simple_target('a.out') target = self.create_simple_target('a.out')
self.read_memory(target) self.read_memory(target)
▲ Show 20 Lines • Show All 291 Lines • Show Last 20 Lines

test/python_api/thread/TestThreadAPI.py

""" """
Test SBThread APIs. Test SBThread APIs.
""" """
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbutil import get_stopped_thread, get_caller_symbol from lldbutil import get_stopped_thread, get_caller_symbol
from lldbtest import * from lldbtest import *
class ThreadAPITestCase(TestBase): class ThreadAPITestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_get_process_with_dsym(self): def test_get_process_with_dsym(self):
"""Test Python SBThread.GetProcess() API.""" """Test Python SBThread.GetProcess() API."""
self.buildDsym() self.buildDsym()
self.get_process() self.get_process()
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_get_process_with_dwarf(self): def test_get_process_with_dwarf(self):
"""Test Python SBThread.GetProcess() API.""" """Test Python SBThread.GetProcess() API."""
self.buildDwarf() self.buildDwarf()
self.get_process() self.get_process()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_get_stop_description_with_dsym(self): def test_get_stop_description_with_dsym(self):
"""Test Python SBThread.GetStopDescription() API.""" """Test Python SBThread.GetStopDescription() API."""
self.buildDsym() self.buildDsym()
self.get_stop_description() self.get_stop_description()
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_get_stop_description_with_dwarf(self): def test_get_stop_description_with_dwarf(self):
"""Test Python SBThread.GetStopDescription() API.""" """Test Python SBThread.GetStopDescription() API."""
self.buildDwarf() self.buildDwarf()
self.get_stop_description() self.get_stop_description()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_run_to_address_with_dsym(self): def test_run_to_address_with_dsym(self):
"""Test Python SBThread.RunToAddress() API.""" """Test Python SBThread.RunToAddress() API."""
# We build a different executable than the default buildDwarf() does. # We build a different executable than the default buildDwarf() does.
d = {'CXX_SOURCES': 'main2.cpp', 'EXE': self.exe_name} d = {'CXX_SOURCES': 'main2.cpp', 'EXE': self.exe_name}
self.buildDsym(dictionary=d) self.buildDsym(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
self.run_to_address(self.exe_name) self.run_to_address(self.exe_name)
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_run_to_address_with_dwarf(self): def test_run_to_address_with_dwarf(self):
"""Test Python SBThread.RunToAddress() API.""" """Test Python SBThread.RunToAddress() API."""
# We build a different executable than the default buildDwarf() does. # We build a different executable than the default buildDwarf() does.
d = {'CXX_SOURCES': 'main2.cpp', 'EXE': self.exe_name} d = {'CXX_SOURCES': 'main2.cpp', 'EXE': self.exe_name}
self.buildDwarf(dictionary=d) self.buildDwarf(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
self.run_to_address(self.exe_name) self.run_to_address(self.exe_name)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_step_out_of_malloc_into_function_b_with_dsym(self): def test_step_out_of_malloc_into_function_b_with_dsym(self):
"""Test Python SBThread.StepOut() API to step out of a malloc call where the call site is at function b().""" """Test Python SBThread.StepOut() API to step out of a malloc call where the call site is at function b()."""
# We build a different executable than the default buildDsym() does. # We build a different executable than the default buildDsym() does.
d = {'CXX_SOURCES': 'main2.cpp', 'EXE': self.exe_name} d = {'CXX_SOURCES': 'main2.cpp', 'EXE': self.exe_name}
self.buildDsym(dictionary=d) self.buildDsym(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
self.step_out_of_malloc_into_function_b(self.exe_name) self.step_out_of_malloc_into_function_b(self.exe_name)
@expectedFailureFreeBSD # llvm.org/pr20476 @expectedFailureFreeBSD # llvm.org/pr20476
@expectedFailureLinux # llvm.org/pr14416 @expectedFailureLinux # llvm.org/pr14416
@python_api_test @python_api_test
@dwarf_test @dwarf_test
def test_step_out_of_malloc_into_function_b_with_dwarf(self): def test_step_out_of_malloc_into_function_b_with_dwarf(self):
"""Test Python SBThread.StepOut() API to step out of a malloc call where the call site is at function b().""" """Test Python SBThread.StepOut() API to step out of a malloc call where the call site is at function b()."""
# We build a different executable than the default buildDwarf() does. # We build a different executable than the default buildDwarf() does.
d = {'CXX_SOURCES': 'main2.cpp', 'EXE': self.exe_name} d = {'CXX_SOURCES': 'main2.cpp', 'EXE': self.exe_name}
self.buildDwarf(dictionary=d) self.buildDwarf(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
self.step_out_of_malloc_into_function_b(self.exe_name) self.step_out_of_malloc_into_function_b(self.exe_name)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_step_over_3_times_with_dsym(self): def test_step_over_3_times_with_dsym(self):
"""Test Python SBThread.StepOver() API.""" """Test Python SBThread.StepOver() API."""
# We build a different executable than the default buildDsym() does. # We build a different executable than the default buildDsym() does.
d = {'CXX_SOURCES': 'main2.cpp', 'EXE': self.exe_name} d = {'CXX_SOURCES': 'main2.cpp', 'EXE': self.exe_name}
self.buildDsym(dictionary=d) self.buildDsym(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
▲ Show 20 Lines • Show All 207 Lines • Show Last 20 Lines

test/python_api/type/TestTypeList.py

""" """
Test SBType and SBTypeList API. Test SBType and SBTypeList API.
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
from lldbtest import * from lldbtest import *
class TypeAndTypeListTestCase(TestBase): class TypeAndTypeListTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Exercise SBType and SBTypeList API.""" """Exercise SBType and SBTypeList API."""
d = {'EXE': self.exe_name} d = {'EXE': self.exe_name}
self.buildDsym(dictionary=d) self.buildDsym(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
self.type_and_typelist_api(self.exe_name) self.type_and_typelist_api(self.exe_name)
▲ Show 20 Lines • Show All 105 Lines • Show Last 20 Lines

test/python_api/value/TestValueAPI.py

""" """
Test some SBValue APIs. Test some SBValue APIs.
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
from lldbtest import * from lldbtest import *
class ValueAPITestCase(TestBase): class ValueAPITestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Exercise some SBValue APIs.""" """Exercise some SBValue APIs."""
d = {'EXE': self.exe_name} d = {'EXE': self.exe_name}
self.buildDsym(dictionary=d) self.buildDsym(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
self.value_api(self.exe_name) self.value_api(self.exe_name)
▲ Show 20 Lines • Show All 122 Lines • Show Last 20 Lines

test/python_api/value/change_values/TestChangeValueAPI.py

""" """
Test some SBValue APIs. Test some SBValue APIs.
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
from lldbtest import * from lldbtest import *
class ChangeValueAPITestCase(TestBase): class ChangeValueAPITestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_change_value_with_dsym(self): def test_change_value_with_dsym(self):
"""Exercise the SBValue::SetValueFromCString API.""" """Exercise the SBValue::SetValueFromCString API."""
d = {'EXE': self.exe_name} d = {'EXE': self.exe_name}
self.buildDsym(dictionary=d) self.buildDsym(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
self.change_value_api(self.exe_name) self.change_value_api(self.exe_name)
▲ Show 20 Lines • Show All 144 Lines • Show Last 20 Lines

test/python_api/value/linked_list/TestValueAPILinkedList.py

""" """
Test SBValue API linked_list_iter which treats the SBValue as a linked list and Test SBValue API linked_list_iter which treats the SBValue as a linked list and
supports iteration till the end of list is reached. supports iteration till the end of list is reached.
""" """
import os, time import os, time
import re import re
import unittest2 import unittest2
import lldb, lldbutil import lldb, lldbutil
from lldbtest import * from lldbtest import *
class ValueAsLinkedListTestCase(TestBase): class ValueAsLinkedListTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Exercise SBValue API linked_list_iter.""" """Exercise SBValue API linked_list_iter."""
d = {'EXE': self.exe_name} d = {'EXE': self.exe_name}
self.buildDsym(dictionary=d) self.buildDsym(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
self.linked_list_api(self.exe_name) self.linked_list_api(self.exe_name)
▲ Show 20 Lines • Show All 126 Lines • Show Last 20 Lines

test/python_api/value_var_update/TestValueVarUpdate.py

"""Test SBValue::GetValueDidChange""" """Test SBValue::GetValueDidChange"""
import os, sys, time import os, sys, time
import unittest2 import unittest2
import lldb import lldb
import time import time
from lldbtest import * from lldbtest import *
class HelloWorldTestCase(TestBase): class HelloWorldTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_with_dsym_and_process_launch_api(self): def test_with_dsym_and_process_launch_api(self):
"""Test SBValue::GetValueDidChange""" """Test SBValue::GetValueDidChange"""
self.buildDsym(dictionary=self.d) self.buildDsym(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
self.do_test() self.do_test()
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

test/python_api/watchpoint/TestSetWatchpoint.py

Show All 14 Linesclass SetWatchpointAPITestCase(TestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Our simple source filename. # Our simple source filename.
self.source = 'main.c' self.source = 'main.c'
# Find the line number to break inside main(). # Find the line number to break inside main().
self.line = line_number(self.source, '// Set break point at this line.') self.line = line_number(self.source, '// Set break point at this line.')
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_watch_val_with_dsym(self): def test_watch_val_with_dsym(self):
"""Exercise SBValue.Watch() API to set a watchpoint.""" """Exercise SBValue.Watch() API to set a watchpoint."""
self.buildDsym() self.buildDsym()
self.do_set_watchpoint() self.do_set_watchpoint()
@python_api_test @python_api_test
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

test/python_api/watchpoint/TestWatchpointIgnoreCount.py

Show All 14 Linesclass WatchpointIgnoreCountTestCase(TestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Our simple source filename. # Our simple source filename.
self.source = 'main.c' self.source = 'main.c'
# Find the line number to break inside main(). # Find the line number to break inside main().
self.line = line_number(self.source, '// Set break point at this line.') self.line = line_number(self.source, '// Set break point at this line.')
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_set_watch_ignore_count_with_dsym(self): def test_set_watch_ignore_count_with_dsym(self):
"""Test SBWatchpoint.SetIgnoreCount() API.""" """Test SBWatchpoint.SetIgnoreCount() API."""
self.buildDsym() self.buildDsym()
self.do_watchpoint_ignore_count() self.do_watchpoint_ignore_count()
@python_api_test @python_api_test
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

test/python_api/watchpoint/TestWatchpointIter.py

Show All 14 Linesclass WatchpointIteratorTestCase(TestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Our simple source filename. # Our simple source filename.
self.source = 'main.c' self.source = 'main.c'
# Find the line number to break inside main(). # Find the line number to break inside main().
self.line = line_number(self.source, '// Set break point at this line.') self.line = line_number(self.source, '// Set break point at this line.')
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_watch_iter_with_dsym(self): def test_watch_iter_with_dsym(self):
"""Exercise SBTarget.watchpoint_iter() API to iterate on the available watchpoints.""" """Exercise SBTarget.watchpoint_iter() API to iterate on the available watchpoints."""
self.buildDsym() self.buildDsym()
self.do_watchpoint_iter() self.do_watchpoint_iter()
@python_api_test @python_api_test
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines

test/python_api/watchpoint/condition/TestWatchpointConditionAPI.py

Show All 19 Lines def setUp(self):
# Find the line number to break inside main(). # Find the line number to break inside main().
self.line = line_number(self.source, '// Set break point at this line.') self.line = line_number(self.source, '// Set break point at this line.')
# And the watchpoint variable declaration line number. # And the watchpoint variable declaration line number.
self.decl = line_number(self.source, '// Watchpoint variable declaration.') self.decl = line_number(self.source, '// Watchpoint variable declaration.')
# Build dictionary to have unique executable names for each test method. # Build dictionary to have unique executable names for each test method.
self.exe_name = self.testMethodName self.exe_name = self.testMethodName
self.d = {'CXX_SOURCES': self.source, 'EXE': self.exe_name} self.d = {'CXX_SOURCES': self.source, 'EXE': self.exe_name}
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_watchpoint_cond_api_with_dsym(self): def test_watchpoint_cond_api_with_dsym(self):
"""Test watchpoint condition API.""" """Test watchpoint condition API."""
self.buildDsym(dictionary=self.d) self.buildDsym(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
self.watchpoint_condition_api() self.watchpoint_condition_api()
@dwarf_test @dwarf_test
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

test/python_api/watchpoint/watchlocation/TestSetWatchlocation.py

Show All 16 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
# Our simple source filename. # Our simple source filename.
self.source = 'main.cpp' self.source = 'main.cpp'
# Find the line number to break inside main(). # Find the line number to break inside main().
self.line = line_number(self.source, '// Set break point at this line.') self.line = line_number(self.source, '// Set break point at this line.')
# This is for verifying that watch location works. # This is for verifying that watch location works.
self.violating_func = "do_bad_thing_with_location"; self.violating_func = "do_bad_thing_with_location";
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_watch_location_with_dsym(self): def test_watch_location_with_dsym(self):
"""Exercise SBValue.WatchPointee() API to set a watchpoint.""" """Exercise SBValue.WatchPointee() API to set a watchpoint."""
self.buildDsym() self.buildDsym()
self.do_set_watchlocation() self.do_set_watchlocation()
@python_api_test @python_api_test
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

test/python_api/watchpoint/watchlocation/TestTargetWatchAddress.py

Show All 16 Lines def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
# Our simple source filename. # Our simple source filename.
self.source = 'main.cpp' self.source = 'main.cpp'
# Find the line number to break inside main(). # Find the line number to break inside main().
self.line = line_number(self.source, '// Set break point at this line.') self.line = line_number(self.source, '// Set break point at this line.')
# This is for verifying that watch location works. # This is for verifying that watch location works.
self.violating_func = "do_bad_thing_with_location"; self.violating_func = "do_bad_thing_with_location";
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_watch_address_with_dsym(self): def test_watch_address_with_dsym(self):
"""Exercise SBTarget.WatchAddress() API to set a watchpoint.""" """Exercise SBTarget.WatchAddress() API to set a watchpoint."""
self.buildDsym() self.buildDsym()
self.do_set_watchaddress() self.do_set_watchaddress()
@python_api_test @python_api_test
@dwarf_test @dwarf_test
@expectedFailureLinux # failed 11/100 dosep runs @expectedFailureLinux # failed 11/100 dosep runs
def test_watch_address_with_dwarf(self): def test_watch_address_with_dwarf(self):
"""Exercise SBTarget.WatchAddress() API to set a watchpoint.""" """Exercise SBTarget.WatchAddress() API to set a watchpoint."""
self.buildDwarf() self.buildDwarf()
self.do_set_watchaddress() self.do_set_watchaddress()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@python_api_test @python_api_test
@dsym_test @dsym_test
def test_watch_address_with_invalid_watch_size_with_dsym(self): def test_watch_address_with_invalid_watch_size_with_dsym(self):
"""Exercise SBTarget.WatchAddress() API but pass an invalid watch_size.""" """Exercise SBTarget.WatchAddress() API but pass an invalid watch_size."""
self.buildDsym() self.buildDsym()
self.do_set_watchaddress_with_invalid_watch_size() self.do_set_watchaddress_with_invalid_watch_size()
@python_api_test @python_api_test
▲ Show 20 Lines • Show All 108 Lines • Show Last 20 Lines

test/settings/TestSettings.py

Show First 20 Lines • Show All 193 Lines • ▼ Show 20 Lines def test_disassembler_settings(self):
self.runCmd("settings set target.use-hex-immediates true") self.runCmd("settings set target.use-hex-immediates true")
self.runCmd("settings set target.hex-immediate-style c") self.runCmd("settings set target.hex-immediate-style c")
self.expect("disassemble -n numberfn", self.expect("disassemble -n numberfn",
substrs = ["0x5a"]) substrs = ["0x5a"])
self.runCmd("settings set target.hex-immediate-style asm") self.runCmd("settings set target.hex-immediate-style asm")
self.expect("disassemble -n numberfn", self.expect("disassemble -n numberfn",
substrs = ["5ah"]) substrs = ["5ah"])
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_run_args_and_env_vars_with_dsym(self): def test_run_args_and_env_vars_with_dsym(self):
"""Test that run-args and env-vars are passed to the launched process.""" """Test that run-args and env-vars are passed to the launched process."""
self.buildDsym() self.buildDsym()
self.pass_run_args_and_env_vars() self.pass_run_args_and_env_vars()
@dwarf_test @dwarf_test
def test_run_args_and_env_vars_with_dwarf(self): def test_run_args_and_env_vars_with_dwarf(self):
▲ Show 20 Lines • Show All 273 Lines • Show Last 20 Lines

test/tools/lldb-mi/signal/TestMiSignal.py

Show First 20 Lines • Show All 74 Lines • ▼ Show 20 Lines def test_lldbmi_stopped_when_stopatentry_local(self):
self.runCmd("-break-insert -f main") self.runCmd("-break-insert -f main")
self.expect("\^done,bkpt={number=\"1\"") self.expect("\^done,bkpt={number=\"1\"")
self.runCmd("-exec-continue") self.runCmd("-exec-continue")
self.expect("\^running") self.expect("\^running")
self.expect("\*stopped,reason=\"breakpoint-hit\"") self.expect("\*stopped,reason=\"breakpoint-hit\"")
@lldbmi_test @lldbmi_test
@expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows") @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
def test_lldbmi_stopped_when_stopatentry_remote(self): def test_lldbmi_stopped_when_stopatentry_remote(self):
"""Test that 'lldb-mi --interpreter' notifies after it was stopped on entry (remote).""" """Test that 'lldb-mi --interpreter' notifies after it was stopped on entry (remote)."""
# Prepare debugserver # Prepare debugserver
import lldbgdbserverutils import lldbgdbserverutils
debugserver_exe = lldbgdbserverutils.get_debugserver_exe() debugserver_exe = lldbgdbserverutils.get_debugserver_exe()
if not debugserver_exe: if not debugserver_exe:
raise Exception("debugserver not found") raise Exception("debugserver not found")
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Lines def test_lldbmi_stopped_when_segfault_local(self):
# Note that message is different in Darwin and Linux: # Note that message is different in Darwin and Linux:
# Darwin: "*stopped,reason=\"exception-received\",exception=\"EXC_BAD_ACCESS (code=1, address=0x0)\",thread-id=\"1\",stopped-threads=\"all\"" # Darwin: "*stopped,reason=\"exception-received\",exception=\"EXC_BAD_ACCESS (code=1, address=0x0)\",thread-id=\"1\",stopped-threads=\"all\""
# Linux: "*stopped,reason=\"exception-received\",exception=\"invalid address (fault address: 0x0)\",thread-id=\"1\",stopped-threads=\"all\"" # Linux: "*stopped,reason=\"exception-received\",exception=\"invalid address (fault address: 0x0)\",thread-id=\"1\",stopped-threads=\"all\""
self.expect([ "\*stopped,reason=\"exception-received\",exception=\"EXC_BAD_ACCESS \(code=1, address=0x0\)\",thread-id=\"1\",stopped-threads=\"all\"", self.expect([ "\*stopped,reason=\"exception-received\",exception=\"EXC_BAD_ACCESS \(code=1, address=0x0\)\",thread-id=\"1\",stopped-threads=\"all\"",
"\*stopped,reason=\"exception-received\",exception=\"invalid address \(fault address: 0x0\)\",thread-id=\"1\",stopped-threads=\"all\"" ]) "\*stopped,reason=\"exception-received\",exception=\"invalid address \(fault address: 0x0\)\",thread-id=\"1\",stopped-threads=\"all\"" ])
@lldbmi_test @lldbmi_test
@expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows") @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
def test_lldbmi_stopped_when_segfault_remote(self): def test_lldbmi_stopped_when_segfault_remote(self):
"""Test that 'lldb-mi --interpreter' notifies after it was stopped when segfault occurred (remote).""" """Test that 'lldb-mi --interpreter' notifies after it was stopped when segfault occurred (remote)."""
# Prepare debugserver # Prepare debugserver
import lldbgdbserverutils import lldbgdbserverutils
debugserver_exe = lldbgdbserverutils.get_debugserver_exe() debugserver_exe = lldbgdbserverutils.get_debugserver_exe()
if not debugserver_exe: if not debugserver_exe:
raise Exception("debugserver not found") raise Exception("debugserver not found")
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

test/tools/lldb-mi/stack/TestMiStack.py

Show First 20 Lines • Show All 232 Lines • ▼ Show 20 Lines def test_lldbmi_stack_info_depth(self):
# Test that invalid max-depth argument is handled # Test that invalid max-depth argument is handled
#FIXME: max-depth argument is ignored #FIXME: max-depth argument is ignored
self.runCmd("-stack-info-depth -1") self.runCmd("-stack-info-depth -1")
#self.expect("\^error") #self.expect("\^error")
@lldbmi_test @lldbmi_test
@expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows") @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
@skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
def test_lldbmi_stack_info_frame(self): def test_lldbmi_stack_info_frame(self):
"""Test that 'lldb-mi --interpreter' can show information about current frame.""" """Test that 'lldb-mi --interpreter' can show information about current frame."""
self.spawnLldbMi(args = None) self.spawnLldbMi(args = None)
# Test that -stack-info-frame fails when program isn't running # Test that -stack-info-frame fails when program isn't running
self.runCmd("-stack-info-frame") self.runCmd("-stack-info-frame")
self.expect("\^error,msg=\"Command 'stack-info-frame'. Invalid process during debug session\"") self.expect("\^error,msg=\"Command 'stack-info-frame'. Invalid process during debug session\"")
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

test/tools/lldb-server/TestGdbRemoteProcessInfo.py

Show First 20 Lines • Show All 142 Lines • ▼ Show 20 Lines def qProcessInfo_does_not_contain_keys(self, absent_key_set):
# Ensure the unexpected keys are not present # Ensure the unexpected keys are not present
unexpected_key_set = set() unexpected_key_set = set()
for unexpected_key in absent_key_set: for unexpected_key in absent_key_set:
if unexpected_key in process_info: if unexpected_key in process_info:
unexpected_key_set.add(unexpected_key) unexpected_key_set.add(unexpected_key)
self.assertEquals(unexpected_key_set, set(), "the listed keys were present but unexpected in qProcessInfo result") self.assertEquals(unexpected_key_set, set(), "the listed keys were present but unexpected in qProcessInfo result")
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@debugserver_test @debugserver_test
@dsym_test @dsym_test
def test_qProcessInfo_contains_cputype_cpusubtype_debugserver_darwin(self): def test_qProcessInfo_contains_cputype_cpusubtype_debugserver_darwin(self):
self.init_debugserver_test() self.init_debugserver_test()
self.buildDsym() self.buildDsym()
self.qProcessInfo_contains_keys(set(['cputype', 'cpusubtype'])) self.qProcessInfo_contains_keys(set(['cputype', 'cpusubtype']))
@unittest2.skipUnless(sys.platform.startswith("linux"), "requires Linux") @skipUnlessPlatform(["linux"])
@llgs_test @llgs_test
@dwarf_test @dwarf_test
def test_qProcessInfo_contains_triple_llgs_linux(self): def test_qProcessInfo_contains_triple_llgs_linux(self):
self.init_llgs_test() self.init_llgs_test()
self.buildDwarf() self.buildDwarf()
self.qProcessInfo_contains_keys(set(['triple'])) self.qProcessInfo_contains_keys(set(['triple']))
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@debugserver_test @debugserver_test
@dsym_test @dsym_test
def test_qProcessInfo_does_not_contain_triple_debugserver_darwin(self): def test_qProcessInfo_does_not_contain_triple_debugserver_darwin(self):
self.init_debugserver_test() self.init_debugserver_test()
self.buildDsym() self.buildDsym()
# We don't expect to see triple on darwin. If we do, we'll prefer triple # We don't expect to see triple on darwin. If we do, we'll prefer triple
# to cputype/cpusubtype and skip some darwin-based ProcessGDBRemote ArchSpec setup # to cputype/cpusubtype and skip some darwin-based ProcessGDBRemote ArchSpec setup
# for the remote Host and Process. # for the remote Host and Process.
self.qProcessInfo_does_not_contain_keys(set(['triple'])) self.qProcessInfo_does_not_contain_keys(set(['triple']))
@unittest2.skipUnless(sys.platform.startswith("linux"), "requires Linux") @skipUnlessPlatform(["linux"]);
@llgs_test @llgs_test
@dwarf_test @dwarf_test
def test_qProcessInfo_does_not_contain_cputype_cpusubtype_llgs_linux(self): def test_qProcessInfo_does_not_contain_cputype_cpusubtype_llgs_linux(self):
self.init_llgs_test() self.init_llgs_test()
self.buildDwarf() self.buildDwarf()
self.qProcessInfo_does_not_contain_keys(set(['cputype', 'cpusubtype'])) self.qProcessInfo_does_not_contain_keys(set(['cputype', 'cpusubtype']))
if __name__ == '__main__': if __name__ == '__main__':
unittest2.main() unittest2.main()

test/tools/lldb-server/TestGdbRemote_qThreadStopInfo.py

Show First 20 Lines • Show All 135 Lines • ▼ Show 20 Linesclass TestGdbRemote_qThreadStopInfo(gdbremote_testcase.GdbRemoteTestCaseBase):
@debugserver_test @debugserver_test
@dsym_test @dsym_test
def test_qThreadStopInfo_has_valid_thread_names_debugserver_dsym(self): def test_qThreadStopInfo_has_valid_thread_names_debugserver_dsym(self):
self.init_debugserver_test() self.init_debugserver_test()
self.buildDsym() self.buildDsym()
self.set_inferior_startup_launch() self.set_inferior_startup_launch()
self.qThreadStopInfo_has_valid_thread_names(self.THREAD_COUNT, "a.out") self.qThreadStopInfo_has_valid_thread_names(self.THREAD_COUNT, "a.out")
@unittest2.skipUnless(sys.platform.startswith("linux"), "test requires OS with set, equal thread names by default") @skipUnlessPlatform(["linux"]) # test requires OS with set, equal thread names by default.
@llgs_test @llgs_test
@dwarf_test @dwarf_test
def test_qThreadStopInfo_has_valid_thread_names_llgs_dwarf(self): def test_qThreadStopInfo_has_valid_thread_names_llgs_dwarf(self):
self.init_llgs_test() self.init_llgs_test()
self.buildDwarf() self.buildDwarf()
self.set_inferior_startup_launch() self.set_inferior_startup_launch()
self.qThreadStopInfo_has_valid_thread_names(self.THREAD_COUNT, "a.out") self.qThreadStopInfo_has_valid_thread_names(self.THREAD_COUNT, "a.out")
if __name__ == '__main__': if __name__ == '__main__':
unittest2.main() unittest2.main()

test/types/HideTestFailures.py

Show All 33 Lines def tearDown(self):
# If we're lucky, test_long_type_with_dsym fails. # If we're lucky, test_long_type_with_dsym fails.
# Let's turn off logging just for that. # Let's turn off logging just for that.
if "test_long_type_with_dsym" in self.id(): if "test_long_type_with_dsym" in self.id():
self.runCmd("log disable lldb") self.runCmd("log disable lldb")
self.runCmd("log disable gdb-remote") self.runCmd("log disable gdb-remote")
# Call super's tearDown(). # Call super's tearDown().
TestBase.tearDown(self) TestBase.tearDown(self)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
def test_char_type_with_dsym(self): def test_char_type_with_dsym(self):
"""Test that char-type variables are displayed correctly.""" """Test that char-type variables are displayed correctly."""
d = {'CXX_SOURCES': 'char.cpp'} d = {'CXX_SOURCES': 'char.cpp'}
self.buildDsym(dictionary=d) self.buildDsym(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
self.char_type() self.char_type()
def test_char_type_with_dwarf(self): def test_char_type_with_dwarf(self):
"""Test that char-type variables are displayed correctly.""" """Test that char-type variables are displayed correctly."""
d = {'CXX_SOURCES': 'char.cpp'} d = {'CXX_SOURCES': 'char.cpp'}
self.buildDwarf(dictionary=d) self.buildDwarf(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
self.char_type() self.char_type()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
def test_short_type_with_dsym(self): def test_short_type_with_dsym(self):
"""Test that short-type variables are displayed correctly.""" """Test that short-type variables are displayed correctly."""
d = {'CXX_SOURCES': 'short.cpp'} d = {'CXX_SOURCES': 'short.cpp'}
self.buildDsym(dictionary=d) self.buildDsym(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
self.short_type() self.short_type()
def test_short_type_with_dwarf(self): def test_short_type_with_dwarf(self):
"""Test that short-type variables are displayed correctly.""" """Test that short-type variables are displayed correctly."""
d = {'CXX_SOURCES': 'short.cpp'} d = {'CXX_SOURCES': 'short.cpp'}
self.buildDwarf(dictionary=d) self.buildDwarf(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
self.short_type() self.short_type()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
def test_int_type_with_dsym(self): def test_int_type_with_dsym(self):
"""Test that int-type variables are displayed correctly.""" """Test that int-type variables are displayed correctly."""
d = {'CXX_SOURCES': 'int.cpp'} d = {'CXX_SOURCES': 'int.cpp'}
self.buildDsym(dictionary=d) self.buildDsym(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
self.int_type() self.int_type()
def test_int_type_with_dwarf(self): def test_int_type_with_dwarf(self):
"""Test that int-type variables are displayed correctly.""" """Test that int-type variables are displayed correctly."""
d = {'CXX_SOURCES': 'int.cpp'} d = {'CXX_SOURCES': 'int.cpp'}
self.buildDwarf(dictionary=d) self.buildDwarf(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
self.int_type() self.int_type()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
def test_long_type_with_dsym(self): def test_long_type_with_dsym(self):
"""Test that long-type variables are displayed correctly.""" """Test that long-type variables are displayed correctly."""
d = {'CXX_SOURCES': 'long.cpp'} d = {'CXX_SOURCES': 'long.cpp'}
print self.id() print self.id()
self.buildDsym(dictionary=d) self.buildDsym(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
self.long_type() self.long_type()
def test_long_type_with_dwarf(self): def test_long_type_with_dwarf(self):
"""Test that long-type variables are displayed correctly.""" """Test that long-type variables are displayed correctly."""
d = {'CXX_SOURCES': 'long.cpp'} d = {'CXX_SOURCES': 'long.cpp'}
self.buildDwarf(dictionary=d) self.buildDwarf(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
self.long_type() self.long_type()
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
def test_long_long_type_with_dsym(self): def test_long_long_type_with_dsym(self):
"""Test that 'long long'-type variables are displayed correctly.""" """Test that 'long long'-type variables are displayed correctly."""
d = {'CXX_SOURCES': 'long_long.cpp'} d = {'CXX_SOURCES': 'long_long.cpp'}
self.buildDsym(dictionary=d) self.buildDsym(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
self.long_long_type() self.long_long_type()
def test_long_long_type_with_dwarf(self): def test_long_long_type_with_dwarf(self):
Show All 32 Lines

test/types/TestFloatTypes.py

""" """
Test that variables of floating point types are displayed correctly. Test that variables of floating point types are displayed correctly.
""" """
import AbstractBase import AbstractBase
import unittest2 import unittest2
import lldb import lldb
import sys import sys
from lldbtest import dsym_test, dwarf_test from lldbtest import *
class FloatTypesTestCase(AbstractBase.GenericTester): class FloatTypesTestCase(AbstractBase.GenericTester):
mydir = AbstractBase.GenericTester.compute_mydir(__file__) mydir = AbstractBase.GenericTester.compute_mydir(__file__)
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
AbstractBase.GenericTester.setUp(self) AbstractBase.GenericTester.setUp(self)
# disable "There is a running process, kill it and restart?" prompt # disable "There is a running process, kill it and restart?" prompt
self.runCmd("settings set auto-confirm true") self.runCmd("settings set auto-confirm true")
self.addTearDownHook(lambda: self.runCmd("settings clear auto-confirm")) self.addTearDownHook(lambda: self.runCmd("settings clear auto-confirm"))
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_float_type_with_dsym(self): def test_float_type_with_dsym(self):
"""Test that float-type variables are displayed correctly.""" """Test that float-type variables are displayed correctly."""
self.build_and_run('float.cpp', set(['float'])) self.build_and_run('float.cpp', set(['float']))
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_float_type_from_block_with_dsym(self): def test_float_type_from_block_with_dsym(self):
"""Test that float-type variables are displayed correctly from a block.""" """Test that float-type variables are displayed correctly from a block."""
self.build_and_run('float.cpp', set(['float']), bc=True) self.build_and_run('float.cpp', set(['float']), bc=True)
@dwarf_test @dwarf_test
def test_float_type_with_dwarf(self): def test_float_type_with_dwarf(self):
"""Test that float-type variables are displayed correctly.""" """Test that float-type variables are displayed correctly."""
self.build_and_run('float.cpp', set(['float']), dsym=False) self.build_and_run('float.cpp', set(['float']), dsym=False)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_double_type_with_dsym(self): def test_double_type_with_dsym(self):
"""Test that double-type variables are displayed correctly.""" """Test that double-type variables are displayed correctly."""
self.build_and_run('double.cpp', set(['double'])) self.build_and_run('double.cpp', set(['double']))
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_double_type_from_block_with_dsym(self): def test_double_type_from_block_with_dsym(self):
"""Test that double-type variables are displayed correctly from a block.""" """Test that double-type variables are displayed correctly from a block."""
self.build_and_run('double.cpp', set(['double']), bc=True) self.build_and_run('double.cpp', set(['double']), bc=True)
@dwarf_test @dwarf_test
def test_double_type_with_dwarf(self): def test_double_type_with_dwarf(self):
"""Test that double-type variables are displayed correctly.""" """Test that double-type variables are displayed correctly."""
self.build_and_run('double.cpp', set(['double']), dsym=False) self.build_and_run('double.cpp', set(['double']), dsym=False)
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/types/TestFloatTypesExpr.py

""" """
Test that variable expressions of floating point types are evaluated correctly. Test that variable expressions of floating point types are evaluated correctly.
""" """
import AbstractBase import AbstractBase
import unittest2 import unittest2
import lldb import lldb
import sys import sys
from lldbtest import dsym_test, dwarf_test from lldbtest import *
class FloatTypesExprTestCase(AbstractBase.GenericTester): class FloatTypesExprTestCase(AbstractBase.GenericTester):
mydir = AbstractBase.GenericTester.compute_mydir(__file__) mydir = AbstractBase.GenericTester.compute_mydir(__file__)
# rdar://problem/8493023 # rdar://problem/8493023
# test/types failures for Test*TypesExpr.py: element offset computed wrong and sign error? # test/types failures for Test*TypesExpr.py: element offset computed wrong and sign error?
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
AbstractBase.GenericTester.setUp(self) AbstractBase.GenericTester.setUp(self)
# disable "There is a running process, kill it and restart?" prompt # disable "There is a running process, kill it and restart?" prompt
self.runCmd("settings set auto-confirm true") self.runCmd("settings set auto-confirm true")
self.addTearDownHook(lambda: self.runCmd("settings clear auto-confirm")) self.addTearDownHook(lambda: self.runCmd("settings clear auto-confirm"))
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_float_type_with_dsym(self): def test_float_type_with_dsym(self):
"""Test that float-type variable expressions are evaluated correctly.""" """Test that float-type variable expressions are evaluated correctly."""
self.build_and_run_expr('float.cpp', set(['float'])) self.build_and_run_expr('float.cpp', set(['float']))
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_float_type_from_block_with_dsym(self): def test_float_type_from_block_with_dsym(self):
"""Test that float-type variables are displayed correctly from a block.""" """Test that float-type variables are displayed correctly from a block."""
self.build_and_run_expr('float.cpp', set(['float']), bc=True) self.build_and_run_expr('float.cpp', set(['float']), bc=True)
@dwarf_test @dwarf_test
def test_float_type_with_dwarf(self): def test_float_type_with_dwarf(self):
"""Test that float-type variable expressions are evaluated correctly.""" """Test that float-type variable expressions are evaluated correctly."""
self.build_and_run_expr('float.cpp', set(['float']), dsym=False) self.build_and_run_expr('float.cpp', set(['float']), dsym=False)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_double_type_with_dsym(self): def test_double_type_with_dsym(self):
"""Test that double-type variable expressions are evaluated correctly.""" """Test that double-type variable expressions are evaluated correctly."""
self.build_and_run_expr('double.cpp', set(['double'])) self.build_and_run_expr('double.cpp', set(['double']))
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_double_type_from_block_with_dsym(self): def test_double_type_from_block_with_dsym(self):
"""Test that double-type variables are displayed correctly from a block.""" """Test that double-type variables are displayed correctly from a block."""
self.build_and_run_expr('double.cpp', set(['double']), bc=True) self.build_and_run_expr('double.cpp', set(['double']), bc=True)
@dwarf_test @dwarf_test
def test_double_type_with_dwarf(self): def test_double_type_with_dwarf(self):
"""Test that double-type variable expressions are evaluated correctly.""" """Test that double-type variable expressions are evaluated correctly."""
self.build_and_run_expr('double.cpp', set(['double']), dsym=False) self.build_and_run_expr('double.cpp', set(['double']), dsym=False)
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/types/TestIntegerTypes.py

""" """
Test that variables of integer basic types are displayed correctly. Test that variables of integer basic types are displayed correctly.
""" """
import AbstractBase import AbstractBase
import unittest2 import unittest2
import lldb import lldb
import sys import sys
from lldbtest import dsym_test, dwarf_test from lldbtest import *
class IntegerTypesTestCase(AbstractBase.GenericTester): class IntegerTypesTestCase(AbstractBase.GenericTester):
mydir = AbstractBase.GenericTester.compute_mydir(__file__) mydir = AbstractBase.GenericTester.compute_mydir(__file__)
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
AbstractBase.GenericTester.setUp(self) AbstractBase.GenericTester.setUp(self)
# disable "There is a running process, kill it and restart?" prompt # disable "There is a running process, kill it and restart?" prompt
self.runCmd("settings set auto-confirm true") self.runCmd("settings set auto-confirm true")
self.addTearDownHook(lambda: self.runCmd("settings clear auto-confirm")) self.addTearDownHook(lambda: self.runCmd("settings clear auto-confirm"))
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_char_type_with_dsym(self): def test_char_type_with_dsym(self):
"""Test that char-type variables are displayed correctly.""" """Test that char-type variables are displayed correctly."""
self.build_and_run('char.cpp', set(['char']), qd=True) self.build_and_run('char.cpp', set(['char']), qd=True)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_char_type_from_block_with_dsym(self): def test_char_type_from_block_with_dsym(self):
"""Test that char-type variables are displayed correctly from a block.""" """Test that char-type variables are displayed correctly from a block."""
self.build_and_run('char.cpp', set(['char']), bc=True, qd=True) self.build_and_run('char.cpp', set(['char']), bc=True, qd=True)
@dwarf_test @dwarf_test
def test_char_type_with_dwarf(self): def test_char_type_with_dwarf(self):
"""Test that char-type variables are displayed correctly.""" """Test that char-type variables are displayed correctly."""
self.build_and_run('char.cpp', set(['char']), dsym=False, qd=True) self.build_and_run('char.cpp', set(['char']), dsym=False, qd=True)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_unsigned_char_type_with_dsym(self): def test_unsigned_char_type_with_dsym(self):
"""Test that 'unsigned_char'-type variables are displayed correctly.""" """Test that 'unsigned_char'-type variables are displayed correctly."""
self.build_and_run('unsigned_char.cpp', set(['unsigned', 'char']), qd=True) self.build_and_run('unsigned_char.cpp', set(['unsigned', 'char']), qd=True)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_unsigned_char_type_from_block_with_dsym(self): def test_unsigned_char_type_from_block_with_dsym(self):
"""Test that 'unsigned char'-type variables are displayed correctly from a block.""" """Test that 'unsigned char'-type variables are displayed correctly from a block."""
self.build_and_run('unsigned_char.cpp', set(['unsigned', 'char']), bc=True, qd=True) self.build_and_run('unsigned_char.cpp', set(['unsigned', 'char']), bc=True, qd=True)
@dwarf_test @dwarf_test
def test_unsigned_char_type_with_dwarf(self): def test_unsigned_char_type_with_dwarf(self):
"""Test that 'unsigned char'-type variables are displayed correctly.""" """Test that 'unsigned char'-type variables are displayed correctly."""
self.build_and_run('unsigned_char.cpp', set(['unsigned', 'char']), dsym=False, qd=True) self.build_and_run('unsigned_char.cpp', set(['unsigned', 'char']), dsym=False, qd=True)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_short_type_with_dsym(self): def test_short_type_with_dsym(self):
"""Test that short-type variables are displayed correctly.""" """Test that short-type variables are displayed correctly."""
self.build_and_run('short.cpp', set(['short'])) self.build_and_run('short.cpp', set(['short']))
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_short_type_from_block_with_dsym(self): def test_short_type_from_block_with_dsym(self):
"""Test that short-type variables are displayed correctly from a block.""" """Test that short-type variables are displayed correctly from a block."""
self.build_and_run('short.cpp', set(['short']), bc=True) self.build_and_run('short.cpp', set(['short']), bc=True)
@dwarf_test @dwarf_test
def test_short_type_with_dwarf(self): def test_short_type_with_dwarf(self):
"""Test that short-type variables are displayed correctly.""" """Test that short-type variables are displayed correctly."""
self.build_and_run('short.cpp', set(['short']), dsym=False) self.build_and_run('short.cpp', set(['short']), dsym=False)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_unsigned_short_type_with_dsym(self): def test_unsigned_short_type_with_dsym(self):
"""Test that 'unsigned_short'-type variables are displayed correctly.""" """Test that 'unsigned_short'-type variables are displayed correctly."""
self.build_and_run('unsigned_short.cpp', set(['unsigned', 'short'])) self.build_and_run('unsigned_short.cpp', set(['unsigned', 'short']))
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_unsigned_short_type_from_block_with_dsym(self): def test_unsigned_short_type_from_block_with_dsym(self):
"""Test that 'unsigned short'-type variables are displayed correctly from a block.""" """Test that 'unsigned short'-type variables are displayed correctly from a block."""
self.build_and_run('unsigned_short.cpp', set(['unsigned', 'short']), bc=True) self.build_and_run('unsigned_short.cpp', set(['unsigned', 'short']), bc=True)
@dwarf_test @dwarf_test
def test_unsigned_short_type_with_dwarf(self): def test_unsigned_short_type_with_dwarf(self):
"""Test that 'unsigned short'-type variables are displayed correctly.""" """Test that 'unsigned short'-type variables are displayed correctly."""
self.build_and_run('unsigned_short.cpp', set(['unsigned', 'short']), dsym=False) self.build_and_run('unsigned_short.cpp', set(['unsigned', 'short']), dsym=False)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_int_type_with_dsym(self): def test_int_type_with_dsym(self):
"""Test that int-type variables are displayed correctly.""" """Test that int-type variables are displayed correctly."""
self.build_and_run('int.cpp', set(['int'])) self.build_and_run('int.cpp', set(['int']))
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_int_type_from_block_with_dsym(self): def test_int_type_from_block_with_dsym(self):
"""Test that int-type variables are displayed correctly from a block.""" """Test that int-type variables are displayed correctly from a block."""
self.build_and_run('int.cpp', set(['int']), dsym=False) self.build_and_run('int.cpp', set(['int']), dsym=False)
@dwarf_test @dwarf_test
def test_int_type_with_dwarf(self): def test_int_type_with_dwarf(self):
"""Test that int-type variables are displayed correctly.""" """Test that int-type variables are displayed correctly."""
self.build_and_run('int.cpp', set(['int']), dsym=False) self.build_and_run('int.cpp', set(['int']), dsym=False)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_unsigned_int_type_with_dsym(self): def test_unsigned_int_type_with_dsym(self):
"""Test that 'unsigned_int'-type variables are displayed correctly.""" """Test that 'unsigned_int'-type variables are displayed correctly."""
self.build_and_run('unsigned_int.cpp', set(['unsigned', 'int'])) self.build_and_run('unsigned_int.cpp', set(['unsigned', 'int']))
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_unsigned_int_type_from_block_with_dsym(self): def test_unsigned_int_type_from_block_with_dsym(self):
"""Test that 'unsigned int'-type variables are displayed correctly from a block.""" """Test that 'unsigned int'-type variables are displayed correctly from a block."""
self.build_and_run('unsigned_int.cpp', set(['unsigned', 'int']), bc=True) self.build_and_run('unsigned_int.cpp', set(['unsigned', 'int']), bc=True)
@dwarf_test @dwarf_test
def test_unsigned_int_type_with_dwarf(self): def test_unsigned_int_type_with_dwarf(self):
"""Test that 'unsigned int'-type variables are displayed correctly.""" """Test that 'unsigned int'-type variables are displayed correctly."""
self.build_and_run('unsigned_int.cpp', set(['unsigned', 'int']), dsym=False) self.build_and_run('unsigned_int.cpp', set(['unsigned', 'int']), dsym=False)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_long_type_with_dsym(self): def test_long_type_with_dsym(self):
"""Test that long-type variables are displayed correctly.""" """Test that long-type variables are displayed correctly."""
self.build_and_run('long.cpp', set(['long'])) self.build_and_run('long.cpp', set(['long']))
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_long_type_from_block_with_dsym(self): def test_long_type_from_block_with_dsym(self):
"""Test that long-type variables are displayed correctly from a block.""" """Test that long-type variables are displayed correctly from a block."""
self.build_and_run('long.cpp', set(['long']), bc=True) self.build_and_run('long.cpp', set(['long']), bc=True)
@dwarf_test @dwarf_test
def test_long_type_with_dwarf(self): def test_long_type_with_dwarf(self):
"""Test that long-type variables are displayed correctly.""" """Test that long-type variables are displayed correctly."""
self.build_and_run('long.cpp', set(['long']), dsym=False) self.build_and_run('long.cpp', set(['long']), dsym=False)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_unsigned_long_type_with_dsym(self): def test_unsigned_long_type_with_dsym(self):
"""Test that 'unsigned long'-type variables are displayed correctly.""" """Test that 'unsigned long'-type variables are displayed correctly."""
self.build_and_run('unsigned_long.cpp', set(['unsigned', 'long'])) self.build_and_run('unsigned_long.cpp', set(['unsigned', 'long']))
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_unsigned_long_type_from_block_with_dsym(self): def test_unsigned_long_type_from_block_with_dsym(self):
"""Test that 'unsigned_long'-type variables are displayed correctly from a block.""" """Test that 'unsigned_long'-type variables are displayed correctly from a block."""
self.build_and_run('unsigned_long.cpp', set(['unsigned', 'long']), bc=True) self.build_and_run('unsigned_long.cpp', set(['unsigned', 'long']), bc=True)
@dwarf_test @dwarf_test
def test_unsigned_long_type_with_dwarf(self): def test_unsigned_long_type_with_dwarf(self):
"""Test that 'unsigned long'-type variables are displayed correctly.""" """Test that 'unsigned long'-type variables are displayed correctly."""
self.build_and_run('unsigned_long.cpp', set(['unsigned', 'long']), dsym=False) self.build_and_run('unsigned_long.cpp', set(['unsigned', 'long']), dsym=False)
# rdar://problem/8482903 # rdar://problem/8482903
# test suite failure for types dir -- "long long" and "unsigned long long" # test suite failure for types dir -- "long long" and "unsigned long long"
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_long_long_type_with_dsym(self): def test_long_long_type_with_dsym(self):
"""Test that 'long long'-type variables are displayed correctly.""" """Test that 'long long'-type variables are displayed correctly."""
self.build_and_run('long_long.cpp', set(['long long'])) self.build_and_run('long_long.cpp', set(['long long']))
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_long_long_type_from_block_with_dsym(self): def test_long_long_type_from_block_with_dsym(self):
"""Test that 'long_long'-type variables are displayed correctly from a block.""" """Test that 'long_long'-type variables are displayed correctly from a block."""
self.build_and_run('long_long.cpp', set(['long long']), bc=True) self.build_and_run('long_long.cpp', set(['long long']), bc=True)
@dwarf_test @dwarf_test
def test_long_long_type_with_dwarf(self): def test_long_long_type_with_dwarf(self):
"""Test that 'long long'-type variables are displayed correctly.""" """Test that 'long long'-type variables are displayed correctly."""
self.build_and_run('long_long.cpp', set(['long long']), dsym=False) self.build_and_run('long_long.cpp', set(['long long']), dsym=False)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_unsigned_long_long_type_with_dsym(self): def test_unsigned_long_long_type_with_dsym(self):
"""Test that 'unsigned long long'-type variables are displayed correctly.""" """Test that 'unsigned long long'-type variables are displayed correctly."""
self.build_and_run('unsigned_long_long.cpp', set(['unsigned', 'long long'])) self.build_and_run('unsigned_long_long.cpp', set(['unsigned', 'long long']))
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_unsigned_long_long_type_from_block_with_dsym(self): def test_unsigned_long_long_type_from_block_with_dsym(self):
"""Test that 'unsigned_long_long'-type variables are displayed correctly from a block.""" """Test that 'unsigned_long_long'-type variables are displayed correctly from a block."""
self.build_and_run('unsigned_long_long.cpp', set(['unsigned', 'long long']), bc=True) self.build_and_run('unsigned_long_long.cpp', set(['unsigned', 'long long']), bc=True)
@dwarf_test @dwarf_test
def test_unsigned_long_long_type_with_dwarf(self): def test_unsigned_long_long_type_with_dwarf(self):
"""Test that 'unsigned long long'-type variables are displayed correctly.""" """Test that 'unsigned long long'-type variables are displayed correctly."""
self.build_and_run('unsigned_long_long.cpp', set(['unsigned', 'long long']), dsym=False) self.build_and_run('unsigned_long_long.cpp', set(['unsigned', 'long long']), dsym=False)
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/types/TestIntegerTypesExpr.py

""" """
Test that variable expressions of integer basic types are evaluated correctly. Test that variable expressions of integer basic types are evaluated correctly.
""" """
import AbstractBase import AbstractBase
import unittest2 import unittest2
import lldb import lldb
import sys import sys
from lldbtest import dsym_test, dwarf_test from lldbtest import *
class IntegerTypesExprTestCase(AbstractBase.GenericTester): class IntegerTypesExprTestCase(AbstractBase.GenericTester):
mydir = AbstractBase.GenericTester.compute_mydir(__file__) mydir = AbstractBase.GenericTester.compute_mydir(__file__)
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
AbstractBase.GenericTester.setUp(self) AbstractBase.GenericTester.setUp(self)
# disable "There is a running process, kill it and restart?" prompt # disable "There is a running process, kill it and restart?" prompt
self.runCmd("settings set auto-confirm true") self.runCmd("settings set auto-confirm true")
self.addTearDownHook(lambda: self.runCmd("settings clear auto-confirm")) self.addTearDownHook(lambda: self.runCmd("settings clear auto-confirm"))
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_char_type_with_dsym(self): def test_char_type_with_dsym(self):
"""Test that char-type variable expressions are evaluated correctly.""" """Test that char-type variable expressions are evaluated correctly."""
self.build_and_run_expr('char.cpp', set(['char']), qd=True) self.build_and_run_expr('char.cpp', set(['char']), qd=True)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_char_type_from_block_with_dsym(self): def test_char_type_from_block_with_dsym(self):
"""Test that char-type variables are displayed correctly from a block.""" """Test that char-type variables are displayed correctly from a block."""
self.build_and_run_expr('char.cpp', set(['char']), bc=True, qd=True) self.build_and_run_expr('char.cpp', set(['char']), bc=True, qd=True)
@dwarf_test @dwarf_test
def test_char_type_with_dwarf(self): def test_char_type_with_dwarf(self):
"""Test that char-type variable expressions are evaluated correctly.""" """Test that char-type variable expressions are evaluated correctly."""
self.build_and_run_expr('char.cpp', set(['char']), dsym=False, qd=True) self.build_and_run_expr('char.cpp', set(['char']), dsym=False, qd=True)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_unsigned_char_type_with_dsym(self): def test_unsigned_char_type_with_dsym(self):
"""Test that 'unsigned_char'-type variable expressions are evaluated correctly.""" """Test that 'unsigned_char'-type variable expressions are evaluated correctly."""
self.build_and_run_expr('unsigned_char.cpp', set(['unsigned', 'char']), qd=True) self.build_and_run_expr('unsigned_char.cpp', set(['unsigned', 'char']), qd=True)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_unsigned_char_type_from_block_with_dsym(self): def test_unsigned_char_type_from_block_with_dsym(self):
"""Test that 'unsigned char'-type variables are displayed correctly from a block.""" """Test that 'unsigned char'-type variables are displayed correctly from a block."""
self.build_and_run_expr('unsigned_char.cpp', set(['unsigned', 'char']), bc=True, qd=True) self.build_and_run_expr('unsigned_char.cpp', set(['unsigned', 'char']), bc=True, qd=True)
@dwarf_test @dwarf_test
def test_unsigned_char_type_with_dwarf(self): def test_unsigned_char_type_with_dwarf(self):
"""Test that 'unsigned char'-type variable expressions are evaluated correctly.""" """Test that 'unsigned char'-type variable expressions are evaluated correctly."""
self.build_and_run_expr('unsigned_char.cpp', set(['unsigned', 'char']), dsym=False, qd=True) self.build_and_run_expr('unsigned_char.cpp', set(['unsigned', 'char']), dsym=False, qd=True)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_short_type_with_dsym(self): def test_short_type_with_dsym(self):
"""Test that short-type variable expressions are evaluated correctly.""" """Test that short-type variable expressions are evaluated correctly."""
self.build_and_run_expr('short.cpp', set(['short'])) self.build_and_run_expr('short.cpp', set(['short']))
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_short_type_from_block_with_dsym(self): def test_short_type_from_block_with_dsym(self):
"""Test that short-type variables are displayed correctly from a block.""" """Test that short-type variables are displayed correctly from a block."""
self.build_and_run_expr('short.cpp', set(['short']), bc=True) self.build_and_run_expr('short.cpp', set(['short']), bc=True)
@dwarf_test @dwarf_test
def test_short_type_with_dwarf(self): def test_short_type_with_dwarf(self):
"""Test that short-type variable expressions are evaluated correctly.""" """Test that short-type variable expressions are evaluated correctly."""
self.build_and_run_expr('short.cpp', set(['short']), dsym=False) self.build_and_run_expr('short.cpp', set(['short']), dsym=False)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_unsigned_short_type_with_dsym(self): def test_unsigned_short_type_with_dsym(self):
"""Test that 'unsigned_short'-type variable expressions are evaluated correctly.""" """Test that 'unsigned_short'-type variable expressions are evaluated correctly."""
self.build_and_run_expr('unsigned_short.cpp', set(['unsigned', 'short'])) self.build_and_run_expr('unsigned_short.cpp', set(['unsigned', 'short']))
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_unsigned_short_type_from_block_with_dsym(self): def test_unsigned_short_type_from_block_with_dsym(self):
"""Test that 'unsigned short'-type variables are displayed correctly from a block.""" """Test that 'unsigned short'-type variables are displayed correctly from a block."""
self.build_and_run_expr('unsigned_short.cpp', set(['unsigned', 'short']), bc=True) self.build_and_run_expr('unsigned_short.cpp', set(['unsigned', 'short']), bc=True)
@dwarf_test @dwarf_test
def test_unsigned_short_type_with_dwarf(self): def test_unsigned_short_type_with_dwarf(self):
"""Test that 'unsigned short'-type variable expressions are evaluated correctly.""" """Test that 'unsigned short'-type variable expressions are evaluated correctly."""
self.build_and_run_expr('unsigned_short.cpp', set(['unsigned', 'short']), dsym=False) self.build_and_run_expr('unsigned_short.cpp', set(['unsigned', 'short']), dsym=False)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_int_type_with_dsym(self): def test_int_type_with_dsym(self):
"""Test that int-type variable expressions are evaluated correctly.""" """Test that int-type variable expressions are evaluated correctly."""
self.build_and_run_expr('int.cpp', set(['int'])) self.build_and_run_expr('int.cpp', set(['int']))
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_int_type_from_block_with_dsym(self): def test_int_type_from_block_with_dsym(self):
"""Test that int-type variables are displayed correctly from a block.""" """Test that int-type variables are displayed correctly from a block."""
self.build_and_run_expr('int.cpp', set(['int']), dsym=False) self.build_and_run_expr('int.cpp', set(['int']), dsym=False)
@dwarf_test @dwarf_test
def test_int_type_with_dwarf(self): def test_int_type_with_dwarf(self):
"""Test that int-type variable expressions are evaluated correctly.""" """Test that int-type variable expressions are evaluated correctly."""
self.build_and_run_expr('int.cpp', set(['int']), dsym=False) self.build_and_run_expr('int.cpp', set(['int']), dsym=False)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_unsigned_int_type_with_dsym(self): def test_unsigned_int_type_with_dsym(self):
"""Test that 'unsigned_int'-type variable expressions are evaluated correctly.""" """Test that 'unsigned_int'-type variable expressions are evaluated correctly."""
self.build_and_run_expr('unsigned_int.cpp', set(['unsigned', 'int'])) self.build_and_run_expr('unsigned_int.cpp', set(['unsigned', 'int']))
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_unsigned_int_type_from_block_with_dsym(self): def test_unsigned_int_type_from_block_with_dsym(self):
"""Test that 'unsigned int'-type variables are displayed correctly from a block.""" """Test that 'unsigned int'-type variables are displayed correctly from a block."""
self.build_and_run_expr('unsigned_int.cpp', set(['unsigned', 'int']), bc=True) self.build_and_run_expr('unsigned_int.cpp', set(['unsigned', 'int']), bc=True)
@dwarf_test @dwarf_test
def test_unsigned_int_type_with_dwarf(self): def test_unsigned_int_type_with_dwarf(self):
"""Test that 'unsigned int'-type variable expressions are evaluated correctly.""" """Test that 'unsigned int'-type variable expressions are evaluated correctly."""
self.build_and_run_expr('unsigned_int.cpp', set(['unsigned', 'int']), dsym=False) self.build_and_run_expr('unsigned_int.cpp', set(['unsigned', 'int']), dsym=False)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_long_type_with_dsym(self): def test_long_type_with_dsym(self):
"""Test that long-type variable expressions are evaluated correctly.""" """Test that long-type variable expressions are evaluated correctly."""
self.build_and_run_expr('long.cpp', set(['long'])) self.build_and_run_expr('long.cpp', set(['long']))
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_long_type_from_block_with_dsym(self): def test_long_type_from_block_with_dsym(self):
"""Test that long-type variables are displayed correctly from a block.""" """Test that long-type variables are displayed correctly from a block."""
self.build_and_run_expr('long.cpp', set(['long']), bc=True) self.build_and_run_expr('long.cpp', set(['long']), bc=True)
@dwarf_test @dwarf_test
def test_long_type_with_dwarf(self): def test_long_type_with_dwarf(self):
"""Test that long-type variable expressions are evaluated correctly.""" """Test that long-type variable expressions are evaluated correctly."""
self.build_and_run_expr('long.cpp', set(['long']), dsym=False) self.build_and_run_expr('long.cpp', set(['long']), dsym=False)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_unsigned_long_type_with_dsym(self): def test_unsigned_long_type_with_dsym(self):
"""Test that 'unsigned long'-type variable expressions are evaluated correctly.""" """Test that 'unsigned long'-type variable expressions are evaluated correctly."""
self.build_and_run_expr('unsigned_long.cpp', set(['unsigned', 'long'])) self.build_and_run_expr('unsigned_long.cpp', set(['unsigned', 'long']))
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_unsigned_long_type_from_block_with_dsym(self): def test_unsigned_long_type_from_block_with_dsym(self):
"""Test that 'unsigned_long'-type variables are displayed correctly from a block.""" """Test that 'unsigned_long'-type variables are displayed correctly from a block."""
self.build_and_run_expr('unsigned_long.cpp', set(['unsigned', 'long']), bc=True) self.build_and_run_expr('unsigned_long.cpp', set(['unsigned', 'long']), bc=True)
@dwarf_test @dwarf_test
def test_unsigned_long_type_with_dwarf(self): def test_unsigned_long_type_with_dwarf(self):
"""Test that 'unsigned long'-type variable expressions are evaluated correctly.""" """Test that 'unsigned long'-type variable expressions are evaluated correctly."""
self.build_and_run_expr('unsigned_long.cpp', set(['unsigned', 'long']), dsym=False) self.build_and_run_expr('unsigned_long.cpp', set(['unsigned', 'long']), dsym=False)
# rdar://problem/8482903 # rdar://problem/8482903
# test suite failure for types dir -- "long long" and "unsigned long long" # test suite failure for types dir -- "long long" and "unsigned long long"
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_long_long_type_with_dsym(self): def test_long_long_type_with_dsym(self):
"""Test that 'long long'-type variable expressions are evaluated correctly.""" """Test that 'long long'-type variable expressions are evaluated correctly."""
self.build_and_run_expr('long_long.cpp', set(['long long'])) self.build_and_run_expr('long_long.cpp', set(['long long']))
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_long_long_type_from_block_with_dsym(self): def test_long_long_type_from_block_with_dsym(self):
"""Test that 'long_long'-type variables are displayed correctly from a block.""" """Test that 'long_long'-type variables are displayed correctly from a block."""
self.build_and_run_expr('long_long.cpp', set(['long long']), bc=True) self.build_and_run_expr('long_long.cpp', set(['long long']), bc=True)
@dwarf_test @dwarf_test
def test_long_long_type_with_dwarf(self): def test_long_long_type_with_dwarf(self):
"""Test that 'long long'-type variable expressions are evaluated correctly.""" """Test that 'long long'-type variable expressions are evaluated correctly."""
self.build_and_run_expr('long_long.cpp', set(['long long']), dsym=False) self.build_and_run_expr('long_long.cpp', set(['long long']), dsym=False)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_unsigned_long_long_type_with_dsym(self): def test_unsigned_long_long_type_with_dsym(self):
"""Test that 'unsigned long long'-type variable expressions are evaluated correctly.""" """Test that 'unsigned long long'-type variable expressions are evaluated correctly."""
self.build_and_run_expr('unsigned_long_long.cpp', set(['unsigned', 'long long'])) self.build_and_run_expr('unsigned_long_long.cpp', set(['unsigned', 'long long']))
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
@dsym_test @dsym_test
def test_unsigned_long_long_type_from_block_with_dsym(self): def test_unsigned_long_long_type_from_block_with_dsym(self):
"""Test that 'unsigned_long_long'-type variables are displayed correctly from a block.""" """Test that 'unsigned_long_long'-type variables are displayed correctly from a block."""
self.build_and_run_expr('unsigned_long_long.cpp', set(['unsigned', 'long long']), bc=True) self.build_and_run_expr('unsigned_long_long.cpp', set(['unsigned', 'long long']), bc=True)
@dwarf_test @dwarf_test
def test_unsigned_long_long_type_with_dwarf(self): def test_unsigned_long_long_type_with_dwarf(self):
"""Test that 'unsigned long long'-type variable expressions are evaluated correctly.""" """Test that 'unsigned long long'-type variable expressions are evaluated correctly."""
self.build_and_run_expr('unsigned_long_long.cpp', set(['unsigned', 'long long']), dsym=False) self.build_and_run_expr('unsigned_long_long.cpp', set(['unsigned', 'long long']), dsym=False)
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/warnings/uuid/TestAddDsymCommand.py

"""Test that the 'add-dsym', aka 'target symbols add', command informs the user about success or failure.""" """Test that the 'add-dsym', aka 'target symbols add', command informs the user about success or failure."""
import os, time import os, time
import unittest2 import unittest2
import lldb import lldb
from lldbtest import * from lldbtest import *
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @skipUnlessDarwin
class AddDsymCommandCase(TestBase): class AddDsymCommandCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def setUp(self): def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
self.template = 'main.cpp.template' self.template = 'main.cpp.template'
self.source = 'main.cpp' self.source = 'main.cpp'
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines