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 remote_test_dir = lldbutil.join_remote_paths(
696 configuration.lldb_platform_working_dir,
697 self.getArchitecture(),
698 str(self.test_number),
700 error = lldb.remote_platform.MakeDirectory(
701 remote_test_dir, 448) # 448 = 0o700
703 lldb.remote_platform.SetWorkingDirectory(remote_test_dir)
705 # This function removes all files from the current working directory while leaving
706 # the directories in place. The cleaup is required to reduce the disk space required
707 # by the test suit while leaving the directories untached is neccessary because
708 # sub-directories might belong to an other test
709 def clean_working_directory():
710 # TODO: Make it working on Windows when we need it for remote debugging support
711 # TODO: Replace the heuristic to remove the files with a logic what collects the
712 # list of files we have to remove during test runs.
713 shell_cmd = lldb.SBPlatformShellCommand(
714 "rm %s/*" % remote_test_dir)
715 lldb.remote_platform.Run(shell_cmd)
716 self.addTearDownHook(clean_working_directory)
718 print("error: making remote directory '%s': %s" % (
719 remote_test_dir, error))
722 """Fixture for unittest test case setup.
724 It works with the test driver to conditionally skip tests and does other
727 # traceback.print_stack()
729 if "LIBCXX_PATH" in os.environ:
730 self.libcxxPath = os.environ["LIBCXX_PATH"]
732 self.libcxxPath = None
734 if "LLDBMI_EXEC" in os.environ:
735 self.lldbMiExec = os.environ["LLDBMI_EXEC"]
737 self.lldbMiExec = None
739 # If we spawn an lldb process for test (via pexpect), do not load the
740 # init file unless told otherwise.
741 if "NO_LLDBINIT" in os.environ and "NO" == os.environ["NO_LLDBINIT"]:
744 self.lldbOption = "--no-lldbinit"
746 # Assign the test method name to self.testMethodName.
748 # For an example of the use of this attribute, look at test/types dir.
749 # There are a bunch of test cases under test/types and we don't want the
750 # module cacheing subsystem to be confused with executable name "a.out"
751 # used for all the test cases.
752 self.testMethodName = self._testMethodName
754 # This is for the case of directly spawning 'lldb'/'gdb' and interacting
755 # with it using pexpect.
757 self.child_prompt = "(lldb) "
758 # If the child is interacting with the embedded script interpreter,
759 # there are two exits required during tear down, first to quit the
760 # embedded script interpreter and second to quit the lldb command
762 self.child_in_script_interpreter = False
764 # These are for customized teardown cleanup.
766 self.doTearDownCleanup = False
767 # And in rare cases where there are multiple teardown cleanups.
769 self.doTearDownCleanups = False
771 # List of spawned subproces.Popen objects
772 self.subprocesses = []
774 # List of forked process PIDs
775 self.forkedProcessPids = []
777 # Create a string buffer to record the session info, to be dumped into a
778 # test case specific file if test failure is encountered.
779 self.log_basename = self.getLogBasenameForCurrentTest()
781 session_file = "{}.log".format(self.log_basename)
782 # Python 3 doesn't support unbuffered I/O in text mode. Open buffered.
783 self.session = encoded_file.open(session_file, "utf-8", mode="w")
785 # Optimistically set __errored__, __failed__, __expected__ to False
786 # initially. If the test errored/failed, the session info
787 # (self.session) is then dumped into a session specific file for
789 self.__cleanup_errored__ = False
790 self.__errored__ = False
791 self.__failed__ = False
792 self.__expected__ = False
793 # We are also interested in unexpected success.
794 self.__unexpected__ = False
796 self.__skipped__ = False
798 # See addTearDownHook(self, hook) which allows the client to add a hook
799 # function to be run during tearDown() time.
802 # See HideStdout(self).
803 self.sys_stdout_hidden = False
805 if self.platformContext:
806 # set environment variable names for finding shared libraries
807 self.dylibPath = self.platformContext.shlib_environment_var
809 # Create the debugger instance if necessary.
812 except AttributeError:
813 self.dbg = lldb.SBDebugger.Create()
816 raise Exception('Invalid debugger instance')
818 # Retrieve the associated command interpreter instance.
819 self.ci = self.dbg.GetCommandInterpreter()
821 raise Exception('Could not get the command interpreter')
823 # And the result object.
824 self.res = lldb.SBCommandReturnObject()
826 self.setPlatformWorkingDir()
827 self.enableLogChannelsForCurrentTest()
829 # Initialize debug_info
830 self.debug_info = None
832 lib_dir = os.environ["LLDB_LIB_DIR"]
834 self.framework_dir = None
835 self.darwinWithFramework = self.platformIsDarwin()
836 if sys.platform.startswith("darwin"):
837 # Handle the framework environment variable if it is set
838 if hasattr(lldbtest_config, 'lldbFrameworkPath'):
839 framework_path = lldbtest_config.lldbFrameworkPath
840 # Framework dir should be the directory containing the framework
841 self.framework_dir = framework_path[:framework_path.rfind('LLDB.framework')]
842 # If a framework dir was not specified assume the Xcode build
843 # directory layout where the framework is in LLDB_LIB_DIR.
845 self.framework_dir = lib_dir
846 self.dsym = os.path.join(self.framework_dir, 'LLDB.framework', 'LLDB')
847 # If the framework binary doesn't exist, assume we didn't actually
848 # build a framework, and fallback to standard *nix behavior by
849 # setting framework_dir and dsym to None.
850 if not os.path.exists(self.dsym):
851 self.framework_dir = None
853 self.darwinWithFramework = False
855 def setAsync(self, value):
856 """ Sets async mode to True/False and ensures it is reset after the testcase completes."""
857 old_async = self.dbg.GetAsync()
858 self.dbg.SetAsync(value)
859 self.addTearDownHook(lambda: self.dbg.SetAsync(old_async))
861 def cleanupSubprocesses(self):
862 # Ensure any subprocesses are cleaned up
863 for p in self.subprocesses:
866 del self.subprocesses[:]
867 # Ensure any forked processes are cleaned up
868 for pid in self.forkedProcessPids:
869 if os.path.exists("/proc/" + str(pid)):
870 os.kill(pid, signal.SIGTERM)
872 def spawnSubprocess(self, executable, args=[], install_remote=True):
873 """ Creates a subprocess.Popen object with the specified executable and arguments,
874 saves it in self.subprocesses, and returns the object.
875 NOTE: if using this function, ensure you also call:
877 self.addTearDownHook(self.cleanupSubprocesses)
879 otherwise the test suite will leak processes.
881 proc = _RemoteProcess(
882 install_remote) if lldb.remote_platform else _LocalProcess(self.TraceOn())
883 proc.launch(executable, args)
884 self.subprocesses.append(proc)
887 def forkSubprocess(self, executable, args=[]):
888 """ Fork a subprocess with its own group ID.
889 NOTE: if using this function, ensure you also call:
891 self.addTearDownHook(self.cleanupSubprocesses)
893 otherwise the test suite will leak processes.
895 child_pid = os.fork()
897 # If more I/O support is required, this can be beefed up.
898 fd = os.open(os.devnull, os.O_RDWR)
901 # This call causes the child to have its of group ID
903 os.execvp(executable, [executable] + args)
904 # Give the child time to get through the execvp() call
906 self.forkedProcessPids.append(child_pid)
909 def HideStdout(self):
910 """Hide output to stdout from the user.
912 During test execution, there might be cases where we don't want to show the
913 standard output to the user. For example,
915 self.runCmd(r'''sc print("\n\n\tHello!\n")''')
917 tests whether command abbreviation for 'script' works or not. There is no
918 need to show the 'Hello' output to the user as long as the 'script' command
919 succeeds and we are not in TraceOn() mode (see the '-t' option).
921 In this case, the test method calls self.HideStdout(self) to redirect the
922 sys.stdout to a null device, and restores the sys.stdout upon teardown.
924 Note that you should only call this method at most once during a test case
925 execution. Any subsequent call has no effect at all."""
926 if self.sys_stdout_hidden:
929 self.sys_stdout_hidden = True
930 old_stdout = sys.stdout
931 sys.stdout = open(os.devnull, 'w')
933 def restore_stdout():
934 sys.stdout = old_stdout
935 self.addTearDownHook(restore_stdout)
937 # =======================================================================
938 # Methods for customized teardown cleanups as well as execution of hooks.
939 # =======================================================================
941 def setTearDownCleanup(self, dictionary=None):
942 """Register a cleanup action at tearDown() time with a dictinary"""
943 self.dict = dictionary
944 self.doTearDownCleanup = True
946 def addTearDownCleanup(self, dictionary):
947 """Add a cleanup action at tearDown() time with a dictinary"""
948 self.dicts.append(dictionary)
949 self.doTearDownCleanups = True
951 def addTearDownHook(self, hook):
953 Add a function to be run during tearDown() time.
955 Hooks are executed in a first come first serve manner.
957 if six.callable(hook):
958 with recording(self, traceAlways) as sbuf:
960 "Adding tearDown hook:",
961 getsource_if_available(hook),
963 self.hooks.append(hook)
967 def deletePexpectChild(self):
968 # This is for the case of directly spawning 'lldb' and interacting with it
970 if self.child and self.child.isalive():
972 with recording(self, traceAlways) as sbuf:
973 print("tearing down the child process....", file=sbuf)
975 if self.child_in_script_interpreter:
976 self.child.sendline('quit()')
977 self.child.expect_exact(self.child_prompt)
979 'settings set interpreter.prompt-on-quit false')
980 self.child.sendline('quit')
981 self.child.expect(pexpect.EOF)
982 except (ValueError, pexpect.ExceptionPexpect):
983 # child is already terminated
985 except OSError as exception:
987 if exception.errno != errno.EIO:
990 # child is already terminated
993 # Give it one final blow to make sure the child is terminated.
997 """Fixture for unittest test case teardown."""
999 # traceback.print_stack()
1001 self.deletePexpectChild()
1003 # Check and run any hook functions.
1004 for hook in reversed(self.hooks):
1005 with recording(self, traceAlways) as sbuf:
1007 "Executing tearDown hook:",
1008 getsource_if_available(hook),
1010 if funcutils.requires_self(hook):
1013 hook() # try the plain call and hope it works
1017 # Perform registered teardown cleanup.
1018 if doCleanup and self.doTearDownCleanup:
1019 self.cleanup(dictionary=self.dict)
1021 # In rare cases where there are multiple teardown cleanups added.
1022 if doCleanup and self.doTearDownCleanups:
1024 for dict in reversed(self.dicts):
1025 self.cleanup(dictionary=dict)
1027 # =========================================================
1028 # Various callbacks to allow introspection of test progress
1029 # =========================================================
1031 def markError(self):
1032 """Callback invoked when an error (unexpected exception) errored."""
1033 self.__errored__ = True
1034 with recording(self, False) as sbuf:
1035 # False because there's no need to write "ERROR" to the stderr twice.
1036 # Once by the Python unittest framework, and a second time by us.
1037 print("ERROR", file=sbuf)
1039 def markCleanupError(self):
1040 """Callback invoked when an error occurs while a test is cleaning up."""
1041 self.__cleanup_errored__ = True
1042 with recording(self, False) as sbuf:
1043 # False because there's no need to write "CLEANUP_ERROR" to the stderr twice.
1044 # Once by the Python unittest framework, and a second time by us.
1045 print("CLEANUP_ERROR", file=sbuf)
1047 def markFailure(self):
1048 """Callback invoked when a failure (test assertion failure) occurred."""
1049 self.__failed__ = True
1050 with recording(self, False) as sbuf:
1051 # False because there's no need to write "FAIL" to the stderr twice.
1052 # Once by the Python unittest framework, and a second time by us.
1053 print("FAIL", file=sbuf)
1055 def markExpectedFailure(self, err, bugnumber):
1056 """Callback invoked when an expected failure/error occurred."""
1057 self.__expected__ = True
1058 with recording(self, False) as sbuf:
1059 # False because there's no need to write "expected failure" to the
1061 # Once by the Python unittest framework, and a second time by us.
1062 if bugnumber is None:
1063 print("expected failure", file=sbuf)
1066 "expected failure (problem id:" + str(bugnumber) + ")",
1069 def markSkippedTest(self):
1070 """Callback invoked when a test is skipped."""
1071 self.__skipped__ = True
1072 with recording(self, False) as sbuf:
1073 # False because there's no need to write "skipped test" to the
1075 # Once by the Python unittest framework, and a second time by us.
1076 print("skipped test", file=sbuf)
1078 def markUnexpectedSuccess(self, bugnumber):
1079 """Callback invoked when an unexpected success occurred."""
1080 self.__unexpected__ = True
1081 with recording(self, False) as sbuf:
1082 # False because there's no need to write "unexpected success" to the
1084 # Once by the Python unittest framework, and a second time by us.
1085 if bugnumber is None:
1086 print("unexpected success", file=sbuf)
1089 "unexpected success (problem id:" + str(bugnumber) + ")",
1092 def getRerunArgs(self):
1093 return " -f %s.%s" % (self.__class__.__name__, self._testMethodName)
1095 def getLogBasenameForCurrentTest(self, prefix=None):
1097 returns a partial path that can be used as the beginning of the name of multiple
1098 log files pertaining to this test
1100 <session-dir>/<arch>-<compiler>-<test-file>.<test-class>.<test-method>
1102 dname = os.path.join(os.environ["LLDB_TEST"],
1103 os.environ["LLDB_SESSION_DIRNAME"])
1104 if not os.path.isdir(dname):
1108 if prefix is not None:
1109 components.append(prefix)
1110 for c in configuration.session_file_format:
1112 components.append(self.__class__.__module__)
1114 components.append(self.__class__.__name__)
1116 compiler = self.getCompiler()
1118 if compiler[1] == ':':
1119 compiler = compiler[2:]
1120 if os.path.altsep is not None:
1121 compiler = compiler.replace(os.path.altsep, os.path.sep)
1123 [x for x in compiler.split(os.path.sep) if x != ""])
1125 components.append(self.getArchitecture())
1127 components.append(self.testMethodName)
1128 fname = "-".join(components)
1130 return os.path.join(dname, fname)
1132 def dumpSessionInfo(self):
1134 Dump the debugger interactions leading to a test error/failure. This
1135 allows for more convenient postmortem analysis.
1137 See also LLDBTestResult (dotest.py) which is a singlton class derived
1138 from TextTestResult and overwrites addError, addFailure, and
1139 addExpectedFailure methods to allow us to to mark the test instance as
1143 # We are here because self.tearDown() detected that this test instance
1144 # either errored or failed. The lldb.test_result singleton contains
1145 # two lists (erros and failures) which get populated by the unittest
1146 # framework. Look over there for stack trace information.
1148 # The lists contain 2-tuples of TestCase instances and strings holding
1149 # formatted tracebacks.
1151 # See http://docs.python.org/library/unittest.html#unittest.TestResult.
1153 # output tracebacks into session
1155 if self.__errored__:
1156 pairs = configuration.test_result.errors
1158 elif self.__cleanup_errored__:
1159 pairs = configuration.test_result.cleanup_errors
1160 prefix = 'CleanupError'
1161 elif self.__failed__:
1162 pairs = configuration.test_result.failures
1164 elif self.__expected__:
1165 pairs = configuration.test_result.expectedFailures
1166 prefix = 'ExpectedFailure'
1167 elif self.__skipped__:
1168 prefix = 'SkippedTest'
1169 elif self.__unexpected__:
1170 prefix = 'UnexpectedSuccess'
1174 if not self.__unexpected__ and not self.__skipped__:
1175 for test, traceback in pairs:
1177 print(traceback, file=self.session)
1179 # put footer (timestamp/rerun instructions) into session
1180 testMethod = getattr(self, self._testMethodName)
1181 if getattr(testMethod, "__benchmarks_test__", False):
1188 "Session info generated @",
1189 datetime.datetime.now().ctime(),
1192 "To rerun this test, issue the following command from the 'test' directory:\n",
1195 "./dotest.py %s -v %s %s" %
1196 (self.getRunOptions(),
1197 ('+b' if benchmarks else '-t'),
1198 self.getRerunArgs()),
1200 self.session.close()
1203 # process the log files
1204 log_files_for_this_test = glob.glob(self.log_basename + "*")
1206 if prefix != 'Success' or lldbtest_config.log_success:
1207 # keep all log files, rename them to include prefix
1208 dst_log_basename = self.getLogBasenameForCurrentTest(prefix)
1209 for src in log_files_for_this_test:
1210 if os.path.isfile(src):
1211 dst = src.replace(self.log_basename, dst_log_basename)
1212 if os.name == "nt" and os.path.isfile(dst):
1213 # On Windows, renaming a -> b will throw an exception if b exists. On non-Windows platforms
1214 # it silently replaces the destination. Ultimately this means that atomic renames are not
1215 # guaranteed to be possible on Windows, but we need this to work anyway, so just remove the
1216 # destination first if it already exists.
1221 # success! (and we don't want log files) delete log files
1222 for log_file in log_files_for_this_test:
1223 remove_file(log_file)
1225 # ====================================================
1226 # Config. methods supported through a plugin interface
1227 # (enables reading of the current test configuration)
1228 # ====================================================
1230 def getArchitecture(self):
1231 """Returns the architecture in effect the test suite is running with."""
1232 module = builder_module()
1233 arch = module.getArchitecture()
1238 def getLldbArchitecture(self):
1239 """Returns the architecture of the lldb binary."""
1240 if not hasattr(self, 'lldbArchitecture'):
1242 # spawn local process
1244 lldbtest_config.lldbExec,
1246 "file " + lldbtest_config.lldbExec,
1251 output = check_output(command)
1252 str = output.decode("utf-8")
1254 for line in str.splitlines():
1256 "Current executable set to '.*' \\((.*)\\)\\.", line)
1258 self.lldbArchitecture = m.group(1)
1261 return self.lldbArchitecture
1263 def getCompiler(self):
1264 """Returns the compiler in effect the test suite is running with."""
1265 module = builder_module()
1266 return module.getCompiler()
1268 def getCompilerBinary(self):
1269 """Returns the compiler binary the test suite is running with."""
1270 return self.getCompiler().split()[0]
1272 def getCompilerVersion(self):
1273 """ Returns a string that represents the compiler version.
1274 Supports: llvm, clang.
1278 compiler = self.getCompilerBinary()
1279 version_output = system([[compiler, "-v"]])[1]
1280 for line in version_output.split(os.linesep):
1281 m = re.search('version ([0-9\.]+)', line)
1283 version = m.group(1)
1286 def getGoCompilerVersion(self):
1287 """ Returns a string that represents the go compiler version, or None if go is not found.
1289 compiler = which("go")
1291 version_output = system([[compiler, "version"]])[0]
1292 for line in version_output.split(os.linesep):
1293 m = re.search('go version (devel|go\\S+)', line)
1298 def platformIsDarwin(self):
1299 """Returns true if the OS triple for the selected platform is any valid apple OS"""
1300 return lldbplatformutil.platformIsDarwin()
1302 def hasDarwinFramework(self):
1303 return self.darwinWithFramework
1305 def getPlatform(self):
1306 """Returns the target platform the test suite is running on."""
1307 return lldbplatformutil.getPlatform()
1309 def isIntelCompiler(self):
1310 """ Returns true if using an Intel (ICC) compiler, false otherwise. """
1311 return any([x in self.getCompiler() for x in ["icc", "icpc", "icl"]])
1313 def expectedCompilerVersion(self, compiler_version):
1314 """Returns True iff compiler_version[1] matches the current compiler version.
1315 Use compiler_version[0] to specify the operator used to determine if a match has occurred.
1316 Any operator other than the following defaults to an equality test:
1317 '>', '>=', "=>", '<', '<=', '=<', '!=', "!" or 'not'
1319 if (compiler_version is None):
1321 operator = str(compiler_version[0])
1322 version = compiler_version[1]
1324 if (version is None):
1326 if (operator == '>'):
1327 return self.getCompilerVersion() > version
1328 if (operator == '>=' or operator == '=>'):
1329 return self.getCompilerVersion() >= version
1330 if (operator == '<'):
1331 return self.getCompilerVersion() < version
1332 if (operator == '<=' or operator == '=<'):
1333 return self.getCompilerVersion() <= version
1334 if (operator == '!=' or operator == '!' or operator == 'not'):
1335 return str(version) not in str(self.getCompilerVersion())
1336 return str(version) in str(self.getCompilerVersion())
1338 def expectedCompiler(self, compilers):
1339 """Returns True iff any element of compilers is a sub-string of the current compiler."""
1340 if (compilers is None):
1343 for compiler in compilers:
1344 if compiler in self.getCompiler():
1349 def expectedArch(self, archs):
1350 """Returns True iff any element of archs is a sub-string of the current architecture."""
1355 if arch in self.getArchitecture():
1360 def getRunOptions(self):
1361 """Command line option for -A and -C to run this test again, called from
1362 self.dumpSessionInfo()."""
1363 arch = self.getArchitecture()
1364 comp = self.getCompiler()
1366 option_str = "-A " + arch
1370 option_str += " -C " + comp
1373 # ==================================================
1374 # Build methods supported through a plugin interface
1375 # ==================================================
1377 def getstdlibFlag(self):
1378 """ Returns the proper -stdlib flag, or empty if not required."""
1379 if self.platformIsDarwin() or self.getPlatform() == "freebsd":
1380 stdlibflag = "-stdlib=libc++"
1381 else: # this includes NetBSD
1385 def getstdFlag(self):
1386 """ Returns the proper stdflag. """
1387 if "gcc" in self.getCompiler() and "4.6" in self.getCompilerVersion():
1388 stdflag = "-std=c++0x"
1390 stdflag = "-std=c++11"
1393 def buildDriver(self, sources, exe_name):
1394 """ Platform-specific way to build a program that links with LLDB (via the liblldb.so
1398 stdflag = self.getstdFlag()
1399 stdlibflag = self.getstdlibFlag()
1401 lib_dir = os.environ["LLDB_LIB_DIR"]
1402 if self.hasDarwinFramework():
1403 d = {'CXX_SOURCES': sources,
1405 'CFLAGS_EXTRAS': "%s %s" % (stdflag, stdlibflag),
1406 'FRAMEWORK_INCLUDES': "-F%s" % self.framework_dir,
1407 'LD_EXTRAS': "%s -Wl,-rpath,%s" % (self.dsym, self.framework_dir),
1409 elif sys.platform.rstrip('0123456789') in ('freebsd', 'linux', 'netbsd', 'darwin') or os.environ.get('LLDB_BUILD_TYPE') == 'Makefile':
1411 'CXX_SOURCES': sources,
1413 'CFLAGS_EXTRAS': "%s %s -I%s" % (stdflag,
1416 os.environ["LLDB_SRC"],
1418 'LD_EXTRAS': "-L%s/../lib -llldb -Wl,-rpath,%s/../lib" % (lib_dir, lib_dir)}
1419 elif sys.platform.startswith('win'):
1421 'CXX_SOURCES': sources,
1423 'CFLAGS_EXTRAS': "%s %s -I%s" % (stdflag,
1426 os.environ["LLDB_SRC"],
1428 'LD_EXTRAS': "-L%s -lliblldb" % os.environ["LLDB_IMPLIB_DIR"]}
1431 "Building LLDB Driver (%s) from sources %s" %
1432 (exe_name, sources))
1434 self.buildDefault(dictionary=d)
1436 def buildLibrary(self, sources, lib_name):
1437 """Platform specific way to build a default library. """
1439 stdflag = self.getstdFlag()
1441 lib_dir = os.environ["LLDB_LIB_DIR"]
1442 if self.hasDarwinFramework():
1443 d = {'DYLIB_CXX_SOURCES': sources,
1444 'DYLIB_NAME': lib_name,
1445 'CFLAGS_EXTRAS': "%s -stdlib=libc++" % stdflag,
1446 'FRAMEWORK_INCLUDES': "-F%s" % self.framework_dir,
1447 'LD_EXTRAS': "%s -Wl,-rpath,%s -dynamiclib" % (self.dsym, self.framework_dir),
1449 elif sys.platform.rstrip('0123456789') in ('freebsd', 'linux', 'netbsd', 'darwin') or os.environ.get('LLDB_BUILD_TYPE') == 'Makefile':
1451 'DYLIB_CXX_SOURCES': sources,
1452 'DYLIB_NAME': lib_name,
1453 'CFLAGS_EXTRAS': "%s -I%s -fPIC" % (stdflag,
1455 os.environ["LLDB_SRC"],
1457 'LD_EXTRAS': "-shared -L%s/../lib -llldb -Wl,-rpath,%s/../lib" % (lib_dir, lib_dir)}
1458 elif self.getPlatform() == 'windows':
1460 'DYLIB_CXX_SOURCES': sources,
1461 'DYLIB_NAME': lib_name,
1462 'CFLAGS_EXTRAS': "%s -I%s -fPIC" % (stdflag,
1464 os.environ["LLDB_SRC"],
1466 'LD_EXTRAS': "-shared -l%s\liblldb.lib" % self.os.environ["LLDB_IMPLIB_DIR"]}
1469 "Building LLDB Library (%s) from sources %s" %
1470 (lib_name, sources))
1472 self.buildDefault(dictionary=d)
1474 def buildProgram(self, sources, exe_name):
1475 """ Platform specific way to build an executable from C/C++ sources. """
1476 d = {'CXX_SOURCES': sources,
1478 self.buildDefault(dictionary=d)
1486 """Platform specific way to build the default binaries."""
1487 module = builder_module()
1488 dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
1489 if not module.buildDefault(
1495 raise Exception("Don't know how to build default binary")
1503 """Platform specific way to build binaries with dsym info."""
1504 module = builder_module()
1505 if not module.buildDsym(
1511 raise Exception("Don't know how to build binary with dsym")
1519 """Platform specific way to build binaries with dwarf maps."""
1520 module = builder_module()
1521 dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
1522 if not module.buildDwarf(
1528 raise Exception("Don't know how to build binary with dwarf")
1536 """Platform specific way to build binaries with dwarf maps."""
1537 module = builder_module()
1538 dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
1539 if not module.buildDwo(
1545 raise Exception("Don't know how to build binary with dwo")
1553 """Platform specific way to build binaries with gmodules info."""
1554 module = builder_module()
1555 if not module.buildGModules(
1561 raise Exception("Don't know how to build binary with gmodules")
1564 """Build the default go binary.
1566 system([[which('go'), 'build -gcflags "-N -l" -o a.out main.go']])
1568 def signBinary(self, binary_path):
1569 if sys.platform.startswith("darwin"):
1570 codesign_cmd = "codesign --force --sign \"%s\" %s" % (
1571 lldbtest_config.codesign_identity, binary_path)
1572 call(codesign_cmd, shell=True)
1574 def findBuiltClang(self):
1575 """Tries to find and use Clang from the build directory as the compiler (instead of the system compiler)."""
1577 "llvm-build/Release+Asserts/x86_64/Release+Asserts/bin/clang",
1578 "llvm-build/Debug+Asserts/x86_64/Debug+Asserts/bin/clang",
1579 "llvm-build/Release/x86_64/Release/bin/clang",
1580 "llvm-build/Debug/x86_64/Debug/bin/clang",
1582 lldb_root_path = os.path.join(
1583 os.path.dirname(__file__), "..", "..", "..", "..")
1584 for p in paths_to_try:
1585 path = os.path.join(lldb_root_path, p)
1586 if os.path.exists(path):
1589 # Tries to find clang at the same folder as the lldb
1590 path = os.path.join(os.path.dirname(lldbtest_config.lldbExec), "clang")
1591 if os.path.exists(path):
1594 return os.environ["CC"]
1600 use_libstdcxx=False):
1601 """ Returns a dictionary (which can be provided to build* functions above) which
1602 contains OS-specific build flags.
1607 # On Mac OS X, unless specifically requested to use libstdc++, use
1609 if not use_libstdcxx and self.platformIsDarwin():
1612 if use_libcxx and self.libcxxPath:
1613 cflags += "-stdlib=libc++ "
1615 libcxxInclude = os.path.join(self.libcxxPath, "include")
1616 libcxxLib = os.path.join(self.libcxxPath, "lib")
1617 if os.path.isdir(libcxxInclude) and os.path.isdir(libcxxLib):
1618 cflags += "-nostdinc++ -I%s -L%s -Wl,-rpath,%s " % (
1619 libcxxInclude, libcxxLib, libcxxLib)
1623 if "gcc" in self.getCompiler() and "4.6" in self.getCompilerVersion():
1627 if self.platformIsDarwin() or self.getPlatform() == "freebsd":
1628 cflags += " -stdlib=libc++"
1629 elif self.getPlatform() == "netbsd":
1630 cflags += " -stdlib=libstdc++"
1631 elif "clang" in self.getCompiler():
1632 cflags += " -stdlib=libstdc++"
1634 return {'CFLAGS_EXTRAS': cflags,
1635 'LD_EXTRAS': ldflags,
1638 def cleanup(self, dictionary=None):
1639 """Platform specific way to do cleanup after build."""
1640 module = builder_module()
1641 if not module.cleanup(self, dictionary):
1643 "Don't know how to do cleanup with dictionary: " +
1646 def getLLDBLibraryEnvVal(self):
1647 """ Returns the path that the OS-specific library search environment variable
1648 (self.dylibPath) should be set to in order for a program to find the LLDB
1649 library. If an environment variable named self.dylibPath is already set,
1650 the new path is appended to it and returned.
1652 existing_library_path = os.environ[
1653 self.dylibPath] if self.dylibPath in os.environ else None
1654 lib_dir = os.environ["LLDB_LIB_DIR"]
1655 if existing_library_path:
1656 return "%s:%s" % (existing_library_path, lib_dir)
1657 elif sys.platform.startswith("darwin"):
1658 return os.path.join(lib_dir, 'LLDB.framework')
1662 def getLibcPlusPlusLibs(self):
1663 if self.getPlatform() in ('freebsd', 'linux', 'netbsd'):
1664 return ['libc++.so.1']
1666 return ['libc++.1.dylib', 'libc++abi.dylib']
1668 # Metaclass for TestBase to change the list of test metods when a new TestCase is loaded.
1669 # We change the test methods to create a new test method for each test for each debug info we are
1670 # testing. The name of the new test method will be '<original-name>_<debug-info>' and with adding
1671 # the new test method we remove the old method at the same time. This functionality can be
1672 # supressed by at test case level setting the class attribute NO_DEBUG_INFO_TESTCASE or at test
1673 # level by using the decorator @no_debug_info_test.
1676 class LLDBTestCaseFactory(type):
1678 def __new__(cls, name, bases, attrs):
1679 original_testcase = super(
1680 LLDBTestCaseFactory, cls).__new__(
1681 cls, name, bases, attrs)
1682 if original_testcase.NO_DEBUG_INFO_TESTCASE:
1683 return original_testcase
1686 for attrname, attrvalue in attrs.items():
1687 if attrname.startswith("test") and not getattr(
1688 attrvalue, "__no_debug_info_test__", False):
1689 target_platform = lldb.DBG.GetSelectedPlatform(
1690 ).GetTriple().split('-')[2]
1692 # If any debug info categories were explicitly tagged, assume that list to be
1693 # authoritative. If none were specified, try with all debug
1695 all_dbginfo_categories = set(
1696 test_categories.debug_info_categories)
1701 [])) & all_dbginfo_categories
1703 categories = all_dbginfo_categories
1705 supported_categories = [
1706 x for x in categories if test_categories.is_supported_on_platform(
1707 x, target_platform, configuration.compilers)]
1708 if "dsym" in supported_categories:
1709 @decorators.add_test_categories(["dsym"])
1711 def dsym_test_method(self, attrvalue=attrvalue):
1712 self.debug_info = "dsym"
1713 return attrvalue(self)
1714 dsym_method_name = attrname + "_dsym"
1715 dsym_test_method.__name__ = dsym_method_name
1716 newattrs[dsym_method_name] = dsym_test_method
1718 if "dwarf" in supported_categories:
1719 @decorators.add_test_categories(["dwarf"])
1721 def dwarf_test_method(self, attrvalue=attrvalue):
1722 self.debug_info = "dwarf"
1723 return attrvalue(self)
1724 dwarf_method_name = attrname + "_dwarf"
1725 dwarf_test_method.__name__ = dwarf_method_name
1726 newattrs[dwarf_method_name] = dwarf_test_method
1728 if "dwo" in supported_categories:
1729 @decorators.add_test_categories(["dwo"])
1731 def dwo_test_method(self, attrvalue=attrvalue):
1732 self.debug_info = "dwo"
1733 return attrvalue(self)
1734 dwo_method_name = attrname + "_dwo"
1735 dwo_test_method.__name__ = dwo_method_name
1736 newattrs[dwo_method_name] = dwo_test_method
1738 if "gmodules" in supported_categories:
1739 @decorators.add_test_categories(["gmodules"])
1741 def gmodules_test_method(self, attrvalue=attrvalue):
1742 self.debug_info = "gmodules"
1743 return attrvalue(self)
1744 gmodules_method_name = attrname + "_gmodules"
1745 gmodules_test_method.__name__ = gmodules_method_name
1746 newattrs[gmodules_method_name] = gmodules_test_method
1749 newattrs[attrname] = attrvalue
1751 LLDBTestCaseFactory,
1758 # Setup the metaclass for this class to change the list of the test
1759 # methods when a new class is loaded
1762 @add_metaclass(LLDBTestCaseFactory)
1763 class TestBase(Base):
1765 This abstract base class is meant to be subclassed. It provides default
1766 implementations for setUpClass(), tearDownClass(), setUp(), and tearDown(),
1769 Important things for test class writers:
1771 - Overwrite the mydir class attribute, otherwise your test class won't
1772 run. It specifies the relative directory to the top level 'test' so
1773 the test harness can change to the correct working directory before
1776 - The setUp method sets up things to facilitate subsequent interactions
1777 with the debugger as part of the test. These include:
1778 - populate the test method name
1779 - create/get a debugger set with synchronous mode (self.dbg)
1780 - get the command interpreter from with the debugger (self.ci)
1781 - create a result object for use with the command interpreter
1785 - The tearDown method tries to perform some necessary cleanup on behalf
1786 of the test to return the debugger to a good state for the next test.
1788 - execute any tearDown hooks registered by the test method with
1789 TestBase.addTearDownHook(); examples can be found in
1790 settings/TestSettings.py
1791 - kill the inferior process associated with each target, if any,
1792 and, then delete the target from the debugger's target list
1793 - perform build cleanup before running the next test method in the
1794 same test class; examples of registering for this service can be
1795 found in types/TestIntegerTypes.py with the call:
1796 - self.setTearDownCleanup(dictionary=d)
1798 - Similarly setUpClass and tearDownClass perform classwise setup and
1799 teardown fixtures. The tearDownClass method invokes a default build
1800 cleanup for the entire test class; also, subclasses can implement the
1801 classmethod classCleanup(cls) to perform special class cleanup action.
1803 - The instance methods runCmd and expect are used heavily by existing
1804 test cases to send a command to the command interpreter and to perform
1805 string/pattern matching on the output of such command execution. The
1806 expect method also provides a mode to peform string/pattern matching
1807 without running a command.
1809 - The build methods buildDefault, buildDsym, and buildDwarf are used to
1810 build the binaries used during a particular test scenario. A plugin
1811 should be provided for the sys.platform running the test suite. The
1812 Mac OS X implementation is located in plugins/darwin.py.
1815 # Subclasses can set this to true (if they don't depend on debug info) to avoid running the
1816 # test multiple times with various debug info types.
1817 NO_DEBUG_INFO_TESTCASE = False
1819 # Maximum allowed attempts when launching the inferior process.
1820 # Can be overridden by the LLDB_MAX_LAUNCH_COUNT environment variable.
1823 # Time to wait before the next launching attempt in second(s).
1824 # Can be overridden by the LLDB_TIME_WAIT_NEXT_LAUNCH environment variable.
1825 timeWaitNextLaunch = 1.0
1827 # Returns the list of categories to which this test case belongs
1828 # by default, look for a ".categories" file, and read its contents
1829 # if no such file exists, traverse the hierarchy - we guarantee
1830 # a .categories to exist at the top level directory so we do not end up
1831 # looping endlessly - subclasses are free to define their own categories
1832 # in whatever way makes sense to them
1833 def getCategories(self):
1836 folder = inspect.getfile(self.__class__)
1837 folder = os.path.dirname(folder)
1838 while folder != '/':
1839 categories_file_name = os.path.join(folder, ".categories")
1840 if os.path.exists(categories_file_name):
1841 categories_file = open(categories_file_name, 'r')
1842 categories = categories_file.readline()
1843 categories_file.close()
1844 categories = str.replace(categories, '\n', '')
1845 categories = str.replace(categories, '\r', '')
1846 return categories.split(',')
1848 folder = os.path.dirname(folder)
1851 def generateSource(self, source):
1852 template = source + '.template'
1853 temp = os.path.join(os.getcwd(), template)
1854 with open(temp, 'r') as f:
1857 public_api_dir = os.path.join(
1858 os.environ["LLDB_SRC"], "include", "lldb", "API")
1860 # Look under the include/lldb/API directory and add #include statements
1861 # for all the SB API headers.
1862 public_headers = os.listdir(public_api_dir)
1863 # For different platforms, the include statement can vary.
1864 if self.hasDarwinFramework():
1865 include_stmt = "'#include <%s>' % os.path.join('LLDB', header)"
1867 include_stmt = "'#include <%s>' % os.path.join('" + public_api_dir + "', header)"
1868 list = [eval(include_stmt) for header in public_headers if (
1869 header.startswith("SB") and header.endswith(".h"))]
1870 includes = '\n'.join(list)
1871 new_content = content.replace('%include_SB_APIs%', includes)
1872 src = os.path.join(os.getcwd(), source)
1873 with open(src, 'w') as f:
1874 f.write(new_content)
1876 self.addTearDownHook(lambda: os.remove(src))
1880 # traceback.print_stack()
1882 # Works with the test driver to conditionally skip tests via
1886 if "LLDB_MAX_LAUNCH_COUNT" in os.environ:
1887 self.maxLaunchCount = int(os.environ["LLDB_MAX_LAUNCH_COUNT"])
1889 if "LLDB_TIME_WAIT_NEXT_LAUNCH" in os.environ:
1890 self.timeWaitNextLaunch = float(
1891 os.environ["LLDB_TIME_WAIT_NEXT_LAUNCH"])
1893 # We want our debugger to be synchronous.
1894 self.dbg.SetAsync(False)
1896 # Retrieve the associated command interpreter instance.
1897 self.ci = self.dbg.GetCommandInterpreter()
1899 raise Exception('Could not get the command interpreter')
1901 # And the result object.
1902 self.res = lldb.SBCommandReturnObject()
1904 def registerSharedLibrariesWithTarget(self, target, shlibs):
1905 '''If we are remotely running the test suite, register the shared libraries with the target so they get uploaded, otherwise do nothing
1907 Any modules in the target that have their remote install file specification set will
1908 get uploaded to the remote host. This function registers the local copies of the
1909 shared libraries with the target and sets their remote install locations so they will
1910 be uploaded when the target is run.
1912 if not shlibs or not self.platformContext:
1915 shlib_environment_var = self.platformContext.shlib_environment_var
1916 shlib_prefix = self.platformContext.shlib_prefix
1917 shlib_extension = '.' + self.platformContext.shlib_extension
1919 working_dir = self.get_process_working_directory()
1920 environment = ['%s=%s' % (shlib_environment_var, working_dir)]
1921 # Add any shared libraries to our target if remote so they get
1922 # uploaded into the working directory on the remote side
1924 # The path can be a full path to a shared library, or a make file name like "Foo" for
1925 # "libFoo.dylib" or "libFoo.so", or "Foo.so" for "Foo.so" or "libFoo.so", or just a
1926 # basename like "libFoo.so". So figure out which one it is and resolve the local copy
1927 # of the shared library accordingly
1928 if os.path.exists(name):
1929 local_shlib_path = name # name is the full path to the local shared library
1931 # Check relative names
1932 local_shlib_path = os.path.join(
1933 os.getcwd(), shlib_prefix + name + shlib_extension)
1934 if not os.path.exists(local_shlib_path):
1935 local_shlib_path = os.path.join(
1936 os.getcwd(), name + shlib_extension)
1937 if not os.path.exists(local_shlib_path):
1938 local_shlib_path = os.path.join(os.getcwd(), name)
1940 # Make sure we found the local shared library in the above code
1941 self.assertTrue(os.path.exists(local_shlib_path))
1943 # Add the shared library to our target
1944 shlib_module = target.AddModule(local_shlib_path, None, None, None)
1945 if lldb.remote_platform:
1946 # We must set the remote install location if we want the shared library
1947 # to get uploaded to the remote target
1948 remote_shlib_path = lldbutil.append_to_process_working_directory(
1949 os.path.basename(local_shlib_path))
1950 shlib_module.SetRemoteInstallFileSpec(
1951 lldb.SBFileSpec(remote_shlib_path, False))
1955 # utility methods that tests can use to access the current objects
1958 raise Exception('Invalid debugger instance')
1959 return self.dbg.GetSelectedTarget()
1963 raise Exception('Invalid debugger instance')
1964 return self.dbg.GetSelectedTarget().GetProcess()
1968 raise Exception('Invalid debugger instance')
1969 return self.dbg.GetSelectedTarget().GetProcess().GetSelectedThread()
1973 raise Exception('Invalid debugger instance')
1974 return self.dbg.GetSelectedTarget().GetProcess(
1975 ).GetSelectedThread().GetSelectedFrame()
1977 def get_process_working_directory(self):
1978 '''Get the working directory that should be used when launching processes for local or remote processes.'''
1979 if lldb.remote_platform:
1980 # Remote tests set the platform working directory up in
1982 return lldb.remote_platform.GetWorkingDirectory()
1984 # local tests change directory into each test subdirectory
1989 # traceback.print_stack()
1991 # Ensure all the references to SB objects have gone away so that we can
1992 # be sure that all test-specific resources have been freed before we
1993 # attempt to delete the targets.
1996 # Delete the target(s) from the debugger as a general cleanup step.
1997 # This includes terminating the process for each target, if any.
1998 # We'd like to reuse the debugger for our next test without incurring
1999 # the initialization overhead.
2001 for target in self.dbg:
2003 targets.append(target)
2004 process = target.GetProcess()
2006 rc = self.invoke(process, "Kill")
2007 self.assertTrue(rc.Success(), PROCESS_KILLED)
2008 for target in targets:
2009 self.dbg.DeleteTarget(target)
2011 # Do this last, to make sure it's in reverse order from how we setup.
2014 # This must be the last statement, otherwise teardown hooks or other
2015 # lines might depend on this still being active.
2018 def switch_to_thread_with_stop_reason(self, stop_reason):
2020 Run the 'thread list' command, and select the thread with stop reason as
2021 'stop_reason'. If no such thread exists, no select action is done.
2023 from .lldbutil import stop_reason_to_str
2024 self.runCmd('thread list')
2025 output = self.res.GetOutput()
2026 thread_line_pattern = re.compile(
2027 "^[ *] thread #([0-9]+):.*stop reason = %s" %
2028 stop_reason_to_str(stop_reason))
2029 for line in output.splitlines():
2030 matched = thread_line_pattern.match(line)
2032 self.runCmd('thread select %s' % matched.group(1))
2034 def runCmd(self, cmd, msg=None, check=True, trace=False, inHistory=False):
2036 Ask the command interpreter to handle the command and then check its
2039 # Fail fast if 'cmd' is not meaningful.
2040 if not cmd or len(cmd) == 0:
2041 raise Exception("Bad 'cmd' parameter encountered")
2043 trace = (True if traceAlways else trace)
2045 if cmd.startswith("target create "):
2046 cmd = cmd.replace("target create ", "file ")
2048 running = (cmd.startswith("run") or cmd.startswith("process launch"))
2050 for i in range(self.maxLaunchCount if running else 1):
2051 self.ci.HandleCommand(cmd, self.res, inHistory)
2053 with recording(self, trace) as sbuf:
2054 print("runCmd:", cmd, file=sbuf)
2056 print("check of return status not required", file=sbuf)
2057 if self.res.Succeeded():
2058 print("output:", self.res.GetOutput(), file=sbuf)
2060 print("runCmd failed!", file=sbuf)
2061 print(self.res.GetError(), file=sbuf)
2063 if self.res.Succeeded():
2066 # For process launch, wait some time before possible next try.
2067 time.sleep(self.timeWaitNextLaunch)
2068 with recording(self, trace) as sbuf:
2069 print("Command '" + cmd + "' failed!", file=sbuf)
2072 self.assertTrue(self.res.Succeeded(),
2073 msg if msg else CMD_MSG(cmd))
2084 """run command in str, and match the result against regexp in patterns returning the match object for the first matching pattern
2086 Otherwise, all the arguments have the same meanings as for the expect function"""
2088 trace = (True if traceAlways else trace)
2091 # First run the command. If we are expecting error, set check=False.
2092 # Pass the assert message along since it provides more semantic
2098 True if trace else False),
2101 # Then compare the output against expected strings.
2102 output = self.res.GetError() if error else self.res.GetOutput()
2104 # If error is True, the API client expects the command to fail!
2106 self.assertFalse(self.res.Succeeded(),
2107 "Command '" + str + "' is expected to fail!")
2109 # No execution required, just compare str against the golden input.
2111 with recording(self, trace) as sbuf:
2112 print("looking at:", output, file=sbuf)
2114 # The heading says either "Expecting" or "Not expecting".
2115 heading = "Expecting" if matching else "Not expecting"
2117 for pattern in patterns:
2118 # Match Objects always have a boolean value of True.
2119 match_object = re.search(pattern, output)
2120 matched = bool(match_object)
2121 with recording(self, trace) as sbuf:
2122 print("%s pattern: %s" % (heading, pattern), file=sbuf)
2123 print("Matched" if matched else "Not matched", file=sbuf)
2127 self.assertTrue(matched if matching else not matched,
2128 msg if msg else EXP_MSG(str, output, exe))
2146 Similar to runCmd; with additional expect style output matching ability.
2148 Ask the command interpreter to handle the command and then check its
2149 return status. The 'msg' parameter specifies an informational assert
2150 message. We expect the output from running the command to start with
2151 'startstr', matches the substrings contained in 'substrs', and regexp
2152 matches the patterns contained in 'patterns'.
2154 If the keyword argument error is set to True, it signifies that the API
2155 client is expecting the command to fail. In this case, the error stream
2156 from running the command is retrieved and compared against the golden
2159 If the keyword argument matching is set to False, it signifies that the API
2160 client is expecting the output of the command not to match the golden
2163 Finally, the required argument 'str' represents the lldb command to be
2164 sent to the command interpreter. In case the keyword argument 'exe' is
2165 set to False, the 'str' is treated as a string to be matched/not-matched
2166 against the golden input.
2168 trace = (True if traceAlways else trace)
2171 # First run the command. If we are expecting error, set check=False.
2172 # Pass the assert message along since it provides more semantic
2178 True if trace else False),
2180 inHistory=inHistory)
2182 # Then compare the output against expected strings.
2183 output = self.res.GetError() if error else self.res.GetOutput()
2185 # If error is True, the API client expects the command to fail!
2187 self.assertFalse(self.res.Succeeded(),
2188 "Command '" + str + "' is expected to fail!")
2190 # No execution required, just compare str against the golden input.
2191 if isinstance(str, lldb.SBCommandReturnObject):
2192 output = str.GetOutput()
2195 with recording(self, trace) as sbuf:
2196 print("looking at:", output, file=sbuf)
2200 # The heading says either "Expecting" or "Not expecting".
2201 heading = "Expecting" if matching else "Not expecting"
2203 # Start from the startstr, if specified.
2204 # If there's no startstr, set the initial state appropriately.
2205 matched = output.startswith(startstr) if startstr else (
2206 True if matching else False)
2209 with recording(self, trace) as sbuf:
2210 print("%s start string: %s" % (heading, startstr), file=sbuf)
2211 print("Matched" if matched else "Not matched", file=sbuf)
2213 # Look for endstr, if specified.
2214 keepgoing = matched if matching else not matched
2216 matched = output.endswith(endstr)
2217 with recording(self, trace) as sbuf:
2218 print("%s end string: %s" % (heading, endstr), file=sbuf)
2219 print("Matched" if matched else "Not matched", file=sbuf)
2221 # Look for sub strings, if specified.
2222 keepgoing = matched if matching else not matched
2223 if substrs and keepgoing:
2224 for substr in substrs:
2225 matched = output.find(substr) != -1
2226 with recording(self, trace) as sbuf:
2227 print("%s sub string: %s" % (heading, substr), file=sbuf)
2228 print("Matched" if matched else "Not matched", file=sbuf)
2229 keepgoing = matched if matching else not matched
2233 # Search for regular expression patterns, if specified.
2234 keepgoing = matched if matching else not matched
2235 if patterns and keepgoing:
2236 for pattern in patterns:
2237 # Match Objects always have a boolean value of True.
2238 matched = bool(re.search(pattern, output))
2239 with recording(self, trace) as sbuf:
2240 print("%s pattern: %s" % (heading, pattern), file=sbuf)
2241 print("Matched" if matched else "Not matched", file=sbuf)
2242 keepgoing = matched if matching else not matched
2246 self.assertTrue(matched if matching else not matched,
2247 msg if msg else EXP_MSG(str, output, exe))
2249 def invoke(self, obj, name, trace=False):
2250 """Use reflection to call a method dynamically with no argument."""
2251 trace = (True if traceAlways else trace)
2253 method = getattr(obj, name)
2255 self.assertTrue(inspect.ismethod(method),
2256 name + "is a method name of object: " + str(obj))
2258 with recording(self, trace) as sbuf:
2259 print(str(method) + ":", result, file=sbuf)
2268 """Platform specific way to build the default binaries."""
2269 module = builder_module()
2270 dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
2271 if self.debug_info is None:
2272 return self.buildDefault(architecture, compiler, dictionary, clean)
2273 elif self.debug_info == "dsym":
2274 return self.buildDsym(architecture, compiler, dictionary, clean)
2275 elif self.debug_info == "dwarf":
2276 return self.buildDwarf(architecture, compiler, dictionary, clean)
2277 elif self.debug_info == "dwo":
2278 return self.buildDwo(architecture, compiler, dictionary, clean)
2279 elif self.debug_info == "gmodules":
2280 return self.buildGModules(
2281 architecture, compiler, dictionary, clean)
2283 self.fail("Can't build for debug info: %s" % self.debug_info)
2285 def run_platform_command(self, cmd):
2286 platform = self.dbg.GetSelectedPlatform()
2287 shell_command = lldb.SBPlatformShellCommand(cmd)
2288 err = platform.Run(shell_command)
2289 return (err, shell_command.GetStatus(), shell_command.GetOutput())
2291 # =================================================
2292 # Misc. helper methods for debugging test execution
2293 # =================================================
2295 def DebugSBValue(self, val):
2296 """Debug print a SBValue object, if traceAlways is True."""
2297 from .lldbutil import value_type_to_str
2303 err.write(val.GetName() + ":\n")
2304 err.write('\t' + "TypeName -> " + val.GetTypeName() + '\n')
2305 err.write('\t' + "ByteSize -> " +
2306 str(val.GetByteSize()) + '\n')
2307 err.write('\t' + "NumChildren -> " +
2308 str(val.GetNumChildren()) + '\n')
2309 err.write('\t' + "Value -> " + str(val.GetValue()) + '\n')
2310 err.write('\t' + "ValueAsUnsigned -> " +
2311 str(val.GetValueAsUnsigned()) + '\n')
2316 val.GetValueType()) +
2318 err.write('\t' + "Summary -> " + str(val.GetSummary()) + '\n')
2319 err.write('\t' + "IsPointerType -> " +
2320 str(val.TypeIsPointerType()) + '\n')
2321 err.write('\t' + "Location -> " + val.GetLocation() + '\n')
2323 def DebugSBType(self, type):
2324 """Debug print a SBType object, if traceAlways is True."""
2329 err.write(type.GetName() + ":\n")
2330 err.write('\t' + "ByteSize -> " +
2331 str(type.GetByteSize()) + '\n')
2332 err.write('\t' + "IsPointerType -> " +
2333 str(type.IsPointerType()) + '\n')
2334 err.write('\t' + "IsReferenceType -> " +
2335 str(type.IsReferenceType()) + '\n')
2337 def DebugPExpect(self, child):
2338 """Debug the spwaned pexpect object."""
2345 def RemoveTempFile(cls, file):
2346 if os.path.exists(file):
2349 # On Windows, the first attempt to delete a recently-touched file can fail
2350 # because of a race with antimalware scanners. This function will detect a
2351 # failure and retry.
2354 def remove_file(file, num_retries=1, sleep_duration=0.5):
2355 for i in range(num_retries + 1):
2360 time.sleep(sleep_duration)