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 statement(self):

->     return self.code.fullsource.getstatement(self.lineno)

   def getstatement(self, lineno):

       """ return Source statement which contains the

               given linenumber (counted from 0).

           """

->     start, end = self.getstatementrange(lineno)

       return self[start:end]

   def getstatementrange(self, lineno):

       """ return (start, end) tuple which spans the minimal 

               statement region which containing the given lineno.

           """

       # XXX there must be a better than these heuristic ways ...

       # XXX there may even be better heuristics :-)

       if not (0 <= lineno < len(self)):

           raise IndexError("lineno out of range")

       # 1. find the start of the statement

       from codeop import compile_command

       for start in range(lineno, -1, -1):

           trylines = self.lines[start:lineno+1]

           # quick hack to indent the source and get it as a string in one go

           trylines.insert(0, 'def xxx():')

           trysource = '\n '.join(trylines)

           #              ^ space here

           try:

               compile_command(trysource)

           except (SyntaxError, OverflowError, ValueError):

               pass

           else:

               break   # got a valid or incomplete statement

       # 2. find the end of the statement

       for end in range(lineno+1, len(self)+1):

           trysource = self[start:end]

->         if trysource.isparseable():

               break

       return start, end