rubyfox-server 2.3.0.pre2

data/lib/rubyfox/server/data/lib/Lib/test/test_re.py

@@ -0,0 +1,304 @@
+#!/usr/local/bin/python
+# -*- mode: python -*-
+# $Id: test_re.py 2294 2003-04-18 05:51:35Z kevinbutler $
+
+import sys
+sys.path=['.']+sys.path
+
+from test_support import *
+import re
+import sys, os, string #, traceback
+
+print_test('re (test_re.py)', 1)
+
+# Misc tests from Tim Peters' re.doc
+
+print_test('basic functions', 2)
+
+print_test('search', 3)
+assert re.search('x*', 'axx').span(0) == (0, 0)
+assert re.search('x*', 'axx').span() == (0, 0)
+assert re.search('x+', 'axx').span(0) == (1, 3)
+assert re.search('x+', 'axx').span() == (1, 3)
+assert re.search('x', 'aaa') == None
+
+print_test('match')
+assert re.match('a*', 'xxx').span(0) == (0, 0)
+assert re.match('a*', 'xxx').span() == (0, 0)
+assert re.match('x*', 'xxxa').span(0) == (0, 3)
+assert re.match('x*', 'xxxa').span() == (0, 3)
+assert re.match('a+', 'xxx') == None
+
+
+print_test('sub')
+assert re.sub("(?i)b+", "x", "bbbb BBBB") == 'x x'
+
+def bump_num(matchobj):
+    int_value = int(matchobj.group(0))
+    return str(int_value + 1)
+
+assert re.sub(r'\d+', bump_num, '08.2 -2 23x99y') == '9.3 -3 24x100y'
+assert re.sub(r'\d+', bump_num, '08.2 -2 23x99y', 3) == '9.3 -3 23x99y'
+
+assert re.sub('.', lambda m: r"\n", 'x') == '\\n'
+assert re.sub('.', r"\n", 'x') == '\n'
+
+s = r"\1\1"
+assert re.sub('(.)', s, 'x') == 'xx'
+assert re.sub('(.)', re.escape(s), 'x') == s
+assert re.sub('(.)', lambda m: s, 'x') == s
+
+assert re.sub('(?P<a>x)', '\g<a>\g<a>', 'xx') == 'xxxx'
+assert re.sub('(?P<a>x)', '\g<a>\g<1>', 'xx') == 'xxxx'
+assert re.sub('(?P<unk>x)', '\g<unk>\g<unk>', 'xx') == 'xxxx'
+assert re.sub('(?P<unk>x)', '\g<1>\g<1>', 'xx') == 'xxxx'
+
+assert re.sub('a', r'\t\n\v\r\f\a\b\B\Z\a\A\w\W\s\S\d\D', 'a') == '\t\n\v\r\f\a\b\\B\\Z\a\\A\\w\\W\\s\\S\\d\\D'
+assert re.sub('a', '\t\n\v\r\f\a', 'a') == '\t\n\v\r\f\a'
+assert re.sub('a', '\t\n\v\r\f\a', 'a') == (chr(9)+chr(10)+chr(11)+chr(13)+chr(12)+chr(7))
+
+assert re.sub('^\s*', 'X', 'test') == 'Xtest'
+
+assert re.sub('a', 'b', 'aaaaa') == 'bbbbb'
+assert re.sub('a', 'b', 'aaaaa', 1) == 'baaaa'
+
+
+print_test('symbolic references', 4)
+
+try:
+    re.sub('(?P<a>x)', '\g<a', 'xx')
+except re.error, reason:
+    pass
+else:
+    raise TestFailed, "symbolic reference"
+
+try:
+    re.sub('(?P<a>x)', '\g<', 'xx')
+except re.error, reason:
+    pass
+else:
+    raise TestFailed, "symbolic reference"
+
+try:
+    re.sub('(?P<a>x)', '\g', 'xx')
+except re.error, reason:
+    pass
+else:
+    raise TestFailed, "symbolic reference"
+
+try:
+    re.sub('(?P<a>x)', '\g<a a>', 'xx')
+except re.error, reason:
+    pass
+else:
+    raise TestFailed, "symbolic reference"
+
+try:
+    re.sub('(?P<a>x)', '\g<1a1>', 'xx')
+except re.error, reason:
+    pass
+else:
+    raise TestFailed, "symbolic reference"
+
+try:
+    re.sub('(?P<a>x)', '\g<ab>', 'xx')
+except (IndexError, re.error), reason:
+    pass
+else:
+    raise TestFailed, "symbolic reference"
+
+try:
+    re.sub('(?P<a>x)|(?P<b>y)', '\g<b>', 'xx')
+except re.error, reason:
+    pass
+else:
+    raise TestFailed, "symbolic reference"
+
+try:
+    re.sub('(?P<a>x)|(?P<b>y)', '\\2', 'xx')
+except re.error, reason:
+    pass
+else:
+    raise TestFailed, "symbolic reference"
+
+
+print_test('subn', 3)
+
+assert re.subn("(?i)b+", "x", "bbbb BBBB") == ('x x', 2)
+assert re.subn("b+", "x", "bbbb BBBB") == ('x BBBB', 1)
+assert re.subn("b+", "x", "xyz") == ('xyz', 0)
+assert re.subn("b*", "x", "xyz") == ('xxxyxzx', 4)
+assert re.subn("b*", "x", "xyz", 2) == ('xxxyz', 2)
+
+print_test('split')
+
+assert re.split(":", ":a:b::c") == ['', 'a', 'b', '', 'c']
+assert re.split(":*", ":a:b::c") == ['', 'a', 'b', 'c']
+assert re.split("(:*)", ":a:b::c") == ['', ':', 'a', ':', 'b', '::', 'c']
+assert re.split("(?::*)", ":a:b::c") == ['', 'a', 'b', 'c']
+assert re.split("(:)*", ":a:b::c") == ['', ':', 'a', ':', 'b', ':', 'c']
+assert re.split("([b:]+)", ":a:b::c") == ['', ':', 'a', ':b::', 'c']
+assert re.split("(b)|(:+)", ":a:b::c") == \
+       ['', None, ':', 'a', None, ':', '', 'b', None, '', None, '::', 'c']
+assert re.split("(?:b)|(?::+)", ":a:b::c") == ['', 'a', '', '', 'c']
+    
+assert re.split(":", ":a:b::c", 2) == ['', 'a', 'b::c']
+assert re.split(':', 'a:b:c:d', 2) == ['a', 'b', 'c:d']
+
+assert re.split("(:)", ":a:b::c", 2) == ['', ':', 'a', ':', 'b::c']
+assert re.split("(:*)", ":a:b::c", 2) == ['', ':', 'a', ':', 'b::c']
+
+print_test('match.groups', 2)
+
+
+# No groups at all
+m = re.match('a', 'a') ; assert m.groups() == ()
+# A single group
+m = re.match('(a)', 'a') ; assert m.groups() == ('a',)
+
+pat = re.compile('((a)|(b))(c)?')
+assert pat.match('a').groups() == ('a', 'a', None, None)
+assert pat.match('b').groups() == ('b', None, 'b', None)
+assert pat.match('ac').groups() == ('a', 'a', None, 'c')
+assert pat.match('bc').groups() == ('b', None, 'b', 'c')
+
+
+
+print_test('match.group', 2)
+
+# A single group
+m = re.match('(a)', 'a')
+assert m.group(0) == 'a' ; assert m.group(0) == 'a'
+assert m.group(1) == 'a' ; assert m.group(1, 1) == ('a', 'a')
+
+pat = re.compile('(?:(?P<a1>a)|(?P<b2>b))(?P<c3>c)?')
+assert pat.match('a').group(1, 2, 3) == ('a', None, None)
+assert pat.match('b').group('a1', 'b2', 'c3') == (None, 'b', None)
+assert pat.match('ac').group(1, 'b2', 3) == ('a', None, 'c')
+
+print_test('escape', 2)
+
+p=""
+for i in range(0, 256):
+    p = p + chr(i)
+    assert re.match(re.escape(chr(i)), chr(i)) != None
+    assert re.match(re.escape(chr(i)), chr(i)).span() == (0,1)
+
+pat=re.compile( re.escape(p) )
+assert pat.match(p) != None
+assert pat.match(p).span() == (0,256)
+
+
+#if verbose:
+#    print 'Pickling a RegexObject instance'
+
+#import pickle
+#pat = re.compile('a(?:b|(c|e){1,2}?|d)+?(.)')
+#s = pickle.dumps(pat)
+#pat = pickle.loads(s)
+
+print_test('flags', 2)
+
+assert re.I == re.IGNORECASE
+assert re.L == re.LOCALE
+assert re.M == re.MULTILINE
+assert re.S == re.DOTALL
+assert re.X == re.VERBOSE
+
+for flags in [re.I, re.M, re.X, re.S, re.L]:
+    r = re.compile('^pattern$', flags)
+
+from re_tests import *
+
+print_test("symbolic groups in regex's", 2)
+print_test("perl5-compatible regex's", 2)
+
+for t in tests:
+    sys.stdout.flush()
+    pattern=s=outcome=repl=expected=None
+    if len(t)==5:
+        pattern, s, outcome, repl, expected = t
+    elif len(t)==3:
+        pattern, s, outcome = t
+    else:
+        raise ValueError, ('Test tuples should have 3 or 5 fields',t)
+
+    try:
+        obj=re.compile(pattern)
+    except re.error:
+        if outcome==SYNTAX_ERROR: pass  # Expected a syntax error
+        else:
+            print '=== Syntax error:', t
+    except KeyboardInterrupt: raise KeyboardInterrupt
+    except:
+        print '*** Unexpected error ***', t
+        #if verbose:
+        #    traceback.print_exc(file=sys.stdout)
+    else:
+        try:
+            result=obj.search(s)
+        except (re.error), msg:
+            print '=== Unexpected exception', t, repr(msg)
+        if outcome==SYNTAX_ERROR:
+            # This should have been a syntax error; forget it.
+            pass
+        elif outcome==FAIL:
+            if result is None: pass   # No match, as expected
+            else: print '=== Succeeded incorrectly', t
+        elif outcome==SUCCEED:
+            if result is not None:
+                # Matched, as expected, so now we compute the
+                # result string and compare it to our expected result.
+                start, end = result.span(0)
+                vardict={'found': result.group(0),
+                         'groups': result.group(),
+                         'flags': result.re.flags}
+                for i in range(1, 100):
+                    try:
+                        gi = result.group(i)
+                        # Special hack because else the string concat fails:
+                        if gi is None:
+                            gi = "None"
+                    except IndexError:
+                        gi = "Error"
+                    vardict['g%d' % i] = gi
+                for i in result.re.groupindex.keys():
+                    try:
+                        gi = result.group(i)
+                        if gi is None:
+                            gi = "None"
+                    except IndexError:
+                        gi = "Error"
+                    vardict[i] = gi
+                repl=eval(repl, vardict)
+                if repl!=expected:
+                    print '=== grouping error', t,
+                    print repr(repl)+' should be '+repr(expected)
+            else:
+                print '=== Failed incorrectly', t
+                continue
+
+            # Try the match with the search area limited to the extent
+            # of the match and see if it still succeeds.  \B will
+            # break (because it won't match at the end or start of a
+            # string), so we'll ignore patterns that feature it.
+
+            if pattern[:2]!='\\B' and pattern[-2:]!='\\B':
+                obj=re.compile(pattern)
+                result=obj.search(s, result.start(0), result.end(0)+1)
+                if result==None:
+                    print '=== Failed on range-limited match', t
+
+            # Try the match with IGNORECASE enabled, and check that it
+            # still succeeds.
+            obj=re.compile(pattern, re.IGNORECASE)
+            result=obj.search(s)
+            if result==None:
+                print '=== Fails on case-insensitive match', t
+
+            # Try the match with LOCALE enabled, and check that it
+            # still succeeds.
+            obj=re.compile(pattern, re.LOCALE)
+            result=obj.search(s)
+            if result==None:
+                print '=== Fails on locale-sensitive match', t

