def test_failure_demo_fails_properly(): 

       config = py.test.config._reparse([failure_demo]) 

       session = config.initsession()

->     session.main()

       l = session.getitemoutcomepairs(Failed)

       assert len(l) == 21 

       l = session.getitemoutcomepairs(Passed)

       assert not l 

   def main(self): 

       """ main loop for running tests. """

       colitems = self.config.getcolitems()

       try:

           self.header(colitems) 

           try:

               try:

                   for colitem in colitems: 

->                     self.runtraced(colitem)

               except KeyboardInterrupt: 

                   raise 

           finally: 

               self.footer(colitems) 

       except Exit, ex:

           pass

       return self.getitemoutcomepairs(Failed)

   def runtraced(self, colitem):

       if self.shouldclose(): 

           raise Exit, "received external close signal" 

       outcome = None 

       colitem.startcapture() 

       try: 

           self.start(colitem)

           try: 

               try:

                   if colitem._stickyfailure: 

                       raise colitem._stickyfailure 

->                 outcome = self.run(colitem) 

               except (KeyboardInterrupt, Exit): 

                   raise 

               except Outcome, outcome: 

                   if outcome.excinfo is None: 

                       outcome.excinfo = py.code.ExceptionInfo() 

               except: 

                   excinfo = py.code.ExceptionInfo() 

                   outcome = Failed(excinfo=excinfo) 

               assert (outcome is None or 

                       isinstance(outcome, (list, Outcome)))

           finally: 

               self.finish(colitem, outcome) 

           if isinstance(outcome, Failed) and self.config.option.exitfirst:

               py.test.exit("exit on first problem configured.", item=colitem)

       finally: 

           colitem.finishcapture()

   def run(self, colitem): 

       if self.config.option.collectonly and isinstance(colitem, py.test.collect.Item): 

           return 

       if isinstance(colitem, py.test.collect.Item): 

           colitem._skipbykeyword(self.config.option.keyword)

       res = colitem.run() 

       if res is None: 

           return Passed() 

       elif not isinstance(res, (list, tuple)): 

           raise TypeError("%r.run() returned neither "

                           "list, tuple nor None: %r" % (colitem, res))

       else: 

           finish = self.startiteration(colitem, res)

           try: 

               for name in res: 

                   obj = colitem.join(name) 

                   assert obj is not None 

->                 self.runtraced(obj) 

           finally: 

               if finish: 

                   finish() 

       return res 

   def runtraced(self, colitem):

       if self.shouldclose(): 

           raise Exit, "received external close signal" 

       outcome = None 

       colitem.startcapture() 

       try: 

           self.start(colitem)

           try: 

               try:

                   if colitem._stickyfailure: 

                       raise colitem._stickyfailure 

->                 outcome = self.run(colitem) 

               except (KeyboardInterrupt, Exit): 

                   raise 

               except Outcome, outcome: 

                   if outcome.excinfo is None: 

                       outcome.excinfo = py.code.ExceptionInfo() 

               except: 

                   excinfo = py.code.ExceptionInfo() 

                   outcome = Failed(excinfo=excinfo) 

               assert (outcome is None or 

                       isinstance(outcome, (list, Outcome)))

           finally: 

               self.finish(colitem, outcome) 

           if isinstance(outcome, Failed) and self.config.option.exitfirst:

               py.test.exit("exit on first problem configured.", item=colitem)

       finally: 

           colitem.finishcapture()

   def run(self, colitem): 

       if self.config.option.collectonly and isinstance(colitem, py.test.collect.Item): 

           return 

       if isinstance(colitem, py.test.collect.Item): 

           colitem._skipbykeyword(self.config.option.keyword)

->     res = colitem.run() 

       if res is None: 

           return Passed() 

       elif not isinstance(res, (list, tuple)): 

           raise TypeError("%r.run() returned neither "

                           "list, tuple nor None: %r" % (colitem, res))

       else: 

           finish = self.startiteration(colitem, res)

           try: 

               for name in res: 

                   obj = colitem.join(name) 

                   assert obj is not None 

                   self.runtraced(obj) 

           finally: 

               if finish: 

                   finish() 

       return res 

   def run(self):

       """ setup and execute the underlying test function. """

       self._state.prepare(self) 

->     self.execute(self.obj, *self._args)

   def execute(self, target, *args):

       """ execute the given test function. """

->     target(*args)

   def test_dynamic_compile_shows_nicely():

       src = 'def foo():\n assert 1 == 0\n'

       name = 'abc-123'

       module = py.std.imp.new_module(name)

->     code = py.code.compile(src, name, 'exec')

       exec code in module.__dict__

       py.std.sys.modules[name] = module

       module.foo()

   def compile_(source, filename=None, mode='exec', flags=

               generators.compiler_flag, dont_inherit=0):

       """ compile the given source to a raw code object,

           which points back to the source code through

           "co_filename.__source__".  All code objects

           contained in the code object will recursively

           also have this special subclass-of-string

           filename.

       """

       s = Source(source)

->     co = s.compile(filename, mode, flags)

       return co

   def compile(self, filename=None, mode='exec',

               flag=generators.compiler_flag, dont_inherit=0):

       """ return compiled code object. if filename is None

               invent an artificial filename which displays

               the source/line position of the caller frame.

           """

       if not filename or py.path.local(filename).check(file=0): 

           frame = sys._getframe(1) # the caller

           filename = '%s<%s:%d>' % (filename, frame.f_code.co_filename,

                                     frame.f_lineno)

       source = "\n".join(self.lines) + '\n'

       try:

           co = cpy_compile(source, filename, mode, flag)

       except SyntaxError, ex:

           # re-represent syntax errors from parsing python strings

           msglines = self.lines[:ex.lineno]

           if ex.offset:

               msglines.append(" "*ex.offset + '^')

           msglines.append("syntax error probably generated here: %s" % filename)

           newex = SyntaxError('\n'.join(msglines))

           newex.offset = ex.offset

           newex.lineno = ex.lineno

           newex.text = ex.text

           raise newex

       else:

           co_filename = MyStr(filename)

           co_filename.__source__ = self

->         return py.code.Code(co).new(rec=1, co_filename=co_filename) 

   def new(self, rec=False, **kwargs): 

       """ return new code object with modified attributes. 

               if rec-cursive is true then dive into code 

               objects contained in co_consts. 

           """ 

       names = [x for x in dir(self.raw) if x[:3] == 'co_']

       for name in kwargs: 

           if name not in names: 

               raise TypeError("unknown code attribute: %r" %(name, ))

       if rec: 

           newconstlist = []

           co = self.raw

           cotype = type(co)

           for c in co.co_consts:

               if isinstance(c, cotype):

->                 c = self.__class__(c).new(rec=True, **kwargs) 

               newconstlist.append(c)

           return self.new(rec=False, co_consts=tuple(newconstlist), **kwargs) 

       for name in names:

           if name not in kwargs:

               kwargs[name] = getattr(self.raw, name)

       return py.std.new.code(

                kwargs['co_argcount'],

                kwargs['co_nlocals'],

                kwargs['co_stacksize'],

                kwargs['co_flags'],

                kwargs['co_code'],

                kwargs['co_consts'],

                kwargs['co_names'],

                kwargs['co_varnames'],

                kwargs['co_filename'],

                kwargs['co_name'],

                kwargs['co_firstlineno'],

                kwargs['co_lnotab'],

                kwargs['co_freevars'],

                kwargs['co_cellvars'],

       )