def check_implied_option(opts, expr):

->     config = py.test.config._reparse(opts + [datadir/'filetest.py'])

       session = config.initsession()

       assert eval(expr, session.config.option.__dict__)

   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 parse(self, args): 

       """ parse cmdline arguments into this config object. 

               Note that this can only be called once per testing process. 

           """ 

       assert not self._initialized, (

               "can only parse cmdline args once per Config object")

       self._initialized = True

       adddefaultoptions(self)

       self._conftest.setinitial(args) 

       args = [str(x) for x in args]

->     cmdlineoption, args = self._parser.parse_args(args) 

       self.option.__dict__.update(vars(cmdlineoption))

       if not args:

           args.append(py.std.os.getcwd())

       self.topdir = gettopdir(args)

       self.args = args 

   def parse_args(self, args=None, values=None):

       """

           parse_args(args : [string] = sys.argv[1:],

                      values : Values = None)

           -> (values : Values, args : [string])

           Parse the command-line options found in 'args' (default:

           sys.argv[1:]).  Any errors result in a call to 'error()', which

           by default prints the usage message to stderr and calls

           sys.exit() with an error message.  On success returns a pair

           (values, args) where 'values' is an Values instance (with all

           your option values) and 'args' is the list of arguments left

           over after parsing options.

           """

       rargs = self._get_args(args)

       if values is None:

           values = self.get_default_values()

       # Store the halves of the argument list as attributes for the

       # convenience of callbacks:

       #   rargs

       #     the rest of the command-line (the "r" stands for

       #     "remaining" or "right-hand")

       #   largs

       #     the leftover arguments -- ie. what's left after removing

       #     options and their arguments (the "l" stands for "leftover"

       #     or "left-hand")

       self.rargs = rargs

       self.largs = largs = []

       self.values = values

       try:

->         stop = self._process_args(largs, rargs, values)

       except (BadOptionError, OptionValueError), err:

           self.error(err.msg)

       args = largs + rargs

       return self.check_values(values, args)

   def _process_args(self, largs, rargs, values):

       """_process_args(largs : [string],

                            rargs : [string],

                            values : Values)

           Process command-line arguments and populate 'values', consuming

           options and arguments from 'rargs'.  If 'allow_interspersed_args' is

           false, stop at the first non-option argument.  If true, accumulate any

           interspersed non-option arguments in 'largs'.

           """

       while rargs:

           arg = rargs[0]

           # We handle bare "--" explicitly, and bare "-" is handled by the

           # standard arg handler since the short arg case ensures that the

           # len of the opt string is greater than 1.

           if arg == "--":

               del rargs[0]

               return

           elif arg[0:2] == "--":

               # process a single long option (possibly with value(s))

               self._process_long_opt(rargs, values)

           elif arg[:1] == "-" and len(arg) > 1:

               # process a cluster of short options (possibly with

               # value(s) for the last one only)

->             self._process_short_opts(rargs, values)

           elif self.allow_interspersed_args:

               largs.append(arg)

               del rargs[0]

           else:

               return                  # stop now, leave this arg in rargs

   def _process_short_opts(self, rargs, values):

       arg = rargs.pop(0)

       stop = False

       i = 1

       for ch in arg[1:]:

           opt = "-" + ch

           option = self._short_opt.get(opt)

           i += 1                      # we have consumed a character

           if not option:

               self.error(_("no such option: %s") % opt)

           if option.takes_value():

               # Any characters left in arg?  Pretend they're the

               # next arg, and stop consuming characters of arg.

               if i < len(arg):

                   rargs.insert(0, arg[i:])

                   stop = True

               nargs = option.nargs

               if len(rargs) < nargs:

                   if nargs == 1:

                       self.error(_("%s option requires an argument") % opt)

                   else:

                       self.error(_("%s option requires %d arguments")

                                  % (opt, nargs))

               elif nargs == 1:

                   value = rargs.pop(0)

               else:

                   value = tuple(rargs[0:nargs])

                   del rargs[0:nargs]

           else:                       # option doesn't take a value

               value = None

->         option.process(opt, value, values, self)

           if stop:

               break

   def process(self, opt, value, values, parser):

       # First, convert the value(s) to the right type.  Howl if any

       # value(s) are bogus.

       value = self.convert_value(opt, value)

       # And then take whatever action is expected of us.

       # This is a separate method to make life easier for

       # subclasses to add new actions.

       return self.take_action(

->         self.action, self.dest, opt, value, values, parser)

   def take_action(self, action, dest, opt, value, values, parser):

       if action == "store":

           setattr(values, dest, value)

       elif action == "store_const":

           setattr(values, dest, self.const)

       elif action == "store_true":

           setattr(values, dest, True)

       elif action == "store_false":

           setattr(values, dest, False)

       elif action == "append":

           values.ensure_value(dest, []).append(value)

       elif action == "count":

->         setattr(values, dest, values.ensure_value(dest, 0) + 1)

       elif action == "callback":

           args = self.callback_args or ()

           kwargs = self.callback_kwargs or {}

           self.callback(self, opt, value, parser, *args, **kwargs)

       elif action == "help":

           parser.print_help()

           parser.exit()

       elif action == "version":

           parser.print_version()

           parser.exit()

       else:

           raise RuntimeError, "unknown action %r" % self.action

       return 1