def test_doctest_extra_exec(): 

       # XXX get rid of the next line: 

       py.magic.autopath().dirpath('conftest.py').copy(tmpdir.join('conftest.py'))

       xtxt = tmpdir.join('y.txt')

       xtxt.write(py.code.Source("""

           hello::

               .. >>> raise ValueError 

                  >>> None

       """))

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

       session = config.initsession()

->     session.main()

       l = session.getitemoutcomepairs(Failed) 

       assert len(l) == 1

   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 startiteration(self, colitem, subitems): 

       if (isinstance(colitem, py.test.collect.Module) 

           and self.config.option.verbose == 0 

           and not self.config.option.collectonly): 

           try: 

               sum = 0

               for sub in subitems:

->                 sum += len(list(colitem.join(sub)._tryiter()))

           except (SystemExit, KeyboardInterrupt): 

               raise 

           except: 

               self.out.write('[?]')

           else: 

               self.out.write('[%d] ' % sum) 

           return self.out.line 

   def join(self, name): 

       if name == self.fspath.basename: 

->         return self.ReSTSyntaxTest(name, parent=self) 

       elif name == 'checklinks': 

           return LinkCheckerMaker(name, self) 

       elif name == 'doctest': 

           return self.DoctestText(name, self)