Merge branch 'addmainunit3-altlink-sharedstmt-dieref-dwz3' into addmainunit3-altlink...
[lldb.git] / lldb / packages / Python / lldbsuite / test / lldbtest.py
1 """
2 LLDB module which provides the abstract base class of lldb test case.
3
4 The concrete subclass can override lldbtest.TestBase in order to inherit the
5 common behavior for unitest.TestCase.setUp/tearDown implemented in this file.
6
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.
10
11 ./dotest.py provides a test driver which sets up the environment to run the
12 entire of part of the test suite .  Example:
13
14 # Exercises the test suite in the types directory....
15 /Volumes/data/lldb/svn/ToT/test $ ./dotest.py -A x86_64 types
16 ...
17
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
20 compilers=['clang']
21
22 Configuration: arch=x86_64 compiler=clang
23 ----------------------------------------------------------------------
24 Collected 72 tests
25
26 ........................................................................
27 ----------------------------------------------------------------------
28 Ran 72 tests in 135.468s
29
30 OK
31 $
32 """
33
34 from __future__ import absolute_import
35 from __future__ import print_function
36
37 # System modules
38 import abc
39 from distutils.version import LooseVersion
40 from functools import wraps
41 import gc
42 import glob
43 import io
44 import os.path
45 import re
46 import shutil
47 import signal
48 from subprocess import *
49 import sys
50 import time
51 import traceback
52 import distutils.spawn
53
54 # Third-party modules
55 import unittest2
56 from six import add_metaclass
57 from six import StringIO as SixStringIO
58 import six
59
60 # LLDB modules
61 import lldb
62 from . import configuration
63 from . import decorators
64 from . import lldbplatformutil
65 from . import lldbtest_config
66 from . import lldbutil
67 from . import test_categories
68 from lldbsuite.support import encoded_file
69 from lldbsuite.support import funcutils
70 from lldbsuite.test.builders import get_builder
71
72 # See also dotest.parseOptionsAndInitTestdirs(), where the environment variables
73 # LLDB_COMMAND_TRACE is set from '-t' option.
74
75 # By default, traceAlways is False.
76 if "LLDB_COMMAND_TRACE" in os.environ and os.environ[
77         "LLDB_COMMAND_TRACE"] == "YES":
78     traceAlways = True
79 else:
80     traceAlways = False
81
82 # By default, doCleanup is True.
83 if "LLDB_DO_CLEANUP" in os.environ and os.environ["LLDB_DO_CLEANUP"] == "NO":
84     doCleanup = False
85 else:
86     doCleanup = True
87
88
89 #
90 # Some commonly used assert messages.
91 #
92
93 COMMAND_FAILED_AS_EXPECTED = "Command has failed as expected"
94
95 CURRENT_EXECUTABLE_SET = "Current executable set successfully"
96
97 PROCESS_IS_VALID = "Process is valid"
98
99 PROCESS_KILLED = "Process is killed successfully"
100
101 PROCESS_EXITED = "Process exited successfully"
102
103 PROCESS_STOPPED = "Process status should be stopped"
104
105 RUN_SUCCEEDED = "Process is launched successfully"
106
107 RUN_COMPLETED = "Process exited successfully"
108
109 BACKTRACE_DISPLAYED_CORRECTLY = "Backtrace displayed correctly"
110
111 BREAKPOINT_CREATED = "Breakpoint created successfully"
112
113 BREAKPOINT_STATE_CORRECT = "Breakpoint state is correct"
114
115 BREAKPOINT_PENDING_CREATED = "Pending breakpoint created successfully"
116
117 BREAKPOINT_HIT_ONCE = "Breakpoint resolved with hit count = 1"
118
119 BREAKPOINT_HIT_TWICE = "Breakpoint resolved with hit count = 2"
120
121 BREAKPOINT_HIT_THRICE = "Breakpoint resolved with hit count = 3"
122
123 MISSING_EXPECTED_REGISTERS = "At least one expected register is unavailable."
124
125 OBJECT_PRINTED_CORRECTLY = "Object printed correctly"
126
127 SOURCE_DISPLAYED_CORRECTLY = "Source code displayed correctly"
128
129 STEP_IN_SUCCEEDED = "Thread step-in succeeded"
130
131 STEP_OUT_SUCCEEDED = "Thread step-out succeeded"
132
133 STOPPED_DUE_TO_EXC_BAD_ACCESS = "Process should be stopped due to bad access exception"
134
135 STOPPED_DUE_TO_ASSERT = "Process should be stopped due to an assertion"
136
137 STOPPED_DUE_TO_BREAKPOINT = "Process should be stopped due to breakpoint"
138
139 STOPPED_DUE_TO_BREAKPOINT_WITH_STOP_REASON_AS = "%s, %s" % (
140     STOPPED_DUE_TO_BREAKPOINT, "instead, the actual stop reason is: '%s'")
141
142 STOPPED_DUE_TO_BREAKPOINT_CONDITION = "Stopped due to breakpoint condition"
143
144 STOPPED_DUE_TO_BREAKPOINT_IGNORE_COUNT = "Stopped due to breakpoint and ignore count"
145
146 STOPPED_DUE_TO_BREAKPOINT_JITTED_CONDITION = "Stopped due to breakpoint jitted condition"
147
148 STOPPED_DUE_TO_SIGNAL = "Process state is stopped due to signal"
149
150 STOPPED_DUE_TO_STEP_IN = "Process state is stopped due to step in"
151
152 STOPPED_DUE_TO_WATCHPOINT = "Process should be stopped due to watchpoint"
153
154 DATA_TYPES_DISPLAYED_CORRECTLY = "Data type(s) displayed correctly"
155
156 VALID_BREAKPOINT = "Got a valid breakpoint"
157
158 VALID_BREAKPOINT_LOCATION = "Got a valid breakpoint location"
159
160 VALID_COMMAND_INTERPRETER = "Got a valid command interpreter"
161
162 VALID_FILESPEC = "Got a valid filespec"
163
164 VALID_MODULE = "Got a valid module"
165
166 VALID_PROCESS = "Got a valid process"
167
168 VALID_SYMBOL = "Got a valid symbol"
169
170 VALID_TARGET = "Got a valid target"
171
172 VALID_PLATFORM = "Got a valid platform"
173
174 VALID_TYPE = "Got a valid type"
175
176 VALID_VARIABLE = "Got a valid variable"
177
178 VARIABLES_DISPLAYED_CORRECTLY = "Variable(s) displayed correctly"
179
180 WATCHPOINT_CREATED = "Watchpoint created successfully"
181
182
183 def CMD_MSG(str):
184     '''A generic "Command '%s' did not return successfully" message generator.'''
185     return "Command '%s' did not return successfully" % str
186
187
188 def COMPLETION_MSG(str_before, str_after, completions):
189     '''A generic assertion failed message generator for the completion mechanism.'''
190     return ("'%s' successfully completes to '%s', but completions were:\n%s"
191            % (str_before, str_after, "\n".join(completions)))
192
193
194 def EXP_MSG(str, actual, exe):
195     '''A generic "'%s' returned unexpected result" message generator if exe.
196     Otherwise, it generates "'%s' does not match expected result" message.'''
197
198     return "'%s' %s result, got '%s'" % (
199         str, 'returned unexpected' if exe else 'does not match expected', actual.strip())
200
201
202 def SETTING_MSG(setting):
203     '''A generic "Value of setting '%s' is not correct" message generator.'''
204     return "Value of setting '%s' is not correct" % setting
205
206
207 def line_number(filename, string_to_match):
208     """Helper function to return the line number of the first matched string."""
209     with io.open(filename, mode='r', encoding="utf-8") as f:
210         for i, line in enumerate(f):
211             if line.find(string_to_match) != -1:
212                 # Found our match.
213                 return i + 1
214     raise Exception(
215         "Unable to find '%s' within file %s" %
216         (string_to_match, filename))
217
218 def get_line(filename, line_number):
219     """Return the text of the line at the 1-based line number."""
220     with io.open(filename, mode='r', encoding="utf-8") as f:
221         return f.readlines()[line_number - 1]
222
223 def pointer_size():
224     """Return the pointer size of the host system."""
225     import ctypes
226     a_pointer = ctypes.c_void_p(0xffff)
227     return 8 * ctypes.sizeof(a_pointer)
228
229
230 def is_exe(fpath):
231     """Returns true if fpath is an executable."""
232     return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
233
234
235 def which(program):
236     """Returns the full path to a program; None otherwise."""
237     fpath, fname = os.path.split(program)
238     if fpath:
239         if is_exe(program):
240             return program
241     else:
242         for path in os.environ["PATH"].split(os.pathsep):
243             exe_file = os.path.join(path, program)
244             if is_exe(exe_file):
245                 return exe_file
246     return None
247
248 class ValueCheck:
249     def __init__(self, name=None, value=None, type=None, summary=None,
250                  children=None):
251         """
252         :param name: The name that the SBValue should have. None if the summary
253                      should not be checked.
254         :param summary: The summary that the SBValue should have. None if the
255                         summary should not be checked.
256         :param value: The value that the SBValue should have. None if the value
257                       should not be checked.
258         :param type: The type that the SBValue result should have. None if the
259                      type should not be checked.
260         :param children: A list of ValueChecks that need to match the children
261                          of this SBValue. None if children shouldn't be checked.
262                          The order of checks is the order of the checks in the
263                          list. The number of checks has to match the number of
264                          children.
265         """
266         self.expect_name = name
267         self.expect_value = value
268         self.expect_type = type
269         self.expect_summary = summary
270         self.children = children
271
272     def check_value(self, test_base, val, error_msg=None):
273         """
274         Checks that the given value matches the currently set properties
275         of this ValueCheck. If a match failed, the given TestBase will
276         be used to emit an error. A custom error message can be specified
277         that will be used to describe failed check for this SBValue (but
278         not errors in the child values).
279         """
280
281         this_error_msg = error_msg if error_msg else ""
282         this_error_msg += "\nChecking SBValue: " + str(val)
283
284         test_base.assertSuccess(val.GetError())
285
286         if self.expect_name:
287             test_base.assertEqual(self.expect_name, val.GetName(),
288                                   this_error_msg)
289         if self.expect_value:
290             test_base.assertEqual(self.expect_value, val.GetValue(),
291                                   this_error_msg)
292         if self.expect_type:
293             test_base.assertEqual(self.expect_type, val.GetDisplayTypeName(),
294                                   this_error_msg)
295         if self.expect_summary:
296             test_base.assertEqual(self.expect_summary, val.GetSummary(),
297                                   this_error_msg)
298         if self.children is not None:
299             self.check_value_children(test_base, val, error_msg)
300
301     def check_value_children(self, test_base, val, error_msg=None):
302         """
303         Checks that the children of a SBValue match a certain structure and
304         have certain properties.
305
306         :param test_base: The current test's TestBase object.
307         :param val: The SBValue to check.
308         """
309
310         this_error_msg = error_msg if error_msg else ""
311         this_error_msg += "\nChecking SBValue: " + str(val)
312
313         test_base.assertEqual(len(self.children), val.GetNumChildren(), this_error_msg)
314
315         for i in range(0, val.GetNumChildren()):
316             expected_child = self.children[i]
317             actual_child = val.GetChildAtIndex(i)
318             expected_child.check_value(test_base, actual_child, error_msg)
319
320 class recording(SixStringIO):
321     """
322     A nice little context manager for recording the debugger interactions into
323     our session object.  If trace flag is ON, it also emits the interactions
324     into the stderr.
325     """
326
327     def __init__(self, test, trace):
328         """Create a SixStringIO instance; record the session obj and trace flag."""
329         SixStringIO.__init__(self)
330         # The test might not have undergone the 'setUp(self)' phase yet, so that
331         # the attribute 'session' might not even exist yet.
332         self.session = getattr(test, "session", None) if test else None
333         self.trace = trace
334
335     def __enter__(self):
336         """
337         Context management protocol on entry to the body of the with statement.
338         Just return the SixStringIO object.
339         """
340         return self
341
342     def __exit__(self, type, value, tb):
343         """
344         Context management protocol on exit from the body of the with statement.
345         If trace is ON, it emits the recordings into stderr.  Always add the
346         recordings to our session object.  And close the SixStringIO object, too.
347         """
348         if self.trace:
349             print(self.getvalue(), file=sys.stderr)
350         if self.session:
351             print(self.getvalue(), file=self.session)
352         self.close()
353
354
355 @add_metaclass(abc.ABCMeta)
356 class _BaseProcess(object):
357
358     @abc.abstractproperty
359     def pid(self):
360         """Returns process PID if has been launched already."""
361
362     @abc.abstractmethod
363     def launch(self, executable, args):
364         """Launches new process with given executable and args."""
365
366     @abc.abstractmethod
367     def terminate(self):
368         """Terminates previously launched process.."""
369
370
371 class _LocalProcess(_BaseProcess):
372
373     def __init__(self, trace_on):
374         self._proc = None
375         self._trace_on = trace_on
376         self._delayafterterminate = 0.1
377
378     @property
379     def pid(self):
380         return self._proc.pid
381
382     def launch(self, executable, args):
383         self._proc = Popen(
384             [executable] + args,
385             stdout=open(
386                 os.devnull) if not self._trace_on else None,
387             stdin=PIPE,
388             preexec_fn=lldbplatformutil.enable_attach)
389
390     def terminate(self):
391         if self._proc.poll() is None:
392             # Terminate _proc like it does the pexpect
393             signals_to_try = [
394                 sig for sig in [
395                     'SIGHUP',
396                     'SIGCONT',
397                     'SIGINT'] if sig in dir(signal)]
398             for sig in signals_to_try:
399                 try:
400                     self._proc.send_signal(getattr(signal, sig))
401                     time.sleep(self._delayafterterminate)
402                     if self._proc.poll() is not None:
403                         return
404                 except ValueError:
405                     pass  # Windows says SIGINT is not a valid signal to send
406             self._proc.terminate()
407             time.sleep(self._delayafterterminate)
408             if self._proc.poll() is not None:
409                 return
410             self._proc.kill()
411             time.sleep(self._delayafterterminate)
412
413     def poll(self):
414         return self._proc.poll()
415
416
417 class _RemoteProcess(_BaseProcess):
418
419     def __init__(self, install_remote):
420         self._pid = None
421         self._install_remote = install_remote
422
423     @property
424     def pid(self):
425         return self._pid
426
427     def launch(self, executable, args):
428         if self._install_remote:
429             src_path = executable
430             dst_path = lldbutil.join_remote_paths(
431                     lldb.remote_platform.GetWorkingDirectory(), os.path.basename(executable))
432
433             dst_file_spec = lldb.SBFileSpec(dst_path, False)
434             err = lldb.remote_platform.Install(
435                 lldb.SBFileSpec(src_path, True), dst_file_spec)
436             if err.Fail():
437                 raise Exception(
438                     "remote_platform.Install('%s', '%s') failed: %s" %
439                     (src_path, dst_path, err))
440         else:
441             dst_path = executable
442             dst_file_spec = lldb.SBFileSpec(executable, False)
443
444         launch_info = lldb.SBLaunchInfo(args)
445         launch_info.SetExecutableFile(dst_file_spec, True)
446         launch_info.SetWorkingDirectory(
447             lldb.remote_platform.GetWorkingDirectory())
448
449         # Redirect stdout and stderr to /dev/null
450         launch_info.AddSuppressFileAction(1, False, True)
451         launch_info.AddSuppressFileAction(2, False, True)
452
453         err = lldb.remote_platform.Launch(launch_info)
454         if err.Fail():
455             raise Exception(
456                 "remote_platform.Launch('%s', '%s') failed: %s" %
457                 (dst_path, args, err))
458         self._pid = launch_info.GetProcessID()
459
460     def terminate(self):
461         lldb.remote_platform.Kill(self._pid)
462
463 # From 2.7's subprocess.check_output() convenience function.
464 # Return a tuple (stdoutdata, stderrdata).
465
466
467 def system(commands, **kwargs):
468     r"""Run an os command with arguments and return its output as a byte string.
469
470     If the exit code was non-zero it raises a CalledProcessError.  The
471     CalledProcessError object will have the return code in the returncode
472     attribute and output in the output attribute.
473
474     The arguments are the same as for the Popen constructor.  Example:
475
476     >>> check_output(["ls", "-l", "/dev/null"])
477     'crw-rw-rw- 1 root root 1, 3 Oct 18  2007 /dev/null\n'
478
479     The stdout argument is not allowed as it is used internally.
480     To capture standard error in the result, use stderr=STDOUT.
481
482     >>> check_output(["/bin/sh", "-c",
483     ...               "ls -l non_existent_file ; exit 0"],
484     ...              stderr=STDOUT)
485     'ls: non_existent_file: No such file or directory\n'
486     """
487
488     # Assign the sender object to variable 'test' and remove it from kwargs.
489     test = kwargs.pop('sender', None)
490
491     # [['make', 'clean', 'foo'], ['make', 'foo']] -> ['make clean foo', 'make foo']
492     commandList = [' '.join(x) for x in commands]
493     output = ""
494     error = ""
495     for shellCommand in commandList:
496         if 'stdout' in kwargs:
497             raise ValueError(
498                 'stdout argument not allowed, it will be overridden.')
499         if 'shell' in kwargs and kwargs['shell'] == False:
500             raise ValueError('shell=False not allowed')
501         process = Popen(
502             shellCommand,
503             stdout=PIPE,
504             stderr=STDOUT,
505             shell=True,
506             **kwargs)
507         pid = process.pid
508         this_output, this_error = process.communicate()
509         retcode = process.poll()
510
511         if retcode:
512             cmd = kwargs.get("args")
513             if cmd is None:
514                 cmd = shellCommand
515             cpe = CalledProcessError(retcode, cmd)
516             # Ensure caller can access the stdout/stderr.
517             cpe.lldb_extensions = {
518                 "combined_output": this_output,
519                 "command": shellCommand
520             }
521             raise cpe
522         output = output + this_output.decode("utf-8", errors='ignore')
523     return output
524
525
526 def getsource_if_available(obj):
527     """
528     Return the text of the source code for an object if available.  Otherwise,
529     a print representation is returned.
530     """
531     import inspect
532     try:
533         return inspect.getsource(obj)
534     except:
535         return repr(obj)
536
537
538 def builder_module():
539     return get_builder(sys.platform)
540
541
542 class Base(unittest2.TestCase):
543     """
544     Abstract base for performing lldb (see TestBase) or other generic tests (see
545     BenchBase for one example).  lldbtest.Base works with the test driver to
546     accomplish things.
547
548     """
549
550     # The concrete subclass should override this attribute.
551     mydir = None
552
553     # Keep track of the old current working directory.
554     oldcwd = None
555
556     @staticmethod
557     def compute_mydir(test_file):
558         '''Subclasses should call this function to correctly calculate the
559            required "mydir" attribute as follows:
560
561             mydir = TestBase.compute_mydir(__file__)
562         '''
563         # /abs/path/to/packages/group/subdir/mytest.py -> group/subdir
564         lldb_test_src = configuration.test_src_root
565         if not test_file.startswith(lldb_test_src):
566           raise Exception(
567               "Test file '%s' must reside within lldb_test_src "
568               "(which is '%s')." % (test_file, lldb_test_src))
569         return os.path.dirname(os.path.relpath(test_file, start=lldb_test_src))
570
571     def TraceOn(self):
572         """Returns True if we are in trace mode (tracing detailed test execution)."""
573         return traceAlways
574
575     def trace(self, *args,**kwargs):
576         with recording(self, self.TraceOn()) as sbuf:
577             print(*args, file=sbuf, **kwargs)
578
579     @classmethod
580     def setUpClass(cls):
581         """
582         Python unittest framework class setup fixture.
583         Do current directory manipulation.
584         """
585         # Fail fast if 'mydir' attribute is not overridden.
586         if not cls.mydir or len(cls.mydir) == 0:
587             raise Exception("Subclasses must override the 'mydir' attribute.")
588
589         # Save old working directory.
590         cls.oldcwd = os.getcwd()
591
592         full_dir = os.path.join(configuration.test_src_root, cls.mydir)
593         if traceAlways:
594             print("Change dir to:", full_dir, file=sys.stderr)
595         os.chdir(full_dir)
596         lldb.SBReproducer.SetWorkingDirectory(full_dir)
597
598         # Set platform context.
599         cls.platformContext = lldbplatformutil.createPlatformContext()
600
601     @classmethod
602     def tearDownClass(cls):
603         """
604         Python unittest framework class teardown fixture.
605         Do class-wide cleanup.
606         """
607
608         if doCleanup:
609             # First, let's do the platform-specific cleanup.
610             module = builder_module()
611             module.cleanup()
612
613             # Subclass might have specific cleanup function defined.
614             if getattr(cls, "classCleanup", None):
615                 if traceAlways:
616                     print(
617                         "Call class-specific cleanup function for class:",
618                         cls,
619                         file=sys.stderr)
620                 try:
621                     cls.classCleanup()
622                 except:
623                     exc_type, exc_value, exc_tb = sys.exc_info()
624                     traceback.print_exception(exc_type, exc_value, exc_tb)
625
626         # Restore old working directory.
627         if traceAlways:
628             print("Restore dir to:", cls.oldcwd, file=sys.stderr)
629         os.chdir(cls.oldcwd)
630
631     def enableLogChannelsForCurrentTest(self):
632         if len(lldbtest_config.channels) == 0:
633             return
634
635         # if debug channels are specified in lldbtest_config.channels,
636         # create a new set of log files for every test
637         log_basename = self.getLogBasenameForCurrentTest()
638
639         # confirm that the file is writeable
640         host_log_path = "{}-host.log".format(log_basename)
641         open(host_log_path, 'w').close()
642         self.log_files.append(host_log_path)
643
644         log_enable = "log enable -Tpn -f {} ".format(host_log_path)
645         for channel_with_categories in lldbtest_config.channels:
646             channel_then_categories = channel_with_categories.split(' ', 1)
647             channel = channel_then_categories[0]
648             if len(channel_then_categories) > 1:
649                 categories = channel_then_categories[1]
650             else:
651                 categories = "default"
652
653             if channel == "gdb-remote" and lldb.remote_platform is None:
654                 # communicate gdb-remote categories to debugserver
655                 os.environ["LLDB_DEBUGSERVER_LOG_FLAGS"] = categories
656
657             self.ci.HandleCommand(
658                 log_enable + channel_with_categories, self.res)
659             if not self.res.Succeeded():
660                 raise Exception(
661                     'log enable failed (check LLDB_LOG_OPTION env variable)')
662
663         # Communicate log path name to debugserver & lldb-server
664         # For remote debugging, these variables need to be set when starting the platform
665         # instance.
666         if lldb.remote_platform is None:
667             server_log_path = "{}-server.log".format(log_basename)
668             open(server_log_path, 'w').close()
669             self.log_files.append(server_log_path)
670             os.environ["LLDB_DEBUGSERVER_LOG_FILE"] = server_log_path
671
672             # Communicate channels to lldb-server
673             os.environ["LLDB_SERVER_LOG_CHANNELS"] = ":".join(
674                 lldbtest_config.channels)
675
676         self.addTearDownHook(self.disableLogChannelsForCurrentTest)
677
678     def disableLogChannelsForCurrentTest(self):
679         # close all log files that we opened
680         for channel_and_categories in lldbtest_config.channels:
681             # channel format - <channel-name> [<category0> [<category1> ...]]
682             channel = channel_and_categories.split(' ', 1)[0]
683             self.ci.HandleCommand("log disable " + channel, self.res)
684             if not self.res.Succeeded():
685                 raise Exception(
686                     'log disable failed (check LLDB_LOG_OPTION env variable)')
687
688         # Retrieve the server log (if any) from the remote system. It is assumed the server log
689         # is writing to the "server.log" file in the current test directory. This can be
690         # achieved by setting LLDB_DEBUGSERVER_LOG_FILE="server.log" when starting remote
691         # platform.
692         if lldb.remote_platform:
693             server_log_path = self.getLogBasenameForCurrentTest() + "-server.log"
694             if lldb.remote_platform.Get(
695                 lldb.SBFileSpec("server.log"),
696                 lldb.SBFileSpec(server_log_path)).Success():
697                 self.log_files.append(server_log_path)
698
699     def setPlatformWorkingDir(self):
700         if not lldb.remote_platform or not configuration.lldb_platform_working_dir:
701             return
702
703         components = self.mydir.split(os.path.sep) + [str(self.test_number), self.getBuildDirBasename()]
704         remote_test_dir = configuration.lldb_platform_working_dir
705         for c in components:
706             remote_test_dir = lldbutil.join_remote_paths(remote_test_dir, c)
707             error = lldb.remote_platform.MakeDirectory(
708                 remote_test_dir, 448)  # 448 = 0o700
709             if error.Fail():
710                 raise Exception("making remote directory '%s': %s" % (
711                     remote_test_dir, error))
712
713         lldb.remote_platform.SetWorkingDirectory(remote_test_dir)
714
715         # This function removes all files from the current working directory while leaving
716         # the directories in place. The cleanup is required to reduce the disk space required
717         # by the test suite while leaving the directories untouched is neccessary because
718         # sub-directories might belong to an other test
719         def clean_working_directory():
720             # TODO: Make it working on Windows when we need it for remote debugging support
721             # TODO: Replace the heuristic to remove the files with a logic what collects the
722             # list of files we have to remove during test runs.
723             shell_cmd = lldb.SBPlatformShellCommand(
724                 "rm %s/*" % remote_test_dir)
725             lldb.remote_platform.Run(shell_cmd)
726         self.addTearDownHook(clean_working_directory)
727
728     def getSourceDir(self):
729         """Return the full path to the current test."""
730         return os.path.join(configuration.test_src_root, self.mydir)
731
732     def getBuildDirBasename(self):
733         return self.__class__.__module__ + "." + self.testMethodName
734
735     def getBuildDir(self):
736         """Return the full path to the current test."""
737         return os.path.join(configuration.test_build_dir, self.mydir,
738                             self.getBuildDirBasename())
739
740     def getReproducerDir(self):
741         """Return the full path to the reproducer if enabled."""
742         if configuration.capture_path:
743             return configuration.capture_path
744         if configuration.replay_path:
745             return configuration.replay_path
746         return None
747
748     def makeBuildDir(self):
749         """Create the test-specific working directory, deleting any previous
750         contents."""
751         bdir = self.getBuildDir()
752         if os.path.isdir(bdir):
753             shutil.rmtree(bdir)
754         lldbutil.mkdir_p(bdir)
755
756     def getBuildArtifact(self, name="a.out"):
757         """Return absolute path to an artifact in the test's build directory."""
758         return os.path.join(self.getBuildDir(), name)
759
760     def getSourcePath(self, name):
761         """Return absolute path to a file in the test's source directory."""
762         return os.path.join(self.getSourceDir(), name)
763
764     def getReproducerArtifact(self, name):
765         lldbutil.mkdir_p(self.getReproducerDir())
766         return os.path.join(self.getReproducerDir(), name)
767
768     def getReproducerRemappedPath(self, path):
769         assert configuration.replay_path
770         assert os.path.isabs(path)
771         path = os.path.relpath(path, '/')
772         return os.path.join(configuration.replay_path, 'root', path)
773
774     @classmethod
775     def setUpCommands(cls):
776         commands = [
777             # First of all, clear all settings to have clean state of global properties.
778             "settings clear -all",
779
780             # Disable Spotlight lookup. The testsuite creates
781             # different binaries with the same UUID, because they only
782             # differ in the debug info, which is not being hashed.
783             "settings set symbols.enable-external-lookup false",
784
785             # Inherit the TCC permissions from the inferior's parent.
786             "settings set target.inherit-tcc true",
787
788             # Kill rather than detach from the inferior if something goes wrong.
789             "settings set target.detach-on-error false",
790
791             # Disable fix-its by default so that incorrect expressions in tests don't
792             # pass just because Clang thinks it has a fix-it.
793             "settings set target.auto-apply-fixits false",
794
795             # Testsuite runs in parallel and the host can have also other load.
796             "settings set plugin.process.gdb-remote.packet-timeout 60",
797
798             'settings set symbols.clang-modules-cache-path "{}"'.format(
799                 configuration.lldb_module_cache_dir),
800             "settings set use-color false",
801         ]
802
803         # Set any user-overridden settings.
804         for setting, value in configuration.settings:
805             commands.append('setting set %s %s'%(setting, value))
806
807         # Make sure that a sanitizer LLDB's environment doesn't get passed on.
808         if cls.platformContext and cls.platformContext.shlib_environment_var in os.environ:
809             commands.append('settings set target.env-vars {}='.format(
810                 cls.platformContext.shlib_environment_var))
811
812         # Set environment variables for the inferior.
813         if lldbtest_config.inferior_env:
814             commands.append('settings set target.env-vars {}'.format(
815                 lldbtest_config.inferior_env))
816         return commands
817
818     def setUp(self):
819         """Fixture for unittest test case setup.
820
821         It works with the test driver to conditionally skip tests and does other
822         initializations."""
823         #import traceback
824         # traceback.print_stack()
825
826         if "LIBCXX_PATH" in os.environ:
827             self.libcxxPath = os.environ["LIBCXX_PATH"]
828         else:
829             self.libcxxPath = None
830
831         if "LLDBVSCODE_EXEC" in os.environ:
832             self.lldbVSCodeExec = os.environ["LLDBVSCODE_EXEC"]
833         else:
834             self.lldbVSCodeExec = None
835
836         self.lldbOption = " ".join(
837             "-o '" + s + "'" for s in self.setUpCommands())
838
839         # If we spawn an lldb process for test (via pexpect), do not load the
840         # init file unless told otherwise.
841         if os.environ.get("NO_LLDBINIT") != "NO":
842             self.lldbOption += " --no-lldbinit"
843
844         # Assign the test method name to self.testMethodName.
845         #
846         # For an example of the use of this attribute, look at test/types dir.
847         # There are a bunch of test cases under test/types and we don't want the
848         # module cacheing subsystem to be confused with executable name "a.out"
849         # used for all the test cases.
850         self.testMethodName = self._testMethodName
851
852         # This is for the case of directly spawning 'lldb'/'gdb' and interacting
853         # with it using pexpect.
854         self.child = None
855         self.child_prompt = "(lldb) "
856         # If the child is interacting with the embedded script interpreter,
857         # there are two exits required during tear down, first to quit the
858         # embedded script interpreter and second to quit the lldb command
859         # interpreter.
860         self.child_in_script_interpreter = False
861
862         # These are for customized teardown cleanup.
863         self.dict = None
864         self.doTearDownCleanup = False
865         # And in rare cases where there are multiple teardown cleanups.
866         self.dicts = []
867         self.doTearDownCleanups = False
868
869         # List of spawned subproces.Popen objects
870         self.subprocesses = []
871
872         # List of log files produced by the current test.
873         self.log_files = []
874
875         # Create the build directory.
876         # The logs are stored in the build directory, so we have to create it
877         # before creating the first log file.
878         self.makeBuildDir()
879
880         session_file = self.getLogBasenameForCurrentTest()+".log"
881         self.log_files.append(session_file)
882
883         # Python 3 doesn't support unbuffered I/O in text mode.  Open buffered.
884         self.session = encoded_file.open(session_file, "utf-8", mode="w")
885
886         # Optimistically set __errored__, __failed__, __expected__ to False
887         # initially.  If the test errored/failed, the session info
888         # (self.session) is then dumped into a session specific file for
889         # diagnosis.
890         self.__cleanup_errored__ = False
891         self.__errored__ = False
892         self.__failed__ = False
893         self.__expected__ = False
894         # We are also interested in unexpected success.
895         self.__unexpected__ = False
896         # And skipped tests.
897         self.__skipped__ = False
898
899         # See addTearDownHook(self, hook) which allows the client to add a hook
900         # function to be run during tearDown() time.
901         self.hooks = []
902
903         # See HideStdout(self).
904         self.sys_stdout_hidden = False
905
906         if self.platformContext:
907             # set environment variable names for finding shared libraries
908             self.dylibPath = self.platformContext.shlib_environment_var
909
910         # Create the debugger instance.
911         self.dbg = lldb.SBDebugger.Create()
912         # Copy selected platform from a global instance if it exists.
913         if lldb.selected_platform is not None:
914             self.dbg.SetSelectedPlatform(lldb.selected_platform)
915
916         if not self.dbg:
917             raise Exception('Invalid debugger instance')
918
919         # Retrieve the associated command interpreter instance.
920         self.ci = self.dbg.GetCommandInterpreter()
921         if not self.ci:
922             raise Exception('Could not get the command interpreter')
923
924         # And the result object.
925         self.res = lldb.SBCommandReturnObject()
926
927         self.setPlatformWorkingDir()
928         self.enableLogChannelsForCurrentTest()
929
930         self.lib_lldb = None
931         self.framework_dir = None
932         self.darwinWithFramework = False
933
934         if sys.platform.startswith("darwin") and configuration.lldb_framework_path:
935             framework = configuration.lldb_framework_path
936             lib = os.path.join(framework, 'LLDB')
937             if os.path.exists(lib):
938                 self.framework_dir = os.path.dirname(framework)
939                 self.lib_lldb = lib
940                 self.darwinWithFramework = self.platformIsDarwin()
941
942     def setAsync(self, value):
943         """ Sets async mode to True/False and ensures it is reset after the testcase completes."""
944         old_async = self.dbg.GetAsync()
945         self.dbg.SetAsync(value)
946         self.addTearDownHook(lambda: self.dbg.SetAsync(old_async))
947
948     def cleanupSubprocesses(self):
949         # Terminate subprocesses in reverse order from how they were created.
950         for p in reversed(self.subprocesses):
951             p.terminate()
952             del p
953         del self.subprocesses[:]
954
955     def spawnSubprocess(self, executable, args=[], install_remote=True):
956         """ Creates a subprocess.Popen object with the specified executable and arguments,
957             saves it in self.subprocesses, and returns the object.
958         """
959         proc = _RemoteProcess(
960             install_remote) if lldb.remote_platform else _LocalProcess(self.TraceOn())
961         proc.launch(executable, args)
962         self.subprocesses.append(proc)
963         return proc
964
965     def HideStdout(self):
966         """Hide output to stdout from the user.
967
968         During test execution, there might be cases where we don't want to show the
969         standard output to the user.  For example,
970
971             self.runCmd(r'''sc print("\n\n\tHello!\n")''')
972
973         tests whether command abbreviation for 'script' works or not.  There is no
974         need to show the 'Hello' output to the user as long as the 'script' command
975         succeeds and we are not in TraceOn() mode (see the '-t' option).
976
977         In this case, the test method calls self.HideStdout(self) to redirect the
978         sys.stdout to a null device, and restores the sys.stdout upon teardown.
979
980         Note that you should only call this method at most once during a test case
981         execution.  Any subsequent call has no effect at all."""
982         if self.sys_stdout_hidden:
983             return
984
985         self.sys_stdout_hidden = True
986         old_stdout = sys.stdout
987         sys.stdout = open(os.devnull, 'w')
988
989         def restore_stdout():
990             sys.stdout = old_stdout
991         self.addTearDownHook(restore_stdout)
992
993     # =======================================================================
994     # Methods for customized teardown cleanups as well as execution of hooks.
995     # =======================================================================
996
997     def setTearDownCleanup(self, dictionary=None):
998         """Register a cleanup action at tearDown() time with a dictionary"""
999         self.dict = dictionary
1000         self.doTearDownCleanup = True
1001
1002     def addTearDownCleanup(self, dictionary):
1003         """Add a cleanup action at tearDown() time with a dictionary"""
1004         self.dicts.append(dictionary)
1005         self.doTearDownCleanups = True
1006
1007     def addTearDownHook(self, hook):
1008         """
1009         Add a function to be run during tearDown() time.
1010
1011         Hooks are executed in a first come first serve manner.
1012         """
1013         if six.callable(hook):
1014             with recording(self, traceAlways) as sbuf:
1015                 print(
1016                     "Adding tearDown hook:",
1017                     getsource_if_available(hook),
1018                     file=sbuf)
1019             self.hooks.append(hook)
1020
1021         return self
1022
1023     def deletePexpectChild(self):
1024         # This is for the case of directly spawning 'lldb' and interacting with it
1025         # using pexpect.
1026         if self.child and self.child.isalive():
1027             import pexpect
1028             with recording(self, traceAlways) as sbuf:
1029                 print("tearing down the child process....", file=sbuf)
1030             try:
1031                 if self.child_in_script_interpreter:
1032                     self.child.sendline('quit()')
1033                     self.child.expect_exact(self.child_prompt)
1034                 self.child.sendline(
1035                     'settings set interpreter.prompt-on-quit false')
1036                 self.child.sendline('quit')
1037                 self.child.expect(pexpect.EOF)
1038             except (ValueError, pexpect.ExceptionPexpect):
1039                 # child is already terminated
1040                 pass
1041             except OSError as exception:
1042                 import errno
1043                 if exception.errno != errno.EIO:
1044                     # unexpected error
1045                     raise
1046                 # child is already terminated
1047             finally:
1048                 # Give it one final blow to make sure the child is terminated.
1049                 self.child.close()
1050
1051     def tearDown(self):
1052         """Fixture for unittest test case teardown."""
1053         self.deletePexpectChild()
1054
1055         # Check and run any hook functions.
1056         for hook in reversed(self.hooks):
1057             with recording(self, traceAlways) as sbuf:
1058                 print(
1059                     "Executing tearDown hook:",
1060                     getsource_if_available(hook),
1061                     file=sbuf)
1062             if funcutils.requires_self(hook):
1063                 hook(self)
1064             else:
1065                 hook()  # try the plain call and hope it works
1066
1067         del self.hooks
1068
1069         # Perform registered teardown cleanup.
1070         if doCleanup and self.doTearDownCleanup:
1071             self.cleanup(dictionary=self.dict)
1072
1073         # In rare cases where there are multiple teardown cleanups added.
1074         if doCleanup and self.doTearDownCleanups:
1075             if self.dicts:
1076                 for dict in reversed(self.dicts):
1077                     self.cleanup(dictionary=dict)
1078
1079         # Remove subprocesses created by the test.
1080         self.cleanupSubprocesses()
1081
1082         # This must be the last statement, otherwise teardown hooks or other
1083         # lines might depend on this still being active.
1084         lldb.SBDebugger.Destroy(self.dbg)
1085         del self.dbg
1086
1087         # All modules should be orphaned now so that they can be cleared from
1088         # the shared module cache.
1089         lldb.SBModule.GarbageCollectAllocatedModules()
1090
1091         # Modules are not orphaned during reproducer replay because they're
1092         # leaked on purpose.
1093         if not configuration.is_reproducer():
1094             # Assert that the global module cache is empty.
1095             self.assertEqual(lldb.SBModule.GetNumberAllocatedModules(), 0)
1096
1097
1098     # =========================================================
1099     # Various callbacks to allow introspection of test progress
1100     # =========================================================
1101
1102     def markError(self):
1103         """Callback invoked when an error (unexpected exception) errored."""
1104         self.__errored__ = True
1105         with recording(self, False) as sbuf:
1106             # False because there's no need to write "ERROR" to the stderr twice.
1107             # Once by the Python unittest framework, and a second time by us.
1108             print("ERROR", file=sbuf)
1109
1110     def markCleanupError(self):
1111         """Callback invoked when an error occurs while a test is cleaning up."""
1112         self.__cleanup_errored__ = True
1113         with recording(self, False) as sbuf:
1114             # False because there's no need to write "CLEANUP_ERROR" to the stderr twice.
1115             # Once by the Python unittest framework, and a second time by us.
1116             print("CLEANUP_ERROR", file=sbuf)
1117
1118     def markFailure(self):
1119         """Callback invoked when a failure (test assertion failure) occurred."""
1120         self.__failed__ = True
1121         with recording(self, False) as sbuf:
1122             # False because there's no need to write "FAIL" to the stderr twice.
1123             # Once by the Python unittest framework, and a second time by us.
1124             print("FAIL", file=sbuf)
1125
1126     def markExpectedFailure(self, err, bugnumber):
1127         """Callback invoked when an expected failure/error occurred."""
1128         self.__expected__ = True
1129         with recording(self, False) as sbuf:
1130             # False because there's no need to write "expected failure" to the
1131             # stderr twice.
1132             # Once by the Python unittest framework, and a second time by us.
1133             if bugnumber is None:
1134                 print("expected failure", file=sbuf)
1135             else:
1136                 print(
1137                     "expected failure (problem id:" + str(bugnumber) + ")",
1138                     file=sbuf)
1139
1140     def markSkippedTest(self):
1141         """Callback invoked when a test is skipped."""
1142         self.__skipped__ = True
1143         with recording(self, False) as sbuf:
1144             # False because there's no need to write "skipped test" to the
1145             # stderr twice.
1146             # Once by the Python unittest framework, and a second time by us.
1147             print("skipped test", file=sbuf)
1148
1149     def markUnexpectedSuccess(self, bugnumber):
1150         """Callback invoked when an unexpected success occurred."""
1151         self.__unexpected__ = True
1152         with recording(self, False) as sbuf:
1153             # False because there's no need to write "unexpected success" to the
1154             # stderr twice.
1155             # Once by the Python unittest framework, and a second time by us.
1156             if bugnumber is None:
1157                 print("unexpected success", file=sbuf)
1158             else:
1159                 print(
1160                     "unexpected success (problem id:" + str(bugnumber) + ")",
1161                     file=sbuf)
1162
1163     def getRerunArgs(self):
1164         return " -f %s.%s" % (self.__class__.__name__, self._testMethodName)
1165
1166     def getLogBasenameForCurrentTest(self, prefix="Incomplete"):
1167         """
1168         returns a partial path that can be used as the beginning of the name of multiple
1169         log files pertaining to this test
1170         """
1171         return os.path.join(self.getBuildDir(), prefix)
1172
1173     def dumpSessionInfo(self):
1174         """
1175         Dump the debugger interactions leading to a test error/failure.  This
1176         allows for more convenient postmortem analysis.
1177
1178         See also LLDBTestResult (dotest.py) which is a singlton class derived
1179         from TextTestResult and overwrites addError, addFailure, and
1180         addExpectedFailure methods to allow us to to mark the test instance as
1181         such.
1182         """
1183
1184         # We are here because self.tearDown() detected that this test instance
1185         # either errored or failed.  The lldb.test_result singleton contains
1186         # two lists (errors and failures) which get populated by the unittest
1187         # framework.  Look over there for stack trace information.
1188         #
1189         # The lists contain 2-tuples of TestCase instances and strings holding
1190         # formatted tracebacks.
1191         #
1192         # See http://docs.python.org/library/unittest.html#unittest.TestResult.
1193
1194         # output tracebacks into session
1195         pairs = []
1196         if self.__errored__:
1197             pairs = configuration.test_result.errors
1198             prefix = 'Error'
1199         elif self.__cleanup_errored__:
1200             pairs = configuration.test_result.cleanup_errors
1201             prefix = 'CleanupError'
1202         elif self.__failed__:
1203             pairs = configuration.test_result.failures
1204             prefix = 'Failure'
1205         elif self.__expected__:
1206             pairs = configuration.test_result.expectedFailures
1207             prefix = 'ExpectedFailure'
1208         elif self.__skipped__:
1209             prefix = 'SkippedTest'
1210         elif self.__unexpected__:
1211             prefix = 'UnexpectedSuccess'
1212         else:
1213             prefix = 'Success'
1214
1215         if not self.__unexpected__ and not self.__skipped__:
1216             for test, traceback in pairs:
1217                 if test is self:
1218                     print(traceback, file=self.session)
1219
1220         import datetime
1221         print(
1222             "Session info generated @",
1223             datetime.datetime.now().ctime(),
1224             file=self.session)
1225         self.session.close()
1226         del self.session
1227
1228         # process the log files
1229         if prefix != 'Success' or lldbtest_config.log_success:
1230             # keep all log files, rename them to include prefix
1231             src_log_basename = self.getLogBasenameForCurrentTest()
1232             dst_log_basename = self.getLogBasenameForCurrentTest(prefix)
1233             for src in self.log_files:
1234                 if os.path.isfile(src):
1235                     dst = src.replace(src_log_basename, dst_log_basename)
1236                     if os.name == "nt" and os.path.isfile(dst):
1237                         # On Windows, renaming a -> b will throw an exception if
1238                         # b exists.  On non-Windows platforms it silently
1239                         # replaces the destination.  Ultimately this means that
1240                         # atomic renames are not guaranteed to be possible on
1241                         # Windows, but we need this to work anyway, so just
1242                         # remove the destination first if it already exists.
1243                         remove_file(dst)
1244
1245                     lldbutil.mkdir_p(os.path.dirname(dst))
1246                     os.rename(src, dst)
1247         else:
1248             # success!  (and we don't want log files) delete log files
1249             for log_file in self.log_files:
1250                 if os.path.isfile(log_file):
1251                     remove_file(log_file)
1252
1253     # ====================================================
1254     # Config. methods supported through a plugin interface
1255     # (enables reading of the current test configuration)
1256     # ====================================================
1257
1258     def isMIPS(self):
1259         """Returns true if the architecture is MIPS."""
1260         arch = self.getArchitecture()
1261         if re.match("mips", arch):
1262             return True
1263         return False
1264
1265     def isPPC64le(self):
1266         """Returns true if the architecture is PPC64LE."""
1267         arch = self.getArchitecture()
1268         if re.match("powerpc64le", arch):
1269             return True
1270         return False
1271
1272     def isAArch64SVE(self):
1273         triple = self.dbg.GetSelectedPlatform().GetTriple()
1274
1275         # TODO other platforms, please implement this function
1276         if not re.match(".*-.*-linux", triple):
1277             return False
1278
1279         # Need to do something different for non-Linux/Android targets
1280         cpuinfo_path = self.getBuildArtifact("cpuinfo")
1281         if configuration.lldb_platform_name:
1282             self.runCmd('platform get-file "/proc/cpuinfo" ' + cpuinfo_path)
1283         else:
1284             cpuinfo_path = "/proc/cpuinfo"
1285
1286         try:
1287             f = open(cpuinfo_path, 'r')
1288             cpuinfo = f.read()
1289             f.close()
1290         except:
1291             return False
1292
1293         return " sve " in cpuinfo
1294
1295     def hasLinuxVmFlags(self):
1296         """ Check that the target machine has "VmFlags" lines in
1297         its /proc/{pid}/smaps files."""
1298
1299         triple = self.dbg.GetSelectedPlatform().GetTriple()
1300         if not re.match(".*-.*-linux", triple):
1301             return False
1302
1303         self.runCmd('platform process list')
1304         pid = None
1305         for line in self.res.GetOutput().splitlines():
1306             if 'lldb-server' in line:
1307                 pid = line.split(' ')[0]
1308                 break
1309
1310         if pid is None:
1311             return False
1312
1313         smaps_path = self.getBuildArtifact('smaps')
1314         self.runCmd('platform get-file "/proc/{}/smaps" {}'.format(pid, smaps_path))
1315
1316         with open(smaps_path, 'r') as f:
1317             return "VmFlags" in f.read()
1318
1319     def getArchitecture(self):
1320         """Returns the architecture in effect the test suite is running with."""
1321         module = builder_module()
1322         arch = module.getArchitecture()
1323         if arch == 'amd64':
1324             arch = 'x86_64'
1325         if arch in ['armv7l', 'armv8l'] :
1326             arch = 'arm'
1327         return arch
1328
1329     def getLldbArchitecture(self):
1330         """Returns the architecture of the lldb binary."""
1331         if not hasattr(self, 'lldbArchitecture'):
1332
1333             # spawn local process
1334             command = [
1335                 lldbtest_config.lldbExec,
1336                 "-o",
1337                 "file " + lldbtest_config.lldbExec,
1338                 "-o",
1339                 "quit"
1340             ]
1341
1342             output = check_output(command)
1343             str = output.decode("utf-8")
1344
1345             for line in str.splitlines():
1346                 m = re.search(
1347                     "Current executable set to '.*' \\((.*)\\)\\.", line)
1348                 if m:
1349                     self.lldbArchitecture = m.group(1)
1350                     break
1351
1352         return self.lldbArchitecture
1353
1354     def getCompiler(self):
1355         """Returns the compiler in effect the test suite is running with."""
1356         module = builder_module()
1357         return module.getCompiler()
1358
1359     def getCompilerBinary(self):
1360         """Returns the compiler binary the test suite is running with."""
1361         return self.getCompiler().split()[0]
1362
1363     def getCompilerVersion(self):
1364         """ Returns a string that represents the compiler version.
1365             Supports: llvm, clang.
1366         """
1367         compiler = self.getCompilerBinary()
1368         version_output = system([[compiler, "--version"]])
1369         for line in version_output.split(os.linesep):
1370             m = re.search('version ([0-9.]+)', line)
1371             if m:
1372                 return m.group(1)
1373         return 'unknown'
1374
1375     def getDwarfVersion(self):
1376         """ Returns the dwarf version generated by clang or '0'. """
1377         if configuration.dwarf_version:
1378             return str(configuration.dwarf_version)
1379         if 'clang' in self.getCompiler():
1380             try:
1381                 driver_output = check_output(
1382                     [self.getCompiler()] + '-g -c -x c - -o - -###'.split(),
1383                     stderr=STDOUT)
1384                 driver_output = driver_output.decode("utf-8")
1385                 for line in driver_output.split(os.linesep):
1386                     m = re.search('dwarf-version=([0-9])', line)
1387                     if m:
1388                         return m.group(1)
1389             except: pass
1390         return '0'
1391
1392     def platformIsDarwin(self):
1393         """Returns true if the OS triple for the selected platform is any valid apple OS"""
1394         return lldbplatformutil.platformIsDarwin()
1395
1396     def hasDarwinFramework(self):
1397         return self.darwinWithFramework
1398
1399     def getPlatform(self):
1400         """Returns the target platform the test suite is running on."""
1401         return lldbplatformutil.getPlatform()
1402
1403     def isIntelCompiler(self):
1404         """ Returns true if using an Intel (ICC) compiler, false otherwise. """
1405         return any([x in self.getCompiler() for x in ["icc", "icpc", "icl"]])
1406
1407     def expectedCompilerVersion(self, compiler_version):
1408         """Returns True iff compiler_version[1] matches the current compiler version.
1409            Use compiler_version[0] to specify the operator used to determine if a match has occurred.
1410            Any operator other than the following defaults to an equality test:
1411              '>', '>=', "=>", '<', '<=', '=<', '!=', "!" or 'not'
1412
1413            If the current compiler version cannot be determined, we assume it is close to the top
1414            of trunk, so any less-than or equal-to comparisons will return False, and any
1415            greater-than or not-equal-to comparisons will return True.
1416         """
1417         if compiler_version is None:
1418             return True
1419         operator = str(compiler_version[0])
1420         version = compiler_version[1]
1421
1422         if version is None:
1423             return True
1424
1425         test_compiler_version = self.getCompilerVersion()
1426         if test_compiler_version == 'unknown':
1427             # Assume the compiler version is at or near the top of trunk.
1428             return operator in ['>', '>=', '!', '!=', 'not']
1429
1430         if operator == '>':
1431             return LooseVersion(test_compiler_version) > LooseVersion(version)
1432         if operator == '>=' or operator == '=>':
1433             return LooseVersion(test_compiler_version) >= LooseVersion(version)
1434         if operator == '<':
1435             return LooseVersion(test_compiler_version) < LooseVersion(version)
1436         if operator == '<=' or operator == '=<':
1437             return LooseVersion(test_compiler_version) <= LooseVersion(version)
1438         if operator == '!=' or operator == '!' or operator == 'not':
1439             return str(version) not in str(test_compiler_version)
1440         return str(version) in str(test_compiler_version)
1441
1442     def expectedCompiler(self, compilers):
1443         """Returns True iff any element of compilers is a sub-string of the current compiler."""
1444         if (compilers is None):
1445             return True
1446
1447         for compiler in compilers:
1448             if compiler in self.getCompiler():
1449                 return True
1450
1451         return False
1452
1453     def expectedArch(self, archs):
1454         """Returns True iff any element of archs is a sub-string of the current architecture."""
1455         if (archs is None):
1456             return True
1457
1458         for arch in archs:
1459             if arch in self.getArchitecture():
1460                 return True
1461
1462         return False
1463
1464     def getRunOptions(self):
1465         """Command line option for -A and -C to run this test again, called from
1466         self.dumpSessionInfo()."""
1467         arch = self.getArchitecture()
1468         comp = self.getCompiler()
1469         option_str = ""
1470         if arch:
1471             option_str = "-A " + arch
1472         if comp:
1473             option_str += " -C " + comp
1474         return option_str
1475
1476     def getDebugInfo(self):
1477         method = getattr(self, self.testMethodName)
1478         return getattr(method, "debug_info", None)
1479
1480     # ==================================================
1481     # Build methods supported through a plugin interface
1482     # ==================================================
1483
1484     def getstdlibFlag(self):
1485         """ Returns the proper -stdlib flag, or empty if not required."""
1486         if self.platformIsDarwin() or self.getPlatform() == "freebsd" or self.getPlatform() == "openbsd":
1487             stdlibflag = "-stdlib=libc++"
1488         else:  # this includes NetBSD
1489             stdlibflag = ""
1490         return stdlibflag
1491
1492     def getstdFlag(self):
1493         """ Returns the proper stdflag. """
1494         if "gcc" in self.getCompiler() and "4.6" in self.getCompilerVersion():
1495             stdflag = "-std=c++0x"
1496         else:
1497             stdflag = "-std=c++11"
1498         return stdflag
1499
1500     def buildDriver(self, sources, exe_name):
1501         """ Platform-specific way to build a program that links with LLDB (via the liblldb.so
1502             or LLDB.framework).
1503         """
1504         stdflag = self.getstdFlag()
1505         stdlibflag = self.getstdlibFlag()
1506
1507         lib_dir = configuration.lldb_libs_dir
1508         if self.hasDarwinFramework():
1509             d = {'CXX_SOURCES': sources,
1510                  'EXE': exe_name,
1511                  'CFLAGS_EXTRAS': "%s %s" % (stdflag, stdlibflag),
1512                  'FRAMEWORK_INCLUDES': "-F%s" % self.framework_dir,
1513                  'LD_EXTRAS': "%s -Wl,-rpath,%s" % (self.lib_lldb, self.framework_dir),
1514                  }
1515         elif sys.platform.startswith('win'):
1516             d = {
1517                 'CXX_SOURCES': sources,
1518                 'EXE': exe_name,
1519                 'CFLAGS_EXTRAS': "%s %s -I%s" % (stdflag,
1520                                                  stdlibflag,
1521                                                  os.path.join(
1522                                                      os.environ["LLDB_SRC"],
1523                                                      "include")),
1524                 'LD_EXTRAS': "-L%s -lliblldb" % lib_dir}
1525         else:
1526             d = {
1527                 'CXX_SOURCES': sources,
1528                 'EXE': exe_name,
1529                 'CFLAGS_EXTRAS': "%s %s -I%s" % (stdflag,
1530                                                  stdlibflag,
1531                                                  os.path.join(
1532                                                      os.environ["LLDB_SRC"],
1533                                                      "include")),
1534                 'LD_EXTRAS': "-L%s -llldb -Wl,-rpath,%s" % (lib_dir, lib_dir)}
1535         if self.TraceOn():
1536             print(
1537                 "Building LLDB Driver (%s) from sources %s" %
1538                 (exe_name, sources))
1539
1540         self.buildDefault(dictionary=d)
1541
1542     def buildLibrary(self, sources, lib_name):
1543         """Platform specific way to build a default library. """
1544
1545         stdflag = self.getstdFlag()
1546
1547         lib_dir = configuration.lldb_libs_dir
1548         if self.hasDarwinFramework():
1549             d = {'DYLIB_CXX_SOURCES': sources,
1550                  'DYLIB_NAME': lib_name,
1551                  'CFLAGS_EXTRAS': "%s -stdlib=libc++" % stdflag,
1552                  'FRAMEWORK_INCLUDES': "-F%s" % self.framework_dir,
1553                  'LD_EXTRAS': "%s -Wl,-rpath,%s -dynamiclib" % (self.lib_lldb, self.framework_dir),
1554                  }
1555         elif self.getPlatform() == 'windows':
1556             d = {
1557                 'DYLIB_CXX_SOURCES': sources,
1558                 'DYLIB_NAME': lib_name,
1559                 'CFLAGS_EXTRAS': "%s -I%s " % (stdflag,
1560                                                os.path.join(
1561                                                    os.environ["LLDB_SRC"],
1562                                                    "include")),
1563                 'LD_EXTRAS': "-shared -l%s\liblldb.lib" % lib_dir}
1564         else:
1565             d = {
1566                 'DYLIB_CXX_SOURCES': sources,
1567                 'DYLIB_NAME': lib_name,
1568                 'CFLAGS_EXTRAS': "%s -I%s -fPIC" % (stdflag,
1569                                                     os.path.join(
1570                                                         os.environ["LLDB_SRC"],
1571                                                         "include")),
1572                 'LD_EXTRAS': "-shared -L%s -llldb -Wl,-rpath,%s" % (lib_dir, lib_dir)}
1573         if self.TraceOn():
1574             print(
1575                 "Building LLDB Library (%s) from sources %s" %
1576                 (lib_name, sources))
1577
1578         self.buildDefault(dictionary=d)
1579
1580     def buildProgram(self, sources, exe_name):
1581         """ Platform specific way to build an executable from C/C++ sources. """
1582         d = {'CXX_SOURCES': sources,
1583              'EXE': exe_name}
1584         self.buildDefault(dictionary=d)
1585
1586     def buildDefault(
1587             self,
1588             architecture=None,
1589             compiler=None,
1590             dictionary=None):
1591         """Platform specific way to build the default binaries."""
1592         testdir = self.mydir
1593         testname = self.getBuildDirBasename()
1594
1595         if not architecture and configuration.arch:
1596             architecture = configuration.arch
1597
1598         if self.getDebugInfo():
1599             raise Exception("buildDefault tests must set NO_DEBUG_INFO_TESTCASE")
1600         module = builder_module()
1601         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
1602         if not module.buildDefault(self, architecture, compiler,
1603                                    dictionary, testdir, testname):
1604             raise Exception("Don't know how to build default binary")
1605
1606     def buildDsym(
1607             self,
1608             architecture=None,
1609             compiler=None,
1610             dictionary=None):
1611         """Platform specific way to build binaries with dsym info."""
1612         testdir = self.mydir
1613         testname = self.getBuildDirBasename()
1614         if self.getDebugInfo() != "dsym":
1615             raise Exception("NO_DEBUG_INFO_TESTCASE must build with buildDefault")
1616
1617         module = builder_module()
1618         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
1619         if not module.buildDsym(self, architecture, compiler,
1620                                 dictionary, testdir, testname):
1621             raise Exception("Don't know how to build binary with dsym")
1622
1623     def buildDwarf(
1624             self,
1625             architecture=None,
1626             compiler=None,
1627             dictionary=None):
1628         """Platform specific way to build binaries with dwarf maps."""
1629         testdir = self.mydir
1630         testname = self.getBuildDirBasename()
1631         if self.getDebugInfo() != "dwarf":
1632             raise Exception("NO_DEBUG_INFO_TESTCASE must build with buildDefault")
1633
1634         module = builder_module()
1635         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
1636         if not module.buildDwarf(self, architecture, compiler,
1637                                    dictionary, testdir, testname):
1638             raise Exception("Don't know how to build binary with dwarf")
1639
1640     def buildDwo(
1641             self,
1642             architecture=None,
1643             compiler=None,
1644             dictionary=None):
1645         """Platform specific way to build binaries with dwarf maps."""
1646         testdir = self.mydir
1647         testname = self.getBuildDirBasename()
1648         if self.getDebugInfo() != "dwo":
1649             raise Exception("NO_DEBUG_INFO_TESTCASE must build with buildDefault")
1650
1651         module = builder_module()
1652         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
1653         if not module.buildDwo(self, architecture, compiler,
1654                                    dictionary, testdir, testname):
1655             raise Exception("Don't know how to build binary with dwo")
1656
1657     def buildGModules(
1658             self,
1659             architecture=None,
1660             compiler=None,
1661             dictionary=None):
1662         """Platform specific way to build binaries with gmodules info."""
1663         testdir = self.mydir
1664         testname = self.getBuildDirBasename()
1665         if self.getDebugInfo() != "gmodules":
1666             raise Exception("NO_DEBUG_INFO_TESTCASE must build with buildDefault")
1667
1668         module = builder_module()
1669         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
1670         if not module.buildGModules(self, architecture, compiler,
1671                                     dictionary, testdir, testname):
1672             raise Exception("Don't know how to build binary with gmodules")
1673
1674     def buildDWZ(
1675             self,
1676             architecture=None,
1677             compiler=None,
1678             dictionary=None):
1679         """Platform specific way to build binaries with dwz optimizer."""
1680         testdir = self.mydir
1681         testname = self.getBuildDirBasename()
1682         if self.getDebugInfo() != "dwz":
1683             raise Exception("NO_DEBUG_INFO_TESTCASE must build with buildDefault")
1684
1685         module = builder_module()
1686         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
1687         if not module.buildDWZ(self, architecture, compiler,
1688                                dictionary, testdir, testname):
1689             raise Exception("Don't know how to build binary with dwz")
1690
1691     def signBinary(self, binary_path):
1692         if sys.platform.startswith("darwin"):
1693             codesign_cmd = "codesign --force --sign \"%s\" %s" % (
1694                 lldbtest_config.codesign_identity, binary_path)
1695             call(codesign_cmd, shell=True)
1696
1697     def findBuiltClang(self):
1698         """Tries to find and use Clang from the build directory as the compiler (instead of the system compiler)."""
1699         paths_to_try = [
1700             "llvm-build/Release+Asserts/x86_64/bin/clang",
1701             "llvm-build/Debug+Asserts/x86_64/bin/clang",
1702             "llvm-build/Release/x86_64/bin/clang",
1703             "llvm-build/Debug/x86_64/bin/clang",
1704         ]
1705         lldb_root_path = os.path.join(
1706             os.path.dirname(__file__), "..", "..", "..", "..")
1707         for p in paths_to_try:
1708             path = os.path.join(lldb_root_path, p)
1709             if os.path.exists(path):
1710                 return path
1711
1712         # Tries to find clang at the same folder as the lldb
1713         lldb_dir = os.path.dirname(lldbtest_config.lldbExec)
1714         path = distutils.spawn.find_executable("clang", lldb_dir)
1715         if path is not None:
1716             return path
1717
1718         return os.environ["CC"]
1719
1720
1721     def yaml2obj(self, yaml_path, obj_path):
1722         """
1723         Create an object file at the given path from a yaml file.
1724
1725         Throws subprocess.CalledProcessError if the object could not be created.
1726         """
1727         yaml2obj_bin = configuration.get_yaml2obj_path()
1728         if not yaml2obj_bin:
1729             self.assertTrue(False, "No valid yaml2obj executable specified")
1730         command = [yaml2obj_bin, "-o=%s" % obj_path, yaml_path]
1731         system([command])
1732
1733     def getBuildFlags(
1734             self,
1735             use_cpp11=True,
1736             use_libcxx=False,
1737             use_libstdcxx=False):
1738         """ Returns a dictionary (which can be provided to build* functions above) which
1739             contains OS-specific build flags.
1740         """
1741         cflags = ""
1742         ldflags = ""
1743
1744         # On Mac OS X, unless specifically requested to use libstdc++, use
1745         # libc++
1746         if not use_libstdcxx and self.platformIsDarwin():
1747             use_libcxx = True
1748
1749         if use_libcxx and self.libcxxPath:
1750             cflags += "-stdlib=libc++ "
1751             if self.libcxxPath:
1752                 libcxxInclude = os.path.join(self.libcxxPath, "include")
1753                 libcxxLib = os.path.join(self.libcxxPath, "lib")
1754                 if os.path.isdir(libcxxInclude) and os.path.isdir(libcxxLib):
1755                     cflags += "-nostdinc++ -I%s -L%s -Wl,-rpath,%s " % (
1756                         libcxxInclude, libcxxLib, libcxxLib)
1757
1758         if use_cpp11:
1759             cflags += "-std="
1760             if "gcc" in self.getCompiler() and "4.6" in self.getCompilerVersion():
1761                 cflags += "c++0x"
1762             else:
1763                 cflags += "c++11"
1764         if self.platformIsDarwin() or self.getPlatform() == "freebsd":
1765             cflags += " -stdlib=libc++"
1766         elif self.getPlatform() == "openbsd":
1767             cflags += " -stdlib=libc++"
1768         elif self.getPlatform() == "netbsd":
1769             # NetBSD defaults to libc++
1770             pass
1771         elif "clang" in self.getCompiler():
1772             cflags += " -stdlib=libstdc++"
1773
1774         return {'CFLAGS_EXTRAS': cflags,
1775                 'LD_EXTRAS': ldflags,
1776                 }
1777
1778     def cleanup(self, dictionary=None):
1779         """Platform specific way to do cleanup after build."""
1780         module = builder_module()
1781         if not module.cleanup(self, dictionary):
1782             raise Exception(
1783                 "Don't know how to do cleanup with dictionary: " +
1784                 dictionary)
1785
1786     def invoke(self, obj, name, trace=False):
1787         """Use reflection to call a method dynamically with no argument."""
1788         trace = (True if traceAlways else trace)
1789
1790         method = getattr(obj, name)
1791         import inspect
1792         self.assertTrue(inspect.ismethod(method),
1793                         name + "is a method name of object: " + str(obj))
1794         result = method()
1795         with recording(self, trace) as sbuf:
1796             print(str(method) + ":", result, file=sbuf)
1797         return result
1798
1799     def getLLDBLibraryEnvVal(self):
1800         """ Returns the path that the OS-specific library search environment variable
1801             (self.dylibPath) should be set to in order for a program to find the LLDB
1802             library. If an environment variable named self.dylibPath is already set,
1803             the new path is appended to it and returned.
1804         """
1805         existing_library_path = os.environ[
1806             self.dylibPath] if self.dylibPath in os.environ else None
1807         if existing_library_path:
1808             return "%s:%s" % (existing_library_path, configuration.lldb_libs_dir)
1809         if sys.platform.startswith("darwin") and configuration.lldb_framework_path:
1810             return configuration.lldb_framework_path
1811         return configuration.lldb_libs_dir
1812
1813     def getLibcPlusPlusLibs(self):
1814         if self.getPlatform() in ('freebsd', 'linux', 'netbsd', 'openbsd'):
1815             return ['libc++.so.1']
1816         else:
1817             return ['libc++.1.dylib', 'libc++abi.']
1818
1819     def run_platform_command(self, cmd):
1820         platform = self.dbg.GetSelectedPlatform()
1821         shell_command = lldb.SBPlatformShellCommand(cmd)
1822         err = platform.Run(shell_command)
1823         return (err, shell_command.GetStatus(), shell_command.GetOutput())
1824
1825 # Metaclass for TestBase to change the list of test metods when a new TestCase is loaded.
1826 # We change the test methods to create a new test method for each test for each debug info we are
1827 # testing. The name of the new test method will be '<original-name>_<debug-info>' and with adding
1828 # the new test method we remove the old method at the same time. This functionality can be
1829 # supressed by at test case level setting the class attribute NO_DEBUG_INFO_TESTCASE or at test
1830 # level by using the decorator @no_debug_info_test.
1831
1832
1833 class LLDBTestCaseFactory(type):
1834
1835     def __new__(cls, name, bases, attrs):
1836         original_testcase = super(
1837             LLDBTestCaseFactory, cls).__new__(
1838             cls, name, bases, attrs)
1839         if original_testcase.NO_DEBUG_INFO_TESTCASE:
1840             return original_testcase
1841
1842         newattrs = {}
1843         for attrname, attrvalue in attrs.items():
1844             if attrname.startswith("test") and not getattr(
1845                     attrvalue, "__no_debug_info_test__", False):
1846
1847                 # If any debug info categories were explicitly tagged, assume that list to be
1848                 # authoritative.  If none were specified, try with all debug
1849                 # info formats.
1850                 all_dbginfo_categories = set(test_categories.debug_info_categories)
1851                 categories = set(
1852                     getattr(
1853                         attrvalue,
1854                         "categories",
1855                         [])) & all_dbginfo_categories
1856                 if not categories:
1857                     categories = all_dbginfo_categories
1858
1859                 for cat in categories:
1860                     @decorators.add_test_categories([cat])
1861                     @wraps(attrvalue)
1862                     def test_method(self, attrvalue=attrvalue):
1863                         return attrvalue(self)
1864
1865                     method_name = attrname + "_" + cat
1866                     test_method.__name__ = method_name
1867                     test_method.debug_info = cat
1868                     newattrs[method_name] = test_method
1869
1870             else:
1871                 newattrs[attrname] = attrvalue
1872         return super(
1873             LLDBTestCaseFactory,
1874             cls).__new__(
1875             cls,
1876             name,
1877             bases,
1878             newattrs)
1879
1880 # Setup the metaclass for this class to change the list of the test
1881 # methods when a new class is loaded
1882
1883
1884 @add_metaclass(LLDBTestCaseFactory)
1885 class TestBase(Base):
1886     """
1887     This abstract base class is meant to be subclassed.  It provides default
1888     implementations for setUpClass(), tearDownClass(), setUp(), and tearDown(),
1889     among other things.
1890
1891     Important things for test class writers:
1892
1893         - Overwrite the mydir class attribute, otherwise your test class won't
1894           run.  It specifies the relative directory to the top level 'test' so
1895           the test harness can change to the correct working directory before
1896           running your test.
1897
1898         - The setUp method sets up things to facilitate subsequent interactions
1899           with the debugger as part of the test.  These include:
1900               - populate the test method name
1901               - create/get a debugger set with synchronous mode (self.dbg)
1902               - get the command interpreter from with the debugger (self.ci)
1903               - create a result object for use with the command interpreter
1904                 (self.res)
1905               - plus other stuffs
1906
1907         - The tearDown method tries to perform some necessary cleanup on behalf
1908           of the test to return the debugger to a good state for the next test.
1909           These include:
1910               - execute any tearDown hooks registered by the test method with
1911                 TestBase.addTearDownHook(); examples can be found in
1912                 settings/TestSettings.py
1913               - kill the inferior process associated with each target, if any,
1914                 and, then delete the target from the debugger's target list
1915               - perform build cleanup before running the next test method in the
1916                 same test class; examples of registering for this service can be
1917                 found in types/TestIntegerTypes.py with the call:
1918                     - self.setTearDownCleanup(dictionary=d)
1919
1920         - Similarly setUpClass and tearDownClass perform classwise setup and
1921           teardown fixtures.  The tearDownClass method invokes a default build
1922           cleanup for the entire test class;  also, subclasses can implement the
1923           classmethod classCleanup(cls) to perform special class cleanup action.
1924
1925         - The instance methods runCmd and expect are used heavily by existing
1926           test cases to send a command to the command interpreter and to perform
1927           string/pattern matching on the output of such command execution.  The
1928           expect method also provides a mode to peform string/pattern matching
1929           without running a command.
1930
1931         - The build methods buildDefault, buildDsym, and buildDwarf are used to
1932           build the binaries used during a particular test scenario.  A plugin
1933           should be provided for the sys.platform running the test suite.  The
1934           Mac OS X implementation is located in builders/darwin.py.
1935     """
1936
1937     # Subclasses can set this to true (if they don't depend on debug info) to avoid running the
1938     # test multiple times with various debug info types.
1939     NO_DEBUG_INFO_TESTCASE = False
1940
1941     # Maximum allowed attempts when launching the inferior process.
1942     # Can be overridden by the LLDB_MAX_LAUNCH_COUNT environment variable.
1943     maxLaunchCount = 1
1944
1945     # Time to wait before the next launching attempt in second(s).
1946     # Can be overridden by the LLDB_TIME_WAIT_NEXT_LAUNCH environment variable.
1947     timeWaitNextLaunch = 1.0
1948
1949     def generateSource(self, source):
1950         template = source + '.template'
1951         temp = os.path.join(self.getSourceDir(), template)
1952         with open(temp, 'r') as f:
1953             content = f.read()
1954
1955         public_api_dir = os.path.join(
1956             os.environ["LLDB_SRC"], "include", "lldb", "API")
1957
1958         # Look under the include/lldb/API directory and add #include statements
1959         # for all the SB API headers.
1960         public_headers = os.listdir(public_api_dir)
1961         # For different platforms, the include statement can vary.
1962         if self.hasDarwinFramework():
1963             include_stmt = "'#include <%s>' % os.path.join('LLDB', header)"
1964         else:
1965             include_stmt = "'#include <%s>' % os.path.join('" + public_api_dir + "', header)"
1966         list = [eval(include_stmt) for header in public_headers if (
1967             header.startswith("SB") and header.endswith(".h"))]
1968         includes = '\n'.join(list)
1969         new_content = content.replace('%include_SB_APIs%', includes)
1970         new_content = new_content.replace('%SOURCE_DIR%', self.getSourceDir())
1971         src = os.path.join(self.getBuildDir(), source)
1972         with open(src, 'w') as f:
1973             f.write(new_content)
1974
1975         self.addTearDownHook(lambda: os.remove(src))
1976
1977     def setUp(self):
1978         # Works with the test driver to conditionally skip tests via
1979         # decorators.
1980         Base.setUp(self)
1981
1982         for s in self.setUpCommands():
1983             self.runCmd(s)
1984
1985         if "LLDB_MAX_LAUNCH_COUNT" in os.environ:
1986             self.maxLaunchCount = int(os.environ["LLDB_MAX_LAUNCH_COUNT"])
1987
1988         if "LLDB_TIME_WAIT_NEXT_LAUNCH" in os.environ:
1989             self.timeWaitNextLaunch = float(
1990                 os.environ["LLDB_TIME_WAIT_NEXT_LAUNCH"])
1991
1992         # We want our debugger to be synchronous.
1993         self.dbg.SetAsync(False)
1994
1995         # Retrieve the associated command interpreter instance.
1996         self.ci = self.dbg.GetCommandInterpreter()
1997         if not self.ci:
1998             raise Exception('Could not get the command interpreter')
1999
2000         # And the result object.
2001         self.res = lldb.SBCommandReturnObject()
2002
2003     def registerSharedLibrariesWithTarget(self, target, shlibs):
2004         '''If we are remotely running the test suite, register the shared libraries with the target so they get uploaded, otherwise do nothing
2005
2006         Any modules in the target that have their remote install file specification set will
2007         get uploaded to the remote host. This function registers the local copies of the
2008         shared libraries with the target and sets their remote install locations so they will
2009         be uploaded when the target is run.
2010         '''
2011         if not shlibs or not self.platformContext:
2012             return None
2013
2014         shlib_environment_var = self.platformContext.shlib_environment_var
2015         shlib_prefix = self.platformContext.shlib_prefix
2016         shlib_extension = '.' + self.platformContext.shlib_extension
2017
2018         dirs = []
2019         # Add any shared libraries to our target if remote so they get
2020         # uploaded into the working directory on the remote side
2021         for name in shlibs:
2022             # The path can be a full path to a shared library, or a make file name like "Foo" for
2023             # "libFoo.dylib" or "libFoo.so", or "Foo.so" for "Foo.so" or "libFoo.so", or just a
2024             # basename like "libFoo.so". So figure out which one it is and resolve the local copy
2025             # of the shared library accordingly
2026             if os.path.isfile(name):
2027                 local_shlib_path = name  # name is the full path to the local shared library
2028             else:
2029                 # Check relative names
2030                 local_shlib_path = os.path.join(
2031                     self.getBuildDir(), shlib_prefix + name + shlib_extension)
2032                 if not os.path.exists(local_shlib_path):
2033                     local_shlib_path = os.path.join(
2034                         self.getBuildDir(), name + shlib_extension)
2035                     if not os.path.exists(local_shlib_path):
2036                         local_shlib_path = os.path.join(self.getBuildDir(), name)
2037
2038                 # Make sure we found the local shared library in the above code
2039                 self.assertTrue(os.path.exists(local_shlib_path))
2040
2041
2042             # Add the shared library to our target
2043             shlib_module = target.AddModule(local_shlib_path, None, None, None)
2044             if lldb.remote_platform:
2045                 # We must set the remote install location if we want the shared library
2046                 # to get uploaded to the remote target
2047                 remote_shlib_path = lldbutil.append_to_process_working_directory(self,
2048                     os.path.basename(local_shlib_path))
2049                 shlib_module.SetRemoteInstallFileSpec(
2050                     lldb.SBFileSpec(remote_shlib_path, False))
2051                 dir_to_add = self.get_process_working_directory()
2052             else:
2053                 dir_to_add = os.path.dirname(local_shlib_path)
2054
2055             if dir_to_add not in dirs:
2056                 dirs.append(dir_to_add)
2057
2058         env_value = self.platformContext.shlib_path_separator.join(dirs)
2059         return ['%s=%s' % (shlib_environment_var, env_value)]
2060
2061     def registerSanitizerLibrariesWithTarget(self, target):
2062         runtimes = []
2063         for m in target.module_iter():
2064             libspec = m.GetFileSpec()
2065             if "clang_rt" in libspec.GetFilename():
2066                 runtimes.append(os.path.join(libspec.GetDirectory(),
2067                                              libspec.GetFilename()))
2068         return self.registerSharedLibrariesWithTarget(target, runtimes)
2069
2070     # utility methods that tests can use to access the current objects
2071     def target(self):
2072         if not self.dbg:
2073             raise Exception('Invalid debugger instance')
2074         return self.dbg.GetSelectedTarget()
2075
2076     def process(self):
2077         if not self.dbg:
2078             raise Exception('Invalid debugger instance')
2079         return self.dbg.GetSelectedTarget().GetProcess()
2080
2081     def thread(self):
2082         if not self.dbg:
2083             raise Exception('Invalid debugger instance')
2084         return self.dbg.GetSelectedTarget().GetProcess().GetSelectedThread()
2085
2086     def frame(self):
2087         if not self.dbg:
2088             raise Exception('Invalid debugger instance')
2089         return self.dbg.GetSelectedTarget().GetProcess(
2090         ).GetSelectedThread().GetSelectedFrame()
2091
2092     def get_process_working_directory(self):
2093         '''Get the working directory that should be used when launching processes for local or remote processes.'''
2094         if lldb.remote_platform:
2095             # Remote tests set the platform working directory up in
2096             # TestBase.setUp()
2097             return lldb.remote_platform.GetWorkingDirectory()
2098         else:
2099             # local tests change directory into each test subdirectory
2100             return self.getBuildDir()
2101
2102     def tearDown(self):
2103         # Ensure all the references to SB objects have gone away so that we can
2104         # be sure that all test-specific resources have been freed before we
2105         # attempt to delete the targets.
2106         gc.collect()
2107
2108         # Delete the target(s) from the debugger as a general cleanup step.
2109         # This includes terminating the process for each target, if any.
2110         # We'd like to reuse the debugger for our next test without incurring
2111         # the initialization overhead.
2112         targets = []
2113         for target in self.dbg:
2114             if target:
2115                 targets.append(target)
2116                 process = target.GetProcess()
2117                 if process:
2118                     rc = self.invoke(process, "Kill")
2119                     assert rc.Success()
2120         for target in targets:
2121             self.dbg.DeleteTarget(target)
2122
2123         if not configuration.is_reproducer():
2124             # Assert that all targets are deleted.
2125             self.assertEqual(self.dbg.GetNumTargets(), 0)
2126
2127         # Do this last, to make sure it's in reverse order from how we setup.
2128         Base.tearDown(self)
2129
2130     def switch_to_thread_with_stop_reason(self, stop_reason):
2131         """
2132         Run the 'thread list' command, and select the thread with stop reason as
2133         'stop_reason'.  If no such thread exists, no select action is done.
2134         """
2135         from .lldbutil import stop_reason_to_str
2136         self.runCmd('thread list')
2137         output = self.res.GetOutput()
2138         thread_line_pattern = re.compile(
2139             "^[ *] thread #([0-9]+):.*stop reason = %s" %
2140             stop_reason_to_str(stop_reason))
2141         for line in output.splitlines():
2142             matched = thread_line_pattern.match(line)
2143             if matched:
2144                 self.runCmd('thread select %s' % matched.group(1))
2145
2146     def runCmd(self, cmd, msg=None, check=True, trace=False, inHistory=False):
2147         """
2148         Ask the command interpreter to handle the command and then check its
2149         return status.
2150         """
2151         # Fail fast if 'cmd' is not meaningful.
2152         if cmd is None:
2153             raise Exception("Bad 'cmd' parameter encountered")
2154
2155         trace = (True if traceAlways else trace)
2156
2157         if cmd.startswith("target create "):
2158             cmd = cmd.replace("target create ", "file ")
2159
2160         running = (cmd.startswith("run") or cmd.startswith("process launch"))
2161
2162         for i in range(self.maxLaunchCount if running else 1):
2163             self.ci.HandleCommand(cmd, self.res, inHistory)
2164
2165             with recording(self, trace) as sbuf:
2166                 print("runCmd:", cmd, file=sbuf)
2167                 if not check:
2168                     print("check of return status not required", file=sbuf)
2169                 if self.res.Succeeded():
2170                     print("output:", self.res.GetOutput(), file=sbuf)
2171                 else:
2172                     print("runCmd failed!", file=sbuf)
2173                     print(self.res.GetError(), file=sbuf)
2174
2175             if self.res.Succeeded():
2176                 break
2177             elif running:
2178                 # For process launch, wait some time before possible next try.
2179                 time.sleep(self.timeWaitNextLaunch)
2180                 with recording(self, trace) as sbuf:
2181                     print("Command '" + cmd + "' failed!", file=sbuf)
2182
2183         if check:
2184             output = ""
2185             if self.res.GetOutput():
2186                 output += "\nCommand output:\n" + self.res.GetOutput()
2187             if self.res.GetError():
2188                 output += "\nError output:\n" + self.res.GetError()
2189             if msg:
2190                 msg += output
2191             if cmd:
2192                 cmd += output
2193             self.assertTrue(self.res.Succeeded(),
2194                             msg if (msg) else CMD_MSG(cmd))
2195
2196     def match(
2197             self,
2198             str,
2199             patterns,
2200             msg=None,
2201             trace=False,
2202             error=False,
2203             matching=True,
2204             exe=True):
2205         """run command in str, and match the result against regexp in patterns returning the match object for the first matching pattern
2206
2207         Otherwise, all the arguments have the same meanings as for the expect function"""
2208
2209         trace = (True if traceAlways else trace)
2210
2211         if exe:
2212             # First run the command.  If we are expecting error, set check=False.
2213             # Pass the assert message along since it provides more semantic
2214             # info.
2215             self.runCmd(
2216                 str,
2217                 msg=msg,
2218                 trace=(
2219                     True if trace else False),
2220                 check=not error)
2221
2222             # Then compare the output against expected strings.
2223             output = self.res.GetError() if error else self.res.GetOutput()
2224
2225             # If error is True, the API client expects the command to fail!
2226             if error:
2227                 self.assertFalse(self.res.Succeeded(),
2228                                  "Command '" + str + "' is expected to fail!")
2229         else:
2230             # No execution required, just compare str against the golden input.
2231             output = str
2232             with recording(self, trace) as sbuf:
2233                 print("looking at:", output, file=sbuf)
2234
2235         # The heading says either "Expecting" or "Not expecting".
2236         heading = "Expecting" if matching else "Not expecting"
2237
2238         for pattern in patterns:
2239             # Match Objects always have a boolean value of True.
2240             match_object = re.search(pattern, output)
2241             matched = bool(match_object)
2242             with recording(self, trace) as sbuf:
2243                 print("%s pattern: %s" % (heading, pattern), file=sbuf)
2244                 print("Matched" if matched else "Not matched", file=sbuf)
2245             if matched:
2246                 break
2247
2248         self.assertTrue(matched if matching else not matched,
2249                         msg if msg else EXP_MSG(str, output, exe))
2250
2251         return match_object
2252
2253     def check_completion_with_desc(self, str_input, match_desc_pairs, enforce_order=False):
2254         """
2255         Checks that when the given input is completed at the given list of
2256         completions and descriptions is returned.
2257         :param str_input: The input that should be completed. The completion happens at the end of the string.
2258         :param match_desc_pairs: A list of pairs that indicate what completions have to be in the list of
2259                                  completions returned by LLDB. The first element of the pair is the completion
2260                                  string that LLDB should generate and the second element the description.
2261         :param enforce_order: True iff the order in which the completions are returned by LLDB
2262                               should match the order of the match_desc_pairs pairs.
2263         """
2264         interp = self.dbg.GetCommandInterpreter()
2265         match_strings = lldb.SBStringList()
2266         description_strings = lldb.SBStringList()
2267         num_matches = interp.HandleCompletionWithDescriptions(str_input, len(str_input), 0, -1, match_strings, description_strings)
2268         self.assertEqual(len(description_strings), len(match_strings))
2269
2270         # The index of the last matched description in description_strings or
2271         # -1 if no description has been matched yet.
2272         last_found_index = -1
2273         out_of_order_errors = ""
2274         missing_pairs = []
2275         for pair in match_desc_pairs:
2276             found_pair = False
2277             for i in range(num_matches + 1):
2278                 match_candidate = match_strings.GetStringAtIndex(i)
2279                 description_candidate = description_strings.GetStringAtIndex(i)
2280                 if match_candidate == pair[0] and description_candidate == pair[1]:
2281                     found_pair = True
2282                     if enforce_order and last_found_index > i:
2283                         new_err = ("Found completion " + pair[0] + " at index " +
2284                                   str(i) + " in returned completion list but " +
2285                                   "should have been after completion " +
2286                                   match_strings.GetStringAtIndex(last_found_index) +
2287                                   " (index:" + str(last_found_index) + ")\n")
2288                         out_of_order_errors += new_err
2289                     last_found_index = i
2290                     break
2291             if not found_pair:
2292                 missing_pairs.append(pair)
2293
2294         error_msg = ""
2295         got_failure = False
2296         if len(missing_pairs):
2297             got_failure = True
2298             error_msg += "Missing pairs:\n"
2299             for pair in missing_pairs:
2300                 error_msg += " [" + pair[0] + ":" + pair[1] + "]\n"
2301         if len(out_of_order_errors):
2302             got_failure = True
2303             error_msg += out_of_order_errors
2304         if got_failure:
2305             error_msg += "Got the following " + str(num_matches) + " completions back:\n"
2306             for i in range(num_matches + 1):
2307                 match_candidate = match_strings.GetStringAtIndex(i)
2308                 description_candidate = description_strings.GetStringAtIndex(i)
2309                 error_msg += "[" + match_candidate + ":" + description_candidate + "] index " + str(i) + "\n"
2310             self.assertFalse(got_failure, error_msg)
2311
2312     def complete_exactly(self, str_input, patterns):
2313         self.complete_from_to(str_input, patterns, True)
2314
2315     def complete_from_to(self, str_input, patterns, turn_off_re_match=False):
2316         """Test that the completion mechanism completes str_input to patterns,
2317         where patterns could be a pattern-string or a list of pattern-strings"""
2318         # Patterns should not be None in order to proceed.
2319         self.assertFalse(patterns is None)
2320         # And should be either a string or list of strings.  Check for list type
2321         # below, if not, make a list out of the singleton string.  If patterns
2322         # is not a string or not a list of strings, there'll be runtime errors
2323         # later on.
2324         if not isinstance(patterns, list):
2325             patterns = [patterns]
2326
2327         interp = self.dbg.GetCommandInterpreter()
2328         match_strings = lldb.SBStringList()
2329         num_matches = interp.HandleCompletion(str_input, len(str_input), 0, -1, match_strings)
2330         common_match = match_strings.GetStringAtIndex(0)
2331         if num_matches == 0:
2332             compare_string = str_input
2333         else:
2334             if common_match != None and len(common_match) > 0:
2335                 compare_string = str_input + common_match
2336             else:
2337                 compare_string = ""
2338                 for idx in range(1, num_matches+1):
2339                     compare_string += match_strings.GetStringAtIndex(idx) + "\n"
2340
2341         for p in patterns:
2342             if turn_off_re_match:
2343                 self.expect(
2344                     compare_string, msg=COMPLETION_MSG(
2345                         str_input, p, match_strings), exe=False, substrs=[p])
2346             else:
2347                 self.expect(
2348                     compare_string, msg=COMPLETION_MSG(
2349                         str_input, p, match_strings), exe=False, patterns=[p])
2350
2351     def completions_match(self, command, completions):
2352         """Checks that the completions for the given command are equal to the
2353         given list of completions"""
2354         interp = self.dbg.GetCommandInterpreter()
2355         match_strings = lldb.SBStringList()
2356         interp.HandleCompletion(command, len(command), 0, -1, match_strings)
2357         # match_strings is a 1-indexed list, so we have to slice...
2358         self.assertItemsEqual(completions, list(match_strings)[1:],
2359                               "List of returned completion is wrong")
2360
2361     def completions_contain(self, command, completions):
2362         """Checks that the completions for the given command contain the given
2363         list of completions."""
2364         interp = self.dbg.GetCommandInterpreter()
2365         match_strings = lldb.SBStringList()
2366         interp.HandleCompletion(command, len(command), 0, -1, match_strings)
2367         for completion in completions:
2368             # match_strings is a 1-indexed list, so we have to slice...
2369             self.assertIn(completion, list(match_strings)[1:],
2370                           "Couldn't find expected completion")
2371
2372     def filecheck(
2373             self,
2374             command,
2375             check_file,
2376             filecheck_options = '',
2377             expect_cmd_failure = False):
2378         # Run the command.
2379         self.runCmd(
2380                 command,
2381                 check=(not expect_cmd_failure),
2382                 msg="FileCheck'ing result of `{0}`".format(command))
2383
2384         self.assertTrue((not expect_cmd_failure) == self.res.Succeeded())
2385
2386         # Get the error text if there was an error, and the regular text if not.
2387         output = self.res.GetOutput() if self.res.Succeeded() \
2388                 else self.res.GetError()
2389
2390         # Assemble the absolute path to the check file. As a convenience for
2391         # LLDB inline tests, assume that the check file is a relative path to
2392         # a file within the inline test directory.
2393         if check_file.endswith('.pyc'):
2394             check_file = check_file[:-1]
2395         check_file_abs = os.path.abspath(check_file)
2396
2397         # Run FileCheck.
2398         filecheck_bin = configuration.get_filecheck_path()
2399         if not filecheck_bin:
2400             self.assertTrue(False, "No valid FileCheck executable specified")
2401         filecheck_args = [filecheck_bin, check_file_abs]
2402         if filecheck_options:
2403             filecheck_args.append(filecheck_options)
2404         subproc = Popen(filecheck_args, stdin=PIPE, stdout=PIPE, stderr=PIPE, universal_newlines = True)
2405         cmd_stdout, cmd_stderr = subproc.communicate(input=output)
2406         cmd_status = subproc.returncode
2407
2408         filecheck_cmd = " ".join(filecheck_args)
2409         filecheck_trace = """
2410 --- FileCheck trace (code={0}) ---
2411 {1}
2412
2413 FileCheck input:
2414 {2}
2415
2416 FileCheck output:
2417 {3}
2418 {4}
2419 """.format(cmd_status, filecheck_cmd, output, cmd_stdout, cmd_stderr)
2420
2421         trace = cmd_status != 0 or traceAlways
2422         with recording(self, trace) as sbuf:
2423             print(filecheck_trace, file=sbuf)
2424
2425         self.assertTrue(cmd_status == 0)
2426
2427     def expect(
2428             self,
2429             str,
2430             msg=None,
2431             patterns=None,
2432             startstr=None,
2433             endstr=None,
2434             substrs=None,
2435             trace=False,
2436             error=False,
2437             ordered=True,
2438             matching=True,
2439             exe=True,
2440             inHistory=False):
2441         """
2442         Similar to runCmd; with additional expect style output matching ability.
2443
2444         Ask the command interpreter to handle the command and then check its
2445         return status.  The 'msg' parameter specifies an informational assert
2446         message.  We expect the output from running the command to start with
2447         'startstr', matches the substrings contained in 'substrs', and regexp
2448         matches the patterns contained in 'patterns'.
2449
2450         When matching is true and ordered is true, which are both the default,
2451         the strings in the substrs array have to appear in the command output
2452         in the order in which they appear in the array.
2453
2454         If the keyword argument error is set to True, it signifies that the API
2455         client is expecting the command to fail.  In this case, the error stream
2456         from running the command is retrieved and compared against the golden
2457         input, instead.
2458
2459         If the keyword argument matching is set to False, it signifies that the API
2460         client is expecting the output of the command not to match the golden
2461         input.
2462
2463         Finally, the required argument 'str' represents the lldb command to be
2464         sent to the command interpreter.  In case the keyword argument 'exe' is
2465         set to False, the 'str' is treated as a string to be matched/not-matched
2466         against the golden input.
2467         """
2468         # Catch cases where `expect` has been miscalled. Specifically, prevent
2469         # this easy to make mistake:
2470         #     self.expect("lldb command", "some substr")
2471         # The `msg` parameter is used only when a failed match occurs. A failed
2472         # match can only occur when one of `patterns`, `startstr`, `endstr`, or
2473         # `substrs` has been given. Thus, if a `msg` is given, it's an error to
2474         # not also provide one of the matcher parameters.
2475         if msg and not (patterns or startstr or endstr or substrs or error):
2476             assert False, "expect() missing a matcher argument"
2477
2478         # Check `patterns` and `substrs` are not accidentally given as strings.
2479         assert not isinstance(patterns, six.string_types), \
2480             "patterns must be a collection of strings"
2481         assert not isinstance(substrs, six.string_types), \
2482             "substrs must be a collection of strings"
2483
2484         trace = (True if traceAlways else trace)
2485
2486         if exe:
2487             # First run the command.  If we are expecting error, set check=False.
2488             # Pass the assert message along since it provides more semantic
2489             # info.
2490             self.runCmd(
2491                 str,
2492                 msg=msg,
2493                 trace=(
2494                     True if trace else False),
2495                 check=not error,
2496                 inHistory=inHistory)
2497
2498             # Then compare the output against expected strings.
2499             output = self.res.GetError() if error else self.res.GetOutput()
2500
2501             # If error is True, the API client expects the command to fail!
2502             if error:
2503                 self.assertFalse(self.res.Succeeded(),
2504                                  "Command '" + str + "' is expected to fail!")
2505         else:
2506             # No execution required, just compare str against the golden input.
2507             if isinstance(str, lldb.SBCommandReturnObject):
2508                 output = str.GetOutput()
2509             else:
2510                 output = str
2511             with recording(self, trace) as sbuf:
2512                 print("looking at:", output, file=sbuf)
2513
2514         expecting_str = "Expecting" if matching else "Not expecting"
2515         def found_str(matched):
2516             return "was found" if matched else "was not found"
2517
2518         # To be used as assert fail message and/or trace content
2519         log_lines = [
2520                 "{}:".format("Ran command" if exe else "Checking string"),
2521                 "\"{}\"".format(str),
2522                 # Space out command and output
2523                 "",
2524         ]
2525         if exe:
2526             # Newline before output to make large strings more readable
2527             log_lines.append("Got output:\n{}".format(output))
2528
2529         # Assume that we start matched if we want a match
2530         # Meaning if you have no conditions, matching or
2531         # not matching will always pass
2532         matched = matching
2533
2534         # We will stop checking on first failure
2535         if startstr:
2536             matched = output.startswith(startstr)
2537             log_lines.append("{} start string: \"{}\" ({})".format(
2538                     expecting_str, startstr, found_str(matched)))
2539
2540         if endstr and matched == matching:
2541             matched = output.endswith(endstr)
2542             log_lines.append("{} end string: \"{}\" ({})".format(
2543                     expecting_str, endstr, found_str(matched)))
2544
2545         if substrs and matched == matching:
2546             start = 0
2547             for substr in substrs:
2548                 index = output[start:].find(substr)
2549                 start = start + index if ordered and matching else 0
2550                 matched = index != -1
2551                 log_lines.append("{} sub string: \"{}\" ({})".format(
2552                         expecting_str, substr, found_str(matched)))
2553
2554                 if matched != matching:
2555                     break
2556
2557         if patterns and matched == matching:
2558             for pattern in patterns:
2559                 matched = re.search(pattern, output)
2560
2561                 pattern_line = "{} regex pattern: \"{}\" ({}".format(
2562                         expecting_str, pattern, found_str(matched))
2563                 if matched:
2564                     pattern_line += ", matched \"{}\"".format(
2565                             matched.group(0))
2566                 pattern_line += ")"
2567                 log_lines.append(pattern_line)
2568
2569                 # Convert to bool because match objects
2570                 # are True-ish but != True itself
2571                 matched = bool(matched)
2572                 if matched != matching:
2573                     break
2574
2575         # If a check failed, add any extra assert message
2576         if msg is not None and matched != matching:
2577             log_lines.append(msg)
2578
2579         log_msg = "\n".join(log_lines)
2580         with recording(self, trace) as sbuf:
2581             print(log_msg, file=sbuf)
2582         if matched != matching:
2583             self.fail(log_msg)
2584
2585     def expect_expr(
2586             self,
2587             expr,
2588             result_summary=None,
2589             result_value=None,
2590             result_type=None,
2591             result_children=None
2592             ):
2593         """
2594         Evaluates the given expression and verifies the result.
2595         :param expr: The expression as a string.
2596         :param result_summary: The summary that the expression should have. None if the summary should not be checked.
2597         :param result_value: The value that the expression should have. None if the value should not be checked.
2598         :param result_type: The type that the expression result should have. None if the type should not be checked.
2599         :param result_children: The expected children of the expression result
2600                                 as a list of ValueChecks. None if the children shouldn't be checked.
2601         """
2602         self.assertTrue(expr.strip() == expr, "Expression contains trailing/leading whitespace: '" + expr + "'")
2603
2604         frame = self.frame()
2605         options = lldb.SBExpressionOptions()
2606
2607         # Disable fix-its that tests don't pass by accident.
2608         options.SetAutoApplyFixIts(False)
2609
2610         # Set the usual default options for normal expressions.
2611         options.SetIgnoreBreakpoints(True)
2612
2613         if self.frame().IsValid():
2614             options.SetLanguage(frame.GuessLanguage())
2615             eval_result = self.frame().EvaluateExpression(expr, options)
2616         else:
2617             target = self.target()
2618             # If there is no selected target, run the expression in the dummy
2619             # target.
2620             if not target.IsValid():
2621                 target = self.dbg.GetDummyTarget()
2622             eval_result = target.EvaluateExpression(expr, options)
2623
2624         value_check = ValueCheck(type=result_type, value=result_value,
2625                                  summary=result_summary, children=result_children)
2626         value_check.check_value(self, eval_result, str(eval_result))
2627         return eval_result
2628
2629     def expect_var_path(
2630             self,
2631             var_path,
2632             summary=None,
2633             value=None,
2634             type=None,
2635             children=None
2636             ):
2637         """
2638         Evaluates the given variable path and verifies the result.
2639         See also 'frame variable' and SBFrame.GetValueForVariablePath.
2640         :param var_path: The variable path as a string.
2641         :param summary: The summary that the variable should have. None if the summary should not be checked.
2642         :param value: The value that the variable should have. None if the value should not be checked.
2643         :param type: The type that the variable result should have. None if the type should not be checked.
2644         :param children: The expected children of the variable  as a list of ValueChecks.
2645                          None if the children shouldn't be checked.
2646         """
2647         self.assertTrue(var_path.strip() == var_path,
2648                         "Expression contains trailing/leading whitespace: '" + var_path + "'")
2649
2650         frame = self.frame()
2651         eval_result = frame.GetValueForVariablePath(var_path)
2652
2653         value_check = ValueCheck(type=type, value=value,
2654                                  summary=summary, children=children)
2655         value_check.check_value(self, eval_result, str(eval_result))
2656         return eval_result
2657
2658     def build(
2659             self,
2660             architecture=None,
2661             compiler=None,
2662             dictionary=None):
2663         """Platform specific way to build the default binaries."""
2664         module = builder_module()
2665
2666         if not architecture and configuration.arch:
2667             architecture = configuration.arch
2668
2669         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
2670         if self.getDebugInfo() is None:
2671             return self.buildDefault(architecture, compiler, dictionary)
2672         elif self.getDebugInfo() == "dsym":
2673             return self.buildDsym(architecture, compiler, dictionary)
2674         elif self.getDebugInfo() == "dwarf":
2675             return self.buildDwarf(architecture, compiler, dictionary)
2676         elif self.getDebugInfo() == "dwo":
2677             return self.buildDwo(architecture, compiler, dictionary)
2678         elif self.getDebugInfo() == "gmodules":
2679             return self.buildGModules(architecture, compiler, dictionary)
2680         elif self.getDebugInfo() == "dwz":
2681             return self.buildDWZ(architecture, compiler, dictionary)
2682         else:
2683             self.fail("Can't build for debug info: %s" % self.getDebugInfo())
2684
2685     """Assert that an lldb.SBError is in the "success" state."""
2686     def assertSuccess(self, obj, msg=None):
2687         if not obj.Success():
2688             error = obj.GetCString()
2689             self.fail(self._formatMessage(msg,
2690                 "'{}' is not success".format(error)))
2691
2692     # =================================================
2693     # Misc. helper methods for debugging test execution
2694     # =================================================
2695
2696     def DebugSBValue(self, val):
2697         """Debug print a SBValue object, if traceAlways is True."""
2698         from .lldbutil import value_type_to_str
2699
2700         if not traceAlways:
2701             return
2702
2703         err = sys.stderr
2704         err.write(val.GetName() + ":\n")
2705         err.write('\t' + "TypeName         -> " + val.GetTypeName() + '\n')
2706         err.write('\t' + "ByteSize         -> " +
2707                   str(val.GetByteSize()) + '\n')
2708         err.write('\t' + "NumChildren      -> " +
2709                   str(val.GetNumChildren()) + '\n')
2710         err.write('\t' + "Value            -> " + str(val.GetValue()) + '\n')
2711         err.write('\t' + "ValueAsUnsigned  -> " +
2712                   str(val.GetValueAsUnsigned()) + '\n')
2713         err.write(
2714             '\t' +
2715             "ValueType        -> " +
2716             value_type_to_str(
2717                 val.GetValueType()) +
2718             '\n')
2719         err.write('\t' + "Summary          -> " + str(val.GetSummary()) + '\n')
2720         err.write('\t' + "IsPointerType    -> " +
2721                   str(val.TypeIsPointerType()) + '\n')
2722         err.write('\t' + "Location         -> " + val.GetLocation() + '\n')
2723
2724     def DebugSBType(self, type):
2725         """Debug print a SBType object, if traceAlways is True."""
2726         if not traceAlways:
2727             return
2728
2729         err = sys.stderr
2730         err.write(type.GetName() + ":\n")
2731         err.write('\t' + "ByteSize        -> " +
2732                   str(type.GetByteSize()) + '\n')
2733         err.write('\t' + "IsPointerType   -> " +
2734                   str(type.IsPointerType()) + '\n')
2735         err.write('\t' + "IsReferenceType -> " +
2736                   str(type.IsReferenceType()) + '\n')
2737
2738     def DebugPExpect(self, child):
2739         """Debug the spwaned pexpect object."""
2740         if not traceAlways:
2741             return
2742
2743         print(child)
2744
2745     @classmethod
2746     def RemoveTempFile(cls, file):
2747         if os.path.exists(file):
2748             remove_file(file)
2749
2750 # On Windows, the first attempt to delete a recently-touched file can fail
2751 # because of a race with antimalware scanners.  This function will detect a
2752 # failure and retry.
2753
2754
2755 def remove_file(file, num_retries=1, sleep_duration=0.5):
2756     for i in range(num_retries + 1):
2757         try:
2758             os.remove(file)
2759             return True
2760         except:
2761             time.sleep(sleep_duration)
2762             continue
2763     return False