This is an archive of the discontinued LLVM Phabricator instance.

Differential D74903

[lldb][testsuite] Create a SBDebugger instance for each test
ClosedPublic

Authored by tatyana-krasnukha on Feb 20 2020, 7:45 AM.

Details

Reviewers
JDevlieghere
labath
jingham
Commits
rGa31130f6fcf2: [lldb][testsuite] Create a SBDebugger instance for each test
Summary

Some tests set settings and don't clean them up, this leads to side effects in other tests.
The patch removes a global debugger instance with a per-test debugger to avoid such effects.

From what I see, lldb.DBG was needed to determine the platform before a test is run, lldb.selected_platform is used for this purpose now. Though, this required adding a new function to the SBPlatform interface.

Diff Detail

Event Timeline

tatyana-krasnukha created this revision.Feb 20 2020, 7:45 AM
Herald added subscribers: lldb-commits, teemperor. · View Herald TranscriptFeb 20 2020, 7:45 AM
tatyana-krasnukha retitled this revision from [lldb][test] Add two wrapper-functions to manage settings in test-suite to [lldb][test] Add two wrapper functions to manage settings in test-suite.Feb 20 2020, 8:01 AM
teemperor added a comment.Feb 20 2020, 10:31 AM

I'm kinda curious how much we actually support this? I know we do a lot of random fiddling with settings and what not, but I feel if we anyway say that each test needs to have a clean setup, can't we just create like a new SBDebugger instance or something like that at test start? That would solve all the cleanup issues and cover all the hidden settings that LLDB supports (e.g. the amazing platform settings command and all that).

tatyana-krasnukha added a comment.Feb 21 2020, 12:29 AM

I like this idea and ready to implement, but I'm not aware of the reasons why the current implementation was chosen. Suppose that initializing the Debugger for each test will slow down the test-suite significantly.

labath added a subscriber: jingham.Feb 21 2020, 5:03 AM

We (mostly me and @jingham) discussed that idea (very) briefly a couple of weeks ago, and my impression was that this (reinitializing SBDebugger for every test) would be a good way to go. There are just too many things that can leak from one session into another, and since none of the default bots run in the monolithic mode, I am frankly surprised that this mode is still even remotely usable.

One thing to be aware of is that SBDebuggers are not perfectly isolated either -- some settings will leak from one debugger into another and so one still has to be careful when setting those...

tatyana-krasnukha updated this revision to Diff 247842.Mar 3 2020, 3:29 AM
tatyana-krasnukha retitled this revision from [lldb][test] Add two wrapper functions to manage settings in test-suite to [lldb][testsuite] Create a SBDebugger instance for each test.
tatyana-krasnukha edited the summary of this revision. (Show Details)
Herald added subscribers: abidh, aheejin, sbc100. · View Herald TranscriptMar 3 2020, 3:29 AM
tatyana-krasnukha planned changes to this revision.Mar 3 2020, 7:36 AM

As Pavel wrote, there are global properties that all debuggers share. That's why this approach doesn't work for me.
I'm going to add settings clear mode without arguments that will revert all the settings to their default values.

tatyana-krasnukha updated this revision to Diff 247908.Mar 3 2020, 8:24 AM

Clear all settings during a test's setUp

labath added a comment.Mar 3 2020, 8:43 AM

Overall, I don't have any big issues with this patch, but overall I see at least two distinct issues being handled here: a) changing how the platform selection works; and b) auto-clearing of settings. Please split those up into separate patches.

tatyana-krasnukha mentioned this in D75537: Clear all settings during a test's setUp.Mar 3 2020, 9:08 AM
tatyana-krasnukha added a child revision: D75537: Clear all settings during a test's setUp.
tatyana-krasnukha updated this revision to Diff 247928.Mar 3 2020, 9:13 AM

Moved settings clearing to the separate patch D75537

labath accepted this revision.Mar 4 2020, 4:10 AM
labath added a reviewer: jingham.

This is a great cleanup.

I don't believe the addition of the new SBPlatform interface is an issue, but I've added @jingham just in case he has any thoughts on that. Please give him a chance to comment on this.

This revision is now accepted and ready to land.Mar 4 2020, 4:10 AM
jingham accepted this revision.Mar 4 2020, 10:22 AM

Seems great to me. Getting the host platform is a generally useful thing to be able to do, and I can't think of anything you would want to add to this, so that is fine to.

Closed by commit rGa31130f6fcf2: [lldb][testsuite] Create a SBDebugger instance for each test (authored by tatyana-krasnukha). · Explain WhyMar 4 2020, 11:31 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
lldb/
bindings/
interface/
2 lines
include/
lldb/
API/
2 lines
packages/
Python/
lldbsuite/
test/
2 lines
30 lines
4 lines
24 lines
source/
API/
6 lines
test/
API/
commands/
target/
auto-install-main-executable/
33 lines
functionalities/
breakpoint/
breakpoint_in_delayslot/
6 lines
step_over_breakpoint/
1 line
gdb_remote_client/
8 lines
8 lines
8 lines
9 lines
8 lines
plugins/
command_plugin/
8 lines
postmortem/
elf-core/
8 lines
gcore/
7 lines
thread_crash/
8 lines
mach-core/
8 lines
minidump-new/
8 lines
8 lines
netbsd-core/
8 lines
thread/
backtrace_all/
6 lines
unwind/
noreturn/
module-end/
8 lines
macosx/
load-kext/
5 lines
python_api/
file_handle/
164 lines
tools/
lldb-server/
platform-process-connect/
22 lines

Diff 248403

lldb/bindings/interface/SBPlatform.i

Show First 20 Lines • Show All 109 Lines • ▼ Show 20 Lines
public: public:
SBPlatform (); SBPlatform ();
SBPlatform (const char *); SBPlatform (const char *);
~SBPlatform(); ~SBPlatform();
static SBPlatform GetHostPlatform();
bool bool
IsValid () const; IsValid () const;
explicit operator bool() const; explicit operator bool() const;
void void
Clear (); Clear ();
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

