| Index: tools/nixysa/third_party/gflags-1.0/python/gflags_unittest.py
|
| ===================================================================
|
| --- tools/nixysa/third_party/gflags-1.0/python/gflags_unittest.py (revision 0)
|
| +++ tools/nixysa/third_party/gflags-1.0/python/gflags_unittest.py (revision 0)
|
| @@ -0,0 +1,1208 @@
|
| +#!/usr/bin/env python
|
| +
|
| +# Copyright (c) 2007, Google Inc.
|
| +# All rights reserved.
|
| +#
|
| +# Redistribution and use in source and binary forms, with or without
|
| +# modification, are permitted provided that the following conditions are
|
| +# met:
|
| +#
|
| +# * Redistributions of source code must retain the above copyright
|
| +# notice, this list of conditions and the following disclaimer.
|
| +# * Redistributions in binary form must reproduce the above
|
| +# copyright notice, this list of conditions and the following disclaimer
|
| +# in the documentation and/or other materials provided with the
|
| +# distribution.
|
| +# * Neither the name of Google Inc. nor the names of its
|
| +# contributors may be used to endorse or promote products derived from
|
| +# this software without specific prior written permission.
|
| +#
|
| +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
| +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
| +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
| +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
| +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
| +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
| +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
| +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
| +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
| +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
| +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
| +
|
| +"Unittest for flags.py module"
|
| +
|
| +__pychecker__ = "no-local" # for unittest
|
| +
|
| +
|
| +import sys
|
| +import os
|
| +import shutil
|
| +import unittest
|
| +
|
| +# We use the name 'flags' internally in this test, for historical reasons.
|
| +# Don't do this yourself! :-) Just do 'import gflags; FLAGS=gflags.FLAGS; etc'
|
| +import gflags as flags
|
| +FLAGS=flags.FLAGS
|
| +
|
| +def MultiLineEqual(expected_help, help):
|
| + """Returns True if expected_help == help. Otherwise returns False
|
| + and logs the difference in a human-readable way.
|
| + """
|
| + if help == expected_help:
|
| + return True
|
| +
|
| + print "Error: FLAGS.MainModuleHelp() didn't return the expected result."
|
| + print "Got:"
|
| + print help
|
| + print "[End of got]"
|
| +
|
| + help_lines = help.split('\n')
|
| + expected_help_lines = expected_help.split('\n')
|
| +
|
| + num_help_lines = len(help_lines)
|
| + num_expected_help_lines = len(expected_help_lines)
|
| +
|
| + if num_help_lines != num_expected_help_lines:
|
| + print "Number of help lines = %d, expected %d" % (
|
| + num_help_lines, num_expected_help_lines)
|
| +
|
| + num_to_match = min(num_help_lines, num_expected_help_lines)
|
| +
|
| + for i in range(num_to_match):
|
| + if help_lines[i] != expected_help_lines[i]:
|
| + print "One discrepancy: Got:"
|
| + print help_lines[i]
|
| + print "Expected:"
|
| + print expected_help_lines[i]
|
| + break
|
| + else:
|
| + # If we got here, found no discrepancy, print first new line.
|
| + if num_help_lines > num_expected_help_lines:
|
| + print "New help line:"
|
| + print help_lines[num_expected_help_lines]
|
| + elif num_expected_help_lines > num_help_lines:
|
| + print "Missing expected help line:"
|
| + print expected_help_lines[num_help_lines]
|
| + else:
|
| + print "Bug in this test -- discrepancy detected but not found."
|
| +
|
| + return False
|
| +
|
| +
|
| +class FlagsUnitTest(unittest.TestCase):
|
| + "Flags Unit Test"
|
| +
|
| + def test_flags(self):
|
| +
|
| + ##############################################
|
| + # Test normal usage with no (expected) errors.
|
| +
|
| + # Define flags
|
| + number_test_framework_flags = len(FLAGS.RegisteredFlags())
|
| + repeatHelp = "how many times to repeat (0-5)"
|
| + flags.DEFINE_integer("repeat", 4, repeatHelp,
|
| + lower_bound=0, short_name='r')
|
| + flags.DEFINE_string("name", "Bob", "namehelp")
|
| + flags.DEFINE_boolean("debug", 0, "debughelp")
|
| + flags.DEFINE_boolean("q", 1, "quiet mode")
|
| + flags.DEFINE_boolean("quack", 0, "superstring of 'q'")
|
| + flags.DEFINE_boolean("noexec", 1, "boolean flag with no as prefix")
|
| + flags.DEFINE_integer("x", 3, "how eXtreme to be")
|
| + flags.DEFINE_integer("l", 0x7fffffff00000000L, "how long to be")
|
| + flags.DEFINE_list('letters', 'a,b,c', "a list of letters")
|
| + flags.DEFINE_enum("kwery", None, ['who', 'what', 'why', 'where', 'when'],
|
| + "?")
|
| +
|
| + # Specify number of flags defined above. The short_name defined
|
| + # for 'repeat' counts as an extra flag.
|
| + number_defined_flags = 10 + 1
|
| + self.assertEqual(len(FLAGS.RegisteredFlags()),
|
| + number_defined_flags + number_test_framework_flags)
|
| +
|
| + assert FLAGS.repeat == 4, "integer default values not set:" + FLAGS.repeat
|
| + assert FLAGS.name == 'Bob', "default values not set:" + FLAGS.name
|
| + assert FLAGS.debug == 0, "boolean default values not set:" + FLAGS.debug
|
| + assert FLAGS.q == 1, "boolean default values not set:" + FLAGS.q
|
| + assert FLAGS.x == 3, "integer default values not set:" + FLAGS.x
|
| + assert FLAGS.l == 0x7fffffff00000000L, ("integer default values not set:"
|
| + + FLAGS.l)
|
| + assert FLAGS.letters == ['a', 'b', 'c'], "list default values not set:" \
|
| + + FLAGS.letters
|
| + assert FLAGS.kwery is None, ("enum default None value not set:"
|
| + + FLAGS.kwery)
|
| +
|
| + flag_values = FLAGS.FlagValuesDict()
|
| + assert flag_values['repeat'] == 4
|
| + assert flag_values['name'] == 'Bob'
|
| + assert flag_values['debug'] == 0
|
| + assert flag_values['r'] == 4 # short for of repeat
|
| + assert flag_values['q'] == 1
|
| + assert flag_values['quack'] == 0
|
| + assert flag_values['x'] == 3
|
| + assert flag_values['l'] == 0x7fffffff00000000L
|
| + assert flag_values['letters'] == ['a', 'b', 'c']
|
| + assert flag_values['kwery'] is None
|
| +
|
| + # Verify string form of defaults
|
| + assert FLAGS['repeat'].default_as_str == "'4'"
|
| + assert FLAGS['name'].default_as_str == "'Bob'"
|
| + assert FLAGS['debug'].default_as_str == "'false'"
|
| + assert FLAGS['q'].default_as_str == "'true'"
|
| + assert FLAGS['quack'].default_as_str == "'false'"
|
| + assert FLAGS['noexec'].default_as_str == "'true'"
|
| + assert FLAGS['x'].default_as_str == "'3'"
|
| + assert FLAGS['l'].default_as_str == "'9223372032559808512'"
|
| + assert FLAGS['letters'].default_as_str == "'a,b,c'"
|
| +
|
| + # Verify that the iterator for flags yields all the keys
|
| + keys = list(FLAGS)
|
| + keys.sort()
|
| + reg_flags = FLAGS.RegisteredFlags()
|
| + reg_flags.sort()
|
| + self.assertEqual(keys, reg_flags)
|
| +
|
| + # Parse flags
|
| + # .. empty command line
|
| + argv = ('./program',)
|
| + argv = FLAGS(argv)
|
| + assert len(argv) == 1, "wrong number of arguments pulled"
|
| + assert argv[0]=='./program', "program name not preserved"
|
| +
|
| + # .. non-empty command line
|
| + argv = ('./program', '--debug', '--name=Bob', '-q', '--x=8')
|
| + argv = FLAGS(argv)
|
| + assert len(argv) == 1, "wrong number of arguments pulled"
|
| + assert argv[0]=='./program', "program name not preserved"
|
| + assert FLAGS['debug'].present == 1
|
| + FLAGS['debug'].present = 0 # Reset
|
| + assert FLAGS['name'].present == 1
|
| + FLAGS['name'].present = 0 # Reset
|
| + assert FLAGS['q'].present == 1
|
| + FLAGS['q'].present = 0 # Reset
|
| + assert FLAGS['x'].present == 1
|
| + FLAGS['x'].present = 0 # Reset
|
| +
|
| + # Flags list
|
| + self.assertEqual(len(FLAGS.RegisteredFlags()),
|
| + number_defined_flags + number_test_framework_flags)
|
| + assert 'name' in FLAGS.RegisteredFlags()
|
| + assert 'debug' in FLAGS.RegisteredFlags()
|
| + assert 'repeat' in FLAGS.RegisteredFlags()
|
| + assert 'r' in FLAGS.RegisteredFlags()
|
| + assert 'q' in FLAGS.RegisteredFlags()
|
| + assert 'quack' in FLAGS.RegisteredFlags()
|
| + assert 'x' in FLAGS.RegisteredFlags()
|
| + assert 'l' in FLAGS.RegisteredFlags()
|
| + assert 'letters' in FLAGS.RegisteredFlags()
|
| +
|
| + # has_key
|
| + assert FLAGS.has_key('name')
|
| + assert not FLAGS.has_key('name2')
|
| + assert 'name' in FLAGS
|
| + assert 'name2' not in FLAGS
|
| +
|
| + # try deleting a flag
|
| + del FLAGS.r
|
| + self.assertEqual(len(FLAGS.RegisteredFlags()),
|
| + number_defined_flags - 1 + number_test_framework_flags)
|
| + assert not 'r' in FLAGS.RegisteredFlags()
|
| +
|
| + # .. command line with extra stuff
|
| + argv = ('./program', '--debug', '--name=Bob', 'extra')
|
| + argv = FLAGS(argv)
|
| + assert len(argv) == 2, "wrong number of arguments pulled"
|
| + assert argv[0]=='./program', "program name not preserved"
|
| + assert argv[1]=='extra', "extra argument not preserved"
|
| + assert FLAGS['debug'].present == 1
|
| + FLAGS['debug'].present = 0 # Reset
|
| + assert FLAGS['name'].present == 1
|
| + FLAGS['name'].present = 0 # Reset
|
| +
|
| + # Test reset
|
| + argv = ('./program', '--debug')
|
| + argv = FLAGS(argv)
|
| + assert len(argv) == 1, "wrong number of arguments pulled"
|
| + assert argv[0] == './program', "program name not preserved"
|
| + assert FLAGS['debug'].present == 1
|
| + assert FLAGS['debug'].value
|
| + FLAGS.Reset()
|
| + assert FLAGS['debug'].present == 0
|
| + assert not FLAGS['debug'].value
|
| +
|
| + # Test that reset restores default value when default value is None.
|
| + argv = ('./program', '--kwery=who')
|
| + argv = FLAGS(argv)
|
| + assert len(argv) == 1, "wrong number of arguments pulled"
|
| + assert argv[0] == './program', "program name not preserved"
|
| + assert FLAGS['kwery'].present == 1
|
| + assert FLAGS['kwery'].value == 'who'
|
| + FLAGS.Reset()
|
| + assert FLAGS['kwery'].present == 0
|
| + assert FLAGS['kwery'].value == None
|
| +
|
| + # Test integer argument passing
|
| + argv = ('./program', '--x', '0x12345')
|
| + argv = FLAGS(argv)
|
| + self.assertEquals(FLAGS.x, 0x12345)
|
| + self.assertEquals(type(FLAGS.x), int)
|
| +
|
| + argv = ('./program', '--x', '0x1234567890ABCDEF1234567890ABCDEF')
|
| + argv = FLAGS(argv)
|
| + self.assertEquals(FLAGS.x, 0x1234567890ABCDEF1234567890ABCDEF)
|
| + self.assertEquals(type(FLAGS.x), long)
|
| +
|
| + # Treat 0-prefixed parameters as base-10, not base-8
|
| + argv = ('./program', '--x', '012345')
|
| + argv = FLAGS(argv)
|
| + self.assertEquals(FLAGS.x, 12345)
|
| + self.assertEquals(type(FLAGS.x), int)
|
| +
|
| + argv = ('./program', '--x', '0123459')
|
| + argv = FLAGS(argv)
|
| + self.assertEquals(FLAGS.x, 123459)
|
| + self.assertEquals(type(FLAGS.x), int)
|
| +
|
| + argv = ('./program', '--x', '0x123efg')
|
| + try:
|
| + argv = FLAGS(argv)
|
| + raise AssertionError("failed to detect invalid hex argument")
|
| + except flags.IllegalFlagValue:
|
| + pass
|
| +
|
| + argv = ('./program', '--x', '0X123efg')
|
| + try:
|
| + argv = FLAGS(argv)
|
| + raise AssertionError("failed to detect invalid hex argument")
|
| + except flags.IllegalFlagValue:
|
| + pass
|
| +
|
| + # Test boolean argument parsing
|
| + flags.DEFINE_boolean("test0", None, "test boolean parsing")
|
| + argv = ('./program', '--notest0')
|
| + argv = FLAGS(argv)
|
| + assert FLAGS.test0 == 0
|
| +
|
| + flags.DEFINE_boolean("test1", None, "test boolean parsing")
|
| + argv = ('./program', '--test1')
|
| + argv = FLAGS(argv)
|
| + assert FLAGS.test1 == 1
|
| +
|
| + FLAGS.test0 = None
|
| + argv = ('./program', '--test0=false')
|
| + argv = FLAGS(argv)
|
| + assert FLAGS.test0 == 0
|
| +
|
| + FLAGS.test1 = None
|
| + argv = ('./program', '--test1=true')
|
| + argv = FLAGS(argv)
|
| + assert FLAGS.test1 == 1
|
| +
|
| + FLAGS.test0 = None
|
| + argv = ('./program', '--test0=0')
|
| + argv = FLAGS(argv)
|
| + assert FLAGS.test0 == 0
|
| +
|
| + FLAGS.test1 = None
|
| + argv = ('./program', '--test1=1')
|
| + argv = FLAGS(argv)
|
| + assert FLAGS.test1 == 1
|
| +
|
| + # Test booleans that already have 'no' as a prefix
|
| + FLAGS.noexec = None
|
| + argv = ('./program', '--nonoexec', '--name', 'Bob')
|
| + argv = FLAGS(argv)
|
| + assert FLAGS.noexec == 0
|
| +
|
| + FLAGS.noexec = None
|
| + argv = ('./program', '--name', 'Bob', '--noexec')
|
| + argv = FLAGS(argv)
|
| + assert FLAGS.noexec == 1
|
| +
|
| + # Test unassigned booleans
|
| + flags.DEFINE_boolean("testnone", None, "test boolean parsing")
|
| + argv = ('./program',)
|
| + argv = FLAGS(argv)
|
| + assert FLAGS.testnone == None
|
| +
|
| + # Test get with default
|
| + flags.DEFINE_boolean("testget1", None, "test parsing with defaults")
|
| + flags.DEFINE_boolean("testget2", None, "test parsing with defaults")
|
| + flags.DEFINE_boolean("testget3", None, "test parsing with defaults")
|
| + flags.DEFINE_integer("testget4", None, "test parsing with defaults")
|
| + argv = ('./program','--testget1','--notestget2')
|
| + argv = FLAGS(argv)
|
| + assert FLAGS.get('testget1', 'foo') == 1
|
| + assert FLAGS.get('testget2', 'foo') == 0
|
| + assert FLAGS.get('testget3', 'foo') == 'foo'
|
| + assert FLAGS.get('testget4', 'foo') == 'foo'
|
| +
|
| + # test list code
|
| + lists = [['hello','moo','boo','1'],
|
| + [],]
|
| +
|
| + flags.DEFINE_list('testlist', '', 'test lists parsing')
|
| + flags.DEFINE_spaceseplist('testspacelist', '', 'tests space lists parsing')
|
| +
|
| + for name, sep in (('testlist', ','), ('testspacelist', ' '),
|
| + ('testspacelist', '\n')):
|
| + for lst in lists:
|
| + argv = ('./program', '--%s=%s' % (name, sep.join(lst)))
|
| + argv = FLAGS(argv)
|
| + self.assertEquals(getattr(FLAGS, name), lst)
|
| +
|
| + # Test help text
|
| + flagsHelp = str(FLAGS)
|
| + assert flagsHelp.find("repeat") != -1, "cannot find flag in help"
|
| + assert flagsHelp.find(repeatHelp) != -1, "cannot find help string in help"
|
| +
|
| + # Test flag specified twice
|
| + argv = ('./program', '--repeat=4', '--repeat=2', '--debug', '--nodebug')
|
| + argv = FLAGS(argv)
|
| + self.assertEqual(FLAGS.get('repeat', None), 2)
|
| + self.assertEqual(FLAGS.get('debug', None), 0)
|
| +
|
| + # Test MultiFlag with single default value
|
| + flags.DEFINE_multistring('s_str', 'sing1',
|
| + 'string option that can occur multiple times',
|
| + short_name='s')
|
| + self.assertEqual(FLAGS.get('s_str', None), [ 'sing1', ])
|
| +
|
| + # Test MultiFlag with list of default values
|
| + multi_string_defs = [ 'def1', 'def2', ]
|
| + flags.DEFINE_multistring('m_str', multi_string_defs,
|
| + 'string option that can occur multiple times',
|
| + short_name='m')
|
| + self.assertEqual(FLAGS.get('m_str', None), multi_string_defs)
|
| +
|
| + # Test flag specified multiple times with a MultiFlag
|
| + argv = ('./program', '--m_str=str1', '-m', 'str2')
|
| + argv = FLAGS(argv)
|
| + self.assertEqual(FLAGS.get('m_str', None), [ 'str1', 'str2', ])
|
| +
|
| + # Test single-letter flags; should support both single and double dash
|
| + argv = ('./program', '-q', '-x8')
|
| + argv = FLAGS(argv)
|
| + self.assertEqual(FLAGS.get('q', None), 1)
|
| + self.assertEqual(FLAGS.get('x', None), 8)
|
| +
|
| + argv = ('./program', '--q', '--x', '9', '--noqu')
|
| + argv = FLAGS(argv)
|
| + self.assertEqual(FLAGS.get('q', None), 1)
|
| + self.assertEqual(FLAGS.get('x', None), 9)
|
| + # --noqu should match '--noquack since it's a unique prefix
|
| + self.assertEqual(FLAGS.get('quack', None), 0)
|
| +
|
| + argv = ('./program', '--noq', '--x=10', '--qu')
|
| + argv = FLAGS(argv)
|
| + self.assertEqual(FLAGS.get('q', None), 0)
|
| + self.assertEqual(FLAGS.get('x', None), 10)
|
| + self.assertEqual(FLAGS.get('quack', None), 1)
|
| +
|
| + ####################################
|
| + # Test flag serialization code:
|
| +
|
| + oldtestlist = FLAGS.testlist
|
| + oldtestspacelist = FLAGS.testspacelist
|
| +
|
| + argv = ('./program',
|
| + FLAGS['test0'].Serialize(),
|
| + FLAGS['test1'].Serialize(),
|
| + FLAGS['testnone'].Serialize(),
|
| + FLAGS['s_str'].Serialize())
|
| + argv = FLAGS(argv)
|
| + self.assertEqual(FLAGS['test0'].Serialize(), '--notest0')
|
| + self.assertEqual(FLAGS['test1'].Serialize(), '--test1')
|
| + self.assertEqual(FLAGS['testnone'].Serialize(), '')
|
| + self.assertEqual(FLAGS['s_str'].Serialize(), '--s_str=sing1')
|
| +
|
| + testlist1 = ['aa', 'bb']
|
| + testspacelist1 = ['aa', 'bb', 'cc']
|
| + FLAGS.testlist = list(testlist1)
|
| + FLAGS.testspacelist = list(testspacelist1)
|
| + argv = ('./program',
|
| + FLAGS['testlist'].Serialize(),
|
| + FLAGS['testspacelist'].Serialize())
|
| + argv = FLAGS(argv)
|
| + self.assertEqual(FLAGS.testlist, testlist1)
|
| + self.assertEqual(FLAGS.testspacelist, testspacelist1)
|
| +
|
| + testlist1 = ['aa some spaces', 'bb']
|
| + testspacelist1 = ['aa', 'bb,some,commas,', 'cc']
|
| + FLAGS.testlist = list(testlist1)
|
| + FLAGS.testspacelist = list(testspacelist1)
|
| + argv = ('./program',
|
| + FLAGS['testlist'].Serialize(),
|
| + FLAGS['testspacelist'].Serialize())
|
| + argv = FLAGS(argv)
|
| + self.assertEqual(FLAGS.testlist, testlist1)
|
| + self.assertEqual(FLAGS.testspacelist, testspacelist1)
|
| +
|
| + FLAGS.testlist = oldtestlist
|
| + FLAGS.testspacelist = oldtestspacelist
|
| +
|
| + ####################################
|
| + # Test flag-update:
|
| +
|
| + def ArgsString():
|
| + flagnames = FLAGS.RegisteredFlags()
|
| +
|
| + flagnames.sort()
|
| + nonbool_flags = ['--%s %s' % (name, FLAGS.get(name, None))
|
| + for name in flagnames
|
| + if not isinstance(FLAGS[name], flags.BooleanFlag)]
|
| +
|
| + truebool_flags = ['--%s' % (name)
|
| + for name in flagnames
|
| + if isinstance(FLAGS[name], flags.BooleanFlag) and
|
| + FLAGS.get(name, None)]
|
| + falsebool_flags = ['--no%s' % (name)
|
| + for name in flagnames
|
| + if isinstance(FLAGS[name], flags.BooleanFlag) and
|
| + not FLAGS.get(name, None)]
|
| + return ' '.join(nonbool_flags + truebool_flags + falsebool_flags)
|
| +
|
| + argv = ('./program', '--repeat=3', '--name=giants', '--nodebug')
|
| + FLAGS(argv)
|
| + self.assertEqual(FLAGS.get('repeat', None), 3)
|
| + self.assertEqual(FLAGS.get('name', None), 'giants')
|
| + self.assertEqual(FLAGS.get('debug', None), 0)
|
| + self.assertEqual(ArgsString(),
|
| + "--kwery None "
|
| + "--l 9223372032559808512 "
|
| + "--letters ['a', 'b', 'c'] "
|
| + "--m ['str1', 'str2'] --m_str ['str1', 'str2'] "
|
| + "--name giants "
|
| + "--repeat 3 "
|
| + "--s ['sing1'] --s_str ['sing1'] "
|
| + "--testget4 None --testlist [] "
|
| + "--testspacelist [] --x 10 "
|
| + "--noexec --quack "
|
| + "--test1 "
|
| + "--testget1 --no? --nodebug --nohelp --nohelpshort "
|
| + "--noq --notest0 --notestget2 "
|
| + "--notestget3 --notestnone")
|
| +
|
| + argv = ('./program', '--debug', '--m_str=upd1', '-s', 'upd2')
|
| + FLAGS(argv)
|
| + self.assertEqual(FLAGS.get('repeat', None), 3)
|
| + self.assertEqual(FLAGS.get('name', None), 'giants')
|
| + self.assertEqual(FLAGS.get('debug', None), 1)
|
| +
|
| + # items appended to existing non-default value lists for --m/--m_str
|
| + # new value overwrites default value (not appended to it) for --s/--s_str
|
| + self.assertEqual(ArgsString(),
|
| + "--kwery None "
|
| + "--l 9223372032559808512 "
|
| + "--letters ['a', 'b', 'c'] "
|
| + "--m ['str1', 'str2', 'upd1'] "
|
| + "--m_str ['str1', 'str2', 'upd1'] "
|
| + "--name giants "
|
| + "--repeat 3 "
|
| + "--s ['upd2'] --s_str ['upd2'] "
|
| + "--testget4 None --testlist [] "
|
| + "--testspacelist [] --x 10 "
|
| + "--debug --noexec --quack "
|
| + "--test1 "
|
| + "--testget1 --no? --nohelp --nohelpshort "
|
| + "--noq --notest0 --notestget2 "
|
| + "--notestget3 --notestnone")
|
| +
|
| +
|
| + ####################################
|
| + # Test all kind of error conditions.
|
| +
|
| + # Duplicate flag detection
|
| + try:
|
| + flags.DEFINE_boolean("run", 0, "runhelp", short_name='q')
|
| + raise AssertionError("duplicate flag detection failed")
|
| + except flags.DuplicateFlag, e:
|
| + pass
|
| +
|
| + try:
|
| + flags.DEFINE_boolean("zoom1", 0, "runhelp z1", short_name='z')
|
| + flags.DEFINE_boolean("zoom2", 0, "runhelp z2", short_name='z')
|
| + raise AssertionError("duplicate flag detection failed")
|
| + except flags.DuplicateFlag, e:
|
| + pass
|
| +
|
| + # Make sure allow_override works
|
| + try:
|
| + flags.DEFINE_boolean("dup1", 0, "runhelp d11", short_name='u',
|
| + allow_override=0)
|
| + flag = FLAGS.FlagDict()['dup1']
|
| + self.assertEqual(flag.default, 0)
|
| +
|
| + flags.DEFINE_boolean("dup1", 1, "runhelp d12", short_name='u',
|
| + allow_override=1)
|
| + flag = FLAGS.FlagDict()['dup1']
|
| + self.assertEqual(flag.default, 1)
|
| + except flags.DuplicateFlag, e:
|
| + raise AssertionError("allow_override did not permit a flag duplication")
|
| +
|
| + # Make sure allow_override works
|
| + try:
|
| + flags.DEFINE_boolean("dup2", 0, "runhelp d21", short_name='u',
|
| + allow_override=1)
|
| + flag = FLAGS.FlagDict()['dup2']
|
| + self.assertEqual(flag.default, 0)
|
| +
|
| + flags.DEFINE_boolean("dup2", 1, "runhelp d22", short_name='u',
|
| + allow_override=0)
|
| + flag = FLAGS.FlagDict()['dup2']
|
| + self.assertEqual(flag.default, 1)
|
| + except flags.DuplicateFlag, e:
|
| + raise AssertionError("allow_override did not permit a flag duplication")
|
| +
|
| + # Make sure allow_override doesn't work with None default
|
| + try:
|
| + flags.DEFINE_boolean("dup3", 0, "runhelp d31", short_name='u',
|
| + allow_override=0)
|
| + flag = FLAGS.FlagDict()['dup3']
|
| + self.assertEqual(flag.default, 0)
|
| +
|
| + flags.DEFINE_boolean("dup3", None, "runhelp d32", short_name='u',
|
| + allow_override=1)
|
| + raise AssertionError('Cannot override a flag with a default of None')
|
| + except flags.DuplicateFlag, e:
|
| + pass
|
| +
|
| + # Make sure that when we override, the help string gets updated correctly
|
| + flags.DEFINE_boolean("dup3", 0, "runhelp d31", short_name='u',
|
| + allow_override=1)
|
| + flags.DEFINE_boolean("dup3", 1, "runhelp d32", short_name='u',
|
| + allow_override=1)
|
| + self.assert_(str(FLAGS).find('runhelp d31') == -1)
|
| + self.assert_(str(FLAGS).find('runhelp d32') != -1)
|
| +
|
| + # Make sure AppendFlagValues works
|
| + new_flags = flags.FlagValues()
|
| + flags.DEFINE_boolean("new1", 0, "runhelp n1", flag_values=new_flags)
|
| + flags.DEFINE_boolean("new2", 0, "runhelp n2", flag_values=new_flags)
|
| + self.assertEqual(len(new_flags.FlagDict()), 2)
|
| + old_len = len(FLAGS.FlagDict())
|
| + FLAGS.AppendFlagValues(new_flags)
|
| + self.assertEqual(len(FLAGS.FlagDict())-old_len, 2)
|
| + self.assertEqual("new1" in FLAGS.FlagDict(), True)
|
| + self.assertEqual("new2" in FLAGS.FlagDict(), True)
|
| +
|
| + # Make sure AppendFlagValues works with flags with shortnames.
|
| + new_flags = flags.FlagValues()
|
| + flags.DEFINE_boolean("new3", 0, "runhelp n3", flag_values=new_flags)
|
| + flags.DEFINE_boolean("new4", 0, "runhelp n4", flag_values=new_flags,
|
| + short_name="n4")
|
| + self.assertEqual(len(new_flags.FlagDict()), 3)
|
| + old_len = len(FLAGS.FlagDict())
|
| + FLAGS.AppendFlagValues(new_flags)
|
| + self.assertEqual(len(FLAGS.FlagDict())-old_len, 3)
|
| + self.assertTrue("new3" in FLAGS.FlagDict())
|
| + self.assertTrue("new4" in FLAGS.FlagDict())
|
| + self.assertTrue("n4" in FLAGS.FlagDict())
|
| + self.assertEqual(FLAGS.FlagDict()['n4'], FLAGS.FlagDict()['new4'])
|
| +
|
| + # Make sure AppendFlagValues fails on duplicates
|
| + flags.DEFINE_boolean("dup4", 0, "runhelp d41")
|
| + new_flags = flags.FlagValues()
|
| + flags.DEFINE_boolean("dup4", 0, "runhelp d42", flag_values=new_flags)
|
| + try:
|
| + FLAGS.AppendFlagValues(new_flags)
|
| + raise AssertionError("ignore_copy was not set but caused no exception")
|
| + except flags.DuplicateFlag, e:
|
| + pass
|
| +
|
| + # Integer out of bounds
|
| + try:
|
| + argv = ('./program', '--repeat=-4')
|
| + FLAGS(argv)
|
| + raise AssertionError('integer bounds exception not raised:'
|
| + + str(FLAGS.repeat))
|
| + except flags.IllegalFlagValue:
|
| + pass
|
| +
|
| + # Non-integer
|
| + try:
|
| + argv = ('./program', '--repeat=2.5')
|
| + FLAGS(argv)
|
| + raise AssertionError("malformed integer value exception not raised")
|
| + except flags.IllegalFlagValue:
|
| + pass
|
| +
|
| + # Missing required arugment
|
| + try:
|
| + argv = ('./program', '--name')
|
| + FLAGS(argv)
|
| + raise AssertionError("Flag argument required exception not raised")
|
| + except flags.FlagsError:
|
| + pass
|
| +
|
| + # Non-boolean arguments for boolean
|
| + try:
|
| + argv = ('./program', '--debug=goofup')
|
| + FLAGS(argv)
|
| + raise AssertionError("Illegal flag value exception not raised")
|
| + except flags.IllegalFlagValue:
|
| + pass
|
| +
|
| + try:
|
| + argv = ('./program', '--debug=42')
|
| + FLAGS(argv)
|
| + raise AssertionError("Illegal flag value exception not raised")
|
| + except flags.IllegalFlagValue:
|
| + pass
|
| +
|
| +
|
| + # Non-numeric argument for integer flag --repeat
|
| + try:
|
| + argv = ('./program', '--repeat', 'Bob', 'extra')
|
| + FLAGS(argv)
|
| + raise AssertionError("Illegal flag value exception not raised")
|
| + except flags.IllegalFlagValue:
|
| + pass
|
| +
|
| + ################################################
|
| + # Code to test the flagfile=<> loading behavior
|
| + ################################################
|
| + def _SetupTestFiles(self):
|
| + """ Creates and sets up some dummy flagfile files with bogus flags"""
|
| +
|
| + # Figure out where to create temporary files
|
| + tmp_path = '/tmp/flags_unittest'
|
| + if os.path.exists(tmp_path):
|
| + shutil.rmtree(tmp_path)
|
| + os.makedirs(tmp_path)
|
| +
|
| + try:
|
| + tmp_flag_file_1 = open((tmp_path + '/UnitTestFile1.tst'), 'w')
|
| + tmp_flag_file_2 = open((tmp_path + '/UnitTestFile2.tst'), 'w')
|
| + tmp_flag_file_3 = open((tmp_path + '/UnitTestFile3.tst'), 'w')
|
| + except IOError, e_msg:
|
| + print e_msg
|
| + print 'FAIL\n File Creation problem in Unit Test'
|
| + sys.exit(1)
|
| +
|
| + # put some dummy flags in our test files
|
| + tmp_flag_file_1.write('#A Fake Comment\n')
|
| + tmp_flag_file_1.write('--UnitTestMessage1=tempFile1!\n')
|
| + tmp_flag_file_1.write('\n')
|
| + tmp_flag_file_1.write('--UnitTestNumber=54321\n')
|
| + tmp_flag_file_1.write('--noUnitTestBoolFlag\n')
|
| + file_list = [tmp_flag_file_1.name]
|
| + # this one includes test file 1
|
| + tmp_flag_file_2.write('//A Different Fake Comment\n')
|
| + tmp_flag_file_2.write('--flagfile=%s\n' % tmp_flag_file_1.name)
|
| + tmp_flag_file_2.write('--UnitTestMessage2=setFromTempFile2\n')
|
| + tmp_flag_file_2.write('\t\t\n')
|
| + tmp_flag_file_2.write('--UnitTestNumber=6789a\n')
|
| + file_list.append(tmp_flag_file_2.name)
|
| + # this file points to itself
|
| + tmp_flag_file_3.write('--flagfile=%s\n' % tmp_flag_file_3.name)
|
| + tmp_flag_file_3.write('--UnitTestMessage1=setFromTempFile3\n')
|
| + tmp_flag_file_3.write('#YAFC\n')
|
| + tmp_flag_file_3.write('--UnitTestBoolFlag\n')
|
| + file_list.append(tmp_flag_file_3.name)
|
| +
|
| + tmp_flag_file_1.close()
|
| + tmp_flag_file_2.close()
|
| + tmp_flag_file_3.close()
|
| +
|
| + return file_list # these are just the file names
|
| + # end SetupFiles def
|
| +
|
| + def _RemoveTestFiles(self, tmp_file_list):
|
| + """Closes the files we just created. tempfile deletes them for us """
|
| + for file_name in tmp_file_list:
|
| + try:
|
| + os.remove(file_name)
|
| + except OSError, e_msg:
|
| + print '%s\n, Problem deleting test file' % e_msg
|
| + #end RemoveTestFiles def
|
| +
|
| + def __DeclareSomeFlags(self):
|
| + flags.DEFINE_string('UnitTestMessage1', 'Foo!', 'You Add Here.')
|
| + flags.DEFINE_string('UnitTestMessage2', 'Bar!', 'Hello, Sailor!')
|
| + flags.DEFINE_boolean('UnitTestBoolFlag', 0, 'Some Boolean thing')
|
| + flags.DEFINE_integer('UnitTestNumber', 12345, 'Some integer',
|
| + lower_bound=0)
|
| + flags.DEFINE_list('UnitTestList', "1,2,3", 'Some list')
|
| +
|
| + def _UndeclareSomeFlags(self):
|
| + FLAGS.__delattr__('UnitTestMessage1')
|
| + FLAGS.__delattr__('UnitTestMessage2')
|
| + FLAGS.__delattr__('UnitTestBoolFlag')
|
| + FLAGS.__delattr__('UnitTestNumber')
|
| + FLAGS.__delattr__('UnitTestList')
|
| +
|
| + #### Flagfile Unit Tests ####
|
| + def testMethod_flagfiles_1(self):
|
| + """ Test trivial case with no flagfile based options. """
|
| + self.__DeclareSomeFlags()
|
| + fake_cmd_line = 'fooScript --UnitTestBoolFlag'
|
| + fake_argv = fake_cmd_line.split(' ')
|
| + FLAGS(fake_argv)
|
| + self.assertEqual( FLAGS.UnitTestBoolFlag, 1)
|
| + self.assertEqual( fake_argv, FLAGS.ReadFlagsFromFiles(fake_argv))
|
| + self._UndeclareSomeFlags()
|
| + # end testMethodOne
|
| +
|
| + def testMethod_flagfiles_2(self):
|
| + """Tests parsing one file + arguments off simulated argv"""
|
| + self.__DeclareSomeFlags()
|
| + tmp_files = self._SetupTestFiles()
|
| + # specify our temp file on the fake cmd line
|
| + fake_cmd_line = 'fooScript --q --flagfile=%s' % tmp_files[0]
|
| + fake_argv = fake_cmd_line.split(' ')
|
| +
|
| + # We should see the original cmd line with the file's contents spliced in.
|
| + # Note that these will be in REVERSE order from order encountered in file
|
| + # This is done so arguements we encounter sooner will have priority.
|
| + expected_results = ['fooScript',
|
| + '--UnitTestMessage1=tempFile1!',
|
| + '--UnitTestNumber=54321',
|
| + '--noUnitTestBoolFlag',
|
| + '--q']
|
| + test_results = FLAGS.ReadFlagsFromFiles(fake_argv)
|
| + self.assertEqual(expected_results, test_results)
|
| + self._RemoveTestFiles(tmp_files)
|
| + self._UndeclareSomeFlags()
|
| + # end testTwo def
|
| +
|
| + def testMethod_flagfiles_3(self):
|
| + """Tests parsing nested files + arguments of simulated argv"""
|
| + self.__DeclareSomeFlags()
|
| + tmp_files = self._SetupTestFiles()
|
| + # specify our temp file on the fake cmd line
|
| + fake_cmd_line = ('fooScript --UnitTestNumber=77 --flagfile=%s'
|
| + % tmp_files[1])
|
| + fake_argv = fake_cmd_line.split(' ')
|
| +
|
| + expected_results = ['fooScript',
|
| + '--UnitTestMessage1=tempFile1!',
|
| + '--UnitTestNumber=54321',
|
| + '--noUnitTestBoolFlag',
|
| + '--UnitTestMessage2=setFromTempFile2',
|
| + '--UnitTestNumber=6789a',
|
| + '--UnitTestNumber=77']
|
| + test_results = FLAGS.ReadFlagsFromFiles(fake_argv)
|
| + self.assertEqual(expected_results, test_results)
|
| + self._RemoveTestFiles(tmp_files)
|
| + self._UndeclareSomeFlags()
|
| + # end testThree def
|
| +
|
| + def testMethod_flagfiles_4(self):
|
| + """Tests parsing self-referential files + arguments of simulated argv.
|
| + This test should print a warning to stderr of some sort.
|
| + """
|
| + self.__DeclareSomeFlags()
|
| + tmp_files = self._SetupTestFiles()
|
| + # specify our temp file on the fake cmd line
|
| + fake_cmd_line = ('fooScript --flagfile=%s --noUnitTestBoolFlag'
|
| + % tmp_files[2])
|
| + fake_argv = fake_cmd_line.split(' ')
|
| + expected_results = ['fooScript',
|
| + '--UnitTestMessage1=setFromTempFile3',
|
| + '--UnitTestBoolFlag',
|
| + '--noUnitTestBoolFlag' ]
|
| +
|
| + test_results = FLAGS.ReadFlagsFromFiles(fake_argv)
|
| + self.assertEqual(expected_results, test_results)
|
| + self._RemoveTestFiles(tmp_files)
|
| + self._UndeclareSomeFlags()
|
| +
|
| + def test_flagfiles_user_path_expansion(self):
|
| + """Test that user directory referenced paths (ie. ~/foo) are correctly
|
| + expanded. This test depends on whatever account's running the unit test
|
| + to have read/write access to their own home directory, otherwise it'll
|
| + FAIL.
|
| + """
|
| + self.__DeclareSomeFlags()
|
| + fake_flagfile_item_style_1 = '--flagfile=~/foo.file'
|
| + fake_flagfile_item_style_2 = '-flagfile=~/foo.file'
|
| +
|
| + expected_results = os.path.expanduser('~/foo.file')
|
| +
|
| + test_results = FLAGS.ExtractFilename(fake_flagfile_item_style_1)
|
| + self.assertEqual(expected_results, test_results)
|
| +
|
| + test_results = FLAGS.ExtractFilename(fake_flagfile_item_style_2)
|
| + self.assertEqual(expected_results, test_results)
|
| +
|
| + self._UndeclareSomeFlags()
|
| +
|
| + # end testFour def
|
| +
|
| + def test_no_touchy_non_flags(self):
|
| + """
|
| + Test that the flags parser does not mutilate arguments which are
|
| + not supposed to be flags
|
| + """
|
| + self.__DeclareSomeFlags()
|
| + fake_argv = ['fooScript', '--UnitTestBoolFlag',
|
| + 'command', '--command_arg1', '--UnitTestBoom', '--UnitTestB']
|
| + argv = FLAGS(fake_argv)
|
| + self.assertEqual(argv, fake_argv[:1] + fake_argv[2:])
|
| + self._UndeclareSomeFlags()
|
| +
|
| + def test_SetDefault(self):
|
| + """
|
| + Test changing flag defaults.
|
| + """
|
| + self.__DeclareSomeFlags()
|
| + # Test that SetDefault changes both the default and the value,
|
| + # and that the value is changed when one is given as an option.
|
| + FLAGS['UnitTestMessage1'].SetDefault('New value')
|
| + self.assertEqual(FLAGS.UnitTestMessage1, 'New value')
|
| + self.assertEqual(FLAGS['UnitTestMessage1'].default_as_str,"'New value'")
|
| + FLAGS([ 'dummyscript', '--UnitTestMessage1=Newer value' ])
|
| + self.assertEqual(FLAGS.UnitTestMessage1, 'Newer value')
|
| +
|
| + # Test that setting the default to None works correctly.
|
| + FLAGS['UnitTestNumber'].SetDefault(None)
|
| + self.assertEqual(FLAGS.UnitTestNumber, None)
|
| + self.assertEqual(FLAGS['UnitTestNumber'].default_as_str, None)
|
| + FLAGS([ 'dummyscript', '--UnitTestNumber=56' ])
|
| + self.assertEqual(FLAGS.UnitTestNumber, 56)
|
| +
|
| + # Test that setting the default to zero works correctly.
|
| + FLAGS['UnitTestNumber'].SetDefault(0)
|
| + self.assertEqual(FLAGS.UnitTestNumber, 0)
|
| + self.assertEqual(FLAGS['UnitTestNumber'].default_as_str, "'0'")
|
| + FLAGS([ 'dummyscript', '--UnitTestNumber=56' ])
|
| + self.assertEqual(FLAGS.UnitTestNumber, 56)
|
| +
|
| + # Test that setting the default to "" works correctly.
|
| + FLAGS['UnitTestMessage1'].SetDefault("")
|
| + self.assertEqual(FLAGS.UnitTestMessage1, "")
|
| + self.assertEqual(FLAGS['UnitTestMessage1'].default_as_str, "''")
|
| + FLAGS([ 'dummyscript', '--UnitTestMessage1=fifty-six' ])
|
| + self.assertEqual(FLAGS.UnitTestMessage1, "fifty-six")
|
| +
|
| + # Test that setting the default to false works correctly.
|
| + FLAGS['UnitTestBoolFlag'].SetDefault(False)
|
| + self.assertEqual(FLAGS.UnitTestBoolFlag, False)
|
| + self.assertEqual(FLAGS['UnitTestBoolFlag'].default_as_str, "'false'")
|
| + FLAGS([ 'dummyscript', '--UnitTestBoolFlag=true' ])
|
| + self.assertEqual(FLAGS.UnitTestBoolFlag, True)
|
| +
|
| + # Test that setting a list default works correctly.
|
| + FLAGS['UnitTestList'].SetDefault('4,5,6')
|
| + self.assertEqual(FLAGS.UnitTestList, ['4', '5', '6'])
|
| + self.assertEqual(FLAGS['UnitTestList'].default_as_str, "'4,5,6'")
|
| + FLAGS([ 'dummyscript', '--UnitTestList=7,8,9' ])
|
| + self.assertEqual(FLAGS.UnitTestList, ['7', '8', '9'])
|
| +
|
| + # Test that setting invalid defaults raises exceptions
|
| + self.assertRaises(flags.IllegalFlagValue,
|
| + FLAGS['UnitTestNumber'].SetDefault, 'oops')
|
| + self.assertRaises(flags.IllegalFlagValue,
|
| + FLAGS['UnitTestNumber'].SetDefault, -1)
|
| + self.assertRaises(flags.IllegalFlagValue,
|
| + FLAGS['UnitTestBoolFlag'].SetDefault, 'oops')
|
| +
|
| + self._UndeclareSomeFlags()
|
| +
|
| + def testMethod_ShortestUniquePrefixes(self):
|
| + """
|
| + Test FlagValues.ShortestUniquePrefixes
|
| + """
|
| + flags.DEFINE_string('a', '', '')
|
| + flags.DEFINE_string('abc', '', '')
|
| + flags.DEFINE_string('common_a_string', '', '')
|
| + flags.DEFINE_boolean('common_b_boolean', 0, '')
|
| + flags.DEFINE_boolean('common_c_boolean', 0, '')
|
| + flags.DEFINE_boolean('common', 0, '')
|
| + flags.DEFINE_integer('commonly', 0, '')
|
| + flags.DEFINE_boolean('zz', 0, '')
|
| + flags.DEFINE_integer('nozz', 0, '')
|
| +
|
| + shorter_flags = FLAGS.ShortestUniquePrefixes(FLAGS.FlagDict())
|
| +
|
| + expected_results = {'nocommon_b_boolean': 'nocommon_b',
|
| + 'common_c_boolean': 'common_c',
|
| + 'common_b_boolean': 'common_b',
|
| + 'a': 'a',
|
| + 'abc': 'ab',
|
| + 'zz': 'z',
|
| + 'nozz': 'nozz',
|
| + 'common_a_string': 'common_a',
|
| + 'commonly': 'commonl',
|
| + 'nocommon_c_boolean': 'nocommon_c',
|
| + 'nocommon': 'nocommon',
|
| + 'common': 'common'}
|
| +
|
| + for name, shorter in expected_results.iteritems():
|
| + self.assertEquals(shorter_flags[name], shorter)
|
| +
|
| + FLAGS.__delattr__('a')
|
| + FLAGS.__delattr__('abc')
|
| + FLAGS.__delattr__('common_a_string')
|
| + FLAGS.__delattr__('common_b_boolean')
|
| + FLAGS.__delattr__('common_c_boolean')
|
| + FLAGS.__delattr__('common')
|
| + FLAGS.__delattr__('commonly')
|
| + FLAGS.__delattr__('zz')
|
| + FLAGS.__delattr__('nozz')
|
| +
|
| + def test_twodasharg_first(self):
|
| + flags.DEFINE_string("twodash_name", "Bob", "namehelp")
|
| + flags.DEFINE_string("twodash_blame", "Rob", "blamehelp")
|
| + argv = ('./program',
|
| + '--',
|
| + '--twodash_name=Harry')
|
| + argv = FLAGS(argv)
|
| + self.assertEqual('Bob', FLAGS.twodash_name)
|
| + self.assertEqual(argv[1], '--twodash_name=Harry')
|
| +
|
| + def test_twodasharg_middle(self):
|
| + flags.DEFINE_string("twodash2_name", "Bob", "namehelp")
|
| + flags.DEFINE_string("twodash2_blame", "Rob", "blamehelp")
|
| + argv = ('./program',
|
| + '--twodash2_blame=Larry',
|
| + '--',
|
| + '--twodash2_name=Harry')
|
| + argv = FLAGS(argv)
|
| + self.assertEqual('Bob', FLAGS.twodash2_name)
|
| + self.assertEqual('Larry', FLAGS.twodash2_blame)
|
| + self.assertEqual(argv[1], '--twodash2_name=Harry')
|
| +
|
| + def test_onedasharg_first(self):
|
| + flags.DEFINE_string("onedash_name", "Bob", "namehelp")
|
| + flags.DEFINE_string("onedash_blame", "Rob", "blamehelp")
|
| + argv = ('./program',
|
| + '-',
|
| + '--onedash_name=Harry')
|
| + argv = FLAGS(argv)
|
| + self.assertEqual(argv[1], '-')
|
| + # TODO(csilvers): we should still parse --onedash_name=Harry as a
|
| + # flag, but currently we don't (we stop flag processing as soon as
|
| + # we see the first non-flag).
|
| +
|
| + def test_unrecognized_flags(self):
|
| + # Unknown flag --nosuchflag
|
| + try:
|
| + argv = ('./program', '--nosuchflag', '--name=Bob', 'extra')
|
| + FLAGS(argv)
|
| + raise AssertionError("Unknown flag exception not raised")
|
| + except flags.UnrecognizedFlag, e:
|
| + assert e.flagname == 'nosuchflag'
|
| +
|
| + # Unknown flag -w (short option)
|
| + try:
|
| + argv = ('./program', '-w', '--name=Bob', 'extra')
|
| + FLAGS(argv)
|
| + raise AssertionError("Unknown flag exception not raised")
|
| + except flags.UnrecognizedFlag, e:
|
| + assert e.flagname == 'w'
|
| +
|
| + # Unknown flag --nosuchflagwithparam=foo
|
| + try:
|
| + argv = ('./program', '--nosuchflagwithparam=foo', '--name=Bob', 'extra')
|
| + FLAGS(argv)
|
| + raise AssertionError("Unknown flag exception not raised")
|
| + except flags.UnrecognizedFlag, e:
|
| + assert e.flagname == 'nosuchflagwithparam'
|
| +
|
| + # Allow unknown flag --nosuchflag if specified with undefok
|
| + argv = ('./program', '--nosuchflag', '--name=Bob',
|
| + '--undefok=nosuchflag', 'extra')
|
| + argv = FLAGS(argv)
|
| + assert len(argv) == 2, "wrong number of arguments pulled"
|
| + assert argv[0]=='./program', "program name not preserved"
|
| + assert argv[1]=='extra', "extra argument not preserved"
|
| +
|
| + # But not if the flagname is misspelled:
|
| + try:
|
| + argv = ('./program', '--nosuchflag', '--name=Bob',
|
| + '--undefok=nosuchfla', 'extra')
|
| + FLAGS(argv)
|
| + raise AssertionError("Unknown flag exception not raised")
|
| + except flags.UnrecognizedFlag, e:
|
| + assert e.flagname == 'nosuchflag'
|
| +
|
| + try:
|
| + argv = ('./program', '--nosuchflag', '--name=Bob',
|
| + '--undefok=nosuchflagg', 'extra')
|
| + FLAGS(argv)
|
| + raise AssertionError("Unknown flag exception not raised")
|
| + except flags.UnrecognizedFlag:
|
| + assert e.flagname == 'nosuchflag'
|
| +
|
| + # Allow unknown short flag -w if specified with undefok
|
| + argv = ('./program', '-w', '--name=Bob', '--undefok=w', 'extra')
|
| + argv = FLAGS(argv)
|
| + assert len(argv) == 2, "wrong number of arguments pulled"
|
| + assert argv[0]=='./program', "program name not preserved"
|
| + assert argv[1]=='extra', "extra argument not preserved"
|
| +
|
| + # Allow unknown flag --nosuchflagwithparam=foo if specified
|
| + # with undefok
|
| + argv = ('./program', '--nosuchflagwithparam=foo', '--name=Bob',
|
| + '--undefok=nosuchflagwithparam', 'extra')
|
| + argv = FLAGS(argv)
|
| + assert len(argv) == 2, "wrong number of arguments pulled"
|
| + assert argv[0]=='./program', "program name not preserved"
|
| + assert argv[1]=='extra', "extra argument not preserved"
|
| +
|
| + # Even if undefok specifies multiple flags
|
| + argv = ('./program', '--nosuchflag', '-w', '--nosuchflagwithparam=foo',
|
| + '--name=Bob',
|
| + '--undefok=nosuchflag,w,nosuchflagwithparam',
|
| + 'extra')
|
| + argv = FLAGS(argv)
|
| + assert len(argv) == 2, "wrong number of arguments pulled"
|
| + assert argv[0]=='./program', "program name not preserved"
|
| + assert argv[1]=='extra', "extra argument not preserved"
|
| +
|
| + # However, not if undefok doesn't specify the flag
|
| + try:
|
| + argv = ('./program', '--nosuchflag', '--name=Bob',
|
| + '--undefok=another_such', 'extra')
|
| + FLAGS(argv)
|
| + raise AssertionError("Unknown flag exception not raised")
|
| + except flags.UnrecognizedFlag, e:
|
| + assert e.flagname == 'nosuchflag'
|
| +
|
| + # Make sure --undefok doesn't mask other option errors.
|
| + try:
|
| + # Provide an option requiring a parameter but not giving it one.
|
| + argv = ('./program', '--undefok=name', '--name')
|
| + FLAGS(argv)
|
| + raise AssertionError("Missing option parameter exception not raised")
|
| + except flags.UnrecognizedFlag:
|
| + raise AssertionError("Wrong kind of error exception raised")
|
| + except flags.FlagsError:
|
| + pass
|
| +
|
| + # Test --undefok <list>
|
| + argv = ('./program', '--nosuchflag', '-w', '--nosuchflagwithparam=foo',
|
| + '--name=Bob',
|
| + '--undefok',
|
| + 'nosuchflag,w,nosuchflagwithparam',
|
| + 'extra')
|
| + argv = FLAGS(argv)
|
| + assert len(argv) == 2, "wrong number of arguments pulled"
|
| + assert argv[0]=='./program', "program name not preserved"
|
| + assert argv[1]=='extra', "extra argument not preserved"
|
| +
|
| + def test_nonglobal_flags(self):
|
| + """Test use of non-global FlagValues"""
|
| + nonglobal_flags = flags.FlagValues()
|
| + flags.DEFINE_string("nonglobal_flag", "Bob", "flaghelp", nonglobal_flags)
|
| + argv = ('./program',
|
| + '--nonglobal_flag=Mary',
|
| + 'extra')
|
| + argv = nonglobal_flags(argv)
|
| + assert len(argv) == 2, "wrong number of arguments pulled"
|
| + assert argv[0]=='./program', "program name not preserved"
|
| + assert argv[1]=='extra', "extra argument not preserved"
|
| + assert nonglobal_flags['nonglobal_flag'].value == 'Mary'
|
| +
|
| + def test_unrecognized_nonglobal_flags(self):
|
| + """Test unrecognized non-global flags"""
|
| + nonglobal_flags = flags.FlagValues()
|
| + argv = ('./program',
|
| + '--nosuchflag')
|
| + try:
|
| + argv = nonglobal_flags(argv)
|
| + raise AssertionError("Unknown flag exception not raised")
|
| + except flags.UnrecognizedFlag, e:
|
| + assert e.flagname == 'nosuchflag'
|
| + pass
|
| +
|
| + argv = ('./program',
|
| + '--nosuchflag',
|
| + '--undefok=nosuchflag')
|
| +
|
| + argv = nonglobal_flags(argv)
|
| + assert len(argv) == 1, "wrong number of arguments pulled"
|
| + assert argv[0]=='./program', "program name not preserved"
|
| +
|
| + def test_main_module_help(self):
|
| + """Test MainModuleHelp()"""
|
| + help = FLAGS.MainModuleHelp()
|
| +
|
| + # When this test is invoked on behalf of flags_unittest_2_2,
|
| + # the main module has not defined any flags. Since there's
|
| + # no easy way to run this script in our test environment
|
| + # directly from python2.2, don't bother to test the output
|
| + # of MainModuleHelp() in that scenario.
|
| + if sys.version.startswith('2.2.'):
|
| + return
|
| +
|
| + expected_help = "\n" + sys.argv[0] + ':' + """
|
| + --[no]debug: debughelp
|
| + (default: 'false')
|
| + -u,--[no]dup1: runhelp d12
|
| + (default: 'true')
|
| + -u,--[no]dup2: runhelp d22
|
| + (default: 'true')
|
| + -u,--[no]dup3: runhelp d32
|
| + (default: 'true')
|
| + --[no]dup4: runhelp d41
|
| + (default: 'false')
|
| + -?,--[no]help: show this help
|
| + --[no]helpshort: show usage only for this module
|
| + --kwery: <who|what|why|where|when>: ?
|
| + --l: how long to be
|
| + (default: '9223372032559808512')
|
| + (an integer)
|
| + --letters: a list of letters
|
| + (default: 'a,b,c')
|
| + (a comma separated list)
|
| + -m,--m_str: string option that can occur multiple times;
|
| + repeat this option to specify a list of values
|
| + (default: "['def1', 'def2']")
|
| + --name: namehelp
|
| + (default: 'Bob')
|
| + --[no]noexec: boolean flag with no as prefix
|
| + (default: 'true')
|
| + --[no]q: quiet mode
|
| + (default: 'true')
|
| + --[no]quack: superstring of 'q'
|
| + (default: 'false')
|
| + -r,--repeat: how many times to repeat (0-5)
|
| + (default: '4')
|
| + (a non-negative integer)
|
| + -s,--s_str: string option that can occur multiple times;
|
| + repeat this option to specify a list of values
|
| + (default: "['sing1']")
|
| + --[no]test0: test boolean parsing
|
| + --[no]test1: test boolean parsing
|
| + --[no]testget1: test parsing with defaults
|
| + --[no]testget2: test parsing with defaults
|
| + --[no]testget3: test parsing with defaults
|
| + --testget4: test parsing with defaults
|
| + (an integer)
|
| + --testlist: test lists parsing
|
| + (default: '')
|
| + (a comma separated list)
|
| + --[no]testnone: test boolean parsing
|
| + --testspacelist: tests space lists parsing
|
| + (default: '')
|
| + (a whitespace separated list)
|
| + --x: how eXtreme to be
|
| + (default: '3')
|
| + (an integer)
|
| + -z,--[no]zoom1: runhelp z1
|
| + (default: 'false')"""
|
| +
|
| + if not MultiLineEqual(expected_help, help):
|
| + self.fail()
|
| +
|
| + def test_create_flag_errors(self):
|
| + # Since the exception classes are exposed, nothing stops users
|
| + # from creating their own instances. This test makes sure that
|
| + # people modifying the flags module understand that the external
|
| + # mechanisms for creating the exceptions should continue to work.
|
| + e = flags.FlagsError()
|
| + e = flags.FlagsError("message")
|
| + e = flags.DuplicateFlag()
|
| + e = flags.DuplicateFlag("message")
|
| + e = flags.IllegalFlagValue()
|
| + e = flags.IllegalFlagValue("message")
|
| + e = flags.UnrecognizedFlag()
|
| + e = flags.UnrecognizedFlag("message")
|
| +
|
| +def main():
|
| + unittest.main()
|
| +
|
| +if __name__ == '__main__':
|
| + main()
|
|
|
| Property changes on: tools/nixysa/third_party/gflags-1.0/python/gflags_unittest.py
|
| ___________________________________________________________________
|
| Added: svn:executable
|
| + *
|
| Added: svn:eol-style
|
| + LF
|
|
|
|
|
Chromium Code Reviews
