new_contents: """
    Test cases for the repr module
    Nick Mathewson
  """
  
  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)))
  
      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([[[[[[[{}]]]]]]]), "[[[[[[[...]]]]]]]")
  
  
  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")
  
  
  run_unittest(ReprTests)
  
subject: Test for the repr module, contributed by Nick Mathewson. This closes SF patch #440826.