lldb/include/lldb/API/SBPlatform.h

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Linespublic:
SBPlatform(const char *platform_name); SBPlatform(const char *platform_name);
SBPlatform(const SBPlatform &rhs); SBPlatform(const SBPlatform &rhs);
SBPlatform &operator=(const SBPlatform &rhs); SBPlatform &operator=(const SBPlatform &rhs);
~SBPlatform(); ~SBPlatform();
static SBPlatform GetHostPlatform();
explicit operator bool() const; explicit operator bool() const;
bool IsValid() const; bool IsValid() const;
void Clear(); void Clear();
const char *GetWorkingDirectory(); const char *GetWorkingDirectory();
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 166 Lines • ▼ Show 20 Lines def fn(self):
lldbplatformutil.getHostPlatform()) lldbplatformutil.getHostPlatform())
skip_for_compiler = _match_decorator_property( skip_for_compiler = _match_decorator_property(
compiler, self.getCompiler()) and self.expectedCompilerVersion(compiler_version) compiler, self.getCompiler()) and self.expectedCompilerVersion(compiler_version)
skip_for_arch = _match_decorator_property( skip_for_arch = _match_decorator_property(
archs, self.getArchitecture()) archs, self.getArchitecture())
skip_for_debug_info = _match_decorator_property( skip_for_debug_info = _match_decorator_property(
debug_info, self.getDebugInfo()) debug_info, self.getDebugInfo())
skip_for_triple = _match_decorator_property( skip_for_triple = _match_decorator_property(
triple, lldb.DBG.GetSelectedPlatform().GetTriple()) triple, lldb.selected_platform.GetTriple())
skip_for_remote = _match_decorator_property( skip_for_remote = _match_decorator_property(
remote, lldb.remote_platform is not None) remote, lldb.remote_platform is not None)
skip_for_swig_version = ( skip_for_swig_version = (
swig_version is None) or ( swig_version is None) or (
not hasattr( not hasattr(
lldb, lldb,
'swig_version')) or ( 'swig_version')) or (
▲ Show 20 Lines • Show All 665 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 768 Lines • ▼ Show 20 Lines for name in python_test_files:
# Generate the test event. # Generate the test event.
configuration.results_formatter_object.handle_event( configuration.results_formatter_object.handle_event(
EventBuilder.event_for_job_test_add_error( EventBuilder.event_for_job_test_add_error(
test_filename, ex, backtrace)) test_filename, ex, backtrace))
raise raise
def setSetting(setting, value):
import lldb
ci = lldb.DBG.GetCommandInterpreter()
res = lldb.SBCommandReturnObject()
cmd = 'setting set %s %s'%(setting, value)
print(cmd)
ci.HandleCommand(cmd, res, False)
if not res.Succeeded():
raise Exception('failed to run "%s"'%cmd)
# ======================================== # # ======================================== #
# # # #
# Execution of the test driver starts here # # Execution of the test driver starts here #
# # # #
# ======================================== # # ======================================== #
def checkDsymForUUIDIsNotOn(): def checkDsymForUUIDIsNotOn():
Show All 9 Lines if "DBGFileMappedPaths = " in output_str:
print(output_str) print(output_str)
print( print(
"Disable automatic lookup and caching of dSYMs before running the test suite!") "Disable automatic lookup and caching of dSYMs before running the test suite!")
print("Exiting...") print("Exiting...")
sys.exit(0) sys.exit(0)
def exitTestSuite(exitCode=None): def exitTestSuite(exitCode=None):
# lldb.py does SBDebugger.Initialize().
# Call SBDebugger.Terminate() on exit.
import lldb import lldb
lldb.SBDebugger.Terminate() lldb.SBDebugger.Terminate()
if exitCode: if exitCode:
sys.exit(exitCode) sys.exit(exitCode)
def getVersionForSDK(sdk): def getVersionForSDK(sdk):
sdk = str.lower(sdk) sdk = str.lower(sdk)
▲ Show 20 Lines • Show All 106 Lines • ▼ Show 20 Linesdef checkWatchpointSupport():
if "watchpoint" in configuration.categories_list: if "watchpoint" in configuration.categories_list:
return # watchpoint category explicitly requested, let it run. return # watchpoint category explicitly requested, let it run.
print("watchpoint tests will not be run because: " + reason) print("watchpoint tests will not be run because: " + reason)
configuration.skip_categories.append("watchpoint") configuration.skip_categories.append("watchpoint")
def checkDebugInfoSupport(): def checkDebugInfoSupport():
import lldb import lldb
platform = lldb.DBG.GetSelectedPlatform().GetTriple().split('-')[2] platform = lldb.selected_platform.GetTriple().split('-')[2]
compiler = configuration.compiler compiler = configuration.compiler
skipped = [] skipped = []
for cat in test_categories.debug_info_categories: for cat in test_categories.debug_info_categories:
if cat in configuration.categories_list: if cat in configuration.categories_list:
continue # Category explicitly requested, let it run. continue # Category explicitly requested, let it run.
if test_categories.is_supported_on_platform(cat, platform, compiler): if test_categories.is_supported_on_platform(cat, platform, compiler):
continue continue
configuration.skip_categories.append(cat) configuration.skip_categories.append(cat)
Show All 13 Linesdef run_suite():
# #
parseOptionsAndInitTestdirs() parseOptionsAndInitTestdirs()
# Setup test results (test results formatter and output handling). # Setup test results (test results formatter and output handling).
setupTestResults() setupTestResults()
setupSysPath() setupSysPath()
# For the time being, let's bracket the test runner within the
# lldb.SBDebugger.Initialize()/Terminate() pair.
import lldb import lldb
# Use host platform by default.
lldb.selected_platform = lldb.SBPlatform.GetHostPlatform()
# Now we can also import lldbutil # Now we can also import lldbutil
from lldbsuite.test import lldbutil from lldbsuite.test import lldbutil
# Create a singleton SBDebugger in the lldb namespace.
lldb.DBG = lldb.SBDebugger.Create()
if configuration.lldb_platform_name: if configuration.lldb_platform_name:
print("Setting up remote platform '%s'" % print("Setting up remote platform '%s'" %
(configuration.lldb_platform_name)) (configuration.lldb_platform_name))
lldb.remote_platform = lldb.SBPlatform( lldb.remote_platform = lldb.SBPlatform(
configuration.lldb_platform_name) configuration.lldb_platform_name)
if not lldb.remote_platform.IsValid(): if not lldb.remote_platform.IsValid():
print( print(
"error: unable to create the LLDB platform named '%s'." % "error: unable to create the LLDB platform named '%s'." %
Show All 32 Lines if configuration.lldb_platform_working_dir:
configuration.lldb_platform_working_dir, 448) # 448 = 0o700 configuration.lldb_platform_working_dir, 448) # 448 = 0o700
if error.Fail(): if error.Fail():
raise Exception("making remote directory '%s': %s" % ( raise Exception("making remote directory '%s': %s" % (
configuration.lldb_platform_working_dir, error)) configuration.lldb_platform_working_dir, error))
if not lldb.remote_platform.SetWorkingDirectory( if not lldb.remote_platform.SetWorkingDirectory(
configuration.lldb_platform_working_dir): configuration.lldb_platform_working_dir):
raise Exception("failed to set working directory '%s'" % configuration.lldb_platform_working_dir) raise Exception("failed to set working directory '%s'" % configuration.lldb_platform_working_dir)
lldb.DBG.SetSelectedPlatform(lldb.remote_platform) lldb.selected_platform = lldb.remote_platform
else: else:
lldb.remote_platform = None lldb.remote_platform = None
configuration.lldb_platform_working_dir = None configuration.lldb_platform_working_dir = None
configuration.lldb_platform_url = None configuration.lldb_platform_url = None
# Set up the working directory. # Set up the working directory.
# Note that it's not dotest's job to clean this directory. # Note that it's not dotest's job to clean this directory.
build_dir = configuration.test_build_dir build_dir = configuration.test_build_dir
lldbutil.mkdir_p(build_dir) lldbutil.mkdir_p(build_dir)
target_platform = lldb.DBG.GetSelectedPlatform().GetTriple().split('-')[2] target_platform = lldb.selected_platform.GetTriple().split('-')[2]
checkLibcxxSupport() checkLibcxxSupport()
checkLibstdcxxSupport() checkLibstdcxxSupport()
checkWatchpointSupport() checkWatchpointSupport()
checkDebugInfoSupport() checkDebugInfoSupport()
# Don't do debugserver tests on anything except OS X. # Don't do debugserver tests on anything except OS X.
configuration.dont_do_debugserver_test = ( configuration.dont_do_debugserver_test = (
Show All 11 Linesdef run_suite():
for testdir in configuration.testdirs: for testdir in configuration.testdirs:
for (dirpath, dirnames, filenames) in os.walk(testdir): for (dirpath, dirnames, filenames) in os.walk(testdir):
visit('Test', dirpath, filenames) visit('Test', dirpath, filenames)
# #
# Now that we have loaded all the test cases, run the whole test suite. # Now that we have loaded all the test cases, run the whole test suite.
# #
# Set any user-overridden settings.
for key, value in configuration.settings:
setSetting(key, value)
# Install the control-c handler. # Install the control-c handler.
unittest2.signals.installHandler() unittest2.signals.installHandler()
lldbutil.mkdir_p(configuration.sdir_name) lldbutil.mkdir_p(configuration.sdir_name)
os.environ["LLDB_SESSION_DIRNAME"] = configuration.sdir_name os.environ["LLDB_SESSION_DIRNAME"] = configuration.sdir_name
sys.stderr.write( sys.stderr.write(
"\nSession logs for test failures/errors/unexpected successes" "\nSession logs for test failures/errors/unexpected successes"
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Lines p = subprocess.Popen(
stdout=subprocess.PIPE, stdout=subprocess.PIPE,
stderr=subprocess.PIPE) stderr=subprocess.PIPE)
stdout, stderr = p.communicate() stdout, stderr = p.communicate()
return p.returncode, stdout, stderr return p.returncode, stdout, stderr
def target_is_android(): def target_is_android():
if not hasattr(target_is_android, 'result'): if not hasattr(target_is_android, 'result'):
triple = lldb.DBG.GetSelectedPlatform().GetTriple() triple = lldb.selected_platform.GetTriple()
match = re.match(".*-.*-.*-android", triple) match = re.match(".*-.*-.*-android", triple)
target_is_android.result = match is not None target_is_android.result = match is not None
return target_is_android.result return target_is_android.result
def android_device_api(): def android_device_api():
if not hasattr(android_device_api, 'result'): if not hasattr(android_device_api, 'result'):
assert configuration.lldb_platform_url is not None assert configuration.lldb_platform_url is not None
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
def getDarwinOSTriples(): def getDarwinOSTriples():
return ['darwin', 'macosx', 'ios', 'watchos', 'tvos', 'bridgeos'] return ['darwin', 'macosx', 'ios', 'watchos', 'tvos', 'bridgeos']
def getPlatform(): def getPlatform():
"""Returns the target platform which the tests are running on.""" """Returns the target platform which the tests are running on."""
triple = lldb.DBG.GetSelectedPlatform().GetTriple() triple = lldb.selected_platform.GetTriple()
if triple is None: if triple is None:
# It might be an unconnected remote platform. # It might be an unconnected remote platform.
return '' return ''
platform = triple.split('-')[2] platform = triple.split('-')[2]
if platform.startswith('freebsd'): if platform.startswith('freebsd'):
platform = 'freebsd' platform = 'freebsd'
elif platform.startswith('netbsd'): elif platform.startswith('netbsd'):
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 697 Lines • ▼ Show 20 Lines def setUpCommands(cls):
# Testsuite runs in parallel and the host can have also other load. # Testsuite runs in parallel and the host can have also other load.
"settings set plugin.process.gdb-remote.packet-timeout 60", "settings set plugin.process.gdb-remote.packet-timeout 60",
'settings set symbols.clang-modules-cache-path "{}"'.format( 'settings set symbols.clang-modules-cache-path "{}"'.format(
configuration.lldb_module_cache_dir), configuration.lldb_module_cache_dir),
"settings set use-color false", "settings set use-color false",
] ]
# Set any user-overridden settings.
for setting, value in configuration.settings:
commands.append('setting set %s %s'%(setting, value))
# Make sure that a sanitizer LLDB's environment doesn't get passed on. # Make sure that a sanitizer LLDB's environment doesn't get passed on.
if cls.platformContext and cls.platformContext.shlib_environment_var in os.environ: if cls.platformContext and cls.platformContext.shlib_environment_var in os.environ:
commands.append('settings set target.env-vars {}='.format( commands.append('settings set target.env-vars {}='.format(
cls.platformContext.shlib_environment_var)) cls.platformContext.shlib_environment_var))
# Set environment variables for the inferior. # Set environment variables for the inferior.
if lldbtest_config.inferior_env: if lldbtest_config.inferior_env:
commands.append('settings set target.env-vars {}'.format( commands.append('settings set target.env-vars {}'.format(
▲ Show 20 Lines • Show All 84 Lines • ▼ Show 20 Lines def setUp(self):
# See HideStdout(self). # See HideStdout(self).
self.sys_stdout_hidden = False self.sys_stdout_hidden = False
if self.platformContext: if self.platformContext:
# set environment variable names for finding shared libraries # set environment variable names for finding shared libraries
self.dylibPath = self.platformContext.shlib_environment_var self.dylibPath = self.platformContext.shlib_environment_var
# Create the debugger instance if necessary. # Create the debugger instance.
try:
self.dbg = lldb.DBG
except AttributeError:
self.dbg = lldb.SBDebugger.Create() self.dbg = lldb.SBDebugger.Create()
# Copy selected platform from a global instance if it exists.
if lldb.selected_platform is not None:
self.dbg.SetSelectedPlatform(lldb.selected_platform)
if not self.dbg: if not self.dbg:
raise Exception('Invalid debugger instance') raise Exception('Invalid debugger instance')
# Retrieve the associated command interpreter instance. # Retrieve the associated command interpreter instance.
self.ci = self.dbg.GetCommandInterpreter() self.ci = self.dbg.GetCommandInterpreter()
if not self.ci: if not self.ci:
raise Exception('Could not get the command interpreter') raise Exception('Could not get the command interpreter')
▲ Show 20 Lines • Show All 194 Lines • ▼ Show 20 Lines def tearDown(self):
self.cleanup(dictionary=self.dict) self.cleanup(dictionary=self.dict)
# In rare cases where there are multiple teardown cleanups added. # In rare cases where there are multiple teardown cleanups added.
if doCleanup and self.doTearDownCleanups: if doCleanup and self.doTearDownCleanups:
if self.dicts: if self.dicts:
for dict in reversed(self.dicts): for dict in reversed(self.dicts):
self.cleanup(dictionary=dict) self.cleanup(dictionary=dict)
# This must be the last statement, otherwise teardown hooks or other
# lines might depend on this still being active.
lldb.SBDebugger.Destroy(self.dbg)
del self.dbg
# ========================================================= # =========================================================
# Various callbacks to allow introspection of test progress # Various callbacks to allow introspection of test progress
# ========================================================= # =========================================================
def markError(self): def markError(self):
"""Callback invoked when an error (unexpected exception) errored.""" """Callback invoked when an error (unexpected exception) errored."""
self.__errored__ = True self.__errored__ = True
with recording(self, False) as sbuf: with recording(self, False) as sbuf:
▲ Show 20 Lines • Show All 960 Lines • ▼ Show 20 Lines def tearDown(self):
rc = self.invoke(process, "Kill") rc = self.invoke(process, "Kill")
self.assertTrue(rc.Success(), PROCESS_KILLED) self.assertTrue(rc.Success(), PROCESS_KILLED)
for target in targets: for target in targets:
self.dbg.DeleteTarget(target) self.dbg.DeleteTarget(target)
# Do this last, to make sure it's in reverse order from how we setup. # Do this last, to make sure it's in reverse order from how we setup.
Base.tearDown(self) Base.tearDown(self)
# This must be the last statement, otherwise teardown hooks or other
# lines might depend on this still being active.
del self.dbg
def switch_to_thread_with_stop_reason(self, stop_reason): def switch_to_thread_with_stop_reason(self, stop_reason):
""" """
Run the 'thread list' command, and select the thread with stop reason as Run the 'thread list' command, and select the thread with stop reason as
'stop_reason'. If no such thread exists, no select action is done. 'stop_reason'. If no such thread exists, no select action is done.
""" """
from .lldbutil import stop_reason_to_str from .lldbutil import stop_reason_to_str
self.runCmd('thread list') self.runCmd('thread list')
output = self.res.GetOutput() output = self.res.GetOutput()
▲ Show 20 Lines • Show All 534 Lines • Show Last 20 Lines

lldb/source/API/SBPlatform.cpp

Show First 20 Lines • Show All 297 Lines • ▼ Show 20 Lines LLDB_RECORD_METHOD(SBPlatform &,
SBPlatform, operator=,(const lldb::SBPlatform &), rhs); SBPlatform, operator=,(const lldb::SBPlatform &), rhs);
m_opaque_sp = rhs.m_opaque_sp; m_opaque_sp = rhs.m_opaque_sp;
return LLDB_RECORD_RESULT(*this); return LLDB_RECORD_RESULT(*this);
} }
SBPlatform::~SBPlatform() = default; SBPlatform::~SBPlatform() = default;
SBPlatform SBPlatform::GetHostPlatform() {
SBPlatform host_platform;
host_platform.m_opaque_sp = Platform::GetHostPlatform();
return host_platform;
}
bool SBPlatform::IsValid() const { bool SBPlatform::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBPlatform, IsValid); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBPlatform, IsValid);
return this->operator bool(); return this->operator bool();
} }
SBPlatform::operator bool() const { SBPlatform::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBPlatform, operator bool); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBPlatform, operator bool);
return m_opaque_sp.get() != nullptr; return m_opaque_sp.get() != nullptr;
▲ Show 20 Lines • Show All 429 Lines • Show Last 20 Lines

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

""" """
Test target commands: target.auto-install-main-executable. Test target commands: target.auto-install-main-executable.
""" """
import time import time
import gdbremote_testcase import gdbremote_testcase
from lldbsuite.test.decorators import * from lldbsuite.test.decorators import *
from lldbsuite.test.lldbtest import * from lldbsuite.test.lldbtest import *
from lldbsuite.test import lldbutil from lldbsuite.test import lldbutil
class TestAutoInstallMainExecutable(gdbremote_testcase.GdbRemoteTestCaseBase): class TestAutoInstallMainExecutable(gdbremote_testcase.GdbRemoteTestCaseBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def setUp(self):
super(TestAutoInstallMainExecutable, self).setUp()
self._initial_platform = lldb.DBG.GetSelectedPlatform()
def tearDown(self):
lldb.DBG.SetSelectedPlatform(self._initial_platform)
super(TestAutoInstallMainExecutable, self).tearDown()
@llgs_test @llgs_test
@no_debug_info_test @no_debug_info_test
@skipIf(remote=False) @skipIf(remote=False)
@expectedFailureAll(hostoslist=["windows"], triple='.*-android') @expectedFailureAll(hostoslist=["windows"], triple='.*-android')
def test_target_auto_install_main_executable(self): def test_target_auto_install_main_executable(self):
self.build() self.build()
self.init_llgs_test(False) self.init_llgs_test(False)
Show All 24 Lines def test_target_auto_install_main_executable(self):
self.debug_monitor_exe, self.debug_monitor_exe,
commandline_args, commandline_args,
install_remote=False) install_remote=False)
self.addTearDownHook(self.cleanupSubprocesses) self.addTearDownHook(self.cleanupSubprocesses)
# Wait for the new process gets ready. # Wait for the new process gets ready.
time.sleep(0.1) time.sleep(0.1)
new_debugger = lldb.SBDebugger.Create() self.dbg.SetAsync(False)
new_debugger.SetAsync(False)
def del_debugger(new_debugger=new_debugger):
del new_debugger
self.addTearDownHook(del_debugger)
new_platform = lldb.SBPlatform(lldb.remote_platform.GetName()) new_platform = lldb.SBPlatform(lldb.remote_platform.GetName())
new_debugger.SetSelectedPlatform(new_platform) self.dbg.SetSelectedPlatform(new_platform)
new_interpreter = new_debugger.GetCommandInterpreter() interpreter = self.dbg.GetCommandInterpreter()
connect_url = "%s://%s:%s" % (protocol, hostname, str(hostport+1)) connect_url = "%s://%s:%s" % (protocol, hostname, str(hostport+1))
command = "platform connect %s" % (connect_url) command = "platform connect %s" % (connect_url)
result = lldb.SBCommandReturnObject() result = lldb.SBCommandReturnObject()
# Test the default setting. # Test the default setting.
new_interpreter.HandleCommand("settings show target.auto-install-main-executable", result) interpreter.HandleCommand("settings show target.auto-install-main-executable", result)
self.assertTrue( self.assertTrue(
result.Succeeded() and result.Succeeded() and
"target.auto-install-main-executable (boolean) = true" in result.GetOutput(), "target.auto-install-main-executable (boolean) = true" in result.GetOutput(),
"Default settings for target.auto-install-main-executable failed.: %s - %s" % "Default settings for target.auto-install-main-executable failed.: %s - %s" %
(result.GetOutput(), result.GetError())) (result.GetOutput(), result.GetError()))
# Disable the auto install. # Disable the auto install.
new_interpreter.HandleCommand("settings set target.auto-install-main-executable false", result) interpreter.HandleCommand("settings set target.auto-install-main-executable false", result)
new_interpreter.HandleCommand("settings show target.auto-install-main-executable", result) interpreter.HandleCommand("settings show target.auto-install-main-executable", result)
self.assertTrue( self.assertTrue(
result.Succeeded() and result.Succeeded() and
"target.auto-install-main-executable (boolean) = false" in result.GetOutput(), "target.auto-install-main-executable (boolean) = false" in result.GetOutput(),
"Default settings for target.auto-install-main-executable failed.: %s - %s" % "Default settings for target.auto-install-main-executable failed.: %s - %s" %
(result.GetOutput(), result.GetError())) (result.GetOutput(), result.GetError()))
new_interpreter.HandleCommand("platform select %s"%configuration.lldb_platform_name, result) interpreter.HandleCommand("platform select %s"%configuration.lldb_platform_name, result)
new_interpreter.HandleCommand(command, result) interpreter.HandleCommand(command, result)
self.assertTrue( self.assertTrue(
result.Succeeded(), result.Succeeded(),
"platform process connect failed: %s - %s" % "platform process connect failed: %s - %s" %
(result.GetOutput(),result.GetError())) (result.GetOutput(),result.GetError()))
# Create the target with the original file. # Create the target with the original file.
new_interpreter.HandleCommand("target create --remote-file %s %s "% interpreter.HandleCommand("target create --remote-file %s %s "%
(os.path.join(working_dir,dest.GetFilename()), self.getBuildArtifact("a.out")), (os.path.join(working_dir,dest.GetFilename()), self.getBuildArtifact("a.out")),
result) result)
self.assertTrue( self.assertTrue(
result.Succeeded(), result.Succeeded(),
"platform create failed: %s - %s" % "platform create failed: %s - %s" %
(result.GetOutput(),result.GetError())) (result.GetOutput(),result.GetError()))
target = new_debugger.GetSelectedTarget() target = new_debugger.GetSelectedTarget()
breakpoint = target.BreakpointCreateByName("main") breakpoint = target.BreakpointCreateByName("main")
launch_info = lldb.SBLaunchInfo(None) launch_info = lldb.SBLaunchInfo(None)
error = lldb.SBError() error = lldb.SBError()
process = target.Launch(launch_info, error) process = target.Launch(launch_info, error)
self.assertTrue(process, PROCESS_IS_VALID) self.assertTrue(process, PROCESS_IS_VALID)
thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint) thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
self.assertTrue( self.assertTrue(
thread.IsValid(), thread.IsValid(),
"There should be a thread stopped due to breakpoint") "There should be a thread stopped due to breakpoint")
frame = thread.GetFrameAtIndex(0) frame = thread.GetFrameAtIndex(0)
self.assertEqual(frame.GetFunction().GetName(), "main") self.assertEqual(frame.GetFunction().GetName(), "main")
new_interpreter.HandleCommand("target variable build", result) interpreter.HandleCommand("target variable build", result)
self.assertTrue( self.assertTrue(
result.Succeeded() and result.Succeeded() and
'"device"' in result.GetOutput(), '"device"' in result.GetOutput(),
"Magic in the binary is wrong: %s " % result.GetOutput()) "Magic in the binary is wrong: %s " % result.GetOutput())
process.Continue() process.Continue()

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

