tools/site_compare/command_line.py

   1 #!/usr/bin/env python
   2 # Copyright (c) 2011 The Chromium Authors. All rights reserved.
   3 # Use of this source code is governed by a BSD-style license that can be
   4 # found in the LICENSE file.
   5
   6 """Parse a command line, retrieving a command and its arguments.
   7
   8 Supports the concept of command line commands, each with its own set
   9 of arguments. Supports dependent arguments and mutually exclusive arguments.
  10 Basically, a better optparse. I took heed of epg's WHINE() in gvn.cmdline
  11 and dumped optparse in favor of something better.
  12 """
  13
  14 import os.path
  15 import re
  16 import string
  17 import sys
  18 import textwrap
  19 import types
  20
  21
  22 def IsString(var):
  23   """Little helper function to see if a variable is a string."""
  24   return type(var) in types.StringTypes
  25
  26
  27 class ParseError(Exception):
  28   """Encapsulates errors from parsing, string arg is description."""
  29   pass
  30
  31
  32 class Command(object):
  33   """Implements a single command."""
  34
  35   def __init__(self, names, helptext, validator=None, impl=None):
  36     """Initializes Command from names and helptext, plus optional callables.
  37
  38     Args:
  39       names:       command name, or list of synonyms
  40       helptext:    brief string description of the command
  41       validator:   callable for custom argument validation
  42                    Should raise ParseError if it wants
  43       impl:        callable to be invoked when command is called
  44     """
  45     self.names = names
  46     self.validator = validator
  47     self.helptext = helptext
  48     self.impl = impl
  49     self.args = []
  50     self.required_groups = []
  51     self.arg_dict = {}
  52     self.positional_args = []
  53     self.cmdline = None
  54
  55   class Argument(object):
  56     """Encapsulates an argument to a command."""
  57     VALID_TYPES = ['string', 'readfile', 'int', 'flag', 'coords']
  58     TYPES_WITH_VALUES = ['string', 'readfile', 'int', 'coords']
  59
  60     def __init__(self, names, helptext, type, metaname,
  61                  required, default, positional):
  62       """Command-line argument to a command.
  63
  64       Args:
  65         names:       argument name, or list of synonyms
  66         helptext:    brief description of the argument
  67         type:        type of the argument. Valid values include:
  68                           string - a string
  69                           readfile - a file which must exist and be available
  70                             for reading
  71                           int - an integer
  72                           flag - an optional flag (bool)
  73                           coords - (x,y) where x and y are ints
  74         metaname:    Name to display for value in help, inferred if not
  75                      specified
  76         required:    True if argument must be specified
  77         default:     Default value if not specified
  78         positional:  Argument specified by location, not name
  79
  80       Raises:
  81         ValueError: the argument name is invalid for some reason
  82       """
  83       if type not in Command.Argument.VALID_TYPES:
  84         raise ValueError("Invalid type: %r" % type)
  85
  86       if required and default is not None:
  87         raise ValueError("required and default are mutually exclusive")
  88
  89       if required and type == 'flag':
  90         raise ValueError("A required flag? Give me a break.")
  91
  92       if metaname and type not in Command.Argument.TYPES_WITH_VALUES:
  93         raise ValueError("Type %r can't have a metaname" % type)
  94
  95       # If no metaname is provided, infer it: use the alphabetical characters
  96       # of the last provided name
  97       if not metaname and type in Command.Argument.TYPES_WITH_VALUES:
  98         metaname = (
  99           names[-1].lstrip(string.punctuation + string.whitespace).upper())
 100
 101       self.names = names
 102       self.helptext = helptext
 103       self.type = type
 104       self.required = required
 105       self.default = default
 106       self.positional = positional
 107       self.metaname = metaname
 108
 109       self.mutex = []          # arguments that are mutually exclusive with
 110                                # this one
 111       self.depends = []        # arguments that must be present for this
 112                                # one to be valid
 113       self.present = False     # has this argument been specified?
 114
 115     def AddDependency(self, arg):
 116       """Makes this argument dependent on another argument.
 117
 118       Args:
 119         arg: name of the argument this one depends on
 120       """
 121       if arg not in self.depends:
 122         self.depends.append(arg)
 123
 124     def AddMutualExclusion(self, arg):
 125       """Makes this argument invalid if another is specified.
 126
 127       Args:
 128         arg: name of the mutually exclusive argument.
 129       """
 130       if arg not in self.mutex:
 131         self.mutex.append(arg)
 132
 133     def GetUsageString(self):
 134       """Returns a brief string describing the argument's usage."""
 135       if not self.positional:
 136         string = self.names[0]
 137         if self.type in Command.Argument.TYPES_WITH_VALUES:
 138           string += "="+self.metaname
 139       else:
 140         string = self.metaname
 141
 142       if not self.required:
 143         string = "["+string+"]"
 144
 145       return string
 146
 147     def GetNames(self):
 148       """Returns a string containing a list of the arg's names."""
 149       if self.positional:
 150         return self.metaname
 151       else:
 152         return ", ".join(self.names)
 153
 154     def GetHelpString(self, width=80, indent=5, names_width=20, gutter=2):
 155       """Returns a help string including help for all the arguments."""
 156       names = [" "*indent + line +" "*(names_width-len(line)) for line in
 157                textwrap.wrap(self.GetNames(), names_width)]
 158
 159       helpstring = textwrap.wrap(self.helptext, width-indent-names_width-gutter)
 160
 161       if len(names) < len(helpstring):
 162         names += [" "*(indent+names_width)]*(len(helpstring)-len(names))
 163
 164       if len(helpstring) < len(names):
 165         helpstring += [""]*(len(names)-len(helpstring))
 166
 167       return "\n".join([name_line + " "*gutter + help_line for
 168                         name_line, help_line in zip(names, helpstring)])
 169
 170     def __repr__(self):
 171       if self.present:
 172         string = '= %r' % self.value
 173       else:
 174         string = "(absent)"
 175
 176       return "Argument %s '%s'%s" % (self.type, self.names[0], string)
 177
 178     # end of nested class Argument
 179
 180   def AddArgument(self, names, helptext, type="string", metaname=None,
 181                   required=False, default=None, positional=False):
 182     """Command-line argument to a command.
 183
 184     Args:
 185       names:      argument name, or list of synonyms
 186       helptext:   brief description of the argument
 187       type:       type of the argument
 188       metaname:   Name to display for value in help, inferred if not
 189       required:   True if argument must be specified
 190       default:    Default value if not specified
 191       positional: Argument specified by location, not name
 192
 193     Raises:
 194       ValueError: the argument already exists or is invalid
 195
 196     Returns:
 197       The newly-created argument
 198     """
 199     if IsString(names): names = [names]
 200
 201     names = [name.lower() for name in names]
 202
 203     for name in names:
 204       if name in self.arg_dict:
 205         raise ValueError("%s is already an argument"%name)
 206
 207     if (positional and required and
 208         [arg for arg in self.args if arg.positional] and
 209         not [arg for arg in self.args if arg.positional][-1].required):
 210       raise ValueError(
 211         "A required positional argument may not follow an optional one.")
 212
 213     arg = Command.Argument(names, helptext, type, metaname,
 214                            required, default, positional)
 215
 216     self.args.append(arg)
 217
 218     for name in names:
 219       self.arg_dict[name] = arg
 220
 221     return arg
 222
 223   def GetArgument(self, name):
 224     """Return an argument from a name."""
 225     return self.arg_dict[name.lower()]
 226
 227   def AddMutualExclusion(self, args):
 228     """Specifies that a list of arguments are mutually exclusive."""
 229     if len(args) < 2:
 230       raise ValueError("At least two arguments must be specified.")
 231
 232     args = [arg.lower() for arg in args]
 233
 234     for index in xrange(len(args)-1):
 235       for index2 in xrange(index+1, len(args)):
 236         self.arg_dict[args[index]].AddMutualExclusion(self.arg_dict[args[index2]])
 237
 238   def AddDependency(self, dependent, depends_on):
 239     """Specifies that one argument may only be present if another is.
 240
 241     Args:
 242       dependent:  the name of the dependent argument
 243       depends_on: the name of the argument on which it depends
 244     """
 245     self.arg_dict[dependent.lower()].AddDependency(
 246       self.arg_dict[depends_on.lower()])
 247
 248   def AddMutualDependency(self, args):
 249     """Specifies that a list of arguments are all mutually dependent."""
 250     if len(args) < 2:
 251       raise ValueError("At least two arguments must be specified.")
 252
 253     args = [arg.lower() for arg in args]
 254
 255     for (arg1, arg2) in [(arg1, arg2) for arg1 in args for arg2 in args]:
 256       if arg1 == arg2: continue
 257       self.arg_dict[arg1].AddDependency(self.arg_dict[arg2])
 258
 259   def AddRequiredGroup(self, args):
 260     """Specifies that at least one of the named arguments must be present."""
 261     if len(args) < 2:
 262       raise ValueError("At least two arguments must be in a required group.")
 263
 264     args = [self.arg_dict[arg.lower()] for arg in args]
 265
 266     self.required_groups.append(args)
 267
 268   def ParseArguments(self):
 269     """Given a command line, parse and validate the arguments."""
 270
 271     # reset all the arguments before we parse
 272     for arg in self.args:
 273       arg.present = False
 274       arg.value = None
 275
 276     self.parse_errors = []
 277
 278     # look for arguments remaining on the command line
 279     while len(self.cmdline.rargs):
 280       try:
 281         self.ParseNextArgument()
 282       except ParseError, e:
 283         self.parse_errors.append(e.args[0])
 284
 285     # after all the arguments are parsed, check for problems
 286     for arg in self.args:
 287       if not arg.present and arg.required:
 288         self.parse_errors.append("'%s': required parameter was missing"
 289                                  % arg.names[0])
 290
 291       if not arg.present and arg.default:
 292         arg.present = True
 293         arg.value = arg.default
 294
 295       if arg.present:
 296         for mutex in arg.mutex:
 297           if mutex.present:
 298             self.parse_errors.append(
 299               "'%s', '%s': arguments are mutually exclusive" %
 300               (arg.argstr, mutex.argstr))
 301
 302         for depend in arg.depends:
 303           if not depend.present:
 304             self.parse_errors.append("'%s': '%s' must be specified as well" %
 305                                      (arg.argstr, depend.names[0]))
 306
 307     # check for required groups
 308     for group in self.required_groups:
 309       if not [arg for arg in group if arg.present]:
 310         self.parse_errors.append("%s: at least one must be present" %
 311                          (", ".join(["'%s'" % arg.names[-1] for arg in group])))
 312
 313     # if we have any validators, invoke them
 314     if not self.parse_errors and self.validator:
 315       try:
 316         self.validator(self)
 317       except ParseError, e:
 318         self.parse_errors.append(e.args[0])
 319
 320   # Helper methods so you can treat the command like a dict
 321   def __getitem__(self, key):
 322     arg = self.arg_dict[key.lower()]
 323
 324     if arg.type == 'flag':
 325       return arg.present
 326     else:
 327       return arg.value
 328
 329   def __iter__(self):
 330     return [arg for arg in self.args if arg.present].__iter__()
 331
 332   def ArgumentPresent(self, key):
 333     """Tests if an argument exists and has been specified."""
 334     return key.lower() in self.arg_dict and self.arg_dict[key.lower()].present
 335
 336   def __contains__(self, key):
 337     return self.ArgumentPresent(key)
 338
 339   def ParseNextArgument(self):
 340     """Find the next argument in the command line and parse it."""
 341     arg = None
 342     value = None
 343     argstr = self.cmdline.rargs.pop(0)
 344
 345     # First check: is this a literal argument?
 346     if argstr.lower() in self.arg_dict:
 347       arg = self.arg_dict[argstr.lower()]
 348       if arg.type in Command.Argument.TYPES_WITH_VALUES:
 349         if len(self.cmdline.rargs):
 350           value = self.cmdline.rargs.pop(0)
 351
 352     # Second check: is this of the form "arg=val" or "arg:val"?
 353     if arg is None:
 354       delimiter_pos = -1
 355
 356       for delimiter in [':', '=']:
 357         pos = argstr.find(delimiter)
 358         if pos >= 0:
 359           if delimiter_pos < 0 or pos < delimiter_pos:
 360             delimiter_pos = pos
 361
 362       if delimiter_pos >= 0:
 363         testarg = argstr[:delimiter_pos]
 364         testval = argstr[delimiter_pos+1:]
 365
 366         if testarg.lower() in self.arg_dict:
 367           arg = self.arg_dict[testarg.lower()]
 368           argstr = testarg
 369           value = testval
 370
 371     # Third check: does this begin an argument?
 372     if arg is None:
 373       for key in self.arg_dict.iterkeys():
 374         if (len(key) < len(argstr) and
 375             self.arg_dict[key].type in Command.Argument.TYPES_WITH_VALUES and
 376             argstr[:len(key)].lower() == key):
 377           value = argstr[len(key):]
 378           argstr = argstr[:len(key)]
 379           arg = self.arg_dict[argstr]
 380
 381     # Fourth check: do we have any positional arguments available?
 382     if arg is None:
 383       for positional_arg in [
 384           testarg for testarg in self.args if testarg.positional]:
 385         if not positional_arg.present:
 386           arg = positional_arg
 387           value = argstr
 388           argstr = positional_arg.names[0]
 389           break
 390
 391     # Push the retrieved argument/value onto the largs stack
 392     if argstr: self.cmdline.largs.append(argstr)
 393     if value:  self.cmdline.largs.append(value)
 394
 395     # If we've made it this far and haven't found an arg, give up
 396     if arg is None:
 397       raise ParseError("Unknown argument: '%s'" % argstr)
 398
 399     # Convert the value, if necessary
 400     if arg.type in Command.Argument.TYPES_WITH_VALUES and value is None:
 401       raise ParseError("Argument '%s' requires a value" % argstr)
 402
 403     if value is not None:
 404       value = self.StringToValue(value, arg.type, argstr)
 405
 406     arg.argstr = argstr
 407     arg.value = value
 408     arg.present = True
 409
 410     # end method ParseNextArgument
 411
 412   def StringToValue(self, value, type, argstr):
 413     """Convert a string from the command line to a value type."""
 414     try:
 415       if type == 'string':
 416         pass  # leave it be
 417
 418       elif type == 'int':
 419         try:
 420           value = int(value)
 421         except ValueError:
 422           raise ParseError
 423
 424       elif type == 'readfile':
 425         if not os.path.isfile(value):
 426           raise ParseError("'%s': '%s' does not exist" % (argstr, value))
 427
 428       elif type == 'coords':
 429         try:
 430           value = [int(val) for val in
 431                    re.match("\(\s*(\d+)\s*\,\s*(\d+)\s*\)\s*\Z", value).
 432                    groups()]
 433         except AttributeError:
 434           raise ParseError
 435
 436       else:
 437         raise ValueError("Unknown type: '%s'" % type)
 438
 439     except ParseError, e:
 440       # The bare exception is raised in the generic case; more specific errors
 441       # will arrive with arguments and should just be reraised
 442       if not e.args:
 443         e = ParseError("'%s': unable to convert '%s' to type '%s'" %
 444                        (argstr, value, type))
 445       raise e
 446
 447     return value
 448
 449   def SortArgs(self):
 450     """Returns a method that can be passed to sort() to sort arguments."""
 451
 452     def ArgSorter(arg1, arg2):
 453       """Helper for sorting arguments in the usage string.
 454
 455       Positional arguments come first, then required arguments,
 456       then optional arguments. Pylint demands this trivial function
 457       have both Args: and Returns: sections, sigh.
 458
 459       Args:
 460         arg1: the first argument to compare
 461         arg2: the second argument to compare
 462
 463       Returns:
 464         -1 if arg1 should be sorted first, +1 if it should be sorted second,
 465         and 0 if arg1 and arg2 have the same sort level.
 466       """
 467       return ((arg2.positional-arg1.positional)*2 +
 468               (arg2.required-arg1.required))
 469     return ArgSorter
 470
 471   def GetUsageString(self, width=80, name=None):
 472     """Gets a string describing how the command is used."""
 473     if name is None: name = self.names[0]
 474
 475     initial_indent = "Usage: %s %s " % (self.cmdline.prog, name)
 476     subsequent_indent = " " * len(initial_indent)
 477
 478     sorted_args = self.args[:]
 479     sorted_args.sort(self.SortArgs())
 480
 481     return textwrap.fill(
 482       " ".join([arg.GetUsageString() for arg in sorted_args]), width,
 483       initial_indent=initial_indent,
 484       subsequent_indent=subsequent_indent)
 485
 486   def GetHelpString(self, width=80):
 487     """Returns a list of help strings for all this command's arguments."""
 488     sorted_args = self.args[:]
 489     sorted_args.sort(self.SortArgs())
 490
 491     return "\n".join([arg.GetHelpString(width) for arg in sorted_args])
 492
 493   # end class Command
 494
 495
 496 class CommandLine(object):
 497   """Parse a command line, extracting a command and its arguments."""
 498
 499   def __init__(self):
 500     self.commands = []
 501     self.cmd_dict = {}
 502
 503     # Add the help command to the parser
 504     help_cmd = self.AddCommand(["help", "--help", "-?", "-h"],
 505                                "Displays help text for a command",
 506                                ValidateHelpCommand,
 507                                DoHelpCommand)
 508
 509     help_cmd.AddArgument(
 510       "command", "Command to retrieve help for", positional=True)
 511     help_cmd.AddArgument(
 512       "--width", "Width of the output", type='int', default=80)
 513
 514     self.Exit = sys.exit   # override this if you don't want the script to halt
 515                            # on error or on display of help
 516
 517     self.out = sys.stdout  # override these if you want to redirect
 518     self.err = sys.stderr  # output or error messages
 519
 520   def AddCommand(self, names, helptext, validator=None, impl=None):
 521     """Add a new command to the parser.
 522
 523     Args:
 524       names:       command name, or list of synonyms
 525       helptext:    brief string description of the command
 526       validator:   method to validate a command's arguments
 527       impl:        callable to be invoked when command is called
 528
 529     Raises:
 530       ValueError: raised if command already added
 531
 532     Returns:
 533       The new command
 534     """
 535     if IsString(names): names = [names]
 536
 537     for name in names:
 538       if name in self.cmd_dict:
 539         raise ValueError("%s is already a command"%name)
 540
 541     cmd = Command(names, helptext, validator, impl)
 542     cmd.cmdline = self
 543
 544     self.commands.append(cmd)
 545     for name in names:
 546       self.cmd_dict[name.lower()] = cmd
 547
 548     return cmd
 549
 550   def GetUsageString(self):
 551     """Returns simple usage instructions."""
 552     return "Type '%s help' for usage." % self.prog
 553
 554   def ParseCommandLine(self, argv=None, prog=None, execute=True):
 555     """Does the work of parsing a command line.
 556
 557     Args:
 558       argv:     list of arguments, defaults to sys.args[1:]
 559       prog:     name of the command, defaults to the base name of the script
 560       execute:  if false, just parse, don't invoke the 'impl' member
 561
 562     Returns:
 563       The command that was executed
 564     """
 565     if argv is None: argv = sys.argv[1:]
 566     if prog is None: prog = os.path.basename(sys.argv[0]).split('.')[0]
 567
 568     # Store off our parameters, we may need them someday
 569     self.argv = argv
 570     self.prog = prog
 571
 572     # We shouldn't be invoked without arguments, that's just lame
 573     if not len(argv):
 574       self.out.writelines(self.GetUsageString())
 575       self.Exit()
 576       return None   # in case the client overrides Exit
 577
 578     # Is it a valid command?
 579     self.command_string = argv[0].lower()
 580     if not self.command_string in self.cmd_dict:
 581       self.err.write("Unknown command: '%s'\n\n" % self.command_string)
 582       self.out.write(self.GetUsageString())
 583       self.Exit()
 584       return None   # in case the client overrides Exit
 585
 586     self.command = self.cmd_dict[self.command_string]
 587
 588     # "rargs" = remaining (unparsed) arguments
 589     # "largs" = already parsed, "left" of the read head
 590     self.rargs = argv[1:]
 591     self.largs = []
 592
 593     # let the command object do the parsing
 594     self.command.ParseArguments()
 595
 596     if self.command.parse_errors:
 597       # there were errors, output the usage string and exit
 598       self.err.write(self.command.GetUsageString()+"\n\n")
 599       self.err.write("\n".join(self.command.parse_errors))
 600       self.err.write("\n\n")
 601
 602       self.Exit()
 603
 604     elif execute and self.command.impl:
 605       self.command.impl(self.command)
 606
 607     return self.command
 608
 609   def __getitem__(self, key):
 610     return self.cmd_dict[key]
 611
 612   def __iter__(self):
 613     return self.cmd_dict.__iter__()
 614
 615
 616 def ValidateHelpCommand(command):
 617   """Checks to make sure an argument to 'help' is a valid command."""
 618   if 'command' in command and command['command'] not in command.cmdline:
 619     raise ParseError("'%s': unknown command" % command['command'])
 620
 621
 622 def DoHelpCommand(command):
 623   """Executed when the command is 'help'."""
 624   out = command.cmdline.out
 625   width = command['--width']
 626
 627   if 'command' not in command:
 628     out.write(command.GetUsageString())
 629     out.write("\n\n")
 630
 631     indent = 5
 632     gutter = 2
 633
 634     command_width = (
 635       max([len(cmd.names[0]) for cmd in command.cmdline.commands]) + gutter)
 636
 637     for cmd in command.cmdline.commands:
 638       cmd_name = cmd.names[0]
 639
 640       initial_indent = (" "*indent + cmd_name + " "*
 641                         (command_width+gutter-len(cmd_name)))
 642       subsequent_indent = " "*(indent+command_width+gutter)
 643
 644       out.write(textwrap.fill(cmd.helptext, width,
 645                               initial_indent=initial_indent,
 646                               subsequent_indent=subsequent_indent))
 647       out.write("\n")
 648
 649     out.write("\n")
 650
 651   else:
 652     help_cmd = command.cmdline[command['command']]
 653
 654     out.write(textwrap.fill(help_cmd.helptext, width))
 655     out.write("\n\n")
 656     out.write(help_cmd.GetUsageString(width=width))
 657     out.write("\n\n")
 658     out.write(help_cmd.GetHelpString(width=width))
 659     out.write("\n")
 660
 661     command.cmdline.Exit()
 662
 663
 664 def main():
 665   # If we're invoked rather than imported, run some tests
 666   cmdline = CommandLine()
 667
 668   # Since we're testing, override Exit()
 669   def TestExit():
 670     pass
 671   cmdline.Exit = TestExit
 672
 673   # Actually, while we're at it, let's override error output too
 674   cmdline.err = open(os.path.devnull, "w")
 675
 676   test = cmdline.AddCommand(["test", "testa", "testb"], "test command")
 677   test.AddArgument(["-i", "--int", "--integer", "--optint", "--optionalint"],
 678                    "optional integer parameter", type='int')
 679   test.AddArgument("--reqint", "required integer parameter", type='int',
 680                    required=True)
 681   test.AddArgument("pos1", "required positional argument", positional=True,
 682                    required=True)
 683   test.AddArgument("pos2", "optional positional argument", positional=True)
 684   test.AddArgument("pos3", "another optional positional arg",
 685                    positional=True)
 686
 687   # mutually dependent arguments
 688   test.AddArgument("--mutdep1", "mutually dependent parameter 1")
 689   test.AddArgument("--mutdep2", "mutually dependent parameter 2")
 690   test.AddArgument("--mutdep3", "mutually dependent parameter 3")
 691   test.AddMutualDependency(["--mutdep1", "--mutdep2", "--mutdep3"])
 692
 693   # mutually exclusive arguments
 694   test.AddArgument("--mutex1", "mutually exclusive parameter 1")
 695   test.AddArgument("--mutex2", "mutually exclusive parameter 2")
 696   test.AddArgument("--mutex3", "mutually exclusive parameter 3")
 697   test.AddMutualExclusion(["--mutex1", "--mutex2", "--mutex3"])
 698
 699   # dependent argument
 700   test.AddArgument("--dependent", "dependent argument")
 701   test.AddDependency("--dependent", "--int")
 702
 703   # other argument types
 704   test.AddArgument("--file", "filename argument", type='readfile')
 705   test.AddArgument("--coords", "coordinate argument", type='coords')
 706   test.AddArgument("--flag", "flag argument", type='flag')
 707
 708   test.AddArgument("--req1", "part of a required group", type='flag')
 709   test.AddArgument("--req2", "part 2 of a required group", type='flag')
 710
 711   test.AddRequiredGroup(["--req1", "--req2"])
 712
 713   # a few failure cases
 714   exception_cases = """
 715     test.AddArgument("failpos", "can't have req'd pos arg after opt",
 716        positional=True, required=True)
 717 +++
 718     test.AddArgument("--int", "this argument already exists")
 719 +++
 720     test.AddDependency("--int", "--doesntexist")
 721 +++
 722     test.AddMutualDependency(["--doesntexist", "--mutdep2"])
 723 +++
 724     test.AddMutualExclusion(["--doesntexist", "--mutex2"])
 725 +++
 726     test.AddArgument("--reqflag", "required flag", required=True, type='flag')
 727 +++
 728     test.AddRequiredGroup(["--req1", "--doesntexist"])
 729 """
 730   for exception_case in exception_cases.split("+++"):
 731     try:
 732       exception_case = exception_case.strip()
 733       exec exception_case     # yes, I'm using exec, it's just for a test.
 734     except ValueError:
 735       # this is expected
 736       pass
 737     except KeyError:
 738       # ...and so is this
 739       pass
 740     else:
 741       print ("FAILURE: expected an exception for '%s'"
 742              " and didn't get it" % exception_case)
 743
 744   # Let's do some parsing! first, the minimal success line:
 745   MIN = "test --reqint 123 param1 --req1 "
 746
 747   # tuples of (command line, expected error count)
 748   test_lines = [
 749     ("test --int 3 foo --req1", 1),   # missing required named parameter
 750     ("test --reqint 3 --req1", 1),    # missing required positional parameter
 751     (MIN, 0),                         # success!
 752     ("test param1 --reqint 123 --req1", 0),  # success, order shouldn't matter
 753     ("test param1 --reqint 123 --req2", 0),  # success, any of required group ok
 754     (MIN+"param2", 0),                # another positional parameter is okay
 755     (MIN+"param2 param3", 0),         # and so are three
 756     (MIN+"param2 param3 param4", 1),  # but four are just too many
 757     (MIN+"--int", 1),                 # where's the value?
 758     (MIN+"--int 456", 0),             # this is fine
 759     (MIN+"--int456", 0),              # as is this
 760     (MIN+"--int:456", 0),             # and this
 761     (MIN+"--int=456", 0),             # and this
 762     (MIN+"--file c:\\windows\\system32\\kernel32.dll", 0),  # yup
 763     (MIN+"--file c:\\thisdoesntexist", 1),           # nope
 764     (MIN+"--mutdep1 a", 2),                          # no!
 765     (MIN+"--mutdep2 b", 2),                          # also no!
 766     (MIN+"--mutdep3 c", 2),                          # dream on!
 767     (MIN+"--mutdep1 a --mutdep2 b", 2),              # almost!
 768     (MIN+"--mutdep1 a --mutdep2 b --mutdep3 c", 0),  # yes
 769     (MIN+"--mutex1 a", 0),                           # yes
 770     (MIN+"--mutex2 b", 0),                           # yes
 771     (MIN+"--mutex3 c", 0),                           # fine
 772     (MIN+"--mutex1 a --mutex2 b", 1),                # not fine
 773     (MIN+"--mutex1 a --mutex2 b --mutex3 c", 3),     # even worse
 774     (MIN+"--dependent 1", 1),                        # no
 775     (MIN+"--dependent 1 --int 2", 0),                # ok
 776     (MIN+"--int abc", 1),                            # bad type
 777     (MIN+"--coords abc", 1),                         # also bad
 778     (MIN+"--coords (abc)", 1),                       # getting warmer
 779     (MIN+"--coords (abc,def)", 1),                   # missing something
 780     (MIN+"--coords (123)", 1),                       # ooh, so close
 781     (MIN+"--coords (123,def)", 1),                   # just a little farther
 782     (MIN+"--coords (123,456)", 0),                   # finally!
 783     ("test --int 123 --reqint=456 foo bar --coords(42,88) baz --req1", 0)
 784     ]
 785
 786   badtests = 0
 787
 788   for (test, expected_failures) in test_lines:
 789     cmdline.ParseCommandLine([x.strip() for x in test.strip().split(" ")])
 790
 791     if not len(cmdline.command.parse_errors) == expected_failures:
 792       print "FAILED:\n  issued: '%s'\n  expected: %d\n  received: %d\n\n" % (
 793         test, expected_failures, len(cmdline.command.parse_errors))
 794       badtests += 1
 795
 796   print "%d failed out of %d tests" % (badtests, len(test_lines))
 797
 798   cmdline.ParseCommandLine(["help", "test"])
 799
 800
 801 if __name__ == "__main__":
 802   sys.exit(main())