def test_assert_reinterpret(self):

       if not hasattr(py.std.os, 'fork'):

           py.test.skip('operating system not supported')

       tmpdir = tmp

       tmpdir.ensure("sub6", "__init__.py")

       tmpdir.ensure("sub6", "test_some.py").write(py.code.Source("""

           def test_one():

               x = [1, 2]

               assert [0] == x

           """))

       args = [str(tmpdir.join("sub6"))]

->     config = py.test.config._reparse(args)

       lsession = LSession(config)

       allevents = []

       lsession.main(reporter=allevents.append, runner=box_runner)

       testevents = [x for x in allevents 

                       if isinstance(x, repevent.ReceivedItemOutcome)]

       failevents = [i for i in testevents if i.outcome.excinfo]

       assert len(failevents) == 1

       assert len(testevents) == 1

       assert failevents[0].outcome.excinfo.value == 'assert [0] == [1, 2]'

   def _reparse(self, args):

       """ this is used from tests that want to re-invoke parse(). """

       #assert args # XXX should not be empty

       global config_per_process

       oldconfig = py.test.config

       try:

->         config_per_process = py.test.config = Config()

           config_per_process.parse(args) 

           return config_per_process

       finally: 

           config_per_process = py.test.config = oldconfig 

   def __init__(self): 

       self.option = CmdOptions()

       self._parser = optparse.OptionParser(

->         usage="usage: %prog [options] [query] [filenames of tests]")

       self._conftest = Conftest()

       self._initialized = False

   def __init__(self,

                usage=None,

                option_list=None,

                option_class=Option,

                version=None,

                conflict_handler="error",

                description=None,

                formatter=None,

                add_help_option=True,

                prog=None):

       OptionContainer.__init__(

           self, option_class, conflict_handler, description)

       self.set_usage(usage)

       self.prog = prog

       self.version = version

       self.allow_interspersed_args = True

       self.process_default_values = True

       if formatter is None:

->         formatter = IndentedHelpFormatter()

       self.formatter = formatter

       self.formatter.set_parser(self)

       # Populate the option list; initial sources are the

       # standard_option_list class attribute, the 'option_list'

       # argument, and (if applicable) the _add_version_option() and

       # _add_help_option() methods.

       self._populate_option_list(option_list,

                                  add_help=add_help_option)

       self._init_parsing_state()