2010-07-03 03:41:59 +00:00
|
|
|
"""
|
|
|
|
LLDB module which provides the abstract base class of lldb test case.
|
|
|
|
|
|
|
|
The concrete subclass can override lldbtest.TesBase in order to inherit the
|
|
|
|
common behavior for unitest.TestCase.setUp/tearDown implemented in this file.
|
|
|
|
|
|
|
|
The subclass should override the attribute mydir in order for the python runtime
|
|
|
|
to locate the individual test cases when running as part of a large test suite
|
|
|
|
or when running each test case as a separate python invocation.
|
|
|
|
|
|
|
|
./dotest.py provides a test driver which sets up the environment to run the
|
|
|
|
entire test suite. Users who want to run a test case on its own can specify the
|
|
|
|
LLDB_TEST and PYTHONPATH environment variables, for example:
|
|
|
|
|
|
|
|
$ export LLDB_TEST=$PWD
|
2010-08-31 17:42:54 +00:00
|
|
|
$ export PYTHONPATH=/Volumes/data/lldb/svn/trunk/build/Debug/LLDB.framework/Resources/Python:$LLDB_TEST:$LLDB_TEST/plugins
|
2010-07-03 03:41:59 +00:00
|
|
|
$ echo $LLDB_TEST
|
|
|
|
/Volumes/data/lldb/svn/trunk/test
|
|
|
|
$ echo $PYTHONPATH
|
2010-08-31 17:42:54 +00:00
|
|
|
/Volumes/data/lldb/svn/trunk/build/Debug/LLDB.framework/Resources/Python:/Volumes/data/lldb/svn/trunk/test:/Volumes/data/lldb/svn/trunk/test/plugins
|
2010-07-03 03:41:59 +00:00
|
|
|
$ python function_types/TestFunctionTypes.py
|
|
|
|
.
|
|
|
|
----------------------------------------------------------------------
|
|
|
|
Ran 1 test in 0.363s
|
|
|
|
|
2010-08-23 17:10:44 +00:00
|
|
|
OK
|
|
|
|
$ LLDB_COMMAND_TRACE=YES python array_types/TestArrayTypes.py
|
2010-09-02 22:25:47 +00:00
|
|
|
|
|
|
|
...
|
2010-08-23 17:10:44 +00:00
|
|
|
|
|
|
|
runCmd: breakpoint set -f main.c -l 42
|
|
|
|
output: Breakpoint created: 1: file ='main.c', line = 42, locations = 1
|
|
|
|
|
|
|
|
runCmd: run
|
|
|
|
output: Launching '/Volumes/data/lldb/svn/trunk/test/array_types/a.out' (x86_64)
|
|
|
|
|
2010-09-02 22:25:47 +00:00
|
|
|
...
|
2010-08-23 17:10:44 +00:00
|
|
|
|
2010-09-02 22:25:47 +00:00
|
|
|
runCmd: frame variable strings
|
2010-08-23 17:10:44 +00:00
|
|
|
output: (char *[4]) strings = {
|
|
|
|
(char *) strings[0] = 0x0000000100000f0c "Hello",
|
|
|
|
(char *) strings[1] = 0x0000000100000f12 "Hola",
|
|
|
|
(char *) strings[2] = 0x0000000100000f17 "Bonjour",
|
|
|
|
(char *) strings[3] = 0x0000000100000f1f "Guten Tag"
|
|
|
|
}
|
|
|
|
|
2010-09-02 22:25:47 +00:00
|
|
|
runCmd: frame variable char_16
|
2010-08-23 17:10:44 +00:00
|
|
|
output: (char [16]) char_16 = {
|
|
|
|
(char) char_16[0] = 'H',
|
|
|
|
(char) char_16[1] = 'e',
|
|
|
|
(char) char_16[2] = 'l',
|
|
|
|
(char) char_16[3] = 'l',
|
|
|
|
(char) char_16[4] = 'o',
|
|
|
|
(char) char_16[5] = ' ',
|
|
|
|
(char) char_16[6] = 'W',
|
|
|
|
(char) char_16[7] = 'o',
|
|
|
|
(char) char_16[8] = 'r',
|
|
|
|
(char) char_16[9] = 'l',
|
|
|
|
(char) char_16[10] = 'd',
|
|
|
|
(char) char_16[11] = '\n',
|
|
|
|
(char) char_16[12] = '\0',
|
|
|
|
(char) char_16[13] = '\0',
|
|
|
|
(char) char_16[14] = '\0',
|
|
|
|
(char) char_16[15] = '\0'
|
|
|
|
}
|
|
|
|
|
2010-09-02 22:25:47 +00:00
|
|
|
runCmd: frame variable ushort_matrix
|
2010-08-23 17:10:44 +00:00
|
|
|
output: (unsigned short [2][3]) ushort_matrix = {
|
|
|
|
(unsigned short [3]) ushort_matrix[0] = {
|
|
|
|
(unsigned short) ushort_matrix[0][0] = 0x0001,
|
|
|
|
(unsigned short) ushort_matrix[0][1] = 0x0002,
|
|
|
|
(unsigned short) ushort_matrix[0][2] = 0x0003
|
|
|
|
},
|
|
|
|
(unsigned short [3]) ushort_matrix[1] = {
|
|
|
|
(unsigned short) ushort_matrix[1][0] = 0x000b,
|
|
|
|
(unsigned short) ushort_matrix[1][1] = 0x0016,
|
|
|
|
(unsigned short) ushort_matrix[1][2] = 0x0021
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-09-02 22:25:47 +00:00
|
|
|
runCmd: frame variable long_6
|
2010-08-23 17:10:44 +00:00
|
|
|
output: (long [6]) long_6 = {
|
|
|
|
(long) long_6[0] = 1,
|
|
|
|
(long) long_6[1] = 2,
|
|
|
|
(long) long_6[2] = 3,
|
|
|
|
(long) long_6[3] = 4,
|
|
|
|
(long) long_6[4] = 5,
|
|
|
|
(long) long_6[5] = 6
|
|
|
|
}
|
|
|
|
|
|
|
|
.
|
|
|
|
----------------------------------------------------------------------
|
|
|
|
Ran 1 test in 0.349s
|
|
|
|
|
2010-07-03 03:41:59 +00:00
|
|
|
OK
|
|
|
|
$
|
|
|
|
"""
|
|
|
|
|
2010-09-21 22:34:45 +00:00
|
|
|
import os, sys, traceback
|
2010-09-21 21:08:53 +00:00
|
|
|
import re
|
2010-08-30 21:35:00 +00:00
|
|
|
from subprocess import *
|
2010-10-15 01:18:29 +00:00
|
|
|
import StringIO
|
2010-08-25 18:49:48 +00:00
|
|
|
import time
|
2010-08-30 23:08:52 +00:00
|
|
|
import types
|
2010-08-05 23:42:46 +00:00
|
|
|
import unittest2
|
2010-07-03 03:41:59 +00:00
|
|
|
import lldb
|
|
|
|
|
2010-10-11 22:25:46 +00:00
|
|
|
# See also dotest.parseOptionsAndInitTestdirs(), where the environment variables
|
|
|
|
# LLDB_COMMAND_TRACE and LLDB_NO_CLEANUP are set from '-t' and '-r dir' options.
|
|
|
|
|
|
|
|
# By default, traceAlways is False.
|
2010-08-31 17:42:54 +00:00
|
|
|
if "LLDB_COMMAND_TRACE" in os.environ and os.environ["LLDB_COMMAND_TRACE"]=="YES":
|
|
|
|
traceAlways = True
|
|
|
|
else:
|
|
|
|
traceAlways = False
|
|
|
|
|
2010-10-11 22:25:46 +00:00
|
|
|
# By default, doCleanup is True.
|
|
|
|
if "LLDB_DO_CLEANUP" in os.environ and os.environ["LLDB_DO_CLEANUP"]=="NO":
|
|
|
|
doCleanup = False
|
|
|
|
else:
|
|
|
|
doCleanup = True
|
|
|
|
|
2010-08-31 17:42:54 +00:00
|
|
|
|
2010-08-09 22:01:17 +00:00
|
|
|
#
|
|
|
|
# Some commonly used assert messages.
|
|
|
|
#
|
|
|
|
|
2010-09-17 22:45:27 +00:00
|
|
|
COMMAND_FAILED_AS_EXPECTED = "Command has failed as expected"
|
|
|
|
|
2010-08-09 22:01:17 +00:00
|
|
|
CURRENT_EXECUTABLE_SET = "Current executable set successfully"
|
|
|
|
|
2010-09-02 21:23:12 +00:00
|
|
|
PROCESS_IS_VALID = "Process is valid"
|
|
|
|
|
|
|
|
PROCESS_KILLED = "Process is killed successfully"
|
|
|
|
|
2010-08-27 23:47:36 +00:00
|
|
|
RUN_SUCCEEDED = "Process is launched successfully"
|
2010-08-09 22:01:17 +00:00
|
|
|
|
2010-08-09 23:44:24 +00:00
|
|
|
RUN_COMPLETED = "Process exited successfully"
|
2010-08-09 22:01:17 +00:00
|
|
|
|
2010-10-05 19:27:32 +00:00
|
|
|
BACKTRACE_DISPLAYED_CORRECTLY = "Backtrace displayed correctly"
|
|
|
|
|
2010-08-09 23:44:24 +00:00
|
|
|
BREAKPOINT_CREATED = "Breakpoint created successfully"
|
|
|
|
|
2010-08-17 21:33:31 +00:00
|
|
|
BREAKPOINT_PENDING_CREATED = "Pending breakpoint created successfully"
|
|
|
|
|
2010-08-09 23:44:24 +00:00
|
|
|
BREAKPOINT_HIT_ONCE = "Breakpoint resolved with hit cout = 1"
|
2010-08-09 22:01:17 +00:00
|
|
|
|
2010-09-30 17:06:24 +00:00
|
|
|
BREAKPOINT_HIT_TWICE = "Breakpoint resolved with hit cout = 2"
|
|
|
|
|
2010-10-15 18:07:09 +00:00
|
|
|
BREAKPOINT_HIT_THRICE = "Breakpoint resolved with hit cout = 3"
|
|
|
|
|
2010-09-22 23:00:20 +00:00
|
|
|
STEP_OUT_SUCCEEDED = "Thread step-out succeeded"
|
|
|
|
|
2010-11-10 23:46:38 +00:00
|
|
|
STOPPED_DUE_TO_BREAKPOINT = "Process should be stopped due to breakpoint"
|
2010-11-10 20:20:06 +00:00
|
|
|
|
2010-11-10 23:46:38 +00:00
|
|
|
STOPPED_DUE_TO_BREAKPOINT_WITH_STOP_REASON_AS = "%s, %s" % (
|
|
|
|
STOPPED_DUE_TO_BREAKPOINT, "instead, the actual stop reason is: '%s'")
|
2010-08-09 22:01:17 +00:00
|
|
|
|
2010-10-20 18:38:48 +00:00
|
|
|
STOPPED_DUE_TO_BREAKPOINT_CONDITION = "Stopped due to breakpoint condition"
|
|
|
|
|
2010-10-14 01:22:03 +00:00
|
|
|
STOPPED_DUE_TO_SIGNAL = "Process state is stopped due to signal"
|
|
|
|
|
2010-08-09 22:01:17 +00:00
|
|
|
STOPPED_DUE_TO_STEP_IN = "Process state is stopped due to step in"
|
|
|
|
|
2010-08-24 22:07:56 +00:00
|
|
|
DATA_TYPES_DISPLAYED_CORRECTLY = "Data type(s) displayed correctly"
|
|
|
|
|
2010-08-26 20:04:17 +00:00
|
|
|
VALID_BREAKPOINT = "Got a valid breakpoint"
|
|
|
|
|
2010-10-22 18:10:25 +00:00
|
|
|
VALID_BREAKPOINT_LOCATION = "Got a valid breakpoint location"
|
|
|
|
|
2010-08-27 23:47:36 +00:00
|
|
|
VALID_FILESPEC = "Got a valid filespec"
|
|
|
|
|
2010-08-26 20:04:17 +00:00
|
|
|
VALID_PROCESS = "Got a valid process"
|
|
|
|
|
|
|
|
VALID_TARGET = "Got a valid target"
|
|
|
|
|
2010-08-25 19:00:04 +00:00
|
|
|
VARIABLES_DISPLAYED_CORRECTLY = "Variable(s) displayed correctly"
|
2010-08-09 22:01:17 +00:00
|
|
|
|
2010-08-26 20:04:17 +00:00
|
|
|
|
2010-08-09 23:44:24 +00:00
|
|
|
#
|
|
|
|
# And a generic "Command '%s' returns successfully" message generator.
|
|
|
|
#
|
2010-11-09 18:42:22 +00:00
|
|
|
def CMD_MSG(str):
|
|
|
|
return "Command '%s' returns successfully" % str
|
|
|
|
|
|
|
|
#
|
|
|
|
# And a generic "'%s' returns expected result" message generator if exe.
|
|
|
|
# Otherwise, it's "'%s' matches expected result"
|
|
|
|
#
|
|
|
|
def EXP_MSG(str, exe):
|
|
|
|
return "'%s' %s expected result" % (str, 'returns' if exe else 'matches')
|
2010-08-09 23:44:24 +00:00
|
|
|
|
2010-10-19 19:11:38 +00:00
|
|
|
#
|
|
|
|
# And a generic "Value of setting '%s' is correct" message generator.
|
|
|
|
#
|
|
|
|
def SETTING_MSG(setting):
|
|
|
|
return "Value of setting '%s' is correct" % setting
|
|
|
|
|
2010-08-26 21:49:29 +00:00
|
|
|
#
|
|
|
|
# Returns an env variable array from the os.environ map object.
|
|
|
|
#
|
|
|
|
def EnvArray():
|
|
|
|
return map(lambda k,v: k+"="+v, os.environ.keys(), os.environ.values())
|
|
|
|
|
2010-10-11 23:52:19 +00:00
|
|
|
def line_number(filename, string_to_match):
|
|
|
|
"""Helper function to return the line number of the first matched string."""
|
|
|
|
with open(filename, 'r') as f:
|
|
|
|
for i, line in enumerate(f):
|
|
|
|
if line.find(string_to_match) != -1:
|
|
|
|
# Found our match.
|
2010-10-12 00:09:25 +00:00
|
|
|
return i+1
|
2010-10-11 23:52:19 +00:00
|
|
|
return -1
|
|
|
|
|
2010-10-05 19:27:32 +00:00
|
|
|
def pointer_size():
|
|
|
|
"""Return the pointer size of the host system."""
|
|
|
|
import ctypes
|
|
|
|
a_pointer = ctypes.c_void_p(0xffff)
|
|
|
|
return 8 * ctypes.sizeof(a_pointer)
|
|
|
|
|
2010-08-27 00:15:48 +00:00
|
|
|
|
2010-10-15 01:18:29 +00:00
|
|
|
class recording(StringIO.StringIO):
|
|
|
|
"""
|
|
|
|
A nice little context manager for recording the debugger interactions into
|
|
|
|
our session object. If trace flag is ON, it also emits the interactions
|
|
|
|
into the stderr.
|
|
|
|
"""
|
|
|
|
def __init__(self, test, trace):
|
Some re-achitecturing of the plugins interface. The caller is now required to
pass in a 'sender' arg to the buildDefault(), buildDsym(), buildDwarf(), and
cleanup() functions. The sender arg will be the test instance itself (i.e.,
an instance of TestBase). This is so that the relevant command execution can be
recorded in the TestBase.session object if sender is available.
The lldbtest.system() command has been modified to pop the 'sender' arg out of
the keyword arguments dictionary and use it as the test instance to facilitate
seesion recordings. An example is in test/types/AbstractBase.py:
def generic_type_tester(self, atoms, quotedDisplay=False):
"""Test that variables with basic types are displayed correctly."""
# First, capture the golden output emitted by the oracle, i.e., the
# series of printf statements.
go = system("./a.out", sender=self)
There are cases when sender is None. This is the case when the @classmethod is
involved in the use of these APIs. When this happens, there is no recording
into a session object, but printing on the sys.stderr is still honored if the
trace flag is ON.
An example is in test/settings/TestSettings.py:
@classmethod
def classCleanup(cls):
system(["/bin/sh", "-c", "rm -f output.txt"])
system(["/bin/sh", "-c", "rm -f stdout.txt"])
llvm-svn: 116648
2010-10-15 23:55:05 +00:00
|
|
|
"""Create a StringIO instance; record the session obj and trace flag."""
|
2010-10-15 01:18:29 +00:00
|
|
|
StringIO.StringIO.__init__(self)
|
Some re-achitecturing of the plugins interface. The caller is now required to
pass in a 'sender' arg to the buildDefault(), buildDsym(), buildDwarf(), and
cleanup() functions. The sender arg will be the test instance itself (i.e.,
an instance of TestBase). This is so that the relevant command execution can be
recorded in the TestBase.session object if sender is available.
The lldbtest.system() command has been modified to pop the 'sender' arg out of
the keyword arguments dictionary and use it as the test instance to facilitate
seesion recordings. An example is in test/types/AbstractBase.py:
def generic_type_tester(self, atoms, quotedDisplay=False):
"""Test that variables with basic types are displayed correctly."""
# First, capture the golden output emitted by the oracle, i.e., the
# series of printf statements.
go = system("./a.out", sender=self)
There are cases when sender is None. This is the case when the @classmethod is
involved in the use of these APIs. When this happens, there is no recording
into a session object, but printing on the sys.stderr is still honored if the
trace flag is ON.
An example is in test/settings/TestSettings.py:
@classmethod
def classCleanup(cls):
system(["/bin/sh", "-c", "rm -f output.txt"])
system(["/bin/sh", "-c", "rm -f stdout.txt"])
llvm-svn: 116648
2010-10-15 23:55:05 +00:00
|
|
|
self.session = test.session if test else None
|
2010-10-15 01:18:29 +00:00
|
|
|
self.trace = trace
|
|
|
|
|
|
|
|
def __enter__(self):
|
|
|
|
"""
|
|
|
|
Context management protocol on entry to the body of the with statement.
|
|
|
|
Just return the StringIO object.
|
|
|
|
"""
|
|
|
|
return self
|
|
|
|
|
|
|
|
def __exit__(self, type, value, tb):
|
|
|
|
"""
|
|
|
|
Context management protocol on exit from the body of the with statement.
|
|
|
|
If trace is ON, it emits the recordings into stderr. Always add the
|
|
|
|
recordings to our session object. And close the StringIO object, too.
|
|
|
|
"""
|
|
|
|
if self.trace:
|
Some re-achitecturing of the plugins interface. The caller is now required to
pass in a 'sender' arg to the buildDefault(), buildDsym(), buildDwarf(), and
cleanup() functions. The sender arg will be the test instance itself (i.e.,
an instance of TestBase). This is so that the relevant command execution can be
recorded in the TestBase.session object if sender is available.
The lldbtest.system() command has been modified to pop the 'sender' arg out of
the keyword arguments dictionary and use it as the test instance to facilitate
seesion recordings. An example is in test/types/AbstractBase.py:
def generic_type_tester(self, atoms, quotedDisplay=False):
"""Test that variables with basic types are displayed correctly."""
# First, capture the golden output emitted by the oracle, i.e., the
# series of printf statements.
go = system("./a.out", sender=self)
There are cases when sender is None. This is the case when the @classmethod is
involved in the use of these APIs. When this happens, there is no recording
into a session object, but printing on the sys.stderr is still honored if the
trace flag is ON.
An example is in test/settings/TestSettings.py:
@classmethod
def classCleanup(cls):
system(["/bin/sh", "-c", "rm -f output.txt"])
system(["/bin/sh", "-c", "rm -f stdout.txt"])
llvm-svn: 116648
2010-10-15 23:55:05 +00:00
|
|
|
print >> sys.stderr, self.getvalue()
|
|
|
|
if self.session:
|
|
|
|
print >> self.session, self.getvalue()
|
2010-10-15 01:18:29 +00:00
|
|
|
self.close()
|
|
|
|
|
Some re-achitecturing of the plugins interface. The caller is now required to
pass in a 'sender' arg to the buildDefault(), buildDsym(), buildDwarf(), and
cleanup() functions. The sender arg will be the test instance itself (i.e.,
an instance of TestBase). This is so that the relevant command execution can be
recorded in the TestBase.session object if sender is available.
The lldbtest.system() command has been modified to pop the 'sender' arg out of
the keyword arguments dictionary and use it as the test instance to facilitate
seesion recordings. An example is in test/types/AbstractBase.py:
def generic_type_tester(self, atoms, quotedDisplay=False):
"""Test that variables with basic types are displayed correctly."""
# First, capture the golden output emitted by the oracle, i.e., the
# series of printf statements.
go = system("./a.out", sender=self)
There are cases when sender is None. This is the case when the @classmethod is
involved in the use of these APIs. When this happens, there is no recording
into a session object, but printing on the sys.stderr is still honored if the
trace flag is ON.
An example is in test/settings/TestSettings.py:
@classmethod
def classCleanup(cls):
system(["/bin/sh", "-c", "rm -f output.txt"])
system(["/bin/sh", "-c", "rm -f stdout.txt"])
llvm-svn: 116648
2010-10-15 23:55:05 +00:00
|
|
|
# From 2.7's subprocess.check_output() convenience function.
|
|
|
|
def system(*popenargs, **kwargs):
|
|
|
|
r"""Run command with arguments and return its output as a byte string.
|
|
|
|
|
|
|
|
If the exit code was non-zero it raises a CalledProcessError. The
|
|
|
|
CalledProcessError object will have the return code in the returncode
|
|
|
|
attribute and output in the output attribute.
|
|
|
|
|
|
|
|
The arguments are the same as for the Popen constructor. Example:
|
|
|
|
|
|
|
|
>>> check_output(["ls", "-l", "/dev/null"])
|
|
|
|
'crw-rw-rw- 1 root root 1, 3 Oct 18 2007 /dev/null\n'
|
|
|
|
|
|
|
|
The stdout argument is not allowed as it is used internally.
|
|
|
|
To capture standard error in the result, use stderr=STDOUT.
|
|
|
|
|
|
|
|
>>> check_output(["/bin/sh", "-c",
|
|
|
|
... "ls -l non_existent_file ; exit 0"],
|
|
|
|
... stderr=STDOUT)
|
|
|
|
'ls: non_existent_file: No such file or directory\n'
|
|
|
|
"""
|
|
|
|
|
|
|
|
# Assign the sender object to variable 'test' and remove it from kwargs.
|
|
|
|
test = kwargs.pop('sender', None)
|
|
|
|
|
|
|
|
if 'stdout' in kwargs:
|
|
|
|
raise ValueError('stdout argument not allowed, it will be overridden.')
|
|
|
|
process = Popen(stdout=PIPE, *popenargs, **kwargs)
|
|
|
|
output, error = process.communicate()
|
|
|
|
retcode = process.poll()
|
|
|
|
|
|
|
|
with recording(test, traceAlways) as sbuf:
|
|
|
|
if isinstance(popenargs, types.StringTypes):
|
|
|
|
args = [popenargs]
|
|
|
|
else:
|
|
|
|
args = list(popenargs)
|
|
|
|
print >> sbuf
|
|
|
|
print >> sbuf, "os command:", args
|
|
|
|
print >> sbuf, "stdout:", output
|
|
|
|
print >> sbuf, "stderr:", error
|
|
|
|
print >> sbuf, "retcode:", retcode
|
|
|
|
print >> sbuf
|
|
|
|
|
|
|
|
if retcode:
|
|
|
|
cmd = kwargs.get("args")
|
|
|
|
if cmd is None:
|
|
|
|
cmd = popenargs[0]
|
|
|
|
raise CalledProcessError(retcode, cmd)
|
|
|
|
return output
|
|
|
|
|
2010-11-01 20:35:01 +00:00
|
|
|
def getsource_if_available(obj):
|
|
|
|
"""
|
|
|
|
Return the text of the source code for an object if available. Otherwise,
|
|
|
|
a print representation is returned.
|
|
|
|
"""
|
|
|
|
import inspect
|
|
|
|
try:
|
|
|
|
return inspect.getsource(obj)
|
|
|
|
except:
|
|
|
|
return repr(obj)
|
|
|
|
|
2010-08-05 23:42:46 +00:00
|
|
|
class TestBase(unittest2.TestCase):
|
2010-10-22 23:15:46 +00:00
|
|
|
"""
|
|
|
|
This abstract base class is meant to be subclassed. It provides default
|
|
|
|
implementations for setUpClass(), tearDownClass(), setUp(), and tearDown(),
|
|
|
|
among other things.
|
|
|
|
|
|
|
|
Important things for test class writers:
|
|
|
|
|
|
|
|
- Overwrite the mydir class attribute, otherwise your test class won't
|
|
|
|
run. It specifies the relative directory to the top level 'test' so
|
|
|
|
the test harness can change to the correct working directory before
|
|
|
|
running your test.
|
|
|
|
|
|
|
|
- The setUp method sets up things to facilitate subsequent interactions
|
|
|
|
with the debugger as part of the test. These include:
|
|
|
|
- create/get a debugger set with synchronous mode (self.dbg)
|
|
|
|
- get the command interpreter from with the debugger (self.ci)
|
|
|
|
- create a result object for use with the command interpreter
|
|
|
|
(self.result)
|
|
|
|
- plus other stuffs
|
|
|
|
|
|
|
|
- The tearDown method tries to perform some necessary cleanup on behalf
|
|
|
|
of the test to return the debugger to a good state for the next test.
|
|
|
|
These include:
|
|
|
|
- execute any tearDown hooks registered by the test method with
|
|
|
|
TestBase.addTearDownHook(); examples can be found in
|
|
|
|
settings/TestSettings.py
|
|
|
|
- kill the inferior process launched during the test method
|
|
|
|
- if by 'run' or 'process launch' command, 'process kill'
|
|
|
|
command is used
|
|
|
|
- if the test method uses LLDB Python API to launch process,
|
|
|
|
it should assign the process object to self.process; that
|
|
|
|
way, tearDown will use self.process.Kill() on the object
|
|
|
|
- perform build cleanup before running the next test method in the
|
|
|
|
same test class; examples of registering for this service can be
|
|
|
|
found in types/TestIntegerTypes.py with the call:
|
|
|
|
- self.setTearDownCleanup(dictionary=d)
|
|
|
|
|
|
|
|
- Similarly setUpClass and tearDownClass perform classwise setup and
|
|
|
|
teardown fixtures. The tearDownClass method invokes a default build
|
|
|
|
cleanup for the entire test class; also, subclasses can implement the
|
|
|
|
classmethod classCleanup(cls) to perform special class cleanup action.
|
|
|
|
|
|
|
|
- The instance methods runCmd and expect are used heavily by existing
|
|
|
|
test cases to send a command to the command interpreter and to perform
|
|
|
|
string/pattern matching on the output of such command execution. The
|
|
|
|
expect method also provides a mode to peform string/pattern matching
|
|
|
|
without running a command.
|
|
|
|
|
|
|
|
- The build methods buildDefault, buildDsym, and buildDwarf are used to
|
|
|
|
build the binaries used during a particular test scenario. A plugin
|
|
|
|
should be provided for the sys.platform running the test suite. The
|
|
|
|
Mac OS X implementation is located in plugins/darwin.py.
|
|
|
|
|
|
|
|
"""
|
2010-07-03 03:41:59 +00:00
|
|
|
|
2010-10-01 22:59:49 +00:00
|
|
|
@classmethod
|
|
|
|
def skipLongRunningTest(cls):
|
|
|
|
"""
|
|
|
|
By default, we skip long running test case.
|
|
|
|
This can be overridden by passing '-l' to the test driver (dotest.py).
|
|
|
|
"""
|
|
|
|
if "LLDB_SKIP_LONG_RUNNING_TEST" in os.environ and "NO" == os.environ["LLDB_SKIP_LONG_RUNNING_TEST"]:
|
|
|
|
return False
|
|
|
|
else:
|
|
|
|
return True
|
|
|
|
|
2010-07-03 03:41:59 +00:00
|
|
|
# The concrete subclass should override this attribute.
|
2010-07-03 20:41:42 +00:00
|
|
|
mydir = None
|
2010-07-03 03:41:59 +00:00
|
|
|
|
2010-08-16 21:28:10 +00:00
|
|
|
# State pertaining to the inferior process, if any.
|
2010-09-02 22:25:47 +00:00
|
|
|
# This reflects inferior process started through the command interface with
|
|
|
|
# either the lldb "run" or "process launch" command.
|
|
|
|
# See also self.runCmd().
|
2010-08-16 21:28:10 +00:00
|
|
|
runStarted = False
|
|
|
|
|
2010-08-25 18:49:48 +00:00
|
|
|
# Maximum allowed attempts when launching the inferior process.
|
|
|
|
# Can be overridden by the LLDB_MAX_LAUNCH_COUNT environment variable.
|
|
|
|
maxLaunchCount = 3;
|
|
|
|
|
|
|
|
# Time to wait before the next launching attempt in second(s).
|
2010-10-19 16:00:42 +00:00
|
|
|
# Can be overridden by the LLDB_TIME_WAIT_NEXT_LAUNCH environment variable.
|
2010-08-25 18:49:48 +00:00
|
|
|
timeWait = 1.0;
|
|
|
|
|
2010-09-16 01:53:04 +00:00
|
|
|
# Keep track of the old current working directory.
|
|
|
|
oldcwd = None
|
2010-08-05 21:23:45 +00:00
|
|
|
|
2010-09-16 01:53:04 +00:00
|
|
|
@classmethod
|
|
|
|
def setUpClass(cls):
|
2010-10-01 22:59:49 +00:00
|
|
|
"""
|
|
|
|
Python unittest framework class setup fixture.
|
|
|
|
Do current directory manipulation.
|
|
|
|
"""
|
|
|
|
|
2010-07-03 20:41:42 +00:00
|
|
|
# Fail fast if 'mydir' attribute is not overridden.
|
2010-09-16 01:53:04 +00:00
|
|
|
if not cls.mydir or len(cls.mydir) == 0:
|
2010-07-03 20:41:42 +00:00
|
|
|
raise Exception("Subclasses must override the 'mydir' attribute.")
|
2010-07-03 03:41:59 +00:00
|
|
|
# Save old working directory.
|
2010-09-16 01:53:04 +00:00
|
|
|
cls.oldcwd = os.getcwd()
|
2010-07-03 03:41:59 +00:00
|
|
|
|
|
|
|
# Change current working directory if ${LLDB_TEST} is defined.
|
|
|
|
# See also dotest.py which sets up ${LLDB_TEST}.
|
|
|
|
if ("LLDB_TEST" in os.environ):
|
2010-09-16 01:53:04 +00:00
|
|
|
if traceAlways:
|
2010-09-30 17:06:24 +00:00
|
|
|
print >> sys.stderr, "Change dir to:", os.path.join(os.environ["LLDB_TEST"], cls.mydir)
|
2010-09-16 01:53:04 +00:00
|
|
|
os.chdir(os.path.join(os.environ["LLDB_TEST"], cls.mydir))
|
|
|
|
|
|
|
|
@classmethod
|
|
|
|
def tearDownClass(cls):
|
2010-10-01 22:59:49 +00:00
|
|
|
"""
|
|
|
|
Python unittest framework class teardown fixture.
|
|
|
|
Do class-wide cleanup.
|
|
|
|
"""
|
2010-09-16 01:53:04 +00:00
|
|
|
|
2010-10-11 22:25:46 +00:00
|
|
|
if doCleanup:
|
|
|
|
# First, let's do the platform-specific cleanup.
|
|
|
|
module = __import__(sys.platform)
|
|
|
|
if not module.cleanup():
|
|
|
|
raise Exception("Don't know how to do cleanup")
|
2010-09-16 01:53:04 +00:00
|
|
|
|
2010-10-11 22:25:46 +00:00
|
|
|
# Subclass might have specific cleanup function defined.
|
|
|
|
if getattr(cls, "classCleanup", None):
|
|
|
|
if traceAlways:
|
|
|
|
print >> sys.stderr, "Call class-specific cleanup function for class:", cls
|
|
|
|
try:
|
|
|
|
cls.classCleanup()
|
|
|
|
except:
|
|
|
|
exc_type, exc_value, exc_tb = sys.exc_info()
|
|
|
|
traceback.print_exception(exc_type, exc_value, exc_tb)
|
2010-09-16 01:53:04 +00:00
|
|
|
|
|
|
|
# Restore old working directory.
|
|
|
|
if traceAlways:
|
2010-09-30 17:06:24 +00:00
|
|
|
print >> sys.stderr, "Restore dir to:", cls.oldcwd
|
2010-09-16 01:53:04 +00:00
|
|
|
os.chdir(cls.oldcwd)
|
|
|
|
|
|
|
|
def setUp(self):
|
|
|
|
#import traceback
|
|
|
|
#traceback.print_stack()
|
2010-07-03 03:41:59 +00:00
|
|
|
|
2010-10-07 02:04:14 +00:00
|
|
|
if ("LLDB_WAIT_BETWEEN_TEST_CASES" in os.environ and
|
|
|
|
os.environ["LLDB_WAIT_BETWEEN_TEST_CASES"] == 'YES'):
|
|
|
|
time.sleep(0.5)
|
|
|
|
|
2010-08-25 18:49:48 +00:00
|
|
|
if "LLDB_MAX_LAUNCH_COUNT" in os.environ:
|
|
|
|
self.maxLaunchCount = int(os.environ["LLDB_MAX_LAUNCH_COUNT"])
|
|
|
|
|
2010-10-19 16:00:42 +00:00
|
|
|
if "LLDB_TIME_WAIT_NEXT_LAUNCH" in os.environ:
|
|
|
|
self.timeWait = float(os.environ["LLDB_TIME_WAIT_NEXT_LAUNCH"])
|
2010-08-25 18:49:48 +00:00
|
|
|
|
2010-07-03 03:41:59 +00:00
|
|
|
# Create the debugger instance if necessary.
|
|
|
|
try:
|
|
|
|
self.dbg = lldb.DBG
|
|
|
|
except AttributeError:
|
|
|
|
self.dbg = lldb.SBDebugger.Create()
|
2010-07-03 20:41:42 +00:00
|
|
|
|
2010-07-03 03:41:59 +00:00
|
|
|
if not self.dbg.IsValid():
|
|
|
|
raise Exception('Invalid debugger instance')
|
|
|
|
|
|
|
|
# We want our debugger to be synchronous.
|
|
|
|
self.dbg.SetAsync(False)
|
|
|
|
|
2010-09-02 21:23:12 +00:00
|
|
|
# There is no process associated with the debugger as yet.
|
2010-09-02 22:25:47 +00:00
|
|
|
# See also self.tearDown() where it checks whether self.process has a
|
|
|
|
# valid reference and calls self.process.Kill() to kill the process.
|
2010-09-02 21:23:12 +00:00
|
|
|
self.process = None
|
|
|
|
|
2010-07-03 03:41:59 +00:00
|
|
|
# Retrieve the associated command interpreter instance.
|
|
|
|
self.ci = self.dbg.GetCommandInterpreter()
|
|
|
|
if not self.ci:
|
|
|
|
raise Exception('Could not get the command interpreter')
|
|
|
|
|
|
|
|
# And the result object.
|
|
|
|
self.res = lldb.SBCommandReturnObject()
|
|
|
|
|
2010-09-22 23:00:20 +00:00
|
|
|
# These are for customized teardown cleanup.
|
|
|
|
self.dict = None
|
|
|
|
self.doTearDownCleanup = False
|
|
|
|
|
Some re-achitecturing of the plugins interface. The caller is now required to
pass in a 'sender' arg to the buildDefault(), buildDsym(), buildDwarf(), and
cleanup() functions. The sender arg will be the test instance itself (i.e.,
an instance of TestBase). This is so that the relevant command execution can be
recorded in the TestBase.session object if sender is available.
The lldbtest.system() command has been modified to pop the 'sender' arg out of
the keyword arguments dictionary and use it as the test instance to facilitate
seesion recordings. An example is in test/types/AbstractBase.py:
def generic_type_tester(self, atoms, quotedDisplay=False):
"""Test that variables with basic types are displayed correctly."""
# First, capture the golden output emitted by the oracle, i.e., the
# series of printf statements.
go = system("./a.out", sender=self)
There are cases when sender is None. This is the case when the @classmethod is
involved in the use of these APIs. When this happens, there is no recording
into a session object, but printing on the sys.stderr is still honored if the
trace flag is ON.
An example is in test/settings/TestSettings.py:
@classmethod
def classCleanup(cls):
system(["/bin/sh", "-c", "rm -f output.txt"])
system(["/bin/sh", "-c", "rm -f stdout.txt"])
llvm-svn: 116648
2010-10-15 23:55:05 +00:00
|
|
|
# Create a string buffer to record the session info, to be dumped into a
|
|
|
|
# test case specific file if test failure is encountered.
|
2010-10-15 01:18:29 +00:00
|
|
|
self.session = StringIO.StringIO()
|
|
|
|
|
2010-11-03 18:17:03 +00:00
|
|
|
# Optimistically set __errored__, __failed__, __expected__ to False
|
2010-10-19 00:25:01 +00:00
|
|
|
# initially. If the test errored/failed, the session info
|
|
|
|
# (self.session) is then dumped into a session specific file for
|
|
|
|
# diagnosis.
|
|
|
|
self.__errored__ = False
|
2010-10-15 02:28:13 +00:00
|
|
|
self.__failed__ = False
|
2010-11-03 18:17:03 +00:00
|
|
|
self.__expected__ = False
|
2010-10-15 02:28:13 +00:00
|
|
|
|
2010-10-19 23:40:13 +00:00
|
|
|
# See addTearDownHook(self, hook) which allows the client to add a hook
|
|
|
|
# function to be run during tearDown() time.
|
|
|
|
self.hooks = []
|
|
|
|
|
2010-10-19 00:25:01 +00:00
|
|
|
def markError(self):
|
2010-11-05 18:10:11 +00:00
|
|
|
"""Callback invoked when an error (unexpected exception) errored."""
|
2010-10-19 00:25:01 +00:00
|
|
|
self.__errored__ = True
|
|
|
|
with recording(self, False) as sbuf:
|
|
|
|
# False because there's no need to write "ERROR" to the stderr twice.
|
|
|
|
# Once by the Python unittest framework, and a second time by us.
|
|
|
|
print >> sbuf, "ERROR"
|
|
|
|
|
2010-10-15 01:18:29 +00:00
|
|
|
def markFailure(self):
|
2010-11-05 18:10:11 +00:00
|
|
|
"""Callback invoked when a failure (test assertion failure) occurred."""
|
2010-10-15 02:28:13 +00:00
|
|
|
self.__failed__ = True
|
2010-10-15 01:18:29 +00:00
|
|
|
with recording(self, False) as sbuf:
|
2010-10-15 16:22:10 +00:00
|
|
|
# False because there's no need to write "FAIL" to the stderr twice.
|
|
|
|
# Once by the Python unittest framework, and a second time by us.
|
2010-10-15 01:18:29 +00:00
|
|
|
print >> sbuf, "FAIL"
|
|
|
|
|
2010-11-03 18:17:03 +00:00
|
|
|
def markExpectedFailure(self):
|
|
|
|
"""Callback invoked when an expected failure/error occurred."""
|
|
|
|
self.__expected__ = True
|
|
|
|
with recording(self, False) as sbuf:
|
|
|
|
# False because there's no need to write "expected failure" to the
|
|
|
|
# stderr twice.
|
|
|
|
# Once by the Python unittest framework, and a second time by us.
|
|
|
|
print >> sbuf, "expected failure"
|
|
|
|
|
2010-10-15 01:18:29 +00:00
|
|
|
def dumpSessionInfo(self):
|
|
|
|
"""
|
2010-10-19 00:25:01 +00:00
|
|
|
Dump the debugger interactions leading to a test error/failure. This
|
|
|
|
allows for more convenient postmortem analysis.
|
2010-11-03 18:17:03 +00:00
|
|
|
|
|
|
|
See also LLDBTestResult (dotest.py) which is a singlton class derived
|
|
|
|
from TextTestResult and overwrites addError, addFailure, and
|
|
|
|
addExpectedFailure methods to allow us to to mark the test instance as
|
|
|
|
such.
|
2010-10-15 01:18:29 +00:00
|
|
|
"""
|
2010-11-03 00:09:38 +00:00
|
|
|
|
|
|
|
# We are here because self.tearDown() detected that this test instance
|
|
|
|
# either errored or failed. The lldb.test_result singleton contains
|
|
|
|
# two lists (erros and failures) which get populated by the unittest
|
|
|
|
# framework. Look over there for stack trace information.
|
|
|
|
#
|
2010-11-03 18:17:03 +00:00
|
|
|
# The lists contain 2-tuples of TestCase instances and strings holding
|
|
|
|
# formatted tracebacks.
|
|
|
|
#
|
2010-11-03 00:09:38 +00:00
|
|
|
# See http://docs.python.org/library/unittest.html#unittest.TestResult.
|
2010-11-03 18:17:03 +00:00
|
|
|
if self.__errored__:
|
|
|
|
pairs = lldb.test_result.errors
|
2010-11-06 00:07:07 +00:00
|
|
|
prefix = 'Error'
|
2010-11-03 18:17:03 +00:00
|
|
|
elif self.__failed__:
|
|
|
|
pairs = lldb.test_result.failures
|
2010-11-06 00:07:07 +00:00
|
|
|
prefix = 'Failure'
|
2010-11-03 18:17:03 +00:00
|
|
|
elif self.__expected__:
|
|
|
|
pairs = lldb.test_result.expectedFailures
|
2010-11-06 00:07:07 +00:00
|
|
|
prefix = 'ExpectedFailure'
|
2010-11-03 18:17:03 +00:00
|
|
|
else:
|
|
|
|
# Simply return, there's no session info to dump!
|
|
|
|
return
|
|
|
|
|
|
|
|
for test, traceback in pairs:
|
2010-10-15 01:18:29 +00:00
|
|
|
if test is self:
|
2010-11-03 18:17:03 +00:00
|
|
|
print >> self.session, traceback
|
2010-10-15 01:18:29 +00:00
|
|
|
|
2010-10-19 00:25:01 +00:00
|
|
|
dname = os.path.join(os.environ["LLDB_TEST"],
|
Add an option '-s session-dir-name' to overwrite the default timestamp-named
directory used to dump the session info for test failures/errors.
Example:
/Volumes/data/lldb/svn/trunk/test $ ./dotest.py -s jason -v array_types
Session info for test errors or failures will go into directory jason
----------------------------------------------------------------------
Collected 4 tests
test_with_dsym_and_python_api (TestArrayTypes.ArrayTypesTestCase)
Use Python APIs to inspect variables with array types. ... ok
test_with_dsym_and_run_command (TestArrayTypes.ArrayTypesTestCase)
Test 'frame variable var_name' on some variables with array types. ... ok
test_with_dwarf_and_python_api (TestArrayTypes.ArrayTypesTestCase)
Use Python APIs to inspect variables with array types. ... ok
test_with_dwarf_and_run_command (TestArrayTypes.ArrayTypesTestCase)
Test 'frame variable var_name' on some variables with array types. ... FAIL
======================================================================
FAIL: test_with_dwarf_and_run_command (TestArrayTypes.ArrayTypesTestCase)
Test 'frame variable var_name' on some variables with array types.
----------------------------------------------------------------------
Traceback (most recent call last):
File "/Volumes/data/lldb/svn/trunk/test/array_types/TestArrayTypes.py", line 27, in test_with_dwarf_and_run_command
self.array_types()
File "/Volumes/data/lldb/svn/trunk/test/array_types/TestArrayTypes.py", line 62, in array_types
'stop reason = breakpoint'])
File "/Volumes/data/lldb/svn/trunk/test/lldbtest.py", line 594, in expect
self.runCmd(str, trace = (True if trace else False), check = not error)
File "/Volumes/data/lldb/svn/trunk/test/lldbtest.py", line 564, in runCmd
msg if msg else CMD_MSG(cmd, True))
AssertionError: False is not True : Command 'thread list' returns successfully
----------------------------------------------------------------------
Ran 4 tests in 3.086s
FAILED (failures=1)
/Volumes/data/lldb/svn/trunk/test $ ls jason
TestArrayTypes.ArrayTypesTestCase.test_with_dwarf_and_run_command.log
/Volumes/data/lldb/svn/trunk/test $ head -10 jason/TestArrayTypes.ArrayTypesTestCase.test_with_dwarf_and_run_command.log
Session info generated @ Thu Oct 21 09:54:15 2010
os command: [['/bin/sh', '-c', 'make clean; make MAKE_DSYM=NO']]
stdout: rm -rf "a.out" "a.out.dSYM" main.o main.d
cc -arch x86_64 -gdwarf-2 -O0 -c -o main.o main.c
cc -arch x86_64 -gdwarf-2 -O0 main.o -o "a.out"
stderr: None
retcode: 0
/Volumes/data/lldb/svn/trunk/test $
llvm-svn: 117028
2010-10-21 16:55:35 +00:00
|
|
|
os.environ["LLDB_SESSION_DIRNAME"])
|
2010-10-19 00:25:01 +00:00
|
|
|
if not os.path.isdir(dname):
|
|
|
|
os.mkdir(dname)
|
2010-11-06 00:07:07 +00:00
|
|
|
fname = os.path.join(dname, "%s-%s.log" % (prefix, self.id()))
|
2010-10-15 01:18:29 +00:00
|
|
|
with open(fname, "w") as f:
|
Add an option '-s session-dir-name' to overwrite the default timestamp-named
directory used to dump the session info for test failures/errors.
Example:
/Volumes/data/lldb/svn/trunk/test $ ./dotest.py -s jason -v array_types
Session info for test errors or failures will go into directory jason
----------------------------------------------------------------------
Collected 4 tests
test_with_dsym_and_python_api (TestArrayTypes.ArrayTypesTestCase)
Use Python APIs to inspect variables with array types. ... ok
test_with_dsym_and_run_command (TestArrayTypes.ArrayTypesTestCase)
Test 'frame variable var_name' on some variables with array types. ... ok
test_with_dwarf_and_python_api (TestArrayTypes.ArrayTypesTestCase)
Use Python APIs to inspect variables with array types. ... ok
test_with_dwarf_and_run_command (TestArrayTypes.ArrayTypesTestCase)
Test 'frame variable var_name' on some variables with array types. ... FAIL
======================================================================
FAIL: test_with_dwarf_and_run_command (TestArrayTypes.ArrayTypesTestCase)
Test 'frame variable var_name' on some variables with array types.
----------------------------------------------------------------------
Traceback (most recent call last):
File "/Volumes/data/lldb/svn/trunk/test/array_types/TestArrayTypes.py", line 27, in test_with_dwarf_and_run_command
self.array_types()
File "/Volumes/data/lldb/svn/trunk/test/array_types/TestArrayTypes.py", line 62, in array_types
'stop reason = breakpoint'])
File "/Volumes/data/lldb/svn/trunk/test/lldbtest.py", line 594, in expect
self.runCmd(str, trace = (True if trace else False), check = not error)
File "/Volumes/data/lldb/svn/trunk/test/lldbtest.py", line 564, in runCmd
msg if msg else CMD_MSG(cmd, True))
AssertionError: False is not True : Command 'thread list' returns successfully
----------------------------------------------------------------------
Ran 4 tests in 3.086s
FAILED (failures=1)
/Volumes/data/lldb/svn/trunk/test $ ls jason
TestArrayTypes.ArrayTypesTestCase.test_with_dwarf_and_run_command.log
/Volumes/data/lldb/svn/trunk/test $ head -10 jason/TestArrayTypes.ArrayTypesTestCase.test_with_dwarf_and_run_command.log
Session info generated @ Thu Oct 21 09:54:15 2010
os command: [['/bin/sh', '-c', 'make clean; make MAKE_DSYM=NO']]
stdout: rm -rf "a.out" "a.out.dSYM" main.o main.d
cc -arch x86_64 -gdwarf-2 -O0 -c -o main.o main.c
cc -arch x86_64 -gdwarf-2 -O0 main.o -o "a.out"
stderr: None
retcode: 0
/Volumes/data/lldb/svn/trunk/test $
llvm-svn: 117028
2010-10-21 16:55:35 +00:00
|
|
|
import datetime
|
|
|
|
print >> f, "Session info generated @", datetime.datetime.now().ctime()
|
2010-10-15 01:18:29 +00:00
|
|
|
print >> f, self.session.getvalue()
|
2010-11-09 22:56:12 +00:00
|
|
|
print >> f, "To rerun this test, issue the following command from the 'test' directory:\n"
|
2010-11-11 23:54:12 +00:00
|
|
|
print >> f, "%s ./dotest.py -v -t -f %s.%s" % (self.getRunSpec(),
|
|
|
|
self.__class__.__name__,
|
|
|
|
self._testMethodName)
|
2010-10-15 01:18:29 +00:00
|
|
|
|
2010-10-19 22:45:25 +00:00
|
|
|
def setTearDownCleanup(self, dictionary=None):
|
|
|
|
"""Register a cleanup action at tearDown() time with a dictinary"""
|
|
|
|
self.dict = dictionary
|
|
|
|
self.doTearDownCleanup = True
|
|
|
|
|
2010-10-19 23:40:13 +00:00
|
|
|
def addTearDownHook(self, hook):
|
|
|
|
"""
|
|
|
|
Add a function to be run during tearDown() time.
|
|
|
|
|
|
|
|
Hooks are executed in a first come first serve manner.
|
|
|
|
"""
|
2010-10-20 18:12:58 +00:00
|
|
|
if callable(hook):
|
|
|
|
with recording(self, traceAlways) as sbuf:
|
2010-11-01 20:35:01 +00:00
|
|
|
print >> sbuf, "Adding tearDown hook:", getsource_if_available(hook)
|
2010-10-20 18:12:58 +00:00
|
|
|
self.hooks.append(hook)
|
2010-10-19 23:40:13 +00:00
|
|
|
|
2010-07-03 03:41:59 +00:00
|
|
|
def tearDown(self):
|
2010-09-02 21:23:12 +00:00
|
|
|
#import traceback
|
|
|
|
#traceback.print_stack()
|
|
|
|
|
2010-10-19 23:40:13 +00:00
|
|
|
# Check and run any hook functions.
|
|
|
|
for hook in self.hooks:
|
2010-10-20 18:12:58 +00:00
|
|
|
with recording(self, traceAlways) as sbuf:
|
2010-11-01 20:35:01 +00:00
|
|
|
print >> sbuf, "Executing tearDown hook:", getsource_if_available(hook)
|
2010-10-19 23:40:13 +00:00
|
|
|
hook()
|
|
|
|
|
2010-09-02 21:23:12 +00:00
|
|
|
# Terminate the current process being debugged, if any.
|
2010-08-16 21:28:10 +00:00
|
|
|
if self.runStarted:
|
2010-09-02 21:23:12 +00:00
|
|
|
self.runCmd("process kill", PROCESS_KILLED, check=False)
|
|
|
|
elif self.process and self.process.IsValid():
|
2010-10-07 02:04:14 +00:00
|
|
|
rc = self.invoke(self.process, "Kill")
|
2010-09-02 21:23:12 +00:00
|
|
|
self.assertTrue(rc.Success(), PROCESS_KILLED)
|
2010-10-07 02:04:14 +00:00
|
|
|
del self.process
|
2010-08-16 21:28:10 +00:00
|
|
|
|
2010-07-03 03:41:59 +00:00
|
|
|
del self.dbg
|
2010-10-19 23:40:13 +00:00
|
|
|
del self.hooks
|
2010-07-03 03:41:59 +00:00
|
|
|
|
2010-09-22 23:00:20 +00:00
|
|
|
# Perform registered teardown cleanup.
|
2010-10-11 22:25:46 +00:00
|
|
|
if doCleanup and self.doTearDownCleanup:
|
2010-09-22 23:00:20 +00:00
|
|
|
module = __import__(sys.platform)
|
2010-10-16 00:08:49 +00:00
|
|
|
if not module.cleanup(self, dictionary=self.dict):
|
2010-09-22 23:00:20 +00:00
|
|
|
raise Exception("Don't know how to do cleanup")
|
|
|
|
|
2010-11-05 18:10:11 +00:00
|
|
|
# Decide whether to dump the session info.
|
2010-11-03 18:17:03 +00:00
|
|
|
self.dumpSessionInfo()
|
2010-10-15 01:18:29 +00:00
|
|
|
|
2010-09-01 00:15:19 +00:00
|
|
|
def runCmd(self, cmd, msg=None, check=True, trace=False, setCookie=True):
|
2010-08-19 23:26:59 +00:00
|
|
|
"""
|
|
|
|
Ask the command interpreter to handle the command and then check its
|
|
|
|
return status.
|
|
|
|
"""
|
|
|
|
# Fail fast if 'cmd' is not meaningful.
|
|
|
|
if not cmd or len(cmd) == 0:
|
|
|
|
raise Exception("Bad 'cmd' parameter encountered")
|
2010-08-20 17:57:32 +00:00
|
|
|
|
2010-08-31 17:42:54 +00:00
|
|
|
trace = (True if traceAlways else trace)
|
2010-08-23 17:10:44 +00:00
|
|
|
|
2010-09-01 00:15:19 +00:00
|
|
|
running = (cmd.startswith("run") or cmd.startswith("process launch"))
|
2010-08-20 17:57:32 +00:00
|
|
|
|
2010-09-01 00:15:19 +00:00
|
|
|
for i in range(self.maxLaunchCount if running else 1):
|
2010-08-25 18:49:48 +00:00
|
|
|
self.ci.HandleCommand(cmd, self.res)
|
2010-08-20 17:57:32 +00:00
|
|
|
|
2010-10-15 01:18:29 +00:00
|
|
|
with recording(self, trace) as sbuf:
|
|
|
|
print >> sbuf, "runCmd:", cmd
|
2010-10-15 16:13:00 +00:00
|
|
|
if not check:
|
2010-10-15 18:52:22 +00:00
|
|
|
print >> sbuf, "check of return status not required"
|
2010-08-25 18:49:48 +00:00
|
|
|
if self.res.Succeeded():
|
2010-10-15 01:18:29 +00:00
|
|
|
print >> sbuf, "output:", self.res.GetOutput()
|
2010-08-25 18:49:48 +00:00
|
|
|
else:
|
2010-10-15 01:18:29 +00:00
|
|
|
print >> sbuf, "runCmd failed!"
|
|
|
|
print >> sbuf, self.res.GetError()
|
2010-08-20 17:57:32 +00:00
|
|
|
|
2010-09-03 22:35:47 +00:00
|
|
|
if running:
|
|
|
|
# For process launch, wait some time before possible next try.
|
|
|
|
time.sleep(self.timeWait)
|
|
|
|
|
2010-08-20 21:03:09 +00:00
|
|
|
if self.res.Succeeded():
|
2010-08-25 18:49:48 +00:00
|
|
|
break
|
2010-10-15 01:18:29 +00:00
|
|
|
elif running:
|
|
|
|
with recording(self, True) as sbuf:
|
|
|
|
print >> sbuf, "Command '" + cmd + "' failed!"
|
2010-08-20 17:57:32 +00:00
|
|
|
|
2010-09-02 21:23:12 +00:00
|
|
|
# Modify runStarted only if "run" or "process launch" was encountered.
|
|
|
|
if running:
|
|
|
|
self.runStarted = running and setCookie
|
2010-09-01 00:15:19 +00:00
|
|
|
|
2010-08-19 23:26:59 +00:00
|
|
|
if check:
|
|
|
|
self.assertTrue(self.res.Succeeded(),
|
2010-11-09 18:42:22 +00:00
|
|
|
msg if msg else CMD_MSG(cmd))
|
2010-08-19 23:26:59 +00:00
|
|
|
|
2010-09-21 23:33:30 +00:00
|
|
|
def expect(self, str, msg=None, patterns=None, startstr=None, substrs=None, trace=False, error=False, matching=True, exe=True):
|
2010-08-19 23:26:59 +00:00
|
|
|
"""
|
|
|
|
Similar to runCmd; with additional expect style output matching ability.
|
|
|
|
|
|
|
|
Ask the command interpreter to handle the command and then check its
|
|
|
|
return status. The 'msg' parameter specifies an informational assert
|
|
|
|
message. We expect the output from running the command to start with
|
2010-09-21 21:08:53 +00:00
|
|
|
'startstr', matches the substrings contained in 'substrs', and regexp
|
|
|
|
matches the patterns contained in 'patterns'.
|
2010-09-17 22:28:51 +00:00
|
|
|
|
|
|
|
If the keyword argument error is set to True, it signifies that the API
|
|
|
|
client is expecting the command to fail. In this case, the error stream
|
2010-09-17 22:45:27 +00:00
|
|
|
from running the command is retrieved and compared against the golden
|
2010-09-17 22:28:51 +00:00
|
|
|
input, instead.
|
2010-09-21 21:08:53 +00:00
|
|
|
|
|
|
|
If the keyword argument matching is set to False, it signifies that the API
|
|
|
|
client is expecting the output of the command not to match the golden
|
|
|
|
input.
|
2010-09-21 23:33:30 +00:00
|
|
|
|
|
|
|
Finally, the required argument 'str' represents the lldb command to be
|
|
|
|
sent to the command interpreter. In case the keyword argument 'exe' is
|
|
|
|
set to False, the 'str' is treated as a string to be matched/not-matched
|
|
|
|
against the golden input.
|
2010-08-19 23:26:59 +00:00
|
|
|
"""
|
2010-08-31 17:42:54 +00:00
|
|
|
trace = (True if traceAlways else trace)
|
2010-08-23 17:10:44 +00:00
|
|
|
|
2010-09-21 23:33:30 +00:00
|
|
|
if exe:
|
|
|
|
# First run the command. If we are expecting error, set check=False.
|
2010-10-28 21:10:32 +00:00
|
|
|
# Pass the assert message along since it provides more semantic info.
|
2010-10-28 18:24:22 +00:00
|
|
|
self.runCmd(str, msg=msg, trace = (True if trace else False), check = not error)
|
2010-08-19 23:26:59 +00:00
|
|
|
|
2010-09-21 23:33:30 +00:00
|
|
|
# Then compare the output against expected strings.
|
|
|
|
output = self.res.GetError() if error else self.res.GetOutput()
|
2010-09-17 22:28:51 +00:00
|
|
|
|
2010-09-21 23:33:30 +00:00
|
|
|
# If error is True, the API client expects the command to fail!
|
|
|
|
if error:
|
|
|
|
self.assertFalse(self.res.Succeeded(),
|
|
|
|
"Command '" + str + "' is expected to fail!")
|
|
|
|
else:
|
|
|
|
# No execution required, just compare str against the golden input.
|
|
|
|
output = str
|
2010-10-15 01:18:29 +00:00
|
|
|
with recording(self, trace) as sbuf:
|
|
|
|
print >> sbuf, "looking at:", output
|
2010-09-17 22:28:51 +00:00
|
|
|
|
2010-09-21 21:08:53 +00:00
|
|
|
# The heading says either "Expecting" or "Not expecting".
|
2010-10-15 01:18:29 +00:00
|
|
|
heading = "Expecting" if matching else "Not expecting"
|
2010-09-21 21:08:53 +00:00
|
|
|
|
|
|
|
# Start from the startstr, if specified.
|
|
|
|
# If there's no startstr, set the initial state appropriately.
|
|
|
|
matched = output.startswith(startstr) if startstr else (True if matching else False)
|
2010-08-20 18:25:15 +00:00
|
|
|
|
2010-10-15 01:18:29 +00:00
|
|
|
if startstr:
|
|
|
|
with recording(self, trace) as sbuf:
|
|
|
|
print >> sbuf, "%s start string: %s" % (heading, startstr)
|
|
|
|
print >> sbuf, "Matched" if matched else "Not matched"
|
2010-08-20 18:25:15 +00:00
|
|
|
|
2010-09-21 21:08:53 +00:00
|
|
|
# Look for sub strings, if specified.
|
|
|
|
keepgoing = matched if matching else not matched
|
|
|
|
if substrs and keepgoing:
|
2010-08-19 23:26:59 +00:00
|
|
|
for str in substrs:
|
2010-09-23 23:35:28 +00:00
|
|
|
matched = output.find(str) != -1
|
2010-10-15 01:18:29 +00:00
|
|
|
with recording(self, trace) as sbuf:
|
|
|
|
print >> sbuf, "%s sub string: %s" % (heading, str)
|
|
|
|
print >> sbuf, "Matched" if matched else "Not matched"
|
2010-09-21 21:08:53 +00:00
|
|
|
keepgoing = matched if matching else not matched
|
|
|
|
if not keepgoing:
|
|
|
|
break
|
|
|
|
|
|
|
|
# Search for regular expression patterns, if specified.
|
|
|
|
keepgoing = matched if matching else not matched
|
|
|
|
if patterns and keepgoing:
|
|
|
|
for pattern in patterns:
|
|
|
|
# Match Objects always have a boolean value of True.
|
|
|
|
matched = bool(re.search(pattern, output))
|
2010-10-15 01:18:29 +00:00
|
|
|
with recording(self, trace) as sbuf:
|
|
|
|
print >> sbuf, "%s pattern: %s" % (heading, pattern)
|
|
|
|
print >> sbuf, "Matched" if matched else "Not matched"
|
2010-09-21 21:08:53 +00:00
|
|
|
keepgoing = matched if matching else not matched
|
|
|
|
if not keepgoing:
|
2010-08-19 23:26:59 +00:00
|
|
|
break
|
|
|
|
|
2010-09-21 21:08:53 +00:00
|
|
|
self.assertTrue(matched if matching else not matched,
|
2010-11-09 18:42:22 +00:00
|
|
|
msg if msg else EXP_MSG(str, exe))
|
2010-08-19 23:26:59 +00:00
|
|
|
|
2010-08-25 22:52:45 +00:00
|
|
|
def invoke(self, obj, name, trace=False):
|
2010-08-25 22:56:10 +00:00
|
|
|
"""Use reflection to call a method dynamically with no argument."""
|
2010-08-31 17:42:54 +00:00
|
|
|
trace = (True if traceAlways else trace)
|
2010-08-25 22:52:45 +00:00
|
|
|
|
|
|
|
method = getattr(obj, name)
|
|
|
|
import inspect
|
|
|
|
self.assertTrue(inspect.ismethod(method),
|
|
|
|
name + "is a method name of object: " + str(obj))
|
|
|
|
result = method()
|
2010-10-15 01:18:29 +00:00
|
|
|
with recording(self, trace) as sbuf:
|
|
|
|
print >> sbuf, str(method) + ":", result
|
2010-08-25 22:52:45 +00:00
|
|
|
return result
|
2010-08-27 00:15:48 +00:00
|
|
|
|
2010-09-01 22:08:51 +00:00
|
|
|
def breakAfterLaunch(self, process, func, trace=False):
|
|
|
|
"""
|
|
|
|
Perform some dancees after LaunchProcess() to break at func name.
|
|
|
|
|
|
|
|
Return True if we can successfully break at the func name in due time.
|
|
|
|
"""
|
|
|
|
trace = (True if traceAlways else trace)
|
|
|
|
|
|
|
|
count = 0
|
|
|
|
while True:
|
|
|
|
# The stop reason of the thread should be breakpoint.
|
|
|
|
thread = process.GetThreadAtIndex(0)
|
|
|
|
SR = thread.GetStopReason()
|
2010-10-15 01:18:29 +00:00
|
|
|
with recording(self, trace) as sbuf:
|
|
|
|
print >> sbuf, "StopReason =", StopReasonString(SR)
|
2010-09-01 22:08:51 +00:00
|
|
|
|
|
|
|
if SR == StopReasonEnum("Breakpoint"):
|
|
|
|
frame = thread.GetFrameAtIndex(0)
|
|
|
|
name = frame.GetFunction().GetName()
|
2010-10-15 01:18:29 +00:00
|
|
|
with recording(self, trace) as sbuf:
|
|
|
|
print >> sbuf, "function =", name
|
2010-09-01 22:08:51 +00:00
|
|
|
if (name == func):
|
|
|
|
# We got what we want; now break out of the loop.
|
|
|
|
return True
|
|
|
|
|
|
|
|
# The inferior is in a transient state; continue the process.
|
|
|
|
time.sleep(1.0)
|
2010-10-15 01:18:29 +00:00
|
|
|
with recording(self, trace) as sbuf:
|
|
|
|
print >> sbuf, "Continuing the process:", process
|
2010-09-01 22:08:51 +00:00
|
|
|
process.Continue()
|
|
|
|
|
|
|
|
count = count + 1
|
2010-09-15 00:00:54 +00:00
|
|
|
if count == 15:
|
2010-10-15 01:18:29 +00:00
|
|
|
with recording(self, trace) as sbuf:
|
|
|
|
print >> sbuf, "Reached 15 iterations, giving up..."
|
2010-09-01 22:08:51 +00:00
|
|
|
# Enough iterations already, break out of the loop.
|
|
|
|
return False
|
|
|
|
|
|
|
|
# End of while loop.
|
|
|
|
|
|
|
|
|
2010-11-11 23:54:12 +00:00
|
|
|
def getRunSpec(self):
|
|
|
|
"""Environment variable spec to run this test again, invoked from within
|
|
|
|
dumpSessionInfo()."""
|
|
|
|
module = __import__(sys.platform)
|
|
|
|
return module.getRunSpec()
|
|
|
|
|
2010-09-22 23:00:20 +00:00
|
|
|
def buildDefault(self, architecture=None, compiler=None, dictionary=None):
|
2010-09-03 23:49:16 +00:00
|
|
|
"""Platform specific way to build the default binaries."""
|
|
|
|
module = __import__(sys.platform)
|
Some re-achitecturing of the plugins interface. The caller is now required to
pass in a 'sender' arg to the buildDefault(), buildDsym(), buildDwarf(), and
cleanup() functions. The sender arg will be the test instance itself (i.e.,
an instance of TestBase). This is so that the relevant command execution can be
recorded in the TestBase.session object if sender is available.
The lldbtest.system() command has been modified to pop the 'sender' arg out of
the keyword arguments dictionary and use it as the test instance to facilitate
seesion recordings. An example is in test/types/AbstractBase.py:
def generic_type_tester(self, atoms, quotedDisplay=False):
"""Test that variables with basic types are displayed correctly."""
# First, capture the golden output emitted by the oracle, i.e., the
# series of printf statements.
go = system("./a.out", sender=self)
There are cases when sender is None. This is the case when the @classmethod is
involved in the use of these APIs. When this happens, there is no recording
into a session object, but printing on the sys.stderr is still honored if the
trace flag is ON.
An example is in test/settings/TestSettings.py:
@classmethod
def classCleanup(cls):
system(["/bin/sh", "-c", "rm -f output.txt"])
system(["/bin/sh", "-c", "rm -f stdout.txt"])
llvm-svn: 116648
2010-10-15 23:55:05 +00:00
|
|
|
if not module.buildDefault(self, architecture, compiler, dictionary):
|
2010-09-03 23:49:16 +00:00
|
|
|
raise Exception("Don't know how to build default binary")
|
|
|
|
|
2010-09-22 23:00:20 +00:00
|
|
|
def buildDsym(self, architecture=None, compiler=None, dictionary=None):
|
2010-08-30 22:26:48 +00:00
|
|
|
"""Platform specific way to build binaries with dsym info."""
|
2010-08-31 17:42:54 +00:00
|
|
|
module = __import__(sys.platform)
|
Some re-achitecturing of the plugins interface. The caller is now required to
pass in a 'sender' arg to the buildDefault(), buildDsym(), buildDwarf(), and
cleanup() functions. The sender arg will be the test instance itself (i.e.,
an instance of TestBase). This is so that the relevant command execution can be
recorded in the TestBase.session object if sender is available.
The lldbtest.system() command has been modified to pop the 'sender' arg out of
the keyword arguments dictionary and use it as the test instance to facilitate
seesion recordings. An example is in test/types/AbstractBase.py:
def generic_type_tester(self, atoms, quotedDisplay=False):
"""Test that variables with basic types are displayed correctly."""
# First, capture the golden output emitted by the oracle, i.e., the
# series of printf statements.
go = system("./a.out", sender=self)
There are cases when sender is None. This is the case when the @classmethod is
involved in the use of these APIs. When this happens, there is no recording
into a session object, but printing on the sys.stderr is still honored if the
trace flag is ON.
An example is in test/settings/TestSettings.py:
@classmethod
def classCleanup(cls):
system(["/bin/sh", "-c", "rm -f output.txt"])
system(["/bin/sh", "-c", "rm -f stdout.txt"])
llvm-svn: 116648
2010-10-15 23:55:05 +00:00
|
|
|
if not module.buildDsym(self, architecture, compiler, dictionary):
|
2010-08-30 22:26:48 +00:00
|
|
|
raise Exception("Don't know how to build binary with dsym")
|
|
|
|
|
2010-09-22 23:00:20 +00:00
|
|
|
def buildDwarf(self, architecture=None, compiler=None, dictionary=None):
|
2010-08-30 22:26:48 +00:00
|
|
|
"""Platform specific way to build binaries with dwarf maps."""
|
2010-08-31 17:42:54 +00:00
|
|
|
module = __import__(sys.platform)
|
Some re-achitecturing of the plugins interface. The caller is now required to
pass in a 'sender' arg to the buildDefault(), buildDsym(), buildDwarf(), and
cleanup() functions. The sender arg will be the test instance itself (i.e.,
an instance of TestBase). This is so that the relevant command execution can be
recorded in the TestBase.session object if sender is available.
The lldbtest.system() command has been modified to pop the 'sender' arg out of
the keyword arguments dictionary and use it as the test instance to facilitate
seesion recordings. An example is in test/types/AbstractBase.py:
def generic_type_tester(self, atoms, quotedDisplay=False):
"""Test that variables with basic types are displayed correctly."""
# First, capture the golden output emitted by the oracle, i.e., the
# series of printf statements.
go = system("./a.out", sender=self)
There are cases when sender is None. This is the case when the @classmethod is
involved in the use of these APIs. When this happens, there is no recording
into a session object, but printing on the sys.stderr is still honored if the
trace flag is ON.
An example is in test/settings/TestSettings.py:
@classmethod
def classCleanup(cls):
system(["/bin/sh", "-c", "rm -f output.txt"])
system(["/bin/sh", "-c", "rm -f stdout.txt"])
llvm-svn: 116648
2010-10-15 23:55:05 +00:00
|
|
|
if not module.buildDwarf(self, architecture, compiler, dictionary):
|
2010-08-30 22:26:48 +00:00
|
|
|
raise Exception("Don't know how to build binary with dwarf")
|
|
|
|
|
2010-08-27 00:15:48 +00:00
|
|
|
def DebugSBValue(self, frame, val):
|
2010-08-31 17:42:54 +00:00
|
|
|
"""Debug print a SBValue object, if traceAlways is True."""
|
2010-11-03 21:37:58 +00:00
|
|
|
from lldbutil import ValueTypeString
|
|
|
|
|
2010-08-31 17:42:54 +00:00
|
|
|
if not traceAlways:
|
2010-08-27 00:15:48 +00:00
|
|
|
return
|
|
|
|
|
|
|
|
err = sys.stderr
|
|
|
|
err.write(val.GetName() + ":\n")
|
2010-11-01 16:08:47 +00:00
|
|
|
err.write('\t' + "TypeName -> " + val.GetTypeName() + '\n')
|
|
|
|
err.write('\t' + "ByteSize -> " + str(val.GetByteSize()) + '\n')
|
|
|
|
err.write('\t' + "NumChildren -> " + str(val.GetNumChildren()) + '\n')
|
|
|
|
err.write('\t' + "Value -> " + str(val.GetValue(frame)) + '\n')
|
2010-11-03 21:37:58 +00:00
|
|
|
err.write('\t' + "ValueType -> " + ValueTypeString(val.GetValueType()) + '\n')
|
2010-11-01 16:08:47 +00:00
|
|
|
err.write('\t' + "Summary -> " + str(val.GetSummary(frame)) + '\n')
|
|
|
|
err.write('\t' + "IsPointerType -> " + str(val.TypeIsPointerType()) + '\n')
|
|
|
|
err.write('\t' + "Location -> " + val.GetLocation(frame) + '\n')
|
2010-08-27 00:15:48 +00:00
|
|
|
|