diff options
Diffstat (limited to 'tests/wpt/web-platform-tests/tools/pytest/_pytest/assertion/util.py')
| -rw-r--r-- | tests/wpt/web-platform-tests/tools/pytest/_pytest/assertion/util.py | 332 |
1 files changed, 0 insertions, 332 deletions
diff --git a/tests/wpt/web-platform-tests/tools/pytest/_pytest/assertion/util.py b/tests/wpt/web-platform-tests/tools/pytest/_pytest/assertion/util.py deleted file mode 100644 index f2f23efea27..00000000000 --- a/tests/wpt/web-platform-tests/tools/pytest/_pytest/assertion/util.py +++ /dev/null @@ -1,332 +0,0 @@ -"""Utilities for assertion debugging""" -import pprint - -import _pytest._code -import py -try: - from collections import Sequence -except ImportError: - Sequence = list - -BuiltinAssertionError = py.builtin.builtins.AssertionError -u = py.builtin._totext - -# The _reprcompare attribute on the util module is used by the new assertion -# interpretation code and assertion rewriter to detect this plugin was -# loaded and in turn call the hooks defined here as part of the -# DebugInterpreter. -_reprcompare = None - - -# the re-encoding is needed for python2 repr -# with non-ascii characters (see issue 877 and 1379) -def ecu(s): - try: - return u(s, 'utf-8', 'replace') - except TypeError: - return s - - -def format_explanation(explanation): - """This formats an explanation - - Normally all embedded newlines are escaped, however there are - three exceptions: \n{, \n} and \n~. The first two are intended - cover nested explanations, see function and attribute explanations - for examples (.visit_Call(), visit_Attribute()). The last one is - for when one explanation needs to span multiple lines, e.g. when - displaying diffs. - """ - explanation = ecu(explanation) - explanation = _collapse_false(explanation) - lines = _split_explanation(explanation) - result = _format_lines(lines) - return u('\n').join(result) - - -def _collapse_false(explanation): - """Collapse expansions of False - - So this strips out any "assert False\n{where False = ...\n}" - blocks. - """ - where = 0 - while True: - start = where = explanation.find("False\n{False = ", where) - if where == -1: - break - level = 0 - prev_c = explanation[start] - for i, c in enumerate(explanation[start:]): - if prev_c + c == "\n{": - level += 1 - elif prev_c + c == "\n}": - level -= 1 - if not level: - break - prev_c = c - else: - raise AssertionError("unbalanced braces: %r" % (explanation,)) - end = start + i - where = end - if explanation[end - 1] == '\n': - explanation = (explanation[:start] + explanation[start+15:end-1] + - explanation[end+1:]) - where -= 17 - return explanation - - -def _split_explanation(explanation): - """Return a list of individual lines in the explanation - - This will return a list of lines split on '\n{', '\n}' and '\n~'. - Any other newlines will be escaped and appear in the line as the - literal '\n' characters. - """ - raw_lines = (explanation or u('')).split('\n') - lines = [raw_lines[0]] - for l in raw_lines[1:]: - if l and l[0] in ['{', '}', '~', '>']: - lines.append(l) - else: - lines[-1] += '\\n' + l - return lines - - -def _format_lines(lines): - """Format the individual lines - - This will replace the '{', '}' and '~' characters of our mini - formatting language with the proper 'where ...', 'and ...' and ' + - ...' text, taking care of indentation along the way. - - Return a list of formatted lines. - """ - result = lines[:1] - stack = [0] - stackcnt = [0] - for line in lines[1:]: - if line.startswith('{'): - if stackcnt[-1]: - s = u('and ') - else: - s = u('where ') - stack.append(len(result)) - stackcnt[-1] += 1 - stackcnt.append(0) - result.append(u(' +') + u(' ')*(len(stack)-1) + s + line[1:]) - elif line.startswith('}'): - stack.pop() - stackcnt.pop() - result[stack[-1]] += line[1:] - else: - assert line[0] in ['~', '>'] - stack[-1] += 1 - indent = len(stack) if line.startswith('~') else len(stack) - 1 - result.append(u(' ')*indent + line[1:]) - assert len(stack) == 1 - return result - - -# Provide basestring in python3 -try: - basestring = basestring -except NameError: - basestring = str - - -def assertrepr_compare(config, op, left, right): - """Return specialised explanations for some operators/operands""" - width = 80 - 15 - len(op) - 2 # 15 chars indentation, 1 space around op - left_repr = py.io.saferepr(left, maxsize=int(width/2)) - right_repr = py.io.saferepr(right, maxsize=width-len(left_repr)) - - summary = u('%s %s %s') % (ecu(left_repr), op, ecu(right_repr)) - - issequence = lambda x: (isinstance(x, (list, tuple, Sequence)) and - not isinstance(x, basestring)) - istext = lambda x: isinstance(x, basestring) - isdict = lambda x: isinstance(x, dict) - isset = lambda x: isinstance(x, (set, frozenset)) - - def isiterable(obj): - try: - iter(obj) - return not istext(obj) - except TypeError: - return False - - verbose = config.getoption('verbose') - explanation = None - try: - if op == '==': - if istext(left) and istext(right): - explanation = _diff_text(left, right, verbose) - else: - if issequence(left) and issequence(right): - explanation = _compare_eq_sequence(left, right, verbose) - elif isset(left) and isset(right): - explanation = _compare_eq_set(left, right, verbose) - elif isdict(left) and isdict(right): - explanation = _compare_eq_dict(left, right, verbose) - if isiterable(left) and isiterable(right): - expl = _compare_eq_iterable(left, right, verbose) - if explanation is not None: - explanation.extend(expl) - else: - explanation = expl - elif op == 'not in': - if istext(left) and istext(right): - explanation = _notin_text(left, right, verbose) - except Exception: - explanation = [ - u('(pytest_assertion plugin: representation of details failed. ' - 'Probably an object has a faulty __repr__.)'), - u(_pytest._code.ExceptionInfo())] - - if not explanation: - return None - - return [summary] + explanation - - -def _diff_text(left, right, verbose=False): - """Return the explanation for the diff between text or bytes - - Unless --verbose is used this will skip leading and trailing - characters which are identical to keep the diff minimal. - - If the input are bytes they will be safely converted to text. - """ - from difflib import ndiff - explanation = [] - if isinstance(left, py.builtin.bytes): - left = u(repr(left)[1:-1]).replace(r'\n', '\n') - if isinstance(right, py.builtin.bytes): - right = u(repr(right)[1:-1]).replace(r'\n', '\n') - if not verbose: - i = 0 # just in case left or right has zero length - for i in range(min(len(left), len(right))): - if left[i] != right[i]: - break - if i > 42: - i -= 10 # Provide some context - explanation = [u('Skipping %s identical leading ' - 'characters in diff, use -v to show') % i] - left = left[i:] - right = right[i:] - if len(left) == len(right): - for i in range(len(left)): - if left[-i] != right[-i]: - break - if i > 42: - i -= 10 # Provide some context - explanation += [u('Skipping %s identical trailing ' - 'characters in diff, use -v to show') % i] - left = left[:-i] - right = right[:-i] - explanation += [line.strip('\n') - for line in ndiff(left.splitlines(), - right.splitlines())] - return explanation - - -def _compare_eq_iterable(left, right, verbose=False): - if not verbose: - return [u('Use -v to get the full diff')] - # dynamic import to speedup pytest - import difflib - - try: - left_formatting = pprint.pformat(left).splitlines() - right_formatting = pprint.pformat(right).splitlines() - explanation = [u('Full diff:')] - except Exception: - # hack: PrettyPrinter.pformat() in python 2 fails when formatting items that can't be sorted(), ie, calling - # sorted() on a list would raise. See issue #718. - # As a workaround, the full diff is generated by using the repr() string of each item of each container. - left_formatting = sorted(repr(x) for x in left) - right_formatting = sorted(repr(x) for x in right) - explanation = [u('Full diff (fallback to calling repr on each item):')] - explanation.extend(line.strip() for line in difflib.ndiff(left_formatting, right_formatting)) - return explanation - - -def _compare_eq_sequence(left, right, verbose=False): - explanation = [] - for i in range(min(len(left), len(right))): - if left[i] != right[i]: - explanation += [u('At index %s diff: %r != %r') - % (i, left[i], right[i])] - break - if len(left) > len(right): - explanation += [u('Left contains more items, first extra item: %s') - % py.io.saferepr(left[len(right)],)] - elif len(left) < len(right): - explanation += [ - u('Right contains more items, first extra item: %s') % - py.io.saferepr(right[len(left)],)] - return explanation - - -def _compare_eq_set(left, right, verbose=False): - explanation = [] - diff_left = left - right - diff_right = right - left - if diff_left: - explanation.append(u('Extra items in the left set:')) - for item in diff_left: - explanation.append(py.io.saferepr(item)) - if diff_right: - explanation.append(u('Extra items in the right set:')) - for item in diff_right: - explanation.append(py.io.saferepr(item)) - return explanation - - -def _compare_eq_dict(left, right, verbose=False): - explanation = [] - common = set(left).intersection(set(right)) - same = dict((k, left[k]) for k in common if left[k] == right[k]) - if same and not verbose: - explanation += [u('Omitting %s identical items, use -v to show') % - len(same)] - elif same: - explanation += [u('Common items:')] - explanation += pprint.pformat(same).splitlines() - diff = set(k for k in common if left[k] != right[k]) - if diff: - explanation += [u('Differing items:')] - for k in diff: - explanation += [py.io.saferepr({k: left[k]}) + ' != ' + - py.io.saferepr({k: right[k]})] - extra_left = set(left) - set(right) - if extra_left: - explanation.append(u('Left contains more items:')) - explanation.extend(pprint.pformat( - dict((k, left[k]) for k in extra_left)).splitlines()) - extra_right = set(right) - set(left) - if extra_right: - explanation.append(u('Right contains more items:')) - explanation.extend(pprint.pformat( - dict((k, right[k]) for k in extra_right)).splitlines()) - return explanation - - -def _notin_text(term, text, verbose=False): - index = text.find(term) - head = text[:index] - tail = text[index+len(term):] - correct_text = head + tail - diff = _diff_text(correct_text, text, verbose) - newdiff = [u('%s is contained here:') % py.io.saferepr(term, maxsize=42)] - for line in diff: - if line.startswith(u('Skipping')): - continue - if line.startswith(u('- ')): - continue - if line.startswith(u('+ ')): - newdiff.append(u(' ') + line[2:]) - else: - newdiff.append(line) - return newdiff |