def test_tbentry_reinterpret(): 

       try: 

           hello("hello") 

       except TypeError: 

           excinfo = py.code.ExceptionInfo() 

       tbentry = excinfo.traceback[-1]

->     msg = tbentry.reinterpret() 

       assert msg.startswith("TypeError: ('hello' + 5)") 

   def reinterpret(self):

       """Reinterpret the failing statement and returns a detailed information

              about what operations are performed."""

       if self.exprinfo is None:

           from py.__.magic import exprinfo

           source = str(self.statement).strip()

->         x = exprinfo.interpret(source, self.frame, should_fail=True)

           if not isinstance(x, str):

               raise TypeError, "interpret returned non-string %r" % (x,)

           self.exprinfo = x 

       return self.exprinfo

   def interpret(source, frame, should_fail=False):

       module = Interpretable(parse(source, 'exec').node)

       #print "got module", module

       if isinstance(frame, py.std.types.FrameType):

           frame = py.code.Frame(frame)

       try:

->         module.run(frame)

       except Failure, e:

           return getfailure(e)

       except passthroughex:

           raise

       except:

           import traceback

           traceback.print_exc()

       if should_fail:

           return "(inconsistently failed then succeeded)"

       else:

           return None

   def run(self, frame):

       for stmt in self.nodes:

           stmt = Interpretable(stmt)

->         stmt.run(frame)

   def run(self, frame):

       expr = Interpretable(self.expr)

->     expr.eval(frame)

       self.result = expr.result

       self.explanation = expr.explanation

   def eval(self, frame, astpattern=astpattern,

                         co=compile(astpattern, '?', 'eval')):

       left = Interpretable(self.left)

       left.eval(frame)

       right = Interpretable(self.right)

->     right.eval(frame)

       self.explanation = (astpattern

                           .replace('__exprinfo_left',  left .explanation)

                           .replace('__exprinfo_right', right.explanation))

       try:

           self.result = frame.eval(co, __exprinfo_left=left.result,

                                        __exprinfo_right=right.result)

       except passthroughex:

           raise

       except:

           raise Failure(self)

   def eval(self, frame):

       # fall-back for unknown expression nodes

       try:

           expr = ast.Expression(self.__obj__)

           expr.filename = '<eval>'

           self.__obj__.filename = '<eval>'

           co = pycodegen.ExpressionCodeGenerator(expr).getCode()

           result = frame.eval(co)

       except passthroughex:

           raise

       except:

           raise Failure(self)

       self.result = result

->     self.explanation = self.explanation or frame.repr(self.result)