def test_keyboard_interrupt():

       # XXX this test is slightly strange because it is not

       # clear that "interpret" should execute "raise" statements

       # ... but it apparently currently does and it's nice to

       # exercise the code because the exprinfo-machinery is

       # not much executed when all tests pass ...

       class DummyCode:

           co_filename = 'dummy'

           co_firstlineno = 0

           co_name = 'dummy'

       class DummyFrame:

           f_globals = f_locals = {}

           f_code = DummyCode

           f_lineno = 0

       for exstr in "SystemExit", "KeyboardInterrupt", "MemoryError":

           ex = eval(exstr)

           try:

->             interpret("raise %s" % exstr, py.code.Frame(DummyFrame))

           except ex:

               pass

           else:

               raise AssertionError, "ex %s didn't pass through" %(exstr, )

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

       # fall-back for unknown statement nodes

       try:

           expr = ast.Module(None, ast.Stmt([self.__obj__]))

           expr.filename = '<run>'

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

->         frame.exec_(co)

       except passthroughex:

           raise

       except:

           raise Failure(self)