Show First 20 Lines • Show All 73 Lines • ▼ Show 20 Lines def function(self, function, target):
bpaddr = location.GetLoadAddress() bpaddr = location.GetLoadAddress()
# Breakpoint address should be adjusted to the address of # Breakpoint address should be adjusted to the address of
# branch instruction. # branch instruction.
self.assertTrue(branchinstaddress == bpaddr) self.assertTrue(branchinstaddress == bpaddr)
i += 1 i += 1
else: else:
i += 1 i += 1
if __name__ == '__main__':
import atexit
lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main()

lldb/test/API/functionalities/breakpoint/step_over_breakpoint/TestStepOverBreakpoint.py

Show First 20 Lines • Show All 81 Lines • ▼ Show 20 Lines def test_step_instruction(self):
break break
# Run the process until termination # Run the process until termination
self.process.Continue() self.process.Continue()
self.assertEquals(self.process.GetState(), lldb.eStateExited) self.assertEquals(self.process.GetState(), lldb.eStateExited)
@skipIf(bugnumber="llvm.org/pr31972", hostoslist=["windows"]) @skipIf(bugnumber="llvm.org/pr31972", hostoslist=["windows"])
def test_step_over(self): def test_step_over(self):
#lldb.DBG.EnableLog("lldb", ["step","breakpoint"])
self.thread.StepOver() self.thread.StepOver()
# We should be stopped at the breakpoint_2 line with stop plan complete reason # We should be stopped at the breakpoint_2 line with stop plan complete reason
self.assertEquals(self.process.GetState(), lldb.eStateStopped) self.assertEquals(self.process.GetState(), lldb.eStateStopped)
self.assertEquals(self.thread.GetStopReason(), lldb.eStopReasonPlanComplete) self.assertEquals(self.thread.GetStopReason(), lldb.eStopReasonPlanComplete)
self.thread.StepOver() self.thread.StepOver()
# We should be stopped at the breakpoint_3 line with stop plan complete reason # We should be stopped at the breakpoint_3 line with stop plan complete reason
Show All 20 Lines

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

import lldb import lldb
import binascii import binascii
from lldbsuite.test.lldbtest import * from lldbsuite.test.lldbtest import *
from lldbsuite.test.decorators import * from lldbsuite.test.decorators import *
from gdbclientutils import * from gdbclientutils import *
class TestGDBRemoteClient(GDBRemoteTestBase): class TestGDBRemoteClient(GDBRemoteTestBase):
class gPacketResponder(MockGDBServerResponder): class gPacketResponder(MockGDBServerResponder):
def readRegisters(self): def readRegisters(self):
return '0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000' return '0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000'
def setUp(self):
super(TestGDBRemoteClient, self).setUp()
self._initial_platform = lldb.DBG.GetSelectedPlatform()
def tearDown(self):
lldb.DBG.SetSelectedPlatform(self._initial_platform)
super(TestGDBRemoteClient, self).tearDown()
def test_connect(self): def test_connect(self):
"""Test connecting to a remote gdb server""" """Test connecting to a remote gdb server"""
target = self.createTarget("a.yaml") target = self.createTarget("a.yaml")
process = self.connect(target) process = self.connect(target)
self.assertPacketLogContains(["qProcessInfo", "qfThreadInfo"]) self.assertPacketLogContains(["qProcessInfo", "qfThreadInfo"])
def test_attach_fail(self): def test_attach_fail(self):
error_msg = "mock-error-msg" error_msg = "mock-error-msg"
▲ Show 20 Lines • Show All 122 Lines • Show Last 20 Lines

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

