blob: 73344d5296a999c9edaa1ca364099ae322c250de [file] [log] [blame]
Johnny Chena1affab2010-07-03 03:41:59 +00001"""
2LLDB module which provides the abstract base class of lldb test case.
3
4The concrete subclass can override lldbtest.TesBase in order to inherit the
5common behavior for unitest.TestCase.setUp/tearDown implemented in this file.
6
7The subclass should override the attribute mydir in order for the python runtime
8to locate the individual test cases when running as part of a large test suite
9or 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
Johnny Chene39170b2012-05-16 20:41:28 +000012entire of part of the test suite . Example:
Johnny Chena1affab2010-07-03 03:41:59 +000013
Johnny Chene39170b2012-05-16 20:41:28 +000014# Exercises the test suite in the types directory....
15/Volumes/data/lldb/svn/ToT/test $ ./dotest.py -A x86_64 types
Johnny Chen59ea45f2010-09-02 22:25:47 +000016...
Johnny Chend0c24b22010-08-23 17:10:44 +000017
Johnny Chene39170b2012-05-16 20:41:28 +000018Session logs for test failures/errors/unexpected successes will go into directory '2012-05-16-13_35_42'
19Command invoked: python ./dotest.py -A x86_64 types
20compilers=['clang']
Johnny Chend0c24b22010-08-23 17:10:44 +000021
Johnny Chene39170b2012-05-16 20:41:28 +000022Configuration: arch=x86_64 compiler=clang
Johnny Chend0c24b22010-08-23 17:10:44 +000023----------------------------------------------------------------------
Johnny Chene39170b2012-05-16 20:41:28 +000024Collected 72 tests
25
26........................................................................
27----------------------------------------------------------------------
28Ran 72 tests in 135.468s
Johnny Chend0c24b22010-08-23 17:10:44 +000029
30OK
Johnny Chena1affab2010-07-03 03:41:59 +000031$
32"""
33
Johnny Chen93ae6042010-09-21 22:34:45 +000034import os, sys, traceback
Enrico Granata0fd6c8d2012-10-24 18:14:21 +000035import os.path
Johnny Chen2d899752010-09-21 21:08:53 +000036import re
Johnny Chena1cc8832010-08-30 21:35:00 +000037from subprocess import *
Johnny Chen84a6d6f2010-10-15 01:18:29 +000038import StringIO
Johnny Chen65572482010-08-25 18:49:48 +000039import time
Johnny Chen1acaf632010-08-30 23:08:52 +000040import types
Johnny Chen75e28f92010-08-05 23:42:46 +000041import unittest2
Johnny Chena1affab2010-07-03 03:41:59 +000042import lldb
43
Johnny Chen548aefd2010-10-11 22:25:46 +000044# See also dotest.parseOptionsAndInitTestdirs(), where the environment variables
Johnny Chen24af2962011-01-19 18:18:47 +000045# LLDB_COMMAND_TRACE and LLDB_DO_CLEANUP are set from '-t' and '-r dir' options.
Johnny Chen548aefd2010-10-11 22:25:46 +000046
47# By default, traceAlways is False.
Johnny Chen9de4ede2010-08-31 17:42:54 +000048if "LLDB_COMMAND_TRACE" in os.environ and os.environ["LLDB_COMMAND_TRACE"]=="YES":
49 traceAlways = True
50else:
51 traceAlways = False
52
Johnny Chen548aefd2010-10-11 22:25:46 +000053# By default, doCleanup is True.
54if "LLDB_DO_CLEANUP" in os.environ and os.environ["LLDB_DO_CLEANUP"]=="NO":
55 doCleanup = False
56else:
57 doCleanup = True
58
Johnny Chen9de4ede2010-08-31 17:42:54 +000059
Johnny Chen96f08d52010-08-09 22:01:17 +000060#
61# Some commonly used assert messages.
62#
63
Johnny Chenee975b82010-09-17 22:45:27 +000064COMMAND_FAILED_AS_EXPECTED = "Command has failed as expected"
65
Johnny Chen96f08d52010-08-09 22:01:17 +000066CURRENT_EXECUTABLE_SET = "Current executable set successfully"
67
Johnny Chen72a14342010-09-02 21:23:12 +000068PROCESS_IS_VALID = "Process is valid"
69
70PROCESS_KILLED = "Process is killed successfully"
71
Johnny Chen0ace30f2010-12-23 01:12:19 +000072PROCESS_EXITED = "Process exited successfully"
73
74PROCESS_STOPPED = "Process status should be stopped"
75
Johnny Chen1bb9f9a2010-08-27 23:47:36 +000076RUN_SUCCEEDED = "Process is launched successfully"
Johnny Chen96f08d52010-08-09 22:01:17 +000077
Johnny Chend85dae52010-08-09 23:44:24 +000078RUN_COMPLETED = "Process exited successfully"
Johnny Chen96f08d52010-08-09 22:01:17 +000079
Johnny Chen5349ee22010-10-05 19:27:32 +000080BACKTRACE_DISPLAYED_CORRECTLY = "Backtrace displayed correctly"
81
Johnny Chend85dae52010-08-09 23:44:24 +000082BREAKPOINT_CREATED = "Breakpoint created successfully"
83
Johnny Chen1ad9e992010-12-04 00:07:24 +000084BREAKPOINT_STATE_CORRECT = "Breakpoint state is correct"
85
Johnny Chen9b92c6e2010-08-17 21:33:31 +000086BREAKPOINT_PENDING_CREATED = "Pending breakpoint created successfully"
87
Johnny Chend85dae52010-08-09 23:44:24 +000088BREAKPOINT_HIT_ONCE = "Breakpoint resolved with hit cout = 1"
Johnny Chen96f08d52010-08-09 22:01:17 +000089
Johnny Chen72afa8d2010-09-30 17:06:24 +000090BREAKPOINT_HIT_TWICE = "Breakpoint resolved with hit cout = 2"
91
Johnny Chenc55dace2010-10-15 18:07:09 +000092BREAKPOINT_HIT_THRICE = "Breakpoint resolved with hit cout = 3"
93
Greg Claytonb2c1a412012-10-24 18:24:14 +000094MISSING_EXPECTED_REGISTERS = "At least one expected register is unavailable."
95
Johnny Chenc0dbdc02011-06-27 20:05:23 +000096OBJECT_PRINTED_CORRECTLY = "Object printed correctly"
97
Johnny Chen6f7abb02010-12-09 18:22:12 +000098SOURCE_DISPLAYED_CORRECTLY = "Source code displayed correctly"
99
Johnny Chen0b3ee552010-09-22 23:00:20 +0000100STEP_OUT_SUCCEEDED = "Thread step-out succeeded"
101
Johnny Chen33cd0c32011-04-15 16:44:48 +0000102STOPPED_DUE_TO_EXC_BAD_ACCESS = "Process should be stopped due to bad access exception"
103
Ashok Thirumurthi5a7a2322013-05-17 15:35:15 +0000104STOPPED_DUE_TO_ASSERT = "Process should be stopped due to an assertion"
105
Johnny Chene8587d02010-11-10 23:46:38 +0000106STOPPED_DUE_TO_BREAKPOINT = "Process should be stopped due to breakpoint"
Johnny Chenc82ac762010-11-10 20:20:06 +0000107
Johnny Chene8587d02010-11-10 23:46:38 +0000108STOPPED_DUE_TO_BREAKPOINT_WITH_STOP_REASON_AS = "%s, %s" % (
109 STOPPED_DUE_TO_BREAKPOINT, "instead, the actual stop reason is: '%s'")
Johnny Chen96f08d52010-08-09 22:01:17 +0000110
Johnny Chenf6bdb192010-10-20 18:38:48 +0000111STOPPED_DUE_TO_BREAKPOINT_CONDITION = "Stopped due to breakpoint condition"
112
Johnny Chen7a4512b2010-12-13 21:49:58 +0000113STOPPED_DUE_TO_BREAKPOINT_IGNORE_COUNT = "Stopped due to breakpoint and ignore count"
114
Johnny Chend7a4eb02010-10-14 01:22:03 +0000115STOPPED_DUE_TO_SIGNAL = "Process state is stopped due to signal"
116
Johnny Chen96f08d52010-08-09 22:01:17 +0000117STOPPED_DUE_TO_STEP_IN = "Process state is stopped due to step in"
118
Johnny Chen58c66e22011-09-15 21:09:59 +0000119STOPPED_DUE_TO_WATCHPOINT = "Process should be stopped due to watchpoint"
120
Johnny Chen4917e102010-08-24 22:07:56 +0000121DATA_TYPES_DISPLAYED_CORRECTLY = "Data type(s) displayed correctly"
122
Johnny Chenb4d1fff2010-08-26 20:04:17 +0000123VALID_BREAKPOINT = "Got a valid breakpoint"
124
Johnny Chen0601a292010-10-22 18:10:25 +0000125VALID_BREAKPOINT_LOCATION = "Got a valid breakpoint location"
126
Johnny Chenac910272011-05-06 23:26:12 +0000127VALID_COMMAND_INTERPRETER = "Got a valid command interpreter"
128
Johnny Chen1bb9f9a2010-08-27 23:47:36 +0000129VALID_FILESPEC = "Got a valid filespec"
130
Johnny Chen8fd886c2010-12-08 01:25:21 +0000131VALID_MODULE = "Got a valid module"
132
Johnny Chenb4d1fff2010-08-26 20:04:17 +0000133VALID_PROCESS = "Got a valid process"
134
Johnny Chen8fd886c2010-12-08 01:25:21 +0000135VALID_SYMBOL = "Got a valid symbol"
136
Johnny Chenb4d1fff2010-08-26 20:04:17 +0000137VALID_TARGET = "Got a valid target"
138
Johnny Chen2ef5eae2012-02-03 20:43:00 +0000139VALID_TYPE = "Got a valid type"
140
Johnny Chen5503d462011-07-15 22:28:10 +0000141VALID_VARIABLE = "Got a valid variable"
142
Johnny Chen22b95b22010-08-25 19:00:04 +0000143VARIABLES_DISPLAYED_CORRECTLY = "Variable(s) displayed correctly"
Johnny Chen96f08d52010-08-09 22:01:17 +0000144
Johnny Chen58c66e22011-09-15 21:09:59 +0000145WATCHPOINT_CREATED = "Watchpoint created successfully"
Johnny Chenb4d1fff2010-08-26 20:04:17 +0000146
Johnny Chen05efcf782010-11-09 18:42:22 +0000147def CMD_MSG(str):
Johnny Chen006b5952011-05-31 22:16:51 +0000148 '''A generic "Command '%s' returns successfully" message generator.'''
Johnny Chen05efcf782010-11-09 18:42:22 +0000149 return "Command '%s' returns successfully" % str
150
Johnny Chendbe2c822012-03-15 19:10:00 +0000151def COMPLETION_MSG(str_before, str_after):
Johnny Chenfbcad682012-01-20 23:02:51 +0000152 '''A generic message generator for the completion mechanism.'''
153 return "'%s' successfully completes to '%s'" % (str_before, str_after)
154
Johnny Chen05efcf782010-11-09 18:42:22 +0000155def EXP_MSG(str, exe):
Johnny Chen006b5952011-05-31 22:16:51 +0000156 '''A generic "'%s' returns expected result" message generator if exe.
157 Otherwise, it generates "'%s' matches expected result" message.'''
Johnny Chen05efcf782010-11-09 18:42:22 +0000158 return "'%s' %s expected result" % (str, 'returns' if exe else 'matches')
Johnny Chend85dae52010-08-09 23:44:24 +0000159
Johnny Chendb9cbe92010-10-19 19:11:38 +0000160def SETTING_MSG(setting):
Johnny Chen006b5952011-05-31 22:16:51 +0000161 '''A generic "Value of setting '%s' is correct" message generator.'''
Johnny Chendb9cbe92010-10-19 19:11:38 +0000162 return "Value of setting '%s' is correct" % setting
163
Johnny Chenf4ce2882010-08-26 21:49:29 +0000164def EnvArray():
Johnny Chen006b5952011-05-31 22:16:51 +0000165 """Returns an env variable array from the os.environ map object."""
Johnny Chenf4ce2882010-08-26 21:49:29 +0000166 return map(lambda k,v: k+"="+v, os.environ.keys(), os.environ.values())
167
Johnny Chen14906002010-10-11 23:52:19 +0000168def line_number(filename, string_to_match):
169 """Helper function to return the line number of the first matched string."""
170 with open(filename, 'r') as f:
171 for i, line in enumerate(f):
172 if line.find(string_to_match) != -1:
173 # Found our match.
Johnny Chen0659e342010-10-12 00:09:25 +0000174 return i+1
Johnny Chen33cd0c32011-04-15 16:44:48 +0000175 raise Exception("Unable to find '%s' within file %s" % (string_to_match, filename))
Johnny Chen14906002010-10-11 23:52:19 +0000176
Johnny Chen5349ee22010-10-05 19:27:32 +0000177def pointer_size():
178 """Return the pointer size of the host system."""
179 import ctypes
180 a_pointer = ctypes.c_void_p(0xffff)
181 return 8 * ctypes.sizeof(a_pointer)
182
Johnny Chen7be5d352012-02-09 02:01:59 +0000183def is_exe(fpath):
184 """Returns true if fpath is an executable."""
185 return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
186
187def which(program):
188 """Returns the full path to a program; None otherwise."""
189 fpath, fname = os.path.split(program)
190 if fpath:
191 if is_exe(program):
192 return program
193 else:
194 for path in os.environ["PATH"].split(os.pathsep):
195 exe_file = os.path.join(path, program)
196 if is_exe(exe_file):
197 return exe_file
198 return None
199
Johnny Chen84a6d6f2010-10-15 01:18:29 +0000200class recording(StringIO.StringIO):
201 """
202 A nice little context manager for recording the debugger interactions into
203 our session object. If trace flag is ON, it also emits the interactions
204 into the stderr.
205 """
206 def __init__(self, test, trace):
Johnny Chen1b7d6292010-10-15 23:55:05 +0000207 """Create a StringIO instance; record the session obj and trace flag."""
Johnny Chen84a6d6f2010-10-15 01:18:29 +0000208 StringIO.StringIO.__init__(self)
Johnny Chen770683d2011-08-16 22:06:17 +0000209 # The test might not have undergone the 'setUp(self)' phase yet, so that
210 # the attribute 'session' might not even exist yet.
Johnny Chen8339f982011-08-16 17:06:45 +0000211 self.session = getattr(test, "session", None) if test else None
Johnny Chen84a6d6f2010-10-15 01:18:29 +0000212 self.trace = trace
213
214 def __enter__(self):
215 """
216 Context management protocol on entry to the body of the with statement.
217 Just return the StringIO object.
218 """
219 return self
220
221 def __exit__(self, type, value, tb):
222 """
223 Context management protocol on exit from the body of the with statement.
224 If trace is ON, it emits the recordings into stderr. Always add the
225 recordings to our session object. And close the StringIO object, too.
226 """
227 if self.trace:
Johnny Chen1b7d6292010-10-15 23:55:05 +0000228 print >> sys.stderr, self.getvalue()
229 if self.session:
230 print >> self.session, self.getvalue()
Johnny Chen84a6d6f2010-10-15 01:18:29 +0000231 self.close()
232
Johnny Chen1b7d6292010-10-15 23:55:05 +0000233# From 2.7's subprocess.check_output() convenience function.
Johnny Chen0bfa8592011-03-23 20:28:59 +0000234# Return a tuple (stdoutdata, stderrdata).
Johnny Chen1b7d6292010-10-15 23:55:05 +0000235def system(*popenargs, **kwargs):
Johnny Chen22ca65d2011-11-16 22:44:28 +0000236 r"""Run an os command with arguments and return its output as a byte string.
Johnny Chen1b7d6292010-10-15 23:55:05 +0000237
238 If the exit code was non-zero it raises a CalledProcessError. The
239 CalledProcessError object will have the return code in the returncode
240 attribute and output in the output attribute.
241
242 The arguments are the same as for the Popen constructor. Example:
243
244 >>> check_output(["ls", "-l", "/dev/null"])
245 'crw-rw-rw- 1 root root 1, 3 Oct 18 2007 /dev/null\n'
246
247 The stdout argument is not allowed as it is used internally.
248 To capture standard error in the result, use stderr=STDOUT.
249
250 >>> check_output(["/bin/sh", "-c",
251 ... "ls -l non_existent_file ; exit 0"],
252 ... stderr=STDOUT)
253 'ls: non_existent_file: No such file or directory\n'
254 """
255
256 # Assign the sender object to variable 'test' and remove it from kwargs.
257 test = kwargs.pop('sender', None)
258
259 if 'stdout' in kwargs:
260 raise ValueError('stdout argument not allowed, it will be overridden.')
Johnny Chen0bfa8592011-03-23 20:28:59 +0000261 process = Popen(stdout=PIPE, stderr=PIPE, *popenargs, **kwargs)
Johnny Chen30b30cb2011-11-16 22:41:53 +0000262 pid = process.pid
Johnny Chen1b7d6292010-10-15 23:55:05 +0000263 output, error = process.communicate()
264 retcode = process.poll()
265
266 with recording(test, traceAlways) as sbuf:
267 if isinstance(popenargs, types.StringTypes):
268 args = [popenargs]
269 else:
270 args = list(popenargs)
271 print >> sbuf
272 print >> sbuf, "os command:", args
Johnny Chen30b30cb2011-11-16 22:41:53 +0000273 print >> sbuf, "with pid:", pid
Johnny Chen1b7d6292010-10-15 23:55:05 +0000274 print >> sbuf, "stdout:", output
275 print >> sbuf, "stderr:", error
276 print >> sbuf, "retcode:", retcode
277 print >> sbuf
278
279 if retcode:
280 cmd = kwargs.get("args")
281 if cmd is None:
282 cmd = popenargs[0]
283 raise CalledProcessError(retcode, cmd)
Johnny Chen0bfa8592011-03-23 20:28:59 +0000284 return (output, error)
Johnny Chen1b7d6292010-10-15 23:55:05 +0000285
Johnny Chen29867642010-11-01 20:35:01 +0000286def getsource_if_available(obj):
287 """
288 Return the text of the source code for an object if available. Otherwise,
289 a print representation is returned.
290 """
291 import inspect
292 try:
293 return inspect.getsource(obj)
294 except:
295 return repr(obj)
296
Peter Collingbourne39bd5362011-06-20 19:06:20 +0000297def builder_module():
298 return __import__("builder_" + sys.platform)
299
Johnny Chen366fb8c2011-08-01 18:46:13 +0000300#
301# Decorators for categorizing test cases.
302#
303
304from functools import wraps
305def python_api_test(func):
306 """Decorate the item as a Python API only test."""
307 if isinstance(func, type) and issubclass(func, unittest2.TestCase):
308 raise Exception("@python_api_test can only be used to decorate a test method")
309 @wraps(func)
310 def wrapper(self, *args, **kwargs):
311 try:
312 if lldb.dont_do_python_api_test:
313 self.skipTest("python api tests")
314 except AttributeError:
315 pass
316 return func(self, *args, **kwargs)
317
318 # Mark this function as such to separate them from lldb command line tests.
319 wrapper.__python_api_test__ = True
320 return wrapper
321
Johnny Chen366fb8c2011-08-01 18:46:13 +0000322def benchmarks_test(func):
323 """Decorate the item as a benchmarks test."""
324 if isinstance(func, type) and issubclass(func, unittest2.TestCase):
325 raise Exception("@benchmarks_test can only be used to decorate a test method")
326 @wraps(func)
327 def wrapper(self, *args, **kwargs):
328 try:
329 if not lldb.just_do_benchmarks_test:
330 self.skipTest("benchmarks tests")
331 except AttributeError:
332 pass
333 return func(self, *args, **kwargs)
334
335 # Mark this function as such to separate them from the regular tests.
336 wrapper.__benchmarks_test__ = True
337 return wrapper
338
Johnny Chena3ed7d82012-04-06 00:56:05 +0000339def dsym_test(func):
340 """Decorate the item as a dsym test."""
341 if isinstance(func, type) and issubclass(func, unittest2.TestCase):
342 raise Exception("@dsym_test can only be used to decorate a test method")
343 @wraps(func)
344 def wrapper(self, *args, **kwargs):
345 try:
346 if lldb.dont_do_dsym_test:
347 self.skipTest("dsym tests")
348 except AttributeError:
349 pass
350 return func(self, *args, **kwargs)
351
352 # Mark this function as such to separate them from the regular tests.
353 wrapper.__dsym_test__ = True
354 return wrapper
355
356def dwarf_test(func):
357 """Decorate the item as a dwarf test."""
358 if isinstance(func, type) and issubclass(func, unittest2.TestCase):
359 raise Exception("@dwarf_test can only be used to decorate a test method")
360 @wraps(func)
361 def wrapper(self, *args, **kwargs):
362 try:
363 if lldb.dont_do_dwarf_test:
364 self.skipTest("dwarf tests")
365 except AttributeError:
366 pass
367 return func(self, *args, **kwargs)
368
369 # Mark this function as such to separate them from the regular tests.
370 wrapper.__dwarf_test__ = True
371 return wrapper
372
Enrico Granata786e8732013-02-23 01:35:21 +0000373def expectedFailureGcc(bugnumber=None):
Enrico Granata21416a12013-02-23 01:05:23 +0000374 if callable(bugnumber):
375 @wraps(bugnumber)
Enrico Granata786e8732013-02-23 01:35:21 +0000376 def expectedFailureGcc_easy_wrapper(*args, **kwargs):
Enrico Granata4d82e972013-02-23 01:28:30 +0000377 from unittest2 import case
378 self = args[0]
379 test_compiler = self.getCompiler()
380 try:
381 bugnumber(*args, **kwargs)
382 except Exception:
Enrico Granata786e8732013-02-23 01:35:21 +0000383 if "gcc" in test_compiler:
Enrico Granata4d82e972013-02-23 01:28:30 +0000384 raise case._ExpectedFailure(sys.exc_info(),None)
385 else:
386 raise
Enrico Granata786e8732013-02-23 01:35:21 +0000387 if "gcc" in test_compiler:
Enrico Granata4d82e972013-02-23 01:28:30 +0000388 raise case._UnexpectedSuccess(sys.exc_info(),None)
Enrico Granata786e8732013-02-23 01:35:21 +0000389 return expectedFailureGcc_easy_wrapper
Enrico Granata21416a12013-02-23 01:05:23 +0000390 else:
Enrico Granata786e8732013-02-23 01:35:21 +0000391 def expectedFailureGcc_impl(func):
Enrico Granata21416a12013-02-23 01:05:23 +0000392 @wraps(func)
393 def wrapper(*args, **kwargs):
Enrico Granata4d82e972013-02-23 01:28:30 +0000394 from unittest2 import case
395 self = args[0]
396 test_compiler = self.getCompiler()
397 try:
398 func(*args, **kwargs)
399 except Exception:
Enrico Granata786e8732013-02-23 01:35:21 +0000400 if "gcc" in test_compiler:
Enrico Granata4d82e972013-02-23 01:28:30 +0000401 raise case._ExpectedFailure(sys.exc_info(),bugnumber)
402 else:
403 raise
Enrico Granata786e8732013-02-23 01:35:21 +0000404 if "gcc" in test_compiler:
Enrico Granata4d82e972013-02-23 01:28:30 +0000405 raise case._UnexpectedSuccess(sys.exc_info(),bugnumber)
Enrico Granata21416a12013-02-23 01:05:23 +0000406 return wrapper
Enrico Granata786e8732013-02-23 01:35:21 +0000407 return expectedFailureGcc_impl
Daniel Malea8b5c29d2013-02-19 16:08:57 +0000408
Enrico Granata786e8732013-02-23 01:35:21 +0000409def expectedFailureClang(bugnumber=None):
410 if callable(bugnumber):
411 @wraps(bugnumber)
412 def expectedFailureClang_easy_wrapper(*args, **kwargs):
413 from unittest2 import case
414 self = args[0]
415 test_compiler = self.getCompiler()
416 try:
417 bugnumber(*args, **kwargs)
418 except Exception:
419 if "clang" in test_compiler:
420 raise case._ExpectedFailure(sys.exc_info(),None)
421 else:
422 raise
423 if "clang" in test_compiler:
424 raise case._UnexpectedSuccess(sys.exc_info(),None)
425 return expectedFailureClang_easy_wrapper
426 else:
427 def expectedFailureClang_impl(func):
428 @wraps(func)
429 def wrapper(*args, **kwargs):
430 from unittest2 import case
431 self = args[0]
432 test_compiler = self.getCompiler()
433 try:
434 func(*args, **kwargs)
435 except Exception:
436 if "clang" in test_compiler:
437 raise case._ExpectedFailure(sys.exc_info(),bugnumber)
438 else:
439 raise
440 if "clang" in test_compiler:
441 raise case._UnexpectedSuccess(sys.exc_info(),bugnumber)
442 return wrapper
443 return expectedFailureClang_impl
Daniel Malea8b5c29d2013-02-19 16:08:57 +0000444
Matt Kopec57d4ab22013-03-15 19:10:12 +0000445def expectedFailureIcc(bugnumber=None):
446 if callable(bugnumber):
447 @wraps(bugnumber)
448 def expectedFailureIcc_easy_wrapper(*args, **kwargs):
449 from unittest2 import case
450 self = args[0]
451 test_compiler = self.getCompiler()
452 try:
453 bugnumber(*args, **kwargs)
454 except Exception:
455 if "icc" in test_compiler:
456 raise case._ExpectedFailure(sys.exc_info(),None)
457 else:
458 raise
459 if "icc" in test_compiler:
460 raise case._UnexpectedSuccess(sys.exc_info(),None)
461 return expectedFailureIcc_easy_wrapper
462 else:
463 def expectedFailureIcc_impl(func):
464 @wraps(func)
465 def wrapper(*args, **kwargs):
466 from unittest2 import case
467 self = args[0]
468 test_compiler = self.getCompiler()
469 try:
470 func(*args, **kwargs)
471 except Exception:
472 if "icc" in test_compiler:
473 raise case._ExpectedFailure(sys.exc_info(),bugnumber)
474 else:
475 raise
476 if "icc" in test_compiler:
477 raise case._UnexpectedSuccess(sys.exc_info(),bugnumber)
478 return wrapper
479 return expectedFailureIcc_impl
480
Daniel Malea8b5c29d2013-02-19 16:08:57 +0000481
Enrico Granata21416a12013-02-23 01:05:23 +0000482def expectedFailurei386(bugnumber=None):
483 if callable(bugnumber):
484 @wraps(bugnumber)
485 def expectedFailurei386_easy_wrapper(*args, **kwargs):
Enrico Granata4d82e972013-02-23 01:28:30 +0000486 from unittest2 import case
487 self = args[0]
488 arch = self.getArchitecture()
489 try:
490 bugnumber(*args, **kwargs)
491 except Exception:
492 if "i386" in arch:
493 raise case._ExpectedFailure(sys.exc_info(),None)
494 else:
495 raise
496 if "i386" in arch:
497 raise case._UnexpectedSuccess(sys.exc_info(),None)
Enrico Granata21416a12013-02-23 01:05:23 +0000498 return expectedFailurei386_easy_wrapper
499 else:
500 def expectedFailurei386_impl(func):
501 @wraps(func)
502 def wrapper(*args, **kwargs):
Enrico Granata4d82e972013-02-23 01:28:30 +0000503 from unittest2 import case
504 self = args[0]
505 arch = self.getArchitecture()
506 try:
507 func(*args, **kwargs)
508 except Exception:
509 if "i386" in arch:
510 raise case._ExpectedFailure(sys.exc_info(),bugnumber)
511 else:
512 raise
513 if "i386" in arch:
514 raise case._UnexpectedSuccess(sys.exc_info(),bugnumber)
Enrico Granata21416a12013-02-23 01:05:23 +0000515 return wrapper
516 return expectedFailurei386_impl
Johnny Chen869e2962011-12-22 21:14:31 +0000517
Enrico Granata21416a12013-02-23 01:05:23 +0000518def expectedFailureLinux(bugnumber=None):
519 if callable(bugnumber):
520 @wraps(bugnumber)
521 def expectedFailureLinux_easy_wrapper(*args, **kwargs):
Enrico Granata4d82e972013-02-23 01:28:30 +0000522 from unittest2 import case
523 self = args[0]
524 platform = sys.platform
525 try:
526 bugnumber(*args, **kwargs)
527 except Exception:
528 if "linux" in platform:
529 raise case._ExpectedFailure(sys.exc_info(),None)
530 else:
531 raise
532 if "linux" in platform:
533 raise case._UnexpectedSuccess(sys.exc_info(),None)
Enrico Granata21416a12013-02-23 01:05:23 +0000534 return expectedFailureLinux_easy_wrapper
535 else:
536 def expectedFailureLinux_impl(func):
537 @wraps(func)
538 def wrapper(*args, **kwargs):
Enrico Granata4d82e972013-02-23 01:28:30 +0000539 from unittest2 import case
540 self = args[0]
541 platform = sys.platform
542 try:
543 func(*args, **kwargs)
544 except Exception:
545 if "linux" in platform:
546 raise case._ExpectedFailure(sys.exc_info(),bugnumber)
547 else:
548 raise
549 if "linux" in platform:
550 raise case._UnexpectedSuccess(sys.exc_info(),bugnumber)
Enrico Granata21416a12013-02-23 01:05:23 +0000551 return wrapper
552 return expectedFailureLinux_impl
Daniel Malea40c9d752012-11-23 21:59:29 +0000553
Matt Kopec3d4d51c2013-05-07 19:29:28 +0000554def expectedFailureDarwin(bugnumber=None):
555 if callable(bugnumber):
556 @wraps(bugnumber)
557 def expectedFailureDarwin_easy_wrapper(*args, **kwargs):
558 from unittest2 import case
559 self = args[0]
560 platform = sys.platform
561 try:
562 bugnumber(*args, **kwargs)
563 except Exception:
564 if "darwin" in platform:
565 raise case._ExpectedFailure(sys.exc_info(),None)
566 else:
567 raise
568 if "darwin" in platform:
569 raise case._UnexpectedSuccess(sys.exc_info(),None)
570 return expectedFailureDarwin_easy_wrapper
571 else:
572 def expectedFailureDarwin_impl(func):
573 @wraps(func)
574 def wrapper(*args, **kwargs):
575 from unittest2 import case
576 self = args[0]
577 platform = sys.platform
578 try:
579 func(*args, **kwargs)
580 except Exception:
581 if "darwin" in platform:
582 raise case._ExpectedFailure(sys.exc_info(),bugnumber)
583 else:
584 raise
585 if "darwin" in platform:
586 raise case._UnexpectedSuccess(sys.exc_info(),bugnumber)
587 return wrapper
588 return expectedFailureDarwin_impl
589
Daniel Malea6bc4dcd2013-05-15 18:48:32 +0000590def skipIfLinux(func):
Daniel Malea40c9d752012-11-23 21:59:29 +0000591 """Decorate the item to skip tests that should be skipped on Linux."""
592 if isinstance(func, type) and issubclass(func, unittest2.TestCase):
Daniel Malea6bc4dcd2013-05-15 18:48:32 +0000593 raise Exception("@skipIfLinux can only be used to decorate a test method")
Daniel Malea40c9d752012-11-23 21:59:29 +0000594 @wraps(func)
595 def wrapper(*args, **kwargs):
596 from unittest2 import case
597 self = args[0]
598 platform = sys.platform
599 if "linux" in platform:
600 self.skipTest("skip on linux")
601 else:
Jim Ingham7bf78a02012-11-27 01:21:28 +0000602 func(*args, **kwargs)
Daniel Malea40c9d752012-11-23 21:59:29 +0000603 return wrapper
604
Daniel Malea156d8e02013-05-14 20:48:54 +0000605def skipIfLinuxClang(func):
606 """Decorate the item to skip tests that should be skipped if building on
607 Linux with clang.
608 """
609 if isinstance(func, type) and issubclass(func, unittest2.TestCase):
610 raise Exception("@skipIfLinuxClang can only be used to decorate a test method")
611 @wraps(func)
612 def wrapper(*args, **kwargs):
613 from unittest2 import case
614 self = args[0]
615 compiler = self.getCompiler()
616 platform = sys.platform
617 if "clang" in compiler and "linux" in platform:
618 self.skipTest("skipping because Clang is used on Linux")
619 else:
620 func(*args, **kwargs)
621 return wrapper
622
Daniel Maleacd630e72013-01-24 23:52:09 +0000623def skipIfGcc(func):
624 """Decorate the item to skip tests that should be skipped if building with gcc ."""
625 if isinstance(func, type) and issubclass(func, unittest2.TestCase):
Daniel Malea54fcf682013-02-27 17:29:46 +0000626 raise Exception("@skipIfGcc can only be used to decorate a test method")
Daniel Maleacd630e72013-01-24 23:52:09 +0000627 @wraps(func)
628 def wrapper(*args, **kwargs):
629 from unittest2 import case
630 self = args[0]
631 compiler = self.getCompiler()
632 if "gcc" in compiler:
633 self.skipTest("skipping because gcc is the test compiler")
634 else:
635 func(*args, **kwargs)
636 return wrapper
637
Matt Kopec57d4ab22013-03-15 19:10:12 +0000638def skipIfIcc(func):
639 """Decorate the item to skip tests that should be skipped if building with icc ."""
640 if isinstance(func, type) and issubclass(func, unittest2.TestCase):
641 raise Exception("@skipIfIcc can only be used to decorate a test method")
642 @wraps(func)
643 def wrapper(*args, **kwargs):
644 from unittest2 import case
645 self = args[0]
646 compiler = self.getCompiler()
647 if "icc" in compiler:
648 self.skipTest("skipping because icc is the test compiler")
649 else:
650 func(*args, **kwargs)
651 return wrapper
652
Daniel Malea9c570672013-05-02 21:44:31 +0000653def skipIfi386(func):
654 """Decorate the item to skip tests that should be skipped if building 32-bit."""
655 if isinstance(func, type) and issubclass(func, unittest2.TestCase):
656 raise Exception("@skipIfi386 can only be used to decorate a test method")
657 @wraps(func)
658 def wrapper(*args, **kwargs):
659 from unittest2 import case
660 self = args[0]
661 if "i386" == self.getArchitecture():
662 self.skipTest("skipping because i386 is not a supported architecture")
663 else:
664 func(*args, **kwargs)
665 return wrapper
666
667
Johnny Chen366fb8c2011-08-01 18:46:13 +0000668class Base(unittest2.TestCase):
Johnny Chen607b7a12010-10-22 23:15:46 +0000669 """
Johnny Chen366fb8c2011-08-01 18:46:13 +0000670 Abstract base for performing lldb (see TestBase) or other generic tests (see
671 BenchBase for one example). lldbtest.Base works with the test driver to
672 accomplish things.
673
Johnny Chen607b7a12010-10-22 23:15:46 +0000674 """
Enrico Granata671dd552012-10-24 21:42:49 +0000675
Enrico Granata03bc3fd2012-10-24 21:44:48 +0000676 # The concrete subclass should override this attribute.
677 mydir = None
Johnny Chena1affab2010-07-03 03:41:59 +0000678
Johnny Chend3521cc2010-09-16 01:53:04 +0000679 # Keep track of the old current working directory.
680 oldcwd = None
Johnny Chen88f83042010-08-05 21:23:45 +0000681
Johnny Chencbe51262011-08-01 19:50:58 +0000682 def TraceOn(self):
683 """Returns True if we are in trace mode (tracing detailed test execution)."""
684 return traceAlways
685
Johnny Chend3521cc2010-09-16 01:53:04 +0000686 @classmethod
687 def setUpClass(cls):
Johnny Chen41998192010-10-01 22:59:49 +0000688 """
689 Python unittest framework class setup fixture.
690 Do current directory manipulation.
691 """
692
Johnny Chenf8c723b2010-07-03 20:41:42 +0000693 # Fail fast if 'mydir' attribute is not overridden.
Johnny Chend3521cc2010-09-16 01:53:04 +0000694 if not cls.mydir or len(cls.mydir) == 0:
Johnny Chenf8c723b2010-07-03 20:41:42 +0000695 raise Exception("Subclasses must override the 'mydir' attribute.")
Enrico Granata0fd6c8d2012-10-24 18:14:21 +0000696
Johnny Chena1affab2010-07-03 03:41:59 +0000697 # Save old working directory.
Johnny Chend3521cc2010-09-16 01:53:04 +0000698 cls.oldcwd = os.getcwd()
Johnny Chena1affab2010-07-03 03:41:59 +0000699
700 # Change current working directory if ${LLDB_TEST} is defined.
701 # See also dotest.py which sets up ${LLDB_TEST}.
702 if ("LLDB_TEST" in os.environ):
Johnny Chend3521cc2010-09-16 01:53:04 +0000703 if traceAlways:
Johnny Chen72afa8d2010-09-30 17:06:24 +0000704 print >> sys.stderr, "Change dir to:", os.path.join(os.environ["LLDB_TEST"], cls.mydir)
Johnny Chend3521cc2010-09-16 01:53:04 +0000705 os.chdir(os.path.join(os.environ["LLDB_TEST"], cls.mydir))
706
707 @classmethod
708 def tearDownClass(cls):
Johnny Chen41998192010-10-01 22:59:49 +0000709 """
710 Python unittest framework class teardown fixture.
711 Do class-wide cleanup.
712 """
Johnny Chend3521cc2010-09-16 01:53:04 +0000713
Johnny Chen028d8eb2011-11-17 19:57:27 +0000714 if doCleanup and not lldb.skip_build_and_cleanup:
Johnny Chen548aefd2010-10-11 22:25:46 +0000715 # First, let's do the platform-specific cleanup.
Peter Collingbourne39bd5362011-06-20 19:06:20 +0000716 module = builder_module()
Johnny Chen548aefd2010-10-11 22:25:46 +0000717 if not module.cleanup():
718 raise Exception("Don't know how to do cleanup")
Johnny Chend3521cc2010-09-16 01:53:04 +0000719
Johnny Chen548aefd2010-10-11 22:25:46 +0000720 # Subclass might have specific cleanup function defined.
721 if getattr(cls, "classCleanup", None):
722 if traceAlways:
723 print >> sys.stderr, "Call class-specific cleanup function for class:", cls
724 try:
725 cls.classCleanup()
726 except:
727 exc_type, exc_value, exc_tb = sys.exc_info()
728 traceback.print_exception(exc_type, exc_value, exc_tb)
Johnny Chend3521cc2010-09-16 01:53:04 +0000729
730 # Restore old working directory.
731 if traceAlways:
Johnny Chen72afa8d2010-09-30 17:06:24 +0000732 print >> sys.stderr, "Restore dir to:", cls.oldcwd
Johnny Chend3521cc2010-09-16 01:53:04 +0000733 os.chdir(cls.oldcwd)
734
Johnny Chen366fb8c2011-08-01 18:46:13 +0000735 @classmethod
736 def skipLongRunningTest(cls):
737 """
738 By default, we skip long running test case.
739 This can be overridden by passing '-l' to the test driver (dotest.py).
740 """
741 if "LLDB_SKIP_LONG_RUNNING_TEST" in os.environ and "NO" == os.environ["LLDB_SKIP_LONG_RUNNING_TEST"]:
742 return False
743 else:
744 return True
Johnny Chen9a9fcf62011-06-21 00:53:00 +0000745
Johnny Chend3521cc2010-09-16 01:53:04 +0000746 def setUp(self):
Johnny Chencbe51262011-08-01 19:50:58 +0000747 """Fixture for unittest test case setup.
748
749 It works with the test driver to conditionally skip tests and does other
750 initializations."""
Johnny Chend3521cc2010-09-16 01:53:04 +0000751 #import traceback
752 #traceback.print_stack()
Johnny Chena1affab2010-07-03 03:41:59 +0000753
Johnny Chen113388f2011-08-02 22:54:37 +0000754 if "LLDB_EXEC" in os.environ:
755 self.lldbExec = os.environ["LLDB_EXEC"]
Johnny Chen6033bed2011-08-26 00:00:01 +0000756 else:
757 self.lldbExec = None
758 if "LLDB_HERE" in os.environ:
759 self.lldbHere = os.environ["LLDB_HERE"]
760 else:
761 self.lldbHere = None
Johnny Chen7d7f4472011-10-07 19:21:09 +0000762 # If we spawn an lldb process for test (via pexpect), do not load the
763 # init file unless told otherwise.
764 if "NO_LLDBINIT" in os.environ and "NO" == os.environ["NO_LLDBINIT"]:
765 self.lldbOption = ""
766 else:
767 self.lldbOption = "--no-lldbinit"
Johnny Chen113388f2011-08-02 22:54:37 +0000768
Johnny Chen71cb7972011-08-01 21:13:26 +0000769 # Assign the test method name to self.testMethodName.
770 #
771 # For an example of the use of this attribute, look at test/types dir.
772 # There are a bunch of test cases under test/types and we don't want the
773 # module cacheing subsystem to be confused with executable name "a.out"
774 # used for all the test cases.
775 self.testMethodName = self._testMethodName
776
Johnny Chen3ebdacc2010-12-10 18:52:10 +0000777 # Python API only test is decorated with @python_api_test,
778 # which also sets the "__python_api_test__" attribute of the
779 # function object to True.
Johnny Chend8c1dd32011-05-31 23:21:42 +0000780 try:
781 if lldb.just_do_python_api_test:
782 testMethod = getattr(self, self._testMethodName)
783 if getattr(testMethod, "__python_api_test__", False):
784 pass
785 else:
Johnny Chen82ccf402011-07-30 01:39:58 +0000786 self.skipTest("non python api test")
787 except AttributeError:
788 pass
789
790 # Benchmarks test is decorated with @benchmarks_test,
791 # which also sets the "__benchmarks_test__" attribute of the
792 # function object to True.
793 try:
794 if lldb.just_do_benchmarks_test:
795 testMethod = getattr(self, self._testMethodName)
796 if getattr(testMethod, "__benchmarks_test__", False):
797 pass
798 else:
799 self.skipTest("non benchmarks test")
Johnny Chend8c1dd32011-05-31 23:21:42 +0000800 except AttributeError:
801 pass
Johnny Chen3ebdacc2010-12-10 18:52:10 +0000802
Johnny Chen71cb7972011-08-01 21:13:26 +0000803 # This is for the case of directly spawning 'lldb'/'gdb' and interacting
804 # with it using pexpect.
805 self.child = None
806 self.child_prompt = "(lldb) "
807 # If the child is interacting with the embedded script interpreter,
808 # there are two exits required during tear down, first to quit the
809 # embedded script interpreter and second to quit the lldb command
810 # interpreter.
811 self.child_in_script_interpreter = False
812
Johnny Chencbe51262011-08-01 19:50:58 +0000813 # These are for customized teardown cleanup.
814 self.dict = None
815 self.doTearDownCleanup = False
816 # And in rare cases where there are multiple teardown cleanups.
817 self.dicts = []
818 self.doTearDownCleanups = False
819
Daniel Malea5c5f01b2013-02-15 21:21:52 +0000820 # List of spawned subproces.Popen objects
821 self.subprocesses = []
822
Johnny Chencbe51262011-08-01 19:50:58 +0000823 # Create a string buffer to record the session info, to be dumped into a
824 # test case specific file if test failure is encountered.
825 self.session = StringIO.StringIO()
826
827 # Optimistically set __errored__, __failed__, __expected__ to False
828 # initially. If the test errored/failed, the session info
829 # (self.session) is then dumped into a session specific file for
830 # diagnosis.
831 self.__errored__ = False
832 self.__failed__ = False
833 self.__expected__ = False
834 # We are also interested in unexpected success.
835 self.__unexpected__ = False
Johnny Chencd1df5a2011-08-16 00:48:58 +0000836 # And skipped tests.
837 self.__skipped__ = False
Johnny Chencbe51262011-08-01 19:50:58 +0000838
839 # See addTearDownHook(self, hook) which allows the client to add a hook
840 # function to be run during tearDown() time.
841 self.hooks = []
842
843 # See HideStdout(self).
844 self.sys_stdout_hidden = False
845
Daniel Maleae5aa0d42012-11-26 21:21:11 +0000846 # set environment variable names for finding shared libraries
847 if sys.platform.startswith("darwin"):
848 self.dylibPath = 'DYLD_LIBRARY_PATH'
849 elif sys.platform.startswith("linux") or sys.platform.startswith("freebsd"):
850 self.dylibPath = 'LD_LIBRARY_PATH'
851
Johnny Chen644ad082011-10-19 16:48:07 +0000852 def runHooks(self, child=None, child_prompt=None, use_cmd_api=False):
Johnny Chen5f3c5672011-10-19 01:06:21 +0000853 """Perform the run hooks to bring lldb debugger to the desired state.
854
Johnny Chen644ad082011-10-19 16:48:07 +0000855 By default, expect a pexpect spawned child and child prompt to be
856 supplied (use_cmd_api=False). If use_cmd_api is true, ignore the child
857 and child prompt and use self.runCmd() to run the hooks one by one.
858
Johnny Chen5f3c5672011-10-19 01:06:21 +0000859 Note that child is a process spawned by pexpect.spawn(). If not, your
860 test case is mostly likely going to fail.
861
862 See also dotest.py where lldb.runHooks are processed/populated.
863 """
864 if not lldb.runHooks:
865 self.skipTest("No runhooks specified for lldb, skip the test")
Johnny Chen644ad082011-10-19 16:48:07 +0000866 if use_cmd_api:
867 for hook in lldb.runhooks:
868 self.runCmd(hook)
869 else:
870 if not child or not child_prompt:
871 self.fail("Both child and child_prompt need to be defined.")
872 for hook in lldb.runHooks:
873 child.sendline(hook)
874 child.expect_exact(child_prompt)
Johnny Chen5f3c5672011-10-19 01:06:21 +0000875
Daniel Malea8b5c29d2013-02-19 16:08:57 +0000876 def setAsync(self, value):
877 """ Sets async mode to True/False and ensures it is reset after the testcase completes."""
878 old_async = self.dbg.GetAsync()
879 self.dbg.SetAsync(value)
880 self.addTearDownHook(lambda: self.dbg.SetAsync(old_async))
881
Daniel Malea5c5f01b2013-02-15 21:21:52 +0000882 def cleanupSubprocesses(self):
883 # Ensure any subprocesses are cleaned up
884 for p in self.subprocesses:
885 if p.poll() == None:
886 p.terminate()
887 del p
888 del self.subprocesses[:]
889
890 def spawnSubprocess(self, executable, args=[]):
891 """ Creates a subprocess.Popen object with the specified executable and arguments,
892 saves it in self.subprocesses, and returns the object.
893 NOTE: if using this function, ensure you also call:
894
895 self.addTearDownHook(self.cleanupSubprocesses)
896
897 otherwise the test suite will leak processes.
898 """
899
900 # Don't display the stdout if not in TraceOn() mode.
901 proc = Popen([executable] + args,
902 stdout = open(os.devnull) if not self.TraceOn() else None,
903 stdin = PIPE)
904 self.subprocesses.append(proc)
905 return proc
906
Johnny Chencbe51262011-08-01 19:50:58 +0000907 def HideStdout(self):
908 """Hide output to stdout from the user.
909
910 During test execution, there might be cases where we don't want to show the
911 standard output to the user. For example,
912
913 self.runCmd(r'''sc print "\n\n\tHello!\n"''')
914
915 tests whether command abbreviation for 'script' works or not. There is no
916 need to show the 'Hello' output to the user as long as the 'script' command
917 succeeds and we are not in TraceOn() mode (see the '-t' option).
918
919 In this case, the test method calls self.HideStdout(self) to redirect the
920 sys.stdout to a null device, and restores the sys.stdout upon teardown.
921
922 Note that you should only call this method at most once during a test case
923 execution. Any subsequent call has no effect at all."""
924 if self.sys_stdout_hidden:
925 return
926
927 self.sys_stdout_hidden = True
928 old_stdout = sys.stdout
929 sys.stdout = open(os.devnull, 'w')
930 def restore_stdout():
931 sys.stdout = old_stdout
932 self.addTearDownHook(restore_stdout)
933
934 # =======================================================================
935 # Methods for customized teardown cleanups as well as execution of hooks.
936 # =======================================================================
937
938 def setTearDownCleanup(self, dictionary=None):
939 """Register a cleanup action at tearDown() time with a dictinary"""
940 self.dict = dictionary
941 self.doTearDownCleanup = True
942
943 def addTearDownCleanup(self, dictionary):
944 """Add a cleanup action at tearDown() time with a dictinary"""
945 self.dicts.append(dictionary)
946 self.doTearDownCleanups = True
947
948 def addTearDownHook(self, hook):
949 """
950 Add a function to be run during tearDown() time.
951
952 Hooks are executed in a first come first serve manner.
953 """
954 if callable(hook):
955 with recording(self, traceAlways) as sbuf:
956 print >> sbuf, "Adding tearDown hook:", getsource_if_available(hook)
957 self.hooks.append(hook)
958
959 def tearDown(self):
960 """Fixture for unittest test case teardown."""
961 #import traceback
962 #traceback.print_stack()
963
Johnny Chen71cb7972011-08-01 21:13:26 +0000964 # This is for the case of directly spawning 'lldb' and interacting with it
965 # using pexpect.
966 import pexpect
967 if self.child and self.child.isalive():
968 with recording(self, traceAlways) as sbuf:
969 print >> sbuf, "tearing down the child process...."
Johnny Chen71cb7972011-08-01 21:13:26 +0000970 try:
Daniel Maleac29f0f32013-02-22 00:41:26 +0000971 if self.child_in_script_interpreter:
972 self.child.sendline('quit()')
973 self.child.expect_exact(self.child_prompt)
974 self.child.sendline('settings set interpreter.prompt-on-quit false')
975 self.child.sendline('quit')
Johnny Chen71cb7972011-08-01 21:13:26 +0000976 self.child.expect(pexpect.EOF)
Daniel Maleac29f0f32013-02-22 00:41:26 +0000977 except ValueError, ExceptionPexpect:
978 # child is already terminated
Johnny Chen71cb7972011-08-01 21:13:26 +0000979 pass
Daniel Maleac29f0f32013-02-22 00:41:26 +0000980
Johnny Chenf0ff42a2012-02-27 23:07:40 +0000981 # Give it one final blow to make sure the child is terminated.
982 self.child.close()
Johnny Chen71cb7972011-08-01 21:13:26 +0000983
Johnny Chencbe51262011-08-01 19:50:58 +0000984 # Check and run any hook functions.
985 for hook in reversed(self.hooks):
986 with recording(self, traceAlways) as sbuf:
987 print >> sbuf, "Executing tearDown hook:", getsource_if_available(hook)
988 hook()
989
990 del self.hooks
991
992 # Perform registered teardown cleanup.
993 if doCleanup and self.doTearDownCleanup:
Johnny Chen028d8eb2011-11-17 19:57:27 +0000994 self.cleanup(dictionary=self.dict)
Johnny Chencbe51262011-08-01 19:50:58 +0000995
996 # In rare cases where there are multiple teardown cleanups added.
997 if doCleanup and self.doTearDownCleanups:
Johnny Chencbe51262011-08-01 19:50:58 +0000998 if self.dicts:
999 for dict in reversed(self.dicts):
Johnny Chen028d8eb2011-11-17 19:57:27 +00001000 self.cleanup(dictionary=dict)
Johnny Chencbe51262011-08-01 19:50:58 +00001001
1002 # Decide whether to dump the session info.
1003 self.dumpSessionInfo()
1004
1005 # =========================================================
1006 # Various callbacks to allow introspection of test progress
1007 # =========================================================
1008
1009 def markError(self):
1010 """Callback invoked when an error (unexpected exception) errored."""
1011 self.__errored__ = True
1012 with recording(self, False) as sbuf:
1013 # False because there's no need to write "ERROR" to the stderr twice.
1014 # Once by the Python unittest framework, and a second time by us.
1015 print >> sbuf, "ERROR"
1016
1017 def markFailure(self):
1018 """Callback invoked when a failure (test assertion failure) occurred."""
1019 self.__failed__ = True
1020 with recording(self, False) as sbuf:
1021 # False because there's no need to write "FAIL" to the stderr twice.
1022 # Once by the Python unittest framework, and a second time by us.
1023 print >> sbuf, "FAIL"
1024
Enrico Granata21416a12013-02-23 01:05:23 +00001025 def markExpectedFailure(self,err,bugnumber):
Johnny Chencbe51262011-08-01 19:50:58 +00001026 """Callback invoked when an expected failure/error occurred."""
1027 self.__expected__ = True
1028 with recording(self, False) as sbuf:
1029 # False because there's no need to write "expected failure" to the
1030 # stderr twice.
1031 # Once by the Python unittest framework, and a second time by us.
Enrico Granata21416a12013-02-23 01:05:23 +00001032 if bugnumber == None:
1033 print >> sbuf, "expected failure"
1034 else:
1035 print >> sbuf, "expected failure (problem id:" + str(bugnumber) + ")"
Johnny Chencbe51262011-08-01 19:50:58 +00001036
Johnny Chenf5b89092011-08-15 23:09:08 +00001037 def markSkippedTest(self):
1038 """Callback invoked when a test is skipped."""
1039 self.__skipped__ = True
1040 with recording(self, False) as sbuf:
1041 # False because there's no need to write "skipped test" to the
1042 # stderr twice.
1043 # Once by the Python unittest framework, and a second time by us.
1044 print >> sbuf, "skipped test"
1045
Enrico Granata21416a12013-02-23 01:05:23 +00001046 def markUnexpectedSuccess(self, bugnumber):
Johnny Chencbe51262011-08-01 19:50:58 +00001047 """Callback invoked when an unexpected success occurred."""
1048 self.__unexpected__ = True
1049 with recording(self, False) as sbuf:
1050 # False because there's no need to write "unexpected success" to the
1051 # stderr twice.
1052 # Once by the Python unittest framework, and a second time by us.
Enrico Granata21416a12013-02-23 01:05:23 +00001053 if bugnumber == None:
1054 print >> sbuf, "unexpected success"
1055 else:
1056 print >> sbuf, "unexpected success (problem id:" + str(bugnumber) + ")"
Johnny Chencbe51262011-08-01 19:50:58 +00001057
1058 def dumpSessionInfo(self):
1059 """
1060 Dump the debugger interactions leading to a test error/failure. This
1061 allows for more convenient postmortem analysis.
1062
1063 See also LLDBTestResult (dotest.py) which is a singlton class derived
1064 from TextTestResult and overwrites addError, addFailure, and
1065 addExpectedFailure methods to allow us to to mark the test instance as
1066 such.
1067 """
1068
1069 # We are here because self.tearDown() detected that this test instance
1070 # either errored or failed. The lldb.test_result singleton contains
1071 # two lists (erros and failures) which get populated by the unittest
1072 # framework. Look over there for stack trace information.
1073 #
1074 # The lists contain 2-tuples of TestCase instances and strings holding
1075 # formatted tracebacks.
1076 #
1077 # See http://docs.python.org/library/unittest.html#unittest.TestResult.
1078 if self.__errored__:
1079 pairs = lldb.test_result.errors
1080 prefix = 'Error'
1081 elif self.__failed__:
1082 pairs = lldb.test_result.failures
1083 prefix = 'Failure'
1084 elif self.__expected__:
1085 pairs = lldb.test_result.expectedFailures
1086 prefix = 'ExpectedFailure'
Johnny Chenf5b89092011-08-15 23:09:08 +00001087 elif self.__skipped__:
1088 prefix = 'SkippedTest'
Johnny Chencbe51262011-08-01 19:50:58 +00001089 elif self.__unexpected__:
1090 prefix = "UnexpectedSuccess"
1091 else:
1092 # Simply return, there's no session info to dump!
1093 return
1094
Johnny Chenf5b89092011-08-15 23:09:08 +00001095 if not self.__unexpected__ and not self.__skipped__:
Johnny Chencbe51262011-08-01 19:50:58 +00001096 for test, traceback in pairs:
1097 if test is self:
1098 print >> self.session, traceback
1099
Johnny Chen6fd55f12011-08-11 00:16:28 +00001100 testMethod = getattr(self, self._testMethodName)
1101 if getattr(testMethod, "__benchmarks_test__", False):
1102 benchmarks = True
1103 else:
1104 benchmarks = False
1105
Johnny Chendfa0cdb2011-12-03 00:16:59 +00001106 # This records the compiler version used for the test.
1107 system([self.getCompiler(), "-v"], sender=self)
1108
Johnny Chencbe51262011-08-01 19:50:58 +00001109 dname = os.path.join(os.environ["LLDB_TEST"],
1110 os.environ["LLDB_SESSION_DIRNAME"])
1111 if not os.path.isdir(dname):
1112 os.mkdir(dname)
Sean Callanan783ac952012-10-16 18:22:04 +00001113 fname = os.path.join(dname, "%s-%s-%s-%s.log" % (prefix, self.getArchitecture(), "_".join(self.getCompiler().split('/')), self.id()))
Johnny Chencbe51262011-08-01 19:50:58 +00001114 with open(fname, "w") as f:
1115 import datetime
1116 print >> f, "Session info generated @", datetime.datetime.now().ctime()
1117 print >> f, self.session.getvalue()
1118 print >> f, "To rerun this test, issue the following command from the 'test' directory:\n"
Johnny Chen6fd55f12011-08-11 00:16:28 +00001119 print >> f, "./dotest.py %s -v %s -f %s.%s" % (self.getRunOptions(),
1120 ('+b' if benchmarks else '-t'),
Johnny Chencbe51262011-08-01 19:50:58 +00001121 self.__class__.__name__,
1122 self._testMethodName)
1123
1124 # ====================================================
1125 # Config. methods supported through a plugin interface
1126 # (enables reading of the current test configuration)
1127 # ====================================================
1128
1129 def getArchitecture(self):
1130 """Returns the architecture in effect the test suite is running with."""
1131 module = builder_module()
1132 return module.getArchitecture()
1133
1134 def getCompiler(self):
1135 """Returns the compiler in effect the test suite is running with."""
1136 module = builder_module()
1137 return module.getCompiler()
1138
Daniel Malea54fcf682013-02-27 17:29:46 +00001139 def getCompilerVersion(self):
1140 """ Returns a string that represents the compiler version.
1141 Supports: llvm, clang.
1142 """
1143 from lldbutil import which
1144 version = 'unknown'
1145
1146 compiler = self.getCompiler()
1147 version_output = system([which(compiler), "-v"])[1]
1148 for line in version_output.split(os.linesep):
Greg Clayton48c6b332013-03-06 02:34:51 +00001149 m = re.search('version ([0-9\.]+)', line)
Daniel Malea54fcf682013-02-27 17:29:46 +00001150 if m:
1151 version = m.group(1)
1152 return version
1153
Johnny Chencbe51262011-08-01 19:50:58 +00001154 def getRunOptions(self):
1155 """Command line option for -A and -C to run this test again, called from
1156 self.dumpSessionInfo()."""
1157 arch = self.getArchitecture()
1158 comp = self.getCompiler()
Johnny Chenb7058c52011-08-24 19:48:51 +00001159 if arch:
1160 option_str = "-A " + arch
Johnny Chencbe51262011-08-01 19:50:58 +00001161 else:
Johnny Chenb7058c52011-08-24 19:48:51 +00001162 option_str = ""
1163 if comp:
Johnny Chene1219bf2012-03-16 20:44:00 +00001164 option_str += " -C " + comp
Johnny Chenb7058c52011-08-24 19:48:51 +00001165 return option_str
Johnny Chencbe51262011-08-01 19:50:58 +00001166
1167 # ==================================================
1168 # Build methods supported through a plugin interface
1169 # ==================================================
1170
Daniel Malea9c570672013-05-02 21:44:31 +00001171 def buildDriver(self, sources, exe_name):
1172 """ Platform-specific way to build a program that links with LLDB (via the liblldb.so
1173 or LLDB.framework).
1174 """
1175 if "gcc" in self.getCompiler() and "4.6" in self.getCompilerVersion():
Daniel Malea15802aa2013-05-06 19:31:31 +00001176 stdflag = "-std=c++0x"
Daniel Malea9c570672013-05-02 21:44:31 +00001177 else:
1178 stdflag = "-std=c++11"
1179
1180 if sys.platform.startswith("darwin"):
1181 dsym = os.path.join(self.lib_dir, 'LLDB.framework', 'LLDB')
1182 d = {'CXX_SOURCES' : sources,
1183 'EXE' : exe_name,
1184 'CFLAGS_EXTRAS' : "%s -stdlib=libc++" % stdflag,
1185 'FRAMEWORK_INCLUDES' : "-F%s" % self.lib_dir,
Jim Inghamec842242013-05-15 01:11:30 +00001186 'LD_EXTRAS' : "%s -rpath %s" % (dsym, self.lib_dir),
Daniel Malea9c570672013-05-02 21:44:31 +00001187 }
1188 elif sys.platform.startswith("linux") or os.environ.get('LLDB_BUILD_TYPE') == 'Makefile':
1189 d = {'CXX_SOURCES' : sources,
1190 'EXE' : exe_name,
1191 'CFLAGS_EXTRAS' : "%s -I%s" % (stdflag, os.path.join(os.environ["LLDB_SRC"], "include")),
1192 'LD_EXTRAS' : "-L%s -llldb" % self.lib_dir}
1193 if self.TraceOn():
1194 print "Building LLDB Driver (%s) from sources %s" % (exe_name, sources)
1195
1196 self.buildDefault(dictionary=d)
1197
1198 def buildProgram(self, sources, exe_name):
1199 """ Platform specific way to build an executable from C/C++ sources. """
1200 d = {'CXX_SOURCES' : sources,
1201 'EXE' : exe_name}
1202 self.buildDefault(dictionary=d)
1203
Johnny Chencbf15912012-02-01 01:49:50 +00001204 def buildDefault(self, architecture=None, compiler=None, dictionary=None, clean=True):
Johnny Chencbe51262011-08-01 19:50:58 +00001205 """Platform specific way to build the default binaries."""
Johnny Chen028d8eb2011-11-17 19:57:27 +00001206 if lldb.skip_build_and_cleanup:
1207 return
Johnny Chencbe51262011-08-01 19:50:58 +00001208 module = builder_module()
Johnny Chencbf15912012-02-01 01:49:50 +00001209 if not module.buildDefault(self, architecture, compiler, dictionary, clean):
Johnny Chencbe51262011-08-01 19:50:58 +00001210 raise Exception("Don't know how to build default binary")
1211
Johnny Chencbf15912012-02-01 01:49:50 +00001212 def buildDsym(self, architecture=None, compiler=None, dictionary=None, clean=True):
Johnny Chencbe51262011-08-01 19:50:58 +00001213 """Platform specific way to build binaries with dsym info."""
Johnny Chen028d8eb2011-11-17 19:57:27 +00001214 if lldb.skip_build_and_cleanup:
1215 return
Johnny Chencbe51262011-08-01 19:50:58 +00001216 module = builder_module()
Johnny Chencbf15912012-02-01 01:49:50 +00001217 if not module.buildDsym(self, architecture, compiler, dictionary, clean):
Johnny Chencbe51262011-08-01 19:50:58 +00001218 raise Exception("Don't know how to build binary with dsym")
1219
Johnny Chencbf15912012-02-01 01:49:50 +00001220 def buildDwarf(self, architecture=None, compiler=None, dictionary=None, clean=True):
Johnny Chencbe51262011-08-01 19:50:58 +00001221 """Platform specific way to build binaries with dwarf maps."""
Johnny Chen028d8eb2011-11-17 19:57:27 +00001222 if lldb.skip_build_and_cleanup:
1223 return
Johnny Chencbe51262011-08-01 19:50:58 +00001224 module = builder_module()
Johnny Chencbf15912012-02-01 01:49:50 +00001225 if not module.buildDwarf(self, architecture, compiler, dictionary, clean):
Johnny Chencbe51262011-08-01 19:50:58 +00001226 raise Exception("Don't know how to build binary with dwarf")
Johnny Chen366fb8c2011-08-01 18:46:13 +00001227
Johnny Chen7f9985a2011-08-12 20:19:22 +00001228 def cleanup(self, dictionary=None):
1229 """Platform specific way to do cleanup after build."""
Johnny Chen028d8eb2011-11-17 19:57:27 +00001230 if lldb.skip_build_and_cleanup:
1231 return
Johnny Chen7f9985a2011-08-12 20:19:22 +00001232 module = builder_module()
1233 if not module.cleanup(self, dictionary):
Johnny Chen028d8eb2011-11-17 19:57:27 +00001234 raise Exception("Don't know how to do cleanup with dictionary: "+dictionary)
Johnny Chen7f9985a2011-08-12 20:19:22 +00001235
Daniel Malea9c570672013-05-02 21:44:31 +00001236 def getLLDBLibraryEnvVal(self):
1237 """ Returns the path that the OS-specific library search environment variable
1238 (self.dylibPath) should be set to in order for a program to find the LLDB
1239 library. If an environment variable named self.dylibPath is already set,
1240 the new path is appended to it and returned.
1241 """
1242 existing_library_path = os.environ[self.dylibPath] if self.dylibPath in os.environ else None
1243 if existing_library_path:
1244 return "%s:%s" % (existing_library_path, self.lib_dir)
1245 elif sys.platform.startswith("darwin"):
1246 return os.path.join(self.lib_dir, 'LLDB.framework')
1247 else:
1248 return self.lib_dir
Johnny Chen366fb8c2011-08-01 18:46:13 +00001249
1250class TestBase(Base):
1251 """
1252 This abstract base class is meant to be subclassed. It provides default
1253 implementations for setUpClass(), tearDownClass(), setUp(), and tearDown(),
1254 among other things.
1255
1256 Important things for test class writers:
1257
1258 - Overwrite the mydir class attribute, otherwise your test class won't
1259 run. It specifies the relative directory to the top level 'test' so
1260 the test harness can change to the correct working directory before
1261 running your test.
1262
1263 - The setUp method sets up things to facilitate subsequent interactions
1264 with the debugger as part of the test. These include:
1265 - populate the test method name
1266 - create/get a debugger set with synchronous mode (self.dbg)
1267 - get the command interpreter from with the debugger (self.ci)
1268 - create a result object for use with the command interpreter
1269 (self.res)
1270 - plus other stuffs
1271
1272 - The tearDown method tries to perform some necessary cleanup on behalf
1273 of the test to return the debugger to a good state for the next test.
1274 These include:
1275 - execute any tearDown hooks registered by the test method with
1276 TestBase.addTearDownHook(); examples can be found in
1277 settings/TestSettings.py
1278 - kill the inferior process associated with each target, if any,
1279 and, then delete the target from the debugger's target list
1280 - perform build cleanup before running the next test method in the
1281 same test class; examples of registering for this service can be
1282 found in types/TestIntegerTypes.py with the call:
1283 - self.setTearDownCleanup(dictionary=d)
1284
1285 - Similarly setUpClass and tearDownClass perform classwise setup and
1286 teardown fixtures. The tearDownClass method invokes a default build
1287 cleanup for the entire test class; also, subclasses can implement the
1288 classmethod classCleanup(cls) to perform special class cleanup action.
1289
1290 - The instance methods runCmd and expect are used heavily by existing
1291 test cases to send a command to the command interpreter and to perform
1292 string/pattern matching on the output of such command execution. The
1293 expect method also provides a mode to peform string/pattern matching
1294 without running a command.
1295
1296 - The build methods buildDefault, buildDsym, and buildDwarf are used to
1297 build the binaries used during a particular test scenario. A plugin
1298 should be provided for the sys.platform running the test suite. The
1299 Mac OS X implementation is located in plugins/darwin.py.
1300 """
1301
1302 # Maximum allowed attempts when launching the inferior process.
1303 # Can be overridden by the LLDB_MAX_LAUNCH_COUNT environment variable.
1304 maxLaunchCount = 3;
1305
1306 # Time to wait before the next launching attempt in second(s).
1307 # Can be overridden by the LLDB_TIME_WAIT_NEXT_LAUNCH environment variable.
1308 timeWaitNextLaunch = 1.0;
1309
1310 def doDelay(self):
1311 """See option -w of dotest.py."""
1312 if ("LLDB_WAIT_BETWEEN_TEST_CASES" in os.environ and
1313 os.environ["LLDB_WAIT_BETWEEN_TEST_CASES"] == 'YES'):
1314 waitTime = 1.0
1315 if "LLDB_TIME_WAIT_BETWEEN_TEST_CASES" in os.environ:
1316 waitTime = float(os.environ["LLDB_TIME_WAIT_BETWEEN_TEST_CASES"])
1317 time.sleep(waitTime)
1318
Enrico Granataac3a8e22012-09-21 19:10:53 +00001319 # Returns the list of categories to which this test case belongs
1320 # by default, look for a ".categories" file, and read its contents
1321 # if no such file exists, traverse the hierarchy - we guarantee
1322 # a .categories to exist at the top level directory so we do not end up
1323 # looping endlessly - subclasses are free to define their own categories
1324 # in whatever way makes sense to them
1325 def getCategories(self):
1326 import inspect
1327 import os.path
1328 folder = inspect.getfile(self.__class__)
1329 folder = os.path.dirname(folder)
1330 while folder != '/':
1331 categories_file_name = os.path.join(folder,".categories")
1332 if os.path.exists(categories_file_name):
1333 categories_file = open(categories_file_name,'r')
1334 categories = categories_file.readline()
1335 categories_file.close()
1336 categories = str.replace(categories,'\n','')
1337 categories = str.replace(categories,'\r','')
1338 return categories.split(',')
1339 else:
1340 folder = os.path.dirname(folder)
1341 continue
1342
Johnny Chen366fb8c2011-08-01 18:46:13 +00001343 def setUp(self):
1344 #import traceback
1345 #traceback.print_stack()
1346
1347 # Works with the test driver to conditionally skip tests via decorators.
1348 Base.setUp(self)
1349
Johnny Chen366fb8c2011-08-01 18:46:13 +00001350 try:
1351 if lldb.blacklist:
1352 className = self.__class__.__name__
1353 classAndMethodName = "%s.%s" % (className, self._testMethodName)
1354 if className in lldb.blacklist:
1355 self.skipTest(lldb.blacklist.get(className))
1356 elif classAndMethodName in lldb.blacklist:
1357 self.skipTest(lldb.blacklist.get(classAndMethodName))
1358 except AttributeError:
1359 pass
1360
Johnny Chen9a9fcf62011-06-21 00:53:00 +00001361 # Insert some delay between successive test cases if specified.
1362 self.doDelay()
Johnny Chene47649c2010-10-07 02:04:14 +00001363
Johnny Chen65572482010-08-25 18:49:48 +00001364 if "LLDB_MAX_LAUNCH_COUNT" in os.environ:
1365 self.maxLaunchCount = int(os.environ["LLDB_MAX_LAUNCH_COUNT"])
1366
Johnny Chend2965212010-10-19 16:00:42 +00001367 if "LLDB_TIME_WAIT_NEXT_LAUNCH" in os.environ:
Johnny Chen458a67e2010-11-29 20:20:34 +00001368 self.timeWaitNextLaunch = float(os.environ["LLDB_TIME_WAIT_NEXT_LAUNCH"])
Johnny Chen65572482010-08-25 18:49:48 +00001369
Johnny Chena1affab2010-07-03 03:41:59 +00001370 # Create the debugger instance if necessary.
1371 try:
1372 self.dbg = lldb.DBG
Johnny Chena1affab2010-07-03 03:41:59 +00001373 except AttributeError:
1374 self.dbg = lldb.SBDebugger.Create()
Johnny Chenf8c723b2010-07-03 20:41:42 +00001375
Johnny Chen960ce122011-05-25 19:06:18 +00001376 if not self.dbg:
Johnny Chena1affab2010-07-03 03:41:59 +00001377 raise Exception('Invalid debugger instance')
1378
1379 # We want our debugger to be synchronous.
1380 self.dbg.SetAsync(False)
1381
1382 # Retrieve the associated command interpreter instance.
1383 self.ci = self.dbg.GetCommandInterpreter()
1384 if not self.ci:
1385 raise Exception('Could not get the command interpreter')
1386
1387 # And the result object.
1388 self.res = lldb.SBCommandReturnObject()
1389
Johnny Chenac97a6b2012-04-16 18:55:15 +00001390 # Run global pre-flight code, if defined via the config file.
1391 if lldb.pre_flight:
1392 lldb.pre_flight(self)
1393
Enrico Granata251729e2012-10-24 01:23:57 +00001394 # utility methods that tests can use to access the current objects
1395 def target(self):
1396 if not self.dbg:
1397 raise Exception('Invalid debugger instance')
1398 return self.dbg.GetSelectedTarget()
1399
1400 def process(self):
1401 if not self.dbg:
1402 raise Exception('Invalid debugger instance')
1403 return self.dbg.GetSelectedTarget().GetProcess()
1404
1405 def thread(self):
1406 if not self.dbg:
1407 raise Exception('Invalid debugger instance')
1408 return self.dbg.GetSelectedTarget().GetProcess().GetSelectedThread()
1409
1410 def frame(self):
1411 if not self.dbg:
1412 raise Exception('Invalid debugger instance')
1413 return self.dbg.GetSelectedTarget().GetProcess().GetSelectedThread().GetSelectedFrame()
1414
Johnny Chena1affab2010-07-03 03:41:59 +00001415 def tearDown(self):
Johnny Chen72a14342010-09-02 21:23:12 +00001416 #import traceback
1417 #traceback.print_stack()
1418
Johnny Chencbe51262011-08-01 19:50:58 +00001419 Base.tearDown(self)
Johnny Chen705737b2010-10-19 23:40:13 +00001420
Johnny Chen409646d2011-06-15 21:24:24 +00001421 # Delete the target(s) from the debugger as a general cleanup step.
1422 # This includes terminating the process for each target, if any.
1423 # We'd like to reuse the debugger for our next test without incurring
1424 # the initialization overhead.
1425 targets = []
1426 for target in self.dbg:
1427 if target:
1428 targets.append(target)
1429 process = target.GetProcess()
1430 if process:
1431 rc = self.invoke(process, "Kill")
1432 self.assertTrue(rc.Success(), PROCESS_KILLED)
1433 for target in targets:
1434 self.dbg.DeleteTarget(target)
Johnny Chenffde4fc2010-08-16 21:28:10 +00001435
Johnny Chenac97a6b2012-04-16 18:55:15 +00001436 # Run global post-flight code, if defined via the config file.
1437 if lldb.post_flight:
1438 lldb.post_flight(self)
1439
Johnny Chena1affab2010-07-03 03:41:59 +00001440 del self.dbg
Johnny Chen84a6d6f2010-10-15 01:18:29 +00001441
Johnny Chen90c56e62011-09-30 21:48:35 +00001442 def switch_to_thread_with_stop_reason(self, stop_reason):
1443 """
1444 Run the 'thread list' command, and select the thread with stop reason as
1445 'stop_reason'. If no such thread exists, no select action is done.
1446 """
1447 from lldbutil import stop_reason_to_str
1448 self.runCmd('thread list')
1449 output = self.res.GetOutput()
1450 thread_line_pattern = re.compile("^[ *] thread #([0-9]+):.*stop reason = %s" %
1451 stop_reason_to_str(stop_reason))
1452 for line in output.splitlines():
1453 matched = thread_line_pattern.match(line)
1454 if matched:
1455 self.runCmd('thread select %s' % matched.group(1))
1456
Johnny Chenef6f4762011-06-15 21:38:39 +00001457 def runCmd(self, cmd, msg=None, check=True, trace=False):
Johnny Chen8df95eb2010-08-19 23:26:59 +00001458 """
1459 Ask the command interpreter to handle the command and then check its
1460 return status.
1461 """
1462 # Fail fast if 'cmd' is not meaningful.
1463 if not cmd or len(cmd) == 0:
1464 raise Exception("Bad 'cmd' parameter encountered")
Johnny Chen4f995f02010-08-20 17:57:32 +00001465
Johnny Chen9de4ede2010-08-31 17:42:54 +00001466 trace = (True if traceAlways else trace)
Johnny Chend0c24b22010-08-23 17:10:44 +00001467
Johnny Chen21f33412010-09-01 00:15:19 +00001468 running = (cmd.startswith("run") or cmd.startswith("process launch"))
Johnny Chen4f995f02010-08-20 17:57:32 +00001469
Johnny Chen21f33412010-09-01 00:15:19 +00001470 for i in range(self.maxLaunchCount if running else 1):
Johnny Chen65572482010-08-25 18:49:48 +00001471 self.ci.HandleCommand(cmd, self.res)
Johnny Chen4f995f02010-08-20 17:57:32 +00001472
Johnny Chen84a6d6f2010-10-15 01:18:29 +00001473 with recording(self, trace) as sbuf:
1474 print >> sbuf, "runCmd:", cmd
Johnny Chen7c565c82010-10-15 16:13:00 +00001475 if not check:
Johnny Chen31cf8e22010-10-15 18:52:22 +00001476 print >> sbuf, "check of return status not required"
Johnny Chen65572482010-08-25 18:49:48 +00001477 if self.res.Succeeded():
Johnny Chen84a6d6f2010-10-15 01:18:29 +00001478 print >> sbuf, "output:", self.res.GetOutput()
Johnny Chen65572482010-08-25 18:49:48 +00001479 else:
Johnny Chen84a6d6f2010-10-15 01:18:29 +00001480 print >> sbuf, "runCmd failed!"
1481 print >> sbuf, self.res.GetError()
Johnny Chen4f995f02010-08-20 17:57:32 +00001482
Johnny Chen029acae2010-08-20 21:03:09 +00001483 if self.res.Succeeded():
Johnny Chen65572482010-08-25 18:49:48 +00001484 break
Johnny Chen84a6d6f2010-10-15 01:18:29 +00001485 elif running:
Johnny Chendcb37222011-01-19 02:02:08 +00001486 # For process launch, wait some time before possible next try.
1487 time.sleep(self.timeWaitNextLaunch)
Johnny Chen894eab42012-08-01 19:56:04 +00001488 with recording(self, trace) as sbuf:
Johnny Chen84a6d6f2010-10-15 01:18:29 +00001489 print >> sbuf, "Command '" + cmd + "' failed!"
Johnny Chen4f995f02010-08-20 17:57:32 +00001490
Johnny Chen8df95eb2010-08-19 23:26:59 +00001491 if check:
1492 self.assertTrue(self.res.Succeeded(),
Johnny Chen05efcf782010-11-09 18:42:22 +00001493 msg if msg else CMD_MSG(cmd))
Johnny Chen8df95eb2010-08-19 23:26:59 +00001494
Jim Ingham431d8392012-09-22 00:05:11 +00001495 def match (self, str, patterns, msg=None, trace=False, error=False, matching=True, exe=True):
1496 """run command in str, and match the result against regexp in patterns returning the match object for the first matching pattern
1497
1498 Otherwise, all the arguments have the same meanings as for the expect function"""
1499
1500 trace = (True if traceAlways else trace)
1501
1502 if exe:
1503 # First run the command. If we are expecting error, set check=False.
1504 # Pass the assert message along since it provides more semantic info.
1505 self.runCmd(str, msg=msg, trace = (True if trace else False), check = not error)
1506
1507 # Then compare the output against expected strings.
1508 output = self.res.GetError() if error else self.res.GetOutput()
1509
1510 # If error is True, the API client expects the command to fail!
1511 if error:
1512 self.assertFalse(self.res.Succeeded(),
1513 "Command '" + str + "' is expected to fail!")
1514 else:
1515 # No execution required, just compare str against the golden input.
1516 output = str
1517 with recording(self, trace) as sbuf:
1518 print >> sbuf, "looking at:", output
1519
1520 # The heading says either "Expecting" or "Not expecting".
1521 heading = "Expecting" if matching else "Not expecting"
1522
1523 for pattern in patterns:
1524 # Match Objects always have a boolean value of True.
1525 match_object = re.search(pattern, output)
1526 matched = bool(match_object)
1527 with recording(self, trace) as sbuf:
1528 print >> sbuf, "%s pattern: %s" % (heading, pattern)
1529 print >> sbuf, "Matched" if matched else "Not matched"
1530 if matched:
1531 break
1532
1533 self.assertTrue(matched if matching else not matched,
1534 msg if msg else EXP_MSG(str, exe))
1535
1536 return match_object
1537
Johnny Chen90c56e62011-09-30 21:48:35 +00001538 def expect(self, str, msg=None, patterns=None, startstr=None, endstr=None, substrs=None, trace=False, error=False, matching=True, exe=True):
Johnny Chen8df95eb2010-08-19 23:26:59 +00001539 """
1540 Similar to runCmd; with additional expect style output matching ability.
1541
1542 Ask the command interpreter to handle the command and then check its
1543 return status. The 'msg' parameter specifies an informational assert
1544 message. We expect the output from running the command to start with
Johnny Chen2d899752010-09-21 21:08:53 +00001545 'startstr', matches the substrings contained in 'substrs', and regexp
1546 matches the patterns contained in 'patterns'.
Johnny Chen9792f8e2010-09-17 22:28:51 +00001547
1548 If the keyword argument error is set to True, it signifies that the API
1549 client is expecting the command to fail. In this case, the error stream
Johnny Chenee975b82010-09-17 22:45:27 +00001550 from running the command is retrieved and compared against the golden
Johnny Chen9792f8e2010-09-17 22:28:51 +00001551 input, instead.
Johnny Chen2d899752010-09-21 21:08:53 +00001552
1553 If the keyword argument matching is set to False, it signifies that the API
1554 client is expecting the output of the command not to match the golden
1555 input.
Johnny Chen8e06de92010-09-21 23:33:30 +00001556
1557 Finally, the required argument 'str' represents the lldb command to be
1558 sent to the command interpreter. In case the keyword argument 'exe' is
1559 set to False, the 'str' is treated as a string to be matched/not-matched
1560 against the golden input.
Johnny Chen8df95eb2010-08-19 23:26:59 +00001561 """
Johnny Chen9de4ede2010-08-31 17:42:54 +00001562 trace = (True if traceAlways else trace)
Johnny Chend0c24b22010-08-23 17:10:44 +00001563
Johnny Chen8e06de92010-09-21 23:33:30 +00001564 if exe:
1565 # First run the command. If we are expecting error, set check=False.
Johnny Chen60881f62010-10-28 21:10:32 +00001566 # Pass the assert message along since it provides more semantic info.
Johnny Chen05dd8932010-10-28 18:24:22 +00001567 self.runCmd(str, msg=msg, trace = (True if trace else False), check = not error)
Johnny Chen8df95eb2010-08-19 23:26:59 +00001568
Johnny Chen8e06de92010-09-21 23:33:30 +00001569 # Then compare the output against expected strings.
1570 output = self.res.GetError() if error else self.res.GetOutput()
Johnny Chen9792f8e2010-09-17 22:28:51 +00001571
Johnny Chen8e06de92010-09-21 23:33:30 +00001572 # If error is True, the API client expects the command to fail!
1573 if error:
1574 self.assertFalse(self.res.Succeeded(),
1575 "Command '" + str + "' is expected to fail!")
1576 else:
1577 # No execution required, just compare str against the golden input.
Enrico Granata01458ca2012-10-23 00:09:02 +00001578 if isinstance(str,lldb.SBCommandReturnObject):
1579 output = str.GetOutput()
1580 else:
1581 output = str
Johnny Chen84a6d6f2010-10-15 01:18:29 +00001582 with recording(self, trace) as sbuf:
1583 print >> sbuf, "looking at:", output
Johnny Chen9792f8e2010-09-17 22:28:51 +00001584
Johnny Chen2d899752010-09-21 21:08:53 +00001585 # The heading says either "Expecting" or "Not expecting".
Johnny Chen84a6d6f2010-10-15 01:18:29 +00001586 heading = "Expecting" if matching else "Not expecting"
Johnny Chen2d899752010-09-21 21:08:53 +00001587
1588 # Start from the startstr, if specified.
1589 # If there's no startstr, set the initial state appropriately.
1590 matched = output.startswith(startstr) if startstr else (True if matching else False)
Johnny Chenead35c82010-08-20 18:25:15 +00001591
Johnny Chen84a6d6f2010-10-15 01:18:29 +00001592 if startstr:
1593 with recording(self, trace) as sbuf:
1594 print >> sbuf, "%s start string: %s" % (heading, startstr)
1595 print >> sbuf, "Matched" if matched else "Not matched"
Johnny Chenead35c82010-08-20 18:25:15 +00001596
Johnny Chen90c56e62011-09-30 21:48:35 +00001597 # Look for endstr, if specified.
1598 keepgoing = matched if matching else not matched
1599 if endstr:
1600 matched = output.endswith(endstr)
1601 with recording(self, trace) as sbuf:
1602 print >> sbuf, "%s end string: %s" % (heading, endstr)
1603 print >> sbuf, "Matched" if matched else "Not matched"
1604
Johnny Chen2d899752010-09-21 21:08:53 +00001605 # Look for sub strings, if specified.
1606 keepgoing = matched if matching else not matched
1607 if substrs and keepgoing:
Johnny Chen8df95eb2010-08-19 23:26:59 +00001608 for str in substrs:
Johnny Chen091bb1d2010-09-23 23:35:28 +00001609 matched = output.find(str) != -1
Johnny Chen84a6d6f2010-10-15 01:18:29 +00001610 with recording(self, trace) as sbuf:
1611 print >> sbuf, "%s sub string: %s" % (heading, str)
1612 print >> sbuf, "Matched" if matched else "Not matched"
Johnny Chen2d899752010-09-21 21:08:53 +00001613 keepgoing = matched if matching else not matched
1614 if not keepgoing:
Johnny Chen8df95eb2010-08-19 23:26:59 +00001615 break
1616
Johnny Chen2d899752010-09-21 21:08:53 +00001617 # Search for regular expression patterns, if specified.
1618 keepgoing = matched if matching else not matched
1619 if patterns and keepgoing:
1620 for pattern in patterns:
1621 # Match Objects always have a boolean value of True.
1622 matched = bool(re.search(pattern, output))
Johnny Chen84a6d6f2010-10-15 01:18:29 +00001623 with recording(self, trace) as sbuf:
1624 print >> sbuf, "%s pattern: %s" % (heading, pattern)
1625 print >> sbuf, "Matched" if matched else "Not matched"
Johnny Chen2d899752010-09-21 21:08:53 +00001626 keepgoing = matched if matching else not matched
1627 if not keepgoing:
1628 break
Johnny Chen2d899752010-09-21 21:08:53 +00001629
1630 self.assertTrue(matched if matching else not matched,
Johnny Chen05efcf782010-11-09 18:42:22 +00001631 msg if msg else EXP_MSG(str, exe))
Johnny Chen8df95eb2010-08-19 23:26:59 +00001632
Johnny Chena8b3cdd2010-08-25 22:52:45 +00001633 def invoke(self, obj, name, trace=False):
Johnny Chend8473bc2010-08-25 22:56:10 +00001634 """Use reflection to call a method dynamically with no argument."""
Johnny Chen9de4ede2010-08-31 17:42:54 +00001635 trace = (True if traceAlways else trace)
Johnny Chena8b3cdd2010-08-25 22:52:45 +00001636
1637 method = getattr(obj, name)
1638 import inspect
1639 self.assertTrue(inspect.ismethod(method),
1640 name + "is a method name of object: " + str(obj))
1641 result = method()
Johnny Chen84a6d6f2010-10-15 01:18:29 +00001642 with recording(self, trace) as sbuf:
1643 print >> sbuf, str(method) + ":", result
Johnny Chena8b3cdd2010-08-25 22:52:45 +00001644 return result
Johnny Chen9c10c182010-08-27 00:15:48 +00001645
Johnny Chenb8770312011-05-27 23:36:52 +00001646 # =================================================
1647 # Misc. helper methods for debugging test execution
1648 # =================================================
1649
Johnny Chen57cd6dd2011-07-11 19:15:11 +00001650 def DebugSBValue(self, val):
Johnny Chen9de4ede2010-08-31 17:42:54 +00001651 """Debug print a SBValue object, if traceAlways is True."""
Johnny Chen47342d52011-04-27 17:43:07 +00001652 from lldbutil import value_type_to_str
Johnny Chen2c8d1592010-11-03 21:37:58 +00001653
Johnny Chen9de4ede2010-08-31 17:42:54 +00001654 if not traceAlways:
Johnny Chen9c10c182010-08-27 00:15:48 +00001655 return
1656
1657 err = sys.stderr
1658 err.write(val.GetName() + ":\n")
Johnny Chen90c56e62011-09-30 21:48:35 +00001659 err.write('\t' + "TypeName -> " + val.GetTypeName() + '\n')
1660 err.write('\t' + "ByteSize -> " + str(val.GetByteSize()) + '\n')
1661 err.write('\t' + "NumChildren -> " + str(val.GetNumChildren()) + '\n')
1662 err.write('\t' + "Value -> " + str(val.GetValue()) + '\n')
1663 err.write('\t' + "ValueAsUnsigned -> " + str(val.GetValueAsUnsigned())+ '\n')
1664 err.write('\t' + "ValueType -> " + value_type_to_str(val.GetValueType()) + '\n')
1665 err.write('\t' + "Summary -> " + str(val.GetSummary()) + '\n')
1666 err.write('\t' + "IsPointerType -> " + str(val.TypeIsPointerType()) + '\n')
1667 err.write('\t' + "Location -> " + val.GetLocation() + '\n')
Johnny Chen9c10c182010-08-27 00:15:48 +00001668
Johnny Chend7e04d92011-08-05 20:17:27 +00001669 def DebugSBType(self, type):
1670 """Debug print a SBType object, if traceAlways is True."""
1671 if not traceAlways:
1672 return
1673
1674 err = sys.stderr
1675 err.write(type.GetName() + ":\n")
1676 err.write('\t' + "ByteSize -> " + str(type.GetByteSize()) + '\n')
1677 err.write('\t' + "IsPointerType -> " + str(type.IsPointerType()) + '\n')
1678 err.write('\t' + "IsReferenceType -> " + str(type.IsReferenceType()) + '\n')
1679
Johnny Chen73041472011-03-12 01:18:19 +00001680 def DebugPExpect(self, child):
1681 """Debug the spwaned pexpect object."""
1682 if not traceAlways:
1683 return
1684
1685 print child
Filipe Cabecinhasdee13ce2012-06-20 10:13:40 +00001686
1687 @classmethod
1688 def RemoveTempFile(cls, file):
1689 if os.path.exists(file):
1690 os.remove(file)