diff options
Diffstat (limited to 'packages/Python/lldbsuite/test/lldbtest.py')
| -rw-r--r-- | packages/Python/lldbsuite/test/lldbtest.py | 2775 |
1 files changed, 2775 insertions, 0 deletions
diff --git a/packages/Python/lldbsuite/test/lldbtest.py b/packages/Python/lldbsuite/test/lldbtest.py new file mode 100644 index 0000000..43d02c5 --- /dev/null +++ b/packages/Python/lldbsuite/test/lldbtest.py @@ -0,0 +1,2775 @@ +""" +LLDB module which provides the abstract base class of lldb test case. + +The concrete subclass can override lldbtest.TesBase in order to inherit the +common behavior for unitest.TestCase.setUp/tearDown implemented in this file. + +The subclass should override the attribute mydir in order for the python runtime +to locate the individual test cases when running as part of a large test suite +or when running each test case as a separate python invocation. + +./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 +$ +""" + +from __future__ import print_function +from __future__ import absolute_import + +# System modules +import abc +import collections +from distutils.version import LooseVersion +import gc +import glob +import inspect +import os, sys, traceback +import os.path +import re +import signal +from subprocess import * +import time +import types + +# Third-party modules +import unittest2 +from six import add_metaclass +from six import StringIO as SixStringIO +from six.moves.urllib import parse as urlparse +import six + +# LLDB modules +import lldb +from . import configuration +from . import lldbtest_config +from . import lldbutil +from . import test_categories + +from .result_formatter import EventBuilder + +# dosep.py starts lots and lots of dotest instances +# This option helps you find if two (or more) dotest instances are using the same +# directory at the same time +# Enable it to cause test failures and stderr messages if dotest instances try to run in +# the same directory simultaneously +# it is disabled by default because it litters the test directories with ".dirlock" files +debug_confirm_directory_exclusivity = False + +# See also dotest.parseOptionsAndInitTestdirs(), where the environment variables +# LLDB_COMMAND_TRACE and LLDB_DO_CLEANUP are set from '-t' and '-r dir' options. + +# By default, traceAlways is False. +if "LLDB_COMMAND_TRACE" in os.environ and os.environ["LLDB_COMMAND_TRACE"]=="YES": + traceAlways = True +else: + traceAlways = False + +# By default, doCleanup is True. +if "LLDB_DO_CLEANUP" in os.environ and os.environ["LLDB_DO_CLEANUP"]=="NO": + doCleanup = False +else: + doCleanup = True + + +# +# Some commonly used assert messages. +# + +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 cout = 1" + +BREAKPOINT_HIT_TWICE = "Breakpoint resolved with hit cout = 2" + +BREAKPOINT_HIT_THRICE = "Breakpoint resolved with hit cout = 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_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_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' returns successfully" message generator.''' + return "Command '%s' returns successfully" % str + +def COMPLETION_MSG(str_before, str_after): + '''A generic message generator for the completion mechanism.''' + return "'%s' successfully completes to '%s'" % (str_before, str_after) + +def EXP_MSG(str, exe): + '''A generic "'%s' returns expected result" message generator if exe. + Otherwise, it generates "'%s' matches expected result" message.''' + return "'%s' %s expected result" % (str, 'returns' if exe else 'matches') + +def SETTING_MSG(setting): + '''A generic "Value of setting '%s' is correct" message generator.''' + return "Value of setting '%s' is correct" % setting + +def EnvArray(): + """Returns an env variable array from the os.environ map object.""" + return list(map(lambda k,v: k+"="+v, list(os.environ.keys()), list(os.environ.values()))) + +def line_number(filename, string_to_match): + """Helper function to return the line number of the first matched string.""" + with open(filename, 'r') as f: + for i, line in enumerate(f): + if line.find(string_to_match) != -1: + # Found our match. + return i+1 + raise Exception("Unable to find '%s' within file %s" % (string_to_match, filename)) + +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.""" + 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 recording(SixStringIO): + """ + 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 SixStringIO instance; record the session obj and trace flag.""" + SixStringIO.__init__(self) + # The test might not have undergone the 'setUp(self)' phase yet, so that + # the attribute 'session' might not even exist yet. + 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 SixStringIO 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 SixStringIO object, too. + """ + if self.trace: + print(self.getvalue(), file=sys.stderr) + if self.session: + print(self.getvalue(), file=self.session) + self.close() + +@add_metaclass(abc.ABCMeta) +class _BaseProcess(object): + + @abc.abstractproperty + def pid(self): + """Returns process PID if has been launched already.""" + + @abc.abstractmethod + def launch(self, executable, args): + """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): + self._proc = Popen([executable] + args, + stdout = open(os.devnull) if not self._trace_on else None, + stdin = PIPE) + + def terminate(self): + if self._proc.poll() == None: + # Terminate _proc like it does the pexpect + 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() != None: + return + except ValueError: + pass # Windows says SIGINT is not a valid signal to send + self._proc.terminate() + time.sleep(self._delayafterterminate) + if self._proc.poll() != None: + return + self._proc.kill() + time.sleep(self._delayafterterminate) + + def poll(self): + return self._proc.poll() + +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): + if self._install_remote: + src_path = executable + dst_path = lldbutil.append_to_process_working_directory(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()) + + # Redirect stdout and stderr to /dev/null + launch_info.AddSuppressFileAction(1, False, True) + launch_info.AddSuppressFileAction(2, False, 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) + +# From 2.7's subprocess.check_output() convenience function. +# Return a tuple (stdoutdata, stderrdata). +def system(commands, **kwargs): + r"""Run an os command with arguments and return its output as a byte string. + + If the exit code was non-zero it raises a CalledProcessError. The + CalledProcessError object will have the return code in the returncode + attribute and output in the output attribute. + + The arguments are the same as for the Popen constructor. Example: + + >>> check_output(["ls", "-l", "/dev/null"]) + 'crw-rw-rw- 1 root root 1, 3 Oct 18 2007 /dev/null\n' + + The stdout argument is not allowed as it is used internally. + To capture standard error in the result, use stderr=STDOUT. + + >>> check_output(["/bin/sh", "-c", + ... "ls -l non_existent_file ; exit 0"], + ... stderr=STDOUT) + 'ls: non_existent_file: No such file or directory\n' + """ + + # Assign the sender object to variable 'test' and remove it from kwargs. + test = kwargs.pop('sender', None) + + # [['make', 'clean', 'foo'], ['make', 'foo']] -> ['make clean foo', 'make foo'] + commandList = [' '.join(x) for x in commands] + output = "" + error = "" + for shellCommand in commandList: + if 'stdout' in kwargs: + raise ValueError('stdout argument not allowed, it will be overridden.') + if 'shell' in kwargs and kwargs['shell']==False: + raise ValueError('shell=False not allowed') + process = Popen(shellCommand, stdout=PIPE, stderr=PIPE, shell=True, universal_newlines=True, **kwargs) + pid = process.pid + this_output, this_error = process.communicate() + retcode = process.poll() + + # Enable trace on failure return while tracking down FreeBSD buildbot issues + trace = traceAlways + if not trace and retcode and sys.platform.startswith("freebsd"): + trace = True + + with recording(test, trace) as sbuf: + print(file=sbuf) + print("os command:", shellCommand, file=sbuf) + print("with pid:", pid, file=sbuf) + print("stdout:", this_output, file=sbuf) + print("stderr:", this_error, file=sbuf) + print("retcode:", retcode, file=sbuf) + print(file=sbuf) + + if retcode: + cmd = kwargs.get("args") + if cmd is None: + cmd = shellCommand + raise CalledProcessError(retcode, cmd) + output = output + this_output + error = error + this_error + return (output, error) + +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(): + if sys.platform.startswith("freebsd"): + return __import__("builder_freebsd") + if sys.platform.startswith("netbsd"): + return __import__("builder_netbsd") + return __import__("builder_" + sys.platform) + +def run_adb_command(cmd, device_id): + device_id_args = [] + if device_id: + device_id_args = ["-s", device_id] + full_cmd = ["adb"] + device_id_args + cmd + p = Popen(full_cmd, stdout=PIPE, stderr=PIPE) + stdout, stderr = p.communicate() + return p.returncode, stdout, stderr + +def append_android_envs(dictionary): + if dictionary is None: + dictionary = {} + dictionary["OS"] = "Android" + if android_device_api() >= 16: + dictionary["PIE"] = 1 + return dictionary + +def target_is_android(): + if not hasattr(target_is_android, 'result'): + triple = lldb.DBG.GetSelectedPlatform().GetTriple() + match = re.match(".*-.*-.*-android", triple) + target_is_android.result = match is not None + return target_is_android.result + +def android_device_api(): + if not hasattr(android_device_api, 'result'): + assert configuration.lldb_platform_url is not None + device_id = None + parsed_url = urlparse.urlparse(configuration.lldb_platform_url) + host_name = parsed_url.netloc.split(":")[0] + if host_name != 'localhost': + device_id = host_name + if device_id.startswith('[') and device_id.endswith(']'): + device_id = device_id[1:-1] + retcode, stdout, stderr = run_adb_command( + ["shell", "getprop", "ro.build.version.sdk"], device_id) + if retcode == 0: + android_device_api.result = int(stdout) + else: + raise LookupError( + ">>> Unable to determine the API level of the Android device.\n" + ">>> stdout:\n%s\n" + ">>> stderr:\n%s\n" % (stdout, stderr)) + return android_device_api.result + +def check_expected_version(comparison, expected, actual): + def fn_leq(x,y): return x <= y + def fn_less(x,y): return x < y + def fn_geq(x,y): return x >= y + def fn_greater(x,y): return x > y + def fn_eq(x,y): return x == y + def fn_neq(x,y): return x != y + + op_lookup = { + "==": fn_eq, + "=": fn_eq, + "!=": fn_neq, + "<>": fn_neq, + ">": fn_greater, + "<": fn_less, + ">=": fn_geq, + "<=": fn_leq + } + expected_str = '.'.join([str(x) for x in expected]) + actual_str = '.'.join([str(x) for x in actual]) + + return op_lookup[comparison](LooseVersion(actual_str), LooseVersion(expected_str)) + +# +# Decorators for categorizing test cases. +# +from functools import wraps + +def add_test_categories(cat): + """Add test categories to a TestCase method""" + cat = test_categories.validate(cat, True) + def impl(func): + if isinstance(func, type) and issubclass(func, unittest2.TestCase): + raise Exception("@add_test_categories can only be used to decorate a test method") + if hasattr(func, "categories"): + cat.extend(func.categories) + func.categories = cat + return func + + return impl + +def benchmarks_test(func): + """Decorate the item as a benchmarks test.""" + if isinstance(func, type) and issubclass(func, unittest2.TestCase): + raise Exception("@benchmarks_test can only be used to decorate a test method") + @wraps(func) + def wrapper(self, *args, **kwargs): + self.skipTest("benchmarks test") + return func(self, *args, **kwargs) + + # Mark this function as such to separate them from the regular tests. + wrapper.__benchmarks_test__ = True + return wrapper + +def no_debug_info_test(func): + """Decorate the item as a test what don't use any debug info. If this annotation is specified + then the test runner won't generate a separate test for each debug info format. """ + if isinstance(func, type) and issubclass(func, unittest2.TestCase): + raise Exception("@no_debug_info_test can only be used to decorate a test method") + @wraps(func) + def wrapper(self, *args, **kwargs): + return func(self, *args, **kwargs) + + # Mark this function as such to separate them from the regular tests. + wrapper.__no_debug_info_test__ = True + return wrapper + +def debugserver_test(func): + """Decorate the item as a debugserver test.""" + if isinstance(func, type) and issubclass(func, unittest2.TestCase): + raise Exception("@debugserver_test can only be used to decorate a test method") + @wraps(func) + def wrapper(self, *args, **kwargs): + if configuration.dont_do_debugserver_test: + self.skipTest("debugserver tests") + return func(self, *args, **kwargs) + + # Mark this function as such to separate them from the regular tests. + wrapper.__debugserver_test__ = True + return wrapper + +def llgs_test(func): + """Decorate the item as a lldb-server test.""" + if isinstance(func, type) and issubclass(func, unittest2.TestCase): + raise Exception("@llgs_test can only be used to decorate a test method") + @wraps(func) + def wrapper(self, *args, **kwargs): + if configuration.dont_do_llgs_test: + self.skipTest("llgs tests") + return func(self, *args, **kwargs) + + # Mark this function as such to separate them from the regular tests. + wrapper.__llgs_test__ = True + return wrapper + +def not_remote_testsuite_ready(func): + """Decorate the item as a test which is not ready yet for remote testsuite.""" + if isinstance(func, type) and issubclass(func, unittest2.TestCase): + raise Exception("@not_remote_testsuite_ready can only be used to decorate a test method") + @wraps(func) + def wrapper(self, *args, **kwargs): + if lldb.remote_platform: + self.skipTest("not ready for remote testsuite") + return func(self, *args, **kwargs) + + # Mark this function as such to separate them from the regular tests. + wrapper.__not_ready_for_remote_testsuite_test__ = True + return wrapper + +def expectedFailure(expected_fn, bugnumber=None): + def expectedFailure_impl(func): + @wraps(func) + def wrapper(*args, **kwargs): + from unittest2 import case + self = args[0] + if expected_fn(self): + if configuration.results_formatter_object is not None: + # Mark this test as expected to fail. + configuration.results_formatter_object.handle_event( + EventBuilder.event_for_mark_test_expected_failure(self)) + xfail_func = unittest2.expectedFailure(func) + xfail_func(*args, **kwargs) + else: + func(*args, **kwargs) + return wrapper + # if bugnumber is not-callable(incluing None), that means decorator function is called with optional arguments + # return decorator in this case, so it will be used to decorating original method + if six.callable(bugnumber): + return expectedFailure_impl(bugnumber) + else: + return expectedFailure_impl + +# You can also pass not_in(list) to reverse the sense of the test for the arguments that +# are simple lists, namely oslist, compiler, and debug_info. + +def not_in(iterable): + return lambda x : x not in iterable + +def check_list_or_lambda(list_or_lambda, value): + if six.callable(list_or_lambda): + return list_or_lambda(value) + elif isinstance(list_or_lambda, list): + for item in list_or_lambda: + if value in item: + return True + return False + elif isinstance(list_or_lambda, str): + return value is None or value in list_or_lambda + else: + return list_or_lambda is None or value is None or list_or_lambda == value + +# provide a function to xfail on defined oslist, compiler version, and archs +# if none is specified for any argument, that argument won't be checked and thus means for all +# for example, +# @expectedFailureAll, xfail for all platform/compiler/arch, +# @expectedFailureAll(compiler='gcc'), xfail for gcc on all platform/architecture +# @expectedFailureAll(bugnumber, ["linux"], "gcc", ['>=', '4.9'], ['i386']), xfail for gcc>=4.9 on linux with i386 +def expectedFailureAll(bugnumber=None, oslist=None, hostoslist=None, compiler=None, compiler_version=None, archs=None, triple=None, debug_info=None, swig_version=None, py_version=None): + def fn(self): + oslist_passes = check_list_or_lambda(oslist, self.getPlatform()) + hostoslist_passes = check_list_or_lambda(hostoslist, getHostPlatform()) + compiler_passes = check_list_or_lambda(self.getCompiler(), compiler) and self.expectedCompilerVersion(compiler_version) + arch_passes = check_list_or_lambda(archs, self.getArchitecture()) + triple_passes = triple is None or re.match(triple, lldb.DBG.GetSelectedPlatform().GetTriple()) + debug_info_passes = check_list_or_lambda(debug_info, self.debug_info) + swig_version_passes = (swig_version is None) or (not hasattr(lldb, 'swig_version')) or (check_expected_version(swig_version[0], swig_version[1], lldb.swig_version)) + py_version_passes = (py_version is None) or check_expected_version(py_version[0], py_version[1], sys.version_info) + + return (oslist_passes and + hostoslist_passes and + compiler_passes and + arch_passes and + triple_passes and + debug_info_passes and + swig_version_passes and + py_version_passes) + return expectedFailure(fn, bugnumber) + +def expectedFailureDwarf(bugnumber=None): + return expectedFailureAll(bugnumber=bugnumber, debug_info="dwarf") + +def expectedFailureDwo(bugnumber=None): + return expectedFailureAll(bugnumber=bugnumber, debug_info="dwo") + +def expectedFailureDsym(bugnumber=None): + return expectedFailureAll(bugnumber=bugnumber, debug_info="dsym") + +def expectedFailureCompiler(compiler, compiler_version=None, bugnumber=None): + if compiler_version is None: + compiler_version=['=', None] + return expectedFailureAll(bugnumber=bugnumber, compiler=compiler, compiler_version=compiler_version) + +# to XFAIL a specific clang versions, try this +# @expectedFailureClang('bugnumber', ['<=', '3.4']) +def expectedFailureClang(bugnumber=None, compiler_version=None): + return expectedFailureCompiler('clang', compiler_version, bugnumber) + +def expectedFailureGcc(bugnumber=None, compiler_version=None): + return expectedFailureCompiler('gcc', compiler_version, bugnumber) + +def expectedFailureIcc(bugnumber=None): + return expectedFailureCompiler('icc', None, bugnumber) + +def expectedFailureArch(arch, bugnumber=None): + def fn(self): + return arch in self.getArchitecture() + return expectedFailure(fn, bugnumber) + +def expectedFailurei386(bugnumber=None): + return expectedFailureArch('i386', bugnumber) + +def expectedFailurex86_64(bugnumber=None): + return expectedFailureArch('x86_64', bugnumber) + +def expectedFailureOS(oslist, bugnumber=None, compilers=None, debug_info=None): + def fn(self): + return (self.getPlatform() in oslist and + self.expectedCompiler(compilers) and + (debug_info is None or self.debug_info in debug_info)) + return expectedFailure(fn, bugnumber) + +def expectedFailureHostOS(oslist, bugnumber=None, compilers=None): + def fn(self): + return (getHostPlatform() in oslist and + self.expectedCompiler(compilers)) + return expectedFailure(fn, bugnumber) + +def expectedFailureDarwin(bugnumber=None, compilers=None, debug_info=None): + # For legacy reasons, we support both "darwin" and "macosx" as OS X triples. + return expectedFailureOS(getDarwinOSTriples(), bugnumber, compilers, debug_info=debug_info) + +def expectedFailureFreeBSD(bugnumber=None, compilers=None, debug_info=None): + return expectedFailureOS(['freebsd'], bugnumber, compilers, debug_info=debug_info) + +def expectedFailureLinux(bugnumber=None, compilers=None, debug_info=None): + return expectedFailureOS(['linux'], bugnumber, compilers, debug_info=debug_info) + +def expectedFailureNetBSD(bugnumber=None, compilers=None, debug_info=None): + return expectedFailureOS(['netbsd'], bugnumber, compilers, debug_info=debug_info) + +def expectedFailureWindows(bugnumber=None, compilers=None, debug_info=None): + return expectedFailureOS(['windows'], bugnumber, compilers, debug_info=debug_info) + +def expectedFailureHostWindows(bugnumber=None, compilers=None): + return expectedFailureHostOS(['windows'], bugnumber, compilers) + +def matchAndroid(api_levels=None, archs=None): + def match(self): + if not target_is_android(): + return False + if archs is not None and self.getArchitecture() not in archs: + return False + if api_levels is not None and android_device_api() not in api_levels: + return False + return True + return match + + +def expectedFailureAndroid(bugnumber=None, api_levels=None, archs=None): + """ Mark a test as xfail for Android. + + Arguments: + bugnumber - The LLVM pr associated with the problem. + api_levels - A sequence of numbers specifying the Android API levels + for which a test is expected to fail. None means all API level. + arch - A sequence of architecture names specifying the architectures + for which a test is expected to fail. None means all architectures. + """ + return expectedFailure(matchAndroid(api_levels, archs), bugnumber) + +# Flakey tests get two chances to run. If they fail the first time round, the result formatter +# makes sure it is run one more time. +def expectedFlakey(expected_fn, bugnumber=None): + def expectedFailure_impl(func): + @wraps(func) + def wrapper(*args, **kwargs): + self = args[0] + if expected_fn(self): + # Send event marking test as explicitly eligible for rerunning. + if configuration.results_formatter_object is not None: + # Mark this test as rerunnable. + configuration.results_formatter_object.handle_event( + EventBuilder.event_for_mark_test_rerun_eligible(self)) + func(*args, **kwargs) + return wrapper + # if bugnumber is not-callable(incluing None), that means decorator function is called with optional arguments + # return decorator in this case, so it will be used to decorating original method + if six.callable(bugnumber): + return expectedFailure_impl(bugnumber) + else: + return expectedFailure_impl + +def expectedFlakeyDwarf(bugnumber=None): + def fn(self): + return self.debug_info == "dwarf" + return expectedFlakey(fn, bugnumber) + +def expectedFlakeyDsym(bugnumber=None): + def fn(self): + return self.debug_info == "dwarf" + return expectedFlakey(fn, bugnumber) + +def expectedFlakeyOS(oslist, bugnumber=None, compilers=None): + def fn(self): + return (self.getPlatform() in oslist and + self.expectedCompiler(compilers)) + return expectedFlakey(fn, bugnumber) + +def expectedFlakeyDarwin(bugnumber=None, compilers=None): + # For legacy reasons, we support both "darwin" and "macosx" as OS X triples. + return expectedFlakeyOS(getDarwinOSTriples(), bugnumber, compilers) + +def expectedFlakeyFreeBSD(bugnumber=None, compilers=None): + return expectedFlakeyOS(['freebsd'], bugnumber, compilers) + +def expectedFlakeyLinux(bugnumber=None, compilers=None): + return expectedFlakeyOS(['linux'], bugnumber, compilers) + +def expectedFlakeyNetBSD(bugnumber=None, compilers=None): + return expectedFlakeyOS(['netbsd'], bugnumber, compilers) + +def expectedFlakeyCompiler(compiler, compiler_version=None, bugnumber=None): + if compiler_version is None: + compiler_version=['=', None] + def fn(self): + return compiler in self.getCompiler() and self.expectedCompilerVersion(compiler_version) + return expectedFlakey(fn, bugnumber) + +# @expectedFlakeyClang('bugnumber', ['<=', '3.4']) +def expectedFlakeyClang(bugnumber=None, compiler_version=None): + return expectedFlakeyCompiler('clang', compiler_version, bugnumber) + +# @expectedFlakeyGcc('bugnumber', ['<=', '3.4']) +def expectedFlakeyGcc(bugnumber=None, compiler_version=None): + return expectedFlakeyCompiler('gcc', compiler_version, bugnumber) + +def expectedFlakeyAndroid(bugnumber=None, api_levels=None, archs=None): + return expectedFlakey(matchAndroid(api_levels, archs), bugnumber) + +def skipIfRemote(func): + """Decorate the item to skip tests if testing remotely.""" + if isinstance(func, type) and issubclass(func, unittest2.TestCase): + raise Exception("@skipIfRemote can only be used to decorate a test method") + @wraps(func) + def wrapper(*args, **kwargs): + from unittest2 import case + if lldb.remote_platform: + self = args[0] + self.skipTest("skip on remote platform") + else: + func(*args, **kwargs) + return wrapper + +def skipUnlessListedRemote(remote_list=None): + def myImpl(func): + if isinstance(func, type) and issubclass(func, unittest2.TestCase): + raise Exception("@skipIfRemote can only be used to decorate a " + "test method") + + @wraps(func) + def wrapper(*args, **kwargs): + if remote_list and lldb.remote_platform: + self = args[0] + triple = self.dbg.GetSelectedPlatform().GetTriple() + for r in remote_list: + if r in triple: + func(*args, **kwargs) + return + self.skipTest("skip on remote platform %s" % str(triple)) + else: + func(*args, **kwargs) + return wrapper + + return myImpl + +def skipIfRemoteDueToDeadlock(func): + """Decorate the item to skip tests if testing remotely due to the test deadlocking.""" + if isinstance(func, type) and issubclass(func, unittest2.TestCase): + raise Exception("@skipIfRemote can only be used to decorate a test method") + @wraps(func) + def wrapper(*args, **kwargs): + from unittest2 import case + if lldb.remote_platform: + self = args[0] + self.skipTest("skip on remote platform (deadlocks)") + else: + func(*args, **kwargs) + return wrapper + +def skipIfNoSBHeaders(func): + """Decorate the item to mark tests that should be skipped when LLDB is built with no SB API headers.""" + if isinstance(func, type) and issubclass(func, unittest2.TestCase): + raise Exception("@skipIfNoSBHeaders can only be used to decorate a test method") + @wraps(func) + def wrapper(*args, **kwargs): + from unittest2 import case + self = args[0] + if sys.platform.startswith("darwin"): + header = os.path.join(os.environ["LLDB_LIB_DIR"], 'LLDB.framework', 'Versions','Current','Headers','LLDB.h') + else: + header = os.path.join(os.environ["LLDB_SRC"], "include", "lldb", "API", "LLDB.h") + platform = sys.platform + if not os.path.exists(header): + self.skipTest("skip because LLDB.h header not found") + else: + func(*args, **kwargs) + return wrapper + +def skipIfiOSSimulator(func): + """Decorate the item to skip tests that should be skipped on the iOS Simulator.""" + return unittest2.skipIf(configuration.lldb_platform_name == 'ios-simulator', 'skip on the iOS Simulator')(func) + +def skipIfFreeBSD(func): + """Decorate the item to skip tests that should be skipped on FreeBSD.""" + return skipIfPlatform(["freebsd"])(func) + +def skipIfNetBSD(func): + """Decorate the item to skip tests that should be skipped on NetBSD.""" + return skipIfPlatform(["netbsd"])(func) + +def getDarwinOSTriples(): + return ['darwin', 'macosx', 'ios'] + +def skipIfDarwin(func): + """Decorate the item to skip tests that should be skipped on Darwin.""" + return skipIfPlatform(getDarwinOSTriples())(func) + +def skipIfLinux(func): + """Decorate the item to skip tests that should be skipped on Linux.""" + return skipIfPlatform(["linux"])(func) + +def skipUnlessHostLinux(func): + """Decorate the item to skip tests that should be skipped on any non Linux host.""" + return skipUnlessHostPlatform(["linux"])(func) + +def skipIfWindows(func): + """Decorate the item to skip tests that should be skipped on Windows.""" + return skipIfPlatform(["windows"])(func) + +def skipIfHostWindows(func): + """Decorate the item to skip tests that should be skipped on Windows.""" + return skipIfHostPlatform(["windows"])(func) + +def skipUnlessWindows(func): + """Decorate the item to skip tests that should be skipped on any non-Windows platform.""" + return skipUnlessPlatform(["windows"])(func) + +def skipUnlessDarwin(func): + """Decorate the item to skip tests that should be skipped on any non Darwin platform.""" + return skipUnlessPlatform(getDarwinOSTriples())(func) + +def skipUnlessGoInstalled(func): + """Decorate the item to skip tests when no Go compiler is available.""" + if isinstance(func, type) and issubclass(func, unittest2.TestCase): + raise Exception("@skipIfGcc can only be used to decorate a test method") + @wraps(func) + def wrapper(*args, **kwargs): + from unittest2 import case + self = args[0] + compiler = self.getGoCompilerVersion() + if not compiler: + self.skipTest("skipping because go compiler not found") + else: + # Ensure the version is the minimum version supported by + # the LLDB go support. + match_version = re.search(r"(\d+\.\d+(\.\d+)?)", compiler) + if not match_version: + # Couldn't determine version. + self.skipTest( + "skipping because go version could not be parsed " + "out of {}".format(compiler)) + else: + from distutils.version import StrictVersion + min_strict_version = StrictVersion("1.4.0") + compiler_strict_version = StrictVersion(match_version.group(1)) + if compiler_strict_version < min_strict_version: + self.skipTest( + "skipping because available go version ({}) does " + "not meet minimum required go version ({})".format( + compiler_strict_version, + min_strict_version)) + func(*args, **kwargs) + return wrapper + +def getPlatform(): + """Returns the target platform which the tests are running on.""" + platform = lldb.DBG.GetSelectedPlatform().GetTriple().split('-')[2] + if platform.startswith('freebsd'): + platform = 'freebsd' + elif platform.startswith('netbsd'): + platform = 'netbsd' + return platform + +def getHostPlatform(): + """Returns the host platform running the test suite.""" + # Attempts to return a platform name matching a target Triple platform. + if sys.platform.startswith('linux'): + return 'linux' + elif sys.platform.startswith('win32'): + return 'windows' + elif sys.platform.startswith('darwin'): + return 'darwin' + elif sys.platform.startswith('freebsd'): + return 'freebsd' + elif sys.platform.startswith('netbsd'): + return 'netbsd' + else: + return sys.platform + +def platformIsDarwin(): + """Returns true if the OS triple for the selected platform is any valid apple OS""" + return getPlatform() in getDarwinOSTriples() + +def skipIfHostIncompatibleWithRemote(func): + """Decorate the item to skip tests if binaries built on this host are incompatible.""" + if isinstance(func, type) and issubclass(func, unittest2.TestCase): + raise Exception("@skipIfHostIncompatibleWithRemote can only be used to decorate a test method") + @wraps(func) + def wrapper(*args, **kwargs): + from unittest2 import case + self = args[0] + host_arch = self.getLldbArchitecture() + host_platform = getHostPlatform() + target_arch = self.getArchitecture() + target_platform = 'darwin' if self.platformIsDarwin() else self.getPlatform() + if not (target_arch == 'x86_64' and host_arch == 'i386') and host_arch != target_arch: + self.skipTest("skipping because target %s is not compatible with host architecture %s" % (target_arch, host_arch)) + elif target_platform != host_platform: + self.skipTest("skipping because target is %s but host is %s" % (target_platform, host_platform)) + else: + func(*args, **kwargs) + return wrapper + +def skipIfHostPlatform(oslist): + """Decorate the item to skip tests if running on one of the listed host platforms.""" + return unittest2.skipIf(getHostPlatform() in oslist, + "skip on %s" % (", ".join(oslist))) + +def skipUnlessHostPlatform(oslist): + """Decorate the item to skip tests unless running on one of the listed host platforms.""" + return unittest2.skipUnless(getHostPlatform() in oslist, + "requires on of %s" % (", ".join(oslist))) + +def skipUnlessArch(archlist): + """Decorate the item to skip tests unless running on one of the listed architectures.""" + def myImpl(func): + if isinstance(func, type) and issubclass(func, unittest2.TestCase): + raise Exception("@skipUnlessArch can only be used to decorate a test method") + + @wraps(func) + def wrapper(*args, **kwargs): + self = args[0] + if self.getArchitecture() not in archlist: + self.skipTest("skipping for architecture %s (requires one of %s)" % + (self.getArchitecture(), ", ".join(archlist))) + else: + func(*args, **kwargs) + return wrapper + + return myImpl + +def skipIfPlatform(oslist): + """Decorate the item to skip tests if running on one of the listed platforms.""" + return unittest2.skipIf(getPlatform() in oslist, + "skip on %s" % (", ".join(oslist))) + +def skipUnlessPlatform(oslist): + """Decorate the item to skip tests unless running on one of the listed platforms.""" + return unittest2.skipUnless(getPlatform() in oslist, + "requires on of %s" % (", ".join(oslist))) + +def skipIfLinuxClang(func): + """Decorate the item to skip tests that should be skipped if building on + Linux with clang. + """ + if isinstance(func, type) and issubclass(func, unittest2.TestCase): + raise Exception("@skipIfLinuxClang can only be used to decorate a test method") + @wraps(func) + def wrapper(*args, **kwargs): + from unittest2 import case + self = args[0] + compiler = self.getCompiler() + platform = self.getPlatform() + if "clang" in compiler and platform == "linux": + self.skipTest("skipping because Clang is used on Linux") + else: + func(*args, **kwargs) + return wrapper + +# provide a function to skip on defined oslist, compiler version, and archs +# if none is specified for any argument, that argument won't be checked and thus means for all +# for example, +# @skipIf, skip for all platform/compiler/arch, +# @skipIf(compiler='gcc'), skip for gcc on all platform/architecture +# @skipIf(bugnumber, ["linux"], "gcc", ['>=', '4.9'], ['i386']), skip for gcc>=4.9 on linux with i386 + +# TODO: refactor current code, to make skipIfxxx functions to call this function +def skipIf(bugnumber=None, oslist=None, compiler=None, compiler_version=None, archs=None, debug_info=None, swig_version=None, py_version=None, remote=None): + def fn(self): + oslist_passes = check_list_or_lambda(oslist, self.getPlatform()) + compiler_passes = check_list_or_lambda(self.getCompiler(), compiler) and self.expectedCompilerVersion(compiler_version) + arch_passes = check_list_or_lambda(archs, self.getArchitecture()) + debug_info_passes = check_list_or_lambda(debug_info, self.debug_info) + swig_version_passes = (swig_version is None) or (not hasattr(lldb, 'swig_version')) or (check_expected_version(swig_version[0], swig_version[1], lldb.swig_version)) + py_version_passes = (py_version is None) or check_expected_version(py_version[0], py_version[1], sys.version_info) + remote_passes = (remote is None) or (remote == (lldb.remote_platform is not None)) + + return (oslist_passes and + compiler_passes and + arch_passes and + debug_info_passes and + swig_version_passes and + py_version_passes and + remote_passes) + + local_vars = locals() + args = [x for x in inspect.getargspec(skipIf).args] + arg_vals = [eval(x, globals(), local_vars) for x in args] + args = [x for x in zip(args, arg_vals) if x[1] is not None] + reasons = ['%s=%s' % (x, str(y)) for (x,y) in args] + return skipTestIfFn(fn, bugnumber, skipReason='skipping because ' + ' && '.join(reasons)) + +def skipIfDebugInfo(bugnumber=None, debug_info=None): + return skipIf(bugnumber=bugnumber, debug_info=debug_info) + +def skipIfDWO(bugnumber=None): + return skipIfDebugInfo(bugnumber, ["dwo"]) + +def skipIfDwarf(bugnumber=None): + return skipIfDebugInfo(bugnumber, ["dwarf"]) + +def skipIfDsym(bugnumber=None): + return skipIfDebugInfo(bugnumber, ["dsym"]) + +def skipTestIfFn(expected_fn, bugnumber=None, skipReason=None): + def skipTestIfFn_impl(func): + @wraps(func) + def wrapper(*args, **kwargs): + from unittest2 import case + self = args[0] + if expected_fn(self): + self.skipTest(skipReason) + else: + func(*args, **kwargs) + return wrapper + if six.callable(bugnumber): + return skipTestIfFn_impl(bugnumber) + else: + return skipTestIfFn_impl + +def skipIfGcc(func): + """Decorate the item to skip tests that should be skipped if building with gcc .""" + if isinstance(func, type) and issubclass(func, unittest2.TestCase): + raise Exception("@skipIfGcc can only be used to decorate a test method") + @wraps(func) + def wrapper(*args, **kwargs): + from unittest2 import case + self = args[0] + compiler = self.getCompiler() + if "gcc" in compiler: + self.skipTest("skipping because gcc is the test compiler") + else: + func(*args, **kwargs) + return wrapper + +def skipIfIcc(func): + """Decorate the item to skip tests that should be skipped if building with icc .""" + if isinstance(func, type) and issubclass(func, unittest2.TestCase): + raise Exception("@skipIfIcc can only be used to decorate a test method") + @wraps(func) + def wrapper(*args, **kwargs): + from unittest2 import case + self = args[0] + compiler = self.getCompiler() + if "icc" in compiler: + self.skipTest("skipping because icc is the test compiler") + else: + func(*args, **kwargs) + return wrapper + +def skipIfi386(func): + """Decorate the item to skip tests that should be skipped if building 32-bit.""" + if isinstance(func, type) and issubclass(func, unittest2.TestCase): + raise Exception("@skipIfi386 can only be used to decorate a test method") + @wraps(func) + def wrapper(*args, **kwargs): + from unittest2 import case + self = args[0] + if "i386" == self.getArchitecture(): + self.skipTest("skipping because i386 is not a supported architecture") + else: + func(*args, **kwargs) + return wrapper + +def skipIfTargetAndroid(api_levels=None, archs=None): + """Decorator to skip tests when the target is Android. + + Arguments: + api_levels - The API levels for which the test should be skipped. If + it is None, then the test will be skipped for all API levels. + arch - A sequence of architecture names specifying the architectures + for which a test is skipped. None means all architectures. + """ + def myImpl(func): + if isinstance(func, type) and issubclass(func, unittest2.TestCase): + raise Exception("@skipIfTargetAndroid can only be used to " + "decorate a test method") + @wraps(func) + def wrapper(*args, **kwargs): + from unittest2 import case + self = args[0] + if matchAndroid(api_levels, archs)(self): + self.skipTest("skiped on Android target with API %d and architecture %s" % + (android_device_api(), self.getArchitecture())) + func(*args, **kwargs) + return wrapper + return myImpl + +def skipUnlessCompilerRt(func): + """Decorate the item to skip tests if testing remotely.""" + if isinstance(func, type) and issubclass(func, unittest2.TestCase): + raise Exception("@skipUnless can only be used to decorate a test method") + @wraps(func) + def wrapper(*args, **kwargs): + from unittest2 import case + import os.path + compilerRtPath = os.path.join(os.path.dirname(__file__), "..", "..", "..", "..", "llvm","projects","compiler-rt") + print(compilerRtPath) + if not os.path.exists(compilerRtPath): + self = args[0] + self.skipTest("skip if compiler-rt not found") + else: + func(*args, **kwargs) + return wrapper + +class _PlatformContext(object): + """Value object class which contains platform-specific options.""" + + def __init__(self, shlib_environment_var, shlib_prefix, shlib_extension): + self.shlib_environment_var = shlib_environment_var + self.shlib_prefix = shlib_prefix + self.shlib_extension = shlib_extension + + +class Base(unittest2.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. + + """ + + # The concrete subclass should override this attribute. + mydir = None + + # Keep track of the old current working directory. + oldcwd = None + + @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__)''' + test_dir = os.path.dirname(test_file) + return test_dir[len(os.environ["LLDB_TEST"])+1:] + + def TraceOn(self): + """Returns True if we are in trace mode (tracing detailed test execution).""" + return traceAlways + + @classmethod + def setUpClass(cls): + """ + Python unittest framework class setup fixture. + Do current directory manipulation. + """ + # Fail fast if 'mydir' attribute is not overridden. + if not cls.mydir or len(cls.mydir) == 0: + raise Exception("Subclasses must override the 'mydir' attribute.") + + # Save old working directory. + cls.oldcwd = os.getcwd() + + # Change current working directory if ${LLDB_TEST} is defined. + # See also dotest.py which sets up ${LLDB_TEST}. + if ("LLDB_TEST" in os.environ): + full_dir = os.path.join(os.environ["LLDB_TEST"], cls.mydir) + if traceAlways: + print("Change dir to:", full_dir, file=sys.stderr) + os.chdir(os.path.join(os.environ["LLDB_TEST"], cls.mydir)) + + if debug_confirm_directory_exclusivity: + import lock + cls.dir_lock = lock.Lock(os.path.join(full_dir, ".dirlock")) + try: + cls.dir_lock.try_acquire() + # write the class that owns the lock into the lock file + cls.dir_lock.handle.write(cls.__name__) + except IOError as ioerror: + # nothing else should have this directory lock + # wait here until we get a lock + cls.dir_lock.acquire() + # read the previous owner from the lock file + lock_id = cls.dir_lock.handle.read() + print("LOCK ERROR: {} wants to lock '{}' but it is already locked by '{}'".format(cls.__name__, full_dir, lock_id), file=sys.stderr) + raise ioerror + + # Set platform context. + if platformIsDarwin(): + cls.platformContext = _PlatformContext('DYLD_LIBRARY_PATH', 'lib', 'dylib') + elif getPlatform() in ("freebsd", "linux", "netbsd"): + cls.platformContext = _PlatformContext('LD_LIBRARY_PATH', 'lib', 'so') + else: + cls.platformContext = None + + @classmethod + def tearDownClass(cls): + """ + Python unittest framework class teardown fixture. + Do class-wide cleanup. + """ + + if doCleanup: + # First, let's do the platform-specific cleanup. + module = builder_module() + module.cleanup() + + # Subclass might have specific cleanup function defined. + 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 debug_confirm_directory_exclusivity: + cls.dir_lock.release() + del cls.dir_lock + + # Restore old working directory. + if traceAlways: + print("Restore dir to:", cls.oldcwd, file=sys.stderr) + os.chdir(cls.oldcwd) + + @classmethod + def skipLongRunningTest(cls): + """ + By default, we skip long running test case. + This can be overridden by passing '-l' to the test driver (dotest.py). + """ + if "LLDB_SKIP_LONG_RUNNING_TEST" in os.environ and "NO" == os.environ["LLDB_SKIP_LONG_RUNNING_TEST"]: + return False + else: + return True + + def enableLogChannelsForCurrentTest(self): + if len(lldbtest_config.channels) == 0: + return + + # if debug channels are specified in lldbtest_config.channels, + # create a new set of log files for every test + log_basename = self.getLogBasenameForCurrentTest() + + # confirm that the file is writeable + host_log_path = "{}-host.log".format(log_basename) + open(host_log_path, 'w').close() + + 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": + # communicate gdb-remote categories to debugserver + 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)') + + # Communicate log path name to debugserver & lldb-server + server_log_path = "{}-server.log".format(log_basename) + open(server_log_path, 'w').close() + os.environ["LLDB_DEBUGSERVER_LOG_FILE"] = server_log_path + + # Communicate channels to lldb-server + os.environ["LLDB_SERVER_LOG_CHANNELS"] = ":".join(lldbtest_config.channels) + + if len(lldbtest_config.channels) == 0: + return + + def disableLogChannelsForCurrentTest(self): + # close all log files that we opened + for channel_and_categories in lldbtest_config.channels: + # channel format - <channel-name> [<category0> [<category1> ...]] + 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)') + + def setUp(self): + """Fixture for unittest test case setup. + + It works with the test driver to conditionally skip tests and does other + initializations.""" + #import traceback + #traceback.print_stack() + + if "LIBCXX_PATH" in os.environ: + self.libcxxPath = os.environ["LIBCXX_PATH"] + else: + self.libcxxPath = None + + if "LLDBMI_EXEC" in os.environ: + self.lldbMiExec = os.environ["LLDBMI_EXEC"] + else: + self.lldbMiExec = None + + # If we spawn an lldb process for test (via pexpect), do not load the + # init file unless told otherwise. + if "NO_LLDBINIT" in os.environ and "NO" == os.environ["NO_LLDBINIT"]: + self.lldbOption = "" + else: + self.lldbOption = "--no-lldbinit" + + # Assign the test method name to self.testMethodName. + # + # For an example of the use of this attribute, look at test/types dir. + # There are a bunch of test cases under test/types and we don't want the + # module cacheing subsystem to be confused with executable name "a.out" + # used for all the test cases. + self.testMethodName = self._testMethodName + + # This is for the case of directly spawning 'lldb'/'gdb' and interacting + # with it using pexpect. + self.child = None + self.child_prompt = "(lldb) " + # If the child is interacting with the embedded script interpreter, + # there are two exits required during tear down, first to quit the + # embedded script interpreter and second to quit the lldb command + # interpreter. + self.child_in_script_interpreter = False + + # These are for customized teardown cleanup. + self.dict = None + self.doTearDownCleanup = False + # And in rare cases where there are multiple teardown cleanups. + self.dicts = [] + self.doTearDownCleanups = False + + # List of spawned subproces.Popen objects + self.subprocesses = [] + + # List of forked process PIDs + self.forkedProcessPids = [] + + # Create a string buffer to record the session info, to be dumped into a + # test case specific file if test failure is encountered. + self.log_basename = self.getLogBasenameForCurrentTest() + + session_file = "{}.log".format(self.log_basename) + # Python 3 doesn't support unbuffered I/O in text mode. Open buffered. + self.session = open(session_file, "w") + + # Optimistically set __errored__, __failed__, __expected__ to False + # initially. If the test errored/failed, the session info + # (self.session) is then dumped into a session specific file for + # diagnosis. + self.__cleanup_errored__ = False + self.__errored__ = False + self.__failed__ = False + self.__expected__ = False + # We are also interested in unexpected success. + self.__unexpected__ = False + # And skipped tests. + self.__skipped__ = False + + # See addTearDownHook(self, hook) which allows the client to add a hook + # function to be run during tearDown() time. + self.hooks = [] + + # See HideStdout(self). + self.sys_stdout_hidden = False + + if self.platformContext: + # set environment variable names for finding shared libraries + self.dylibPath = self.platformContext.shlib_environment_var + + # Create the debugger instance if necessary. + try: + self.dbg = lldb.DBG + except AttributeError: + self.dbg = lldb.SBDebugger.Create() + + if not self.dbg: + raise Exception('Invalid debugger instance') + + # Retrieve the associated command interpreter instance. + self.ci = self.dbg.GetCommandInterpreter() + if not self.ci: + raise Exception('Could not get the command interpreter') + + # And the result object. + self.res = lldb.SBCommandReturnObject() + + self.enableLogChannelsForCurrentTest() + + #Initialize debug_info + self.debug_info = None + + 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): + # Ensure any subprocesses are cleaned up + for p in self.subprocesses: + p.terminate() + del p + del self.subprocesses[:] + # Ensure any forked processes are cleaned up + for pid in self.forkedProcessPids: + if os.path.exists("/proc/" + str(pid)): + os.kill(pid, signal.SIGTERM) + + def spawnSubprocess(self, executable, args=[], install_remote=True): + """ Creates a subprocess.Popen object with the specified executable and arguments, + saves it in self.subprocesses, and returns the object. + NOTE: if using this function, ensure you also call: + + self.addTearDownHook(self.cleanupSubprocesses) + + otherwise the test suite will leak processes. + """ + proc = _RemoteProcess(install_remote) if lldb.remote_platform else _LocalProcess(self.TraceOn()) + proc.launch(executable, args) + self.subprocesses.append(proc) + return proc + + def forkSubprocess(self, executable, args=[]): + """ Fork a subprocess with its own group ID. + NOTE: if using this function, ensure you also call: + + self.addTearDownHook(self.cleanupSubprocesses) + + otherwise the test suite will leak processes. + """ + child_pid = os.fork() + if child_pid == 0: + # If more I/O support is required, this can be beefed up. + fd = os.open(os.devnull, os.O_RDWR) + os.dup2(fd, 1) + os.dup2(fd, 2) + # This call causes the child to have its of group ID + os.setpgid(0,0) + os.execvp(executable, [executable] + args) + # Give the child time to get through the execvp() call + time.sleep(0.1) + self.forkedProcessPids.append(child_pid) + return child_pid + + 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) + + # ======================================================================= + # Methods for customized teardown cleanups as well as execution of hooks. + # ======================================================================= + + def setTearDownCleanup(self, dictionary=None): + """Register a cleanup action at tearDown() time with a dictinary""" + self.dict = dictionary + self.doTearDownCleanup = True + + def addTearDownCleanup(self, dictionary): + """Add a cleanup action at tearDown() time with a dictinary""" + 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 six.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): + # This is for the case of directly spawning 'lldb' and interacting with it + # using pexpect. + 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): + # child is already terminated + pass + except OSError as exception: + import errno + if exception.errno != errno.EIO: + # unexpected error + raise + # child is already terminated + pass + finally: + # Give it one final blow to make sure the child is terminated. + self.child.close() + + def tearDown(self): + """Fixture for unittest test case teardown.""" + #import traceback + #traceback.print_stack() + + self.deletePexpectChild() + + # Check and run any hook functions. + for hook in reversed(self.hooks): + with recording(self, traceAlways) as sbuf: + print("Executing tearDown hook:", getsource_if_available(hook), file=sbuf) + import inspect + hook_argc = len(inspect.getargspec(hook).args) + if hook_argc == 0 or getattr(hook,'im_self',None): + hook() + elif hook_argc == 1: + hook(self) + else: + hook() # try the plain call and hope it works + + del self.hooks + + # Perform registered teardown cleanup. + if doCleanup and self.doTearDownCleanup: + self.cleanup(dictionary=self.dict) + + # In rare cases where there are multiple teardown cleanups added. + if doCleanup and self.doTearDownCleanups: + if self.dicts: + for dict in reversed(self.dicts): + self.cleanup(dictionary=dict) + + self.disableLogChannelsForCurrentTest() + + # ========================================================= + # Various callbacks to allow introspection of test progress + # ========================================================= + + def markError(self): + """Callback invoked when an error (unexpected exception) errored.""" + self.__errored__ = True + with recording(self, False) as sbuf: + # False because there's no need to write "ERROR" to the stderr twice. + # Once by the Python unittest framework, and a second time by us. + 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: + # False because there's no need to write "CLEANUP_ERROR" to the stderr twice. + # Once by the Python unittest framework, and a second time by us. + 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: + # False because there's no need to write "FAIL" to the stderr twice. + # Once by the Python unittest framework, and a second time by us. + print("FAIL", file=sbuf) + + def markExpectedFailure(self,err,bugnumber): + """Callback invoked when an expected failure/error occurred.""" + self.__expected__ = True + with recording(self, False) as sbuf: + # False because there's no need to write "expected failure" to the + # stderr twice. + # Once by the Python unittest framework, and a second time by us. + if bugnumber == None: + print("expected failure", file=sbuf) + else: + print("expected failure (problem id:" + str(bugnumber) + ")", file=sbuf) + + def markSkippedTest(self): + """Callback invoked when a test is skipped.""" + self.__skipped__ = True + with recording(self, False) as sbuf: + # False because there's no need to write "skipped test" to the + # stderr twice. + # Once by the Python unittest framework, and a second time by us. + print("skipped test", file=sbuf) + + def markUnexpectedSuccess(self, bugnumber): + """Callback invoked when an unexpected success occurred.""" + self.__unexpected__ = True + with recording(self, False) as sbuf: + # False because there's no need to write "unexpected success" to the + # stderr twice. + # Once by the Python unittest framework, and a second time by us. + if bugnumber == None: + print("unexpected success", file=sbuf) + else: + print("unexpected success (problem id:" + str(bugnumber) + ")", file=sbuf) + + def getRerunArgs(self): + return " -f %s.%s" % (self.__class__.__name__, self._testMethodName) + + def getLogBasenameForCurrentTest(self, prefix=None): + """ + returns a partial path that can be used as the beginning of the name of multiple + log files pertaining to this test + + <session-dir>/<arch>-<compiler>-<test-file>.<test-class>.<test-method> + """ + dname = os.path.join(os.environ["LLDB_TEST"], + os.environ["LLDB_SESSION_DIRNAME"]) + if not os.path.isdir(dname): + os.mkdir(dname) + + compiler = self.getCompiler() + + if compiler[1] == ':': + compiler = compiler[2:] + if os.path.altsep is not None: + compiler = compiler.replace(os.path.altsep, os.path.sep) + + fname = "{}-{}-{}".format(self.id(), self.getArchitecture(), "_".join(compiler.split(os.path.sep))) + if len(fname) > 200: + fname = "{}-{}-{}".format(self.id(), self.getArchitecture(), compiler.split(os.path.sep)[-1]) + + if prefix is not None: + fname = "{}-{}".format(prefix, fname) + + return os.path.join(dname, fname) + + 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. + """ + + # We are here because self.tearDown() detected that this test instance + # either errored or failed. The lldb.test_result singleton contains + # two lists (erros and failures) which get populated by the unittest + # framework. Look over there for stack trace information. + # + # The lists contain 2-tuples of TestCase instances and strings holding + # formatted tracebacks. + # + # See http://docs.python.org/library/unittest.html#unittest.TestResult. + + # output tracebacks into session + 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) + + # put footer (timestamp/rerun instructions) into session + testMethod = getattr(self, self._testMethodName) + if getattr(testMethod, "__benchmarks_test__", False): + benchmarks = True + else: + benchmarks = False + + import datetime + print("Session info generated @", datetime.datetime.now().ctime(), file=self.session) + print("To rerun this test, issue the following command from the 'test' directory:\n", file=self.session) + print("./dotest.py %s -v %s %s" % (self.getRunOptions(), + ('+b' if benchmarks else '-t'), + self.getRerunArgs()), file=self.session) + self.session.close() + del self.session + + # process the log files + log_files_for_this_test = glob.glob(self.log_basename + "*") + + if prefix != 'Success' or lldbtest_config.log_success: + # keep all log files, rename them to include prefix + dst_log_basename = self.getLogBasenameForCurrentTest(prefix) + for src in log_files_for_this_test: + if os.path.isfile(src): + dst = src.replace(self.log_basename, dst_log_basename) + if os.name == "nt" and os.path.isfile(dst): + # On Windows, renaming a -> b will throw an exception if b exists. On non-Windows platforms + # it silently replaces the destination. Ultimately this means that atomic renames are not + # guaranteed to be possible on Windows, but we need this to work anyway, so just remove the + # destination first if it already exists. + os.remove(dst) + + os.rename(src, dst) + else: + # success! (and we don't want log files) delete log files + for log_file in log_files_for_this_test: + try: + os.unlink(log_file) + except: + # We've seen consistent unlink failures on Windows, perhaps because the + # just-created log file is being scanned by anti-virus. Empirically, this + # sleep-and-retry approach allows tests to succeed much more reliably. + # Attempts to figure out exactly what process was still holding a file handle + # have failed because running instrumentation like Process Monitor seems to + # slow things down enough that the problem becomes much less consistent. + time.sleep(0.5) + os.unlink(log_file) + + # ==================================================== + # Config. methods supported through a plugin interface + # (enables reading of the current test configuration) + # ==================================================== + + def getArchitecture(self): + """Returns the architecture in effect the test suite is running with.""" + module = builder_module() + arch = module.getArchitecture() + if arch == 'amd64': + arch = 'x86_64' + return arch + + def getLldbArchitecture(self): + """Returns the architecture of the lldb binary.""" + if not hasattr(self, 'lldbArchitecture'): + + # spawn local process + command = [ + lldbtest_config.lldbExec, + "-o", + "file " + lldbtest_config.lldbExec, + "-o", + "quit" + ] + + output = check_output(command) + str = output.decode("utf-8"); + + for line in str.splitlines(): + m = re.search("Current executable set to '.*' \\((.*)\\)\\.", line) + if m: + self.lldbArchitecture = m.group(1) + break + + return self.lldbArchitecture + + def getCompiler(self): + """Returns the compiler in effect the test suite is running with.""" + module = builder_module() + return module.getCompiler() + + def getCompilerBinary(self): + """Returns the compiler binary the test suite is running with.""" + return self.getCompiler().split()[0] + + def getCompilerVersion(self): + """ Returns a string that represents the compiler version. + Supports: llvm, clang. + """ + from .lldbutil import which + version = 'unknown' + + compiler = self.getCompilerBinary() + version_output = system([[which(compiler), "-v"]])[1] + for line in version_output.split(os.linesep): + m = re.search('version ([0-9\.]+)', line) + if m: + version = m.group(1) + return version + + def getGoCompilerVersion(self): + """ Returns a string that represents the go compiler version, or None if go is not found. + """ + compiler = which("go") + if compiler: + version_output = system([[compiler, "version"]])[0] + for line in version_output.split(os.linesep): + m = re.search('go version (devel|go\\S+)', line) + if m: + return m.group(1) + return None + + def platformIsDarwin(self): + """Returns true if the OS triple for the selected platform is any valid apple OS""" + return platformIsDarwin() + + def getPlatform(self): + """Returns the target platform the test suite is running on.""" + return 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 (compiler_version == None): + return True + operator = str(compiler_version[0]) + version = compiler_version[1] + + if (version == None): + return True + if (operator == '>'): + return self.getCompilerVersion() > version + if (operator == '>=' or operator == '=>'): + return self.getCompilerVersion() >= version + if (operator == '<'): + return self.getCompilerVersion() < version + if (operator == '<=' or operator == '=<'): + return self.getCompilerVersion() <= version + if (operator == '!=' or operator == '!' or operator == 'not'): + return str(version) not in str(self.getCompilerVersion()) + return str(version) in str(self.getCompilerVersion()) + + def expectedCompiler(self, compilers): + """Returns True iff any element of compilers is a sub-string of the current compiler.""" + if (compilers == None): + return True + + for compiler in compilers: + if compiler in self.getCompiler(): + return True + + return False + + def expectedArch(self, archs): + """Returns True iff any element of archs is a sub-string of the current architecture.""" + if (archs == 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() + if arch: + option_str = "-A " + arch + else: + option_str = "" + if comp: + option_str += " -C " + comp + return option_str + + # ================================================== + # Build methods supported through a plugin interface + # ================================================== + + def getstdlibFlag(self): + """ Returns the proper -stdlib flag, or empty if not required.""" + if self.platformIsDarwin() or self.getPlatform() == "freebsd": + stdlibflag = "-stdlib=libc++" + else: # this includes NetBSD + 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 = os.environ["LLDB_LIB_DIR"] + if sys.platform.startswith("darwin"): + dsym = os.path.join(lib_dir, 'LLDB.framework', 'LLDB') + d = {'CXX_SOURCES' : sources, + 'EXE' : exe_name, + 'CFLAGS_EXTRAS' : "%s %s" % (stdflag, stdlibflag), + 'FRAMEWORK_INCLUDES' : "-F%s" % lib_dir, + 'LD_EXTRAS' : "%s -Wl,-rpath,%s" % (dsym, lib_dir), + } + elif sys.platform.rstrip('0123456789') in ('freebsd', 'linux', 'netbsd') or os.environ.get('LLDB_BUILD_TYPE') == 'Makefile': + d = {'CXX_SOURCES' : sources, + 'EXE' : exe_name, + 'CFLAGS_EXTRAS' : "%s %s -I%s" % (stdflag, stdlibflag, os.path.join(os.environ["LLDB_SRC"], "include")), + 'LD_EXTRAS' : "-L%s -llldb" % lib_dir} + elif sys.platform.startswith('win'): + d = {'CXX_SOURCES' : sources, + 'EXE' : exe_name, + 'CFLAGS_EXTRAS' : "%s %s -I%s" % (stdflag, stdlibflag, os.path.join(os.environ["LLDB_SRC"], "include")), + 'LD_EXTRAS' : "-L%s -lliblldb" % os.environ["LLDB_IMPLIB_DIR"]} + if self.TraceOn(): + print("Building LLDB Driver (%s) from sources %s" % (exe_name, sources)) + + self.buildDefault(dictionary=d) + + def buildLibrary(self, sources, lib_name): + """Platform specific way to build a default library. """ + + stdflag = self.getstdFlag() + + lib_dir = os.environ["LLDB_LIB_DIR"] + if self.platformIsDarwin(): + dsym = os.path.join(lib_dir, 'LLDB.framework', 'LLDB') + d = {'DYLIB_CXX_SOURCES' : sources, + 'DYLIB_NAME' : lib_name, + 'CFLAGS_EXTRAS' : "%s -stdlib=libc++" % stdflag, + 'FRAMEWORK_INCLUDES' : "-F%s" % lib_dir, + 'LD_EXTRAS' : "%s -Wl,-rpath,%s -dynamiclib" % (dsym, lib_dir), + } + elif self.getPlatform() in ('freebsd', 'linux', 'netbsd') or os.environ.get('LLDB_BUILD_TYPE') == 'Makefile': + d = {'DYLIB_CXX_SOURCES' : sources, + 'DYLIB_NAME' : lib_name, + 'CFLAGS_EXTRAS' : "%s -I%s -fPIC" % (stdflag, os.path.join(os.environ["LLDB_SRC"], "include")), + 'LD_EXTRAS' : "-shared -L%s -llldb" % lib_dir} + elif self.getPlatform() == 'windows': + d = {'DYLIB_CXX_SOURCES' : sources, + 'DYLIB_NAME' : lib_name, + 'CFLAGS_EXTRAS' : "%s -I%s -fPIC" % (stdflag, os.path.join(os.environ["LLDB_SRC"], "include")), + 'LD_EXTRAS' : "-shared -l%s\liblldb.lib" % self.os.environ["LLDB_IMPLIB_DIR"]} + if self.TraceOn(): + print("Building LLDB Library (%s) from sources %s" % (lib_name, sources)) + + self.buildDefault(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.buildDefault(dictionary=d) + + def buildDefault(self, architecture=None, compiler=None, dictionary=None, clean=True): + """Platform specific way to build the default binaries.""" + module = builder_module() + if target_is_android(): + dictionary = append_android_envs(dictionary) + if not module.buildDefault(self, architecture, compiler, dictionary, clean): + raise Exception("Don't know how to build default binary") + + def buildDsym(self, architecture=None, compiler=None, dictionary=None, clean=True): + """Platform specific way to build binaries with dsym info.""" + module = builder_module() + if not module.buildDsym(self, architecture, compiler, dictionary, clean): + raise Exception("Don't know how to build binary with dsym") + + def buildDwarf(self, architecture=None, compiler=None, dictionary=None, clean=True): + """Platform specific way to build binaries with dwarf maps.""" + module = builder_module() + if target_is_android(): + dictionary = append_android_envs(dictionary) + if not module.buildDwarf(self, architecture, compiler, dictionary, clean): + raise Exception("Don't know how to build binary with dwarf") + + def buildDwo(self, architecture=None, compiler=None, dictionary=None, clean=True): + """Platform specific way to build binaries with dwarf maps.""" + module = builder_module() + if target_is_android(): + dictionary = append_android_envs(dictionary) + if not module.buildDwo(self, architecture, compiler, dictionary, clean): + raise Exception("Don't know how to build binary with dwo") + + def buildGo(self): + """Build the default go binary. + """ + system([[which('go'), 'build -gcflags "-N -l" -o a.out main.go']]) + + def signBinary(self, binary_path): + if sys.platform.startswith("darwin"): + codesign_cmd = "codesign --force --sign lldb_codesign %s" % (binary_path) + call(codesign_cmd, shell=True) + + 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/Release+Asserts/bin/clang", + "llvm-build/Debug+Asserts/x86_64/Debug+Asserts/bin/clang", + "llvm-build/Release/x86_64/Release/bin/clang", + "llvm-build/Debug/x86_64/Debug/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 + + # Tries to find clang at the same folder as the lldb + path = os.path.join(os.path.dirname(lldbtest_config.lldbExec), "clang") + if os.path.exists(path): + return path + + return os.environ["CC"] + + def getBuildFlags(self, use_cpp11=True, use_libcxx=False, use_libstdcxx=False): + """ Returns a dictionary (which can be provided to build* functions above) which + contains OS-specific build flags. + """ + cflags = "" + ldflags = "" + + # On Mac OS X, unless specifically requested to use libstdc++, use libc++ + if not use_libstdcxx and self.platformIsDarwin(): + use_libcxx = True + + if use_libcxx and self.libcxxPath: + cflags += "-stdlib=libc++ " + if self.libcxxPath: + libcxxInclude = os.path.join(self.libcxxPath, "include") + libcxxLib = os.path.join(self.libcxxPath, "lib") + if os.path.isdir(libcxxInclude) and os.path.isdir(libcxxLib): + cflags += "-nostdinc++ -I%s -L%s -Wl,-rpath,%s " % (libcxxInclude, libcxxLib, libcxxLib) + + if use_cpp11: + cflags += "-std=" + if "gcc" in self.getCompiler() and "4.6" in self.getCompilerVersion(): + cflags += "c++0x" + else: + cflags += "c++11" + if self.platformIsDarwin() or self.getPlatform() == "freebsd": + cflags += " -stdlib=libc++" + elif self.getPlatform() == "netbsd": + cflags += " -stdlib=libstdc++" + elif "clang" in self.getCompiler(): + cflags += " -stdlib=libstdc++" + + return {'CFLAGS_EXTRAS' : cflags, + 'LD_EXTRAS' : ldflags, + } + + def cleanup(self, dictionary=None): + """Platform specific way to do cleanup after build.""" + module = builder_module() + if not module.cleanup(self, dictionary): + raise Exception("Don't know how to do cleanup with dictionary: "+dictionary) + + def getLLDBLibraryEnvVal(self): + """ Returns the path that the OS-specific library search environment variable + (self.dylibPath) should be set to in order for a program to find the LLDB + library. If an environment variable named self.dylibPath is already set, + the new path is appended to it and returned. + """ + existing_library_path = os.environ[self.dylibPath] if self.dylibPath in os.environ else None + lib_dir = os.environ["LLDB_LIB_DIR"] + if existing_library_path: + return "%s:%s" % (existing_library_path, lib_dir) + elif sys.platform.startswith("darwin"): + return os.path.join(lib_dir, 'LLDB.framework') + else: + return lib_dir + + def getLibcPlusPlusLibs(self): + if self.getPlatform() in ('freebsd', 'linux', 'netbsd'): + return ['libc++.so.1'] + else: + return ['libc++.1.dylib','libc++abi.dylib'] + +# Metaclass for TestBase to change the list of test metods when a new TestCase is loaded. +# We change the test methods to create a new test method for each test for each debug info we are +# testing. The name of the new test method will be '<original-name>_<debug-info>' and with adding +# the new test method we remove the old method at the same time. +class LLDBTestCaseFactory(type): + def __new__(cls, name, bases, attrs): + newattrs = {} + for attrname, attrvalue in attrs.items(): + if attrname.startswith("test") and not getattr(attrvalue, "__no_debug_info_test__", False): + target_platform = lldb.DBG.GetSelectedPlatform().GetTriple().split('-')[2] + + # If any debug info categories were explicitly tagged, assume that list to be + # authoritative. If none were specified, try with all debug info formats. + all_dbginfo_categories = set(test_categories.debug_info_categories) + categories = set(getattr(attrvalue, "categories", [])) & all_dbginfo_categories + if not categories: + categories = all_dbginfo_categories + + supported_categories = [x for x in categories + if test_categories.is_supported_on_platform(x, target_platform)] + if "dsym" in supported_categories: + @add_test_categories(["dsym"]) + @wraps(attrvalue) + def dsym_test_method(self, attrvalue=attrvalue): + self.debug_info = "dsym" + return attrvalue(self) + dsym_method_name = attrname + "_dsym" + dsym_test_method.__name__ = dsym_method_name + newattrs[dsym_method_name] = dsym_test_method + + if "dwarf" in supported_categories: + @add_test_categories(["dwarf"]) + @wraps(attrvalue) + def dwarf_test_method(self, attrvalue=attrvalue): + self.debug_info = "dwarf" + return attrvalue(self) + dwarf_method_name = attrname + "_dwarf" + dwarf_test_method.__name__ = dwarf_method_name + newattrs[dwarf_method_name] = dwarf_test_method + + if "dwo" in supported_categories: + @add_test_categories(["dwo"]) + @wraps(attrvalue) + def dwo_test_method(self, attrvalue=attrvalue): + self.debug_info = "dwo" + return attrvalue(self) + dwo_method_name = attrname + "_dwo" + dwo_test_method.__name__ = dwo_method_name + newattrs[dwo_method_name] = dwo_test_method + else: + newattrs[attrname] = attrvalue + return super(LLDBTestCaseFactory, cls).__new__(cls, name, bases, newattrs) + +# Setup the metaclass for this class to change the list of the test methods when a new class is loaded +@add_metaclass(LLDBTestCaseFactory) +class TestBase(Base): + """ + 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: + + - Overwrite the mydir class attribute, otherwise your test class won't + run. It specifies the relative directory to the top level 'test' so + the test harness can change to the correct working directory before + running your test. + + - 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 methods buildDefault, buildDsym, and buildDwarf are 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 plugins/darwin.py. + """ + + # Maximum allowed attempts when launching the inferior process. + # Can be overridden by the LLDB_MAX_LAUNCH_COUNT environment variable. + maxLaunchCount = 3; + + # Time to wait before the next launching attempt in second(s). + # Can be overridden by the LLDB_TIME_WAIT_NEXT_LAUNCH environment variable. + timeWaitNextLaunch = 1.0; + + # Returns the list of categories to which this test case belongs + # by default, look for a ".categories" file, and read its contents + # if no such file exists, traverse the hierarchy - we guarantee + # a .categories to exist at the top level directory so we do not end up + # looping endlessly - subclasses are free to define their own categories + # in whatever way makes sense to them + def getCategories(self): + import inspect + import os.path + folder = inspect.getfile(self.__class__) + folder = os.path.dirname(folder) + while folder != '/': + categories_file_name = os.path.join(folder,".categories") + if os.path.exists(categories_file_name): + categories_file = open(categories_file_name,'r') + categories = categories_file.readline() + categories_file.close() + categories = str.replace(categories,'\n','') + categories = str.replace(categories,'\r','') + return categories.split(',') + else: + folder = os.path.dirname(folder) + continue + + def setUp(self): + #import traceback + #traceback.print_stack() + + # Works with the test driver to conditionally skip tests via decorators. + Base.setUp(self) + + 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"]) + + # We want our debugger to be synchronous. + self.dbg.SetAsync(False) + + # Retrieve the associated command interpreter instance. + self.ci = self.dbg.GetCommandInterpreter() + if not self.ci: + raise Exception('Could not get the command interpreter') + + # And the result object. + self.res = lldb.SBCommandReturnObject() + + if lldb.remote_platform and configuration.lldb_platform_working_dir: + remote_test_dir = lldbutil.join_remote_paths( + configuration.lldb_platform_working_dir, + self.getArchitecture(), + str(self.test_number), + self.mydir) + error = lldb.remote_platform.MakeDirectory(remote_test_dir, 448) # 448 = 0o700 + if error.Success(): + lldb.remote_platform.SetWorkingDirectory(remote_test_dir) + + # This function removes all files from the current working directory while leaving + # the directories in place. The cleaup is required to reduce the disk space required + # by the test suit while leaving the directories untached is neccessary because + # sub-directories might belong to an other test + def clean_working_directory(): + # TODO: Make it working on Windows when we need it for remote debugging support + # TODO: Replace the heuristic to remove the files with a logic what collects the + # list of files we have to remove during test runs. + shell_cmd = lldb.SBPlatformShellCommand("rm %s/*" % remote_test_dir) + lldb.remote_platform.Run(shell_cmd) + self.addTearDownHook(clean_working_directory) + else: + print("error: making remote directory '%s': %s" % (remote_test_dir, error)) + + 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 + + working_dir = self.get_process_working_directory() + environment = ['%s=%s' % (shlib_environment_var, working_dir)] + # Add any shared libraries to our target if remote so they get + # uploaded into the working directory on the remote side + for name in shlibs: + # The path can be a full path to a shared library, or a make file name like "Foo" for + # "libFoo.dylib" or "libFoo.so", or "Foo.so" for "Foo.so" or "libFoo.so", or just a + # basename like "libFoo.so". So figure out which one it is and resolve the local copy + # of the shared library accordingly + if os.path.exists(name): + local_shlib_path = name # name is the full path to the local shared library + else: + # Check relative names + local_shlib_path = os.path.join(os.getcwd(), shlib_prefix + name + shlib_extension) + if not os.path.exists(local_shlib_path): + local_shlib_path = os.path.join(os.getcwd(), name + shlib_extension) + if not os.path.exists(local_shlib_path): + local_shlib_path = os.path.join(os.getcwd(), name) + + # Make sure we found the local shared library in the above code + self.assertTrue(os.path.exists(local_shlib_path)) + + # Add the shared library to our target + shlib_module = target.AddModule(local_shlib_path, None, None, None) + if lldb.remote_platform: + # We must set the remote install location if we want the shared library + # to get uploaded to the remote target + remote_shlib_path = lldbutil.append_to_process_working_directory(os.path.basename(local_shlib_path)) + shlib_module.SetRemoteInstallFileSpec(lldb.SBFileSpec(remote_shlib_path, False)) + + return environment + + # utility methods that tests can use to access the current objects + 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: + # Remote tests set the platform working directory up in TestBase.setUp() + return lldb.remote_platform.GetWorkingDirectory() + else: + # local tests change directory into each test subdirectory + return os.getcwd() + + def tearDown(self): + #import traceback + #traceback.print_stack() + + # Ensure all the references to SB objects have gone away so that we can + # be sure that all test-specific resources have been freed before we + # attempt to delete the targets. + gc.collect() + + # Delete the target(s) from the debugger as a general cleanup step. + # This includes terminating the process for each target, if any. + # We'd like to reuse the debugger for our next test without incurring + # the initialization overhead. + targets = [] + for target in self.dbg: + if target: + targets.append(target) + process = target.GetProcess() + if process: + rc = self.invoke(process, "Kill") + self.assertTrue(rc.Success(), PROCESS_KILLED) + for target in targets: + self.dbg.DeleteTarget(target) + + # Do this last, to make sure it's in reverse order from how we setup. + 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): + """ + 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 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. + """ + # Fail fast if 'cmd' is not meaningful. + if not cmd or len(cmd) == 0: + 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): + self.ci.HandleCommand(cmd, self.res, inHistory) + + with recording(self, trace) as sbuf: + print("runCmd:", cmd, file=sbuf) + if not check: + print("check of return status not required", file=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: + # For process launch, wait some time before possible next try. + time.sleep(self.timeWaitNextLaunch) + with recording(self, trace) as sbuf: + print("Command '" + cmd + "' failed!", file=sbuf) + + if check: + self.assertTrue(self.res.Succeeded(), + msg if msg else CMD_MSG(cmd)) + + 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: + # First run the command. If we are expecting error, set check=False. + # Pass the assert message along since it provides more semantic info. + self.runCmd(str, msg=msg, trace = (True if trace else False), check = not error) + + # Then compare the output against expected strings. + output = self.res.GetError() if error else self.res.GetOutput() + + # If error is True, the API client expects the command to fail! + if error: + self.assertFalse(self.res.Succeeded(), + "Command '" + str + "' is expected to fail!") + else: + # No execution required, just compare str against the golden input. + output = str + with recording(self, trace) as sbuf: + print("looking at:", output, file=sbuf) + + # The heading says either "Expecting" or "Not expecting". + heading = "Expecting" if matching else "Not expecting" + + for pattern in patterns: + # Match Objects always have a boolean value of True. + 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, exe)) + + return match_object + + def expect(self, str, msg=None, patterns=None, startstr=None, endstr=None, substrs=None, trace=False, error=False, 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'. + + 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 'str' represents the lldb command to be + sent to the command interpreter. In case the keyword argument 'exe' is + set to False, the 'str' is treated as a string to be matched/not-matched + against the golden input. + """ + trace = (True if traceAlways else trace) + + if exe: + # First run the command. If we are expecting error, set check=False. + # Pass the assert message along since it provides more semantic info. + self.runCmd(str, msg=msg, trace = (True if trace else False), check = not error, inHistory=inHistory) + + # Then compare the output against expected strings. + output = self.res.GetError() if error else self.res.GetOutput() + + # If error is True, the API client expects the command to fail! + if error: + self.assertFalse(self.res.Succeeded(), + "Command '" + str + "' is expected to fail!") + else: + # No execution required, just compare str against the golden input. + if isinstance(str,lldb.SBCommandReturnObject): + output = str.GetOutput() + else: + output = str + with recording(self, trace) as sbuf: + print("looking at:", output, file=sbuf) + + # The heading says either "Expecting" or "Not expecting". + heading = "Expecting" if matching else "Not expecting" + + # Start from the startstr, if specified. + # If there's no startstr, set the initial state appropriately. + matched = output.startswith(startstr) if startstr else (True if matching else False) + + if startstr: + with recording(self, trace) as sbuf: + print("%s start string: %s" % (heading, startstr), file=sbuf) + print("Matched" if matched else "Not matched", file=sbuf) + + # Look for endstr, if specified. + keepgoing = matched if matching else not matched + if endstr: + matched = output.endswith(endstr) + with recording(self, trace) as sbuf: + print("%s end string: %s" % (heading, endstr), file=sbuf) + print("Matched" if matched else "Not matched", file=sbuf) + + # Look for sub strings, if specified. + keepgoing = matched if matching else not matched + if substrs and keepgoing: + for str in substrs: + matched = output.find(str) != -1 + with recording(self, trace) as sbuf: + print("%s sub string: %s" % (heading, str), file=sbuf) + print("Matched" if matched else "Not matched", file=sbuf) + keepgoing = matched if matching else not matched + if not keepgoing: + break + + # Search for regular expression patterns, if specified. + keepgoing = matched if matching else not matched + if patterns and keepgoing: + for pattern in patterns: + # Match Objects always have a boolean value of True. + matched = bool(re.search(pattern, output)) + with recording(self, trace) as sbuf: + print("%s pattern: %s" % (heading, pattern), file=sbuf) + print("Matched" if matched else "Not matched", file=sbuf) + keepgoing = matched if matching else not matched + if not keepgoing: + break + + self.assertTrue(matched if matching else not matched, + msg if msg else EXP_MSG(str, exe)) + + 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 build(self, architecture=None, compiler=None, dictionary=None, clean=True): + """Platform specific way to build the default binaries.""" + module = builder_module() + if target_is_android(): + dictionary = append_android_envs(dictionary) + if self.debug_info is None: + return self.buildDefault(architecture, compiler, dictionary, clean) + elif self.debug_info == "dsym": + return self.buildDsym(architecture, compiler, dictionary, clean) + elif self.debug_info == "dwarf": + return self.buildDwarf(architecture, compiler, dictionary, clean) + elif self.debug_info == "dwo": + return self.buildDwo(architecture, compiler, dictionary, clean) + else: + self.fail("Can't build for debug info: %s" % self.debug_info) + + # ================================================= + # Misc. helper methods for debugging test execution + # ================================================= + + 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' + "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): + os.remove(file) |
