def test_compile_and_getsource(self):

       co = self.source.compile()

       exec co

       f(7)

->     excinfo = py.test.raises(AssertionError, "f(6)")

       frame = excinfo.traceback[-1].frame 

       stmt = frame.code.fullsource.getstatement(frame.lineno)

       #print "block", str(block)

       assert str(stmt).strip().startswith('assert')

   def raises(ExpectedException, *args, **kwargs):

       """ raise AssertionError, if target code does not raise the expected

           exception.

       """

       assert args

       __tracebackhide__ = True 

       if isinstance(args[0], str):

           expr, = args

           assert isinstance(expr, str)

           frame = sys._getframe(1)

           loc = frame.f_locals.copy()

           loc.update(kwargs)

           #print "raises frame scope: %r" % frame.f_locals

           source = py.code.Source(expr)

           try:

->             exec source.compile() in frame.f_globals, loc

               #del __traceback__

               # XXX didn'T mean f_globals == f_locals something special?

               #     this is destroyed here ...

           except ExpectedException:

               return py.code.ExceptionInfo()

       else:

           func = args[0]

           assert callable

           try:

               func(*args[1:], **kwargs)

               #del __traceback__

           except ExpectedException:

               return py.code.ExceptionInfo()

           k = ", ".join(["%s=%r" % x for x in kwargs.items()])

           if k:

               k = ', ' + k

           expr = '%s(%r%s)' %(func.__name__, args, k)

       raise ExceptionFailure(msg="DID NOT RAISE", 

                              expr=args, expected=ExpectedException) 

-> f(6)

   def f(x):

       assert (x ==

               3 +

->             4)

   def __init__(self, *args):

       BuiltinAssertionError.__init__(self, *args)

       if args: 

           self.msg = str(args[0])

       else: 

           f = sys._getframe(1)

           try:

               source = py.code.Frame(f).statement

               source = str(source.deindent()).strip()

           except py.error.ENOENT:

               source = None

               # this can also occur during reinterpretation, when the

               # co_filename is set to "<run>".

           if source:

->             self.msg = exprinfo.interpret(source, f, should_fail=True)

               if not self.args:

                   self.args = (self.msg,)

           else:

               self.msg = None

   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):

       test = Interpretable(self.test)

->     test.eval(frame)

       # simplify 'assert False where False = ...'

       if (test.explanation.startswith('False\n{False = ') and

           test.explanation.endswith('\n}')):

           test.explanation = test.explanation[15:-2]

       # print the result as  'assert <explanation>'

       self.result = test.result

       self.explanation = 'assert ' + test.explanation

       if not frame.is_true(test.result):

           try:

               raise BuiltinAssertionError

           except passthroughex:

               raise

           except:

               raise Failure(self)

   def eval(self, frame):

       expr = Interpretable(self.expr)

       expr.eval(frame)

       for operation, expr2 in self.ops:

           expr2 = Interpretable(expr2)

->         expr2.eval(frame)

           self.explanation = "%s %s %s" % (

               expr.explanation, operation, expr2.explanation)

           co = compile("__exprinfo_left %s __exprinfo_right" % operation,

                        '?', 'eval')

           try:

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

                                            __exprinfo_right=expr2.result)

           except passthroughex:

               raise

           except:

               raise Failure(self)

           if not frame.is_true(self.result):

               break

           expr = expr2

   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)