import lldb import lldb
from lldbsuite.test.lldbtest import * from lldbsuite.test.lldbtest import *
from lldbsuite.test.decorators import * from lldbsuite.test.decorators import *
from gdbclientutils import * from gdbclientutils import *
class TestGDBRemoteLoad(GDBRemoteTestBase): class TestGDBRemoteLoad(GDBRemoteTestBase):
def setUp(self):
super(TestGDBRemoteLoad, self).setUp()
self._initial_platform = lldb.DBG.GetSelectedPlatform()
def tearDown(self):
lldb.DBG.SetSelectedPlatform(self._initial_platform)
super(TestGDBRemoteLoad, self).tearDown()
def test_module_load_address(self): def test_module_load_address(self):
"""Test that setting the load address of a module uses virtual addresses""" """Test that setting the load address of a module uses virtual addresses"""
target = self.createTarget("a.yaml") target = self.createTarget("a.yaml")
process = self.connect(target) process = self.connect(target)
module = target.GetModuleAtIndex(0) module = target.GetModuleAtIndex(0)
self.assertTrue(module.IsValid()) self.assertTrue(module.IsValid())
self.assertTrue(target.SetModuleLoadAddress(module, 0).Success()) self.assertTrue(target.SetModuleLoadAddress(module, 0).Success())
address = target.ResolveLoadAddress(0x2001) address = target.ResolveLoadAddress(0x2001)
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 80 Lines • ▼ Show 20 Lines def readMemory(self, addr, length):
for i in range(addr_from, addr_to): for i in range(addr_from, addr_to):
result += format(file_content[i], '02x') result += format(file_content[i], '02x')
file.close() file.close()
return result return result
class TestWasm(GDBRemoteTestBase): class TestWasm(GDBRemoteTestBase):
def setUp(self):
super(TestWasm, self).setUp()
self._initial_platform = lldb.DBG.GetSelectedPlatform()
def tearDown(self):
lldb.DBG.SetSelectedPlatform(self._initial_platform)
super(TestWasm, self).tearDown()
@skipIfAsan @skipIfAsan
@skipIfXmlSupportMissing @skipIfXmlSupportMissing
def test_load_module_with_embedded_symbols_from_remote(self): def test_load_module_with_embedded_symbols_from_remote(self):
"""Test connecting to a WebAssembly engine via GDB-remote and loading a Wasm module with embedded DWARF symbols""" """Test connecting to a WebAssembly engine via GDB-remote and loading a Wasm module with embedded DWARF symbols"""
yaml_path = "test_wasm_embedded_debug_sections.yaml" yaml_path = "test_wasm_embedded_debug_sections.yaml"
yaml_base, ext = os.path.splitext(yaml_path) yaml_base, ext = os.path.splitext(yaml_path)
obj_path = self.getBuildArtifact(yaml_base) obj_path = self.getBuildArtifact(yaml_base)
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

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

import lldb import lldb
from lldbsuite.test.lldbtest import * from lldbsuite.test.lldbtest import *
from lldbsuite.test.decorators import * from lldbsuite.test.decorators import *
from gdbclientutils import * from gdbclientutils import *
class TestWriteMemory(GDBRemoteTestBase): class TestWriteMemory(GDBRemoteTestBase):
def setUp(self):
super(TestWriteMemory, self).setUp()
self._initial_platform = lldb.DBG.GetSelectedPlatform()
def tearDown(self):
lldb.DBG.SetSelectedPlatform(self._initial_platform)
super(TestWriteMemory, self).tearDown()
def test(self): def test(self):
class MyResponder(MockGDBServerResponder): class MyResponder(MockGDBServerResponder):
def setBreakpoint(self, packet): def setBreakpoint(self, packet):
return "OK" return "OK"
self.server.responder = MyResponder() self.server.responder = MyResponder()
target = self.dbg.CreateTargetWithFileAndTargetTriple('', 'x86_64-pc-linux') target = self.dbg.CreateTargetWithFileAndTargetTriple('', 'x86_64-pc-linux')
Show All 12 Lines

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

import lldb import lldb
from lldbsuite.test.lldbtest import * from lldbsuite.test.lldbtest import *
from lldbsuite.test.decorators import * from lldbsuite.test.decorators import *
from gdbclientutils import * from gdbclientutils import *
class TestqOffsets(GDBRemoteTestBase): class TestqOffsets(GDBRemoteTestBase):
class Responder(MockGDBServerResponder): class Responder(MockGDBServerResponder):
def qOffsets(self): def qOffsets(self):
return 'Text=470000;Data=470000' return 'Text=470000;Data=470000'
def setUp(self):
super(TestqOffsets, self).setUp()
self._initial_platform = lldb.DBG.GetSelectedPlatform()
def tearDown(self):
lldb.DBG.SetSelectedPlatform(self._initial_platform)
super(TestqOffsets, self).tearDown()
def test(self): def test(self):
self.server.responder = TestqOffsets.Responder() self.server.responder = TestqOffsets.Responder()
target = self.createTarget("qOffsets.yaml") target = self.createTarget("qOffsets.yaml")
text = target.modules[0].FindSection(".text") text = target.modules[0].FindSection(".text")
self.assertEquals(text.GetLoadAddress(target), lldb.LLDB_INVALID_ADDRESS) self.assertEquals(text.GetLoadAddress(target), lldb.LLDB_INVALID_ADDRESS)
process = self.connect(target) process = self.connect(target)
self.assertEquals(text.GetLoadAddress(target), 0x471000) self.assertEquals(text.GetLoadAddress(target), 0x471000)

lldb/test/API/functionalities/plugins/command_plugin/TestPluginCommands.py

Show All 31 Lines def test_load_plugin(self):
if sys.platform.startswith("darwin"): if sys.platform.startswith("darwin"):
plugin_lib_name = "lib%s.dylib" % plugin_name plugin_lib_name = "lib%s.dylib" % plugin_name
else: else:
plugin_lib_name = "lib%s.so" % plugin_name plugin_lib_name = "lib%s.so" % plugin_name
# Invoke the library build rule. # Invoke the library build rule.
self.buildLibrary("plugin.cpp", plugin_name) self.buildLibrary("plugin.cpp", plugin_name)
debugger = lldb.SBDebugger.Create()
retobj = lldb.SBCommandReturnObject() retobj = lldb.SBCommandReturnObject()
retval = debugger.GetCommandInterpreter().HandleCommand( retval = self.dbg.GetCommandInterpreter().HandleCommand(
"plugin load %s" % self.getBuildArtifact(plugin_lib_name), retobj) "plugin load %s" % self.getBuildArtifact(plugin_lib_name), retobj)
retobj.Clear() retobj.Clear()
retval = debugger.GetCommandInterpreter().HandleCommand( retval = self.dbg.GetCommandInterpreter().HandleCommand(
"plugin_loaded_command child abc def ghi", retobj) "plugin_loaded_command child abc def ghi", retobj)
if self.TraceOn(): if self.TraceOn():
print(retobj.GetOutput()) print(retobj.GetOutput())
self.expect(retobj, substrs=['abc def ghi'], exe=False) self.expect(retobj, substrs=['abc def ghi'], exe=False)
retobj.Clear() retobj.Clear()
# check that abbreviations work correctly in plugin commands. # check that abbreviations work correctly in plugin commands.
retval = debugger.GetCommandInterpreter().HandleCommand( retval = self.dbg.GetCommandInterpreter().HandleCommand(
"plugin_loaded_ ch abc def ghi", retobj) "plugin_loaded_ ch abc def ghi", retobj)
if self.TraceOn(): if self.TraceOn():
print(retobj.GetOutput()) print(retobj.GetOutput())
self.expect(retobj, substrs=['abc def ghi'], exe=False) self.expect(retobj, substrs=['abc def ghi'], exe=False)
@no_debug_info_test @no_debug_info_test
Show All 10 Lines

lldb/test/API/functionalities/postmortem/elf-core/TestLinuxCore.py

Show All 27 Linesclass LinuxCoreTestCase(TestBase):
_ppc64le_pid = 28147 _ppc64le_pid = 28147
_i386_regions = 4 _i386_regions = 4
_x86_64_regions = 5 _x86_64_regions = 5
_s390x_regions = 2 _s390x_regions = 2
_mips_regions = 5 _mips_regions = 5
_ppc64le_regions = 2 _ppc64le_regions = 2
def setUp(self):
super(LinuxCoreTestCase, self).setUp()
self._initial_platform = lldb.DBG.GetSelectedPlatform()
def tearDown(self):
lldb.DBG.SetSelectedPlatform(self._initial_platform)
super(LinuxCoreTestCase, self).tearDown()
@skipIf(triple='^mips') @skipIf(triple='^mips')
@skipIfLLVMTargetMissing("X86") @skipIfLLVMTargetMissing("X86")
def test_i386(self): def test_i386(self):
"""Test that lldb can read the process information from an i386 linux core file.""" """Test that lldb can read the process information from an i386 linux core file."""
self.do_test("linux-i386", self._i386_pid, self._i386_regions, "a.out") self.do_test("linux-i386", self._i386_pid, self._i386_regions, "a.out")
@skipIfLLVMTargetMissing("Mips") @skipIfLLVMTargetMissing("Mips")
def test_mips_o32(self): def test_mips_o32(self):
▲ Show 20 Lines • Show All 328 Lines • Show Last 20 Lines

lldb/test/API/functionalities/postmortem/elf-core/gcore/TestGCore.py

""" """
Test signal reporting when debugging with linux core files. Test signal reporting when debugging with linux core files.
""" """
import lldb import lldb
from lldbsuite.test.decorators import * from lldbsuite.test.decorators import *
from lldbsuite.test.lldbtest import * from lldbsuite.test.lldbtest import *
from lldbsuite.test import lldbutil from lldbsuite.test import lldbutil
class GCoreTestCase(TestBase): class GCoreTestCase(TestBase):
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def setUp(self):
super(GCoreTestCase, self).setUp()
self._initial_platform = lldb.DBG.GetSelectedPlatform()
def tearDown(self):
lldb.DBG.SetSelectedPlatform(self._initial_platform)
super(GCoreTestCase, self).tearDown()
_i386_pid = 5586 _i386_pid = 5586
_x86_64_pid = 5669 _x86_64_pid = 5669
@skipIf(oslist=['windows']) @skipIf(oslist=['windows'])
@skipIf(triple='^mips') @skipIf(triple='^mips')
def test_i386(self): def test_i386(self):
"""Test that lldb can read the process information from an i386 linux core file.""" """Test that lldb can read the process information from an i386 linux core file."""
Show All 23 Lines

lldb/test/API/functionalities/postmortem/elf-core/thread_crash/TestLinuxCoreThreads.py

Show All 9 Lines
from lldbsuite.test import lldbutil from lldbsuite.test import lldbutil
class LinuxCoreThreadsTestCase(TestBase): class LinuxCoreThreadsTestCase(TestBase):
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def setUp(self):
super(LinuxCoreThreadsTestCase, self).setUp()
self._initial_platform = lldb.DBG.GetSelectedPlatform()
def tearDown(self):
lldb.DBG.SetSelectedPlatform(self._initial_platform)
super(LinuxCoreThreadsTestCase, self).tearDown()
_i386_pid = 5193 _i386_pid = 5193
_x86_64_pid = 5222 _x86_64_pid = 5222
# Thread id for the failing thread. # Thread id for the failing thread.
_i386_tid = 5195 _i386_tid = 5195
_x86_64_tid = 5250 _x86_64_tid = 5250
@skipIf(oslist=['windows']) @skipIf(oslist=['windows'])
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

lldb/test/API/functionalities/postmortem/mach-core/TestMachCore.py

Show All 9 Lines
from lldbsuite.test import lldbutil from lldbsuite.test import lldbutil
class MachCoreTestCase(TestBase): class MachCoreTestCase(TestBase):
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def setUp(self):
super(MachCoreTestCase, self).setUp()
self._initial_platform = lldb.DBG.GetSelectedPlatform()
def tearDown(self):
lldb.DBG.SetSelectedPlatform(self._initial_platform)
super(MachCoreTestCase, self).tearDown()
# This was originally marked as expected failure on Windows, but it has # This was originally marked as expected failure on Windows, but it has
# started timing out instead, so the expectedFailure attribute no longer # started timing out instead, so the expectedFailure attribute no longer
# correctly tracks it: llvm.org/pr37371 # correctly tracks it: llvm.org/pr37371
@skipIfWindows @skipIfWindows
def test_selected_thread(self): def test_selected_thread(self):
"""Test that the right thread is selected after a core is loaded.""" """Test that the right thread is selected after a core is loaded."""
# Create core form YAML. # Create core form YAML.
self.yaml2obj("test.core.yaml", self.getBuildArtifact("test.core")) self.yaml2obj("test.core.yaml", self.getBuildArtifact("test.core"))
Show All 36 Lines

