From 2ee0e8eaec7f6e87664c2c9297633623cbd28868 Mon Sep 17 00:00:00 2001 From: Brett Cannon <bcannon@gmail.com> Date: Fri, 23 May 2008 05:03:59 +0000 Subject: Revert the renaming of repr to reprlib. --- Demo/pdist/cmptree.py | 2 +- Demo/pdist/server.py | 2 +- Doc/library/datatypes.rst | 2 +- Doc/library/repr.rst | 139 ++++++++++++++++++ Doc/library/reprlib.rst | 143 ------------------- Doc/tutorial/stdlib2.rst | 6 +- Lib/bdb.py | 6 +- Lib/copy.py | 19 +-- Lib/idlelib/Debugger.py | 4 +- Lib/idlelib/ObjectBrowser.py | 2 +- Lib/pdb.py | 2 +- Lib/pydoc.py | 2 +- Lib/repr.py | 132 +++++++++++++++++ Lib/reprlib.py | 132 ----------------- Lib/test/test___all__.py | 2 +- Lib/test/test_py3kwarn.py | 2 +- Lib/test/test_repr.py | 327 +++++++++++++++++++++++++++++++++++++++++++ Lib/test/test_reprlib.py | 327 ------------------------------------------- Misc/NEWS | 3 - 19 files changed, 624 insertions(+), 630 deletions(-) create mode 100644 Doc/library/repr.rst delete mode 100644 Doc/library/reprlib.rst create mode 100644 Lib/repr.py delete mode 100644 Lib/reprlib.py create mode 100644 Lib/test/test_repr.py delete mode 100644 Lib/test/test_reprlib.py diff --git a/Demo/pdist/cmptree.py b/Demo/pdist/cmptree.py index dccd3ae..f6c611f 100755 --- a/Demo/pdist/cmptree.py +++ b/Demo/pdist/cmptree.py @@ -1,7 +1,7 @@ """Compare local and remote dictionaries and transfer differing files -- like rdist.""" import sys -from reprlib import repr +from repr import repr import FSProxy import time import os diff --git a/Demo/pdist/server.py b/Demo/pdist/server.py index ea70e71..e692eea 100755 --- a/Demo/pdist/server.py +++ b/Demo/pdist/server.py @@ -4,7 +4,7 @@ import sys import socket import pickle from fnmatch import fnmatch -from reprlib import repr +from repr import repr # Default verbosity (0 = silent, 1 = print connections, 2 = print requests too) diff --git a/Doc/library/datatypes.rst b/Doc/library/datatypes.rst index b6b37ab..4ebaa6c 100644 --- a/Doc/library/datatypes.rst +++ b/Doc/library/datatypes.rst @@ -36,4 +36,4 @@ The following modules are documented in this chapter: new.rst copy.rst pprint.rst - reprlib.rst + repr.rst diff --git a/Doc/library/repr.rst b/Doc/library/repr.rst new file mode 100644 index 0000000..bd9743d --- /dev/null +++ b/Doc/library/repr.rst @@ -0,0 +1,139 @@ + +:mod:`repr` --- Alternate :func:`repr` implementation +===================================================== + +.. module:: repr + :synopsis: Alternate repr() implementation with size limits. +.. sectionauthor:: Fred L. Drake, Jr. <fdrake@acm.org> + +.. note:: + The :mod:`repr` module has been renamed to :mod:`reprlib` in + Python 3.0. + +The :mod:`repr` module provides a means for producing object representations +with limits on the size of the resulting strings. This is used in the Python +debugger and may be useful in other contexts as well. + +This module provides a class, an instance, and a function: + + +.. class:: Repr() + + Class which provides formatting services useful in implementing functions + similar to the built-in :func:`repr`; size limits for different object types + are added to avoid the generation of representations which are excessively long. + + +.. data:: aRepr + + This is an instance of :class:`Repr` which is used to provide the :func:`repr` + function described below. Changing the attributes of this object will affect + the size limits used by :func:`repr` and the Python debugger. + + +.. function:: repr(obj) + + This is the :meth:`repr` method of ``aRepr``. It returns a string similar to + that returned by the built-in function of the same name, but with limits on + most sizes. + + +.. _repr-objects: + +Repr Objects +------------ + +:class:`Repr` instances provide several members which can be used to provide +size limits for the representations of different object types, and methods +which format specific object types. + + +.. attribute:: Repr.maxlevel + + Depth limit on the creation of recursive representations. The default is ``6``. + + +.. attribute:: Repr.maxdict + Repr.maxlist + Repr.maxtuple + Repr.maxset + Repr.maxfrozenset + Repr.maxdeque + Repr.maxarray + + Limits on the number of entries represented for the named object type. The + default is ``4`` for :attr:`maxdict`, ``5`` for :attr:`maxarray`, and ``6`` for + the others. + + .. versionadded:: 2.4 + :attr:`maxset`, :attr:`maxfrozenset`, and :attr:`set`. + + +.. attribute:: Repr.maxlong + + Maximum number of characters in the representation for a long integer. Digits + are dropped from the middle. The default is ``40``. + + +.. attribute:: Repr.maxstring + + Limit on the number of characters in the representation of the string. Note + that the "normal" representation of the string is used as the character source: + if escape sequences are needed in the representation, these may be mangled when + the representation is shortened. The default is ``30``. + + +.. attribute:: Repr.maxother + + This limit is used to control the size of object types for which no specific + formatting method is available on the :class:`Repr` object. It is applied in a + similar manner as :attr:`maxstring`. The default is ``20``. + + +.. method:: Repr.repr(obj) + + The equivalent to the built-in :func:`repr` that uses the formatting imposed by + the instance. + + +.. method:: Repr.repr1(obj, level) + + Recursive implementation used by :meth:`repr`. This uses the type of *obj* to + determine which formatting method to call, passing it *obj* and *level*. The + type-specific methods should call :meth:`repr1` to perform recursive formatting, + with ``level - 1`` for the value of *level* in the recursive call. + + +.. method:: Repr.repr_TYPE(obj, level) + :noindex: + + Formatting methods for specific types are implemented as methods with a name + based on the type name. In the method name, **TYPE** is replaced by + ``string.join(string.split(type(obj).__name__, '_'))``. Dispatch to these + methods is handled by :meth:`repr1`. Type-specific methods which need to + recursively format a value should call ``self.repr1(subobj, level - 1)``. + + +.. _subclassing-reprs: + +Subclassing Repr Objects +------------------------ + +The use of dynamic dispatching by :meth:`Repr.repr1` allows subclasses of +:class:`Repr` to add support for additional built-in object types or to modify +the handling of types already supported. This example shows how special support +for file objects could be added:: + + import repr + import sys + + class MyRepr(repr.Repr): + def repr_file(self, obj, level): + if obj.name in ['<stdin>', '<stdout>', '<stderr>']: + return obj.name + else: + return `obj` + + aRepr = MyRepr() + print aRepr.repr(sys.stdin) # prints '<stdin>' + diff --git a/Doc/library/reprlib.rst b/Doc/library/reprlib.rst deleted file mode 100644 index c4859be..0000000 --- a/Doc/library/reprlib.rst +++ /dev/null @@ -1,143 +0,0 @@ -:mod:`reprlib` --- Alternate :func:`repr` implementation -======================================================== - -.. module:: repr - :synopsis: Old name for the reprlib module. - -.. module:: reprlib - :synopsis: Alternate repr() implementation with size limits. -.. sectionauthor:: Fred L. Drake, Jr. <fdrake@acm.org> - -.. note:: - The :mod:`repr` module has been renamed to :mod:`reprlib` in - Python 3.0. It is importable under both names in Python 2.6 - and the rest of the 2.x series. - - -The :mod:`reprlib` module provides a means for producing object representations -with limits on the size of the resulting strings. This is used in the Python -debugger and may be useful in other contexts as well. - -This module provides a class, an instance, and a function: - - -.. class:: Repr() - - Class which provides formatting services useful in implementing functions - similar to the built-in :func:`repr`; size limits for different object types - are added to avoid the generation of representations which are excessively long. - - -.. data:: aRepr - - This is an instance of :class:`Repr` which is used to provide the :func:`repr` - function described below. Changing the attributes of this object will affect - the size limits used by :func:`repr` and the Python debugger. - - -.. function:: repr(obj) - - This is the :meth:`repr` method of ``aRepr``. It returns a string similar to - that returned by the built-in function of the same name, but with limits on - most sizes. - - -.. _repr-objects: - -Repr Objects ------------- - -:class:`Repr` instances provide several members which can be used to provide -size limits for the representations of different object types, and methods -which format specific object types. - - -.. attribute:: Repr.maxlevel - - Depth limit on the creation of recursive representations. The default is ``6``. - - -.. attribute:: Repr.maxdict - Repr.maxlist - Repr.maxtuple - Repr.maxset - Repr.maxfrozenset - Repr.maxdeque - Repr.maxarray - - Limits on the number of entries represented for the named object type. The - default is ``4`` for :attr:`maxdict`, ``5`` for :attr:`maxarray`, and ``6`` for - the others. - - .. versionadded:: 2.4 - :attr:`maxset`, :attr:`maxfrozenset`, and :attr:`set`. - - -.. attribute:: Repr.maxlong - - Maximum number of characters in the representation for a long integer. Digits - are dropped from the middle. The default is ``40``. - - -.. attribute:: Repr.maxstring - - Limit on the number of characters in the representation of the string. Note - that the "normal" representation of the string is used as the character source: - if escape sequences are needed in the representation, these may be mangled when - the representation is shortened. The default is ``30``. - - -.. attribute:: Repr.maxother - - This limit is used to control the size of object types for which no specific - formatting method is available on the :class:`Repr` object. It is applied in a - similar manner as :attr:`maxstring`. The default is ``20``. - - -.. method:: Repr.repr(obj) - - The equivalent to the built-in :func:`repr` that uses the formatting imposed by - the instance. - - -.. method:: Repr.repr1(obj, level) - - Recursive implementation used by :meth:`repr`. This uses the type of *obj* to - determine which formatting method to call, passing it *obj* and *level*. The - type-specific methods should call :meth:`repr1` to perform recursive formatting, - with ``level - 1`` for the value of *level* in the recursive call. - - -.. method:: Repr.repr_TYPE(obj, level) - :noindex: - - Formatting methods for specific types are implemented as methods with a name - based on the type name. In the method name, **TYPE** is replaced by - ``string.join(string.split(type(obj).__name__, '_'))``. Dispatch to these - methods is handled by :meth:`repr1`. Type-specific methods which need to - recursively format a value should call ``self.repr1(subobj, level - 1)``. - - -.. _subclassing-reprs: - -Subclassing Repr Objects ------------------------- - -The use of dynamic dispatching by :meth:`Repr.repr1` allows subclasses of -:class:`Repr` to add support for additional built-in object types or to modify -the handling of types already supported. This example shows how special support -for file objects could be added:: - - import repr - import sys - - class MyRepr(repr.Repr): - def repr_file(self, obj, level): - if obj.name in ['<stdin>', '<stdout>', '<stderr>']: - return obj.name - else: - return `obj` - - aRepr = MyRepr() - print aRepr.repr(sys.stdin) # prints '<stdin>' - diff --git a/Doc/tutorial/stdlib2.rst b/Doc/tutorial/stdlib2.rst index 79044f9..9da5213 100644 --- a/Doc/tutorial/stdlib2.rst +++ b/Doc/tutorial/stdlib2.rst @@ -13,11 +13,11 @@ programming needs. These modules rarely occur in small scripts. Output Formatting ================= -The :mod:`reprlib` module provides a version of :func:`repr` customized for +The :mod:`repr` module provides a version of :func:`repr` customized for abbreviated displays of large or deeply nested containers:: - >>> import reprlib - >>> reprlib.repr(set('supercalifragilisticexpialidocious')) + >>> import repr + >>> repr.repr(set('supercalifragilisticexpialidocious')) "set(['a', 'c', 'd', 'e', 'f', 'g', ...])" The :mod:`pprint` module offers more sophisticated control over printing both diff --git a/Lib/bdb.py b/Lib/bdb.py index 5e4d7b4..74870e3 100644 --- a/Lib/bdb.py +++ b/Lib/bdb.py @@ -325,7 +325,7 @@ class Bdb: # def format_stack_entry(self, frame_lineno, lprefix=': '): - import linecache, reprlib + import linecache, repr frame, lineno = frame_lineno filename = self.canonic(frame.f_code.co_filename) s = '%s(%r)' % (filename, lineno) @@ -338,13 +338,13 @@ class Bdb: else: args = None if args: - s = s + reprlib.repr(args) + s = s + repr.repr(args) else: s = s + '()' if '__return__' in frame.f_locals: rv = frame.f_locals['__return__'] s = s + '->' - s = s + reprlib.repr(rv) + s = s + repr.repr(rv) line = linecache.getline(filename, lineno) if line: s = s + lprefix + line.strip() return s diff --git a/Lib/copy.py b/Lib/copy.py index f3871e5..3f2033f 100644 --- a/Lib/copy.py +++ b/Lib/copy.py @@ -399,16 +399,17 @@ def _test(): print l2 l.append({l[1]: l, 'xyz': l[2]}) l3 = copy(l) - import reprlib - print map(reprlib.repr, l) - print map(reprlib.repr, l1) - print map(reprlib.repr, l2) - print map(reprlib.repr, l3) + import repr + print map(repr.repr, l) + print map(repr.repr, l1) + print map(repr.repr, l2) + print map(repr.repr, l3) l3 = deepcopy(l) - print map(reprlib.repr, l) - print map(reprlib.repr, l1) - print map(reprlib.repr, l2) - print map(reprlib.repr, l3) + import repr + print map(repr.repr, l) + print map(repr.repr, l1) + print map(repr.repr, l2) + print map(repr.repr, l3) if __name__ == '__main__': _test() diff --git a/Lib/idlelib/Debugger.py b/Lib/idlelib/Debugger.py index a56c224..f56460a 100644 --- a/Lib/idlelib/Debugger.py +++ b/Lib/idlelib/Debugger.py @@ -413,8 +413,8 @@ class NamespaceViewer: height = 20*len(dict) # XXX 20 == observed height of Entry widget self.master = master self.title = title - import reprlib - self.repr = reprlib.Repr() + import repr + self.repr = repr.Repr() self.repr.maxstring = 60 self.repr.maxother = 60 self.frame = frame = Frame(master) diff --git a/Lib/idlelib/ObjectBrowser.py b/Lib/idlelib/ObjectBrowser.py index 8ff0041..a2a6cee 100644 --- a/Lib/idlelib/ObjectBrowser.py +++ b/Lib/idlelib/ObjectBrowser.py @@ -11,7 +11,7 @@ from TreeWidget import TreeItem, TreeNode, ScrolledCanvas -from reprlib import Repr +from repr import Repr myrepr = Repr() myrepr.maxstring = 100 diff --git a/Lib/pdb.py b/Lib/pdb.py index 3ed7a2f..8616202 100755 --- a/Lib/pdb.py +++ b/Lib/pdb.py @@ -8,7 +8,7 @@ import sys import linecache import cmd import bdb -from reprlib import Repr +from repr import Repr import os import re import pprint diff --git a/Lib/pydoc.py b/Lib/pydoc.py index 987d213..8007ed0 100755 --- a/Lib/pydoc.py +++ b/Lib/pydoc.py @@ -53,7 +53,7 @@ Richard Chamberlain, for the first implementation of textdoc. # path will be displayed. import sys, imp, os, re, types, inspect, __builtin__, pkgutil -from reprlib import Repr +from repr import Repr from string import expandtabs, find, join, lower, split, strip, rfind, rstrip try: from collections import deque diff --git a/Lib/repr.py b/Lib/repr.py new file mode 100644 index 0000000..3c26cc3 --- /dev/null +++ b/Lib/repr.py @@ -0,0 +1,132 @@ +"""Redo the builtin repr() (representation) but with limits on most sizes.""" + +__all__ = ["Repr","repr"] + +import __builtin__ +from itertools import islice + +class Repr: + + def __init__(self): + self.maxlevel = 6 + self.maxtuple = 6 + self.maxlist = 6 + self.maxarray = 5 + self.maxdict = 4 + self.maxset = 6 + self.maxfrozenset = 6 + self.maxdeque = 6 + self.maxstring = 30 + self.maxlong = 40 + self.maxother = 20 + + def repr(self, x): + return self.repr1(x, self.maxlevel) + + def repr1(self, x, level): + typename = type(x).__name__ + if ' ' in typename: + parts = typename.split() + typename = '_'.join(parts) + if hasattr(self, 'repr_' + typename): + return getattr(self, 'repr_' + typename)(x, level) + else: + s = __builtin__.repr(x) + if len(s) > self.maxother: + i = max(0, (self.maxother-3)//2) + j = max(0, self.maxother-3-i) + s = s[:i] + '...' + s[len(s)-j:] + return s + + def _repr_iterable(self, x, level, left, right, maxiter, trail=''): + n = len(x) + if level <= 0 and n: + s = '...' + else: + newlevel = level - 1 + repr1 = self.repr1 + pieces = [repr1(elem, newlevel) for elem in islice(x, maxiter)] + if n > maxiter: pieces.append('...') + s = ', '.join(pieces) + if n == 1 and trail: right = trail + right + return '%s%s%s' % (left, s, right) + + def repr_tuple(self, x, level): + return self._repr_iterable(x, level, '(', ')', self.maxtuple, ',') + + def repr_list(self, x, level): + return self._repr_iterable(x, level, '[', ']', self.maxlist) + + def repr_array(self, x, level): + header = "array('%s', [" % x.typecode + return self._repr_iterable(x, level, header, '])', self.maxarray) + + def repr_set(self, x, level): + x = _possibly_sorted(x) + return self._repr_iterable(x, level, 'set([', '])', self.maxset) + + def repr_frozenset(self, x, level): + x = _possibly_sorted(x) + return self._repr_iterable(x, level, 'frozenset([', '])', + self.maxfrozenset) + + def repr_deque(self, x, level): + return self._repr_iterable(x, level, 'deque([', '])', self.maxdeque) + + def repr_dict(self, x, level): + n = len(x) + if n == 0: return '{}' + if level <= 0: return '{...}' + newlevel = level - 1 + repr1 = self.repr1 + pieces = [] + for key in islice(_possibly_sorted(x), self.maxdict): + keyrepr = repr1(key, newlevel) + valrepr = repr1(x[key], newlevel) + pieces.append('%s: %s' % (keyrepr, valrepr)) + if n > self.maxdict: pieces.append('...') + s = ', '.join(pieces) + return '{%s}' % (s,) + + def repr_str(self, x, level): + s = __builtin__.repr(x[:self.maxstring]) + if len(s) > self.maxstring: + i = max(0, (self.maxstring-3)//2) + j = max(0, self.maxstring-3-i) + s = __builtin__.repr(x[:i] + x[len(x)-j:]) + s = s[:i] + '...' + s[len(s)-j:] + return s + + def repr_long(self, x, level): + s = __builtin__.repr(x) # XXX Hope this isn't too slow... + if len(s) > self.maxlong: + i = max(0, (self.maxlong-3)//2) + j = max(0, self.maxlong-3-i) + s = s[:i] + '...' + s[len(s)-j:] + return s + + def repr_instance(self, x, level): + try: + s = __builtin__.repr(x) + # Bugs in x.__repr__() can cause arbitrary + # exceptions -- then make up something + except Exception: + return '<%s instance at %x>' % (x.__class__.__name__, id(x)) + if len(s) > self.maxstring: + i = max(0, (self.maxstring-3)//2) + j = max(0, self.maxstring-3-i) + s = s[:i] + '...' + s[len(s)-j:] + return s + + +def _possibly_sorted(x): + # Since not all sequences of items can be sorted and comparison + # functions may raise arbitrary exceptions, return an unsorted + # sequence in that case. + try: + return sorted(x) + except Exception: + return list(x) + +aRepr = Repr() +repr = aRepr.repr diff --git a/Lib/reprlib.py b/Lib/reprlib.py deleted file mode 100644 index 3c26cc3..0000000 --- a/Lib/reprlib.py +++ /dev/null @@ -1,132 +0,0 @@ -"""Redo the builtin repr() (representation) but with limits on most sizes.""" - -__all__ = ["Repr","repr"] - -import __builtin__ -from itertools import islice - -class Repr: - - def __init__(self): - self.maxlevel = 6 - self.maxtuple = 6 - self.maxlist = 6 - self.maxarray = 5 - self.maxdict = 4 - self.maxset = 6 - self.maxfrozenset = 6 - self.maxdeque = 6 - self.maxstring = 30 - self.maxlong = 40 - self.maxother = 20 - - def repr(self, x): - return self.repr1(x, self.maxlevel) - - def repr1(self, x, level): - typename = type(x).__name__ - if ' ' in typename: - parts = typename.split() - typename = '_'.join(parts) - if hasattr(self, 'repr_' + typename): - return getattr(self, 'repr_' + typename)(x, level) - else: - s = __builtin__.repr(x) - if len(s) > self.maxother: - i = max(0, (self.maxother-3)//2) - j = max(0, self.maxother-3-i) - s = s[:i] + '...' + s[len(s)-j:] - return s - - def _repr_iterable(self, x, level, left, right, maxiter, trail=''): - n = len(x) - if level <= 0 and n: - s = '...' - else: - newlevel = level - 1 - repr1 = self.repr1 - pieces = [repr1(elem, newlevel) for elem in islice(x, maxiter)] - if n > maxiter: pieces.append('...') - s = ', '.join(pieces) - if n == 1 and trail: right = trail + right - return '%s%s%s' % (left, s, right) - - def repr_tuple(self, x, level): - return self._repr_iterable(x, level, '(', ')', self.maxtuple, ',') - - def repr_list(self, x, level): - return self._repr_iterable(x, level, '[', ']', self.maxlist) - - def repr_array(self, x, level): - header = "array('%s', [" % x.typecode - return self._repr_iterable(x, level, header, '])', self.maxarray) - - def repr_set(self, x, level): - x = _possibly_sorted(x) - return self._repr_iterable(x, level, 'set([', '])', self.maxset) - - def repr_frozenset(self, x, level): - x = _possibly_sorted(x) - return self._repr_iterable(x, level, 'frozenset([', '])', - self.maxfrozenset) - - def repr_deque(self, x, level): - return self._repr_iterable(x, level, 'deque([', '])', self.maxdeque) - - def repr_dict(self, x, level): - n = len(x) - if n == 0: return '{}' - if level <= 0: return '{...}' - newlevel = level - 1 - repr1 = self.repr1 - pieces = [] - for key in islice(_possibly_sorted(x), self.maxdict): - keyrepr = repr1(key, newlevel) - valrepr = repr1(x[key], newlevel) - pieces.append('%s: %s' % (keyrepr, valrepr)) - if n > self.maxdict: pieces.append('...') - s = ', '.join(pieces) - return '{%s}' % (s,) - - def repr_str(self, x, level): - s = __builtin__.repr(x[:self.maxstring]) - if len(s) > self.maxstring: - i = max(0, (self.maxstring-3)//2) - j = max(0, self.maxstring-3-i) - s = __builtin__.repr(x[:i] + x[len(x)-j:]) - s = s[:i] + '...' + s[len(s)-j:] - return s - - def repr_long(self, x, level): - s = __builtin__.repr(x) # XXX Hope this isn't too slow... - if len(s) > self.maxlong: - i = max(0, (self.maxlong-3)//2) - j = max(0, self.maxlong-3-i) - s = s[:i] + '...' + s[len(s)-j:] - return s - - def repr_instance(self, x, level): - try: - s = __builtin__.repr(x) - # Bugs in x.__repr__() can cause arbitrary - # exceptions -- then make up something - except Exception: - return '<%s instance at %x>' % (x.__class__.__name__, id(x)) - if len(s) > self.maxstring: - i = max(0, (self.maxstring-3)//2) - j = max(0, self.maxstring-3-i) - s = s[:i] + '...' + s[len(s)-j:] - return s - - -def _possibly_sorted(x): - # Since not all sequences of items can be sorted and comparison - # functions may raise arbitrary exceptions, return an unsorted - # sequence in that case. - try: - return sorted(x) - except Exception: - return list(x) - -aRepr = Repr() -repr = aRepr.repr diff --git a/Lib/test/test___all__.py b/Lib/test/test___all__.py index 466d921..846a2f6 100644 --- a/Lib/test/test___all__.py +++ b/Lib/test/test___all__.py @@ -123,7 +123,7 @@ class AllTest(unittest.TestCase): self.check_all("quopri") self.check_all("random") self.check_all("re") - self.check_all("reprlib") + self.check_all("repr") self.check_all("rexec") self.check_all("rfc822") self.check_all("rlcompleter") diff --git a/Lib/test/test_py3kwarn.py b/Lib/test/test_py3kwarn.py index ece38ec..b12d14d 100644 --- a/Lib/test/test_py3kwarn.py +++ b/Lib/test/test_py3kwarn.py @@ -218,7 +218,7 @@ class TestStdlibRenames(unittest.TestCase): renames = {'Queue': 'queue', 'SocketServer': 'socketserver', 'ConfigParser': 'configparser', - 'repr': 'reprlib'} + } def check_rename(self, module_name, new_module_name): """Make sure that: diff --git a/Lib/test/test_repr.py b/Lib/test/test_repr.py new file mode 100644 index 0000000..1094816 --- /dev/null +++ b/Lib/test/test_repr.py @@ -0,0 +1,327 @@ +""" + Test cases for the repr module + Nick Mathewson +""" + +import sys +import os +import shutil +import unittest + +from test.test_support import run_unittest +from repr import repr as r # Don't shadow builtin repr +from repr import Repr + + +def nestedTuple(nesting): + t = () + for i in range(nesting): + t = (t,) + return t + +class ReprTests(unittest.TestCase): + + def test_string(self): + eq = self.assertEquals + eq(r("abc"), "'abc'") + eq(r("abcdefghijklmnop"),"'abcdefghijklmnop'") + + s = "a"*30+"b"*30 + expected = repr(s)[:13] + "..." + repr(s)[-14:] + eq(r(s), expected) + + eq(r("\"'"), repr("\"'")) + s = "\""*30+"'"*100 + expected = repr(s)[:13] + "..." + repr(s)[-14:] + eq(r(s), expected) + + def test_tuple(self): + eq = self.assertEquals + eq(r((1,)), "(1,)") + + t3 = (1, 2, 3) + eq(r(t3), "(1, 2, 3)") + + r2 = Repr() + r2.maxtuple = 2 + expected = repr(t3)[:-2] + "...)" + eq(r2.repr(t3), expected) + + def test_container(self): + from array import array + from collections import deque + + eq = self.assertEquals + # Tuples give up after 6 elements + eq(r(()), "()") + eq(r((1,)), "(1,)") + eq(r((1, 2, 3)), "(1, 2, 3)") + eq(r((1, 2, 3, 4, 5, 6)), "(1, 2, 3, 4, 5, 6)") + eq(r((1, 2, 3, 4, 5, 6, 7)), "(1, 2, 3, 4, 5, 6, ...)") + + # Lists give up after 6 as well + eq(r([]), "[]") + eq(r([1]), "[1]") + eq(r([1, 2, 3]), "[1, 2, 3]") + eq(r([1, 2, 3, 4, 5, 6]), "[1, 2, 3, 4, 5, 6]") + eq(r([1, 2, 3, 4, 5, 6, 7]), "[1, 2, 3, 4, 5, 6, ...]") + + # Sets give up after 6 as well + eq(r(set([])), "set([])") + eq(r(set([1])), "set([1])") + eq(r(set([1, 2, 3])), "set([1, 2, 3])") + eq(r(set([1, 2, 3, 4, 5, 6])), "set([1, 2, 3, 4, 5, 6])") + eq(r(set([1, 2, 3, 4, 5, 6, 7])), "set([1, 2, 3, 4, 5, 6, ...])") + + # Frozensets give up after 6 as well + eq(r(frozenset([])), "frozenset([])") + eq(r(frozenset([1])), "frozenset([1])") + eq(r(frozenset([1, 2, 3])), "frozenset([1, 2, 3])") + eq(r(frozenset([1, 2, 3, 4, 5, 6])), "frozenset([1, 2, 3, 4, 5, 6])") + eq(r(frozenset([1, 2, 3, 4, 5, 6, 7])), "frozenset([1, 2, 3, 4, 5, 6, ...])") + + # collections.deque after 6 + eq(r(deque([1, 2, 3, 4, 5, 6, 7])), "deque([1, 2, 3, 4, 5, 6, ...])") + + # Dictionaries give up after 4. + eq(r({}), "{}") + d = {'alice': 1, 'bob': 2, 'charles': 3, 'dave': 4} + eq(r(d), "{'alice': 1, 'bob': 2, 'charles': 3, 'dave': 4}") + d['arthur'] = 1 + eq(r(d), "{'alice': 1, 'arthur': 1, 'bob': 2, 'charles': 3, ...}") + + # array.array after 5. + eq(r(array('i')), "array('i', [])") + eq(r(array('i', [1])), "array('i', [1])") + eq(r(array('i', [1, 2])), "array('i', [1, 2])") + eq(r(array('i', [1, 2, 3])), "array('i', [1, 2, 3])") + eq(r(array('i', [1, 2, 3, 4])), "array('i', [1, 2, 3, 4])") + eq(r(array('i', [1, 2, 3, 4, 5])), "array('i', [1, 2, 3, 4, 5])") + eq(r(array('i', [1, 2, 3, 4, 5, 6])), + "array('i', [1, 2, 3, 4, 5, ...])") + + def test_numbers(self): + eq = self.assertEquals + eq(r(123), repr(123)) + eq(r(123L), repr(123L)) + eq(r(1.0/3), repr(1.0/3)) + + n = 10L**100 + expected = repr(n)[:18] + "..." + repr(n)[-19:] + eq(r(n), expected) + + def test_instance(self): + eq = self.assertEquals + i1 = ClassWithRepr("a") + eq(r(i1), repr(i1)) + + i2 = ClassWithRepr("x"*1000) + expected = repr(i2)[:13] + "..." + repr(i2)[-14:] + eq(r(i2), expected) + + i3 = ClassWithFailingRepr() + eq(r(i3), ("<ClassWithFailingRepr instance at %x>"%id(i3))) + + s = r(ClassWithFailingRepr) + self.failUnless(s.startswith("<class ")) + self.failUnless(s.endswith(">")) + self.failUnless(s.find("...") == 8) + + def test_file(self): + fp = open(unittest.__file__) + self.failUnless(repr(fp).startswith( + "<open file '%s', mode 'r' at 0x" % unittest.__file__)) + fp.close() + self.failUnless(repr(fp).startswith( + "<closed file '%s', mode 'r' at 0x" % unittest.__file__)) + + def test_lambda(self): + self.failUnless(repr(lambda x: x).startswith( + "<function <lambda")) + # XXX anonymous functions? see func_repr + + def test_builtin_function(self): + eq = self.assertEquals + # Functions + eq(repr(hash), '<built-in function hash>') + # Methods + self.failUnless(repr(''.split).startswith( + '<built-in method split of str object at 0x')) + + def test_xrange(self): + eq = self.assertEquals + eq(repr(xrange(1)), 'xrange(1)') + eq(repr(xrange(1, 2)), 'xrange(1, 2)') + eq(repr(xrange(1, 2, 3)), 'xrange(1, 4, 3)') + + def test_nesting(self): + eq = self.assertEquals + # everything is meant to give up after 6 levels. + eq(r([[[[[[[]]]]]]]), "[[[[[[[]]]]]]]") + eq(r([[[[[[[[]]]]]]]]), "[[[[[[[...]]]]]]]") + + eq(r(nestedTuple(6)), "(((((((),),),),),),)") + eq(r(nestedTuple(7)), "(((((((...),),),),),),)") + + eq(r({ nestedTuple(5) : nestedTuple(5) }), + "{((((((),),),),),): ((((((),),),),),)}") + eq(r({ nestedTuple(6) : nestedTuple(6) }), + "{((((((...),),),),),): ((((((...),),),),),)}") + + eq(r([[[[[[{}]]]]]]), "[[[[[[{}]]]]]]") + eq(r([[[[[[[{}]]]]]]]), "[[[[[[[...]]]]]]]") + + def test_buffer(self): + # XXX doesn't test buffers with no b_base or read-write buffers (see + # bufferobject.c). The test is fairly incomplete too. Sigh. + x = buffer('foo') + self.failUnless(repr(x).startswith('<read-only buffer for 0x')) + + def test_cell(self): + # XXX Hmm? How to get at a cell object? + pass + + def test_descriptors(self): + eq = self.assertEquals + # method descriptors + eq(repr(dict.items), "<method 'items' of 'dict' objects>") + # XXX member descriptors + # XXX attribute descriptors + # XXX slot descriptors + # static and class methods + class C: + def foo(cls): pass + x = staticmethod(C.foo) + self.failUnless(repr(x).startswith('<staticmethod object at 0x')) + x = classmethod(C.foo) + self.failUnless(repr(x).startswith('<classmethod object at 0x')) + + def test_unsortable(self): + # Repr.repr() used to call sorted() on sets, frozensets and dicts + # without taking into account that not all objects are comparable + x = set([1j, 2j, 3j]) + y = frozenset(x) + z = {1j: 1, 2j: 2} + r(x) + r(y) + r(z) + +def touch(path, text=''): + fp = open(path, 'w') + fp.write(text) + fp.close() + +class LongReprTest(unittest.TestCase): + def setUp(self): + longname = 'areallylongpackageandmodulenametotestreprtruncation' + self.pkgname = os.path.join(longname) + self.subpkgname = os.path.join(longname, longname) + # Make the package and subpackage + shutil.rmtree(self.pkgname, ignore_errors=True) + os.mkdir(self.pkgname) + touch(os.path.join(self.pkgname, '__init__'+os.extsep+'py')) + shutil.rmtree(self.subpkgname, ignore_errors=True) + os.mkdir(self.subpkgname) + touch(os.path.join(self.subpkgname, '__init__'+os.extsep+'py')) + # Remember where we are + self.here = os.getcwd() + sys.path.insert(0, self.here) + + def tearDown(self): + actions = [] + for dirpath, dirnames, filenames in os.walk(self.pkgname): + for name in dirnames + filenames: + actions.append(os.path.join(dirpath, name)) + actions.append(self.pkgname) + actions.sort() + actions.reverse() + for p in actions: + if os.path.isdir(p): + os.rmdir(p) + else: + os.remove(p) + del sys.path[0] + + def test_module(self): + eq = self.assertEquals + touch(os.path.join(self.subpkgname, self.pkgname + os.extsep + 'py')) + from areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation import areallylongpackageandmodulenametotestreprtruncation + eq(repr(areallylongpackageandmodulenametotestreprtruncation), + "<module '%s' from '%s'>" % (areallylongpackageandmodulenametotestreprtruncation.__name__, areallylongpackageandmodulenametotestreprtruncation.__file__)) + eq(repr(sys), "<module 'sys' (built-in)>") + + def test_type(self): + eq = self.assertEquals + touch(os.path.join(self.subpkgname, 'foo'+os.extsep+'py'), '''\ +class foo(object): + pass +''') + from areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation import foo + eq(repr(foo.foo), + "<class '%s.foo'>" % foo.__name__) + + def test_object(self): + # XXX Test the repr of a type with a really long tp_name but with no + # tp_repr. WIBNI we had ::Inline? :) + pass + + def test_class(self): + touch(os.path.join(self.subpkgname, 'bar'+os.extsep+'py'), '''\ +class bar: + pass +''') + from areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation import bar + # Module name may be prefixed with "test.", depending on how run. + self.failUnless(repr(bar.bar).startswith( + "<class %s.bar at 0x" % bar.__name__)) + + def test_instance(self): + touch(os.path.join(self.subpkgname, 'baz'+os.extsep+'py'), '''\ +class baz: + pass +''') + from areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation import baz + ibaz = baz.baz() + self.failUnless(repr(ibaz).startswith( + "<%s.baz instance at 0x" % baz.__name__)) + + def test_method(self): + eq = self.assertEquals + touch(os.path.join(self.subpkgname, 'qux'+os.extsep+'py'), '''\ +class aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: + def amethod(self): pass +''') + from areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation import qux + # Unbound methods first + eq(repr(qux.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.amethod), + '<unbound method aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.amethod>') + # Bound method next + iqux = qux.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa() + self.failUnless(repr(iqux.amethod).startswith( + '<bound method aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.amethod of <%s.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa instance at 0x' \ + % (qux.__name__,) )) + + def test_builtin_function(self): + # XXX test built-in functions and methods with really long names + pass + +class ClassWithRepr: + def __init__(self, s): + self.s = s + def __repr__(self): + return "ClassWithLongRepr(%r)" % self.s + + +class ClassWithFailingRepr: + def __repr__(self): + raise Exception("This should be caught by Repr.repr_instance") + + +def test_main(): + run_unittest(ReprTests) + if os.name != 'mac': + run_unittest(LongReprTest) + + +if __name__ == "__main__": + test_main() diff --git a/Lib/test/test_reprlib.py b/Lib/test/test_reprlib.py deleted file mode 100644 index 50f728c..0000000 --- a/Lib/test/test_reprlib.py +++ /dev/null @@ -1,327 +0,0 @@ -""" - Test cases for the repr module - Nick Mathewson -""" - -import sys -import os -import shutil -import unittest - -from test.test_support import run_unittest -from reprlib import repr as r # Don't shadow builtin repr -from reprlib import Repr - - -def nestedTuple(nesting): - t = () - for i in range(nesting): - t = (t,) - return t - -class ReprTests(unittest.TestCase): - - def test_string(self): - eq = self.assertEquals - eq(r("abc"), "'abc'") - eq(r("abcdefghijklmnop"),"'abcdefghijklmnop'") - - s = "a"*30+"b"*30 - expected = repr(s)[:13] + "..." + repr(s)[-14:] - eq(r(s), expected) - - eq(r("\"'"), repr("\"'")) - s = "\""*30+"'"*100 - expected = repr(s)[:13] + "..." + repr(s)[-14:] - eq(r(s), expected) - - def test_tuple(self): - eq = self.assertEquals - eq(r((1,)), "(1,)") - - t3 = (1, 2, 3) - eq(r(t3), "(1, 2, 3)") - - r2 = Repr() - r2.maxtuple = 2 - expected = repr(t3)[:-2] + "...)" - eq(r2.repr(t3), expected) - - def test_container(self): - from array import array - from collections import deque - - eq = self.assertEquals - # Tuples give up after 6 elements - eq(r(()), "()") - eq(r((1,)), "(1,)") - eq(r((1, 2, 3)), "(1, 2, 3)") - eq(r((1, 2, 3, 4, 5, 6)), "(1, 2, 3, 4, 5, 6)") - eq(r((1, 2, 3, 4, 5, 6, 7)), "(1, 2, 3, 4, 5, 6, ...)") - - # Lists give up after 6 as well - eq(r([]), "[]") - eq(r([1]), "[1]") - eq(r([1, 2, 3]), "[1, 2, 3]") - eq(r([1, 2, 3, 4, 5, 6]), "[1, 2, 3, 4, 5, 6]") - eq(r([1, 2, 3, 4, 5, 6, 7]), "[1, 2, 3, 4, 5, 6, ...]") - - # Sets give up after 6 as well - eq(r(set([])), "set([])") - eq(r(set([1])), "set([1])") - eq(r(set([1, 2, 3])), "set([1, 2, 3])") - eq(r(set([1, 2, 3, 4, 5, 6])), "set([1, 2, 3, 4, 5, 6])") - eq(r(set([1, 2, 3, 4, 5, 6, 7])), "set([1, 2, 3, 4, 5, 6, ...])") - - # Frozensets give up after 6 as well - eq(r(frozenset([])), "frozenset([])") - eq(r(frozenset([1])), "frozenset([1])") - eq(r(frozenset([1, 2, 3])), "frozenset([1, 2, 3])") - eq(r(frozenset([1, 2, 3, 4, 5, 6])), "frozenset([1, 2, 3, 4, 5, 6])") - eq(r(frozenset([1, 2, 3, 4, 5, 6, 7])), "frozenset([1, 2, 3, 4, 5, 6, ...])") - - # collections.deque after 6 - eq(r(deque([1, 2, 3, 4, 5, 6, 7])), "deque([1, 2, 3, 4, 5, 6, ...])") - - # Dictionaries give up after 4. - eq(r({}), "{}") - d = {'alice': 1, 'bob': 2, 'charles': 3, 'dave': 4} - eq(r(d), "{'alice': 1, 'bob': 2, 'charles': 3, 'dave': 4}") - d['arthur'] = 1 - eq(r(d), "{'alice': 1, 'arthur': 1, 'bob': 2, 'charles': 3, ...}") - - # array.array after 5. - eq(r(array('i')), "array('i', [])") - eq(r(array('i', [1])), "array('i', [1])") - eq(r(array('i', [1, 2])), "array('i', [1, 2])") - eq(r(array('i', [1, 2, 3])), "array('i', [1, 2, 3])") - eq(r(array('i', [1, 2, 3, 4])), "array('i', [1, 2, 3, 4])") - eq(r(array('i', [1, 2, 3, 4, 5])), "array('i', [1, 2, 3, 4, 5])") - eq(r(array('i', [1, 2, 3, 4, 5, 6])), - "array('i', [1, 2, 3, 4, 5, ...])") - - def test_numbers(self): - eq = self.assertEquals - eq(r(123), repr(123)) - eq(r(123L), repr(123L)) - eq(r(1.0/3), repr(1.0/3)) - - n = 10L**100 - expected = repr(n)[:18] + "..." + repr(n)[-19:] - eq(r(n), expected) - - def test_instance(self): - eq = self.assertEquals - i1 = ClassWithRepr("a") - eq(r(i1), repr(i1)) - - i2 = ClassWithRepr("x"*1000) - expected = repr(i2)[:13] + "..." + repr(i2)[-14:] - eq(r(i2), expected) - - i3 = ClassWithFailingRepr() - eq(r(i3), ("<ClassWithFailingRepr instance at %x>"%id(i3))) - - s = r(ClassWithFailingRepr) - self.failUnless(s.startswith("<class ")) - self.failUnless(s.endswith(">")) - self.failUnless(s.find("...") == 8) - - def test_file(self): - fp = open(unittest.__file__) - self.failUnless(repr(fp).startswith( - "<open file '%s', mode 'r' at 0x" % unittest.__file__)) - fp.close() - self.failUnless(repr(fp).startswith( - "<closed file '%s', mode 'r' at 0x" % unittest.__file__)) - - def test_lambda(self): - self.failUnless(repr(lambda x: x).startswith( - "<function <lambda")) - # XXX anonymous functions? see func_repr - - def test_builtin_function(self): - eq = self.assertEquals - # Functions - eq(repr(hash), '<built-in function hash>') - # Methods - self.failUnless(repr(''.split).startswith( - '<built-in method split of str object at 0x')) - - def test_xrange(self): - eq = self.assertEquals - eq(repr(xrange(1)), 'xrange(1)') - eq(repr(xrange(1, 2)), 'xrange(1, 2)') - eq(repr(xrange(1, 2, 3)), 'xrange(1, 4, 3)') - - def test_nesting(self): - eq = self.assertEquals - # everything is meant to give up after 6 levels. - eq(r([[[[[[[]]]]]]]), "[[[[[[[]]]]]]]") - eq(r([[[[[[[[]]]]]]]]), "[[[[[[[...]]]]]]]") - - eq(r(nestedTuple(6)), "(((((((),),),),),),)") - eq(r(nestedTuple(7)), "(((((((...),),),),),),)") - - eq(r({ nestedTuple(5) : nestedTuple(5) }), - "{((((((),),),),),): ((((((),),),),),)}") - eq(r({ nestedTuple(6) : nestedTuple(6) }), - "{((((((...),),),),),): ((((((...),),),),),)}") - - eq(r([[[[[[{}]]]]]]), "[[[[[[{}]]]]]]") - eq(r([[[[[[[{}]]]]]]]), "[[[[[[[...]]]]]]]") - - def test_buffer(self): - # XXX doesn't test buffers with no b_base or read-write buffers (see - # bufferobject.c). The test is fairly incomplete too. Sigh. - x = buffer('foo') - self.failUnless(repr(x).startswith('<read-only buffer for 0x')) - - def test_cell(self): - # XXX Hmm? How to get at a cell object? - pass - - def test_descriptors(self): - eq = self.assertEquals - # method descriptors - eq(repr(dict.items), "<method 'items' of 'dict' objects>") - # XXX member descriptors - # XXX attribute descriptors - # XXX slot descriptors - # static and class methods - class C: - def foo(cls): pass - x = staticmethod(C.foo) - self.failUnless(repr(x).startswith('<staticmethod object at 0x')) - x = classmethod(C.foo) - self.failUnless(repr(x).startswith('<classmethod object at 0x')) - - def test_unsortable(self): - # Repr.repr() used to call sorted() on sets, frozensets and dicts - # without taking into account that not all objects are comparable - x = set([1j, 2j, 3j]) - y = frozenset(x) - z = {1j: 1, 2j: 2} - r(x) - r(y) - r(z) - -def touch(path, text=''): - fp = open(path, 'w') - fp.write(text) - fp.close() - -class LongReprTest(unittest.TestCase): - def setUp(self): - longname = 'areallylongpackageandmodulenametotestreprtruncation' - self.pkgname = os.path.join(longname) - self.subpkgname = os.path.join(longname, longname) - # Make the package and subpackage - shutil.rmtree(self.pkgname, ignore_errors=True) - os.mkdir(self.pkgname) - touch(os.path.join(self.pkgname, '__init__'+os.extsep+'py')) - shutil.rmtree(self.subpkgname, ignore_errors=True) - os.mkdir(self.subpkgname) - touch(os.path.join(self.subpkgname, '__init__'+os.extsep+'py')) - # Remember where we are - self.here = os.getcwd() - sys.path.insert(0, self.here) - - def tearDown(self): - actions = [] - for dirpath, dirnames, filenames in os.walk(self.pkgname): - for name in dirnames + filenames: - actions.append(os.path.join(dirpath, name)) - actions.append(self.pkgname) - actions.sort() - actions.reverse() - for p in actions: - if os.path.isdir(p): - os.rmdir(p) - else: - os.remove(p) - del sys.path[0] - - def test_module(self): - eq = self.assertEquals - touch(os.path.join(self.subpkgname, self.pkgname + os.extsep + 'py')) - from areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation import areallylongpackageandmodulenametotestreprtruncation - eq(repr(areallylongpackageandmodulenametotestreprtruncation), - "<module '%s' from '%s'>" % (areallylongpackageandmodulenametotestreprtruncation.__name__, areallylongpackageandmodulenametotestreprtruncation.__file__)) - eq(repr(sys), "<module 'sys' (built-in)>") - - def test_type(self): - eq = self.assertEquals - touch(os.path.join(self.subpkgname, 'foo'+os.extsep+'py'), '''\ -class foo(object): - pass -''') - from areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation import foo - eq(repr(foo.foo), - "<class '%s.foo'>" % foo.__name__) - - def test_object(self): - # XXX Test the repr of a type with a really long tp_name but with no - # tp_repr. WIBNI we had ::Inline? :) - pass - - def test_class(self): - touch(os.path.join(self.subpkgname, 'bar'+os.extsep+'py'), '''\ -class bar: - pass -''') - from areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation import bar - # Module name may be prefixed with "test.", depending on how run. - self.failUnless(repr(bar.bar).startswith( - "<class %s.bar at 0x" % bar.__name__)) - - def test_instance(self): - touch(os.path.join(self.subpkgname, 'baz'+os.extsep+'py'), '''\ -class baz: - pass -''') - from areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation import baz - ibaz = baz.baz() - self.failUnless(repr(ibaz).startswith( - "<%s.baz instance at 0x" % baz.__name__)) - - def test_method(self): - eq = self.assertEquals - touch(os.path.join(self.subpkgname, 'qux'+os.extsep+'py'), '''\ -class aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: - def amethod(self): pass -''') - from areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation import qux - # Unbound methods first - eq(repr(qux.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.amethod), - '<unbound method aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.amethod>') - # Bound method next - iqux = qux.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa() - self.failUnless(repr(iqux.amethod).startswith( - '<bound method aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.amethod of <%s.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa instance at 0x' \ - % (qux.__name__,) )) - - def test_builtin_function(self): - # XXX test built-in functions and methods with really long names - pass - -class ClassWithRepr: - def __init__(self, s): - self.s = s - def __repr__(self): - return "ClassWithLongRepr(%r)" % self.s - - -class ClassWithFailingRepr: - def __repr__(self): - raise Exception("This should be caught by Repr.repr_instance") - - -def test_main(): - run_unittest(ReprTests) - if os.name != 'mac': - run_unittest(LongReprTest) - - -if __name__ == "__main__": - test_main() diff --git a/Misc/NEWS b/Misc/NEWS index 9479125..ec232a6 100644 --- a/Misc/NEWS +++ b/Misc/NEWS @@ -76,9 +76,6 @@ Library ctypes.util.find_library(name) now call this function when name is 'm' or 'c'. -- The repr module has been renamed 'reprlib'. The old name is now - deprecated. - - The statvfs module has been deprecated for removal in Python 3.0. - The sunaudiodev and SUNAUDIODEV modules have been deprecated for -- cgit v0.12