2 LLDB module which provides the abstract base class of lldb test case.
4 The concrete subclass can override lldbtest.TesBase in order to inherit the
5 common behavior for unitest.TestCase.setUp/tearDown implemented in this file.
7 The subclass should override the attribute mydir in order for the python runtime
8 to locate the individual test cases when running as part of a large test suite
9 or when running each test case as a separate python invocation.
11 ./dotest.py provides a test driver which sets up the environment to run the
12 entire of part of the test suite . Example:
14 # Exercises the test suite in the types directory....
15 /Volumes/data/lldb/svn/ToT/test $ ./dotest.py -A x86_64 types
18 Session logs for test failures/errors/unexpected successes will go into directory '2012-05-16-13_35_42'
19 Command invoked: python ./dotest.py -A x86_64 types
22 Configuration: arch=x86_64 compiler=clang
23 ----------------------------------------------------------------------
26 ........................................................................
27 ----------------------------------------------------------------------
28 Ran 72 tests in 135.468s
34 from __future__ import absolute_import
35 from __future__ import print_function
40 from functools import wraps
48 from subprocess import *
56 from six import add_metaclass
57 from six import StringIO as SixStringIO
63 from . import configuration
64 from . import decorators
65 from . import lldbplatformutil
66 from . import lldbtest_config
67 from . import lldbutil
68 from . import test_categories
69 from lldbsuite.support import encoded_file
70 from lldbsuite.support import funcutils
72 # dosep.py starts lots and lots of dotest instances
73 # This option helps you find if two (or more) dotest instances are using the same
74 # directory at the same time
75 # Enable it to cause test failures and stderr messages if dotest instances try to run in
76 # the same directory simultaneously
77 # it is disabled by default because it litters the test directories with
79 debug_confirm_directory_exclusivity = False
81 # See also dotest.parseOptionsAndInitTestdirs(), where the environment variables
82 # LLDB_COMMAND_TRACE and LLDB_DO_CLEANUP are set from '-t' and '-r dir'
85 # By default, traceAlways is False.
86 if "LLDB_COMMAND_TRACE" in os.environ and os.environ[
87 "LLDB_COMMAND_TRACE"] == "YES":
92 # By default, doCleanup is True.
93 if "LLDB_DO_CLEANUP" in os.environ and os.environ["LLDB_DO_CLEANUP"] == "NO":
100 # Some commonly used assert messages.
103 COMMAND_FAILED_AS_EXPECTED = "Command has failed as expected"
105 CURRENT_EXECUTABLE_SET = "Current executable set successfully"
107 PROCESS_IS_VALID = "Process is valid"
109 PROCESS_KILLED = "Process is killed successfully"
111 PROCESS_EXITED = "Process exited successfully"
113 PROCESS_STOPPED = "Process status should be stopped"
115 RUN_SUCCEEDED = "Process is launched successfully"
117 RUN_COMPLETED = "Process exited successfully"
119 BACKTRACE_DISPLAYED_CORRECTLY = "Backtrace displayed correctly"
121 BREAKPOINT_CREATED = "Breakpoint created successfully"
123 BREAKPOINT_STATE_CORRECT = "Breakpoint state is correct"
125 BREAKPOINT_PENDING_CREATED = "Pending breakpoint created successfully"
127 BREAKPOINT_HIT_ONCE = "Breakpoint resolved with hit cout = 1"
129 BREAKPOINT_HIT_TWICE = "Breakpoint resolved with hit cout = 2"
131 BREAKPOINT_HIT_THRICE = "Breakpoint resolved with hit cout = 3"
133 MISSING_EXPECTED_REGISTERS = "At least one expected register is unavailable."
135 OBJECT_PRINTED_CORRECTLY = "Object printed correctly"
137 SOURCE_DISPLAYED_CORRECTLY = "Source code displayed correctly"
139 STEP_OUT_SUCCEEDED = "Thread step-out succeeded"
141 STOPPED_DUE_TO_EXC_BAD_ACCESS = "Process should be stopped due to bad access exception"
143 STOPPED_DUE_TO_ASSERT = "Process should be stopped due to an assertion"
145 STOPPED_DUE_TO_BREAKPOINT = "Process should be stopped due to breakpoint"
147 STOPPED_DUE_TO_BREAKPOINT_WITH_STOP_REASON_AS = "%s, %s" % (
148 STOPPED_DUE_TO_BREAKPOINT, "instead, the actual stop reason is: '%s'")
150 STOPPED_DUE_TO_BREAKPOINT_CONDITION = "Stopped due to breakpoint condition"
152 STOPPED_DUE_TO_BREAKPOINT_IGNORE_COUNT = "Stopped due to breakpoint and ignore count"
154 STOPPED_DUE_TO_SIGNAL = "Process state is stopped due to signal"
156 STOPPED_DUE_TO_STEP_IN = "Process state is stopped due to step in"
158 STOPPED_DUE_TO_WATCHPOINT = "Process should be stopped due to watchpoint"
160 DATA_TYPES_DISPLAYED_CORRECTLY = "Data type(s) displayed correctly"
162 VALID_BREAKPOINT = "Got a valid breakpoint"
164 VALID_BREAKPOINT_LOCATION = "Got a valid breakpoint location"
166 VALID_COMMAND_INTERPRETER = "Got a valid command interpreter"
168 VALID_FILESPEC = "Got a valid filespec"
170 VALID_MODULE = "Got a valid module"
172 VALID_PROCESS = "Got a valid process"
174 VALID_SYMBOL = "Got a valid symbol"
176 VALID_TARGET = "Got a valid target"
178 VALID_PLATFORM = "Got a valid platform"
180 VALID_TYPE = "Got a valid type"
182 VALID_VARIABLE = "Got a valid variable"
184 VARIABLES_DISPLAYED_CORRECTLY = "Variable(s) displayed correctly"
186 WATCHPOINT_CREATED = "Watchpoint created successfully"
190 '''A generic "Command '%s' returns successfully" message generator.'''
191 return "Command '%s' returns successfully" % str
194 def COMPLETION_MSG(str_before, str_after):
195 '''A generic message generator for the completion mechanism.'''
196 return "'%s' successfully completes to '%s'" % (str_before, str_after)
199 def EXP_MSG(str, actual, exe):
200 '''A generic "'%s' returns expected result" message generator if exe.
201 Otherwise, it generates "'%s' matches expected result" message.'''
203 return "'%s' %s expected result, got '%s'" % (
204 str, 'returns' if exe else 'matches', actual.strip())
207 def SETTING_MSG(setting):
208 '''A generic "Value of setting '%s' is correct" message generator.'''
209 return "Value of setting '%s' is correct" % setting
213 """Returns an env variable array from the os.environ map object."""
214 return list(map(lambda k,
216 list(os.environ.keys()),
217 list(os.environ.values())))
220 def line_number(filename, string_to_match):
221 """Helper function to return the line number of the first matched string."""
222 with io.open(filename, mode='r', encoding="utf-8") as f:
223 for i, line in enumerate(f):
224 if line.find(string_to_match) != -1:
228 "Unable to find '%s' within file %s" %
229 (string_to_match, filename))
231 def get_line(filename, line_number):
232 """Return the text of the line at the 1-based line number."""
233 with io.open(filename, mode='r', encoding="utf-8") as f:
234 return f.readlines()[line_number - 1]
237 """Return the pointer size of the host system."""
239 a_pointer = ctypes.c_void_p(0xffff)
240 return 8 * ctypes.sizeof(a_pointer)
244 """Returns true if fpath is an executable."""
245 return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
249 """Returns the full path to a program; None otherwise."""
250 fpath, fname = os.path.split(program)
255 for path in os.environ["PATH"].split(os.pathsep):
256 exe_file = os.path.join(path, program)
262 class recording(SixStringIO):
264 A nice little context manager for recording the debugger interactions into
265 our session object. If trace flag is ON, it also emits the interactions
269 def __init__(self, test, trace):
270 """Create a SixStringIO instance; record the session obj and trace flag."""
271 SixStringIO.__init__(self)
272 # The test might not have undergone the 'setUp(self)' phase yet, so that
273 # the attribute 'session' might not even exist yet.
274 self.session = getattr(test, "session", None) if test else None
279 Context management protocol on entry to the body of the with statement.
280 Just return the SixStringIO object.
284 def __exit__(self, type, value, tb):
286 Context management protocol on exit from the body of the with statement.
287 If trace is ON, it emits the recordings into stderr. Always add the
288 recordings to our session object. And close the SixStringIO object, too.
291 print(self.getvalue(), file=sys.stderr)
293 print(self.getvalue(), file=self.session)
297 @add_metaclass(abc.ABCMeta)
298 class _BaseProcess(object):
300 @abc.abstractproperty
302 """Returns process PID if has been launched already."""
305 def launch(self, executable, args):
306 """Launches new process with given executable and args."""
310 """Terminates previously launched process.."""
313 class _LocalProcess(_BaseProcess):
315 def __init__(self, trace_on):
317 self._trace_on = trace_on
318 self._delayafterterminate = 0.1
322 return self._proc.pid
324 def launch(self, executable, args):
328 os.devnull) if not self._trace_on else None,
332 if self._proc.poll() is None:
333 # Terminate _proc like it does the pexpect
338 'SIGINT'] if sig in dir(signal)]
339 for sig in signals_to_try:
341 self._proc.send_signal(getattr(signal, sig))
342 time.sleep(self._delayafterterminate)
343 if self._proc.poll() is not None:
346 pass # Windows says SIGINT is not a valid signal to send
347 self._proc.terminate()
348 time.sleep(self._delayafterterminate)
349 if self._proc.poll() is not None:
352 time.sleep(self._delayafterterminate)
355 return self._proc.poll()
358 class _RemoteProcess(_BaseProcess):
360 def __init__(self, install_remote):
362 self._install_remote = install_remote
368 def launch(self, executable, args):
369 if self._install_remote:
370 src_path = executable
371 dst_path = lldbutil.append_to_process_working_directory(
372 os.path.basename(executable))
374 dst_file_spec = lldb.SBFileSpec(dst_path, False)
375 err = lldb.remote_platform.Install(
376 lldb.SBFileSpec(src_path, True), dst_file_spec)
379 "remote_platform.Install('%s', '%s') failed: %s" %
380 (src_path, dst_path, err))
382 dst_path = executable
383 dst_file_spec = lldb.SBFileSpec(executable, False)
385 launch_info = lldb.SBLaunchInfo(args)
386 launch_info.SetExecutableFile(dst_file_spec, True)
387 launch_info.SetWorkingDirectory(
388 lldb.remote_platform.GetWorkingDirectory())
390 # Redirect stdout and stderr to /dev/null
391 launch_info.AddSuppressFileAction(1, False, True)
392 launch_info.AddSuppressFileAction(2, False, True)
394 err = lldb.remote_platform.Launch(launch_info)
397 "remote_platform.Launch('%s', '%s') failed: %s" %
398 (dst_path, args, err))
399 self._pid = launch_info.GetProcessID()
402 lldb.remote_platform.Kill(self._pid)
404 # From 2.7's subprocess.check_output() convenience function.
405 # Return a tuple (stdoutdata, stderrdata).
408 def system(commands, **kwargs):
409 r"""Run an os command with arguments and return its output as a byte string.
411 If the exit code was non-zero it raises a CalledProcessError. The
412 CalledProcessError object will have the return code in the returncode
413 attribute and output in the output attribute.
415 The arguments are the same as for the Popen constructor. Example:
417 >>> check_output(["ls", "-l", "/dev/null"])
418 'crw-rw-rw- 1 root root 1, 3 Oct 18 2007 /dev/null\n'
420 The stdout argument is not allowed as it is used internally.
421 To capture standard error in the result, use stderr=STDOUT.
423 >>> check_output(["/bin/sh", "-c",
424 ... "ls -l non_existent_file ; exit 0"],
426 'ls: non_existent_file: No such file or directory\n'
429 # Assign the sender object to variable 'test' and remove it from kwargs.
430 test = kwargs.pop('sender', None)
432 # [['make', 'clean', 'foo'], ['make', 'foo']] -> ['make clean foo', 'make foo']
433 commandList = [' '.join(x) for x in commands]
436 for shellCommand in commandList:
437 if 'stdout' in kwargs:
439 'stdout argument not allowed, it will be overridden.')
440 if 'shell' in kwargs and kwargs['shell'] == False:
441 raise ValueError('shell=False not allowed')
447 universal_newlines=True,
450 this_output, this_error = process.communicate()
451 retcode = process.poll()
453 # Enable trace on failure return while tracking down FreeBSD buildbot
456 if not trace and retcode and sys.platform.startswith("freebsd"):
459 with recording(test, trace) as sbuf:
461 print("os command:", shellCommand, file=sbuf)
462 print("with pid:", pid, file=sbuf)
463 print("stdout:", this_output, file=sbuf)
464 print("stderr:", this_error, file=sbuf)
465 print("retcode:", retcode, file=sbuf)
469 cmd = kwargs.get("args")
472 cpe = CalledProcessError(retcode, cmd)
473 # Ensure caller can access the stdout/stderr.
474 cpe.lldb_extensions = {
475 "stdout_content": this_output,
476 "stderr_content": this_error,
477 "command": shellCommand
480 output = output + this_output
481 error = error + this_error
482 return (output, error)
485 def getsource_if_available(obj):
487 Return the text of the source code for an object if available. Otherwise,
488 a print representation is returned.
492 return inspect.getsource(obj)
497 def builder_module():
498 if sys.platform.startswith("freebsd"):
499 return __import__("builder_freebsd")
500 if sys.platform.startswith("netbsd"):
501 return __import__("builder_netbsd")
502 if sys.platform.startswith("linux"):
503 # sys.platform with Python-3.x returns 'linux', but with
504 # Python-2.x it returns 'linux2'.
505 return __import__("builder_linux")
506 return __import__("builder_" + sys.platform)
509 class Base(unittest2.TestCase):
511 Abstract base for performing lldb (see TestBase) or other generic tests (see
512 BenchBase for one example). lldbtest.Base works with the test driver to
517 # The concrete subclass should override this attribute.
520 # Keep track of the old current working directory.
524 def compute_mydir(test_file):
525 '''Subclasses should call this function to correctly calculate the required "mydir" attribute as follows:
527 mydir = TestBase.compute_mydir(__file__)'''
528 test_dir = os.path.dirname(test_file)
529 return test_dir[len(os.environ["LLDB_TEST"]) + 1:]
532 """Returns True if we are in trace mode (tracing detailed test execution)."""
538 Python unittest framework class setup fixture.
539 Do current directory manipulation.
541 # Fail fast if 'mydir' attribute is not overridden.
542 if not cls.mydir or len(cls.mydir) == 0:
543 raise Exception("Subclasses must override the 'mydir' attribute.")
545 # Save old working directory.
546 cls.oldcwd = os.getcwd()
548 # Change current working directory if ${LLDB_TEST} is defined.
549 # See also dotest.py which sets up ${LLDB_TEST}.
550 if ("LLDB_TEST" in os.environ):
551 full_dir = os.path.join(os.environ["LLDB_TEST"], cls.mydir)
553 print("Change dir to:", full_dir, file=sys.stderr)
554 os.chdir(os.path.join(os.environ["LLDB_TEST"], cls.mydir))
556 if debug_confirm_directory_exclusivity:
558 cls.dir_lock = lock.Lock(os.path.join(full_dir, ".dirlock"))
560 cls.dir_lock.try_acquire()
561 # write the class that owns the lock into the lock file
562 cls.dir_lock.handle.write(cls.__name__)
563 except IOError as ioerror:
564 # nothing else should have this directory lock
565 # wait here until we get a lock
566 cls.dir_lock.acquire()
567 # read the previous owner from the lock file
568 lock_id = cls.dir_lock.handle.read()
570 "LOCK ERROR: {} wants to lock '{}' but it is already locked by '{}'".format(
577 # Set platform context.
578 cls.platformContext = lldbplatformutil.createPlatformContext()
581 def tearDownClass(cls):
583 Python unittest framework class teardown fixture.
584 Do class-wide cleanup.
588 # First, let's do the platform-specific cleanup.
589 module = builder_module()
592 # Subclass might have specific cleanup function defined.
593 if getattr(cls, "classCleanup", None):
596 "Call class-specific cleanup function for class:",
602 exc_type, exc_value, exc_tb = sys.exc_info()
603 traceback.print_exception(exc_type, exc_value, exc_tb)
605 if debug_confirm_directory_exclusivity:
606 cls.dir_lock.release()
609 # Restore old working directory.
611 print("Restore dir to:", cls.oldcwd, file=sys.stderr)
615 def skipLongRunningTest(cls):
617 By default, we skip long running test case.
618 This can be overridden by passing '-l' to the test driver (dotest.py).
620 if "LLDB_SKIP_LONG_RUNNING_TEST" in os.environ and "NO" == os.environ[
621 "LLDB_SKIP_LONG_RUNNING_TEST"]:
626 def enableLogChannelsForCurrentTest(self):
627 if len(lldbtest_config.channels) == 0:
630 # if debug channels are specified in lldbtest_config.channels,
631 # create a new set of log files for every test
632 log_basename = self.getLogBasenameForCurrentTest()
634 # confirm that the file is writeable
635 host_log_path = "{}-host.log".format(log_basename)
636 open(host_log_path, 'w').close()
638 log_enable = "log enable -Tpn -f {} ".format(host_log_path)
639 for channel_with_categories in lldbtest_config.channels:
640 channel_then_categories = channel_with_categories.split(' ', 1)
641 channel = channel_then_categories[0]
642 if len(channel_then_categories) > 1:
643 categories = channel_then_categories[1]
645 categories = "default"
647 if channel == "gdb-remote" and lldb.remote_platform is None:
648 # communicate gdb-remote categories to debugserver
649 os.environ["LLDB_DEBUGSERVER_LOG_FLAGS"] = categories
651 self.ci.HandleCommand(
652 log_enable + channel_with_categories, self.res)
653 if not self.res.Succeeded():
655 'log enable failed (check LLDB_LOG_OPTION env variable)')
657 # Communicate log path name to debugserver & lldb-server
658 # For remote debugging, these variables need to be set when starting the platform
660 if lldb.remote_platform is None:
661 server_log_path = "{}-server.log".format(log_basename)
662 open(server_log_path, 'w').close()
663 os.environ["LLDB_DEBUGSERVER_LOG_FILE"] = server_log_path
665 # Communicate channels to lldb-server
666 os.environ["LLDB_SERVER_LOG_CHANNELS"] = ":".join(
667 lldbtest_config.channels)
669 self.addTearDownHook(self.disableLogChannelsForCurrentTest)
671 def disableLogChannelsForCurrentTest(self):
672 # close all log files that we opened
673 for channel_and_categories in lldbtest_config.channels:
674 # channel format - <channel-name> [<category0> [<category1> ...]]
675 channel = channel_and_categories.split(' ', 1)[0]
676 self.ci.HandleCommand("log disable " + channel, self.res)
677 if not self.res.Succeeded():
679 'log disable failed (check LLDB_LOG_OPTION env variable)')
681 # Retrieve the server log (if any) from the remote system. It is assumed the server log
682 # is writing to the "server.log" file in the current test directory. This can be
683 # achieved by setting LLDB_DEBUGSERVER_LOG_FILE="server.log" when starting remote
684 # platform. If the remote logging is not enabled, then just let the Get() command silently
686 if lldb.remote_platform:
687 lldb.remote_platform.Get(
688 lldb.SBFileSpec("server.log"), lldb.SBFileSpec(
689 self.getLogBasenameForCurrentTest() + "-server.log"))
691 def setPlatformWorkingDir(self):
692 if not lldb.remote_platform or not configuration.lldb_platform_working_dir:
695 components = [str(self.test_number)] + self.mydir.split(os.path.sep)
696 remote_test_dir = configuration.lldb_platform_working_dir
698 remote_test_dir = lldbutil.join_remote_paths(remote_test_dir, c)
699 error = lldb.remote_platform.MakeDirectory(
700 remote_test_dir, 448) # 448 = 0o700
702 raise Exception("making remote directory '%s': %s" % (
703 remote_test_dir, error))
705 lldb.remote_platform.SetWorkingDirectory(remote_test_dir)
707 # This function removes all files from the current working directory while leaving
708 # the directories in place. The cleaup is required to reduce the disk space required
709 # by the test suite while leaving the directories untouched is neccessary because
710 # sub-directories might belong to an other test
711 def clean_working_directory():
712 # TODO: Make it working on Windows when we need it for remote debugging support
713 # TODO: Replace the heuristic to remove the files with a logic what collects the
714 # list of files we have to remove during test runs.
715 shell_cmd = lldb.SBPlatformShellCommand(
716 "rm %s/*" % remote_test_dir)
717 lldb.remote_platform.Run(shell_cmd)
718 self.addTearDownHook(clean_working_directory)
721 """Fixture for unittest test case setup.
723 It works with the test driver to conditionally skip tests and does other
726 # traceback.print_stack()
728 if "LIBCXX_PATH" in os.environ:
729 self.libcxxPath = os.environ["LIBCXX_PATH"]
731 self.libcxxPath = None
733 if "LLDBMI_EXEC" in os.environ:
734 self.lldbMiExec = os.environ["LLDBMI_EXEC"]
736 self.lldbMiExec = None
738 # If we spawn an lldb process for test (via pexpect), do not load the
739 # init file unless told otherwise.
740 if "NO_LLDBINIT" in os.environ and "NO" == os.environ["NO_LLDBINIT"]:
743 self.lldbOption = "--no-lldbinit"
745 # Assign the test method name to self.testMethodName.
747 # For an example of the use of this attribute, look at test/types dir.
748 # There are a bunch of test cases under test/types and we don't want the
749 # module cacheing subsystem to be confused with executable name "a.out"
750 # used for all the test cases.
751 self.testMethodName = self._testMethodName
753 # This is for the case of directly spawning 'lldb'/'gdb' and interacting
754 # with it using pexpect.
756 self.child_prompt = "(lldb) "
757 # If the child is interacting with the embedded script interpreter,
758 # there are two exits required during tear down, first to quit the
759 # embedded script interpreter and second to quit the lldb command
761 self.child_in_script_interpreter = False
763 # These are for customized teardown cleanup.
765 self.doTearDownCleanup = False
766 # And in rare cases where there are multiple teardown cleanups.
768 self.doTearDownCleanups = False
770 # List of spawned subproces.Popen objects
771 self.subprocesses = []
773 # List of forked process PIDs
774 self.forkedProcessPids = []
776 # Create a string buffer to record the session info, to be dumped into a
777 # test case specific file if test failure is encountered.
778 self.log_basename = self.getLogBasenameForCurrentTest()
780 session_file = "{}.log".format(self.log_basename)
781 # Python 3 doesn't support unbuffered I/O in text mode. Open buffered.
782 self.session = encoded_file.open(session_file, "utf-8", mode="w")
784 # Optimistically set __errored__, __failed__, __expected__ to False
785 # initially. If the test errored/failed, the session info
786 # (self.session) is then dumped into a session specific file for
788 self.__cleanup_errored__ = False
789 self.__errored__ = False
790 self.__failed__ = False
791 self.__expected__ = False
792 # We are also interested in unexpected success.
793 self.__unexpected__ = False
795 self.__skipped__ = False
797 # See addTearDownHook(self, hook) which allows the client to add a hook
798 # function to be run during tearDown() time.
801 # See HideStdout(self).
802 self.sys_stdout_hidden = False
804 if self.platformContext:
805 # set environment variable names for finding shared libraries
806 self.dylibPath = self.platformContext.shlib_environment_var
808 # Create the debugger instance if necessary.
811 except AttributeError:
812 self.dbg = lldb.SBDebugger.Create()
815 raise Exception('Invalid debugger instance')
817 # Retrieve the associated command interpreter instance.
818 self.ci = self.dbg.GetCommandInterpreter()
820 raise Exception('Could not get the command interpreter')
822 # And the result object.
823 self.res = lldb.SBCommandReturnObject()
825 self.setPlatformWorkingDir()
826 self.enableLogChannelsForCurrentTest()
828 # Initialize debug_info
829 self.debug_info = None
831 lib_dir = os.environ["LLDB_LIB_DIR"]
833 self.framework_dir = None
834 self.darwinWithFramework = self.platformIsDarwin()
835 if sys.platform.startswith("darwin"):
836 # Handle the framework environment variable if it is set
837 if hasattr(lldbtest_config, 'lldbFrameworkPath'):
838 framework_path = lldbtest_config.lldbFrameworkPath
839 # Framework dir should be the directory containing the framework
840 self.framework_dir = framework_path[:framework_path.rfind('LLDB.framework')]
841 # If a framework dir was not specified assume the Xcode build
842 # directory layout where the framework is in LLDB_LIB_DIR.
844 self.framework_dir = lib_dir
845 self.dsym = os.path.join(self.framework_dir, 'LLDB.framework', 'LLDB')
846 # If the framework binary doesn't exist, assume we didn't actually
847 # build a framework, and fallback to standard *nix behavior by
848 # setting framework_dir and dsym to None.
849 if not os.path.exists(self.dsym):
850 self.framework_dir = None
852 self.darwinWithFramework = False
854 def setAsync(self, value):
855 """ Sets async mode to True/False and ensures it is reset after the testcase completes."""
856 old_async = self.dbg.GetAsync()
857 self.dbg.SetAsync(value)
858 self.addTearDownHook(lambda: self.dbg.SetAsync(old_async))
860 def cleanupSubprocesses(self):
861 # Ensure any subprocesses are cleaned up
862 for p in self.subprocesses:
865 del self.subprocesses[:]
866 # Ensure any forked processes are cleaned up
867 for pid in self.forkedProcessPids:
868 if os.path.exists("/proc/" + str(pid)):
869 os.kill(pid, signal.SIGTERM)
871 def spawnSubprocess(self, executable, args=[], install_remote=True):
872 """ Creates a subprocess.Popen object with the specified executable and arguments,
873 saves it in self.subprocesses, and returns the object.
874 NOTE: if using this function, ensure you also call:
876 self.addTearDownHook(self.cleanupSubprocesses)
878 otherwise the test suite will leak processes.
880 proc = _RemoteProcess(
881 install_remote) if lldb.remote_platform else _LocalProcess(self.TraceOn())
882 proc.launch(executable, args)
883 self.subprocesses.append(proc)
886 def forkSubprocess(self, executable, args=[]):
887 """ Fork a subprocess with its own group ID.
888 NOTE: if using this function, ensure you also call:
890 self.addTearDownHook(self.cleanupSubprocesses)
892 otherwise the test suite will leak processes.
894 child_pid = os.fork()
896 # If more I/O support is required, this can be beefed up.
897 fd = os.open(os.devnull, os.O_RDWR)
900 # This call causes the child to have its of group ID
902 os.execvp(executable, [executable] + args)
903 # Give the child time to get through the execvp() call
905 self.forkedProcessPids.append(child_pid)
908 def HideStdout(self):
909 """Hide output to stdout from the user.
911 During test execution, there might be cases where we don't want to show the
912 standard output to the user. For example,
914 self.runCmd(r'''sc print("\n\n\tHello!\n")''')
916 tests whether command abbreviation for 'script' works or not. There is no
917 need to show the 'Hello' output to the user as long as the 'script' command
918 succeeds and we are not in TraceOn() mode (see the '-t' option).
920 In this case, the test method calls self.HideStdout(self) to redirect the
921 sys.stdout to a null device, and restores the sys.stdout upon teardown.
923 Note that you should only call this method at most once during a test case
924 execution. Any subsequent call has no effect at all."""
925 if self.sys_stdout_hidden:
928 self.sys_stdout_hidden = True
929 old_stdout = sys.stdout
930 sys.stdout = open(os.devnull, 'w')
932 def restore_stdout():
933 sys.stdout = old_stdout
934 self.addTearDownHook(restore_stdout)
936 # =======================================================================
937 # Methods for customized teardown cleanups as well as execution of hooks.
938 # =======================================================================
940 def setTearDownCleanup(self, dictionary=None):
941 """Register a cleanup action at tearDown() time with a dictinary"""
942 self.dict = dictionary
943 self.doTearDownCleanup = True
945 def addTearDownCleanup(self, dictionary):
946 """Add a cleanup action at tearDown() time with a dictinary"""
947 self.dicts.append(dictionary)
948 self.doTearDownCleanups = True
950 def addTearDownHook(self, hook):
952 Add a function to be run during tearDown() time.
954 Hooks are executed in a first come first serve manner.
956 if six.callable(hook):
957 with recording(self, traceAlways) as sbuf:
959 "Adding tearDown hook:",
960 getsource_if_available(hook),
962 self.hooks.append(hook)
966 def deletePexpectChild(self):
967 # This is for the case of directly spawning 'lldb' and interacting with it
969 if self.child and self.child.isalive():
971 with recording(self, traceAlways) as sbuf:
972 print("tearing down the child process....", file=sbuf)
974 if self.child_in_script_interpreter:
975 self.child.sendline('quit()')
976 self.child.expect_exact(self.child_prompt)
978 'settings set interpreter.prompt-on-quit false')
979 self.child.sendline('quit')
980 self.child.expect(pexpect.EOF)
981 except (ValueError, pexpect.ExceptionPexpect):
982 # child is already terminated
984 except OSError as exception:
986 if exception.errno != errno.EIO:
989 # child is already terminated
992 # Give it one final blow to make sure the child is terminated.
996 """Fixture for unittest test case teardown."""
998 # traceback.print_stack()
1000 self.deletePexpectChild()
1002 # Check and run any hook functions.
1003 for hook in reversed(self.hooks):
1004 with recording(self, traceAlways) as sbuf:
1006 "Executing tearDown hook:",
1007 getsource_if_available(hook),
1009 if funcutils.requires_self(hook):
1012 hook() # try the plain call and hope it works
1016 # Perform registered teardown cleanup.
1017 if doCleanup and self.doTearDownCleanup:
1018 self.cleanup(dictionary=self.dict)
1020 # In rare cases where there are multiple teardown cleanups added.
1021 if doCleanup and self.doTearDownCleanups:
1023 for dict in reversed(self.dicts):
1024 self.cleanup(dictionary=dict)
1026 # =========================================================
1027 # Various callbacks to allow introspection of test progress
1028 # =========================================================
1030 def markError(self):
1031 """Callback invoked when an error (unexpected exception) errored."""
1032 self.__errored__ = True
1033 with recording(self, False) as sbuf:
1034 # False because there's no need to write "ERROR" to the stderr twice.
1035 # Once by the Python unittest framework, and a second time by us.
1036 print("ERROR", file=sbuf)
1038 def markCleanupError(self):
1039 """Callback invoked when an error occurs while a test is cleaning up."""
1040 self.__cleanup_errored__ = True
1041 with recording(self, False) as sbuf:
1042 # False because there's no need to write "CLEANUP_ERROR" to the stderr twice.
1043 # Once by the Python unittest framework, and a second time by us.
1044 print("CLEANUP_ERROR", file=sbuf)
1046 def markFailure(self):
1047 """Callback invoked when a failure (test assertion failure) occurred."""
1048 self.__failed__ = True
1049 with recording(self, False) as sbuf:
1050 # False because there's no need to write "FAIL" to the stderr twice.
1051 # Once by the Python unittest framework, and a second time by us.
1052 print("FAIL", file=sbuf)
1054 def markExpectedFailure(self, err, bugnumber):
1055 """Callback invoked when an expected failure/error occurred."""
1056 self.__expected__ = True
1057 with recording(self, False) as sbuf:
1058 # False because there's no need to write "expected failure" to the
1060 # Once by the Python unittest framework, and a second time by us.
1061 if bugnumber is None:
1062 print("expected failure", file=sbuf)
1065 "expected failure (problem id:" + str(bugnumber) + ")",
1068 def markSkippedTest(self):
1069 """Callback invoked when a test is skipped."""
1070 self.__skipped__ = True
1071 with recording(self, False) as sbuf:
1072 # False because there's no need to write "skipped test" to the
1074 # Once by the Python unittest framework, and a second time by us.
1075 print("skipped test", file=sbuf)
1077 def markUnexpectedSuccess(self, bugnumber):
1078 """Callback invoked when an unexpected success occurred."""
1079 self.__unexpected__ = True
1080 with recording(self, False) as sbuf:
1081 # False because there's no need to write "unexpected success" to the
1083 # Once by the Python unittest framework, and a second time by us.
1084 if bugnumber is None:
1085 print("unexpected success", file=sbuf)
1088 "unexpected success (problem id:" + str(bugnumber) + ")",
1091 def getRerunArgs(self):
1092 return " -f %s.%s" % (self.__class__.__name__, self._testMethodName)
1094 def getLogBasenameForCurrentTest(self, prefix=None):
1096 returns a partial path that can be used as the beginning of the name of multiple
1097 log files pertaining to this test
1099 <session-dir>/<arch>-<compiler>-<test-file>.<test-class>.<test-method>
1101 dname = os.path.join(os.environ["LLDB_TEST"],
1102 os.environ["LLDB_SESSION_DIRNAME"])
1103 if not os.path.isdir(dname):
1107 if prefix is not None:
1108 components.append(prefix)
1109 for c in configuration.session_file_format:
1111 components.append(self.__class__.__module__)
1113 components.append(self.__class__.__name__)
1115 compiler = self.getCompiler()
1117 if compiler[1] == ':':
1118 compiler = compiler[2:]
1119 if os.path.altsep is not None:
1120 compiler = compiler.replace(os.path.altsep, os.path.sep)
1121 path_components = [x for x in compiler.split(os.path.sep) if x != ""]
1123 # Add at most 4 path components to avoid generating very long
1125 components.extend(path_components[-4:])
1127 components.append(self.getArchitecture())
1129 components.append(self.testMethodName)
1130 fname = "-".join(components)
1132 return os.path.join(dname, fname)
1134 def dumpSessionInfo(self):
1136 Dump the debugger interactions leading to a test error/failure. This
1137 allows for more convenient postmortem analysis.
1139 See also LLDBTestResult (dotest.py) which is a singlton class derived
1140 from TextTestResult and overwrites addError, addFailure, and
1141 addExpectedFailure methods to allow us to to mark the test instance as
1145 # We are here because self.tearDown() detected that this test instance
1146 # either errored or failed. The lldb.test_result singleton contains
1147 # two lists (erros and failures) which get populated by the unittest
1148 # framework. Look over there for stack trace information.
1150 # The lists contain 2-tuples of TestCase instances and strings holding
1151 # formatted tracebacks.
1153 # See http://docs.python.org/library/unittest.html#unittest.TestResult.
1155 # output tracebacks into session
1157 if self.__errored__:
1158 pairs = configuration.test_result.errors
1160 elif self.__cleanup_errored__:
1161 pairs = configuration.test_result.cleanup_errors
1162 prefix = 'CleanupError'
1163 elif self.__failed__:
1164 pairs = configuration.test_result.failures
1166 elif self.__expected__:
1167 pairs = configuration.test_result.expectedFailures
1168 prefix = 'ExpectedFailure'
1169 elif self.__skipped__:
1170 prefix = 'SkippedTest'
1171 elif self.__unexpected__:
1172 prefix = 'UnexpectedSuccess'
1176 if not self.__unexpected__ and not self.__skipped__:
1177 for test, traceback in pairs:
1179 print(traceback, file=self.session)
1181 # put footer (timestamp/rerun instructions) into session
1182 testMethod = getattr(self, self._testMethodName)
1183 if getattr(testMethod, "__benchmarks_test__", False):
1190 "Session info generated @",
1191 datetime.datetime.now().ctime(),
1194 "To rerun this test, issue the following command from the 'test' directory:\n",
1197 "./dotest.py %s -v %s %s" %
1198 (self.getRunOptions(),
1199 ('+b' if benchmarks else '-t'),
1200 self.getRerunArgs()),
1202 self.session.close()
1205 # process the log files
1206 log_files_for_this_test = glob.glob(self.log_basename + "*")
1208 if prefix != 'Success' or lldbtest_config.log_success:
1209 # keep all log files, rename them to include prefix
1210 dst_log_basename = self.getLogBasenameForCurrentTest(prefix)
1211 for src in log_files_for_this_test:
1212 if os.path.isfile(src):
1213 dst = src.replace(self.log_basename, dst_log_basename)
1214 if os.name == "nt" and os.path.isfile(dst):
1215 # On Windows, renaming a -> b will throw an exception if b exists. On non-Windows platforms
1216 # it silently replaces the destination. Ultimately this means that atomic renames are not
1217 # guaranteed to be possible on Windows, but we need this to work anyway, so just remove the
1218 # destination first if it already exists.
1223 # success! (and we don't want log files) delete log files
1224 for log_file in log_files_for_this_test:
1225 remove_file(log_file)
1227 # ====================================================
1228 # Config. methods supported through a plugin interface
1229 # (enables reading of the current test configuration)
1230 # ====================================================
1233 """Returns true if the architecture is MIPS."""
1234 arch = self.getArchitecture()
1235 if re.match("mips", arch):
1239 def getArchitecture(self):
1240 """Returns the architecture in effect the test suite is running with."""
1241 module = builder_module()
1242 arch = module.getArchitecture()
1247 def getLldbArchitecture(self):
1248 """Returns the architecture of the lldb binary."""
1249 if not hasattr(self, 'lldbArchitecture'):
1251 # spawn local process
1253 lldbtest_config.lldbExec,
1255 "file " + lldbtest_config.lldbExec,
1260 output = check_output(command)
1261 str = output.decode("utf-8")
1263 for line in str.splitlines():
1265 "Current executable set to '.*' \\((.*)\\)\\.", line)
1267 self.lldbArchitecture = m.group(1)
1270 return self.lldbArchitecture
1272 def getCompiler(self):
1273 """Returns the compiler in effect the test suite is running with."""
1274 module = builder_module()
1275 return module.getCompiler()
1277 def getCompilerBinary(self):
1278 """Returns the compiler binary the test suite is running with."""
1279 return self.getCompiler().split()[0]
1281 def getCompilerVersion(self):
1282 """ Returns a string that represents the compiler version.
1283 Supports: llvm, clang.
1287 compiler = self.getCompilerBinary()
1288 version_output = system([[compiler, "-v"]])[1]
1289 for line in version_output.split(os.linesep):
1290 m = re.search('version ([0-9\.]+)', line)
1292 version = m.group(1)
1295 def getGoCompilerVersion(self):
1296 """ Returns a string that represents the go compiler version, or None if go is not found.
1298 compiler = which("go")
1300 version_output = system([[compiler, "version"]])[0]
1301 for line in version_output.split(os.linesep):
1302 m = re.search('go version (devel|go\\S+)', line)
1307 def platformIsDarwin(self):
1308 """Returns true if the OS triple for the selected platform is any valid apple OS"""
1309 return lldbplatformutil.platformIsDarwin()
1311 def hasDarwinFramework(self):
1312 return self.darwinWithFramework
1314 def getPlatform(self):
1315 """Returns the target platform the test suite is running on."""
1316 return lldbplatformutil.getPlatform()
1318 def isIntelCompiler(self):
1319 """ Returns true if using an Intel (ICC) compiler, false otherwise. """
1320 return any([x in self.getCompiler() for x in ["icc", "icpc", "icl"]])
1322 def expectedCompilerVersion(self, compiler_version):
1323 """Returns True iff compiler_version[1] matches the current compiler version.
1324 Use compiler_version[0] to specify the operator used to determine if a match has occurred.
1325 Any operator other than the following defaults to an equality test:
1326 '>', '>=', "=>", '<', '<=', '=<', '!=', "!" or 'not'
1328 if (compiler_version is None):
1330 operator = str(compiler_version[0])
1331 version = compiler_version[1]
1333 if (version is None):
1335 if (operator == '>'):
1336 return self.getCompilerVersion() > version
1337 if (operator == '>=' or operator == '=>'):
1338 return self.getCompilerVersion() >= version
1339 if (operator == '<'):
1340 return self.getCompilerVersion() < version
1341 if (operator == '<=' or operator == '=<'):
1342 return self.getCompilerVersion() <= version
1343 if (operator == '!=' or operator == '!' or operator == 'not'):
1344 return str(version) not in str(self.getCompilerVersion())
1345 return str(version) in str(self.getCompilerVersion())
1347 def expectedCompiler(self, compilers):
1348 """Returns True iff any element of compilers is a sub-string of the current compiler."""
1349 if (compilers is None):
1352 for compiler in compilers:
1353 if compiler in self.getCompiler():
1358 def expectedArch(self, archs):
1359 """Returns True iff any element of archs is a sub-string of the current architecture."""
1364 if arch in self.getArchitecture():
1369 def getRunOptions(self):
1370 """Command line option for -A and -C to run this test again, called from
1371 self.dumpSessionInfo()."""
1372 arch = self.getArchitecture()
1373 comp = self.getCompiler()
1376 option_str = "-A " + arch
1378 option_str += " -C " + comp
1381 # ==================================================
1382 # Build methods supported through a plugin interface
1383 # ==================================================
1385 def getstdlibFlag(self):
1386 """ Returns the proper -stdlib flag, or empty if not required."""
1387 if self.platformIsDarwin() or self.getPlatform() == "freebsd":
1388 stdlibflag = "-stdlib=libc++"
1389 else: # this includes NetBSD
1393 def getstdFlag(self):
1394 """ Returns the proper stdflag. """
1395 if "gcc" in self.getCompiler() and "4.6" in self.getCompilerVersion():
1396 stdflag = "-std=c++0x"
1398 stdflag = "-std=c++11"
1401 def buildDriver(self, sources, exe_name):
1402 """ Platform-specific way to build a program that links with LLDB (via the liblldb.so
1406 stdflag = self.getstdFlag()
1407 stdlibflag = self.getstdlibFlag()
1409 lib_dir = os.environ["LLDB_LIB_DIR"]
1410 if self.hasDarwinFramework():
1411 d = {'CXX_SOURCES': sources,
1413 'CFLAGS_EXTRAS': "%s %s" % (stdflag, stdlibflag),
1414 'FRAMEWORK_INCLUDES': "-F%s" % self.framework_dir,
1415 'LD_EXTRAS': "%s -Wl,-rpath,%s" % (self.dsym, self.framework_dir),
1417 elif sys.platform.rstrip('0123456789') in ('freebsd', 'linux', 'netbsd', 'darwin') or os.environ.get('LLDB_BUILD_TYPE') == 'Makefile':
1419 'CXX_SOURCES': sources,
1421 'CFLAGS_EXTRAS': "%s %s -I%s" % (stdflag,
1424 os.environ["LLDB_SRC"],
1426 'LD_EXTRAS': "-L%s/../lib -llldb -Wl,-rpath,%s/../lib" % (lib_dir, lib_dir)}
1427 elif sys.platform.startswith('win'):
1429 'CXX_SOURCES': sources,
1431 'CFLAGS_EXTRAS': "%s %s -I%s" % (stdflag,
1434 os.environ["LLDB_SRC"],
1436 'LD_EXTRAS': "-L%s -lliblldb" % os.environ["LLDB_IMPLIB_DIR"]}
1439 "Building LLDB Driver (%s) from sources %s" %
1440 (exe_name, sources))
1442 self.buildDefault(dictionary=d)
1444 def buildLibrary(self, sources, lib_name):
1445 """Platform specific way to build a default library. """
1447 stdflag = self.getstdFlag()
1449 lib_dir = os.environ["LLDB_LIB_DIR"]
1450 if self.hasDarwinFramework():
1451 d = {'DYLIB_CXX_SOURCES': sources,
1452 'DYLIB_NAME': lib_name,
1453 'CFLAGS_EXTRAS': "%s -stdlib=libc++" % stdflag,
1454 'FRAMEWORK_INCLUDES': "-F%s" % self.framework_dir,
1455 'LD_EXTRAS': "%s -Wl,-rpath,%s -dynamiclib" % (self.dsym, self.framework_dir),
1457 elif sys.platform.rstrip('0123456789') in ('freebsd', 'linux', 'netbsd', 'darwin') or os.environ.get('LLDB_BUILD_TYPE') == 'Makefile':
1459 'DYLIB_CXX_SOURCES': sources,
1460 'DYLIB_NAME': lib_name,
1461 'CFLAGS_EXTRAS': "%s -I%s -fPIC" % (stdflag,
1463 os.environ["LLDB_SRC"],
1465 'LD_EXTRAS': "-shared -L%s/../lib -llldb -Wl,-rpath,%s/../lib" % (lib_dir, lib_dir)}
1466 elif self.getPlatform() == 'windows':
1468 'DYLIB_CXX_SOURCES': sources,
1469 'DYLIB_NAME': lib_name,
1470 'CFLAGS_EXTRAS': "%s -I%s -fPIC" % (stdflag,
1472 os.environ["LLDB_SRC"],
1474 'LD_EXTRAS': "-shared -l%s\liblldb.lib" % self.os.environ["LLDB_IMPLIB_DIR"]}
1477 "Building LLDB Library (%s) from sources %s" %
1478 (lib_name, sources))
1480 self.buildDefault(dictionary=d)
1482 def buildProgram(self, sources, exe_name):
1483 """ Platform specific way to build an executable from C/C++ sources. """
1484 d = {'CXX_SOURCES': sources,
1486 self.buildDefault(dictionary=d)
1494 """Platform specific way to build the default binaries."""
1495 module = builder_module()
1496 dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
1497 if not module.buildDefault(
1503 raise Exception("Don't know how to build default binary")
1511 """Platform specific way to build binaries with dsym info."""
1512 module = builder_module()
1513 dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
1514 if not module.buildDsym(
1520 raise Exception("Don't know how to build binary with dsym")
1528 """Platform specific way to build binaries with dwarf maps."""
1529 module = builder_module()
1530 dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
1531 if not module.buildDwarf(
1537 raise Exception("Don't know how to build binary with dwarf")
1545 """Platform specific way to build binaries with dwarf maps."""
1546 module = builder_module()
1547 dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
1548 if not module.buildDwo(
1554 raise Exception("Don't know how to build binary with dwo")
1562 """Platform specific way to build binaries with gmodules info."""
1563 module = builder_module()
1564 dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
1565 if not module.buildGModules(
1571 raise Exception("Don't know how to build binary with gmodules")
1574 """Build the default go binary.
1576 system([[which('go'), 'build -gcflags "-N -l" -o a.out main.go']])
1578 def signBinary(self, binary_path):
1579 if sys.platform.startswith("darwin"):
1580 codesign_cmd = "codesign --force --sign \"%s\" %s" % (
1581 lldbtest_config.codesign_identity, binary_path)
1582 call(codesign_cmd, shell=True)
1584 def findBuiltClang(self):
1585 """Tries to find and use Clang from the build directory as the compiler (instead of the system compiler)."""
1587 "llvm-build/Release+Asserts/x86_64/Release+Asserts/bin/clang",
1588 "llvm-build/Debug+Asserts/x86_64/Debug+Asserts/bin/clang",
1589 "llvm-build/Release/x86_64/Release/bin/clang",
1590 "llvm-build/Debug/x86_64/Debug/bin/clang",
1592 lldb_root_path = os.path.join(
1593 os.path.dirname(__file__), "..", "..", "..", "..")
1594 for p in paths_to_try:
1595 path = os.path.join(lldb_root_path, p)
1596 if os.path.exists(path):
1599 # Tries to find clang at the same folder as the lldb
1600 path = os.path.join(os.path.dirname(lldbtest_config.lldbExec), "clang")
1601 if os.path.exists(path):
1604 return os.environ["CC"]
1610 use_libstdcxx=False):
1611 """ Returns a dictionary (which can be provided to build* functions above) which
1612 contains OS-specific build flags.
1617 # On Mac OS X, unless specifically requested to use libstdc++, use
1619 if not use_libstdcxx and self.platformIsDarwin():
1622 if use_libcxx and self.libcxxPath:
1623 cflags += "-stdlib=libc++ "
1625 libcxxInclude = os.path.join(self.libcxxPath, "include")
1626 libcxxLib = os.path.join(self.libcxxPath, "lib")
1627 if os.path.isdir(libcxxInclude) and os.path.isdir(libcxxLib):
1628 cflags += "-nostdinc++ -I%s -L%s -Wl,-rpath,%s " % (
1629 libcxxInclude, libcxxLib, libcxxLib)
1633 if "gcc" in self.getCompiler() and "4.6" in self.getCompilerVersion():
1637 if self.platformIsDarwin() or self.getPlatform() == "freebsd":
1638 cflags += " -stdlib=libc++"
1639 elif self.getPlatform() == "netbsd":
1640 cflags += " -stdlib=libstdc++"
1641 elif "clang" in self.getCompiler():
1642 cflags += " -stdlib=libstdc++"
1644 return {'CFLAGS_EXTRAS': cflags,
1645 'LD_EXTRAS': ldflags,
1648 def cleanup(self, dictionary=None):
1649 """Platform specific way to do cleanup after build."""
1650 module = builder_module()
1651 if not module.cleanup(self, dictionary):
1653 "Don't know how to do cleanup with dictionary: " +
1656 def getLLDBLibraryEnvVal(self):
1657 """ Returns the path that the OS-specific library search environment variable
1658 (self.dylibPath) should be set to in order for a program to find the LLDB
1659 library. If an environment variable named self.dylibPath is already set,
1660 the new path is appended to it and returned.
1662 existing_library_path = os.environ[
1663 self.dylibPath] if self.dylibPath in os.environ else None
1664 lib_dir = os.environ["LLDB_LIB_DIR"]
1665 if existing_library_path:
1666 return "%s:%s" % (existing_library_path, lib_dir)
1667 elif sys.platform.startswith("darwin"):
1668 return os.path.join(lib_dir, 'LLDB.framework')
1672 def getLibcPlusPlusLibs(self):
1673 if self.getPlatform() in ('freebsd', 'linux', 'netbsd'):
1674 return ['libc++.so.1']
1676 return ['libc++.1.dylib', 'libc++abi.dylib']
1678 # Metaclass for TestBase to change the list of test metods when a new TestCase is loaded.
1679 # We change the test methods to create a new test method for each test for each debug info we are
1680 # testing. The name of the new test method will be '<original-name>_<debug-info>' and with adding
1681 # the new test method we remove the old method at the same time. This functionality can be
1682 # supressed by at test case level setting the class attribute NO_DEBUG_INFO_TESTCASE or at test
1683 # level by using the decorator @no_debug_info_test.
1686 class LLDBTestCaseFactory(type):
1688 def __new__(cls, name, bases, attrs):
1689 original_testcase = super(
1690 LLDBTestCaseFactory, cls).__new__(
1691 cls, name, bases, attrs)
1692 if original_testcase.NO_DEBUG_INFO_TESTCASE:
1693 return original_testcase
1696 for attrname, attrvalue in attrs.items():
1697 if attrname.startswith("test") and not getattr(
1698 attrvalue, "__no_debug_info_test__", False):
1699 target_platform = lldb.DBG.GetSelectedPlatform(
1700 ).GetTriple().split('-')[2]
1702 # If any debug info categories were explicitly tagged, assume that list to be
1703 # authoritative. If none were specified, try with all debug
1705 all_dbginfo_categories = set(
1706 test_categories.debug_info_categories)
1711 [])) & all_dbginfo_categories
1713 categories = all_dbginfo_categories
1715 supported_categories = [
1716 x for x in categories if test_categories.is_supported_on_platform(
1717 x, target_platform, configuration.compiler)]
1718 if "dsym" in supported_categories:
1719 @decorators.add_test_categories(["dsym"])
1721 def dsym_test_method(self, attrvalue=attrvalue):
1722 self.debug_info = "dsym"
1723 return attrvalue(self)
1724 dsym_method_name = attrname + "_dsym"
1725 dsym_test_method.__name__ = dsym_method_name
1726 newattrs[dsym_method_name] = dsym_test_method
1728 if "dwarf" in supported_categories:
1729 @decorators.add_test_categories(["dwarf"])
1731 def dwarf_test_method(self, attrvalue=attrvalue):
1732 self.debug_info = "dwarf"
1733 return attrvalue(self)
1734 dwarf_method_name = attrname + "_dwarf"
1735 dwarf_test_method.__name__ = dwarf_method_name
1736 newattrs[dwarf_method_name] = dwarf_test_method
1738 if "dwo" in supported_categories:
1739 @decorators.add_test_categories(["dwo"])
1741 def dwo_test_method(self, attrvalue=attrvalue):
1742 self.debug_info = "dwo"
1743 return attrvalue(self)
1744 dwo_method_name = attrname + "_dwo"
1745 dwo_test_method.__name__ = dwo_method_name
1746 newattrs[dwo_method_name] = dwo_test_method
1748 if "gmodules" in supported_categories:
1749 @decorators.add_test_categories(["gmodules"])
1751 def gmodules_test_method(self, attrvalue=attrvalue):
1752 self.debug_info = "gmodules"
1753 return attrvalue(self)
1754 gmodules_method_name = attrname + "_gmodules"
1755 gmodules_test_method.__name__ = gmodules_method_name
1756 newattrs[gmodules_method_name] = gmodules_test_method
1759 newattrs[attrname] = attrvalue
1761 LLDBTestCaseFactory,
1768 # Setup the metaclass for this class to change the list of the test
1769 # methods when a new class is loaded
1772 @add_metaclass(LLDBTestCaseFactory)
1773 class TestBase(Base):
1775 This abstract base class is meant to be subclassed. It provides default
1776 implementations for setUpClass(), tearDownClass(), setUp(), and tearDown(),
1779 Important things for test class writers:
1781 - Overwrite the mydir class attribute, otherwise your test class won't
1782 run. It specifies the relative directory to the top level 'test' so
1783 the test harness can change to the correct working directory before
1786 - The setUp method sets up things to facilitate subsequent interactions
1787 with the debugger as part of the test. These include:
1788 - populate the test method name
1789 - create/get a debugger set with synchronous mode (self.dbg)
1790 - get the command interpreter from with the debugger (self.ci)
1791 - create a result object for use with the command interpreter
1795 - The tearDown method tries to perform some necessary cleanup on behalf
1796 of the test to return the debugger to a good state for the next test.
1798 - execute any tearDown hooks registered by the test method with
1799 TestBase.addTearDownHook(); examples can be found in
1800 settings/TestSettings.py
1801 - kill the inferior process associated with each target, if any,
1802 and, then delete the target from the debugger's target list
1803 - perform build cleanup before running the next test method in the
1804 same test class; examples of registering for this service can be
1805 found in types/TestIntegerTypes.py with the call:
1806 - self.setTearDownCleanup(dictionary=d)
1808 - Similarly setUpClass and tearDownClass perform classwise setup and
1809 teardown fixtures. The tearDownClass method invokes a default build
1810 cleanup for the entire test class; also, subclasses can implement the
1811 classmethod classCleanup(cls) to perform special class cleanup action.
1813 - The instance methods runCmd and expect are used heavily by existing
1814 test cases to send a command to the command interpreter and to perform
1815 string/pattern matching on the output of such command execution. The
1816 expect method also provides a mode to peform string/pattern matching
1817 without running a command.
1819 - The build methods buildDefault, buildDsym, and buildDwarf are used to
1820 build the binaries used during a particular test scenario. A plugin
1821 should be provided for the sys.platform running the test suite. The
1822 Mac OS X implementation is located in plugins/darwin.py.
1825 # Subclasses can set this to true (if they don't depend on debug info) to avoid running the
1826 # test multiple times with various debug info types.
1827 NO_DEBUG_INFO_TESTCASE = False
1829 # Maximum allowed attempts when launching the inferior process.
1830 # Can be overridden by the LLDB_MAX_LAUNCH_COUNT environment variable.
1833 # Time to wait before the next launching attempt in second(s).
1834 # Can be overridden by the LLDB_TIME_WAIT_NEXT_LAUNCH environment variable.
1835 timeWaitNextLaunch = 1.0
1837 def generateSource(self, source):
1838 template = source + '.template'
1839 temp = os.path.join(os.getcwd(), template)
1840 with open(temp, 'r') as f:
1843 public_api_dir = os.path.join(
1844 os.environ["LLDB_SRC"], "include", "lldb", "API")
1846 # Look under the include/lldb/API directory and add #include statements
1847 # for all the SB API headers.
1848 public_headers = os.listdir(public_api_dir)
1849 # For different platforms, the include statement can vary.
1850 if self.hasDarwinFramework():
1851 include_stmt = "'#include <%s>' % os.path.join('LLDB', header)"
1853 include_stmt = "'#include <%s>' % os.path.join('" + public_api_dir + "', header)"
1854 list = [eval(include_stmt) for header in public_headers if (
1855 header.startswith("SB") and header.endswith(".h"))]
1856 includes = '\n'.join(list)
1857 new_content = content.replace('%include_SB_APIs%', includes)
1858 src = os.path.join(os.getcwd(), source)
1859 with open(src, 'w') as f:
1860 f.write(new_content)
1862 self.addTearDownHook(lambda: os.remove(src))
1866 # traceback.print_stack()
1868 # Works with the test driver to conditionally skip tests via
1872 if "LLDB_MAX_LAUNCH_COUNT" in os.environ:
1873 self.maxLaunchCount = int(os.environ["LLDB_MAX_LAUNCH_COUNT"])
1875 if "LLDB_TIME_WAIT_NEXT_LAUNCH" in os.environ:
1876 self.timeWaitNextLaunch = float(
1877 os.environ["LLDB_TIME_WAIT_NEXT_LAUNCH"])
1879 # We want our debugger to be synchronous.
1880 self.dbg.SetAsync(False)
1882 # Retrieve the associated command interpreter instance.
1883 self.ci = self.dbg.GetCommandInterpreter()
1885 raise Exception('Could not get the command interpreter')
1887 # And the result object.
1888 self.res = lldb.SBCommandReturnObject()
1890 def registerSharedLibrariesWithTarget(self, target, shlibs):
1891 '''If we are remotely running the test suite, register the shared libraries with the target so they get uploaded, otherwise do nothing
1893 Any modules in the target that have their remote install file specification set will
1894 get uploaded to the remote host. This function registers the local copies of the
1895 shared libraries with the target and sets their remote install locations so they will
1896 be uploaded when the target is run.
1898 if not shlibs or not self.platformContext:
1901 shlib_environment_var = self.platformContext.shlib_environment_var
1902 shlib_prefix = self.platformContext.shlib_prefix
1903 shlib_extension = '.' + self.platformContext.shlib_extension
1905 working_dir = self.get_process_working_directory()
1906 environment = ['%s=%s' % (shlib_environment_var, working_dir)]
1907 # Add any shared libraries to our target if remote so they get
1908 # uploaded into the working directory on the remote side
1910 # The path can be a full path to a shared library, or a make file name like "Foo" for
1911 # "libFoo.dylib" or "libFoo.so", or "Foo.so" for "Foo.so" or "libFoo.so", or just a
1912 # basename like "libFoo.so". So figure out which one it is and resolve the local copy
1913 # of the shared library accordingly
1914 if os.path.isfile(name):
1915 local_shlib_path = name # name is the full path to the local shared library
1917 # Check relative names
1918 local_shlib_path = os.path.join(
1919 os.getcwd(), shlib_prefix + name + shlib_extension)
1920 if not os.path.exists(local_shlib_path):
1921 local_shlib_path = os.path.join(
1922 os.getcwd(), name + shlib_extension)
1923 if not os.path.exists(local_shlib_path):
1924 local_shlib_path = os.path.join(os.getcwd(), name)
1926 # Make sure we found the local shared library in the above code
1927 self.assertTrue(os.path.exists(local_shlib_path))
1929 # Add the shared library to our target
1930 shlib_module = target.AddModule(local_shlib_path, None, None, None)
1931 if lldb.remote_platform:
1932 # We must set the remote install location if we want the shared library
1933 # to get uploaded to the remote target
1934 remote_shlib_path = lldbutil.append_to_process_working_directory(
1935 os.path.basename(local_shlib_path))
1936 shlib_module.SetRemoteInstallFileSpec(
1937 lldb.SBFileSpec(remote_shlib_path, False))
1941 # utility methods that tests can use to access the current objects
1944 raise Exception('Invalid debugger instance')
1945 return self.dbg.GetSelectedTarget()
1949 raise Exception('Invalid debugger instance')
1950 return self.dbg.GetSelectedTarget().GetProcess()
1954 raise Exception('Invalid debugger instance')
1955 return self.dbg.GetSelectedTarget().GetProcess().GetSelectedThread()
1959 raise Exception('Invalid debugger instance')
1960 return self.dbg.GetSelectedTarget().GetProcess(
1961 ).GetSelectedThread().GetSelectedFrame()
1963 def get_process_working_directory(self):
1964 '''Get the working directory that should be used when launching processes for local or remote processes.'''
1965 if lldb.remote_platform:
1966 # Remote tests set the platform working directory up in
1968 return lldb.remote_platform.GetWorkingDirectory()
1970 # local tests change directory into each test subdirectory
1975 # traceback.print_stack()
1977 # Ensure all the references to SB objects have gone away so that we can
1978 # be sure that all test-specific resources have been freed before we
1979 # attempt to delete the targets.
1982 # Delete the target(s) from the debugger as a general cleanup step.
1983 # This includes terminating the process for each target, if any.
1984 # We'd like to reuse the debugger for our next test without incurring
1985 # the initialization overhead.
1987 for target in self.dbg:
1989 targets.append(target)
1990 process = target.GetProcess()
1992 rc = self.invoke(process, "Kill")
1993 self.assertTrue(rc.Success(), PROCESS_KILLED)
1994 for target in targets:
1995 self.dbg.DeleteTarget(target)
1997 # Do this last, to make sure it's in reverse order from how we setup.
2000 # This must be the last statement, otherwise teardown hooks or other
2001 # lines might depend on this still being active.
2004 def switch_to_thread_with_stop_reason(self, stop_reason):
2006 Run the 'thread list' command, and select the thread with stop reason as
2007 'stop_reason'. If no such thread exists, no select action is done.
2009 from .lldbutil import stop_reason_to_str
2010 self.runCmd('thread list')
2011 output = self.res.GetOutput()
2012 thread_line_pattern = re.compile(
2013 "^[ *] thread #([0-9]+):.*stop reason = %s" %
2014 stop_reason_to_str(stop_reason))
2015 for line in output.splitlines():
2016 matched = thread_line_pattern.match(line)
2018 self.runCmd('thread select %s' % matched.group(1))
2020 def runCmd(self, cmd, msg=None, check=True, trace=False, inHistory=False):
2022 Ask the command interpreter to handle the command and then check its
2025 # Fail fast if 'cmd' is not meaningful.
2026 if not cmd or len(cmd) == 0:
2027 raise Exception("Bad 'cmd' parameter encountered")
2029 trace = (True if traceAlways else trace)
2031 if cmd.startswith("target create "):
2032 cmd = cmd.replace("target create ", "file ")
2034 running = (cmd.startswith("run") or cmd.startswith("process launch"))
2036 for i in range(self.maxLaunchCount if running else 1):
2037 self.ci.HandleCommand(cmd, self.res, inHistory)
2039 with recording(self, trace) as sbuf:
2040 print("runCmd:", cmd, file=sbuf)
2042 print("check of return status not required", file=sbuf)
2043 if self.res.Succeeded():
2044 print("output:", self.res.GetOutput(), file=sbuf)
2046 print("runCmd failed!", file=sbuf)
2047 print(self.res.GetError(), file=sbuf)
2049 if self.res.Succeeded():
2052 # For process launch, wait some time before possible next try.
2053 time.sleep(self.timeWaitNextLaunch)
2054 with recording(self, trace) as sbuf:
2055 print("Command '" + cmd + "' failed!", file=sbuf)
2058 self.assertTrue(self.res.Succeeded(),
2059 msg if msg else CMD_MSG(cmd))
2070 """run command in str, and match the result against regexp in patterns returning the match object for the first matching pattern
2072 Otherwise, all the arguments have the same meanings as for the expect function"""
2074 trace = (True if traceAlways else trace)
2077 # First run the command. If we are expecting error, set check=False.
2078 # Pass the assert message along since it provides more semantic
2084 True if trace else False),
2087 # Then compare the output against expected strings.
2088 output = self.res.GetError() if error else self.res.GetOutput()
2090 # If error is True, the API client expects the command to fail!
2092 self.assertFalse(self.res.Succeeded(),
2093 "Command '" + str + "' is expected to fail!")
2095 # No execution required, just compare str against the golden input.
2097 with recording(self, trace) as sbuf:
2098 print("looking at:", output, file=sbuf)
2100 # The heading says either "Expecting" or "Not expecting".
2101 heading = "Expecting" if matching else "Not expecting"
2103 for pattern in patterns:
2104 # Match Objects always have a boolean value of True.
2105 match_object = re.search(pattern, output)
2106 matched = bool(match_object)
2107 with recording(self, trace) as sbuf:
2108 print("%s pattern: %s" % (heading, pattern), file=sbuf)
2109 print("Matched" if matched else "Not matched", file=sbuf)
2113 self.assertTrue(matched if matching else not matched,
2114 msg if msg else EXP_MSG(str, output, exe))
2132 Similar to runCmd; with additional expect style output matching ability.
2134 Ask the command interpreter to handle the command and then check its
2135 return status. The 'msg' parameter specifies an informational assert
2136 message. We expect the output from running the command to start with
2137 'startstr', matches the substrings contained in 'substrs', and regexp
2138 matches the patterns contained in 'patterns'.
2140 If the keyword argument error is set to True, it signifies that the API
2141 client is expecting the command to fail. In this case, the error stream
2142 from running the command is retrieved and compared against the golden
2145 If the keyword argument matching is set to False, it signifies that the API
2146 client is expecting the output of the command not to match the golden
2149 Finally, the required argument 'str' represents the lldb command to be
2150 sent to the command interpreter. In case the keyword argument 'exe' is
2151 set to False, the 'str' is treated as a string to be matched/not-matched
2152 against the golden input.
2154 trace = (True if traceAlways else trace)
2157 # First run the command. If we are expecting error, set check=False.
2158 # Pass the assert message along since it provides more semantic
2164 True if trace else False),
2166 inHistory=inHistory)
2168 # Then compare the output against expected strings.
2169 output = self.res.GetError() if error else self.res.GetOutput()
2171 # If error is True, the API client expects the command to fail!
2173 self.assertFalse(self.res.Succeeded(),
2174 "Command '" + str + "' is expected to fail!")
2176 # No execution required, just compare str against the golden input.
2177 if isinstance(str, lldb.SBCommandReturnObject):
2178 output = str.GetOutput()
2181 with recording(self, trace) as sbuf:
2182 print("looking at:", output, file=sbuf)
2186 # The heading says either "Expecting" or "Not expecting".
2187 heading = "Expecting" if matching else "Not expecting"
2189 # Start from the startstr, if specified.
2190 # If there's no startstr, set the initial state appropriately.
2191 matched = output.startswith(startstr) if startstr else (
2192 True if matching else False)
2195 with recording(self, trace) as sbuf:
2196 print("%s start string: %s" % (heading, startstr), file=sbuf)
2197 print("Matched" if matched else "Not matched", file=sbuf)
2199 # Look for endstr, if specified.
2200 keepgoing = matched if matching else not matched
2202 matched = output.endswith(endstr)
2203 with recording(self, trace) as sbuf:
2204 print("%s end string: %s" % (heading, endstr), file=sbuf)
2205 print("Matched" if matched else "Not matched", file=sbuf)
2207 # Look for sub strings, if specified.
2208 keepgoing = matched if matching else not matched
2209 if substrs and keepgoing:
2210 for substr in substrs:
2211 matched = output.find(substr) != -1
2212 with recording(self, trace) as sbuf:
2213 print("%s sub string: %s" % (heading, substr), file=sbuf)
2214 print("Matched" if matched else "Not matched", file=sbuf)
2215 keepgoing = matched if matching else not matched
2219 # Search for regular expression patterns, if specified.
2220 keepgoing = matched if matching else not matched
2221 if patterns and keepgoing:
2222 for pattern in patterns:
2223 # Match Objects always have a boolean value of True.
2224 matched = bool(re.search(pattern, output))
2225 with recording(self, trace) as sbuf:
2226 print("%s pattern: %s" % (heading, pattern), file=sbuf)
2227 print("Matched" if matched else "Not matched", file=sbuf)
2228 keepgoing = matched if matching else not matched
2232 self.assertTrue(matched if matching else not matched,
2233 msg if msg else EXP_MSG(str, output, exe))
2235 def invoke(self, obj, name, trace=False):
2236 """Use reflection to call a method dynamically with no argument."""
2237 trace = (True if traceAlways else trace)
2239 method = getattr(obj, name)
2241 self.assertTrue(inspect.ismethod(method),
2242 name + "is a method name of object: " + str(obj))
2244 with recording(self, trace) as sbuf:
2245 print(str(method) + ":", result, file=sbuf)
2254 """Platform specific way to build the default binaries."""
2255 module = builder_module()
2256 dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
2257 if self.debug_info is None:
2258 return self.buildDefault(architecture, compiler, dictionary, clean)
2259 elif self.debug_info == "dsym":
2260 return self.buildDsym(architecture, compiler, dictionary, clean)
2261 elif self.debug_info == "dwarf":
2262 return self.buildDwarf(architecture, compiler, dictionary, clean)
2263 elif self.debug_info == "dwo":
2264 return self.buildDwo(architecture, compiler, dictionary, clean)
2265 elif self.debug_info == "gmodules":
2266 return self.buildGModules(
2267 architecture, compiler, dictionary, clean)
2269 self.fail("Can't build for debug info: %s" % self.debug_info)
2271 def run_platform_command(self, cmd):
2272 platform = self.dbg.GetSelectedPlatform()
2273 shell_command = lldb.SBPlatformShellCommand(cmd)
2274 err = platform.Run(shell_command)
2275 return (err, shell_command.GetStatus(), shell_command.GetOutput())
2277 # =================================================
2278 # Misc. helper methods for debugging test execution
2279 # =================================================
2281 def DebugSBValue(self, val):
2282 """Debug print a SBValue object, if traceAlways is True."""
2283 from .lldbutil import value_type_to_str
2289 err.write(val.GetName() + ":\n")
2290 err.write('\t' + "TypeName -> " + val.GetTypeName() + '\n')
2291 err.write('\t' + "ByteSize -> " +
2292 str(val.GetByteSize()) + '\n')
2293 err.write('\t' + "NumChildren -> " +
2294 str(val.GetNumChildren()) + '\n')
2295 err.write('\t' + "Value -> " + str(val.GetValue()) + '\n')
2296 err.write('\t' + "ValueAsUnsigned -> " +
2297 str(val.GetValueAsUnsigned()) + '\n')
2302 val.GetValueType()) +
2304 err.write('\t' + "Summary -> " + str(val.GetSummary()) + '\n')
2305 err.write('\t' + "IsPointerType -> " +
2306 str(val.TypeIsPointerType()) + '\n')
2307 err.write('\t' + "Location -> " + val.GetLocation() + '\n')
2309 def DebugSBType(self, type):
2310 """Debug print a SBType object, if traceAlways is True."""
2315 err.write(type.GetName() + ":\n")
2316 err.write('\t' + "ByteSize -> " +
2317 str(type.GetByteSize()) + '\n')
2318 err.write('\t' + "IsPointerType -> " +
2319 str(type.IsPointerType()) + '\n')
2320 err.write('\t' + "IsReferenceType -> " +
2321 str(type.IsReferenceType()) + '\n')
2323 def DebugPExpect(self, child):
2324 """Debug the spwaned pexpect object."""
2331 def RemoveTempFile(cls, file):
2332 if os.path.exists(file):
2335 # On Windows, the first attempt to delete a recently-touched file can fail
2336 # because of a race with antimalware scanners. This function will detect a
2337 # failure and retry.
2340 def remove_file(file, num_retries=1, sleep_duration=0.5):
2341 for i in range(num_retries + 1):
2346 time.sleep(sleep_duration)