lldb/test/API/functionalities/postmortem/minidump-new/TestMiniDumpNew.py

Show All 16 Linesclass MiniDumpNewTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
_linux_x86_64_pid = 29917 _linux_x86_64_pid = 29917
_linux_x86_64_not_crashed_pid = 29939 _linux_x86_64_not_crashed_pid = 29939
_linux_x86_64_not_crashed_pid_offset = 0xD967 _linux_x86_64_not_crashed_pid_offset = 0xD967
def setUp(self):
super(MiniDumpNewTestCase, self).setUp()
self._initial_platform = lldb.DBG.GetSelectedPlatform()
def tearDown(self):
lldb.DBG.SetSelectedPlatform(self._initial_platform)
super(MiniDumpNewTestCase, self).tearDown()
def process_from_yaml(self, yaml_file): def process_from_yaml(self, yaml_file):
minidump_path = self.getBuildArtifact(os.path.basename(yaml_file) + ".dmp") minidump_path = self.getBuildArtifact(os.path.basename(yaml_file) + ".dmp")
self.yaml2obj(yaml_file, minidump_path) self.yaml2obj(yaml_file, minidump_path)
self.target = self.dbg.CreateTarget(None) self.target = self.dbg.CreateTarget(None)
self.process = self.target.LoadCore(minidump_path) self.process = self.target.LoadCore(minidump_path)
return self.process return self.process
def check_state(self): def check_state(self):
▲ Show 20 Lines • Show All 423 Lines • Show Last 20 Lines

lldb/test/API/functionalities/postmortem/minidump-new/TestMiniDumpUUID.py

Show All 12 Lines
class MiniDumpUUIDTestCase(TestBase): class MiniDumpUUIDTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
def setUp(self):
super(MiniDumpUUIDTestCase, self).setUp()
self._initial_platform = lldb.DBG.GetSelectedPlatform()
def tearDown(self):
lldb.DBG.SetSelectedPlatform(self._initial_platform)
super(MiniDumpUUIDTestCase, self).tearDown()
def verify_module(self, module, verify_path, verify_uuid): def verify_module(self, module, verify_path, verify_uuid):
uuid = module.GetUUIDString() uuid = module.GetUUIDString()
self.assertEqual(verify_path, module.GetFileSpec().fullpath) self.assertEqual(verify_path, module.GetFileSpec().fullpath)
self.assertEqual(verify_uuid, uuid) self.assertEqual(verify_uuid, uuid)
def get_minidump_modules(self, yaml_file): def get_minidump_modules(self, yaml_file):
minidump_path = self.getBuildArtifact(os.path.basename(yaml_file) + ".dmp") minidump_path = self.getBuildArtifact(os.path.basename(yaml_file) + ".dmp")
self.yaml2obj(yaml_file, minidump_path) self.yaml2obj(yaml_file, minidump_path)
▲ Show 20 Lines • Show All 159 Lines • Show Last 20 Lines

lldb/test/API/functionalities/postmortem/netbsd-core/TestNetBSDCore.py

Show All 12 Lines
from lldbsuite.test import lldbutil from lldbsuite.test import lldbutil
class NetBSDCoreCommonTestCase(TestBase): class NetBSDCoreCommonTestCase(TestBase):
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def setUp(self):
super(NetBSDCoreCommonTestCase, self).setUp()
self._initial_platform = lldb.DBG.GetSelectedPlatform()
def tearDown(self):
lldb.DBG.SetSelectedPlatform(self._initial_platform)
super(NetBSDCoreCommonTestCase, self).tearDown()
def check_memory_regions(self, process, region_count): def check_memory_regions(self, process, region_count):
region_list = process.GetMemoryRegions() region_list = process.GetMemoryRegions()
self.assertEqual(region_list.GetSize(), region_count) self.assertEqual(region_list.GetSize(), region_count)
region = lldb.SBMemoryRegionInfo() region = lldb.SBMemoryRegionInfo()
# Check we have the right number of regions. # Check we have the right number of regions.
self.assertEqual(region_list.GetSize(), region_count) self.assertEqual(region_list.GetSize(), region_count)
▲ Show 20 Lines • Show All 201 Lines • Show Last 20 Lines

lldb/test/API/functionalities/thread/backtrace_all/TestBacktraceAll.py

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Lines def test(self):
'stop reason = breakpoint']) 'stop reason = breakpoint'])
# This should not result in a segmentation fault # This should not result in a segmentation fault
self.expect("thread backtrace all", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread backtrace all", STOPPED_DUE_TO_BREAKPOINT,
substrs=["stop reason = breakpoint 1."]) substrs=["stop reason = breakpoint 1."])
# Run to completion # Run to completion
self.runCmd("continue") self.runCmd("continue")
if __name__ == '__main__':
import atexit
lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main()

lldb/test/API/functionalities/unwind/noreturn/module-end/TestNoReturnModuleEnd.py

Show All 9 Lines
from lldbsuite.test.lldbtest import * from lldbsuite.test.lldbtest import *
from lldbsuite.test import lldbutil from lldbsuite.test import lldbutil
class TestNoreturnModuleEnd(TestBase): class TestNoreturnModuleEnd(TestBase):
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def setUp(self):
super(TestNoreturnModuleEnd, self).setUp()
self._initial_platform = lldb.DBG.GetSelectedPlatform()
def tearDown(self):
lldb.DBG.SetSelectedPlatform(self._initial_platform)
super(TestNoreturnModuleEnd, self).tearDown()
def test(self): def test(self):
target = self.dbg.CreateTarget("test.out") target = self.dbg.CreateTarget("test.out")
process = target.LoadCore("test.core") process = target.LoadCore("test.core")
self.assertTrue(process.IsValid(), PROCESS_IS_VALID) self.assertTrue(process.IsValid(), PROCESS_IS_VALID)
self.assertEqual(process.GetNumThreads(), 1) self.assertEqual(process.GetNumThreads(), 1)
thread = process.GetSelectedThread() thread = process.GetSelectedThread()
self.assertTrue(thread.IsValid()) self.assertTrue(thread.IsValid())
Show All 17 Lines

lldb/test/API/macosx/load-kext/TestLoadKext.py

Show All 9 Lines
from lldbsuite.test import lldbutil from lldbsuite.test import lldbutil
class LoadKextTestCase(TestBase): class LoadKextTestCase(TestBase):
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def setUp(self):
TestBase.setUp(self)
#super(LoadKextTestCase, self).setUp()
#self._initial_platform = lldb.DBG.GetSelectedPlatform()
def test_load_kext(self): def test_load_kext(self):
"""Test that lldb can load a kext binary.""" """Test that lldb can load a kext binary."""
# Create kext from YAML. # Create kext from YAML.
self.yaml2obj("mykext.yaml", self.getBuildArtifact("mykext")) self.yaml2obj("mykext.yaml", self.getBuildArtifact("mykext"))
target = self.dbg.CreateTarget(self.getBuildArtifact("mykext")) target = self.dbg.CreateTarget(self.getBuildArtifact("mykext"))
self.assertTrue(target.IsValid()) self.assertTrue(target.IsValid())
self.assertEqual(target.GetNumModules(), 1) self.assertEqual(target.GetNumModules(), 1)
mod = target.GetModuleAtIndex(0) mod = target.GetModuleAtIndex(0)
self.assertEqual(mod.GetFileSpec().GetFilename(), "mykext") self.assertEqual(mod.GetFileSpec().GetFilename(), "mykext")

lldb/test/API/python_api/file_handle/TestFileHandle.py