data/lib/rubyfox/server/data/lib/Lib/test/test_regex.py

@@ -0,0 +1,113 @@
+from test_support import verbose, sortdict
+import warnings
+warnings.filterwarnings("ignore", "the regex module is deprecated",
+                        DeprecationWarning, __name__)
+import regex
+from regex_syntax import *
+
+re = 'a+b+c+'
+print 'no match:', regex.match(re, 'hello aaaabcccc world')
+print 'successful search:', regex.search(re, 'hello aaaabcccc world')
+try:
+    cre = regex.compile('\(' + re)
+except regex.error:
+    print 'caught expected exception'
+else:
+    print 'expected regex.error not raised'
+
+print 'failed awk syntax:', regex.search('(a+)|(b+)', 'cdb')
+prev = regex.set_syntax(RE_SYNTAX_AWK)
+print 'successful awk syntax:', regex.search('(a+)|(b+)', 'cdb')
+regex.set_syntax(prev)
+print 'failed awk syntax:', regex.search('(a+)|(b+)', 'cdb')
+
+re = '\(<one>[0-9]+\) *\(<two>[0-9]+\)'
+print 'matching with group names and compile()'
+cre = regex.compile(re)
+print cre.match('801 999')
+try:
+    print cre.group('one')
+except regex.error:
+    print 'caught expected exception'
+else:
+    print 'expected regex.error not raised'
+
+print 'matching with group names and symcomp()'
+cre = regex.symcomp(re)
+print cre.match('801 999')
+print cre.group(0)
+print cre.group('one')
+print cre.group(1, 2)
+print cre.group('one', 'two')
+print 'realpat:', cre.realpat
+print 'groupindex:', sortdict(cre.groupindex)
+
+re = 'world'
+cre = regex.compile(re)
+print 'not case folded search:', cre.search('HELLO WORLD')
+cre = regex.compile(re, regex.casefold)
+print 'case folded search:', cre.search('HELLO WORLD')
+
+print '__members__:', cre.__members__
+print 'regs:', cre.regs
+print 'last:', cre.last
+print 'translate:', len(cre.translate)
+print 'givenpat:', cre.givenpat
+
+print 'match with pos:', cre.match('hello world', 7)
+print 'search with pos:', cre.search('hello world there world', 7)
+print 'bogus group:', cre.group(0, 1, 3)
+try:
+    print 'no name:', cre.group('one')
+except regex.error:
+    print 'caught expected exception'
+else:
+    print 'expected regex.error not raised'
+
+from regex_tests import *
+if verbose: print 'Running regex_tests test suite'
+
+for t in tests:
+    pattern=s=outcome=repl=expected=None
+    if len(t)==5:
+        pattern, s, outcome, repl, expected = t
+    elif len(t)==3:
+        pattern, s, outcome = t
+    else:
+        raise ValueError, ('Test tuples should have 3 or 5 fields',t)
+
+    try:
+        obj=regex.compile(pattern)
+    except regex.error:
+        if outcome==SYNTAX_ERROR: pass    # Expected a syntax error
+        else:
+            # Regex syntax errors aren't yet reported, so for
+            # the official test suite they'll be quietly ignored.
+            pass
+            #print '=== Syntax error:', t
+    else:
+        try:
+            result=obj.search(s)
+        except regex.error, msg:
+            print '=== Unexpected exception', t, repr(msg)
+        if outcome==SYNTAX_ERROR:
+            # This should have been a syntax error; forget it.
+            pass
+        elif outcome==FAIL:
+            if result==-1: pass   # No match, as expected
+            else: print '=== Succeeded incorrectly', t
+        elif outcome==SUCCEED:
+            if result!=-1:
+                # Matched, as expected, so now we compute the
+                # result string and compare it to our expected result.
+                start, end = obj.regs[0]
+                found=s[start:end]
+                groups=obj.group(1,2,3,4,5,6,7,8,9,10)
+                vardict=vars()
+                for i in range(len(groups)):
+                    vardict['g'+str(i+1)]=str(groups[i])
+                repl=eval(repl)
+                if repl!=expected:
+                    print '=== grouping error', t, repr(repl)+' should be '+repr(expected)
+            else:
+                print '=== Failed incorrectly', t

