# Common functions and variables for testing the Python pretty printers.
#
# Copyright (C) 2016-2018 Free Software Foundation, Inc.
# This file is part of the GNU C Library.
#
# The GNU C Library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# The GNU C Library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with the GNU C Library; if not, see
# <http://www.gnu.org/licenses/>.
"""These tests require PExpect 4.0 or newer.
Exported constants:
PASS, FAIL, UNSUPPORTED (int): Test exit codes, as per evaluate-test.sh.
"""
import os
import re
from test_printers_exceptions import *
PASS = 0
FAIL = 1
UNSUPPORTED = 77
gdb_bin = 'gdb'
gdb_options = '-q -nx'
gdb_invocation = '{0} {1}'.format(gdb_bin, gdb_options)
pexpect_min_version = 4
gdb_min_version = (7, 8)
encoding = 'utf-8'
try:
import pexpect
except ImportError:
print('PExpect 4.0 or newer must be installed to test the pretty printers.')
exit(UNSUPPORTED)
pexpect_version = pexpect.__version__.split('.')[0]
if int(pexpect_version) < pexpect_min_version:
print('PExpect 4.0 or newer must be installed to test the pretty printers.')
exit(UNSUPPORTED)
if not pexpect.which(gdb_bin):
print('gdb 7.8 or newer must be installed to test the pretty printers.')
exit(UNSUPPORTED)
timeout = 5
TIMEOUTFACTOR = os.environ.get('TIMEOUTFACTOR')
if TIMEOUTFACTOR:
timeout = int(TIMEOUTFACTOR)
try:
# Check the gdb version.
version_cmd = '{0} --version'.format(gdb_invocation, timeout=timeout)
gdb_version_out = pexpect.run(version_cmd, encoding=encoding)
# The gdb version string is "GNU gdb <PKGVERSION><version>", where
# PKGVERSION can be any text. We assume that there'll always be a space
# between PKGVERSION and the version number for the sake of the regexp.
version_match = re.search(r'GNU gdb .* ([1-9]+)\.([0-9]+)', gdb_version_out)
if not version_match:
print('The gdb version string (gdb -v) is incorrectly formatted.')
exit(UNSUPPORTED)
gdb_version = (int(version_match.group(1)), int(version_match.group(2)))
if gdb_version < gdb_min_version:
print('gdb 7.8 or newer must be installed to test the pretty printers.')
exit(UNSUPPORTED)
# Check if gdb supports Python.
gdb_python_cmd = '{0} -ex "python import os" -batch'.format(gdb_invocation,
timeout=timeout)
gdb_python_error = pexpect.run(gdb_python_cmd, encoding=encoding)
if gdb_python_error:
print('gdb must have python support to test the pretty printers.')
print('gdb output: {!r}'.format(gdb_python_error))
exit(UNSUPPORTED)
# If everything's ok, spawn the gdb process we'll use for testing.
gdb = pexpect.spawn(gdb_invocation, echo=False, timeout=timeout,
encoding=encoding)
gdb_prompt = u'\(gdb\)'
gdb.expect(gdb_prompt)
except pexpect.ExceptionPexpect as exception:
print('Error: {0}'.format(exception))
exit(FAIL)
def test(command, pattern=None):
"""Sends 'command' to gdb and expects the given 'pattern'.
If 'pattern' is None, simply consumes everything up to and including
the gdb prompt.
Args:
command (string): The command we'll send to gdb.
pattern (raw string): A pattern the gdb output should match.
Returns:
string: The string that matched 'pattern', or an empty string if
'pattern' was None.
"""
match = ''
gdb.sendline(command)
if pattern:
# PExpect does a non-greedy match for '+' and '*'. Since it can't look
# ahead on the gdb output stream, if 'pattern' ends with a '+' or a '*'
# we may end up matching only part of the required output.
# To avoid this, we'll consume 'pattern' and anything that follows it
# up to and including the gdb prompt, then extract 'pattern' later.
index = gdb.expect([u'{0}.+{1}'.format(pattern, gdb_prompt),
pexpect.TIMEOUT])
if index == 0:
# gdb.after now contains the whole match. Extract the text that
# matches 'pattern'.
match = re.match(pattern, gdb.after, re.DOTALL).group()
elif index == 1:
# We got a timeout exception. Print information on what caused it
# and bail out.
error = ('Response does not match the expected pattern.\n'
'Command: {0}\n'
'Expected pattern: {1}\n'
'Response: {2}'.format(command, pattern, gdb.before))
raise pexpect.TIMEOUT(error)
else:
# Consume just the the gdb prompt.
gdb.expect(gdb_prompt)
return match
def init_test(test_bin, printer_files, printer_names):
"""Loads the test binary file and the required pretty printers to gdb.
Args:
test_bin (string): The name of the test binary file.
pretty_printers (list of strings): A list with the names of the pretty
printer files.
"""
# Load all the pretty printer files. We're assuming these are safe.
for printer_file in printer_files:
test('source {0}'.format(printer_file))
# Disable all the pretty printers.
test('disable pretty-printer', r'0 of [0-9]+ printers enabled')
# Enable only the required printers.
for printer in printer_names:
test('enable pretty-printer {0}'.format(printer),
r'[1-9][0-9]* of [1-9]+ printers enabled')
# Finally, load the test binary.
test('file {0}'.format(test_bin))
# Disable lock elision.
test('set environment GLIBC_TUNABLES glibc.elision.enable=0')
def go_to_main():
"""Executes a gdb 'start' command, which takes us to main."""
test('start', r'main')
def get_line_number(file_name, string):
"""Returns the number of the line in which 'string' appears within a file.
Args:
file_name (string): The name of the file we'll search through.
string (string): The string we'll look for.
Returns:
int: The number of the line in which 'string' appears, starting from 1.
"""
number = -1
with open(file_name) as src_file:
for i, line in enumerate(src_file):
if string in line:
number = i + 1
break
if number == -1:
raise NoLineError(file_name, string)
return number
def break_at(file_name, string, temporary=True, thread=None):
"""Places a breakpoint on the first line in 'file_name' containing 'string'.
'string' is usually a comment like "Stop here". Notice this may fail unless
the comment is placed inline next to actual code, e.g.:
...
/* Stop here */
...
may fail, while:
...
some_func(); /* Stop here */
...
will succeed.
If 'thread' isn't None, the breakpoint will be set for all the threads.
Otherwise, it'll be set only for 'thread'.
Args:
file_name (string): The name of the file we'll place the breakpoint in.
string (string): A string we'll look for inside the file.
We'll place a breakpoint on the line which contains it.
temporary (bool): Whether the breakpoint should be automatically deleted
after we reach it.
thread (int): The number of the thread we'll place the breakpoint for,
as seen by gdb. If specified, it should be greater than zero.
"""
if not thread:
thread_str = ''
else:
thread_str = 'thread {0}'.format(thread)
if temporary:
command = 'tbreak'
break_type = 'Temporary breakpoint'
else:
command = 'break'
break_type = 'Breakpoint'
line_number = str(get_line_number(file_name, string))
test('{0} {1}:{2} {3}'.format(command, file_name, line_number, thread_str),
r'{0} [0-9]+ at 0x[a-f0-9]+: file {1}, line {2}\.'.format(break_type,
file_name,
line_number))
def continue_cmd(thread=None):
"""Executes a gdb 'continue' command.
If 'thread' isn't None, the command will be applied to all the threads.
Otherwise, it'll be applied only to 'thread'.
Args:
thread (int): The number of the thread we'll apply the command to,
as seen by gdb. If specified, it should be greater than zero.
"""
if not thread:
command = 'continue'
else:
command = 'thread apply {0} continue'.format(thread)
test(command)
def next_cmd(count=1, thread=None):
"""Executes a gdb 'next' command.
If 'thread' isn't None, the command will be applied to all the threads.
Otherwise, it'll be applied only to 'thread'.
Args:
count (int): The 'count' argument of the 'next' command.
thread (int): The number of the thread we'll apply the command to,
as seen by gdb. If specified, it should be greater than zero.
"""
if not thread:
command = 'next'
else:
command = 'thread apply {0} next'
test('{0} {1}'.format(command, count))
def select_thread(thread):
"""Selects the thread indicated by 'thread'.
Args:
thread (int): The number of the thread we'll switch to, as seen by gdb.
This should be greater than zero.
"""
if thread > 0:
test('thread {0}'.format(thread))
def get_current_thread_lwpid():
"""Gets the current thread's Lightweight Process ID.
Returns:
string: The current thread's LWP ID.
"""
# It's easier to get the LWP ID through the Python API than the gdb CLI.
command = 'python print(gdb.selected_thread().ptid[1])'
return test(command, r'[0-9]+')
def set_scheduler_locking(mode):
"""Executes the gdb 'set scheduler-locking' command.
Args:
mode (bool): Whether the scheduler locking mode should be 'on'.
"""
modes = {
True: 'on',
False: 'off'
}
test('set scheduler-locking {0}'.format(modes[mode]))
def test_printer(var, to_string, children=None, is_ptr=True):
""" Tests the output of a pretty printer.
For a variable called 'var', this tests whether its associated printer
outputs the expected 'to_string' and children (if any).
Args:
var (string): The name of the variable we'll print.
to_string (raw string): The expected output of the printer's 'to_string'
method.
children (map {raw string->raw string}): A map with the expected output
of the printer's children' method.
is_ptr (bool): Whether 'var' is a pointer, and thus should be
dereferenced.
"""
if is_ptr:
var = '*{0}'.format(var)
test('print {0}'.format(var), to_string)
if children:
for name, value in children.items():
# Children are shown as 'name = value'.
test('print {0}'.format(var), r'{0} = {1}'.format(name, value))
def check_debug_symbol(symbol):
""" Tests whether a given debugging symbol exists.
If the symbol doesn't exist, raises a DebugError.
Args:
symbol (string): The symbol we're going to check for.
"""
try:
test('ptype {0}'.format(symbol), r'type = {0}'.format(symbol))
except pexpect.TIMEOUT:
# The symbol doesn't exist.
raise DebugError(symbol)