"""
LLDB module which provides the abstract base class of lldb test case.
The concrete subclass can override lldbtest.TestBase in order to inherit the
common behavior for unitest.TestCase.setUp/tearDown implemented in this file.
./dotest.py provides a test driver which sets up the environment to run the
entire of part of the test suite . Example:
# Exercises the test suite in the types directory....
/Volumes/data/lldb/svn/ToT/test $ ./dotest.py -A x86_64 types
...
Session logs for test failures/errors/unexpected successes will go into directory '2012-05-16-13_35_42'
Command invoked: python ./dotest.py -A x86_64 types
compilers=['clang']
Configuration: arch=x86_64 compiler=clang
----------------------------------------------------------------------
Collected 72 tests
........................................................................
----------------------------------------------------------------------
Ran 72 tests in 135.468s
OK
$
"""
import abc
from functools import wraps
import gc
import glob
import io
import json
import os.path
import re
import shutil
import signal
from subprocess import *
import sys
import time
import traceback
import unittest
import lldb
from . import configuration
from . import decorators
from . import lldbplatformutil
from . import lldbtest_config
from . import lldbutil
from . import test_categories
from lldbsuite.support import encoded_file
from lldbsuite.support import funcutils
from lldbsuite.support import seven
from lldbsuite.test_event import build_exception
if "LLDB_COMMAND_TRACE" in os.environ and os.environ["LLDB_COMMAND_TRACE"] == "YES":
traceAlways = True
else:
traceAlways = False
if "LLDB_DO_CLEANUP" in os.environ and os.environ["LLDB_DO_CLEANUP"] == "NO":
doCleanup = False
else:
doCleanup = True
COMMAND_FAILED_AS_EXPECTED = "Command has failed as expected"
CURRENT_EXECUTABLE_SET = "Current executable set successfully"
PROCESS_IS_VALID = "Process is valid"
PROCESS_KILLED = "Process is killed successfully"
PROCESS_EXITED = "Process exited successfully"
PROCESS_STOPPED = "Process status should be stopped"
RUN_SUCCEEDED = "Process is launched successfully"
RUN_COMPLETED = "Process exited successfully"
BACKTRACE_DISPLAYED_CORRECTLY = "Backtrace displayed correctly"
BREAKPOINT_CREATED = "Breakpoint created successfully"
BREAKPOINT_STATE_CORRECT = "Breakpoint state is correct"
BREAKPOINT_PENDING_CREATED = "Pending breakpoint created successfully"
BREAKPOINT_HIT_ONCE = "Breakpoint resolved with hit count = 1"
BREAKPOINT_HIT_TWICE = "Breakpoint resolved with hit count = 2"
BREAKPOINT_HIT_THRICE = "Breakpoint resolved with hit count = 3"
MISSING_EXPECTED_REGISTERS = "At least one expected register is unavailable."
OBJECT_PRINTED_CORRECTLY = "Object printed correctly"
SOURCE_DISPLAYED_CORRECTLY = "Source code displayed correctly"
STEP_IN_SUCCEEDED = "Thread step-in succeeded"
STEP_OUT_SUCCEEDED = "Thread step-out succeeded"
STOPPED_DUE_TO_EXC_BAD_ACCESS = "Process should be stopped due to bad access exception"
STOPPED_DUE_TO_ASSERT = "Process should be stopped due to an assertion"
STOPPED_DUE_TO_BREAKPOINT = "Process should be stopped due to breakpoint"
STOPPED_DUE_TO_BREAKPOINT_WITH_STOP_REASON_AS = "%s, %s" % (
STOPPED_DUE_TO_BREAKPOINT,
"instead, the actual stop reason is: '%s'",
)
STOPPED_DUE_TO_BREAKPOINT_CONDITION = "Stopped due to breakpoint condition"
STOPPED_DUE_TO_BREAKPOINT_IGNORE_COUNT = "Stopped due to breakpoint and ignore count"
STOPPED_DUE_TO_BREAKPOINT_JITTED_CONDITION = (
"Stopped due to breakpoint jitted condition"
)
STOPPED_DUE_TO_SIGNAL = "Process state is stopped due to signal"
STOPPED_DUE_TO_STEP_IN = "Process state is stopped due to step in"
STOPPED_DUE_TO_WATCHPOINT = "Process should be stopped due to watchpoint"
DATA_TYPES_DISPLAYED_CORRECTLY = "Data type(s) displayed correctly"
VALID_BREAKPOINT = "Got a valid breakpoint"
VALID_BREAKPOINT_LOCATION = "Got a valid breakpoint location"
VALID_COMMAND_INTERPRETER = "Got a valid command interpreter"
VALID_FILESPEC = "Got a valid filespec"
VALID_MODULE = "Got a valid module"
VALID_PROCESS = "Got a valid process"
VALID_SYMBOL = "Got a valid symbol"
VALID_TARGET = "Got a valid target"
VALID_PLATFORM = "Got a valid platform"
VALID_TYPE = "Got a valid type"
VALID_VARIABLE = "Got a valid variable"
VARIABLES_DISPLAYED_CORRECTLY = "Variable(s) displayed correctly"
WATCHPOINT_CREATED = "Watchpoint created successfully"
def CMD_MSG(str):
"""A generic "Command '%s' did not return successfully" message generator."""
return "Command '%s' did not return successfully" % str
def COMPLETION_MSG(str_before, str_after, completions):
"""A generic assertion failed message generator for the completion mechanism."""
return "'%s' successfully completes to '%s', but completions were:\n%s" % (
str_before,
str_after,
"\n".join(completions),
)
def EXP_MSG(str, actual, exe):
"""A generic "'%s' returned unexpected result" message generator if exe.
Otherwise, it generates "'%s' does not match expected result" message."""
return "'%s' %s result, got '%s'" % (
str,
"returned unexpected" if exe else "does not match expected",
actual.strip(),
)
def SETTING_MSG(setting):
"""A generic "Value of setting '%s' is not correct" message generator."""
return "Value of setting '%s' is not correct" % setting
def line_number(filename, string_to_match):
"""Helper function to return the line number of the first matched string."""
with io.open(filename, mode="r", encoding="utf-8") as f:
for i, line in enumerate(f):
if line.find(string_to_match) != -1:
return i + 1
raise Exception("Unable to find '%s' within file %s" % (string_to_match, filename))
def get_line(filename, line_number):
"""Return the text of the line at the 1-based line number."""
with io.open(filename, mode="r", encoding="utf-8") as f:
return f.readlines()[line_number - 1]
def pointer_size():
"""Return the pointer size of the host system."""
import ctypes
a_pointer = ctypes.c_void_p(0xFFFF)
return 8 * ctypes.sizeof(a_pointer)
def is_exe(fpath):
"""Returns true if fpath is an executable."""
if fpath is None:
return False
if sys.platform == "win32":
if not fpath.endswith(".exe"):
fpath += ".exe"
return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
def which(program):
"""Returns the full path to a program; None otherwise."""
fpath, fname = os.path.split(program)
if fpath:
if is_exe(program):
return program
else:
for path in os.environ["PATH"].split(os.pathsep):
exe_file = os.path.join(path, program)
if is_exe(exe_file):
return exe_file
return None
class ValueCheck:
def __init__(
self,
name=None,
value=None,
type=None,
summary=None,
children=None,
dereference=None,
):
"""
:param name: The name that the SBValue should have. None if the summary
should not be checked.
:param summary: The summary that the SBValue should have. None if the
summary should not be checked.
:param value: The value that the SBValue should have. None if the value
should not be checked.
:param type: The type that the SBValue result should have. None if the
type should not be checked.
:param children: A list of ValueChecks that need to match the children
of this SBValue. None if children shouldn't be checked.
The order of checks is the order of the checks in the
list. The number of checks has to match the number of
children.
:param dereference: A ValueCheck for the SBValue returned by the
`Dereference` function.
"""
self.expect_name = name
self.expect_value = value
self.expect_type = type
self.expect_summary = summary
self.children = children
self.dereference = dereference
def check_value(self, test_base, val, error_msg=None):
"""
Checks that the given value matches the currently set properties
of this ValueCheck. If a match failed, the given TestBase will
be used to emit an error. A custom error message can be specified
that will be used to describe failed check for this SBValue (but
not errors in the child values).
"""
this_error_msg = error_msg if error_msg else ""
this_error_msg += "\nChecking SBValue: " + str(val)
test_base.assertSuccess(val.GetError())
pattern_type = type(re.compile(""))
if self.expect_name:
test_base.assertEqual(self.expect_name, val.GetName(), this_error_msg)
if self.expect_value:
if isinstance(self.expect_value, pattern_type):
test_base.assertRegex(val.GetValue(), self.expect_value, this_error_msg)
else:
test_base.assertEqual(self.expect_value, val.GetValue(), this_error_msg)
if self.expect_type:
test_base.assertEqual(
self.expect_type, val.GetDisplayTypeName(), this_error_msg
)
if self.expect_summary:
if isinstance(self.expect_summary, pattern_type):
test_base.assertRegex(
val.GetSummary(), self.expect_summary, this_error_msg
)
else:
test_base.assertEqual(
self.expect_summary, val.GetSummary(), this_error_msg
)
if self.children is not None:
self.check_value_children(test_base, val, error_msg)
if self.dereference is not None:
self.dereference.check_value(test_base, val.Dereference(), error_msg)
def check_value_children(self, test_base, val, error_msg=None):
"""
Checks that the children of a SBValue match a certain structure and
have certain properties.
:param test_base: The current test's TestBase object.
:param val: The SBValue to check.
"""
this_error_msg = error_msg if error_msg else ""
this_error_msg += "\nChecking SBValue: " + str(val)
test_base.assertEqual(len(self.children), val.GetNumChildren(), this_error_msg)
for i in range(0, val.GetNumChildren()):
expected_child = self.children[i]
actual_child = val.GetChildAtIndex(i)
child_error = "Checking child with index " + str(i) + ":\n" + error_msg
expected_child.check_value(test_base, actual_child, child_error)
class recording(io.StringIO):
"""
A nice little context manager for recording the debugger interactions into
our session object. If trace flag is ON, it also emits the interactions
into the stderr.
"""
def __init__(self, test, trace):
"""Create a io.StringIO instance; record the session obj and trace flag."""
io.StringIO.__init__(self)
self.session = getattr(test, "session", None) if test else None
self.trace = trace
def __enter__(self):
"""
Context management protocol on entry to the body of the with statement.
Just return the io.StringIO object.
"""
return self
def __exit__(self, type, value, tb):
"""
Context management protocol on exit from the body of the with statement.
If trace is ON, it emits the recordings into stderr. Always add the
recordings to our session object. And close the io.StringIO object, too.
"""
if self.trace:
print(self.getvalue(), file=sys.stderr)
if self.session:
print(self.getvalue(), file=self.session)
self.close()
class _BaseProcess(object, metaclass=abc.ABCMeta):
@abc.abstractproperty
def pid(self):
"""Returns process PID if has been launched already."""
@abc.abstractmethod
def launch(self, executable, args, extra_env):
"""Launches new process with given executable and args."""
@abc.abstractmethod
def terminate(self):
"""Terminates previously launched process.."""
class _LocalProcess(_BaseProcess):
def __init__(self, trace_on):
self._proc = None
self._trace_on = trace_on
self._delayafterterminate = 0.1
@property
def pid(self):
return self._proc.pid
def launch(self, executable, args, extra_env):
env = None
if extra_env:
env = dict(os.environ)
env.update([kv.split("=", 1) for kv in extra_env])
self._proc = Popen(
[executable] + args,
stdout=open(os.devnull) if not self._trace_on else None,
stdin=PIPE,
env=env,
)
def terminate(self):
if self._proc.poll() is None:
signals_to_try = [
sig for sig in ["SIGHUP", "SIGCONT", "SIGINT"] if sig in dir(signal)
]
for sig in signals_to_try:
try:
self._proc.send_signal(getattr(signal, sig))
time.sleep(self._delayafterterminate)
if self._proc.poll() is not None:
return
except ValueError:
pass
self._proc.terminate()
time.sleep(self._delayafterterminate)
if self._proc.poll() is not None:
return
self._proc.kill()
time.sleep(self._delayafterterminate)
def poll(self):
return self._proc.poll()
def wait(self, timeout=None):
return self._proc.wait(timeout)
class _RemoteProcess(_BaseProcess):
def __init__(self, install_remote):
self._pid = None
self._install_remote = install_remote
@property
def pid(self):
return self._pid
def launch(self, executable, args, extra_env):
if self._install_remote:
src_path = executable
dst_path = lldbutil.join_remote_paths(
lldb.remote_platform.GetWorkingDirectory(), os.path.basename(executable)
)
dst_file_spec = lldb.SBFileSpec(dst_path, False)
err = lldb.remote_platform.Install(
lldb.SBFileSpec(src_path, True), dst_file_spec
)
if err.Fail():
raise Exception(
"remote_platform.Install('%s', '%s') failed: %s"
% (src_path, dst_path, err)
)
else:
dst_path = executable
dst_file_spec = lldb.SBFileSpec(executable, False)
launch_info = lldb.SBLaunchInfo(args)
launch_info.SetExecutableFile(dst_file_spec, True)
launch_info.SetWorkingDirectory(lldb.remote_platform.GetWorkingDirectory())
launch_info.AddSuppressFileAction(1, False, True)
launch_info.AddSuppressFileAction(2, False, True)
if extra_env:
launch_info.SetEnvironmentEntries(extra_env, True)
err = lldb.remote_platform.Launch(launch_info)
if err.Fail():
raise Exception(
"remote_platform.Launch('%s', '%s') failed: %s" % (dst_path, args, err)
)
self._pid = launch_info.GetProcessID()
def terminate(self):
lldb.remote_platform.Kill(self._pid)
def getsource_if_available(obj):
"""
Return the text of the source code for an object if available. Otherwise,
a print representation is returned.
"""
import inspect
try:
return inspect.getsource(obj)
except:
return repr(obj)
def builder_module():
return lldbplatformutil.builder_module()
class Base(unittest.TestCase):
"""
Abstract base for performing lldb (see TestBase) or other generic tests (see
BenchBase for one example). lldbtest.Base works with the test driver to
accomplish things.
"""
mydir = None
oldcwd = None
maxLaunchCount = 1
timeWaitNextLaunch = 1.0
@staticmethod
def compute_mydir(test_file):
"""Subclasses should call this function to correctly calculate the
required "mydir" attribute as follows:
mydir = TestBase.compute_mydir(__file__)
"""
lldb_test_src = configuration.test_src_root
if not test_file.startswith(lldb_test_src):
raise Exception(
"Test file '%s' must reside within lldb_test_src "
"(which is '%s')." % (test_file, lldb_test_src)
)
return os.path.dirname(os.path.relpath(test_file, start=lldb_test_src))
def TraceOn(self):
"""Returns True if we are in trace mode (tracing detailed test execution)."""
return traceAlways
def trace(self, *args, **kwargs):
with recording(self, self.TraceOn()) as sbuf:
print(*args, file=sbuf, **kwargs)
@classmethod
def setUpClass(cls):
"""
Python unittest framework class setup fixture.
Do current directory manipulation.
"""
if not cls.mydir:
cls.mydir = Base.compute_mydir(sys.modules[cls.__module__].__file__)
if not cls.mydir:
raise Exception("Subclasses must override the 'mydir' attribute.")
cls.oldcwd = os.getcwd()
full_dir = os.path.join(configuration.test_src_root, cls.mydir)
if traceAlways:
print("Change dir to:", full_dir, file=sys.stderr)
os.chdir(full_dir)
cls.platformContext = lldbplatformutil.createPlatformContext()
@classmethod
def tearDownClass(cls):
"""
Python unittest framework class teardown fixture.
Do class-wide cleanup.
"""
if doCleanup:
module = builder_module()
module.cleanup()
if getattr(cls, "classCleanup", None):
if traceAlways:
print(
"Call class-specific cleanup function for class:",
cls,
file=sys.stderr,
)
try:
cls.classCleanup()
except:
exc_type, exc_value, exc_tb = sys.exc_info()
traceback.print_exception(exc_type, exc_value, exc_tb)
if traceAlways:
print("Restore dir to:", cls.oldcwd, file=sys.stderr)
os.chdir(cls.oldcwd)
def enableLogChannelsForCurrentTest(self):
if len(lldbtest_config.channels) == 0:
return
log_basename = self.getLogBasenameForCurrentTest()
host_log_path = "{}-host.log".format(log_basename)
open(host_log_path, "w").close()
self.log_files.append(host_log_path)
log_enable = "log enable -Tpn -f {} ".format(host_log_path)
for channel_with_categories in lldbtest_config.channels:
channel_then_categories = channel_with_categories.split(" ", 1)
channel = channel_then_categories[0]
if len(channel_then_categories) > 1:
categories = channel_then_categories[1]
else:
categories = "default"
if channel == "gdb-remote" and lldb.remote_platform is None:
os.environ["LLDB_DEBUGSERVER_LOG_FLAGS"] = categories
self.ci.HandleCommand(log_enable + channel_with_categories, self.res)
if not self.res.Succeeded():
raise Exception(
"log enable failed (check LLDB_LOG_OPTION env variable)"
)
if lldb.remote_platform is None:
server_log_path = "{}-server.log".format(log_basename)
open(server_log_path, "w").close()
self.log_files.append(server_log_path)
os.environ["LLDB_DEBUGSERVER_LOG_FILE"] = server_log_path
os.environ["LLDB_SERVER_LOG_CHANNELS"] = ":".join(lldbtest_config.channels)
self.addTearDownHook(self.disableLogChannelsForCurrentTest)
def disableLogChannelsForCurrentTest(self):
for channel_and_categories in lldbtest_config.channels:
channel = channel_and_categories.split(" ", 1)[0]
self.ci.HandleCommand("log disable " + channel, self.res)
if not self.res.Succeeded():
raise Exception(
"log disable failed (check LLDB_LOG_OPTION env variable)"
)
if lldb.remote_platform:
server_log_path = self.getLogBasenameForCurrentTest() + "-server.log"
if lldb.remote_platform.Get(
lldb.SBFileSpec("server.log"), lldb.SBFileSpec(server_log_path)
).Success():
self.log_files.append(server_log_path)
def setPlatformWorkingDir(self):
if not lldb.remote_platform or not configuration.lldb_platform_working_dir:
return
components = self.mydir.split(os.path.sep) + [
str(self.test_number),
self.getBuildDirBasename(),
]
remote_test_dir = configuration.lldb_platform_working_dir
for c in components:
remote_test_dir = lldbutil.join_remote_paths(remote_test_dir, c)
error = lldb.remote_platform.MakeDirectory(
remote_test_dir, 448
)
if error.Fail():
raise Exception(
"making remote directory '%s': %s" % (remote_test_dir, error)
)
lldb.remote_platform.SetWorkingDirectory(remote_test_dir)
def clean_working_directory():
shell_cmd = lldb.SBPlatformShellCommand("rm %s/*" % remote_test_dir)
lldb.remote_platform.Run(shell_cmd)
self.addTearDownHook(clean_working_directory)
def getSourceDir(self):
"""Return the full path to the current test."""
return os.path.join(configuration.test_src_root, self.mydir)
def getBuildDirBasename(self):
return self.__class__.__module__ + "." + self.testMethodName
def getBuildDir(self):
"""Return the full path to the current test."""
return os.path.join(
configuration.test_build_dir, self.mydir, self.getBuildDirBasename()
)
def makeBuildDir(self):
"""Create the test-specific working directory, deleting any previous
contents."""
bdir = self.getBuildDir()
if os.path.isdir(bdir):
shutil.rmtree(bdir)
lldbutil.mkdir_p(bdir)
def getBuildArtifact(self, name="a.out"):
"""Return absolute path to an artifact in the test's build directory."""
return os.path.join(self.getBuildDir(), name)
def getSourcePath(self, name):
"""Return absolute path to a file in the test's source directory."""
return os.path.join(self.getSourceDir(), name)
@classmethod
def setUpCommands(cls):
commands = [
"settings clear -all",
"settings set symbols.enable-external-lookup false",
"settings set target.inherit-tcc true",
"settings set target.disable-aslr false",
"settings set target.detach-on-error false",
"settings set target.auto-apply-fixits false",
"settings set plugin.process.gdb-remote.packet-timeout 60",
'settings set symbols.clang-modules-cache-path "{}"'.format(
configuration.lldb_module_cache_dir
),
"settings set use-color false",
]
for setting, value in configuration.settings:
commands.append("setting set %s %s" % (setting, value))
if (
cls.platformContext
and cls.platformContext.shlib_environment_var in os.environ
):
commands.append(
"settings set target.env-vars {}=".format(
cls.platformContext.shlib_environment_var
)
)
if lldbtest_config.inferior_env:
commands.append(
"settings set target.env-vars {}".format(lldbtest_config.inferior_env)
)
return commands
def setUp(self):
"""Fixture for unittest test case setup.
It works with the test driver to conditionally skip tests and does other
initializations."""
if "LLDB_MAX_LAUNCH_COUNT" in os.environ:
self.maxLaunchCount = int(os.environ["LLDB_MAX_LAUNCH_COUNT"])
if "LLDB_TIME_WAIT_NEXT_LAUNCH" in os.environ:
self.timeWaitNextLaunch = float(os.environ["LLDB_TIME_WAIT_NEXT_LAUNCH"])
if "LIBCXX_PATH" in os.environ:
self.libcxxPath = os.environ["LIBCXX_PATH"]
else:
self.libcxxPath = None
if "LLDBDAP_EXEC" in os.environ:
self.lldbDAPExec = os.environ["LLDBDAP_EXEC"]
else:
self.lldbDAPExec = None
self.lldbOption = " ".join("-o '" + s + "'" for s in self.setUpCommands())
if os.environ.get("NO_LLDBINIT") != "NO":
self.lldbOption += " --no-lldbinit"
self.testMethodName = self._testMethodName
self.child = None
self.child_prompt = "(lldb) "
self.child_in_script_interpreter = False
self.dict = None
self.doTearDownCleanup = False
self.dicts = []
self.doTearDownCleanups = False
self.subprocesses = []
self.log_files = []
self.makeBuildDir()
session_file = self.getLogBasenameForCurrentTest() + ".log"
self.log_files.append(session_file)
self.session = encoded_file.open(session_file, "utf-8", mode="w")
self.__cleanup_errored__ = False
self.__errored__ = False
self.__failed__ = False
self.__expected__ = False
self.__unexpected__ = False
self.__skipped__ = False
self.hooks = []
self.sys_stdout_hidden = False
if self.platformContext:
self.dylibPath = self.platformContext.shlib_environment_var
self.dbg = lldb.SBDebugger.Create()
if lldb.selected_platform is not None:
self.dbg.SetSelectedPlatform(lldb.selected_platform)
if not self.dbg:
raise Exception("Invalid debugger instance")
self.ci = self.dbg.GetCommandInterpreter()
if not self.ci:
raise Exception("Could not get the command interpreter")
self.res = lldb.SBCommandReturnObject()
self.setPlatformWorkingDir()
self.enableLogChannelsForCurrentTest()
self.lib_lldb = None
self.framework_dir = None
self.darwinWithFramework = False
if sys.platform.startswith("darwin") and configuration.lldb_framework_path:
framework = configuration.lldb_framework_path
lib = os.path.join(framework, "LLDB")
if os.path.exists(lib):
self.framework_dir = os.path.dirname(framework)
self.lib_lldb = lib
self.darwinWithFramework = self.platformIsDarwin()
def setAsync(self, value):
"""Sets async mode to True/False and ensures it is reset after the testcase completes."""
old_async = self.dbg.GetAsync()
self.dbg.SetAsync(value)
self.addTearDownHook(lambda: self.dbg.SetAsync(old_async))
def cleanupSubprocesses(self):
for p in reversed(self.subprocesses):
p.terminate()
del p
del self.subprocesses[:]
def spawnSubprocess(self, executable, args=[], extra_env=None, install_remote=True):
"""Creates a subprocess.Popen object with the specified executable and arguments,
saves it in self.subprocesses, and returns the object.
"""
proc = (
_RemoteProcess(install_remote)
if lldb.remote_platform
else _LocalProcess(self.TraceOn())
)
proc.launch(executable, args, extra_env=extra_env)
self.subprocesses.append(proc)
return proc
def runCmd(self, cmd, msg=None, check=True, trace=False, inHistory=False):
"""
Ask the command interpreter to handle the command and then check its
return status.
"""
if cmd is None:
raise Exception("Bad 'cmd' parameter encountered")
trace = True if traceAlways else trace
if cmd.startswith("target create "):
cmd = cmd.replace("target create ", "file ")
running = cmd.startswith("run") or cmd.startswith("process launch")
for i in range(self.maxLaunchCount if running else 1):
with recording(self, trace) as sbuf:
print("runCmd:", cmd, file=sbuf)
if not check:
print("check of return status not required", file=sbuf)
self.ci.HandleCommand(cmd, self.res, inHistory)
with recording(self, trace) as sbuf:
if self.res.Succeeded():
print("output:", self.res.GetOutput(), file=sbuf)
else:
print("runCmd failed!", file=sbuf)
print(self.res.GetError(), file=sbuf)
if self.res.Succeeded():
break
elif running:
time.sleep(self.timeWaitNextLaunch)
with recording(self, trace) as sbuf:
print("Command '" + cmd + "' failed!", file=sbuf)
if check:
output = ""
if self.res.GetOutput():
output += "\nCommand output:\n" + self.res.GetOutput()
if self.res.GetError():
output += "\nError output:\n" + self.res.GetError()
if msg:
msg += output
if cmd:
cmd += output
self.assertTrue(self.res.Succeeded(), msg if (msg) else CMD_MSG(cmd))
def HideStdout(self):
"""Hide output to stdout from the user.
During test execution, there might be cases where we don't want to show the
standard output to the user. For example,
self.runCmd(r'''sc print("\n\n\tHello!\n")''')
tests whether command abbreviation for 'script' works or not. There is no
need to show the 'Hello' output to the user as long as the 'script' command
succeeds and we are not in TraceOn() mode (see the '-t' option).
In this case, the test method calls self.HideStdout(self) to redirect the
sys.stdout to a null device, and restores the sys.stdout upon teardown.
Note that you should only call this method at most once during a test case
execution. Any subsequent call has no effect at all."""
if self.sys_stdout_hidden:
return
self.sys_stdout_hidden = True
old_stdout = sys.stdout
sys.stdout = open(os.devnull, "w")
def restore_stdout():
sys.stdout = old_stdout
self.addTearDownHook(restore_stdout)
def setTearDownCleanup(self, dictionary=None):
"""Register a cleanup action at tearDown() time with a dictionary"""
self.dict = dictionary
self.doTearDownCleanup = True
def addTearDownCleanup(self, dictionary):
"""Add a cleanup action at tearDown() time with a dictionary"""
self.dicts.append(dictionary)
self.doTearDownCleanups = True
def addTearDownHook(self, hook):
"""
Add a function to be run during tearDown() time.
Hooks are executed in a first come first serve manner.
"""
if callable(hook):
with recording(self, traceAlways) as sbuf:
print("Adding tearDown hook:", getsource_if_available(hook), file=sbuf)
self.hooks.append(hook)
return self
def deletePexpectChild(self):
if self.child and self.child.isalive():
import pexpect
with recording(self, traceAlways) as sbuf:
print("tearing down the child process....", file=sbuf)
try:
if self.child_in_script_interpreter:
self.child.sendline("quit()")
self.child.expect_exact(self.child_prompt)
self.child.sendline("settings set interpreter.prompt-on-quit false")
self.child.sendline("quit")
self.child.expect(pexpect.EOF)
except (ValueError, pexpect.ExceptionPexpect):
pass
except OSError as exception:
import errno
if exception.errno != errno.EIO:
raise
finally:
self.child.close()
def tearDown(self):
"""Fixture for unittest test case teardown."""
self.deletePexpectChild()
for hook in reversed(self.hooks):
with recording(self, traceAlways) as sbuf:
print(
"Executing tearDown hook:", getsource_if_available(hook), file=sbuf
)
if funcutils.requires_self(hook):
hook(self)
else:
hook()
del self.hooks
if doCleanup and self.doTearDownCleanup:
self.cleanup(dictionary=self.dict)
if doCleanup and self.doTearDownCleanups:
if self.dicts:
for dict in reversed(self.dicts):
self.cleanup(dictionary=dict)
self.cleanupSubprocesses()
lldb.SBDebugger.Destroy(self.dbg)
del self.dbg
lldb.SBModule.GarbageCollectAllocatedModules()
if self.getPlatform() != "windows":
self.assertEqual(lldb.SBModule.GetNumberAllocatedModules(), 0)
def markError(self):
"""Callback invoked when an error (unexpected exception) errored."""
self.__errored__ = True
with recording(self, False) as sbuf:
print("ERROR", file=sbuf)
def markCleanupError(self):
"""Callback invoked when an error occurs while a test is cleaning up."""
self.__cleanup_errored__ = True
with recording(self, False) as sbuf:
print("CLEANUP_ERROR", file=sbuf)
def markFailure(self):
"""Callback invoked when a failure (test assertion failure) occurred."""
self.__failed__ = True
with recording(self, False) as sbuf:
print("FAIL", file=sbuf)
def markExpectedFailure(self, err):
"""Callback invoked when an expected failure/error occurred."""
self.__expected__ = True
with recording(self, False) as sbuf:
print("expected failure", file=sbuf)
def markSkippedTest(self):
"""Callback invoked when a test is skipped."""
self.__skipped__ = True
with recording(self, False) as sbuf:
print("skipped test", file=sbuf)
def markUnexpectedSuccess(self):
"""Callback invoked when an unexpected success occurred."""
self.__unexpected__ = True
with recording(self, False) as sbuf:
print("unexpected success", file=sbuf)
def getRerunArgs(self):
return " -f %s.%s" % (self.__class__.__name__, self._testMethodName)
def getLogBasenameForCurrentTest(self, prefix="Incomplete"):
"""
returns a partial path that can be used as the beginning of the name of multiple
log files pertaining to this test
"""
return os.path.join(self.getBuildDir(), prefix)
def dumpSessionInfo(self):
"""
Dump the debugger interactions leading to a test error/failure. This
allows for more convenient postmortem analysis.
See also LLDBTestResult (dotest.py) which is a singlton class derived
from TextTestResult and overwrites addError, addFailure, and
addExpectedFailure methods to allow us to to mark the test instance as
such.
"""
pairs = []
if self.__errored__:
pairs = configuration.test_result.errors
prefix = "Error"
elif self.__cleanup_errored__:
pairs = configuration.test_result.cleanup_errors
prefix = "CleanupError"
elif self.__failed__:
pairs = configuration.test_result.failures
prefix = "Failure"
elif self.__expected__:
pairs = configuration.test_result.expectedFailures
prefix = "ExpectedFailure"
elif self.__skipped__:
prefix = "SkippedTest"
elif self.__unexpected__:
prefix = "UnexpectedSuccess"
else:
prefix = "Success"
if not self.__unexpected__ and not self.__skipped__:
for test, traceback in pairs:
if test is self:
print(traceback, file=self.session)
import datetime
print(
"Session info generated @",
datetime.datetime.now().ctime(),
file=self.session,
)
self.session.close()
del self.session
if prefix != "Success" or lldbtest_config.log_success:
src_log_basename = self.getLogBasenameForCurrentTest()
dst_log_basename = self.getLogBasenameForCurrentTest(prefix)
for src in self.log_files:
if os.path.isfile(src):
dst = src.replace(src_log_basename, dst_log_basename)
if os.name == "nt" and os.path.isfile(dst):
remove_file(dst)
lldbutil.mkdir_p(os.path.dirname(dst))
os.rename(src, dst)
else:
for log_file in self.log_files:
if os.path.isfile(log_file):
remove_file(log_file)
def hasXMLSupport(self):
"""Returns True if lldb was built with XML support. Use this check to
enable parts of tests, if you want to skip a whole test use skipIfXmlSupportMissing
instead."""
return (
lldb.SBDebugger.GetBuildConfiguration()
.GetValueForKey("xml")
.GetValueForKey("value")
.GetBooleanValue(False)
)
def isMIPS(self):
"""Returns true if the architecture is MIPS."""
arch = self.getArchitecture()
if re.match("mips", arch):
return True
return False
def isPPC64le(self):
"""Returns true if the architecture is PPC64LE."""
arch = self.getArchitecture()
if re.match("powerpc64le", arch):
return True
return False
def getCPUInfo(self):
triple = self.dbg.GetSelectedPlatform().GetTriple()
if not re.match(".*-.*-linux", triple):
return ""
cpuinfo_path = self.getBuildArtifact("cpuinfo")
if configuration.lldb_platform_name:
self.runCmd('platform get-file "/proc/cpuinfo" ' + cpuinfo_path)
else:
cpuinfo_path = "/proc/cpuinfo"
try:
with open(cpuinfo_path, "r") as f:
cpuinfo = f.read()
except:
return ""
return cpuinfo
def isAArch64(self):
"""Returns true if the architecture is AArch64."""
arch = self.getArchitecture().lower()
return arch in ["aarch64", "arm64", "arm64e"]
def isAArch64SVE(self):
return self.isAArch64() and "sve" in self.getCPUInfo()
def isAArch64SME(self):
return self.isAArch64() and "sme" in self.getCPUInfo()
def isAArch64SME2(self):
return self.isAArch64() and "sme2" in self.getCPUInfo()
def isAArch64SMEFA64(self):
cpuinfo = self.getCPUInfo()
return self.isAArch64() and "sme" in cpuinfo and "smefa64" in cpuinfo
def isAArch64MTE(self):
return self.isAArch64() and "mte" in self.getCPUInfo()
def isAArch64PAuth(self):
if self.getArchitecture() == "arm64e":
return True
return self.isAArch64() and "paca" in self.getCPUInfo()
def isAArch64Windows(self):
"""Returns true if the architecture is AArch64 and platform windows."""
if self.getPlatform() == "windows":
arch = self.getArchitecture().lower()
return arch in ["aarch64", "arm64", "arm64e"]
return False
def getArchitecture(self):
"""Returns the architecture in effect the test suite is running with."""
return lldbplatformutil.getArchitecture()
def getLldbArchitecture(self):
"""Returns the architecture of the lldb binary."""
return lldbplatformutil.getLLDBArchitecture()
def getCompiler(self):
"""Returns the compiler in effect the test suite is running with."""
return lldbplatformutil.getCompiler()
def getCompilerBinary(self):
"""Returns the compiler binary the test suite is running with."""
return lldbplatformutil.getCompilerBinary()
def getCompilerVersion(self):
"""Returns a string that represents the compiler version.
Supports: llvm, clang.
"""
return lldbplatformutil.getCompilerVersion()
def getDwarfVersion(self):
"""Returns the dwarf version generated by clang or '0'."""
return lldbplatformutil.getDwarfVersion()
def platformIsDarwin(self):
"""Returns true if the OS triple for the selected platform is any valid apple OS"""
return lldbplatformutil.platformIsDarwin()
def hasDarwinFramework(self):
return self.darwinWithFramework
def getPlatform(self):
"""Returns the target platform the test suite is running on."""
return lldbplatformutil.getPlatform()
def isIntelCompiler(self):
"""Returns true if using an Intel (ICC) compiler, false otherwise."""
return any([x in self.getCompiler() for x in ["icc", "icpc", "icl"]])
def expectedCompilerVersion(self, compiler_version):
"""Returns True iff compiler_version[1] matches the current compiler version.
Use compiler_version[0] to specify the operator used to determine if a match has occurred.
Any operator other than the following defaults to an equality test:
'>', '>=', "=>", '<', '<=', '=<', '!=', "!" or 'not'
If the current compiler version cannot be determined, we assume it is close to the top
of trunk, so any less-than or equal-to comparisons will return False, and any
greater-than or not-equal-to comparisons will return True.
"""
return lldbplatformutil.expectedCompilerVersion(compiler_version)
def expectedCompiler(self, compilers):
"""Returns True iff any element of compilers is a sub-string of the current compiler."""
return lldbplatformutil.expectedCompiler(compilers)
def expectedArch(self, archs):
"""Returns True iff any element of archs is a sub-string of the current architecture."""
if archs is None:
return True
for arch in archs:
if arch in self.getArchitecture():
return True
return False
def getRunOptions(self):
"""Command line option for -A and -C to run this test again, called from
self.dumpSessionInfo()."""
arch = self.getArchitecture()
comp = self.getCompiler()
option_str = ""
if arch:
option_str = "-A " + arch
if comp:
option_str += " -C " + comp
return option_str
def getDebugInfo(self):
method = getattr(self, self.testMethodName)
return getattr(method, "debug_info", None)
def build(
self,
debug_info=None,
architecture=None,
compiler=None,
dictionary=None,
make_targets=None,
):
"""Platform specific way to build binaries."""
if not architecture and configuration.arch:
architecture = configuration.arch
if debug_info is None:
debug_info = self.getDebugInfo()
dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
testdir = self.mydir
testname = self.getBuildDirBasename()
module = builder_module()
command = builder_module().getBuildCommand(
debug_info,
architecture,
compiler,
dictionary,
testdir,
testname,
make_targets,
)
if command is None:
raise Exception("Don't know how to build binary")
self.runBuildCommand(command)
def runBuildCommand(self, command):
self.trace(seven.join_for_shell(command))
try:
output = check_output(command, stderr=STDOUT, errors="replace")
except CalledProcessError as cpe:
raise build_exception.BuildError(cpe)
self.trace(output)
def getstdlibFlag(self):
"""Returns the proper -stdlib flag, or empty if not required."""
if (
self.platformIsDarwin()
or self.getPlatform() == "freebsd"
or self.getPlatform() == "openbsd"
):
stdlibflag = "-stdlib=libc++"
else:
stdlibflag = ""
return stdlibflag
def getstdFlag(self):
"""Returns the proper stdflag."""
if "gcc" in self.getCompiler() and "4.6" in self.getCompilerVersion():
stdflag = "-std=c++0x"
else:
stdflag = "-std=c++11"
return stdflag
def buildDriver(self, sources, exe_name):
"""Platform-specific way to build a program that links with LLDB (via the liblldb.so
or LLDB.framework).
"""
stdflag = self.getstdFlag()
stdlibflag = self.getstdlibFlag()
lib_dir = configuration.lldb_libs_dir
if self.hasDarwinFramework():
d = {
"CXX_SOURCES": sources,
"EXE": exe_name,
"CFLAGS_EXTRAS": "%s %s" % (stdflag, stdlibflag),
"FRAMEWORK_INCLUDES": "-F%s" % self.framework_dir,
"LD_EXTRAS": "%s -Wl,-rpath,%s" % (self.lib_lldb, self.framework_dir),
}
elif sys.platform.startswith("win"):
d = {
"CXX_SOURCES": sources,
"EXE": exe_name,
"CFLAGS_EXTRAS": "%s %s -I%s -I%s"
% (
stdflag,
stdlibflag,
os.path.join(os.environ["LLDB_SRC"], "include"),
os.path.join(configuration.lldb_obj_root, "include"),
),
"LD_EXTRAS": "-L%s -lliblldb" % lib_dir,
}
else:
d = {
"CXX_SOURCES": sources,
"EXE": exe_name,
"CFLAGS_EXTRAS": "%s %s -I%s -I%s"
% (
stdflag,
stdlibflag,
os.path.join(os.environ["LLDB_SRC"], "include"),
os.path.join(configuration.lldb_obj_root, "include"),
),
"LD_EXTRAS": "-L%s -llldb -Wl,-rpath,%s" % (lib_dir, lib_dir),
}
if self.TraceOn():
print("Building LLDB Driver (%s) from sources %s" % (exe_name, sources))
self.build(dictionary=d)
def buildLibrary(self, sources, lib_name):
"""Platform specific way to build a default library."""
stdflag = self.getstdFlag()
lib_dir = configuration.lldb_libs_dir
if self.hasDarwinFramework():
d = {
"DYLIB_CXX_SOURCES": sources,
"DYLIB_NAME": lib_name,
"CFLAGS_EXTRAS": "%s -stdlib=libc++ -I%s"
% (stdflag, os.path.join(configuration.lldb_obj_root, "include")),
"FRAMEWORK_INCLUDES": "-F%s" % self.framework_dir,
"LD_EXTRAS": "%s -Wl,-rpath,%s -dynamiclib"
% (self.lib_lldb, self.framework_dir),
}
elif self.getPlatform() == "windows":
d = {
"DYLIB_CXX_SOURCES": sources,
"DYLIB_NAME": lib_name,
"CFLAGS_EXTRAS": "%s -I%s -I%s"
% (
stdflag,
os.path.join(os.environ["LLDB_SRC"], "include"),
os.path.join(configuration.lldb_obj_root, "include"),
),
"LD_EXTRAS": "-shared -l%s\\liblldb.lib" % lib_dir,
}
else:
d = {
"DYLIB_CXX_SOURCES": sources,
"DYLIB_NAME": lib_name,
"CFLAGS_EXTRAS": "%s -I%s -I%s -fPIC"
% (
stdflag,
os.path.join(os.environ["LLDB_SRC"], "include"),
os.path.join(configuration.lldb_obj_root, "include"),
),
"LD_EXTRAS": "-shared -L%s -llldb -Wl,-rpath,%s" % (lib_dir, lib_dir),
}
if self.TraceOn():
print("Building LLDB Library (%s) from sources %s" % (lib_name, sources))
self.build(dictionary=d)
def buildProgram(self, sources, exe_name):
"""Platform specific way to build an executable from C/C++ sources."""
d = {"CXX_SOURCES": sources, "EXE": exe_name}
self.build(dictionary=d)
def findBuiltClang(self):
"""Tries to find and use Clang from the build directory as the compiler (instead of the system compiler)."""
paths_to_try = [
"llvm-build/Release+Asserts/x86_64/bin/clang",
"llvm-build/Debug+Asserts/x86_64/bin/clang",
"llvm-build/Release/x86_64/bin/clang",
"llvm-build/Debug/x86_64/bin/clang",
]
lldb_root_path = os.path.join(os.path.dirname(__file__), "..", "..", "..", "..")
for p in paths_to_try:
path = os.path.join(lldb_root_path, p)
if os.path.exists(path):
return path
lldb_dir = os.path.dirname(lldbtest_config.lldbExec)
path = shutil.which("clang", path=lldb_dir)
if path is not None:
return path
return os.environ["CC"]
def yaml2obj(self, yaml_path, obj_path, max_size=None):
"""
Create an object file at the given path from a yaml file.
Throws subprocess.CalledProcessError if the object could not be created.
"""
yaml2obj_bin = configuration.get_yaml2obj_path()
if not yaml2obj_bin:
self.assertTrue(False, "No valid yaml2obj executable specified")
command = [yaml2obj_bin, "-o=%s" % obj_path, yaml_path]
if max_size is not None:
command += ["--max-size=%d" % max_size]
self.runBuildCommand(command)
def cleanup(self, dictionary=None):
"""Platform specific way to do cleanup after build."""
module = builder_module()
if not module.cleanup(dictionary):
raise Exception(
"Don't know how to do cleanup with dictionary: " + dictionary
)
def invoke(self, obj, name, trace=False):
"""Use reflection to call a method dynamically with no argument."""
trace = True if traceAlways else trace
method = getattr(obj, name)
import inspect
self.assertTrue(
inspect.ismethod(method), name + "is a method name of object: " + str(obj)
)
result = method()
with recording(self, trace) as sbuf:
print(str(method) + ":", result, file=sbuf)
return result
def getLibcPlusPlusLibs(self):
if self.getPlatform() in ("freebsd", "linux", "netbsd", "openbsd"):
return ["libc++.so.1"]
else:
return ["libc++.1.dylib", "libc++abi."]
def run_platform_command(self, cmd):
platform = self.dbg.GetSelectedPlatform()
shell_command = lldb.SBPlatformShellCommand(cmd)
err = platform.Run(shell_command)
return (err, shell_command.GetStatus(), shell_command.GetOutput())
def get_stats(self, options=None):
"""
Get the output of the "statistics dump" with optional extra options
and return the JSON as a python dictionary.
"""
return_obj = lldb.SBCommandReturnObject()
command = "statistics dump "
if options is not None:
command += options
self.ci.HandleCommand(command, return_obj, False)
metrics_json = return_obj.GetOutput()
return json.loads(metrics_json)
class LLDBTestCaseFactory(type):
def __new__(cls, name, bases, attrs):
original_testcase = super(LLDBTestCaseFactory, cls).__new__(
cls, name, bases, attrs
)
if original_testcase.NO_DEBUG_INFO_TESTCASE:
return original_testcase
def no_reason(_):
return None
newattrs = {}
for attrname, attrvalue in attrs.items():
if attrname.startswith("test") and not getattr(
attrvalue, "__no_debug_info_test__", False
):
all_dbginfo_categories = set(
test_categories.debug_info_categories.keys()
)
categories = (
set(getattr(attrvalue, "categories", [])) & all_dbginfo_categories
)
if not categories:
categories = [
category
for category, can_replicate in test_categories.debug_info_categories.items()
if can_replicate
]
xfail_for_debug_info_cat_fn = getattr(
attrvalue, "__xfail_for_debug_info_cat_fn__", no_reason
)
skip_for_debug_info_cat_fn = getattr(
attrvalue, "__skip_for_debug_info_cat_fn__", no_reason
)
for cat in categories:
@decorators.add_test_categories([cat])
@wraps(attrvalue)
def test_method(self, attrvalue=attrvalue):
return attrvalue(self)
method_name = attrname + "_" + cat
test_method.__name__ = method_name
test_method.debug_info = cat
xfail_reason = xfail_for_debug_info_cat_fn(cat)
if xfail_reason:
test_method = unittest.expectedFailure(test_method)
skip_reason = skip_for_debug_info_cat_fn(cat)
if skip_reason:
test_method = unittest.skip(skip_reason)(test_method)
newattrs[method_name] = test_method
else:
newattrs[attrname] = attrvalue
return super(LLDBTestCaseFactory, cls).__new__(cls, name, bases, newattrs)
class TestBase(Base, metaclass=LLDBTestCaseFactory):
"""
This abstract base class is meant to be subclassed. It provides default
implementations for setUpClass(), tearDownClass(), setUp(), and tearDown(),
among other things.
Important things for test class writers:
- The setUp method sets up things to facilitate subsequent interactions
with the debugger as part of the test. These include:
- populate the test method name
- create/get a debugger set with synchronous mode (self.dbg)
- get the command interpreter from with the debugger (self.ci)
- create a result object for use with the command interpreter
(self.res)
- plus other stuffs
- The tearDown method tries to perform some necessary cleanup on behalf
of the test to return the debugger to a good state for the next test.
These include:
- execute any tearDown hooks registered by the test method with
TestBase.addTearDownHook(); examples can be found in
settings/TestSettings.py
- kill the inferior process associated with each target, if any,
and, then delete the target from the debugger's target list
- perform build cleanup before running the next test method in the
same test class; examples of registering for this service can be
found in types/TestIntegerTypes.py with the call:
- self.setTearDownCleanup(dictionary=d)
- Similarly setUpClass and tearDownClass perform classwise setup and
teardown fixtures. The tearDownClass method invokes a default build
cleanup for the entire test class; also, subclasses can implement the
classmethod classCleanup(cls) to perform special class cleanup action.
- The instance methods runCmd and expect are used heavily by existing
test cases to send a command to the command interpreter and to perform
string/pattern matching on the output of such command execution. The
expect method also provides a mode to peform string/pattern matching
without running a command.
- The build method is used to build the binaries used during a
particular test scenario. A plugin should be provided for the
sys.platform running the test suite. The Mac OS X implementation is
located in builders/darwin.py.
"""
NO_DEBUG_INFO_TESTCASE = False
def generateSource(self, source):
template = source + ".template"
temp = os.path.join(self.getSourceDir(), template)
with open(temp, "r") as f:
content = f.read()
public_api_dir = os.path.join(os.environ["LLDB_SRC"], "include", "lldb", "API")
public_headers = os.listdir(public_api_dir)
if self.hasDarwinFramework():
include_stmt = "'#include <%s>' % os.path.join('LLDB', header)"
else:
include_stmt = (
"'#include <%s>' % os.path.join(r'" + public_api_dir + "', header)"
)
list = [
eval(include_stmt)
for header in public_headers
if (header.startswith("SB") and header.endswith(".h"))
]
includes = "\n".join(list)
new_content = content.replace("%include_SB_APIs%", includes)
new_content = new_content.replace("%SOURCE_DIR%", self.getSourceDir())
src = os.path.join(self.getBuildDir(), source)
with open(src, "w") as f:
f.write(new_content)
self.addTearDownHook(lambda: os.remove(src))
def setUp(self):
Base.setUp(self)
for s in self.setUpCommands():
self.runCmd(s)
self.dbg.SetAsync(False)
self.ci = self.dbg.GetCommandInterpreter()
if not self.ci:
raise Exception("Could not get the command interpreter")
self.res = lldb.SBCommandReturnObject()
def registerSharedLibrariesWithTarget(self, target, shlibs):
"""If we are remotely running the test suite, register the shared libraries with the target so they get uploaded, otherwise do nothing
Any modules in the target that have their remote install file specification set will
get uploaded to the remote host. This function registers the local copies of the
shared libraries with the target and sets their remote install locations so they will
be uploaded when the target is run.
"""
if not shlibs or not self.platformContext:
return None
shlib_environment_var = self.platformContext.shlib_environment_var
shlib_prefix = self.platformContext.shlib_prefix
shlib_extension = "." + self.platformContext.shlib_extension
dirs = []
for name in shlibs:
if os.path.isfile(name):
local_shlib_path = (
name
)
else:
local_shlib_path = os.path.join(
self.getBuildDir(), shlib_prefix + name + shlib_extension
)
if not os.path.exists(local_shlib_path):
local_shlib_path = os.path.join(
self.getBuildDir(), name + shlib_extension
)
if not os.path.exists(local_shlib_path):
local_shlib_path = os.path.join(self.getBuildDir(), name)
self.assertTrue(os.path.exists(local_shlib_path))
shlib_module = target.AddModule(local_shlib_path, None, None, None)
if lldb.remote_platform:
remote_shlib_path = lldbutil.append_to_process_working_directory(
self, os.path.basename(local_shlib_path)
)
shlib_module.SetRemoteInstallFileSpec(
lldb.SBFileSpec(remote_shlib_path, False)
)
dir_to_add = self.get_process_working_directory()
else:
dir_to_add = os.path.dirname(local_shlib_path)
if dir_to_add not in dirs:
dirs.append(dir_to_add)
env_value = self.platformContext.shlib_path_separator.join(dirs)
return ["%s=%s" % (shlib_environment_var, env_value)]
def registerSanitizerLibrariesWithTarget(self, target):
runtimes = []
for m in target.module_iter():
libspec = m.GetFileSpec()
if "clang_rt" in libspec.GetFilename():
runtimes.append(
os.path.join(libspec.GetDirectory(), libspec.GetFilename())
)
return self.registerSharedLibrariesWithTarget(target, runtimes)
def target(self):
if not self.dbg:
raise Exception("Invalid debugger instance")
return self.dbg.GetSelectedTarget()
def process(self):
if not self.dbg:
raise Exception("Invalid debugger instance")
return self.dbg.GetSelectedTarget().GetProcess()
def thread(self):
if not self.dbg:
raise Exception("Invalid debugger instance")
return self.dbg.GetSelectedTarget().GetProcess().GetSelectedThread()
def frame(self):
if not self.dbg:
raise Exception("Invalid debugger instance")
return (
self.dbg.GetSelectedTarget()
.GetProcess()
.GetSelectedThread()
.GetSelectedFrame()
)
def get_process_working_directory(self):
"""Get the working directory that should be used when launching processes for local or remote processes."""
if lldb.remote_platform:
return lldb.remote_platform.GetWorkingDirectory()
else:
return self.getBuildDir()
def tearDown(self):
gc.collect()
targets = []
for target in self.dbg:
if target:
targets.append(target)
process = target.GetProcess()
if process:
rc = self.invoke(process, "Kill")
assert rc.Success()
for target in targets:
self.dbg.DeleteTarget(target)
self.assertEqual(self.dbg.GetNumTargets(), 0)
Base.tearDown(self)
def switch_to_thread_with_stop_reason(self, stop_reason):
"""
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.
"""
from .lldbutil import stop_reason_to_str
self.runCmd("thread list")
output = self.res.GetOutput()
thread_line_pattern = re.compile(
"^[ *] thread #([0-9]+):.*stop reason = %s"
% stop_reason_to_str(stop_reason)
)
for line in output.splitlines():
matched = thread_line_pattern.match(line)
if matched:
self.runCmd("thread select %s" % matched.group(1))
def match(
self, str, patterns, msg=None, trace=False, error=False, matching=True, exe=True
):
"""run command in str, and match the result against regexp in patterns returning the match object for the first matching pattern
Otherwise, all the arguments have the same meanings as for the expect function
"""
trace = True if traceAlways else trace
if exe:
self.runCmd(str, msg=msg, trace=(True if trace else False), check=not error)
output = self.res.GetError() if error else self.res.GetOutput()
if error:
self.assertFalse(
self.res.Succeeded(), "Command '" + str + "' is expected to fail!"
)
else:
output = str
with recording(self, trace) as sbuf:
print("looking at:", output, file=sbuf)
heading = "Expecting" if matching else "Not expecting"
for pattern in patterns:
match_object = re.search(pattern, output)
matched = bool(match_object)
with recording(self, trace) as sbuf:
print("%s pattern: %s" % (heading, pattern), file=sbuf)
print("Matched" if matched else "Not matched", file=sbuf)
if matched:
break
self.assertTrue(
matched if matching else not matched,
msg if msg else EXP_MSG(str, output, exe),
)
return match_object
def check_completion_with_desc(
self, str_input, match_desc_pairs, enforce_order=False
):
"""
Checks that when the given input is completed at the given list of
completions and descriptions is returned.
:param str_input: The input that should be completed. The completion happens at the end of the string.
:param match_desc_pairs: A list of pairs that indicate what completions have to be in the list of
completions returned by LLDB. The first element of the pair is the completion
string that LLDB should generate and the second element the description.
:param enforce_order: True iff the order in which the completions are returned by LLDB
should match the order of the match_desc_pairs pairs.
"""
interp = self.dbg.GetCommandInterpreter()
match_strings = lldb.SBStringList()
description_strings = lldb.SBStringList()
num_matches = interp.HandleCompletionWithDescriptions(
str_input, len(str_input), 0, -1, match_strings, description_strings
)
self.assertEqual(len(description_strings), len(match_strings))
last_found_index = -1
out_of_order_errors = ""
missing_pairs = []
for pair in match_desc_pairs:
found_pair = False
for i in range(num_matches + 1):
match_candidate = match_strings.GetStringAtIndex(i)
description_candidate = description_strings.GetStringAtIndex(i)
if match_candidate == pair[0] and description_candidate == pair[1]:
found_pair = True
if enforce_order and last_found_index > i:
new_err = (
"Found completion "
+ pair[0]
+ " at index "
+ str(i)
+ " in returned completion list but "
+ "should have been after completion "
+ match_strings.GetStringAtIndex(last_found_index)
+ " (index:"
+ str(last_found_index)
+ ")\n"
)
out_of_order_errors += new_err
last_found_index = i
break
if not found_pair:
missing_pairs.append(pair)
error_msg = ""
got_failure = False
if len(missing_pairs):
got_failure = True
error_msg += "Missing pairs:\n"
for pair in missing_pairs:
error_msg += " [" + pair[0] + ":" + pair[1] + "]\n"
if len(out_of_order_errors):
got_failure = True
error_msg += out_of_order_errors
if got_failure:
error_msg += (
"Got the following " + str(num_matches) + " completions back:\n"
)
for i in range(num_matches + 1):
match_candidate = match_strings.GetStringAtIndex(i)
description_candidate = description_strings.GetStringAtIndex(i)
error_msg += (
"["
+ match_candidate
+ ":"
+ description_candidate
+ "] index "
+ str(i)
+ "\n"
)
self.assertFalse(got_failure, error_msg)
def complete_from_to(self, str_input, patterns):
"""Test that the completion mechanism completes str_input to patterns,
where patterns could be a single pattern-string or a list of
pattern-strings.
If there is only one pattern and it is exactly equal to str_input, this
assumes that there should be no completions provided and that the result
should be the same as the input."""
self.assertFalse(patterns is None)
if not isinstance(patterns, list):
patterns = [patterns]
interp = self.dbg.GetCommandInterpreter()
match_strings = lldb.SBStringList()
num_matches = interp.HandleCompletion(
str_input, len(str_input), 0, -1, match_strings
)
common_match = match_strings.GetStringAtIndex(0)
if num_matches == 0:
compare_string = str_input
else:
if common_match is not None and len(common_match) > 0:
compare_string = str_input + common_match
else:
compare_string = ""
for idx in range(1, num_matches + 1):
compare_string += match_strings.GetStringAtIndex(idx) + "\n"
if len(patterns) == 1 and str_input == patterns[0] and num_matches:
self.fail("Expected no completions but got:\n" + compare_string)
for p in patterns:
self.expect(
compare_string,
msg=COMPLETION_MSG(str_input, p, match_strings),
exe=False,
substrs=[p],
)
def completions_match(self, command, completions):
"""Checks that the completions for the given command are equal to the
given list of completions"""
interp = self.dbg.GetCommandInterpreter()
match_strings = lldb.SBStringList()
interp.HandleCompletion(command, len(command), 0, -1, match_strings)
self.assertCountEqual(
completions, list(match_strings)[1:], "List of returned completion is wrong"
)
def completions_contain(self, command, completions):
"""Checks that the completions for the given command contain the given
list of completions."""
interp = self.dbg.GetCommandInterpreter()
match_strings = lldb.SBStringList()
interp.HandleCompletion(command, len(command), 0, -1, match_strings)
for completion in completions:
self.assertIn(
completion, list(match_strings)[1:], "Couldn't find expected completion"
)
def filecheck(
self, command, check_file, filecheck_options="", expect_cmd_failure=False
):
self.runCmd(
command,
check=(not expect_cmd_failure),
msg="FileCheck'ing result of `{0}`".format(command),
)
self.assertTrue((not expect_cmd_failure) == self.res.Succeeded())
output = self.res.GetOutput() if self.res.Succeeded() else self.res.GetError()
if check_file.endswith(".pyc"):
check_file = check_file[:-1]
check_file_abs = os.path.abspath(check_file)
filecheck_bin = configuration.get_filecheck_path()
if not filecheck_bin:
self.assertTrue(False, "No valid FileCheck executable specified")
filecheck_args = [filecheck_bin, check_file_abs]
if filecheck_options:
filecheck_args.append(filecheck_options)
subproc = Popen(
filecheck_args,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE,
universal_newlines=True,
)
cmd_stdout, cmd_stderr = subproc.communicate(input=output)
cmd_status = subproc.returncode
filecheck_cmd = " ".join(filecheck_args)
filecheck_trace = """
--- FileCheck trace (code={0}) ---
{1}
FileCheck input:
{2}
FileCheck output:
{3}
{4}
""".format(
cmd_status, filecheck_cmd, output, cmd_stdout, cmd_stderr
)
trace = cmd_status != 0 or traceAlways
with recording(self, trace) as sbuf:
print(filecheck_trace, file=sbuf)
self.assertTrue(cmd_status == 0)
def expect(
self,
string,
msg=None,
patterns=None,
startstr=None,
endstr=None,
substrs=None,
trace=False,
error=False,
ordered=True,
matching=True,
exe=True,
inHistory=False,
):
"""
Similar to runCmd; with additional expect style output matching ability.
Ask the command interpreter to handle the command and then check its
return status. The 'msg' parameter specifies an informational assert
message. We expect the output from running the command to start with
'startstr', matches the substrings contained in 'substrs', and regexp
matches the patterns contained in 'patterns'.
When matching is true and ordered is true, which are both the default,
the strings in the substrs array have to appear in the command output
in the order in which they appear in the array.
If the keyword argument error is set to True, it signifies that the API
client is expecting the command to fail. In this case, the error stream
from running the command is retrieved and compared against the golden
input, instead.
If the keyword argument matching is set to False, it signifies that the API
client is expecting the output of the command not to match the golden
input.
Finally, the required argument 'string' represents the lldb command to be
sent to the command interpreter. In case the keyword argument 'exe' is
set to False, the 'string' is treated as a string to be matched/not-matched
against the golden input.
"""
if msg and not (patterns or startstr or endstr or substrs or error):
assert False, "expect() missing a matcher argument"
assert not isinstance(patterns, str), "patterns must be a collection of strings"
assert not isinstance(substrs, str), "substrs must be a collection of strings"
trace = True if traceAlways else trace
if exe:
self.runCmd(
string,
msg=msg,
trace=(True if trace else False),
check=not error,
inHistory=inHistory,
)
output = self.res.GetError() if error else self.res.GetOutput()
if error:
self.assertFalse(
self.res.Succeeded(),
"Command '" + string + "' is expected to fail!",
)
else:
if isinstance(string, lldb.SBCommandReturnObject):
output = string.GetOutput()
else:
output = string
with recording(self, trace) as sbuf:
print("looking at:", output, file=sbuf)
expecting_str = "Expecting" if matching else "Not expecting"
def found_str(matched):
return "was found" if matched else "was not found"
log_lines = [
"{}:".format("Ran command" if exe else "Checking string"),
'"{}"'.format(string),
"",
]
if exe:
log_lines.append("Got output:\n{}".format(output))
matched = matching
if startstr:
matched = output.startswith(startstr)
log_lines.append(
'{} start string: "{}" ({})'.format(
expecting_str, startstr, found_str(matched)
)
)
if endstr and matched == matching:
matched = output.endswith(endstr)
log_lines.append(
'{} end string: "{}" ({})'.format(
expecting_str, endstr, found_str(matched)
)
)
if substrs and matched == matching:
start = 0
for substr in substrs:
index = output[start:].find(substr)
start = start + index + len(substr) if ordered and matching else 0
matched = index != -1
log_lines.append(
'{} sub string: "{}" ({})'.format(
expecting_str, substr, found_str(matched)
)
)
if matched != matching:
break
if patterns and matched == matching:
for pattern in patterns:
matched = re.search(pattern, output)
pattern_line = '{} regex pattern: "{}" ({}'.format(
expecting_str, pattern, found_str(matched)
)
if matched:
pattern_line += ', matched "{}"'.format(matched.group(0))
pattern_line += ")"
log_lines.append(pattern_line)
matched = bool(matched)
if matched != matching:
break
if msg is not None and matched != matching:
log_lines.append(msg)
log_msg = "\n".join(log_lines)
with recording(self, trace) as sbuf:
print(log_msg, file=sbuf)
if matched != matching:
self.fail(log_msg)
def expect_expr(
self,
expr,
result_summary=None,
result_value=None,
result_type=None,
result_children=None,
):
"""
Evaluates the given expression and verifies the result.
:param expr: The expression as a string.
:param result_summary: The summary that the expression should have. None if the summary should not be checked.
:param result_value: The value that the expression should have. None if the value should not be checked.
:param result_type: The type that the expression result should have. None if the type should not be checked.
:param result_children: The expected children of the expression result
as a list of ValueChecks. None if the children shouldn't be checked.
"""
self.assertTrue(
expr.strip() == expr,
"Expression contains trailing/leading whitespace: '" + expr + "'",
)
frame = self.frame()
options = lldb.SBExpressionOptions()
options.SetAutoApplyFixIts(False)
options.SetIgnoreBreakpoints(True)
if self.frame().IsValid():
options.SetLanguage(frame.GuessLanguage())
eval_result = self.frame().EvaluateExpression(expr, options)
else:
target = self.target()
if not target.IsValid():
target = self.dbg.GetDummyTarget()
eval_result = target.EvaluateExpression(expr, options)
value_check = ValueCheck(
type=result_type,
value=result_value,
summary=result_summary,
children=result_children,
)
value_check.check_value(self, eval_result, str(eval_result))
return eval_result
def expect_var_path(
self, var_path, summary=None, value=None, type=None, children=None
):
"""
Evaluates the given variable path and verifies the result.
See also 'frame variable' and SBFrame.GetValueForVariablePath.
:param var_path: The variable path as a string.
:param summary: The summary that the variable should have. None if the summary should not be checked.
:param value: The value that the variable should have. None if the value should not be checked.
:param type: The type that the variable result should have. None if the type should not be checked.
:param children: The expected children of the variable as a list of ValueChecks.
None if the children shouldn't be checked.
"""
self.assertTrue(
var_path.strip() == var_path,
"Expression contains trailing/leading whitespace: '" + var_path + "'",
)
frame = self.frame()
eval_result = frame.GetValueForVariablePath(var_path)
value_check = ValueCheck(
type=type, value=value, summary=summary, children=children
)
value_check.check_value(self, eval_result, str(eval_result))
return eval_result
"""Assert that an lldb.SBError is in the "success" state."""
def assertSuccess(self, obj, msg=None):
if not obj.Success():
error = obj.GetCString()
self.fail(self._formatMessage(msg, "'{}' is not success".format(error)))
"""Assert that an lldb.SBError is in the "failure" state."""
def assertFailure(self, obj, error_str=None, msg=None):
if obj.Success():
self.fail(self._formatMessage(msg, "Error not in a fail state"))
if error_str is None:
return
error = obj.GetCString()
self.assertEqual(error, error_str, msg)
"""Assert that a command return object is successful"""
def assertCommandReturn(self, obj, msg=None):
if not obj.Succeeded():
error = obj.GetError()
self.fail(self._formatMessage(msg, "'{}' is not success".format(error)))
"""Assert two states are equal"""
def assertState(self, first, second, msg=None):
if first != second:
error = "{} ({}) != {} ({})".format(
lldbutil.state_type_to_str(first),
first,
lldbutil.state_type_to_str(second),
second,
)
self.fail(self._formatMessage(msg, error))
"""Assert two stop reasons are equal"""
def assertStopReason(self, first, second, msg=None):
if first != second:
error = "{} ({}) != {} ({})".format(
lldbutil.stop_reason_to_str(first),
first,
lldbutil.stop_reason_to_str(second),
second,
)
self.fail(self._formatMessage(msg, error))
def createTestTarget(self, file_path=None, msg=None, load_dependent_modules=True):
"""
Creates a target from the file found at the given file path.
Asserts that the resulting target is valid.
:param file_path: The file path that should be used to create the target.
The default argument opens the current default test
executable in the current test directory.
:param msg: A custom error message.
"""
if file_path is None:
file_path = self.getBuildArtifact("a.out")
error = lldb.SBError()
triple = ""
platform = ""
target = self.dbg.CreateTarget(
file_path, triple, platform, load_dependent_modules, error
)
if error.Fail():
err = "Couldn't create target for path '{}': {}".format(
file_path, str(error)
)
self.fail(self._formatMessage(msg, err))
self.assertTrue(target.IsValid(), "Got invalid target without error")
return target
def DebugSBValue(self, val):
"""Debug print a SBValue object, if traceAlways is True."""
from .lldbutil import value_type_to_str
if not traceAlways:
return
err = sys.stderr
err.write(val.GetName() + ":\n")
err.write("\t" + "TypeName -> " + val.GetTypeName() + "\n")
err.write("\t" + "ByteSize -> " + str(val.GetByteSize()) + "\n")
err.write("\t" + "NumChildren -> " + str(val.GetNumChildren()) + "\n")
err.write("\t" + "Value -> " + str(val.GetValue()) + "\n")
err.write("\t" + "ValueAsUnsigned -> " + str(val.GetValueAsUnsigned()) + "\n")
err.write(
"\t" + "ValueType -> " + value_type_to_str(val.GetValueType()) + "\n"
)
err.write("\t" + "Summary -> " + str(val.GetSummary()) + "\n")
err.write("\t" + "IsPointerType -> " + str(val.TypeIsPointerType()) + "\n")
err.write("\t" + "Location -> " + val.GetLocation() + "\n")
def DebugSBType(self, type):
"""Debug print a SBType object, if traceAlways is True."""
if not traceAlways:
return
err = sys.stderr
err.write(type.GetName() + ":\n")
err.write("\t" + "ByteSize -> " + str(type.GetByteSize()) + "\n")
err.write("\t" + "IsAggregateType -> " + str(type.IsAggregateType()) + "\n")
err.write("\t" + "IsPointerType -> " + str(type.IsPointerType()) + "\n")
err.write("\t" + "IsReferenceType -> " + str(type.IsReferenceType()) + "\n")
def DebugPExpect(self, child):
"""Debug the spwaned pexpect object."""
if not traceAlways:
return
print(child)
@classmethod
def RemoveTempFile(cls, file):
if os.path.exists(file):
remove_file(file)
def remove_file(file, num_retries=1, sleep_duration=0.5):
for i in range(num_retries + 1):
try:
os.remove(file)
return True
except:
time.sleep(sleep_duration)
continue
return False