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