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
|
2012-05-16 20:41:28 +00:00
|
|
|
entire of part of the test suite . Example:
|
2010-09-02 22:25:47 +00:00
|
|
|
|
2012-05-16 20:41:28 +00:00
|
|
|
# Exercises the test suite in the types directory....
|
|
|
|
/Volumes/data/lldb/svn/ToT/test $ ./dotest.py -A x86_64 types
|
2010-09-02 22:25:47 +00:00
|
|
|
...
|
2010-08-23 17:10:44 +00:00
|
|
|
|
2012-05-16 20:41:28 +00:00
|
|
|
Session logs for test failures/errors/unexpected successes will go into directory '2012-05-16-13_35_42'
|
|
|
|
Command invoked: python ./dotest.py -A x86_64 types
|
|
|
|
compilers=['clang']
|
2010-08-23 17:10:44 +00:00
|
|
|
|
2012-05-16 20:41:28 +00:00
|
|
|
Configuration: arch=x86_64 compiler=clang
|
|
|
|
----------------------------------------------------------------------
|
|
|
|
Collected 72 tests
|
2010-08-23 17:10:44 +00:00
|
|
|
|
2012-05-16 20:41:28 +00:00
|
|
|
........................................................................
|
2010-08-23 17:10:44 +00:00
|
|
|
----------------------------------------------------------------------
|
2012-05-16 20:41:28 +00:00
|
|
|
Ran 72 tests in 135.468s
|
2010-08-23 17:10:44 +00:00
|
|
|
|
2010-07-03 03:41:59 +00:00
|
|
|
OK
|
|
|
|
$
|
|
|
|
"""
|
|
|
|
|
2010-09-21 22:34:45 +00:00
|
|
|
import os, sys, traceback
|
2012-10-24 18:14:21 +00:00
|
|
|
import os.path
|
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
|
2011-01-19 18:18:47 +00:00
|
|
|
# LLDB_COMMAND_TRACE and LLDB_DO_CLEANUP are set from '-t' and '-r dir' options.
|
2010-10-11 22:25:46 +00:00
|
|
|
|
|
|
|
# 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-12-23 01:12:19 +00:00
|
|
|
PROCESS_EXITED = "Process exited successfully"
|
|
|
|
|
|
|
|
PROCESS_STOPPED = "Process status should be stopped"
|
|
|
|
|
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-12-04 00:07:24 +00:00
|
|
|
BREAKPOINT_STATE_CORRECT = "Breakpoint state is correct"
|
|
|
|
|
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"
|
|
|
|
|
2012-10-24 18:24:14 +00:00
|
|
|
MISSING_EXPECTED_REGISTERS = "At least one expected register is unavailable."
|
|
|
|
|
2011-06-27 20:05:23 +00:00
|
|
|
OBJECT_PRINTED_CORRECTLY = "Object printed correctly"
|
|
|
|
|
2010-12-09 18:22:12 +00:00
|
|
|
SOURCE_DISPLAYED_CORRECTLY = "Source code displayed correctly"
|
|
|
|
|
2010-09-22 23:00:20 +00:00
|
|
|
STEP_OUT_SUCCEEDED = "Thread step-out succeeded"
|
|
|
|
|
2011-04-15 16:44:48 +00:00
|
|
|
STOPPED_DUE_TO_EXC_BAD_ACCESS = "Process should be stopped due to bad access exception"
|
|
|
|
|
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-12-13 21:49:58 +00:00
|
|
|
STOPPED_DUE_TO_BREAKPOINT_IGNORE_COUNT = "Stopped due to breakpoint and ignore count"
|
|
|
|
|
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"
|
|
|
|
|
2011-09-15 21:09:59 +00:00
|
|
|
STOPPED_DUE_TO_WATCHPOINT = "Process should be stopped due to watchpoint"
|
|
|
|
|
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"
|
|
|
|
|
2011-05-06 23:26:12 +00:00
|
|
|
VALID_COMMAND_INTERPRETER = "Got a valid command interpreter"
|
|
|
|
|
2010-08-27 23:47:36 +00:00
|
|
|
VALID_FILESPEC = "Got a valid filespec"
|
|
|
|
|
2010-12-08 01:25:21 +00:00
|
|
|
VALID_MODULE = "Got a valid module"
|
|
|
|
|
2010-08-26 20:04:17 +00:00
|
|
|
VALID_PROCESS = "Got a valid process"
|
|
|
|
|
2010-12-08 01:25:21 +00:00
|
|
|
VALID_SYMBOL = "Got a valid symbol"
|
|
|
|
|
2010-08-26 20:04:17 +00:00
|
|
|
VALID_TARGET = "Got a valid target"
|
|
|
|
|
2012-02-03 20:43:00 +00:00
|
|
|
VALID_TYPE = "Got a valid type"
|
|
|
|
|
2011-07-15 22:28:10 +00:00
|
|
|
VALID_VARIABLE = "Got a valid variable"
|
|
|
|
|
2010-08-25 19:00:04 +00:00
|
|
|
VARIABLES_DISPLAYED_CORRECTLY = "Variable(s) displayed correctly"
|
2010-08-09 22:01:17 +00:00
|
|
|
|
2011-09-15 21:09:59 +00:00
|
|
|
WATCHPOINT_CREATED = "Watchpoint created successfully"
|
2010-08-26 20:04:17 +00:00
|
|
|
|
2010-11-09 18:42:22 +00:00
|
|
|
def CMD_MSG(str):
|
2011-05-31 22:16:51 +00:00
|
|
|
'''A generic "Command '%s' returns successfully" message generator.'''
|
2010-11-09 18:42:22 +00:00
|
|
|
return "Command '%s' returns successfully" % str
|
|
|
|
|
2012-03-15 19:10:00 +00:00
|
|
|
def COMPLETION_MSG(str_before, str_after):
|
2012-01-20 23:02:51 +00:00
|
|
|
'''A generic message generator for the completion mechanism.'''
|
|
|
|
return "'%s' successfully completes to '%s'" % (str_before, str_after)
|
|
|
|
|
2010-11-09 18:42:22 +00:00
|
|
|
def EXP_MSG(str, exe):
|
2011-05-31 22:16:51 +00:00
|
|
|
'''A generic "'%s' returns expected result" message generator if exe.
|
|
|
|
Otherwise, it generates "'%s' matches expected result" message.'''
|
2010-11-09 18:42:22 +00:00
|
|
|
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
|
|
|
def SETTING_MSG(setting):
|
2011-05-31 22:16:51 +00:00
|
|
|
'''A generic "Value of setting '%s' is correct" message generator.'''
|
2010-10-19 19:11:38 +00:00
|
|
|
return "Value of setting '%s' is correct" % setting
|
|
|
|
|
2010-08-26 21:49:29 +00:00
|
|
|
def EnvArray():
|
2011-05-31 22:16:51 +00:00
|
|
|
"""Returns an env variable array from the os.environ map object."""
|
2010-08-26 21:49:29 +00:00
|
|
|
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
|
2011-04-15 16:44:48 +00:00
|
|
|
raise Exception("Unable to find '%s' within file %s" % (string_to_match, filename))
|
2010-10-11 23:52:19 +00:00
|
|
|
|
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)
|
|
|
|
|
2012-02-09 02:01:59 +00:00
|
|
|
def is_exe(fpath):
|
|
|
|
"""Returns true if fpath is an executable."""
|
|
|
|
return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
|
|
|
|
|
|
|
|
def which(program):
|
|
|
|
"""Returns the full path to a program; None otherwise."""
|
|
|
|
fpath, fname = os.path.split(program)
|
|
|
|
if fpath:
|
|
|
|
if is_exe(program):
|
|
|
|
return program
|
|
|
|
else:
|
|
|
|
for path in os.environ["PATH"].split(os.pathsep):
|
|
|
|
exe_file = os.path.join(path, program)
|
|
|
|
if is_exe(exe_file):
|
|
|
|
return exe_file
|
|
|
|
return None
|
|
|
|
|
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)
|
2011-08-16 22:06:17 +00:00
|
|
|
# The test might not have undergone the 'setUp(self)' phase yet, so that
|
|
|
|
# the attribute 'session' might not even exist yet.
|
2011-08-16 17:06:45 +00:00
|
|
|
self.session = getattr(test, "session", None) 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.
|
Turns out that the test failure wrt:
rdar://problem/9173060 lldb hangs while running unique-types
disappears if running with clang version >= 3. Modify the TestUniqueTypes.py
to detect if we are running with clang version < 3 and, if true, skip the test.
Update the lldbtest.system() function to return a tuple of (stdoutdata, stderrdata)
since we need the stderr data from "clang -v" command. Modify existing clients of
lldbtest.system() to now use, for example:
# First, capture the golden output emitted by the oracle, i.e., the
# series of printf statements.
- go = system("./a.out", sender=self)
+ go = system("./a.out", sender=self)[0]
# This golden list contains a list of (variable, value) pairs extracted
# from the golden output.
gl = []
And add two utility functions to lldbutil.py.
llvm-svn: 128162
2011-03-23 20:28:59 +00:00
|
|
|
# Return a tuple (stdoutdata, stderrdata).
|
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
|
|
|
def system(*popenargs, **kwargs):
|
2011-11-16 22:44:28 +00:00
|
|
|
r"""Run an os command with arguments and return its output as a byte string.
|
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 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.')
|
Turns out that the test failure wrt:
rdar://problem/9173060 lldb hangs while running unique-types
disappears if running with clang version >= 3. Modify the TestUniqueTypes.py
to detect if we are running with clang version < 3 and, if true, skip the test.
Update the lldbtest.system() function to return a tuple of (stdoutdata, stderrdata)
since we need the stderr data from "clang -v" command. Modify existing clients of
lldbtest.system() to now use, for example:
# First, capture the golden output emitted by the oracle, i.e., the
# series of printf statements.
- go = system("./a.out", sender=self)
+ go = system("./a.out", sender=self)[0]
# This golden list contains a list of (variable, value) pairs extracted
# from the golden output.
gl = []
And add two utility functions to lldbutil.py.
llvm-svn: 128162
2011-03-23 20:28:59 +00:00
|
|
|
process = Popen(stdout=PIPE, stderr=PIPE, *popenargs, **kwargs)
|
2011-11-16 22:41:53 +00:00
|
|
|
pid = process.pid
|
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
|
|
|
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
|
2011-11-16 22:41:53 +00:00
|
|
|
print >> sbuf, "with pid:", pid
|
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 >> 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)
|
Turns out that the test failure wrt:
rdar://problem/9173060 lldb hangs while running unique-types
disappears if running with clang version >= 3. Modify the TestUniqueTypes.py
to detect if we are running with clang version < 3 and, if true, skip the test.
Update the lldbtest.system() function to return a tuple of (stdoutdata, stderrdata)
since we need the stderr data from "clang -v" command. Modify existing clients of
lldbtest.system() to now use, for example:
# First, capture the golden output emitted by the oracle, i.e., the
# series of printf statements.
- go = system("./a.out", sender=self)
+ go = system("./a.out", sender=self)[0]
# This golden list contains a list of (variable, value) pairs extracted
# from the golden output.
gl = []
And add two utility functions to lldbutil.py.
llvm-svn: 128162
2011-03-23 20:28:59 +00:00
|
|
|
return (output, error)
|
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
|
|
|
|
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)
|
|
|
|
|
2011-06-20 19:06:20 +00:00
|
|
|
def builder_module():
|
|
|
|
return __import__("builder_" + sys.platform)
|
|
|
|
|
2011-08-01 18:46:13 +00:00
|
|
|
#
|
|
|
|
# Decorators for categorizing test cases.
|
|
|
|
#
|
2010-10-22 23:15:46 +00:00
|
|
|
|
2011-08-01 18:46:13 +00:00
|
|
|
from functools import wraps
|
|
|
|
def python_api_test(func):
|
|
|
|
"""Decorate the item as a Python API only test."""
|
|
|
|
if isinstance(func, type) and issubclass(func, unittest2.TestCase):
|
|
|
|
raise Exception("@python_api_test can only be used to decorate a test method")
|
|
|
|
@wraps(func)
|
|
|
|
def wrapper(self, *args, **kwargs):
|
|
|
|
try:
|
|
|
|
if lldb.dont_do_python_api_test:
|
|
|
|
self.skipTest("python api tests")
|
|
|
|
except AttributeError:
|
|
|
|
pass
|
|
|
|
return func(self, *args, **kwargs)
|
2010-10-22 23:15:46 +00:00
|
|
|
|
2011-08-01 18:46:13 +00:00
|
|
|
# Mark this function as such to separate them from lldb command line tests.
|
|
|
|
wrapper.__python_api_test__ = True
|
|
|
|
return wrapper
|
2010-10-22 23:15:46 +00:00
|
|
|
|
2011-08-01 18:46:13 +00:00
|
|
|
def benchmarks_test(func):
|
|
|
|
"""Decorate the item as a benchmarks test."""
|
|
|
|
if isinstance(func, type) and issubclass(func, unittest2.TestCase):
|
|
|
|
raise Exception("@benchmarks_test can only be used to decorate a test method")
|
|
|
|
@wraps(func)
|
|
|
|
def wrapper(self, *args, **kwargs):
|
|
|
|
try:
|
|
|
|
if not lldb.just_do_benchmarks_test:
|
|
|
|
self.skipTest("benchmarks tests")
|
|
|
|
except AttributeError:
|
|
|
|
pass
|
|
|
|
return func(self, *args, **kwargs)
|
2010-10-22 23:15:46 +00:00
|
|
|
|
2011-08-01 18:46:13 +00:00
|
|
|
# Mark this function as such to separate them from the regular tests.
|
|
|
|
wrapper.__benchmarks_test__ = True
|
|
|
|
return wrapper
|
2010-10-22 23:15:46 +00:00
|
|
|
|
2012-04-06 00:56:05 +00:00
|
|
|
def dsym_test(func):
|
|
|
|
"""Decorate the item as a dsym test."""
|
|
|
|
if isinstance(func, type) and issubclass(func, unittest2.TestCase):
|
|
|
|
raise Exception("@dsym_test can only be used to decorate a test method")
|
|
|
|
@wraps(func)
|
|
|
|
def wrapper(self, *args, **kwargs):
|
|
|
|
try:
|
|
|
|
if lldb.dont_do_dsym_test:
|
|
|
|
self.skipTest("dsym tests")
|
|
|
|
except AttributeError:
|
|
|
|
pass
|
|
|
|
return func(self, *args, **kwargs)
|
|
|
|
|
|
|
|
# Mark this function as such to separate them from the regular tests.
|
|
|
|
wrapper.__dsym_test__ = True
|
|
|
|
return wrapper
|
|
|
|
|
|
|
|
def dwarf_test(func):
|
|
|
|
"""Decorate the item as a dwarf test."""
|
|
|
|
if isinstance(func, type) and issubclass(func, unittest2.TestCase):
|
|
|
|
raise Exception("@dwarf_test can only be used to decorate a test method")
|
|
|
|
@wraps(func)
|
|
|
|
def wrapper(self, *args, **kwargs):
|
|
|
|
try:
|
|
|
|
if lldb.dont_do_dwarf_test:
|
|
|
|
self.skipTest("dwarf tests")
|
|
|
|
except AttributeError:
|
|
|
|
pass
|
|
|
|
return func(self, *args, **kwargs)
|
|
|
|
|
|
|
|
# Mark this function as such to separate them from the regular tests.
|
|
|
|
wrapper.__dwarf_test__ = True
|
|
|
|
return wrapper
|
|
|
|
|
2013-02-23 01:35:21 +00:00
|
|
|
def expectedFailureGcc(bugnumber=None):
|
2013-02-23 01:05:23 +00:00
|
|
|
if callable(bugnumber):
|
|
|
|
@wraps(bugnumber)
|
2013-02-23 01:35:21 +00:00
|
|
|
def expectedFailureGcc_easy_wrapper(*args, **kwargs):
|
2013-02-23 01:28:30 +00:00
|
|
|
from unittest2 import case
|
|
|
|
self = args[0]
|
|
|
|
test_compiler = self.getCompiler()
|
|
|
|
try:
|
|
|
|
bugnumber(*args, **kwargs)
|
|
|
|
except Exception:
|
2013-02-23 01:35:21 +00:00
|
|
|
if "gcc" in test_compiler:
|
2013-02-23 01:28:30 +00:00
|
|
|
raise case._ExpectedFailure(sys.exc_info(),None)
|
|
|
|
else:
|
|
|
|
raise
|
2013-02-23 01:35:21 +00:00
|
|
|
if "gcc" in test_compiler:
|
2013-02-23 01:28:30 +00:00
|
|
|
raise case._UnexpectedSuccess(sys.exc_info(),None)
|
2013-02-23 01:35:21 +00:00
|
|
|
return expectedFailureGcc_easy_wrapper
|
2013-02-23 01:05:23 +00:00
|
|
|
else:
|
2013-02-23 01:35:21 +00:00
|
|
|
def expectedFailureGcc_impl(func):
|
2013-02-23 01:05:23 +00:00
|
|
|
@wraps(func)
|
|
|
|
def wrapper(*args, **kwargs):
|
2013-02-23 01:28:30 +00:00
|
|
|
from unittest2 import case
|
|
|
|
self = args[0]
|
|
|
|
test_compiler = self.getCompiler()
|
|
|
|
try:
|
|
|
|
func(*args, **kwargs)
|
|
|
|
except Exception:
|
2013-02-23 01:35:21 +00:00
|
|
|
if "gcc" in test_compiler:
|
2013-02-23 01:28:30 +00:00
|
|
|
raise case._ExpectedFailure(sys.exc_info(),bugnumber)
|
|
|
|
else:
|
|
|
|
raise
|
2013-02-23 01:35:21 +00:00
|
|
|
if "gcc" in test_compiler:
|
2013-02-23 01:28:30 +00:00
|
|
|
raise case._UnexpectedSuccess(sys.exc_info(),bugnumber)
|
2013-02-23 01:05:23 +00:00
|
|
|
return wrapper
|
2013-02-23 01:35:21 +00:00
|
|
|
return expectedFailureGcc_impl
|
2013-02-19 16:08:57 +00:00
|
|
|
|
2013-02-23 01:35:21 +00:00
|
|
|
def expectedFailureClang(bugnumber=None):
|
|
|
|
if callable(bugnumber):
|
|
|
|
@wraps(bugnumber)
|
|
|
|
def expectedFailureClang_easy_wrapper(*args, **kwargs):
|
|
|
|
from unittest2 import case
|
|
|
|
self = args[0]
|
|
|
|
test_compiler = self.getCompiler()
|
|
|
|
try:
|
|
|
|
bugnumber(*args, **kwargs)
|
|
|
|
except Exception:
|
|
|
|
if "clang" in test_compiler:
|
|
|
|
raise case._ExpectedFailure(sys.exc_info(),None)
|
|
|
|
else:
|
|
|
|
raise
|
|
|
|
if "clang" in test_compiler:
|
|
|
|
raise case._UnexpectedSuccess(sys.exc_info(),None)
|
|
|
|
return expectedFailureClang_easy_wrapper
|
|
|
|
else:
|
|
|
|
def expectedFailureClang_impl(func):
|
|
|
|
@wraps(func)
|
|
|
|
def wrapper(*args, **kwargs):
|
|
|
|
from unittest2 import case
|
|
|
|
self = args[0]
|
|
|
|
test_compiler = self.getCompiler()
|
|
|
|
try:
|
|
|
|
func(*args, **kwargs)
|
|
|
|
except Exception:
|
|
|
|
if "clang" in test_compiler:
|
|
|
|
raise case._ExpectedFailure(sys.exc_info(),bugnumber)
|
|
|
|
else:
|
|
|
|
raise
|
|
|
|
if "clang" in test_compiler:
|
|
|
|
raise case._UnexpectedSuccess(sys.exc_info(),bugnumber)
|
|
|
|
return wrapper
|
|
|
|
return expectedFailureClang_impl
|
2013-02-19 16:08:57 +00:00
|
|
|
|
|
|
|
|
2013-02-23 01:05:23 +00:00
|
|
|
def expectedFailurei386(bugnumber=None):
|
|
|
|
if callable(bugnumber):
|
|
|
|
@wraps(bugnumber)
|
|
|
|
def expectedFailurei386_easy_wrapper(*args, **kwargs):
|
2013-02-23 01:28:30 +00:00
|
|
|
from unittest2 import case
|
|
|
|
self = args[0]
|
|
|
|
arch = self.getArchitecture()
|
|
|
|
try:
|
|
|
|
bugnumber(*args, **kwargs)
|
|
|
|
except Exception:
|
|
|
|
if "i386" in arch:
|
|
|
|
raise case._ExpectedFailure(sys.exc_info(),None)
|
|
|
|
else:
|
|
|
|
raise
|
|
|
|
if "i386" in arch:
|
|
|
|
raise case._UnexpectedSuccess(sys.exc_info(),None)
|
2013-02-23 01:05:23 +00:00
|
|
|
return expectedFailurei386_easy_wrapper
|
|
|
|
else:
|
|
|
|
def expectedFailurei386_impl(func):
|
|
|
|
@wraps(func)
|
|
|
|
def wrapper(*args, **kwargs):
|
2013-02-23 01:28:30 +00:00
|
|
|
from unittest2 import case
|
|
|
|
self = args[0]
|
|
|
|
arch = self.getArchitecture()
|
|
|
|
try:
|
|
|
|
func(*args, **kwargs)
|
|
|
|
except Exception:
|
|
|
|
if "i386" in arch:
|
|
|
|
raise case._ExpectedFailure(sys.exc_info(),bugnumber)
|
|
|
|
else:
|
|
|
|
raise
|
|
|
|
if "i386" in arch:
|
|
|
|
raise case._UnexpectedSuccess(sys.exc_info(),bugnumber)
|
2013-02-23 01:05:23 +00:00
|
|
|
return wrapper
|
|
|
|
return expectedFailurei386_impl
|
|
|
|
|
|
|
|
def expectedFailureLinux(bugnumber=None):
|
|
|
|
if callable(bugnumber):
|
|
|
|
@wraps(bugnumber)
|
|
|
|
def expectedFailureLinux_easy_wrapper(*args, **kwargs):
|
2013-02-23 01:28:30 +00:00
|
|
|
from unittest2 import case
|
|
|
|
self = args[0]
|
|
|
|
platform = sys.platform
|
|
|
|
try:
|
|
|
|
bugnumber(*args, **kwargs)
|
|
|
|
except Exception:
|
|
|
|
if "linux" in platform:
|
|
|
|
raise case._ExpectedFailure(sys.exc_info(),None)
|
|
|
|
else:
|
|
|
|
raise
|
|
|
|
if "linux" in platform:
|
|
|
|
raise case._UnexpectedSuccess(sys.exc_info(),None)
|
2013-02-23 01:05:23 +00:00
|
|
|
return expectedFailureLinux_easy_wrapper
|
|
|
|
else:
|
|
|
|
def expectedFailureLinux_impl(func):
|
|
|
|
@wraps(func)
|
|
|
|
def wrapper(*args, **kwargs):
|
2013-02-23 01:28:30 +00:00
|
|
|
from unittest2 import case
|
|
|
|
self = args[0]
|
|
|
|
platform = sys.platform
|
|
|
|
try:
|
|
|
|
func(*args, **kwargs)
|
|
|
|
except Exception:
|
|
|
|
if "linux" in platform:
|
|
|
|
raise case._ExpectedFailure(sys.exc_info(),bugnumber)
|
|
|
|
else:
|
|
|
|
raise
|
|
|
|
if "linux" in platform:
|
|
|
|
raise case._UnexpectedSuccess(sys.exc_info(),bugnumber)
|
2013-02-23 01:05:23 +00:00
|
|
|
return wrapper
|
|
|
|
return expectedFailureLinux_impl
|
2012-11-23 21:59:29 +00:00
|
|
|
|
|
|
|
def skipOnLinux(func):
|
|
|
|
"""Decorate the item to skip tests that should be skipped on Linux."""
|
|
|
|
if isinstance(func, type) and issubclass(func, unittest2.TestCase):
|
|
|
|
raise Exception("@skipOnLinux can only be used to decorate a test method")
|
|
|
|
@wraps(func)
|
|
|
|
def wrapper(*args, **kwargs):
|
|
|
|
from unittest2 import case
|
|
|
|
self = args[0]
|
|
|
|
platform = sys.platform
|
|
|
|
if "linux" in platform:
|
|
|
|
self.skipTest("skip on linux")
|
|
|
|
else:
|
2012-11-27 01:21:28 +00:00
|
|
|
func(*args, **kwargs)
|
2012-11-23 21:59:29 +00:00
|
|
|
return wrapper
|
|
|
|
|
2013-01-24 23:52:09 +00:00
|
|
|
def skipIfGcc(func):
|
|
|
|
"""Decorate the item to skip tests that should be skipped if building with gcc ."""
|
|
|
|
if isinstance(func, type) and issubclass(func, unittest2.TestCase):
|
2013-02-27 17:29:46 +00:00
|
|
|
raise Exception("@skipIfGcc can only be used to decorate a test method")
|
2013-01-24 23:52:09 +00:00
|
|
|
@wraps(func)
|
|
|
|
def wrapper(*args, **kwargs):
|
|
|
|
from unittest2 import case
|
|
|
|
self = args[0]
|
|
|
|
compiler = self.getCompiler()
|
|
|
|
if "gcc" in compiler:
|
|
|
|
self.skipTest("skipping because gcc is the test compiler")
|
|
|
|
else:
|
|
|
|
func(*args, **kwargs)
|
|
|
|
return wrapper
|
|
|
|
|
2011-08-01 18:46:13 +00:00
|
|
|
class Base(unittest2.TestCase):
|
|
|
|
"""
|
|
|
|
Abstract base for performing lldb (see TestBase) or other generic tests (see
|
|
|
|
BenchBase for one example). lldbtest.Base works with the test driver to
|
|
|
|
accomplish things.
|
|
|
|
|
2010-10-22 23:15:46 +00:00
|
|
|
"""
|
2012-10-24 21:42:49 +00:00
|
|
|
|
2012-10-24 21:44:48 +00:00
|
|
|
# The concrete subclass should override this attribute.
|
|
|
|
mydir = None
|
2010-07-03 03:41:59 +00:00
|
|
|
|
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
|
|
|
|
2011-08-01 19:50:58 +00:00
|
|
|
def TraceOn(self):
|
|
|
|
"""Returns True if we are in trace mode (tracing detailed test execution)."""
|
|
|
|
return traceAlways
|
|
|
|
|
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.")
|
2012-10-24 18:14:21 +00:00
|
|
|
|
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
|
|
|
|
2011-11-17 19:57:27 +00:00
|
|
|
if doCleanup and not lldb.skip_build_and_cleanup:
|
2010-10-11 22:25:46 +00:00
|
|
|
# First, let's do the platform-specific cleanup.
|
2011-06-20 19:06:20 +00:00
|
|
|
module = builder_module()
|
2010-10-11 22:25:46 +00:00
|
|
|
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)
|
|
|
|
|
2011-08-01 18:46:13 +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
|
|
|
|
|
|
|
|
def setUp(self):
|
2011-08-01 19:50:58 +00:00
|
|
|
"""Fixture for unittest test case setup.
|
|
|
|
|
|
|
|
It works with the test driver to conditionally skip tests and does other
|
|
|
|
initializations."""
|
2011-08-01 18:46:13 +00:00
|
|
|
#import traceback
|
|
|
|
#traceback.print_stack()
|
|
|
|
|
2011-08-02 22:54:37 +00:00
|
|
|
if "LLDB_EXEC" in os.environ:
|
|
|
|
self.lldbExec = os.environ["LLDB_EXEC"]
|
2011-08-26 00:00:01 +00:00
|
|
|
else:
|
|
|
|
self.lldbExec = None
|
|
|
|
if "LLDB_HERE" in os.environ:
|
|
|
|
self.lldbHere = os.environ["LLDB_HERE"]
|
|
|
|
else:
|
|
|
|
self.lldbHere = None
|
2011-10-07 19:21:09 +00:00
|
|
|
# If we spawn an lldb process for test (via pexpect), do not load the
|
|
|
|
# init file unless told otherwise.
|
|
|
|
if "NO_LLDBINIT" in os.environ and "NO" == os.environ["NO_LLDBINIT"]:
|
|
|
|
self.lldbOption = ""
|
|
|
|
else:
|
|
|
|
self.lldbOption = "--no-lldbinit"
|
2011-08-02 22:54:37 +00:00
|
|
|
|
2011-08-01 21:13:26 +00:00
|
|
|
# Assign the test method name to self.testMethodName.
|
|
|
|
#
|
|
|
|
# For an example of the use of this attribute, look at test/types dir.
|
|
|
|
# There are a bunch of test cases under test/types and we don't want the
|
|
|
|
# module cacheing subsystem to be confused with executable name "a.out"
|
|
|
|
# used for all the test cases.
|
|
|
|
self.testMethodName = self._testMethodName
|
|
|
|
|
2011-08-01 18:46:13 +00:00
|
|
|
# Python API only test is decorated with @python_api_test,
|
|
|
|
# which also sets the "__python_api_test__" attribute of the
|
|
|
|
# function object to True.
|
|
|
|
try:
|
|
|
|
if lldb.just_do_python_api_test:
|
|
|
|
testMethod = getattr(self, self._testMethodName)
|
|
|
|
if getattr(testMethod, "__python_api_test__", False):
|
|
|
|
pass
|
|
|
|
else:
|
|
|
|
self.skipTest("non python api test")
|
|
|
|
except AttributeError:
|
|
|
|
pass
|
|
|
|
|
|
|
|
# Benchmarks test is decorated with @benchmarks_test,
|
|
|
|
# which also sets the "__benchmarks_test__" attribute of the
|
|
|
|
# function object to True.
|
|
|
|
try:
|
|
|
|
if lldb.just_do_benchmarks_test:
|
|
|
|
testMethod = getattr(self, self._testMethodName)
|
|
|
|
if getattr(testMethod, "__benchmarks_test__", False):
|
|
|
|
pass
|
|
|
|
else:
|
|
|
|
self.skipTest("non benchmarks test")
|
|
|
|
except AttributeError:
|
|
|
|
pass
|
|
|
|
|
2011-08-01 21:13:26 +00:00
|
|
|
# This is for the case of directly spawning 'lldb'/'gdb' and interacting
|
|
|
|
# with it using pexpect.
|
|
|
|
self.child = None
|
|
|
|
self.child_prompt = "(lldb) "
|
|
|
|
# If the child is interacting with the embedded script interpreter,
|
|
|
|
# there are two exits required during tear down, first to quit the
|
|
|
|
# embedded script interpreter and second to quit the lldb command
|
|
|
|
# interpreter.
|
|
|
|
self.child_in_script_interpreter = False
|
|
|
|
|
2011-08-01 19:50:58 +00:00
|
|
|
# These are for customized teardown cleanup.
|
|
|
|
self.dict = None
|
|
|
|
self.doTearDownCleanup = False
|
|
|
|
# And in rare cases where there are multiple teardown cleanups.
|
|
|
|
self.dicts = []
|
|
|
|
self.doTearDownCleanups = False
|
|
|
|
|
2013-02-15 21:21:52 +00:00
|
|
|
# List of spawned subproces.Popen objects
|
|
|
|
self.subprocesses = []
|
|
|
|
|
2011-08-01 19:50:58 +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.
|
|
|
|
self.session = StringIO.StringIO()
|
|
|
|
|
|
|
|
# Optimistically set __errored__, __failed__, __expected__ to False
|
|
|
|
# initially. If the test errored/failed, the session info
|
|
|
|
# (self.session) is then dumped into a session specific file for
|
|
|
|
# diagnosis.
|
|
|
|
self.__errored__ = False
|
|
|
|
self.__failed__ = False
|
|
|
|
self.__expected__ = False
|
|
|
|
# We are also interested in unexpected success.
|
|
|
|
self.__unexpected__ = False
|
2011-08-16 00:48:58 +00:00
|
|
|
# And skipped tests.
|
|
|
|
self.__skipped__ = False
|
2011-08-01 19:50:58 +00:00
|
|
|
|
|
|
|
# See addTearDownHook(self, hook) which allows the client to add a hook
|
|
|
|
# function to be run during tearDown() time.
|
|
|
|
self.hooks = []
|
|
|
|
|
|
|
|
# See HideStdout(self).
|
|
|
|
self.sys_stdout_hidden = False
|
|
|
|
|
2012-11-26 21:21:11 +00:00
|
|
|
# set environment variable names for finding shared libraries
|
|
|
|
if sys.platform.startswith("darwin"):
|
|
|
|
self.dylibPath = 'DYLD_LIBRARY_PATH'
|
|
|
|
elif sys.platform.startswith("linux") or sys.platform.startswith("freebsd"):
|
|
|
|
self.dylibPath = 'LD_LIBRARY_PATH'
|
|
|
|
|
2011-10-19 16:48:07 +00:00
|
|
|
def runHooks(self, child=None, child_prompt=None, use_cmd_api=False):
|
2011-10-19 01:06:21 +00:00
|
|
|
"""Perform the run hooks to bring lldb debugger to the desired state.
|
|
|
|
|
2011-10-19 16:48:07 +00:00
|
|
|
By default, expect a pexpect spawned child and child prompt to be
|
|
|
|
supplied (use_cmd_api=False). If use_cmd_api is true, ignore the child
|
|
|
|
and child prompt and use self.runCmd() to run the hooks one by one.
|
|
|
|
|
2011-10-19 01:06:21 +00:00
|
|
|
Note that child is a process spawned by pexpect.spawn(). If not, your
|
|
|
|
test case is mostly likely going to fail.
|
|
|
|
|
|
|
|
See also dotest.py where lldb.runHooks are processed/populated.
|
|
|
|
"""
|
|
|
|
if not lldb.runHooks:
|
|
|
|
self.skipTest("No runhooks specified for lldb, skip the test")
|
2011-10-19 16:48:07 +00:00
|
|
|
if use_cmd_api:
|
|
|
|
for hook in lldb.runhooks:
|
|
|
|
self.runCmd(hook)
|
|
|
|
else:
|
|
|
|
if not child or not child_prompt:
|
|
|
|
self.fail("Both child and child_prompt need to be defined.")
|
|
|
|
for hook in lldb.runHooks:
|
|
|
|
child.sendline(hook)
|
|
|
|
child.expect_exact(child_prompt)
|
2011-10-19 01:06:21 +00:00
|
|
|
|
2013-02-19 16:08:57 +00:00
|
|
|
def setAsync(self, value):
|
|
|
|
""" Sets async mode to True/False and ensures it is reset after the testcase completes."""
|
|
|
|
old_async = self.dbg.GetAsync()
|
|
|
|
self.dbg.SetAsync(value)
|
|
|
|
self.addTearDownHook(lambda: self.dbg.SetAsync(old_async))
|
|
|
|
|
2013-02-15 21:21:52 +00:00
|
|
|
def cleanupSubprocesses(self):
|
|
|
|
# Ensure any subprocesses are cleaned up
|
|
|
|
for p in self.subprocesses:
|
|
|
|
if p.poll() == None:
|
|
|
|
p.terminate()
|
|
|
|
del p
|
|
|
|
del self.subprocesses[:]
|
|
|
|
|
|
|
|
def spawnSubprocess(self, executable, args=[]):
|
|
|
|
""" Creates a subprocess.Popen object with the specified executable and arguments,
|
|
|
|
saves it in self.subprocesses, and returns the object.
|
|
|
|
NOTE: if using this function, ensure you also call:
|
|
|
|
|
|
|
|
self.addTearDownHook(self.cleanupSubprocesses)
|
|
|
|
|
|
|
|
otherwise the test suite will leak processes.
|
|
|
|
"""
|
|
|
|
|
|
|
|
# Don't display the stdout if not in TraceOn() mode.
|
|
|
|
proc = Popen([executable] + args,
|
|
|
|
stdout = open(os.devnull) if not self.TraceOn() else None,
|
|
|
|
stdin = PIPE)
|
|
|
|
self.subprocesses.append(proc)
|
|
|
|
return proc
|
|
|
|
|
2011-08-01 19:50:58 +00:00
|
|
|
def HideStdout(self):
|
|
|
|
"""Hide output to stdout from the user.
|
|
|
|
|
|
|
|
During test execution, there might be cases where we don't want to show the
|
|
|
|
standard output to the user. For example,
|
|
|
|
|
|
|
|
self.runCmd(r'''sc print "\n\n\tHello!\n"''')
|
|
|
|
|
|
|
|
tests whether command abbreviation for 'script' works or not. There is no
|
|
|
|
need to show the 'Hello' output to the user as long as the 'script' command
|
|
|
|
succeeds and we are not in TraceOn() mode (see the '-t' option).
|
|
|
|
|
|
|
|
In this case, the test method calls self.HideStdout(self) to redirect the
|
|
|
|
sys.stdout to a null device, and restores the sys.stdout upon teardown.
|
|
|
|
|
|
|
|
Note that you should only call this method at most once during a test case
|
|
|
|
execution. Any subsequent call has no effect at all."""
|
|
|
|
if self.sys_stdout_hidden:
|
|
|
|
return
|
|
|
|
|
|
|
|
self.sys_stdout_hidden = True
|
|
|
|
old_stdout = sys.stdout
|
|
|
|
sys.stdout = open(os.devnull, 'w')
|
|
|
|
def restore_stdout():
|
|
|
|
sys.stdout = old_stdout
|
|
|
|
self.addTearDownHook(restore_stdout)
|
|
|
|
|
|
|
|
# =======================================================================
|
|
|
|
# Methods for customized teardown cleanups as well as execution of hooks.
|
|
|
|
# =======================================================================
|
|
|
|
|
|
|
|
def setTearDownCleanup(self, dictionary=None):
|
|
|
|
"""Register a cleanup action at tearDown() time with a dictinary"""
|
|
|
|
self.dict = dictionary
|
|
|
|
self.doTearDownCleanup = True
|
|
|
|
|
|
|
|
def addTearDownCleanup(self, dictionary):
|
|
|
|
"""Add a cleanup action at tearDown() time with a dictinary"""
|
|
|
|
self.dicts.append(dictionary)
|
|
|
|
self.doTearDownCleanups = True
|
|
|
|
|
|
|
|
def addTearDownHook(self, hook):
|
|
|
|
"""
|
|
|
|
Add a function to be run during tearDown() time.
|
|
|
|
|
|
|
|
Hooks are executed in a first come first serve manner.
|
|
|
|
"""
|
|
|
|
if callable(hook):
|
|
|
|
with recording(self, traceAlways) as sbuf:
|
|
|
|
print >> sbuf, "Adding tearDown hook:", getsource_if_available(hook)
|
|
|
|
self.hooks.append(hook)
|
|
|
|
|
|
|
|
def tearDown(self):
|
|
|
|
"""Fixture for unittest test case teardown."""
|
|
|
|
#import traceback
|
|
|
|
#traceback.print_stack()
|
|
|
|
|
2011-08-01 21:13:26 +00:00
|
|
|
# This is for the case of directly spawning 'lldb' and interacting with it
|
|
|
|
# using pexpect.
|
|
|
|
import pexpect
|
|
|
|
if self.child and self.child.isalive():
|
|
|
|
with recording(self, traceAlways) as sbuf:
|
|
|
|
print >> sbuf, "tearing down the child process...."
|
|
|
|
try:
|
2013-02-22 00:41:26 +00:00
|
|
|
if self.child_in_script_interpreter:
|
|
|
|
self.child.sendline('quit()')
|
|
|
|
self.child.expect_exact(self.child_prompt)
|
|
|
|
self.child.sendline('settings set interpreter.prompt-on-quit false')
|
|
|
|
self.child.sendline('quit')
|
2011-08-01 21:13:26 +00:00
|
|
|
self.child.expect(pexpect.EOF)
|
2013-02-22 00:41:26 +00:00
|
|
|
except ValueError, ExceptionPexpect:
|
|
|
|
# child is already terminated
|
2011-08-01 21:13:26 +00:00
|
|
|
pass
|
2013-02-22 00:41:26 +00:00
|
|
|
|
2012-02-27 23:07:40 +00:00
|
|
|
# Give it one final blow to make sure the child is terminated.
|
|
|
|
self.child.close()
|
2011-08-01 21:13:26 +00:00
|
|
|
|
2011-08-01 19:50:58 +00:00
|
|
|
# Check and run any hook functions.
|
|
|
|
for hook in reversed(self.hooks):
|
|
|
|
with recording(self, traceAlways) as sbuf:
|
|
|
|
print >> sbuf, "Executing tearDown hook:", getsource_if_available(hook)
|
|
|
|
hook()
|
|
|
|
|
|
|
|
del self.hooks
|
|
|
|
|
|
|
|
# Perform registered teardown cleanup.
|
|
|
|
if doCleanup and self.doTearDownCleanup:
|
2011-11-17 19:57:27 +00:00
|
|
|
self.cleanup(dictionary=self.dict)
|
2011-08-01 19:50:58 +00:00
|
|
|
|
|
|
|
# In rare cases where there are multiple teardown cleanups added.
|
|
|
|
if doCleanup and self.doTearDownCleanups:
|
|
|
|
if self.dicts:
|
|
|
|
for dict in reversed(self.dicts):
|
2011-11-17 19:57:27 +00:00
|
|
|
self.cleanup(dictionary=dict)
|
2011-08-01 19:50:58 +00:00
|
|
|
|
|
|
|
# Decide whether to dump the session info.
|
|
|
|
self.dumpSessionInfo()
|
|
|
|
|
|
|
|
# =========================================================
|
|
|
|
# Various callbacks to allow introspection of test progress
|
|
|
|
# =========================================================
|
|
|
|
|
|
|
|
def markError(self):
|
|
|
|
"""Callback invoked when an error (unexpected exception) errored."""
|
|
|
|
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"
|
|
|
|
|
|
|
|
def markFailure(self):
|
|
|
|
"""Callback invoked when a failure (test assertion failure) occurred."""
|
|
|
|
self.__failed__ = True
|
|
|
|
with recording(self, False) as sbuf:
|
|
|
|
# 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.
|
|
|
|
print >> sbuf, "FAIL"
|
|
|
|
|
2013-02-23 01:05:23 +00:00
|
|
|
def markExpectedFailure(self,err,bugnumber):
|
2011-08-01 19:50:58 +00:00
|
|
|
"""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.
|
2013-02-23 01:05:23 +00:00
|
|
|
if bugnumber == None:
|
|
|
|
print >> sbuf, "expected failure"
|
|
|
|
else:
|
|
|
|
print >> sbuf, "expected failure (problem id:" + str(bugnumber) + ")"
|
2011-08-01 19:50:58 +00:00
|
|
|
|
2011-08-15 23:09:08 +00:00
|
|
|
def markSkippedTest(self):
|
|
|
|
"""Callback invoked when a test is skipped."""
|
|
|
|
self.__skipped__ = True
|
|
|
|
with recording(self, False) as sbuf:
|
|
|
|
# False because there's no need to write "skipped test" to the
|
|
|
|
# stderr twice.
|
|
|
|
# Once by the Python unittest framework, and a second time by us.
|
|
|
|
print >> sbuf, "skipped test"
|
|
|
|
|
2013-02-23 01:05:23 +00:00
|
|
|
def markUnexpectedSuccess(self, bugnumber):
|
2011-08-01 19:50:58 +00:00
|
|
|
"""Callback invoked when an unexpected success occurred."""
|
|
|
|
self.__unexpected__ = True
|
|
|
|
with recording(self, False) as sbuf:
|
|
|
|
# False because there's no need to write "unexpected success" to the
|
|
|
|
# stderr twice.
|
|
|
|
# Once by the Python unittest framework, and a second time by us.
|
2013-02-23 01:05:23 +00:00
|
|
|
if bugnumber == None:
|
|
|
|
print >> sbuf, "unexpected success"
|
|
|
|
else:
|
|
|
|
print >> sbuf, "unexpected success (problem id:" + str(bugnumber) + ")"
|
2011-08-01 19:50:58 +00:00
|
|
|
|
|
|
|
def dumpSessionInfo(self):
|
|
|
|
"""
|
|
|
|
Dump the debugger interactions leading to a test error/failure. This
|
|
|
|
allows for more convenient postmortem analysis.
|
|
|
|
|
|
|
|
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.
|
|
|
|
"""
|
|
|
|
|
|
|
|
# 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.
|
|
|
|
#
|
|
|
|
# The lists contain 2-tuples of TestCase instances and strings holding
|
|
|
|
# formatted tracebacks.
|
|
|
|
#
|
|
|
|
# See http://docs.python.org/library/unittest.html#unittest.TestResult.
|
|
|
|
if self.__errored__:
|
|
|
|
pairs = lldb.test_result.errors
|
|
|
|
prefix = 'Error'
|
|
|
|
elif self.__failed__:
|
|
|
|
pairs = lldb.test_result.failures
|
|
|
|
prefix = 'Failure'
|
|
|
|
elif self.__expected__:
|
|
|
|
pairs = lldb.test_result.expectedFailures
|
|
|
|
prefix = 'ExpectedFailure'
|
2011-08-15 23:09:08 +00:00
|
|
|
elif self.__skipped__:
|
|
|
|
prefix = 'SkippedTest'
|
2011-08-01 19:50:58 +00:00
|
|
|
elif self.__unexpected__:
|
|
|
|
prefix = "UnexpectedSuccess"
|
|
|
|
else:
|
|
|
|
# Simply return, there's no session info to dump!
|
|
|
|
return
|
|
|
|
|
2011-08-15 23:09:08 +00:00
|
|
|
if not self.__unexpected__ and not self.__skipped__:
|
2011-08-01 19:50:58 +00:00
|
|
|
for test, traceback in pairs:
|
|
|
|
if test is self:
|
|
|
|
print >> self.session, traceback
|
|
|
|
|
2011-08-11 00:16:28 +00:00
|
|
|
testMethod = getattr(self, self._testMethodName)
|
|
|
|
if getattr(testMethod, "__benchmarks_test__", False):
|
|
|
|
benchmarks = True
|
|
|
|
else:
|
|
|
|
benchmarks = False
|
|
|
|
|
2011-12-03 00:16:59 +00:00
|
|
|
# This records the compiler version used for the test.
|
|
|
|
system([self.getCompiler(), "-v"], sender=self)
|
|
|
|
|
2011-08-01 19:50:58 +00:00
|
|
|
dname = os.path.join(os.environ["LLDB_TEST"],
|
|
|
|
os.environ["LLDB_SESSION_DIRNAME"])
|
|
|
|
if not os.path.isdir(dname):
|
|
|
|
os.mkdir(dname)
|
2012-10-16 18:22:04 +00:00
|
|
|
fname = os.path.join(dname, "%s-%s-%s-%s.log" % (prefix, self.getArchitecture(), "_".join(self.getCompiler().split('/')), self.id()))
|
2011-08-01 19:50:58 +00:00
|
|
|
with open(fname, "w") as f:
|
|
|
|
import datetime
|
|
|
|
print >> f, "Session info generated @", datetime.datetime.now().ctime()
|
|
|
|
print >> f, self.session.getvalue()
|
|
|
|
print >> f, "To rerun this test, issue the following command from the 'test' directory:\n"
|
2011-08-11 00:16:28 +00:00
|
|
|
print >> f, "./dotest.py %s -v %s -f %s.%s" % (self.getRunOptions(),
|
|
|
|
('+b' if benchmarks else '-t'),
|
2011-08-01 19:50:58 +00:00
|
|
|
self.__class__.__name__,
|
|
|
|
self._testMethodName)
|
|
|
|
|
|
|
|
# ====================================================
|
|
|
|
# Config. methods supported through a plugin interface
|
|
|
|
# (enables reading of the current test configuration)
|
|
|
|
# ====================================================
|
|
|
|
|
|
|
|
def getArchitecture(self):
|
|
|
|
"""Returns the architecture in effect the test suite is running with."""
|
|
|
|
module = builder_module()
|
|
|
|
return module.getArchitecture()
|
|
|
|
|
|
|
|
def getCompiler(self):
|
|
|
|
"""Returns the compiler in effect the test suite is running with."""
|
|
|
|
module = builder_module()
|
|
|
|
return module.getCompiler()
|
|
|
|
|
2013-02-27 17:29:46 +00:00
|
|
|
def getCompilerVersion(self):
|
|
|
|
""" Returns a string that represents the compiler version.
|
|
|
|
Supports: llvm, clang.
|
|
|
|
"""
|
|
|
|
from lldbutil import which
|
|
|
|
version = 'unknown'
|
|
|
|
|
|
|
|
compiler = self.getCompiler()
|
|
|
|
version_output = system([which(compiler), "-v"])[1]
|
|
|
|
for line in version_output.split(os.linesep):
|
|
|
|
compiler_shortname = 'invalid'
|
2013-02-28 18:46:31 +00:00
|
|
|
for c in ["clang", "LLVM", "gcc"]:
|
2013-02-27 17:29:46 +00:00
|
|
|
if c in compiler:
|
|
|
|
compiler_shortname = c
|
|
|
|
m = re.search('%s version ([0-9\.]+)' % compiler_shortname, line)
|
|
|
|
if m:
|
|
|
|
version = m.group(1)
|
|
|
|
return version
|
|
|
|
|
2011-08-01 19:50:58 +00:00
|
|
|
def getRunOptions(self):
|
|
|
|
"""Command line option for -A and -C to run this test again, called from
|
|
|
|
self.dumpSessionInfo()."""
|
|
|
|
arch = self.getArchitecture()
|
|
|
|
comp = self.getCompiler()
|
2011-08-24 19:48:51 +00:00
|
|
|
if arch:
|
|
|
|
option_str = "-A " + arch
|
2011-08-01 19:50:58 +00:00
|
|
|
else:
|
2011-08-24 19:48:51 +00:00
|
|
|
option_str = ""
|
|
|
|
if comp:
|
2012-03-16 20:44:00 +00:00
|
|
|
option_str += " -C " + comp
|
2011-08-24 19:48:51 +00:00
|
|
|
return option_str
|
2011-08-01 19:50:58 +00:00
|
|
|
|
|
|
|
# ==================================================
|
|
|
|
# Build methods supported through a plugin interface
|
|
|
|
# ==================================================
|
|
|
|
|
2012-02-01 01:49:50 +00:00
|
|
|
def buildDefault(self, architecture=None, compiler=None, dictionary=None, clean=True):
|
2011-08-01 19:50:58 +00:00
|
|
|
"""Platform specific way to build the default binaries."""
|
2011-11-17 19:57:27 +00:00
|
|
|
if lldb.skip_build_and_cleanup:
|
|
|
|
return
|
2011-08-01 19:50:58 +00:00
|
|
|
module = builder_module()
|
2012-02-01 01:49:50 +00:00
|
|
|
if not module.buildDefault(self, architecture, compiler, dictionary, clean):
|
2011-08-01 19:50:58 +00:00
|
|
|
raise Exception("Don't know how to build default binary")
|
|
|
|
|
2012-02-01 01:49:50 +00:00
|
|
|
def buildDsym(self, architecture=None, compiler=None, dictionary=None, clean=True):
|
2011-08-01 19:50:58 +00:00
|
|
|
"""Platform specific way to build binaries with dsym info."""
|
2011-11-17 19:57:27 +00:00
|
|
|
if lldb.skip_build_and_cleanup:
|
|
|
|
return
|
2011-08-01 19:50:58 +00:00
|
|
|
module = builder_module()
|
2012-02-01 01:49:50 +00:00
|
|
|
if not module.buildDsym(self, architecture, compiler, dictionary, clean):
|
2011-08-01 19:50:58 +00:00
|
|
|
raise Exception("Don't know how to build binary with dsym")
|
|
|
|
|
2012-02-01 01:49:50 +00:00
|
|
|
def buildDwarf(self, architecture=None, compiler=None, dictionary=None, clean=True):
|
2011-08-01 19:50:58 +00:00
|
|
|
"""Platform specific way to build binaries with dwarf maps."""
|
2011-11-17 19:57:27 +00:00
|
|
|
if lldb.skip_build_and_cleanup:
|
|
|
|
return
|
2011-08-01 19:50:58 +00:00
|
|
|
module = builder_module()
|
2012-02-01 01:49:50 +00:00
|
|
|
if not module.buildDwarf(self, architecture, compiler, dictionary, clean):
|
2011-08-01 19:50:58 +00:00
|
|
|
raise Exception("Don't know how to build binary with dwarf")
|
2011-08-01 18:46:13 +00:00
|
|
|
|
2011-08-12 20:19:22 +00:00
|
|
|
def cleanup(self, dictionary=None):
|
|
|
|
"""Platform specific way to do cleanup after build."""
|
2011-11-17 19:57:27 +00:00
|
|
|
if lldb.skip_build_and_cleanup:
|
|
|
|
return
|
2011-08-12 20:19:22 +00:00
|
|
|
module = builder_module()
|
|
|
|
if not module.cleanup(self, dictionary):
|
2011-11-17 19:57:27 +00:00
|
|
|
raise Exception("Don't know how to do cleanup with dictionary: "+dictionary)
|
2011-08-12 20:19:22 +00:00
|
|
|
|
2011-08-01 18:46:13 +00:00
|
|
|
|
|
|
|
class TestBase(Base):
|
|
|
|
"""
|
|
|
|
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:
|
|
|
|
- populate the test method name
|
|
|
|
- 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.res)
|
|
|
|
- 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 associated with each target, if any,
|
|
|
|
and, then delete the target from the debugger's target list
|
|
|
|
- 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.
|
|
|
|
"""
|
|
|
|
|
|
|
|
# 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).
|
|
|
|
# Can be overridden by the LLDB_TIME_WAIT_NEXT_LAUNCH environment variable.
|
|
|
|
timeWaitNextLaunch = 1.0;
|
|
|
|
|
2011-06-21 00:53:00 +00:00
|
|
|
def doDelay(self):
|
|
|
|
"""See option -w of dotest.py."""
|
|
|
|
if ("LLDB_WAIT_BETWEEN_TEST_CASES" in os.environ and
|
|
|
|
os.environ["LLDB_WAIT_BETWEEN_TEST_CASES"] == 'YES'):
|
|
|
|
waitTime = 1.0
|
|
|
|
if "LLDB_TIME_WAIT_BETWEEN_TEST_CASES" in os.environ:
|
|
|
|
waitTime = float(os.environ["LLDB_TIME_WAIT_BETWEEN_TEST_CASES"])
|
|
|
|
time.sleep(waitTime)
|
|
|
|
|
Initial commit of a new testsuite feature: test categories.
This feature allows us to group test cases into logical groups (categories), and to only run a subset of test cases based on these categories.
Each test-case can have a new method getCategories(self): which returns a list of strings that are the categories to which the test case belongs.
If a test-case does not provide its own categories, we will look for categories in the class that contains the test case.
If that fails too, the default implementation looks for a .category file, which contains a comma separated list of strings.
The test suite will recurse look for .categories up until the top level directory (which we guarantee will have an empty .category file).
The driver dotest.py has a new --category <foo> option, which can be repeated, and specifies which categories of tests you want to run.
(example: ./dotest.py --category objc --category expression)
All tests that do not belong to any specified category will be skipped. Other filtering options still exist and should not interfere with category filtering.
A few tests have been categorized. Feel free to categorize others, and to suggest new categories that we could want to use.
All categories need to be validly defined in dotest.py, or the test suite will refuse to run when you use them as arguments to --category.
In the end, failures will be reported on a per-category basis, as well as in the usual format.
This is the very first stage of this feature. Feel free to chime in with ideas for improvements!
llvm-svn: 164403
2012-09-21 19:10:53 +00:00
|
|
|
# Returns the list of categories to which this test case belongs
|
|
|
|
# by default, look for a ".categories" file, and read its contents
|
|
|
|
# if no such file exists, traverse the hierarchy - we guarantee
|
|
|
|
# a .categories to exist at the top level directory so we do not end up
|
|
|
|
# looping endlessly - subclasses are free to define their own categories
|
|
|
|
# in whatever way makes sense to them
|
|
|
|
def getCategories(self):
|
|
|
|
import inspect
|
|
|
|
import os.path
|
|
|
|
folder = inspect.getfile(self.__class__)
|
|
|
|
folder = os.path.dirname(folder)
|
|
|
|
while folder != '/':
|
|
|
|
categories_file_name = os.path.join(folder,".categories")
|
|
|
|
if os.path.exists(categories_file_name):
|
|
|
|
categories_file = open(categories_file_name,'r')
|
|
|
|
categories = categories_file.readline()
|
|
|
|
categories_file.close()
|
|
|
|
categories = str.replace(categories,'\n','')
|
|
|
|
categories = str.replace(categories,'\r','')
|
|
|
|
return categories.split(',')
|
|
|
|
else:
|
|
|
|
folder = os.path.dirname(folder)
|
|
|
|
continue
|
|
|
|
|
2010-09-16 01:53:04 +00:00
|
|
|
def setUp(self):
|
|
|
|
#import traceback
|
|
|
|
#traceback.print_stack()
|
2010-07-03 03:41:59 +00:00
|
|
|
|
2011-08-01 18:46:13 +00:00
|
|
|
# Works with the test driver to conditionally skip tests via decorators.
|
|
|
|
Base.setUp(self)
|
|
|
|
|
2011-05-31 23:21:42 +00:00
|
|
|
try:
|
|
|
|
if lldb.blacklist:
|
|
|
|
className = self.__class__.__name__
|
|
|
|
classAndMethodName = "%s.%s" % (className, self._testMethodName)
|
|
|
|
if className in lldb.blacklist:
|
|
|
|
self.skipTest(lldb.blacklist.get(className))
|
|
|
|
elif classAndMethodName in lldb.blacklist:
|
|
|
|
self.skipTest(lldb.blacklist.get(classAndMethodName))
|
|
|
|
except AttributeError:
|
|
|
|
pass
|
2010-12-01 22:47:54 +00:00
|
|
|
|
2011-06-21 00:53:00 +00:00
|
|
|
# Insert some delay between successive test cases if specified.
|
|
|
|
self.doDelay()
|
2010-10-07 02:04:14 +00:00
|
|
|
|
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:
|
2010-11-29 20:20:34 +00:00
|
|
|
self.timeWaitNextLaunch = 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
|
|
|
|
2011-05-25 19:06:18 +00:00
|
|
|
if not self.dbg:
|
2010-07-03 03:41:59 +00:00
|
|
|
raise Exception('Invalid debugger instance')
|
|
|
|
|
|
|
|
# We want our debugger to be synchronous.
|
|
|
|
self.dbg.SetAsync(False)
|
|
|
|
|
|
|
|
# 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()
|
|
|
|
|
2012-04-16 18:55:15 +00:00
|
|
|
# Run global pre-flight code, if defined via the config file.
|
|
|
|
if lldb.pre_flight:
|
|
|
|
lldb.pre_flight(self)
|
|
|
|
|
2012-10-24 01:23:57 +00:00
|
|
|
# utility methods that tests can use to access the current objects
|
|
|
|
def target(self):
|
|
|
|
if not self.dbg:
|
|
|
|
raise Exception('Invalid debugger instance')
|
|
|
|
return self.dbg.GetSelectedTarget()
|
|
|
|
|
|
|
|
def process(self):
|
|
|
|
if not self.dbg:
|
|
|
|
raise Exception('Invalid debugger instance')
|
|
|
|
return self.dbg.GetSelectedTarget().GetProcess()
|
|
|
|
|
|
|
|
def thread(self):
|
|
|
|
if not self.dbg:
|
|
|
|
raise Exception('Invalid debugger instance')
|
|
|
|
return self.dbg.GetSelectedTarget().GetProcess().GetSelectedThread()
|
|
|
|
|
|
|
|
def frame(self):
|
|
|
|
if not self.dbg:
|
|
|
|
raise Exception('Invalid debugger instance')
|
|
|
|
return self.dbg.GetSelectedTarget().GetProcess().GetSelectedThread().GetSelectedFrame()
|
|
|
|
|
2010-07-03 03:41:59 +00:00
|
|
|
def tearDown(self):
|
2010-09-02 21:23:12 +00:00
|
|
|
#import traceback
|
|
|
|
#traceback.print_stack()
|
|
|
|
|
2011-08-01 19:50:58 +00:00
|
|
|
Base.tearDown(self)
|
2010-10-19 23:40:13 +00:00
|
|
|
|
2011-06-15 21:24:24 +00:00
|
|
|
# Delete the target(s) from the debugger as a general cleanup step.
|
|
|
|
# This includes terminating the process for each target, if any.
|
|
|
|
# We'd like to reuse the debugger for our next test without incurring
|
|
|
|
# the initialization overhead.
|
|
|
|
targets = []
|
|
|
|
for target in self.dbg:
|
|
|
|
if target:
|
|
|
|
targets.append(target)
|
|
|
|
process = target.GetProcess()
|
|
|
|
if process:
|
|
|
|
rc = self.invoke(process, "Kill")
|
|
|
|
self.assertTrue(rc.Success(), PROCESS_KILLED)
|
|
|
|
for target in targets:
|
|
|
|
self.dbg.DeleteTarget(target)
|
2010-08-16 21:28:10 +00:00
|
|
|
|
2012-04-16 18:55:15 +00:00
|
|
|
# Run global post-flight code, if defined via the config file.
|
|
|
|
if lldb.post_flight:
|
|
|
|
lldb.post_flight(self)
|
|
|
|
|
2010-07-03 03:41:59 +00:00
|
|
|
del self.dbg
|
2010-10-15 01:18:29 +00:00
|
|
|
|
2011-09-30 21:48:35 +00:00
|
|
|
def switch_to_thread_with_stop_reason(self, stop_reason):
|
|
|
|
"""
|
|
|
|
Run the 'thread list' command, and select the thread with stop reason as
|
|
|
|
'stop_reason'. If no such thread exists, no select action is done.
|
|
|
|
"""
|
|
|
|
from lldbutil import stop_reason_to_str
|
|
|
|
self.runCmd('thread list')
|
|
|
|
output = self.res.GetOutput()
|
|
|
|
thread_line_pattern = re.compile("^[ *] thread #([0-9]+):.*stop reason = %s" %
|
|
|
|
stop_reason_to_str(stop_reason))
|
|
|
|
for line in output.splitlines():
|
|
|
|
matched = thread_line_pattern.match(line)
|
|
|
|
if matched:
|
|
|
|
self.runCmd('thread select %s' % matched.group(1))
|
|
|
|
|
2011-06-15 21:38:39 +00:00
|
|
|
def runCmd(self, cmd, msg=None, check=True, trace=False):
|
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-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:
|
2011-01-19 02:02:08 +00:00
|
|
|
# For process launch, wait some time before possible next try.
|
|
|
|
time.sleep(self.timeWaitNextLaunch)
|
2012-08-01 19:56:04 +00:00
|
|
|
with recording(self, trace) as sbuf:
|
2010-10-15 01:18:29 +00:00
|
|
|
print >> sbuf, "Command '" + cmd + "' failed!"
|
2010-08-20 17:57:32 +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
|
|
|
|
2012-09-22 00:05:11 +00:00
|
|
|
def match (self, str, patterns, msg=None, trace=False, error=False, matching=True, exe=True):
|
|
|
|
"""run command in str, and match the result against regexp in patterns returning the match object for the first matching pattern
|
|
|
|
|
|
|
|
Otherwise, all the arguments have the same meanings as for the expect function"""
|
|
|
|
|
|
|
|
trace = (True if traceAlways else trace)
|
|
|
|
|
|
|
|
if exe:
|
|
|
|
# First run the command. If we are expecting error, set check=False.
|
|
|
|
# Pass the assert message along since it provides more semantic info.
|
|
|
|
self.runCmd(str, msg=msg, trace = (True if trace else False), check = not error)
|
|
|
|
|
|
|
|
# Then compare the output against expected strings.
|
|
|
|
output = self.res.GetError() if error else self.res.GetOutput()
|
|
|
|
|
|
|
|
# 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
|
|
|
|
with recording(self, trace) as sbuf:
|
|
|
|
print >> sbuf, "looking at:", output
|
|
|
|
|
|
|
|
# The heading says either "Expecting" or "Not expecting".
|
|
|
|
heading = "Expecting" if matching else "Not expecting"
|
|
|
|
|
|
|
|
for pattern in patterns:
|
|
|
|
# Match Objects always have a boolean value of True.
|
|
|
|
match_object = re.search(pattern, output)
|
|
|
|
matched = bool(match_object)
|
|
|
|
with recording(self, trace) as sbuf:
|
|
|
|
print >> sbuf, "%s pattern: %s" % (heading, pattern)
|
|
|
|
print >> sbuf, "Matched" if matched else "Not matched"
|
|
|
|
if matched:
|
|
|
|
break
|
|
|
|
|
|
|
|
self.assertTrue(matched if matching else not matched,
|
|
|
|
msg if msg else EXP_MSG(str, exe))
|
|
|
|
|
|
|
|
return match_object
|
|
|
|
|
2011-09-30 21:48:35 +00:00
|
|
|
def expect(self, str, msg=None, patterns=None, startstr=None, endstr=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.
|
2012-10-23 00:09:02 +00:00
|
|
|
if isinstance(str,lldb.SBCommandReturnObject):
|
|
|
|
output = str.GetOutput()
|
|
|
|
else:
|
|
|
|
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
|
|
|
|
2011-09-30 21:48:35 +00:00
|
|
|
# Look for endstr, if specified.
|
|
|
|
keepgoing = matched if matching else not matched
|
|
|
|
if endstr:
|
|
|
|
matched = output.endswith(endstr)
|
|
|
|
with recording(self, trace) as sbuf:
|
|
|
|
print >> sbuf, "%s end string: %s" % (heading, endstr)
|
|
|
|
print >> sbuf, "Matched" if matched else "Not matched"
|
|
|
|
|
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
|
|
|
|
2011-05-27 23:36:52 +00:00
|
|
|
# =================================================
|
|
|
|
# Misc. helper methods for debugging test execution
|
|
|
|
# =================================================
|
|
|
|
|
2011-07-11 19:15:11 +00:00
|
|
|
def DebugSBValue(self, val):
|
2010-08-31 17:42:54 +00:00
|
|
|
"""Debug print a SBValue object, if traceAlways is True."""
|
2011-04-27 17:43:07 +00:00
|
|
|
from lldbutil import value_type_to_str
|
2010-11-03 21:37:58 +00:00
|
|
|
|
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")
|
2011-09-30 21:48:35 +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()) + '\n')
|
|
|
|
err.write('\t' + "ValueAsUnsigned -> " + str(val.GetValueAsUnsigned())+ '\n')
|
|
|
|
err.write('\t' + "ValueType -> " + value_type_to_str(val.GetValueType()) + '\n')
|
|
|
|
err.write('\t' + "Summary -> " + str(val.GetSummary()) + '\n')
|
|
|
|
err.write('\t' + "IsPointerType -> " + str(val.TypeIsPointerType()) + '\n')
|
|
|
|
err.write('\t' + "Location -> " + val.GetLocation() + '\n')
|
2010-08-27 00:15:48 +00:00
|
|
|
|
2011-08-05 20:17:27 +00:00
|
|
|
def DebugSBType(self, type):
|
|
|
|
"""Debug print a SBType object, if traceAlways is True."""
|
|
|
|
if not traceAlways:
|
|
|
|
return
|
|
|
|
|
|
|
|
err = sys.stderr
|
|
|
|
err.write(type.GetName() + ":\n")
|
|
|
|
err.write('\t' + "ByteSize -> " + str(type.GetByteSize()) + '\n')
|
|
|
|
err.write('\t' + "IsPointerType -> " + str(type.IsPointerType()) + '\n')
|
|
|
|
err.write('\t' + "IsReferenceType -> " + str(type.IsReferenceType()) + '\n')
|
|
|
|
|
2011-03-12 01:18:19 +00:00
|
|
|
def DebugPExpect(self, child):
|
|
|
|
"""Debug the spwaned pexpect object."""
|
|
|
|
if not traceAlways:
|
|
|
|
return
|
|
|
|
|
|
|
|
print child
|
2012-06-20 10:13:40 +00:00
|
|
|
|
|
|
|
@classmethod
|
|
|
|
def RemoveTempFile(cls, file):
|
|
|
|
if os.path.exists(file):
|
|
|
|
os.remove(file)
|