Show First 20 Lines • Show All 76 Lines • ▼ Show 20 Linesdef readStrippedLines(f):
return list(i()) return list(i())
class FileHandleTestCase(lldbtest.TestBase): class FileHandleTestCase(lldbtest.TestBase):
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
mydir = lldbtest.Base.compute_mydir(__file__) mydir = lldbtest.Base.compute_mydir(__file__)
# The way this class interacts with the debugger is different # The way normal tests evaluate debugger commands is
# than normal. Most of these test cases will mess with the
# debugger I/O streams, so we want a fresh debugger for each
# test so those mutations don't interfere with each other.
#
# Also, the way normal tests evaluate debugger commands is
# by using a SBCommandInterpreter directly, which captures # by using a SBCommandInterpreter directly, which captures
# the output in a result object. For many of tests tests # the output in a result object. For many of tests tests
# we want the debugger to write the output directly to # we want the debugger to write the output directly to
# its I/O streams like it would have done interactively. # its I/O streams like it would have done interactively.
# #
# For this reason we also define handleCmd() here, even though # For this reason we also define handleCmd() here, even though
# it is similar to runCmd(). # it is similar to runCmd().
def setUp(self): def setUp(self):
super(FileHandleTestCase, self).setUp() super(FileHandleTestCase, self).setUp()
self.debugger = lldb.SBDebugger.Create()
self.out_filename = self.getBuildArtifact('output') self.out_filename = self.getBuildArtifact('output')
self.in_filename = self.getBuildArtifact('input') self.in_filename = self.getBuildArtifact('input')
def tearDown(self): def tearDown(self):
lldb.SBDebugger.Destroy(self.debugger)
super(FileHandleTestCase, self).tearDown() super(FileHandleTestCase, self).tearDown()
for name in (self.out_filename, self.in_filename): for name in (self.out_filename, self.in_filename):
if os.path.exists(name): if os.path.exists(name):
os.unlink(name) os.unlink(name)
# Similar to runCmd(), but this uses the per-test debugger, and it # Similar to runCmd(), but letting the debugger just print the results
# supports, letting the debugger just print the results instead # instead of collecting them.
# of collecting them.
def handleCmd(self, cmd, check=True, collect_result=True): def handleCmd(self, cmd, check=True, collect_result=True):
assert not check or collect_result assert not check or collect_result
ret = lldb.SBCommandReturnObject() ret = lldb.SBCommandReturnObject()
if collect_result: if collect_result:
interpreter = self.debugger.GetCommandInterpreter() interpreter = self.dbg.GetCommandInterpreter()
interpreter.HandleCommand(cmd, ret) interpreter.HandleCommand(cmd, ret)
else: else:
self.debugger.HandleCommand(cmd) self.dbg.HandleCommand(cmd)
self.debugger.GetOutputFile().Flush() self.dbg.GetOutputFile().Flush()
self.debugger.GetErrorFile().Flush() self.dbg.GetErrorFile().Flush()
if collect_result and check: if collect_result and check:
self.assertTrue(ret.Succeeded()) self.assertTrue(ret.Succeeded())
return ret.GetOutput() return ret.GetOutput()
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_legacy_file_out_script(self): def test_legacy_file_out_script(self):
with open(self.out_filename, 'w') as f: with open(self.out_filename, 'w') as f:
self.debugger.SetOutputFileHandle(f, False) self.dbg.SetOutputFileHandle(f, False)
# scripts print to output even if you capture the results # scripts print to output even if you capture the results
# I'm not sure I love that behavior, but that's the way # I'm not sure I love that behavior, but that's the way
# it's been for a long time. That's why this test works # it's been for a long time. That's why this test works
# even with collect_result=True. # even with collect_result=True.
self.handleCmd('script 1+1') self.handleCmd('script 1+1')
self.debugger.GetOutputFileHandle().write('FOO\n') self.dbg.GetOutputFileHandle().write('FOO\n')
lldb.SBDebugger.Destroy(self.debugger)
with open(self.out_filename, 'r') as f: with open(self.out_filename, 'r') as f:
self.assertEqual(readStrippedLines(f), ['2', 'FOO']) self.assertEqual(readStrippedLines(f), ['2', 'FOO'])
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_legacy_file_out(self): def test_legacy_file_out(self):
with open(self.out_filename, 'w') as f: with open(self.out_filename, 'w') as f:
self.debugger.SetOutputFileHandle(f, False) self.dbg.SetOutputFileHandle(f, False)
self.handleCmd('p/x 3735928559', collect_result=False, check=False) self.handleCmd('p/x 3735928559', collect_result=False, check=False)
lldb.SBDebugger.Destroy(self.debugger)
with open(self.out_filename, 'r') as f: with open(self.out_filename, 'r') as f:
self.assertIn('deadbeef', f.read()) self.assertIn('deadbeef', f.read())
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_legacy_file_err_with_get(self): def test_legacy_file_err_with_get(self):
with open(self.out_filename, 'w') as f: with open(self.out_filename, 'w') as f:
self.debugger.SetErrorFileHandle(f, False) self.dbg.SetErrorFileHandle(f, False)
self.handleCmd('lolwut', check=False, collect_result=False) self.handleCmd('lolwut', check=False, collect_result=False)
f2 = self.debugger.GetErrorFileHandle() f2 = self.dbg.GetErrorFileHandle()
f2.write('FOOBAR\n') f2.write('FOOBAR\n')
f2.flush() f2.flush()
lldb.SBDebugger.Destroy(self.debugger)
with open(self.out_filename, 'r') as f: with open(self.out_filename, 'r') as f:
errors = f.read() errors = f.read()
self.assertTrue(re.search(r'error:.*lolwut', errors)) self.assertTrue(re.search(r'error:.*lolwut', errors))
self.assertTrue(re.search(r'FOOBAR', errors)) self.assertTrue(re.search(r'FOOBAR', errors))
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_legacy_file_err(self): def test_legacy_file_err(self):
with open(self.out_filename, 'w') as f: with open(self.out_filename, 'w') as f:
self.debugger.SetErrorFileHandle(f, False) self.dbg.SetErrorFileHandle(f, False)
self.handleCmd('lol', check=False, collect_result=False) self.handleCmd('lol', check=False, collect_result=False)
lldb.SBDebugger.Destroy(self.debugger)
with open(self.out_filename, 'r') as f: with open(self.out_filename, 'r') as f:
self.assertIn("is not a valid command", f.read()) self.assertIn("is not a valid command", f.read())
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_legacy_file_error(self): def test_legacy_file_error(self):
debugger = self.debugger
with open(self.out_filename, 'w') as f: with open(self.out_filename, 'w') as f:
debugger.SetErrorFileHandle(f, False) self.dbg.SetErrorFileHandle(f, False)
self.handleCmd('lolwut', check=False, collect_result=False) self.handleCmd('lolwut', check=False, collect_result=False)
with open(self.out_filename, 'r') as f: with open(self.out_filename, 'r') as f:
errors = f.read() errors = f.read()
self.assertTrue(re.search(r'error:.*lolwut', errors)) self.assertTrue(re.search(r'error:.*lolwut', errors))
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_sbfile_type_errors(self): def test_sbfile_type_errors(self):
sbf = lldb.SBFile() sbf = lldb.SBFile()
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines def test_sbfile_read(self):
sbf.Close() sbf.Close()
self.assertTrue(f.closed) self.assertTrue(f.closed)
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_fileno_out(self): def test_fileno_out(self):
with open(self.out_filename, 'w') as f: with open(self.out_filename, 'w') as f:
sbf = lldb.SBFile(f.fileno(), "w", False) sbf = lldb.SBFile(f.fileno(), "w", False)
status = self.debugger.SetOutputFile(sbf) status = self.dbg.SetOutputFile(sbf)
self.assertTrue(status.Success()) self.assertTrue(status.Success())
self.handleCmd('script 1+2') self.handleCmd('script 1+2')
self.debugger.GetOutputFile().Write(b'quux') self.dbg.GetOutputFile().Write(b'quux')
with open(self.out_filename, 'r') as f: with open(self.out_filename, 'r') as f:
self.assertEqual(readStrippedLines(f), ['3', 'quux']) self.assertEqual(readStrippedLines(f), ['3', 'quux'])
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_fileno_help(self): def test_fileno_help(self):
with open(self.out_filename, 'w') as f: with open(self.out_filename, 'w') as f:
sbf = lldb.SBFile(f.fileno(), "w", False) sbf = lldb.SBFile(f.fileno(), "w", False)
status = self.debugger.SetOutputFile(sbf) status = self.dbg.SetOutputFile(sbf)
self.assertTrue(status.Success()) self.assertTrue(status.Success())
self.handleCmd("help help", collect_result=False, check=False) self.handleCmd("help help", collect_result=False, check=False)
with open(self.out_filename, 'r') as f: with open(self.out_filename, 'r') as f:
self.assertTrue(re.search(r'Show a list of all debugger commands', f.read())) self.assertTrue(re.search(r'Show a list of all debugger commands', f.read()))
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_help(self): def test_help(self):
debugger = self.debugger
with open(self.out_filename, 'w') as f: with open(self.out_filename, 'w') as f:
status = debugger.SetOutputFile(lldb.SBFile(f)) status = self.dbg.SetOutputFile(lldb.SBFile(f))
self.assertTrue(status.Success()) self.assertTrue(status.Success())
self.handleCmd("help help", check=False, collect_result=False) self.handleCmd("help help", check=False, collect_result=False)
with open(self.out_filename, 'r') as f: with open(self.out_filename, 'r') as f:
self.assertIn('Show a list of all debugger commands', f.read()) self.assertIn('Show a list of all debugger commands', f.read())
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_immediate(self): def test_immediate(self):
with open(self.out_filename, 'w') as f: with open(self.out_filename, 'w') as f:
ret = lldb.SBCommandReturnObject() ret = lldb.SBCommandReturnObject()
ret.SetImmediateOutputFile(f) ret.SetImmediateOutputFile(f)
interpreter = self.debugger.GetCommandInterpreter() interpreter = self.dbg.GetCommandInterpreter()
interpreter.HandleCommand("help help", ret) interpreter.HandleCommand("help help", ret)
# make sure the file wasn't closed early. # make sure the file wasn't closed early.
f.write("\nQUUX\n") f.write("\nQUUX\n")
ret = None # call destructor and flush streams ret = None # call destructor and flush streams
with open(self.out_filename, 'r') as f: with open(self.out_filename, 'r') as f:
output = f.read() output = f.read()
self.assertTrue(re.search(r'Show a list of all debugger commands', output)) self.assertTrue(re.search(r'Show a list of all debugger commands', output))
self.assertTrue(re.search(r'QUUX', output)) self.assertTrue(re.search(r'QUUX', output))
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@skipIf(py_version=['<', (3,)]) @skipIf(py_version=['<', (3,)])
def test_immediate_string(self): def test_immediate_string(self):
f = io.StringIO() f = io.StringIO()
ret = lldb.SBCommandReturnObject() ret = lldb.SBCommandReturnObject()
ret.SetImmediateOutputFile(f) ret.SetImmediateOutputFile(f)
interpreter = self.debugger.GetCommandInterpreter() interpreter = self.dbg.GetCommandInterpreter()
interpreter.HandleCommand("help help", ret) interpreter.HandleCommand("help help", ret)
# make sure the file wasn't closed early. # make sure the file wasn't closed early.
f.write("\nQUUX\n") f.write("\nQUUX\n")
ret = None # call destructor and flush streams ret = None # call destructor and flush streams
output = f.getvalue() output = f.getvalue()
self.assertTrue(re.search(r'Show a list of all debugger commands', output)) self.assertTrue(re.search(r'Show a list of all debugger commands', output))
self.assertTrue(re.search(r'QUUX', output)) self.assertTrue(re.search(r'QUUX', output))
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@skipIf(py_version=['<', (3,)]) @skipIf(py_version=['<', (3,)])
def test_immediate_sbfile_string(self): def test_immediate_sbfile_string(self):
f = io.StringIO() f = io.StringIO()
ret = lldb.SBCommandReturnObject() ret = lldb.SBCommandReturnObject()
ret.SetImmediateOutputFile(lldb.SBFile(f)) ret.SetImmediateOutputFile(lldb.SBFile(f))
interpreter = self.debugger.GetCommandInterpreter() interpreter = self.dbg.GetCommandInterpreter()
interpreter.HandleCommand("help help", ret) interpreter.HandleCommand("help help", ret)
output = f.getvalue() output = f.getvalue()
ret = None # call destructor and flush streams ret = None # call destructor and flush streams
# sbfile default constructor doesn't borrow the file # sbfile default constructor doesn't borrow the file
self.assertTrue(f.closed) self.assertTrue(f.closed)
self.assertTrue(re.search(r'Show a list of all debugger commands', output)) self.assertTrue(re.search(r'Show a list of all debugger commands', output))
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_fileno_inout(self): def test_fileno_inout(self):
with open(self.in_filename, 'w') as f: with open(self.in_filename, 'w') as f:
f.write("help help\n") f.write("help help\n")
with open(self.out_filename, 'w') as outf, open(self.in_filename, 'r') as inf: with open(self.out_filename, 'w') as outf, open(self.in_filename, 'r') as inf:
outsbf = lldb.SBFile(outf.fileno(), "w", False) outsbf = lldb.SBFile(outf.fileno(), "w", False)
status = self.debugger.SetOutputFile(outsbf) status = self.dbg.SetOutputFile(outsbf)
self.assertTrue(status.Success()) self.assertTrue(status.Success())
insbf = lldb.SBFile(inf.fileno(), "r", False) insbf = lldb.SBFile(inf.fileno(), "r", False)
status = self.debugger.SetInputFile(insbf) status = self.dbg.SetInputFile(insbf)
self.assertTrue(status.Success()) self.assertTrue(status.Success())
opts = lldb.SBCommandInterpreterRunOptions() opts = lldb.SBCommandInterpreterRunOptions()
self.debugger.RunCommandInterpreter(True, False, opts, 0, False, False) self.dbg.RunCommandInterpreter(True, False, opts, 0, False, False)
self.debugger.GetOutputFile().Flush() self.dbg.GetOutputFile().Flush()
with open(self.out_filename, 'r') as f: with open(self.out_filename, 'r') as f:
self.assertTrue(re.search(r'Show a list of all debugger commands', f.read())) self.assertTrue(re.search(r'Show a list of all debugger commands', f.read()))
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_inout(self): def test_inout(self):
with open(self.in_filename, 'w') as f: with open(self.in_filename, 'w') as f:
f.write("help help\n") f.write("help help\n")
with open(self.out_filename, 'w') as outf, \ with open(self.out_filename, 'w') as outf, \
open(self.in_filename, 'r') as inf: open(self.in_filename, 'r') as inf:
status = self.debugger.SetOutputFile(lldb.SBFile(outf)) status = self.dbg.SetOutputFile(lldb.SBFile(outf))
self.assertTrue(status.Success()) self.assertTrue(status.Success())
status = self.debugger.SetInputFile(lldb.SBFile(inf)) status = self.dbg.SetInputFile(lldb.SBFile(inf))
self.assertTrue(status.Success()) self.assertTrue(status.Success())
opts = lldb.SBCommandInterpreterRunOptions() opts = lldb.SBCommandInterpreterRunOptions()
self.debugger.RunCommandInterpreter(True, False, opts, 0, False, False) self.dbg.RunCommandInterpreter(True, False, opts, 0, False, False)
self.debugger.GetOutputFile().Flush() self.dbg.GetOutputFile().Flush()
with open(self.out_filename, 'r') as f: with open(self.out_filename, 'r') as f:
output = f.read() output = f.read()
self.assertIn('Show a list of all debugger commands', output) self.assertIn('Show a list of all debugger commands', output)
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_binary_inout(self): def test_binary_inout(self):
debugger = self.debugger
with open(self.in_filename, 'w') as f: with open(self.in_filename, 'w') as f:
f.write("help help\n") f.write("help help\n")
with open(self.out_filename, 'wb') as outf, \ with open(self.out_filename, 'wb') as outf, \
open(self.in_filename, 'rb') as inf: open(self.in_filename, 'rb') as inf:
status = debugger.SetOutputFile(lldb.SBFile(outf)) status = self.dbg.SetOutputFile(lldb.SBFile(outf))
self.assertTrue(status.Success()) self.assertTrue(status.Success())
status = debugger.SetInputFile(lldb.SBFile(inf)) status = self.dbg.SetInputFile(lldb.SBFile(inf))
self.assertTrue(status.Success()) self.assertTrue(status.Success())
opts = lldb.SBCommandInterpreterRunOptions() opts = lldb.SBCommandInterpreterRunOptions()
debugger.RunCommandInterpreter(True, False, opts, 0, False, False) self.dbg.RunCommandInterpreter(True, False, opts, 0, False, False)
debugger.GetOutputFile().Flush() self.dbg.GetOutputFile().Flush()
with open(self.out_filename, 'r') as f: with open(self.out_filename, 'r') as f:
output = f.read() output = f.read()
self.assertIn('Show a list of all debugger commands', output) self.assertIn('Show a list of all debugger commands', output)
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@skipIf(py_version=['<', (3,)]) @skipIf(py_version=['<', (3,)])
def test_string_inout(self): def test_string_inout(self):
inf = io.StringIO("help help\np/x ~0\n") inf = io.StringIO("help help\np/x ~0\n")
outf = io.StringIO() outf = io.StringIO()
status = self.debugger.SetOutputFile(lldb.SBFile(outf)) status = self.dbg.SetOutputFile(lldb.SBFile(outf))
self.assertTrue(status.Success()) self.assertTrue(status.Success())
status = self.debugger.SetInputFile(lldb.SBFile(inf)) status = self.dbg.SetInputFile(lldb.SBFile(inf))
self.assertTrue(status.Success()) self.assertTrue(status.Success())
opts = lldb.SBCommandInterpreterRunOptions() opts = lldb.SBCommandInterpreterRunOptions()
self.debugger.RunCommandInterpreter(True, False, opts, 0, False, False) self.dbg.RunCommandInterpreter(True, False, opts, 0, False, False)
self.debugger.GetOutputFile().Flush() self.dbg.GetOutputFile().Flush()
output = outf.getvalue() output = outf.getvalue()
self.assertIn('Show a list of all debugger commands', output) self.assertIn('Show a list of all debugger commands', output)
self.assertIn('0xfff', output) self.assertIn('0xfff', output)
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@skipIf(py_version=['<', (3,)]) @skipIf(py_version=['<', (3,)])
def test_bytes_inout(self): def test_bytes_inout(self):
inf = io.BytesIO(b"help help\nhelp b\n") inf = io.BytesIO(b"help help\nhelp b\n")
outf = io.BytesIO() outf = io.BytesIO()
status = self.debugger.SetOutputFile(lldb.SBFile(outf)) status = self.dbg.SetOutputFile(lldb.SBFile(outf))
self.assertTrue(status.Success()) self.assertTrue(status.Success())
status = self.debugger.SetInputFile(lldb.SBFile(inf)) status = self.dbg.SetInputFile(lldb.SBFile(inf))
self.assertTrue(status.Success()) self.assertTrue(status.Success())
opts = lldb.SBCommandInterpreterRunOptions() opts = lldb.SBCommandInterpreterRunOptions()
self.debugger.RunCommandInterpreter(True, False, opts, 0, False, False) self.dbg.RunCommandInterpreter(True, False, opts, 0, False, False)
self.debugger.GetOutputFile().Flush() self.dbg.GetOutputFile().Flush()
output = outf.getvalue() output = outf.getvalue()
self.assertIn(b'Show a list of all debugger commands', output) self.assertIn(b'Show a list of all debugger commands', output)
self.assertIn(b'Set a breakpoint', output) self.assertIn(b'Set a breakpoint', output)
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_fileno_error(self): def test_fileno_error(self):
with open(self.out_filename, 'w') as f: with open(self.out_filename, 'w') as f:
sbf = lldb.SBFile(f.fileno(), 'w', False) sbf = lldb.SBFile(f.fileno(), 'w', False)
status = self.debugger.SetErrorFile(sbf) status = self.dbg.SetErrorFile(sbf)
self.assertTrue(status.Success()) self.assertTrue(status.Success())
self.handleCmd('lolwut', check=False, collect_result=False) self.handleCmd('lolwut', check=False, collect_result=False)
self.debugger.GetErrorFile().Write(b'\nzork\n') self.dbg.GetErrorFile().Write(b'\nzork\n')
with open(self.out_filename, 'r') as f: with open(self.out_filename, 'r') as f:
errors = f.read() errors = f.read()
self.assertTrue(re.search(r'error:.*lolwut', errors)) self.assertTrue(re.search(r'error:.*lolwut', errors))
self.assertTrue(re.search(r'zork', errors)) self.assertTrue(re.search(r'zork', errors))
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_replace_stdout(self): def test_replace_stdout(self):
f = io.StringIO() f = io.StringIO()
with replace_stdout(f): with replace_stdout(f):
self.assertEqual(sys.stdout, f) self.assertEqual(sys.stdout, f)
self.handleCmd('script sys.stdout.write("lol")', self.handleCmd('script sys.stdout.write("lol")',
collect_result=False, check=False) collect_result=False, check=False)
self.assertEqual(sys.stdout, f) self.assertEqual(sys.stdout, f)
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_replace_stdout_with_nonfile(self): def test_replace_stdout_with_nonfile(self):
debugger = self.debugger
f = io.StringIO() f = io.StringIO()
with replace_stdout(f): with replace_stdout(f):
class Nothing(): class Nothing():
pass pass
with replace_stdout(Nothing): with replace_stdout(Nothing):
self.assertEqual(sys.stdout, Nothing) self.assertEqual(sys.stdout, Nothing)
self.handleCmd('script sys.stdout.write("lol")', self.handleCmd('script sys.stdout.write("lol")',
check=False, collect_result=False) check=False, collect_result=False)
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Lines def test_sbfile_write_string(self):
sbf.Close() sbf.Close()
self.assertTrue(f.closed) self.assertTrue(f.closed)
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@skipIf(py_version=['<', (3,)]) @skipIf(py_version=['<', (3,)])
def test_string_out(self): def test_string_out(self):
f = io.StringIO() f = io.StringIO()
status = self.debugger.SetOutputFile(f) status = self.dbg.SetOutputFile(f)
self.assertTrue(status.Success()) self.assertTrue(status.Success())
self.handleCmd("script 'foobar'") self.handleCmd("script 'foobar'")
self.assertEqual(f.getvalue().strip(), "'foobar'") self.assertEqual(f.getvalue().strip(), "'foobar'")
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@skipIf(py_version=['<', (3,)]) @skipIf(py_version=['<', (3,)])
def test_string_error(self): def test_string_error(self):
f = io.StringIO() f = io.StringIO()
debugger = self.debugger status = self.dbg.SetErrorFile(f)
status = debugger.SetErrorFile(f)
self.assertTrue(status.Success()) self.assertTrue(status.Success())
self.handleCmd('lolwut', check=False, collect_result=False) self.handleCmd('lolwut', check=False, collect_result=False)
errors = f.getvalue() errors = f.getvalue()
self.assertTrue(re.search(r'error:.*lolwut', errors)) self.assertTrue(re.search(r'error:.*lolwut', errors))
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@skipIf(py_version=['<', (3,)]) @skipIf(py_version=['<', (3,)])
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines def test_sbfile_read_bytes(self):
self.assertEqual(buf[:n], b'zork') self.assertEqual(buf[:n], b'zork')
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@skipIf(py_version=['<', (3,)]) @skipIf(py_version=['<', (3,)])
def test_sbfile_out(self): def test_sbfile_out(self):
with open(self.out_filename, 'w') as f: with open(self.out_filename, 'w') as f:
sbf = lldb.SBFile(f) sbf = lldb.SBFile(f)
status = self.debugger.SetOutputFile(sbf) status = self.dbg.SetOutputFile(sbf)
self.assertTrue(status.Success()) self.assertTrue(status.Success())
self.handleCmd('script 2+2') self.handleCmd('script 2+2')
with open(self.out_filename, 'r') as f: with open(self.out_filename, 'r') as f:
self.assertEqual(f.read().strip(), '4') self.assertEqual(f.read().strip(), '4')
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@skipIf(py_version=['<', (3,)]) @skipIf(py_version=['<', (3,)])
def test_file_out(self): def test_file_out(self):
with open(self.out_filename, 'w') as f: with open(self.out_filename, 'w') as f:
status = self.debugger.SetOutputFile(f) status = self.dbg.SetOutputFile(f)
self.assertTrue(status.Success()) self.assertTrue(status.Success())
self.handleCmd('script 2+2') self.handleCmd('script 2+2')
with open(self.out_filename, 'r') as f: with open(self.out_filename, 'r') as f:
self.assertEqual(f.read().strip(), '4') self.assertEqual(f.read().strip(), '4')
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_sbfile_error(self): def test_sbfile_error(self):
with open(self.out_filename, 'w') as f: with open(self.out_filename, 'w') as f:
sbf = lldb.SBFile(f) sbf = lldb.SBFile(f)
status = self.debugger.SetErrorFile(sbf) status = self.dbg.SetErrorFile(sbf)
self.assertTrue(status.Success()) self.assertTrue(status.Success())
self.handleCmd('lolwut', check=False, collect_result=False) self.handleCmd('lolwut', check=False, collect_result=False)
with open(self.out_filename, 'r') as f: with open(self.out_filename, 'r') as f:
errors = f.read() errors = f.read()
self.assertTrue(re.search(r'error:.*lolwut', errors)) self.assertTrue(re.search(r'error:.*lolwut', errors))
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_file_error(self): def test_file_error(self):
with open(self.out_filename, 'w') as f: with open(self.out_filename, 'w') as f:
status = self.debugger.SetErrorFile(f) status = self.dbg.SetErrorFile(f)
self.assertTrue(status.Success()) self.assertTrue(status.Success())
self.handleCmd('lolwut', check=False, collect_result=False) self.handleCmd('lolwut', check=False, collect_result=False)
with open(self.out_filename, 'r') as f: with open(self.out_filename, 'r') as f:
errors = f.read() errors = f.read()
self.assertTrue(re.search(r'error:.*lolwut', errors)) self.assertTrue(re.search(r'error:.*lolwut', errors))
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
Show All 13 Lines def test_exceptions(self):
self.assertTrue(error.Fail()) self.assertTrue(error.Fail())
self.assertIn('OH NOE', error.GetCString()) self.assertIn('OH NOE', error.GetCString())
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@skipIf(py_version=['<', (3,)]) @skipIf(py_version=['<', (3,)])
def test_exceptions_logged(self): def test_exceptions_logged(self):
messages = list() messages = list()
self.debugger.SetLoggingCallback(messages.append) self.dbg.SetLoggingCallback(messages.append)
self.handleCmd('log enable lldb script') self.handleCmd('log enable lldb script')
self.debugger.SetOutputFile(lldb.SBFile(BadIO())) self.dbg.SetOutputFile(lldb.SBFile(BadIO()))
self.handleCmd('script 1+1') self.handleCmd('script 1+1')
self.assertTrue(any('OH NOE' in msg for msg in messages)) self.assertTrue(any('OH NOE' in msg for msg in messages))
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@skipIf(py_version=['<', (3,)]) @skipIf(py_version=['<', (3,)])
def test_flush(self): def test_flush(self):
flushed = MutableBool(False) flushed = MutableBool(False)
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines def test_fileno_flush(self):
sbf = None sbf = None
self.assertFalse(f.closed) self.assertFalse(f.closed)
f.seek(0) f.seek(0)
self.assertEqual(f.read(), 'foobar') self.assertEqual(f.read(), 'foobar')
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_close(self): def test_close(self):
debugger = self.debugger
with open(self.out_filename, 'w') as f: with open(self.out_filename, 'w') as f:
status = debugger.SetOutputFile(f) status = self.dbg.SetOutputFile(f)
self.assertTrue(status.Success()) self.assertTrue(status.Success())
self.handleCmd("help help", check=False, collect_result=False) self.handleCmd("help help", check=False, collect_result=False)
# make sure the file wasn't closed early. # make sure the file wasn't closed early.
f.write("\nZAP\n") f.write("\nZAP\n")
lldb.SBDebugger.Destroy(debugger) lldb.SBDebugger.Destroy(self.dbg)
# check that output file was closed when debugger was destroyed. # check that output file was closed when debugger was destroyed.
with self.assertRaises(ValueError): with self.assertRaises(ValueError):
f.write("\nQUUX\n") f.write("\nQUUX\n")
with open(self.out_filename, 'r') as f: with open(self.out_filename, 'r') as f:
output = f.read() output = f.read()
self.assertTrue(re.search(r'Show a list of all debugger commands', output)) self.assertTrue(re.search(r'Show a list of all debugger commands', output))
self.assertTrue(re.search(r'ZAP', output)) self.assertTrue(re.search(r'ZAP', output))
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@skipIf(py_version=['<', (3,)]) @skipIf(py_version=['<', (3,)])
def test_stdout(self): def test_stdout(self):
f = io.StringIO() f = io.StringIO()
status = self.debugger.SetOutputFile(f) status = self.dbg.SetOutputFile(f)
self.assertTrue(status.Success()) self.assertTrue(status.Success())
self.handleCmd(r"script sys.stdout.write('foobar\n')") self.handleCmd(r"script sys.stdout.write('foobar\n')")
self.assertEqual(f.getvalue().strip().split(), ["foobar", "7"]) self.assertEqual(f.getvalue().strip().split(), ["foobar", "7"])
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_stdout_file(self): def test_stdout_file(self):
with open(self.out_filename, 'w') as f: with open(self.out_filename, 'w') as f:
status = self.debugger.SetOutputFile(f) status = self.dbg.SetOutputFile(f)
self.assertTrue(status.Success()) self.assertTrue(status.Success())
self.handleCmd(r"script sys.stdout.write('foobar\n')") self.handleCmd(r"script sys.stdout.write('foobar\n')")
with open(self.out_filename, 'r') as f: with open(self.out_filename, 'r') as f:
# In python2 sys.stdout.write() returns None, which # In python2 sys.stdout.write() returns None, which
# the REPL will ignore, but in python3 it will # the REPL will ignore, but in python3 it will
# return the number of bytes written, which the REPL # return the number of bytes written, which the REPL
# will print out. # will print out.
lines = [x for x in f.read().strip().split() if x != "7"] lines = [x for x in f.read().strip().split() if x != "7"]
▲ Show 20 Lines • Show All 72 Lines • ▼ Show 20 Lines def test_back_and_forth(self):
sbf.Write(str(i).encode('ascii') + b"\n") sbf.Write(str(i).encode('ascii') + b"\n")
files = list(i(sbf)) files = list(i(sbf))
with open(self.out_filename, 'r') as f: with open(self.out_filename, 'r') as f:
self.assertEqual(list(range(10)), list(map(int, f.read().strip().split()))) self.assertEqual(list(range(10)), list(map(int, f.read().strip().split())))
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_set_filehandle_none(self): def test_set_filehandle_none(self):
self.assertRaises(Exception, self.debugger.SetOutputFile, None) self.assertRaises(Exception, self.dbg.SetOutputFile, None)
self.assertRaises(Exception, self.debugger.SetOutputFile, "ham sandwich") self.assertRaises(Exception, self.dbg.SetOutputFile, "ham sandwich")
self.assertRaises(Exception, self.debugger.SetOutputFileHandle, "ham sandwich") self.assertRaises(Exception, self.dbg.SetOutputFileHandle, "ham sandwich")
self.assertRaises(Exception, self.debugger.SetInputFile, None) self.assertRaises(Exception, self.dbg.SetInputFile, None)
self.assertRaises(Exception, self.debugger.SetInputFile, "ham sandwich") self.assertRaises(Exception, self.dbg.SetInputFile, "ham sandwich")
self.assertRaises(Exception, self.debugger.SetInputFileHandle, "ham sandwich") self.assertRaises(Exception, self.dbg.SetInputFileHandle, "ham sandwich")
self.assertRaises(Exception, self.debugger.SetErrorFile, None) self.assertRaises(Exception, self.dbg.SetErrorFile, None)
self.assertRaises(Exception, self.debugger.SetErrorFile, "ham sandwich") self.assertRaises(Exception, self.dbg.SetErrorFile, "ham sandwich")
self.assertRaises(Exception, self.debugger.SetErrorFileHandle, "ham sandwich") self.assertRaises(Exception, self.dbg.SetErrorFileHandle, "ham sandwich")
with open(self.out_filename, 'w') as f: with open(self.out_filename, 'w') as f:
status = self.debugger.SetOutputFile(f) status = self.dbg.SetOutputFile(f)
self.assertTrue(status.Success()) self.assertTrue(status.Success())
status = self.debugger.SetErrorFile(f) status = self.dbg.SetErrorFile(f)
self.assertTrue(status.Success()) self.assertTrue(status.Success())
self.debugger.SetOutputFileHandle(None, False) self.dbg.SetOutputFileHandle(None, False)
self.debugger.SetErrorFileHandle(None, False) self.dbg.SetErrorFileHandle(None, False)
sbf = self.debugger.GetOutputFile() sbf = self.dbg.GetOutputFile()
if sys.version_info.major >= 3: if sys.version_info.major >= 3:
# python 2 lacks PyFile_FromFd, so GetFile() will # python 2 lacks PyFile_FromFd, so GetFile() will
# have to duplicate the file descriptor and make a FILE* # have to duplicate the file descriptor and make a FILE*
# in order to convert a NativeFile it back to a python # in order to convert a NativeFile it back to a python
# file. # file.
self.assertEqual(sbf.GetFile().fileno(), 1) self.assertEqual(sbf.GetFile().fileno(), 1)
sbf = self.debugger.GetErrorFile() sbf = self.dbg.GetErrorFile()
if sys.version_info.major >= 3: if sys.version_info.major >= 3:
self.assertEqual(sbf.GetFile().fileno(), 2) self.assertEqual(sbf.GetFile().fileno(), 2)
with open(self.out_filename, 'r') as f: with open(self.out_filename, 'r') as f:
status = self.debugger.SetInputFile(f) status = self.dbg.SetInputFile(f)
self.assertTrue(status.Success()) self.assertTrue(status.Success())
self.debugger.SetInputFileHandle(None, False) self.dbg.SetInputFileHandle(None, False)
sbf = self.debugger.GetInputFile() sbf = self.dbg.GetInputFile()
if sys.version_info.major >= 3: if sys.version_info.major >= 3:
self.assertEqual(sbf.GetFile().fileno(), 0) self.assertEqual(sbf.GetFile().fileno(), 0)
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_sbstream(self): def test_sbstream(self):
with open(self.out_filename, 'w') as f: with open(self.out_filename, 'w') as f:
Show All 21 Lines

