| #!/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() |