data/lib/rubyfox/server/data/lib/Lib/test/test_repr.py

@@ -0,0 +1,278 @@
+"""
+  Test cases for the repr module
+  Nick Mathewson
+"""
+
+import sys
+import os
+import unittest
+
+from test_support import run_unittest
+from repr import repr as r # Don't shadow builtin 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 = `s`[:13] + "..." + `s`[-14:]
+        eq(r(s), expected)
+
+        eq(r("\"'"), repr("\"'"))
+        s = "\""*30+"'"*100
+        expected = `s`[:13] + "..." + `s`[-14:]
+        eq(r(s), expected)
+
+    def test_container(self):
+        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, ...]")
+
+        # 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, ...}")
+
+    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 = `n`[:18] + "..." + `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 = `i2`[:13] + "..." + `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'" % unittest.__file__))
+        fp.close()
+        self.failUnless(repr(fp).startswith(
+            "<closed file '%s', mode 'r'" % 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'))
+
+    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)')
+        #commented out for jython since this is deprecated.
+        # Turn off warnings for deprecated multiplication
+        #import warnings
+        #warnings.filterwarnings('ignore', category=DeprecationWarning,
+        #                        module=ReprTests.__module__)
+        #eq(repr(xrange(1) * 3), '(xrange(1) * 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([[[[[[[{}]]]]]]]), "[[[[[[[...]]]]]]]")
+
+    #XXX: no buffer in jython.
+    #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'))
+
+    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'))
+        x = classmethod(C.foo)
+        self.failUnless(repr(x).startswith('<classmethod object'))
+
+def touch(path, text=''):
+    fp = open(path, 'w')
+    fp.write(text)
+    fp.close()
+
+def zap(actions, dirname, names):
+    for name in names:
+        actions.append(os.path.join(dirname, name))
+
+#
+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
+        os.mkdir(self.pkgname)
+        touch(os.path.join(self.pkgname, '__init__'+os.extsep+'py'))
+        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 = []
+        os.path.walk(self.pkgname, zap, actions)
+        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 'areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation' from '%s'>" % areallylongpackageandmodulenametotestreprtruncation.__file__)
+
+    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 'areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation.foo.foo'>")
+
+    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
+        self.failUnless(repr(bar.bar).startswith(
+            "<class areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation.bar.bar"))
+
+    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(
+            "<areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation.baz.baz instance"))
+
+    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 <areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation.qux.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa instance'))
+
+    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' and not os.name.startswith('java'):
+        run_unittest(LongReprTest)
+
+
+if __name__ == "__main__":
+    test_main()