lldb/test/API/tools/lldb-server/platform-process-connect/TestPlatformProcessConnect.py

import time import time
import gdbremote_testcase import gdbremote_testcase
from lldbsuite.test.decorators import * from lldbsuite.test.decorators import *
from lldbsuite.test.lldbtest import * from lldbsuite.test.lldbtest import *
from lldbsuite.test import lldbutil from lldbsuite.test import lldbutil
class TestPlatformProcessConnect(gdbremote_testcase.GdbRemoteTestCaseBase): class TestPlatformProcessConnect(gdbremote_testcase.GdbRemoteTestCaseBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def setUp(self):
super(TestPlatformProcessConnect, self).setUp()
self._initial_platform = lldb.DBG.GetSelectedPlatform()
def tearDown(self):
lldb.DBG.SetSelectedPlatform(self._initial_platform)
super(TestPlatformProcessConnect, self).tearDown()
@llgs_test @llgs_test
@no_debug_info_test @no_debug_info_test
@skipIf(remote=False) @skipIf(remote=False)
@expectedFailureAll(hostoslist=["windows"], triple='.*-android') @expectedFailureAll(hostoslist=["windows"], triple='.*-android')
def test_platform_process_connect(self): def test_platform_process_connect(self):
self.build() self.build()
self.init_llgs_test(False) self.init_llgs_test(False)
Show All 32 Lines def test_platform_process_connect(self):
self.spawnSubprocess( self.spawnSubprocess(
self.debug_monitor_exe, self.debug_monitor_exe,
commandline_args, commandline_args,
install_remote=False) install_remote=False)
self.addTearDownHook(self.cleanupSubprocesses) self.addTearDownHook(self.cleanupSubprocesses)
socket_id = lldbutil.wait_for_file_on_target(self, port_file) socket_id = lldbutil.wait_for_file_on_target(self, port_file)
new_debugger = lldb.SBDebugger.Create() self.dbg.SetAsync(False)
new_debugger.SetAsync(False)
def del_debugger(new_debugger=new_debugger):
del new_debugger
self.addTearDownHook(del_debugger)
new_platform = lldb.SBPlatform(lldb.remote_platform.GetName()) new_platform = lldb.SBPlatform(lldb.remote_platform.GetName())
new_debugger.SetSelectedPlatform(new_platform) self.dbg.SetSelectedPlatform(new_platform)
new_interpreter = new_debugger.GetCommandInterpreter()
if unix_protocol: if unix_protocol:
connect_url = "%s://%s%s" % (protocol, hostname, socket_id) connect_url = "%s://%s%s" % (protocol, hostname, socket_id)
else: else:
connect_url = "%s://%s:%s" % (protocol, hostname, socket_id) connect_url = "%s://%s:%s" % (protocol, hostname, socket_id)
command = "platform connect %s" % (connect_url) command = "platform connect %s" % (connect_url)
result = lldb.SBCommandReturnObject() result = lldb.SBCommandReturnObject()
new_interpreter.HandleCommand(command, result) self.dbg.GetCommandInterpreter().HandleCommand(command, result)
self.assertTrue( self.assertTrue(
result.Succeeded(), result.Succeeded(),
"platform process connect failed: %s" % "platform process connect failed: %s" %
result.GetOutput()) result.GetOutput())
target = new_debugger.GetSelectedTarget() target = self.dbg.GetSelectedTarget()
process = target.GetProcess() process = target.GetProcess()
thread = process.GetThreadAtIndex(0) thread = process.GetThreadAtIndex(0)
breakpoint = target.BreakpointCreateByName("main") breakpoint = target.BreakpointCreateByName("main")
process.Continue() process.Continue()
frame = thread.GetFrameAtIndex(0) frame = thread.GetFrameAtIndex(0)
self.assertEqual(frame.GetFunction().GetName(), "main") self.assertEqual(frame.GetFunction().GetName(), "main")
self.assertEqual(frame.FindVariable("argc").GetValueAsSigned(), 2) self.assertEqual(frame.FindVariable("argc").GetValueAsSigned(), 2)
process.Continue() process.Continue()