werunplugged/unplugged-system
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
06ee9615ad
unplugged-system/external/python/absl-py/absl/flags/tests/flags_test.py

3022 lines
110 KiB
Python
Raw Blame History

# Copyright 2017 The Abseil Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tests for absl.flags used as a package."""
import contextlib
import enum
import io
import os
import shutil
import sys
import tempfile
import unittest
from absl import flags
from absl.flags import _exceptions
from absl.flags import _helpers
from absl.flags.tests import module_bar
from absl.flags.tests import module_baz
from absl.flags.tests import module_foo
from absl.testing import absltest
FLAGS = flags.FLAGS
@contextlib.contextmanager
def _use_gnu_getopt(flag_values, use_gnu_get_opt):
old_use_gnu_get_opt = flag_values.is_gnu_getopt()
flag_values.set_gnu_getopt(use_gnu_get_opt)
yield
flag_values.set_gnu_getopt(old_use_gnu_get_opt)
class FlagDictToArgsTest(absltest.TestCase):
def test_flatten_google_flag_map(self):
arg_dict = {
'week-end': None,
'estudia': False,
'trabaja': False,
'party': True,
'monday': 'party',
'score': 42,
'loadthatstuff': [42, 'hello', 'goodbye'],
}
self.assertSameElements(
('--week-end', '--noestudia', '--notrabaja', '--party',
'--monday=party', '--score=42', '--loadthatstuff=42,hello,goodbye'),
flags.flag_dict_to_args(arg_dict))
def test_flatten_google_flag_map_with_multi_flag(self):
arg_dict = {
'some_list': ['value1', 'value2'],
'some_multi_string': ['value3', 'value4'],
}
self.assertSameElements(
('--some_list=value1,value2', '--some_multi_string=value3',
'--some_multi_string=value4'),
flags.flag_dict_to_args(arg_dict, multi_flags={'some_multi_string'}))
class Fruit(enum.Enum):
APPLE = object()
ORANGE = object()
class CaseSensitiveFruit(enum.Enum):
apple = 1
orange = 2
APPLE = 3
class EmptyEnum(enum.Enum):
pass
class AliasFlagsTest(absltest.TestCase):
def setUp(self):
super(AliasFlagsTest, self).setUp()
self.flags = flags.FlagValues()
@property
def alias(self):
return self.flags['alias']
@property
def aliased(self):
return self.flags['aliased']
def define_alias(self, *args, **kwargs):
flags.DEFINE_alias(*args, flag_values=self.flags, **kwargs)
def define_integer(self, *args, **kwargs):
flags.DEFINE_integer(*args, flag_values=self.flags, **kwargs)
def define_multi_integer(self, *args, **kwargs):
flags.DEFINE_multi_integer(*args, flag_values=self.flags, **kwargs)
def define_string(self, *args, **kwargs):
flags.DEFINE_string(*args, flag_values=self.flags, **kwargs)
def assert_alias_mirrors_aliased(self, alias, aliased, ignore_due_to_bug=()):
# A few sanity checks to avoid false success
self.assertIn('FlagAlias', alias.__class__.__qualname__)
self.assertIsNot(alias, aliased)
self.assertNotEqual(aliased.name, alias.name)
alias_state = {}
aliased_state = {}
attrs = {
'allow_hide_cpp',
'allow_override',
'allow_override_cpp',
'allow_overwrite',
'allow_using_method_names',
'boolean',
'default',
'default_as_str',
'default_unparsed',
# TODO(rlevasseur): This should match, but a bug prevents it from being
# in sync.
# 'using_default_value',
'value',
}
attrs.difference_update(ignore_due_to_bug)
for attr in attrs:
alias_state[attr] = getattr(alias, attr)
aliased_state[attr] = getattr(aliased, attr)
self.assertEqual(aliased_state, alias_state, 'LHS is aliased; RHS is alias')
def test_serialize_multi(self):
self.define_multi_integer('aliased', [0, 1], '')
self.define_alias('alias', 'aliased')
actual = self.alias.serialize()
# TODO(rlevasseur): This should check for --alias=0\n--alias=1, but
# a bug causes it to serialize incorrectly.
self.assertEqual('--alias=[0, 1]', actual)
def test_allow_overwrite_false(self):
self.define_integer('aliased', None, 'help', allow_overwrite=False)
self.define_alias('alias', 'aliased')
with self.assertRaisesRegex(flags.IllegalFlagValueError, 'already defined'):
self.flags(['./program', '--alias=1', '--aliased=2'])
self.assertEqual(1, self.alias.value)
self.assertEqual(1, self.aliased.value)
def test_aliasing_multi_no_default(self):
def define_flags():
self.flags = flags.FlagValues()
self.define_multi_integer('aliased', None, 'help')
self.define_alias('alias', 'aliased')
with self.subTest('after defining'):
define_flags()
self.assert_alias_mirrors_aliased(self.alias, self.aliased)
self.assertIsNone(self.alias.value)
with self.subTest('set alias'):
define_flags()
self.flags(['./program', '--alias=1', '--alias=2'])
self.assertEqual([1, 2], self.alias.value)
self.assert_alias_mirrors_aliased(self.alias, self.aliased)
with self.subTest('set aliased'):
define_flags()
self.flags(['./program', '--aliased=1', '--aliased=2'])
self.assertEqual([1, 2], self.alias.value)
self.assert_alias_mirrors_aliased(self.alias, self.aliased)
with self.subTest('not setting anything'):
define_flags()
self.flags(['./program'])
self.assertEqual(None, self.alias.value)
self.assert_alias_mirrors_aliased(self.alias, self.aliased)
def test_aliasing_multi_with_default(self):
def define_flags():
self.flags = flags.FlagValues()
self.define_multi_integer('aliased', [0], 'help')
self.define_alias('alias', 'aliased')
with self.subTest('after defining'):
define_flags()
self.assertEqual([0], self.alias.default)
self.assert_alias_mirrors_aliased(self.alias, self.aliased)
with self.subTest('set alias'):
define_flags()
self.flags(['./program', '--alias=1', '--alias=2'])
self.assertEqual([1, 2], self.alias.value)
self.assert_alias_mirrors_aliased(self.alias, self.aliased)
self.assertEqual(2, self.alias.present)
# TODO(rlevasseur): This should assert 0, but a bug with aliases and
# MultiFlag causes the alias to increment aliased's present counter.
self.assertEqual(2, self.aliased.present)
with self.subTest('set aliased'):
define_flags()
self.flags(['./program', '--aliased=1', '--aliased=2'])
self.assertEqual([1, 2], self.alias.value)
self.assert_alias_mirrors_aliased(self.alias, self.aliased)
self.assertEqual(0, self.alias.present)
# TODO(rlevasseur): This should assert 0, but a bug with aliases and
# MultiFlag causes the alias to increment aliased present counter.
self.assertEqual(2, self.aliased.present)
with self.subTest('not setting anything'):
define_flags()
self.flags(['./program'])
self.assertEqual([0], self.alias.value)
self.assert_alias_mirrors_aliased(self.alias, self.aliased)
self.assertEqual(0, self.alias.present)
self.assertEqual(0, self.aliased.present)
def test_aliasing_regular(self):
def define_flags():
self.flags = flags.FlagValues()
self.define_string('aliased', '', 'help')
self.define_alias('alias', 'aliased')
define_flags()
self.assert_alias_mirrors_aliased(self.alias, self.aliased)
self.flags(['./program', '--alias=1'])
self.assertEqual('1', self.alias.value)
self.assert_alias_mirrors_aliased(self.alias, self.aliased)
self.assertEqual(1, self.alias.present)
self.assertEqual('--alias=1', self.alias.serialize())
self.assertEqual(1, self.aliased.present)
define_flags()
self.flags(['./program', '--aliased=2'])
self.assertEqual('2', self.alias.value)
self.assert_alias_mirrors_aliased(self.alias, self.aliased)
self.assertEqual(0, self.alias.present)
self.assertEqual('--alias=2', self.alias.serialize())
self.assertEqual(1, self.aliased.present)
def test_defining_alias_doesnt_affect_aliased_state_regular(self):
self.define_string('aliased', 'default', 'help')
self.define_alias('alias', 'aliased')
self.assertEqual(0, self.aliased.present)
self.assertEqual(0, self.alias.present)
def test_defining_alias_doesnt_affect_aliased_state_multi(self):
self.define_multi_integer('aliased', [0], 'help')
self.define_alias('alias', 'aliased')
self.assertEqual([0], self.aliased.value)
self.assertEqual([0], self.aliased.default)
self.assertEqual(0, self.aliased.present)
self.assertEqual([0], self.aliased.value)
self.assertEqual([0], self.aliased.default)
self.assertEqual(0, self.alias.present)
class FlagsUnitTest(absltest.TestCase):
"""Flags Unit Test."""
maxDiff = None
def test_flags(self):
"""Test normal usage with no (expected) errors."""
# Define flags
number_test_framework_flags = len(FLAGS)
repeat_help = 'how many times to repeat (0-5)'
flags.DEFINE_integer(
'repeat', 4, repeat_help, 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_float('float', 3.14, 'using floats')
flags.DEFINE_integer('octal', '0o666', 'using octals')
flags.DEFINE_integer('decimal', '666', 'using decimals')
flags.DEFINE_integer('hexadecimal', '0x666', 'using hexadecimals')
flags.DEFINE_integer('x', 3, 'how eXtreme to be')
flags.DEFINE_integer('l', 0x7fffffff00000000, 'how long to be')
flags.DEFINE_list('args', 'v=1,"vmodule=a=0,b=2"', 'a list of arguments')
flags.DEFINE_list('letters', 'a,b,c', 'a list of letters')
flags.DEFINE_list('numbers', [1, 2, 3], 'a list of numbers')
flags.DEFINE_enum('kwery', None, ['who', 'what', 'Why', 'where', 'when'],
'?')
flags.DEFINE_enum(
'sense', None, ['Case', 'case', 'CASE'], '?', case_sensitive=True)
flags.DEFINE_enum(
'cases',
None, ['UPPER', 'lower', 'Initial', 'Ot_HeR'],
'?',
case_sensitive=False)
flags.DEFINE_enum(
'funny',
None, ['Joke', 'ha', 'ha', 'ha', 'ha'],
'?',
case_sensitive=True)
flags.DEFINE_enum(
'blah',
None, ['bla', 'Blah', 'BLAH', 'blah'],
'?',
case_sensitive=False)
flags.DEFINE_string(
'only_once', None, 'test only sets this once', allow_overwrite=False)
flags.DEFINE_string(
'universe',
None,
'test tries to set this three times',
allow_overwrite=False)
# Specify number of flags defined above. The short_name defined
# for 'repeat' counts as an extra flag.
number_defined_flags = 22 + 1
self.assertLen(FLAGS, number_defined_flags + number_test_framework_flags)
self.assertEqual(FLAGS.repeat, 4)
self.assertEqual(FLAGS.name, 'Bob')
self.assertEqual(FLAGS.debug, 0)
self.assertEqual(FLAGS.q, 1)
self.assertEqual(FLAGS.octal, 0o666)
self.assertEqual(FLAGS.decimal, 666)
self.assertEqual(FLAGS.hexadecimal, 0x666)
self.assertEqual(FLAGS.x, 3)
self.assertEqual(FLAGS.l, 0x7fffffff00000000)
self.assertEqual(FLAGS.args, ['v=1', 'vmodule=a=0,b=2'])
self.assertEqual(FLAGS.letters, ['a', 'b', 'c'])
self.assertEqual(FLAGS.numbers, [1, 2, 3])
self.assertIsNone(FLAGS.kwery)
self.assertIsNone(FLAGS.sense)
self.assertIsNone(FLAGS.cases)
self.assertIsNone(FLAGS.funny)
self.assertIsNone(FLAGS.blah)
flag_values = FLAGS.flag_values_dict()
self.assertEqual(flag_values['repeat'], 4)
self.assertEqual(flag_values['name'], 'Bob')
self.assertEqual(flag_values['debug'], 0)
self.assertEqual(flag_values['r'], 4) # Short for repeat.
self.assertEqual(flag_values['q'], 1)
self.assertEqual(flag_values['quack'], 0)
self.assertEqual(flag_values['x'], 3)
self.assertEqual(flag_values['l'], 0x7fffffff00000000)
self.assertEqual(flag_values['args'], ['v=1', 'vmodule=a=0,b=2'])
self.assertEqual(flag_values['letters'], ['a', 'b', 'c'])
self.assertEqual(flag_values['numbers'], [1, 2, 3])
self.assertIsNone(flag_values['kwery'])
self.assertIsNone(flag_values['sense'])
self.assertIsNone(flag_values['cases'])
self.assertIsNone(flag_values['funny'])
self.assertIsNone(flag_values['blah'])
# Verify string form of defaults
self.assertEqual(FLAGS['repeat'].default_as_str, "'4'")
self.assertEqual(FLAGS['name'].default_as_str, "'Bob'")
self.assertEqual(FLAGS['debug'].default_as_str, "'false'")
self.assertEqual(FLAGS['q'].default_as_str, "'true'")
self.assertEqual(FLAGS['quack'].default_as_str, "'false'")
self.assertEqual(FLAGS['noexec'].default_as_str, "'true'")
self.assertEqual(FLAGS['x'].default_as_str, "'3'")
self.assertEqual(FLAGS['l'].default_as_str, "'9223372032559808512'")
self.assertEqual(FLAGS['args'].default_as_str, '\'v=1,"vmodule=a=0,b=2"\'')
self.assertEqual(FLAGS['letters'].default_as_str, "'a,b,c'")
self.assertEqual(FLAGS['numbers'].default_as_str, "'1,2,3'")
# Verify that the iterator for flags yields all the keys
keys = list(FLAGS)
keys.sort()
reg_flags = list(FLAGS._flags())
reg_flags.sort()
self.assertEqual(keys, reg_flags)
# Parse flags
# .. empty command line
argv = ('./program',)
argv = FLAGS(argv)
self.assertLen(argv, 1, 'wrong number of arguments pulled')
self.assertEqual(argv[0], './program', 'program name not preserved')
# .. non-empty command line
argv = ('./program', '--debug', '--name=Bob', '-q', '--x=8')
argv = FLAGS(argv)
self.assertLen(argv, 1, 'wrong number of arguments pulled')
self.assertEqual(argv[0], './program', 'program name not preserved')
self.assertEqual(FLAGS['debug'].present, 1)
FLAGS['debug'].present = 0 # Reset
self.assertEqual(FLAGS['name'].present, 1)
FLAGS['name'].present = 0 # Reset
self.assertEqual(FLAGS['q'].present, 1)
FLAGS['q'].present = 0 # Reset
self.assertEqual(FLAGS['x'].present, 1)
FLAGS['x'].present = 0 # Reset
# Flags list.
self.assertLen(FLAGS, number_defined_flags + number_test_framework_flags)
self.assertIn('name', FLAGS)
self.assertIn('debug', FLAGS)
self.assertIn('repeat', FLAGS)
self.assertIn('r', FLAGS)
self.assertIn('q', FLAGS)
self.assertIn('quack', FLAGS)
self.assertIn('x', FLAGS)
self.assertIn('l', FLAGS)
self.assertIn('args', FLAGS)
self.assertIn('letters', FLAGS)
self.assertIn('numbers', FLAGS)
# __contains__
self.assertIn('name', FLAGS)
self.assertNotIn('name2', FLAGS)
# try deleting a flag
del FLAGS.r
self.assertLen(FLAGS,
number_defined_flags - 1 + number_test_framework_flags)
self.assertNotIn('r', FLAGS)
# .. command line with extra stuff
argv = ('./program', '--debug', '--name=Bob', 'extra')
argv = FLAGS(argv)
self.assertLen(argv, 2, 'wrong number of arguments pulled')
self.assertEqual(argv[0], './program', 'program name not preserved')
self.assertEqual(argv[1], 'extra', 'extra argument not preserved')
self.assertEqual(FLAGS['debug'].present, 1)
FLAGS['debug'].present = 0 # Reset
self.assertEqual(FLAGS['name'].present, 1)
FLAGS['name'].present = 0 # Reset
# Test reset
argv = ('./program', '--debug')
argv = FLAGS(argv)
self.assertLen(argv, 1, 'wrong number of arguments pulled')
self.assertEqual(argv[0], './program', 'program name not preserved')
self.assertEqual(FLAGS['debug'].present, 1)
self.assertTrue(FLAGS['debug'].value)
FLAGS.unparse_flags()
self.assertEqual(FLAGS['debug'].present, 0)
self.assertFalse(FLAGS['debug'].value)
# Test that reset restores default value when default value is None.
argv = ('./program', '--kwery=who')
argv = FLAGS(argv)
self.assertLen(argv, 1, 'wrong number of arguments pulled')
self.assertEqual(argv[0], './program', 'program name not preserved')
self.assertEqual(FLAGS['kwery'].present, 1)
self.assertEqual(FLAGS['kwery'].value, 'who')
FLAGS.unparse_flags()
argv = ('./program', '--kwery=Why')
argv = FLAGS(argv)
self.assertLen(argv, 1, 'wrong number of arguments pulled')
self.assertEqual(argv[0], './program', 'program name not preserved')
self.assertEqual(FLAGS['kwery'].present, 1)
self.assertEqual(FLAGS['kwery'].value, 'Why')
FLAGS.unparse_flags()
self.assertEqual(FLAGS['kwery'].present, 0)
self.assertIsNone(FLAGS['kwery'].value)
# Test case sensitive enum.
argv = ('./program', '--sense=CASE')
argv = FLAGS(argv)
self.assertLen(argv, 1, 'wrong number of arguments pulled')
self.assertEqual(argv[0], './program', 'program name not preserved')
self.assertEqual(FLAGS['sense'].present, 1)
self.assertEqual(FLAGS['sense'].value, 'CASE')
FLAGS.unparse_flags()
argv = ('./program', '--sense=Case')
argv = FLAGS(argv)
self.assertLen(argv, 1, 'wrong number of arguments pulled')
self.assertEqual(argv[0], './program', 'program name not preserved')
self.assertEqual(FLAGS['sense'].present, 1)
self.assertEqual(FLAGS['sense'].value, 'Case')
FLAGS.unparse_flags()
# Test case insensitive enum.
argv = ('./program', '--cases=upper')
argv = FLAGS(argv)
self.assertLen(argv, 1, 'wrong number of arguments pulled')
self.assertEqual(argv[0], './program', 'program name not preserved')
self.assertEqual(FLAGS['cases'].present, 1)
self.assertEqual(FLAGS['cases'].value, 'UPPER')
FLAGS.unparse_flags()
# Test case sensitive enum with duplicates.
argv = ('./program', '--funny=ha')
argv = FLAGS(argv)
self.assertLen(argv, 1, 'wrong number of arguments pulled')
self.assertEqual(argv[0], './program', 'program name not preserved')
self.assertEqual(FLAGS['funny'].present, 1)
self.assertEqual(FLAGS['funny'].value, 'ha')
FLAGS.unparse_flags()
# Test case insensitive enum with duplicates.
argv = ('./program', '--blah=bLah')
argv = FLAGS(argv)
self.assertLen(argv, 1, 'wrong number of arguments pulled')
self.assertEqual(argv[0], './program', 'program name not preserved')
self.assertEqual(FLAGS['blah'].present, 1)
self.assertEqual(FLAGS['blah'].value, 'Blah')
FLAGS.unparse_flags()
argv = ('./program', '--blah=BLAH')
argv = FLAGS(argv)
self.assertLen(argv, 1, 'wrong number of arguments pulled')
self.assertEqual(argv[0], './program', 'program name not preserved')
self.assertEqual(FLAGS['blah'].present, 1)
self.assertEqual(FLAGS['blah'].value, 'Blah')
FLAGS.unparse_flags()
# Test integer argument passing
argv = ('./program', '--x', '0x12345')
argv = FLAGS(argv)
self.assertEqual(FLAGS.x, 0x12345)
self.assertEqual(type(FLAGS.x), int)
argv = ('./program', '--x', '0x1234567890ABCDEF1234567890ABCDEF')
argv = FLAGS(argv)
self.assertEqual(FLAGS.x, 0x1234567890ABCDEF1234567890ABCDEF)
self.assertIsInstance(FLAGS.x, int)
argv = ('./program', '--x', '0o12345')
argv = FLAGS(argv)
self.assertEqual(FLAGS.x, 0o12345)
self.assertEqual(type(FLAGS.x), int)
# Treat 0-prefixed parameters as base-10, not base-8
argv = ('./program', '--x', '012345')
argv = FLAGS(argv)
self.assertEqual(FLAGS.x, 12345)
self.assertEqual(type(FLAGS.x), int)
argv = ('./program', '--x', '0123459')
argv = FLAGS(argv)
self.assertEqual(FLAGS.x, 123459)
self.assertEqual(type(FLAGS.x), int)
argv = ('./program', '--x', '0x123efg')
with self.assertRaises(flags.IllegalFlagValueError):
argv = FLAGS(argv)
# Test boolean argument parsing
flags.DEFINE_boolean('test0', None, 'test boolean parsing')
argv = ('./program', '--notest0')
argv = FLAGS(argv)
self.assertEqual(FLAGS.test0, 0)
flags.DEFINE_boolean('test1', None, 'test boolean parsing')
argv = ('./program', '--test1')
argv = FLAGS(argv)
self.assertEqual(FLAGS.test1, 1)
FLAGS.test0 = None
argv = ('./program', '--test0=false')
argv = FLAGS(argv)
self.assertEqual(FLAGS.test0, 0)
FLAGS.test1 = None
argv = ('./program', '--test1=true')
argv = FLAGS(argv)
self.assertEqual(FLAGS.test1, 1)
FLAGS.test0 = None
argv = ('./program', '--test0=0')
argv = FLAGS(argv)
self.assertEqual(FLAGS.test0, 0)
FLAGS.test1 = None
argv = ('./program', '--test1=1')
argv = FLAGS(argv)
self.assertEqual(FLAGS.test1, 1)
# Test booleans that already have 'no' as a prefix
FLAGS.noexec = None
argv = ('./program', '--nonoexec', '--name', 'Bob')
argv = FLAGS(argv)
self.assertEqual(FLAGS.noexec, 0)
FLAGS.noexec = None
argv = ('./program', '--name', 'Bob', '--noexec')
argv = FLAGS(argv)
self.assertEqual(FLAGS.noexec, 1)
# Test unassigned booleans
flags.DEFINE_boolean('testnone', None, 'test boolean parsing')
argv = ('./program',)
argv = FLAGS(argv)
self.assertIsNone(FLAGS.testnone)
# 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)
self.assertEqual(FLAGS.get_flag_value('testget1', 'foo'), 1)
self.assertEqual(FLAGS.get_flag_value('testget2', 'foo'), 0)
self.assertEqual(FLAGS.get_flag_value('testget3', 'foo'), 'foo')
self.assertEqual(FLAGS.get_flag_value('testget4', 'foo'), 'foo')
# test list code
lists = [['hello', 'moo', 'boo', '1'], []]
flags.DEFINE_list('testcomma_list', '', 'test comma list parsing')
flags.DEFINE_spaceseplist('testspace_list', '', 'tests space list parsing')
flags.DEFINE_spaceseplist(
'testspace_or_comma_list',
'',
'tests space list parsing with comma compatibility',
comma_compat=True)
for name, sep in (('testcomma_list', ','), ('testspace_list',
' '), ('testspace_list', '\n'),
('testspace_or_comma_list',
' '), ('testspace_or_comma_list',
'\n'), ('testspace_or_comma_list', ',')):
for lst in lists:
argv = ('./program', '--%s=%s' % (name, sep.join(lst)))
argv = FLAGS(argv)
self.assertEqual(getattr(FLAGS, name), lst)
# Test help text
flags_help = str(FLAGS)
self.assertNotEqual(
flags_help.find('repeat'), -1, 'cannot find flag in help')
self.assertNotEqual(
flags_help.find(repeat_help), -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_flag_value('repeat', None), 2)
self.assertEqual(FLAGS.get_flag_value('debug', None), 0)
# Test MultiFlag with single default value
flags.DEFINE_multi_string(
's_str',
'sing1',
'string option that can occur multiple times',
short_name='s')
self.assertEqual(FLAGS.get_flag_value('s_str', None), ['sing1'])
# Test MultiFlag with list of default values
multi_string_defs = ['def1', 'def2']
flags.DEFINE_multi_string(
'm_str',
multi_string_defs,
'string option that can occur multiple times',
short_name='m')
self.assertEqual(FLAGS.get_flag_value('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_flag_value('m_str', None), ['str1', 'str2'])
# A flag with allow_overwrite set to False should behave normally when it
# is only specified once
argv = ('./program', '--only_once=singlevalue')
argv = FLAGS(argv)
self.assertEqual(FLAGS.get_flag_value('only_once', None), 'singlevalue')
# A flag with allow_overwrite set to False should complain when it is
# specified more than once
argv = ('./program', '--universe=ptolemaic', '--universe=copernicean',
'--universe=euclidean')
self.assertRaisesWithLiteralMatch(
flags.IllegalFlagValueError,
'flag --universe=copernicean: already defined as ptolemaic', FLAGS,
argv)
# Test single-letter flags; should support both single and double dash
argv = ('./program', '-q')
argv = FLAGS(argv)
self.assertEqual(FLAGS.get_flag_value('q', None), 1)
argv = ('./program', '--q', '--x', '9', '--noquack')
argv = FLAGS(argv)
self.assertEqual(FLAGS.get_flag_value('q', None), 1)
self.assertEqual(FLAGS.get_flag_value('x', None), 9)
self.assertEqual(FLAGS.get_flag_value('quack', None), 0)
argv = ('./program', '--noq', '--x=10', '--quack')
argv = FLAGS(argv)
self.assertEqual(FLAGS.get_flag_value('q', None), 0)
self.assertEqual(FLAGS.get_flag_value('x', None), 10)
self.assertEqual(FLAGS.get_flag_value('quack', None), 1)
####################################
# Test flag serialization code:
old_testcomma_list = FLAGS.testcomma_list
old_testspace_list = FLAGS.testspace_list
old_testspace_or_comma_list = FLAGS.testspace_or_comma_list
argv = ('./program', FLAGS['test0'].serialize(), FLAGS['test1'].serialize(),
FLAGS['s_str'].serialize())
argv = FLAGS(argv)
self.assertEqual(FLAGS['test0'].serialize(), '--notest0')
self.assertEqual(FLAGS['test1'].serialize(), '--test1')
self.assertEqual(FLAGS['s_str'].serialize(), '--s_str=sing1')
self.assertEqual(FLAGS['testnone'].serialize(), '')
testcomma_list1 = ['aa', 'bb']
testspace_list1 = ['aa', 'bb', 'cc']
testspace_or_comma_list1 = ['aa', 'bb', 'cc', 'dd']
FLAGS.testcomma_list = list(testcomma_list1)
FLAGS.testspace_list = list(testspace_list1)
FLAGS.testspace_or_comma_list = list(testspace_or_comma_list1)
argv = ('./program', FLAGS['testcomma_list'].serialize(),
FLAGS['testspace_list'].serialize(),
FLAGS['testspace_or_comma_list'].serialize())
argv = FLAGS(argv)
self.assertEqual(FLAGS.testcomma_list, testcomma_list1)
self.assertEqual(FLAGS.testspace_list, testspace_list1)
self.assertEqual(FLAGS.testspace_or_comma_list, testspace_or_comma_list1)
testcomma_list1 = ['aa some spaces', 'bb']
testspace_list1 = ['aa', 'bb,some,commas,', 'cc']
testspace_or_comma_list1 = ['aa', 'bb,some,commas,', 'cc']
FLAGS.testcomma_list = list(testcomma_list1)
FLAGS.testspace_list = list(testspace_list1)
FLAGS.testspace_or_comma_list = list(testspace_or_comma_list1)
argv = ('./program', FLAGS['testcomma_list'].serialize(),
FLAGS['testspace_list'].serialize(),
FLAGS['testspace_or_comma_list'].serialize())
argv = FLAGS(argv)
self.assertEqual(FLAGS.testcomma_list, testcomma_list1)
self.assertEqual(FLAGS.testspace_list, testspace_list1)
# We don't expect idempotency when commas are placed in an item value and
# comma_compat is enabled.
self.assertEqual(FLAGS.testspace_or_comma_list,
['aa', 'bb', 'some', 'commas', 'cc'])
FLAGS.testcomma_list = old_testcomma_list
FLAGS.testspace_list = old_testspace_list
FLAGS.testspace_or_comma_list = old_testspace_or_comma_list
####################################
# Test flag-update:
def args_list():
# Exclude flags that have different default values based on the
# environment.
flags_to_exclude = {'log_dir', 'test_srcdir', 'test_tmpdir'}
flagnames = set(FLAGS) - flags_to_exclude
nonbool_flags = []
truebool_flags = []
falsebool_flags = []
for name in flagnames:
flag_value = FLAGS.get_flag_value(name, None)
if not isinstance(FLAGS[name], flags.BooleanFlag):
nonbool_flags.append('--%s %s' % (name, flag_value))
elif flag_value:
truebool_flags.append('--%s' % name)
else:
falsebool_flags.append('--no%s' % name)
all_flags = nonbool_flags + truebool_flags + falsebool_flags
all_flags.sort()
return all_flags
argv = ('./program', '--repeat=3', '--name=giants', '--nodebug')
FLAGS(argv)
self.assertEqual(FLAGS.get_flag_value('repeat', None), 3)
self.assertEqual(FLAGS.get_flag_value('name', None), 'giants')
self.assertEqual(FLAGS.get_flag_value('debug', None), 0)
self.assertListEqual([
'--alsologtostderr',
"--args ['v=1', 'vmodule=a=0,b=2']",
'--blah None',
'--cases None',
'--decimal 666',
'--float 3.14',
'--funny None',
'--hexadecimal 1638',
'--kwery None',
'--l 9223372032559808512',
"--letters ['a', 'b', 'c']",
'--logger_levels {}',
"--m ['str1', 'str2']",
"--m_str ['str1', 'str2']",
'--name giants',
'--no?',
'--nodebug',
'--noexec',
'--nohelp',
'--nohelpfull',
'--nohelpshort',
'--nohelpxml',
'--nologtostderr',
'--noonly_check_args',
'--nopdb_post_mortem',
'--noq',
'--norun_with_pdb',
'--norun_with_profiling',
'--notest0',
'--notestget2',
'--notestget3',
'--notestnone',
'--numbers [1, 2, 3]',
'--octal 438',
'--only_once singlevalue',
'--pdb False',
'--profile_file None',
'--quack',
'--repeat 3',
"--s ['sing1']",
"--s_str ['sing1']",
'--sense None',
'--showprefixforinfo',
'--stderrthreshold fatal',
'--test1',
'--test_random_seed 301',
'--test_randomize_ordering_seed ',
'--testcomma_list []',
'--testget1',
'--testget4 None',
'--testspace_list []',
'--testspace_or_comma_list []',
'--tmod_baz_x',
'--universe ptolemaic',
'--use_cprofile_for_profiling',
'--v -1',
'--verbosity -1',
'--x 10',
'--xml_output_file ',
], args_list())
argv = ('./program', '--debug', '--m_str=upd1', '-s', 'upd2')
FLAGS(argv)
self.assertEqual(FLAGS.get_flag_value('repeat', None), 3)
self.assertEqual(FLAGS.get_flag_value('name', None), 'giants')
self.assertEqual(FLAGS.get_flag_value('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.assertListEqual([
'--alsologtostderr',
"--args ['v=1', 'vmodule=a=0,b=2']",
'--blah None',
'--cases None',
'--debug',
'--decimal 666',
'--float 3.14',
'--funny None',
'--hexadecimal 1638',
'--kwery None',
'--l 9223372032559808512',
"--letters ['a', 'b', 'c']",
'--logger_levels {}',
"--m ['str1', 'str2', 'upd1']",
"--m_str ['str1', 'str2', 'upd1']",
'--name giants',
'--no?',
'--noexec',
'--nohelp',
'--nohelpfull',
'--nohelpshort',
'--nohelpxml',
'--nologtostderr',
'--noonly_check_args',
'--nopdb_post_mortem',
'--noq',
'--norun_with_pdb',
'--norun_with_profiling',
'--notest0',
'--notestget2',
'--notestget3',
'--notestnone',
'--numbers [1, 2, 3]',
'--octal 438',
'--only_once singlevalue',
'--pdb False',
'--profile_file None',
'--quack',
'--repeat 3',
"--s ['sing1', 'upd2']",
"--s_str ['sing1', 'upd2']",
'--sense None',
'--showprefixforinfo',
'--stderrthreshold fatal',
'--test1',
'--test_random_seed 301',
'--test_randomize_ordering_seed ',
'--testcomma_list []',
'--testget1',
'--testget4 None',
'--testspace_list []',
'--testspace_or_comma_list []',
'--tmod_baz_x',
'--universe ptolemaic',
'--use_cprofile_for_profiling',
'--v -1',
'--verbosity -1',
'--x 10',
'--xml_output_file ',
], args_list())
####################################
# Test all kind of error conditions.
# Argument not in enum exception
argv = ('./program', '--kwery=WHEN')
self.assertRaises(flags.IllegalFlagValueError, FLAGS, argv)
argv = ('./program', '--kwery=why')
self.assertRaises(flags.IllegalFlagValueError, FLAGS, argv)
# Duplicate flag detection
with self.assertRaises(flags.DuplicateFlagError):
flags.DEFINE_boolean('run', 0, 'runhelp', short_name='q')
# Duplicate short flag detection
with self.assertRaisesRegex(
flags.DuplicateFlagError,
r"The flag 'z' is defined twice\. .*First from.*, Second from"):
flags.DEFINE_boolean('zoom1', 0, 'runhelp z1', short_name='z')
flags.DEFINE_boolean('zoom2', 0, 'runhelp z2', short_name='z')
raise AssertionError('duplicate short flag detection failed')
# Duplicate mixed flag detection
with self.assertRaisesRegex(
flags.DuplicateFlagError,
r"The flag 's' is defined twice\. .*First from.*, Second from"):
flags.DEFINE_boolean('short1', 0, 'runhelp s1', short_name='s')
flags.DEFINE_boolean('s', 0, 'runhelp s2')
# Check that duplicate flag detection detects definition sites
# correctly.
flagnames = ['repeated']
original_flags = flags.FlagValues()
flags.DEFINE_boolean(
flagnames[0],
False,
'Flag about to be repeated.',
flag_values=original_flags)
duplicate_flags = module_foo.duplicate_flags(flagnames)
with self.assertRaisesRegex(flags.DuplicateFlagError,
'flags_test.*module_foo'):
original_flags.append_flag_values(duplicate_flags)
# Make sure allow_override works
try:
flags.DEFINE_boolean(
'dup1', 0, 'runhelp d11', short_name='u', allow_override=0)
flag = FLAGS._flags()['dup1']
self.assertEqual(flag.default, 0)
flags.DEFINE_boolean(
'dup1', 1, 'runhelp d12', short_name='u', allow_override=1)
flag = FLAGS._flags()['dup1']
self.assertEqual(flag.default, 1)
except flags.DuplicateFlagError:
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._flags()['dup2']
self.assertEqual(flag.default, 0)
flags.DEFINE_boolean(
'dup2', 1, 'runhelp d22', short_name='u', allow_override=0)
flag = FLAGS._flags()['dup2']
self.assertEqual(flag.default, 1)
except flags.DuplicateFlagError:
raise AssertionError('allow_override did not permit a flag duplication')
# Make sure that re-importing a module does not cause a DuplicateFlagError
# to be raised.
try:
sys.modules.pop('absl.flags.tests.module_baz')
import absl.flags.tests.module_baz
del absl
except flags.DuplicateFlagError:
raise AssertionError('Module reimport caused flag duplication error')
# 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.assertEqual(str(FLAGS).find('runhelp d31'), -1)
self.assertNotEqual(str(FLAGS).find('runhelp d32'), -1)
# Make sure append_flag_values 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._flags()), 2)
old_len = len(FLAGS._flags())
FLAGS.append_flag_values(new_flags)
self.assertEqual(len(FLAGS._flags()) - old_len, 2)
self.assertEqual('new1' in FLAGS._flags(), True)
self.assertEqual('new2' in FLAGS._flags(), True)
# Then test that removing those flags works
FLAGS.remove_flag_values(new_flags)
self.assertEqual(len(FLAGS._flags()), old_len)
self.assertFalse('new1' in FLAGS._flags())
self.assertFalse('new2' in FLAGS._flags())
# Make sure append_flag_values 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._flags()), 3)
old_len = len(FLAGS._flags())
FLAGS.append_flag_values(new_flags)
self.assertEqual(len(FLAGS._flags()) - old_len, 3)
self.assertIn('new3', FLAGS._flags())
self.assertIn('new4', FLAGS._flags())
self.assertIn('n4', FLAGS._flags())
self.assertEqual(FLAGS._flags()['n4'], FLAGS._flags()['new4'])
# Then test removing them
FLAGS.remove_flag_values(new_flags)
self.assertEqual(len(FLAGS._flags()), old_len)
self.assertFalse('new3' in FLAGS._flags())
self.assertFalse('new4' in FLAGS._flags())
self.assertFalse('n4' in FLAGS._flags())
# Make sure append_flag_values 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)
with self.assertRaises(flags.DuplicateFlagError):
FLAGS.append_flag_values(new_flags)
# Integer out of bounds
with self.assertRaises(flags.IllegalFlagValueError):
argv = ('./program', '--repeat=-4')
FLAGS(argv)
# Non-integer
with self.assertRaises(flags.IllegalFlagValueError):
argv = ('./program', '--repeat=2.5')
FLAGS(argv)
# Missing required argument
with self.assertRaises(flags.Error):
argv = ('./program', '--name')
FLAGS(argv)
# Non-boolean arguments for boolean
with self.assertRaises(flags.IllegalFlagValueError):
argv = ('./program', '--debug=goofup')
FLAGS(argv)
with self.assertRaises(flags.IllegalFlagValueError):
argv = ('./program', '--debug=42')
FLAGS(argv)
# Non-numeric argument for integer flag --repeat
with self.assertRaises(flags.IllegalFlagValueError):
argv = ('./program', '--repeat', 'Bob', 'extra')
FLAGS(argv)
# Aliases of existing flags
with self.assertRaises(flags.UnrecognizedFlagError):
flags.DEFINE_alias('alias_not_a_flag', 'not_a_flag')
# Programmtically modify alias and aliased flag
flags.DEFINE_alias('alias_octal', 'octal')
FLAGS.octal = 0o2222
self.assertEqual(0o2222, FLAGS.octal)
self.assertEqual(0o2222, FLAGS.alias_octal)
FLAGS.alias_octal = 0o4444
self.assertEqual(0o4444, FLAGS.octal)
self.assertEqual(0o4444, FLAGS.alias_octal)
# Setting alias preserves the default of the original
flags.DEFINE_alias('alias_name', 'name')
flags.DEFINE_alias('alias_debug', 'debug')
flags.DEFINE_alias('alias_decimal', 'decimal')
flags.DEFINE_alias('alias_float', 'float')
flags.DEFINE_alias('alias_letters', 'letters')
self.assertEqual(FLAGS['name'].default, FLAGS.alias_name)
self.assertEqual(FLAGS['debug'].default, FLAGS.alias_debug)
self.assertEqual(int(FLAGS['decimal'].default), FLAGS.alias_decimal)
self.assertEqual(float(FLAGS['float'].default), FLAGS.alias_float)
self.assertSameElements(FLAGS['letters'].default, FLAGS.alias_letters)
# Original flags set on command line
argv = ('./program', '--name=Martin', '--debug=True', '--decimal=777',
'--letters=x,y,z')
FLAGS(argv)
self.assertEqual('Martin', FLAGS.name)
self.assertEqual('Martin', FLAGS.alias_name)
self.assertTrue(FLAGS.debug)
self.assertTrue(FLAGS.alias_debug)
self.assertEqual(777, FLAGS.decimal)
self.assertEqual(777, FLAGS.alias_decimal)
self.assertSameElements(['x', 'y', 'z'], FLAGS.letters)
self.assertSameElements(['x', 'y', 'z'], FLAGS.alias_letters)
# Alias flags set on command line
argv = ('./program', '--alias_name=Auston', '--alias_debug=False',
'--alias_decimal=888', '--alias_letters=l,m,n')
FLAGS(argv)
self.assertEqual('Auston', FLAGS.name)
self.assertEqual('Auston', FLAGS.alias_name)
self.assertFalse(FLAGS.debug)
self.assertFalse(FLAGS.alias_debug)
self.assertEqual(888, FLAGS.decimal)
self.assertEqual(888, FLAGS.alias_decimal)
self.assertSameElements(['l', 'm', 'n'], FLAGS.letters)
self.assertSameElements(['l', 'm', 'n'], FLAGS.alias_letters)
# Make sure importing a module does not change flag value parsed
# from commandline.
flags.DEFINE_integer(
'dup5', 1, 'runhelp d51', short_name='u5', allow_override=0)
self.assertEqual(FLAGS.dup5, 1)
self.assertEqual(FLAGS.dup5, 1)
argv = ('./program', '--dup5=3')
FLAGS(argv)
self.assertEqual(FLAGS.dup5, 3)
flags.DEFINE_integer(
'dup5', 2, 'runhelp d52', short_name='u5', allow_override=1)
self.assertEqual(FLAGS.dup5, 3)
# Make sure importing a module does not change user defined flag value.
flags.DEFINE_integer(
'dup6', 1, 'runhelp d61', short_name='u6', allow_override=0)
self.assertEqual(FLAGS.dup6, 1)
FLAGS.dup6 = 3
self.assertEqual(FLAGS.dup6, 3)
flags.DEFINE_integer(
'dup6', 2, 'runhelp d62', short_name='u6', allow_override=1)
self.assertEqual(FLAGS.dup6, 3)
# Make sure importing a module does not change user defined flag value
# even if it is the 'default' value.
flags.DEFINE_integer(
'dup7', 1, 'runhelp d71', short_name='u7', allow_override=0)
self.assertEqual(FLAGS.dup7, 1)
FLAGS.dup7 = 1
self.assertEqual(FLAGS.dup7, 1)
flags.DEFINE_integer(
'dup7', 2, 'runhelp d72', short_name='u7', allow_override=1)
self.assertEqual(FLAGS.dup7, 1)
# Test module_help().
helpstr = FLAGS.module_help(module_baz)
expected_help = '\n' + module_baz.__name__ + ':' + """
--[no]tmod_baz_x: Boolean flag.
(default: 'true')"""
self.assertMultiLineEqual(expected_help, helpstr)
# Test main_module_help(). This must be part of test_flags because
# it depends on dup1/2/3/etc being introduced first.
helpstr = FLAGS.main_module_help()
expected_help = '\n' + sys.argv[0] + ':' + """
--[no]alias_debug: Alias for --debug.
(default: 'false')
--alias_decimal: Alias for --decimal.
(default: '666')
(an integer)
--alias_float: Alias for --float.
(default: '3.14')
(a number)
--alias_letters: Alias for --letters.
(default: 'a,b,c')
(a comma separated list)
--alias_name: Alias for --name.
(default: 'Bob')
--alias_octal: Alias for --octal.
(default: '438')
(an integer)
--args: a list of arguments
(default: 'v=1,"vmodule=a=0,b=2"')
(a comma separated list)
--blah: <bla|Blah|BLAH|blah>: ?
--cases: <UPPER|lower|Initial|Ot_HeR>: ?
--[no]debug: debughelp
(default: 'false')
--decimal: using decimals
(default: '666')
(an integer)
-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')
-u5,--dup5: runhelp d51
(default: '1')
(an integer)
-u6,--dup6: runhelp d61
(default: '1')
(an integer)
-u7,--dup7: runhelp d71
(default: '1')
(an integer)
--float: using floats
(default: '3.14')
(a number)
--funny: <Joke|ha|ha|ha|ha>: ?
--hexadecimal: using hexadecimals
(default: '1638')
(an integer)
--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')
--numbers: a list of numbers
(default: '1,2,3')
(a comma separated list)
--octal: using octals
(default: '438')
(an integer)
--only_once: test only sets this once
--[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']")
--sense: <Case|case|CASE>: ?
--[no]test0: test boolean parsing
--[no]test1: test boolean parsing
--testcomma_list: test comma list parsing
(default: '')
(a comma separated list)
--[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)
--[no]testnone: test boolean parsing
--testspace_list: tests space list parsing
(default: '')
(a whitespace separated list)
--testspace_or_comma_list: tests space list parsing with comma compatibility
(default: '')
(a whitespace or comma separated list)
--universe: test tries to set this three times
--x: how eXtreme to be
(default: '3')
(an integer)
-z,--[no]zoom1: runhelp z1
(default: 'false')"""
self.assertMultiLineEqual(expected_help, helpstr)
def test_string_flag_with_wrong_type(self):
fv = flags.FlagValues()
with self.assertRaises(flags.IllegalFlagValueError):
flags.DEFINE_string('name', False, 'help', flag_values=fv)
with self.assertRaises(flags.IllegalFlagValueError):
flags.DEFINE_string('name2', 0, 'help', flag_values=fv)
def test_integer_flag_with_wrong_type(self):
fv = flags.FlagValues()
with self.assertRaises(flags.IllegalFlagValueError):
flags.DEFINE_integer('name', 1e2, 'help', flag_values=fv)
with self.assertRaises(flags.IllegalFlagValueError):
flags.DEFINE_integer('name', [], 'help', flag_values=fv)
with self.assertRaises(flags.IllegalFlagValueError):
flags.DEFINE_integer('name', False, 'help', flag_values=fv)
def test_float_flag_with_wrong_type(self):
fv = flags.FlagValues()
with self.assertRaises(flags.IllegalFlagValueError):
flags.DEFINE_float('name', False, 'help', flag_values=fv)
def test_enum_flag_with_empty_values(self):
fv = flags.FlagValues()
with self.assertRaises(ValueError):
flags.DEFINE_enum('fruit', None, [], 'help', flag_values=fv)
def test_define_enum_class_flag(self):
fv = flags.FlagValues()
flags.DEFINE_enum_class('fruit', None, Fruit, '?', flag_values=fv)
fv.mark_as_parsed()
self.assertIsNone(fv.fruit)
def test_parse_enum_class_flag(self):
fv = flags.FlagValues()
flags.DEFINE_enum_class('fruit', None, Fruit, '?', flag_values=fv)
argv = ('./program', '--fruit=orange')
argv = fv(argv)
self.assertEqual(len(argv), 1, 'wrong number of arguments pulled')
self.assertEqual(argv[0], './program', 'program name not preserved')
self.assertEqual(fv['fruit'].present, 1)
self.assertEqual(fv['fruit'].value, Fruit.ORANGE)
fv.unparse_flags()
argv = ('./program', '--fruit=APPLE')
argv = fv(argv)
self.assertEqual(len(argv), 1, 'wrong number of arguments pulled')
self.assertEqual(argv[0], './program', 'program name not preserved')
self.assertEqual(fv['fruit'].present, 1)
self.assertEqual(fv['fruit'].value, Fruit.APPLE)
fv.unparse_flags()
def test_enum_class_flag_help_message(self):
fv = flags.FlagValues()
flags.DEFINE_enum_class('fruit', None, Fruit, '?', flag_values=fv)
helpstr = fv.main_module_help()
expected_help = '\n%s:\n --fruit: <apple|orange>: ?' % sys.argv[0]
self.assertEqual(helpstr, expected_help)
def test_enum_class_flag_with_wrong_default_value_type(self):
fv = flags.FlagValues()
with self.assertRaises(_exceptions.IllegalFlagValueError):
flags.DEFINE_enum_class('fruit', 1, Fruit, 'help', flag_values=fv)
def test_enum_class_flag_requires_enum_class(self):
fv = flags.FlagValues()
with self.assertRaises(TypeError):
flags.DEFINE_enum_class(
'fruit', None, ['apple', 'orange'], 'help', flag_values=fv)
def test_enum_class_flag_requires_non_empty_enum_class(self):
fv = flags.FlagValues()
with self.assertRaises(ValueError):
flags.DEFINE_enum_class('empty', None, EmptyEnum, 'help', flag_values=fv)
def test_required_flag(self):
fv = flags.FlagValues()
fl = flags.DEFINE_integer(
name='int_flag',
default=None,
help='help',
required=True,
flag_values=fv)
# Since the flag is required, the FlagHolder should ensure value returned
# is not None.
self.assertTrue(fl._ensure_non_none_value)
def test_illegal_required_flag(self):
fv = flags.FlagValues()
with self.assertRaises(ValueError):
flags.DEFINE_integer(
name='int_flag',
default=3,
help='help',
required=True,
flag_values=fv)
class MultiNumericalFlagsTest(absltest.TestCase):
def test_multi_numerical_flags(self):
"""Test multi_int and multi_float flags."""
fv = flags.FlagValues()
int_defaults = [77, 88]
flags.DEFINE_multi_integer(
'm_int',
int_defaults,
'integer option that can occur multiple times',
short_name='mi',
flag_values=fv)
self.assertListEqual(fv['m_int'].default, int_defaults)
argv = ('./program', '--m_int=-99', '--mi=101')
fv(argv)
self.assertListEqual(fv.get_flag_value('m_int', None), [-99, 101])
float_defaults = [2.2, 3]
flags.DEFINE_multi_float(
'm_float',
float_defaults,
'float option that can occur multiple times',
short_name='mf',
flag_values=fv)
for (expected, actual) in zip(float_defaults,
fv.get_flag_value('m_float', None)):
self.assertAlmostEqual(expected, actual)
argv = ('./program', '--m_float=-17', '--mf=2.78e9')
fv(argv)
expected_floats = [-17.0, 2.78e9]
for (expected, actual) in zip(expected_floats,
fv.get_flag_value('m_float', None)):
self.assertAlmostEqual(expected, actual)
def test_multi_numerical_with_tuples(self):
"""Verify multi_int/float accept tuples as default values."""
flags.DEFINE_multi_integer(
'm_int_tuple', (77, 88),
'integer option that can occur multiple times',
short_name='mi_tuple')
self.assertListEqual(FLAGS.get_flag_value('m_int_tuple', None), [77, 88])
dict_with_float_keys = {2.2: 'hello', 3: 'happy'}
float_defaults = dict_with_float_keys.keys()
flags.DEFINE_multi_float(
'm_float_tuple',
float_defaults,
'float option that can occur multiple times',
short_name='mf_tuple')
for (expected, actual) in zip(float_defaults,
FLAGS.get_flag_value('m_float_tuple', None)):
self.assertAlmostEqual(expected, actual)
def test_single_value_default(self):
"""Test multi_int and multi_float flags with a single default value."""
int_default = 77
flags.DEFINE_multi_integer('m_int1', int_default,
'integer option that can occur multiple times')
self.assertListEqual(FLAGS.get_flag_value('m_int1', None), [int_default])
float_default = 2.2
flags.DEFINE_multi_float('m_float1', float_default,
'float option that can occur multiple times')
actual = FLAGS.get_flag_value('m_float1', None)
self.assertEqual(1, len(actual))
self.assertAlmostEqual(actual[0], float_default)
def test_bad_multi_numerical_flags(self):
"""Test multi_int and multi_float flags with non-parseable values."""
# Test non-parseable defaults.
self.assertRaisesRegex(
flags.IllegalFlagValueError,
r"flag --m_int2=abc: invalid literal for int\(\) with base 10: 'abc'",
flags.DEFINE_multi_integer, 'm_int2', ['abc'], 'desc')
self.assertRaisesRegex(
flags.IllegalFlagValueError, r'flag --m_float2=abc: '
r'(invalid literal for float\(\)|could not convert string to float): '
r"'?abc'?", flags.DEFINE_multi_float, 'm_float2', ['abc'], 'desc')
# Test non-parseable command line values.
fv = flags.FlagValues()
flags.DEFINE_multi_integer(
'm_int2',
'77',
'integer option that can occur multiple times',
flag_values=fv)
argv = ('./program', '--m_int2=def')
self.assertRaisesRegex(
flags.IllegalFlagValueError,
r"flag --m_int2=def: invalid literal for int\(\) with base 10: 'def'",
fv, argv)
flags.DEFINE_multi_float(
'm_float2',
2.2,
'float option that can occur multiple times',
flag_values=fv)
argv = ('./program', '--m_float2=def')
self.assertRaisesRegex(
flags.IllegalFlagValueError, r'flag --m_float2=def: '
r'(invalid literal for float\(\)|could not convert string to float): '
r"'?def'?", fv, argv)
class MultiEnumFlagsTest(absltest.TestCase):
def test_multi_enum_flags(self):
"""Test multi_enum flags."""
fv = flags.FlagValues()
enum_defaults = ['FOO', 'BAZ']
flags.DEFINE_multi_enum(
'm_enum',
enum_defaults, ['FOO', 'BAR', 'BAZ', 'WHOOSH'],
'Enum option that can occur multiple times',
short_name='me',
flag_values=fv)
self.assertListEqual(fv['m_enum'].default, enum_defaults)
argv = ('./program', '--m_enum=WHOOSH', '--me=FOO')
fv(argv)
self.assertListEqual(fv.get_flag_value('m_enum', None), ['WHOOSH', 'FOO'])
def test_help_text(self):
"""Test multi_enum flag's help text."""
fv = flags.FlagValues()
flags.DEFINE_multi_enum(
'm_enum',
None, ['FOO', 'BAR'],
'Enum option that can occur multiple times',
flag_values=fv)
self.assertRegex(
fv['m_enum'].help,
r'<FOO\|BAR>: Enum option that can occur multiple times;\s+'
'repeat this option to specify a list of values')
def test_single_value_default(self):
"""Test multi_enum flags with a single default value."""
fv = flags.FlagValues()
enum_default = 'FOO'
flags.DEFINE_multi_enum(
'm_enum1',
enum_default, ['FOO', 'BAR', 'BAZ', 'WHOOSH'],
'enum option that can occur multiple times',
flag_values=fv)
self.assertListEqual(fv['m_enum1'].default, [enum_default])
def test_case_sensitivity(self):
"""Test case sensitivity of multi_enum flag."""
fv = flags.FlagValues()
# Test case insensitive enum.
flags.DEFINE_multi_enum(
'm_enum2', ['whoosh'], ['FOO', 'BAR', 'BAZ', 'WHOOSH'],
'Enum option that can occur multiple times',
short_name='me2',
case_sensitive=False,
flag_values=fv)
argv = ('./program', '--m_enum2=bar', '--me2=fOo')
fv(argv)
self.assertListEqual(fv.get_flag_value('m_enum2', None), ['BAR', 'FOO'])
# Test case sensitive enum.
flags.DEFINE_multi_enum(
'm_enum3', ['BAR'], ['FOO', 'BAR', 'BAZ', 'WHOOSH'],
'Enum option that can occur multiple times',
short_name='me3',
case_sensitive=True,
flag_values=fv)
argv = ('./program', '--m_enum3=bar', '--me3=fOo')
self.assertRaisesRegex(
flags.IllegalFlagValueError,
r'flag --m_enum3=invalid: value should be one of <FOO|BAR|BAZ|WHOOSH>',
fv, argv)
def test_bad_multi_enum_flags(self):
"""Test multi_enum with invalid values."""
# Test defaults that are not in the permitted list of enums.
self.assertRaisesRegex(
flags.IllegalFlagValueError,
r'flag --m_enum=INVALID: value should be one of <FOO|BAR|BAZ>',
flags.DEFINE_multi_enum, 'm_enum', ['INVALID'], ['FOO', 'BAR', 'BAZ'],
'desc')
self.assertRaisesRegex(
flags.IllegalFlagValueError,
r'flag --m_enum=1234: value should be one of <FOO|BAR|BAZ>',
flags.DEFINE_multi_enum, 'm_enum2', [1234], ['FOO', 'BAR', 'BAZ'],
'desc')
# Test command-line values that are not in the permitted list of enums.
flags.DEFINE_multi_enum('m_enum4', 'FOO', ['FOO', 'BAR', 'BAZ'],
'enum option that can occur multiple times')
argv = ('./program', '--m_enum4=INVALID')
self.assertRaisesRegex(
flags.IllegalFlagValueError,
r'flag --m_enum4=invalid: value should be one of <FOO|BAR|BAZ>', FLAGS,
argv)
class MultiEnumClassFlagsTest(absltest.TestCase):
def test_define_results_in_registered_flag_with_none(self):
fv = flags.FlagValues()
enum_defaults = None
flags.DEFINE_multi_enum_class(
'fruit',
enum_defaults,
Fruit,
'Enum option that can occur multiple times',
flag_values=fv)
fv.mark_as_parsed()
self.assertIsNone(fv.fruit)
def test_help_text(self):
fv = flags.FlagValues()
enum_defaults = None
flags.DEFINE_multi_enum_class(
'fruit',
enum_defaults,
Fruit,
'Enum option that can occur multiple times',
flag_values=fv)
self.assertRegex(
fv['fruit'].help,
r'<apple\|orange>: Enum option that can occur multiple times;\s+'
'repeat this option to specify a list of values')
def test_define_results_in_registered_flag_with_string(self):
fv = flags.FlagValues()
enum_defaults = 'apple'
flags.DEFINE_multi_enum_class(
'fruit',
enum_defaults,
Fruit,
'Enum option that can occur multiple times',
flag_values=fv)
fv.mark_as_parsed()
self.assertListEqual(fv.fruit, [Fruit.APPLE])
def test_define_results_in_registered_flag_with_enum(self):
fv = flags.FlagValues()
enum_defaults = Fruit.APPLE
flags.DEFINE_multi_enum_class(
'fruit',
enum_defaults,
Fruit,
'Enum option that can occur multiple times',
flag_values=fv)
fv.mark_as_parsed()
self.assertListEqual(fv.fruit, [Fruit.APPLE])
def test_define_results_in_registered_flag_with_string_list(self):
fv = flags.FlagValues()
enum_defaults = ['apple', 'APPLE']
flags.DEFINE_multi_enum_class(
'fruit',
enum_defaults,
CaseSensitiveFruit,
'Enum option that can occur multiple times',
flag_values=fv,
case_sensitive=True)
fv.mark_as_parsed()
self.assertListEqual(fv.fruit,
[CaseSensitiveFruit.apple, CaseSensitiveFruit.APPLE])
def test_define_results_in_registered_flag_with_enum_list(self):
fv = flags.FlagValues()
enum_defaults = [Fruit.APPLE, Fruit.ORANGE]
flags.DEFINE_multi_enum_class(
'fruit',
enum_defaults,
Fruit,
'Enum option that can occur multiple times',
flag_values=fv)
fv.mark_as_parsed()
self.assertListEqual(fv.fruit, [Fruit.APPLE, Fruit.ORANGE])
def test_from_command_line_returns_multiple(self):
fv = flags.FlagValues()
enum_defaults = [Fruit.APPLE]
flags.DEFINE_multi_enum_class(
'fruit',
enum_defaults,
Fruit,
'Enum option that can occur multiple times',
flag_values=fv)
argv = ('./program', '--fruit=Apple', '--fruit=orange')
fv(argv)
self.assertListEqual(fv.fruit, [Fruit.APPLE, Fruit.ORANGE])
def test_bad_multi_enum_class_flags_from_definition(self):
with self.assertRaisesRegex(
flags.IllegalFlagValueError,
'flag --fruit=INVALID: value should be one of <apple|orange|APPLE>'):
flags.DEFINE_multi_enum_class('fruit', ['INVALID'], Fruit, 'desc')
def test_bad_multi_enum_class_flags_from_commandline(self):
fv = flags.FlagValues()
enum_defaults = [Fruit.APPLE]
flags.DEFINE_multi_enum_class(
'fruit', enum_defaults, Fruit, 'desc', flag_values=fv)
argv = ('./program', '--fruit=INVALID')
with self.assertRaisesRegex(
flags.IllegalFlagValueError,
'flag --fruit=INVALID: value should be one of <apple|orange|APPLE>'):
fv(argv)
class UnicodeFlagsTest(absltest.TestCase):
"""Testing proper unicode support for flags."""
def test_unicode_default_and_helpstring(self):
fv = flags.FlagValues()
flags.DEFINE_string(
'unicode_str',
b'\xC3\x80\xC3\xBD'.decode('utf-8'),
b'help:\xC3\xAA'.decode('utf-8'),
flag_values=fv)
argv = ('./program',)
fv(argv) # should not raise any exceptions
argv = ('./program', '--unicode_str=foo')
fv(argv) # should not raise any exceptions
def test_unicode_in_list(self):
fv = flags.FlagValues()
flags.DEFINE_list(
'unicode_list',
['abc', b'\xC3\x80'.decode('utf-8'), b'\xC3\xBD'.decode('utf-8')],
b'help:\xC3\xAB'.decode('utf-8'),
flag_values=fv)
argv = ('./program',)
fv(argv) # should not raise any exceptions
argv = ('./program', '--unicode_list=hello,there')
fv(argv) # should not raise any exceptions
def test_xmloutput(self):
fv = flags.FlagValues()
flags.DEFINE_string(
'unicode1',
b'\xC3\x80\xC3\xBD'.decode('utf-8'),
b'help:\xC3\xAC'.decode('utf-8'),
flag_values=fv)
flags.DEFINE_list(
'unicode2',
['abc', b'\xC3\x80'.decode('utf-8'), b'\xC3\xBD'.decode('utf-8')],
b'help:\xC3\xAD'.decode('utf-8'),
flag_values=fv)
flags.DEFINE_list(
'non_unicode', ['abc', 'def', 'ghi'],
b'help:\xC3\xAD'.decode('utf-8'),
flag_values=fv)
outfile = io.StringIO()
fv.write_help_in_xml_format(outfile)
actual_output = outfile.getvalue()
# The xml output is large, so we just check parts of it.
self.assertIn(
b'<name>unicode1</name>\n'
b' <meaning>help:\xc3\xac</meaning>\n'
b' <default>\xc3\x80\xc3\xbd</default>\n'
b' <current>\xc3\x80\xc3\xbd</current>'.decode('utf-8'),
actual_output)
self.assertIn(
b'<name>unicode2</name>\n'
b' <meaning>help:\xc3\xad</meaning>\n'
b' <default>abc,\xc3\x80,\xc3\xbd</default>\n'
b" <current>['abc', '\xc3\x80', '\xc3\xbd']"
b'</current>'.decode('utf-8'), actual_output)
self.assertIn(
b'<name>non_unicode</name>\n'
b' <meaning>help:\xc3\xad</meaning>\n'
b' <default>abc,def,ghi</default>\n'
b" <current>['abc', 'def', 'ghi']"
b'</current>'.decode('utf-8'), actual_output)
class LoadFromFlagFileTest(absltest.TestCase):
"""Testing loading flags from a file and parsing them."""
def setUp(self):
self.flag_values = flags.FlagValues()
flags.DEFINE_string(
'unittest_message1',
'Foo!',
'You Add Here.',
flag_values=self.flag_values)
flags.DEFINE_string(
'unittest_message2',
'Bar!',
'Hello, Sailor!',
flag_values=self.flag_values)
flags.DEFINE_boolean(
'unittest_boolflag',
0,
'Some Boolean thing',
flag_values=self.flag_values)
flags.DEFINE_integer(
'unittest_number',
12345,
'Some integer',
lower_bound=0,
flag_values=self.flag_values)
flags.DEFINE_list(
'UnitTestList', '1,2,3', 'Some list', flag_values=self.flag_values)
self.tmp_path = None
self.flag_values.mark_as_parsed()
def tearDown(self):
self._remove_test_files()
def _setup_test_files(self):
"""Creates and sets up some dummy flagfile files with bogus flags."""
# Figure out where to create temporary files
self.assertFalse(self.tmp_path)
self.tmp_path = tempfile.mkdtemp()
tmp_flag_file_1 = open(self.tmp_path + '/UnitTestFile1.tst', 'w')
tmp_flag_file_2 = open(self.tmp_path + '/UnitTestFile2.tst', 'w')
tmp_flag_file_3 = open(self.tmp_path + '/UnitTestFile3.tst', 'w')
tmp_flag_file_4 = open(self.tmp_path + '/UnitTestFile4.tst', 'w')
# put some dummy flags in our test files
tmp_flag_file_1.write('#A Fake Comment\n')
tmp_flag_file_1.write('--unittest_message1=tempFile1!\n')
tmp_flag_file_1.write('\n')
tmp_flag_file_1.write('--unittest_number=54321\n')
tmp_flag_file_1.write('--nounittest_boolflag\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('--unittest_message2=setFromTempFile2\n')
tmp_flag_file_2.write('\t\t\n')
tmp_flag_file_2.write('--unittest_number=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('--unittest_message1=setFromTempFile3\n')
tmp_flag_file_3.write('#YAFC\n')
tmp_flag_file_3.write('--unittest_boolflag\n')
file_list.append(tmp_flag_file_3.name)
# this file is unreadable
tmp_flag_file_4.write('--flagfile=%s\n' % tmp_flag_file_3.name)
tmp_flag_file_4.write('--unittest_message1=setFromTempFile4\n')
tmp_flag_file_4.write('--unittest_message1=setFromTempFile4\n')
os.chmod(self.tmp_path + '/UnitTestFile4.tst', 0)
file_list.append(tmp_flag_file_4.name)
tmp_flag_file_1.close()
tmp_flag_file_2.close()
tmp_flag_file_3.close()
tmp_flag_file_4.close()
return file_list # these are just the file names
def _remove_test_files(self):
"""Removes the files we just created."""
if self.tmp_path:
shutil.rmtree(self.tmp_path, ignore_errors=True)
self.tmp_path = None
def _read_flags_from_files(self, argv, force_gnu):
return argv[:1] + self.flag_values.read_flags_from_files(
argv[1:], force_gnu=force_gnu)
#### Flagfile Unit Tests ####
def test_method_flagfiles_1(self):
"""Test trivial case with no flagfile based options."""
fake_cmd_line = 'fooScript --unittest_boolflag'
fake_argv = fake_cmd_line.split(' ')
self.flag_values(fake_argv)
self.assertEqual(self.flag_values.unittest_boolflag, 1)
self.assertListEqual(fake_argv,
self._read_flags_from_files(fake_argv, False))
def test_method_flagfiles_2(self):
"""Tests parsing one file + arguments off simulated argv."""
tmp_files = self._setup_test_files()
# 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.
# Flags from the file will appear in the order order they are specified
# in the file, in the same position as the flagfile argument.
expected_results = [
'fooScript', '--q', '--unittest_message1=tempFile1!',
'--unittest_number=54321', '--nounittest_boolflag'
]
test_results = self._read_flags_from_files(fake_argv, False)
self.assertListEqual(expected_results, test_results)
# end testTwo def
def test_method_flagfiles_3(self):
"""Tests parsing nested files + arguments of simulated argv."""
tmp_files = self._setup_test_files()
# specify our temp file on the fake cmd line
fake_cmd_line = ('fooScript --unittest_number=77 --flagfile=%s' %
tmp_files[1])
fake_argv = fake_cmd_line.split(' ')
expected_results = [
'fooScript', '--unittest_number=77', '--unittest_message1=tempFile1!',
'--unittest_number=54321', '--nounittest_boolflag',
'--unittest_message2=setFromTempFile2', '--unittest_number=6789a'
]
test_results = self._read_flags_from_files(fake_argv, False)
self.assertListEqual(expected_results, test_results)
# end testThree def
def test_method_flagfiles_3_spaces(self):
"""Tests parsing nested files + arguments of simulated argv.
The arguments include a pair that is actually an arg with a value, so it
doesn't stop processing.
"""
tmp_files = self._setup_test_files()
# specify our temp file on the fake cmd line
fake_cmd_line = ('fooScript --unittest_number 77 --flagfile=%s' %
tmp_files[1])
fake_argv = fake_cmd_line.split(' ')
expected_results = [
'fooScript', '--unittest_number', '77',
'--unittest_message1=tempFile1!', '--unittest_number=54321',
'--nounittest_boolflag', '--unittest_message2=setFromTempFile2',
'--unittest_number=6789a'
]
test_results = self._read_flags_from_files(fake_argv, False)
self.assertListEqual(expected_results, test_results)
def test_method_flagfiles_3_spaces_boolean(self):
"""Tests parsing nested files + arguments of simulated argv.
The arguments include a pair that looks like a --x y arg with value, but
since the flag is a boolean it's actually not.
"""
tmp_files = self._setup_test_files()
# specify our temp file on the fake cmd line
fake_cmd_line = ('fooScript --unittest_boolflag 77 --flagfile=%s' %
tmp_files[1])
fake_argv = fake_cmd_line.split(' ')
expected_results = [
'fooScript', '--unittest_boolflag', '77',
'--flagfile=%s' % tmp_files[1]
]
with _use_gnu_getopt(self.flag_values, False):
test_results = self._read_flags_from_files(fake_argv, False)
self.assertListEqual(expected_results, test_results)
def test_method_flagfiles_4(self):
"""Tests parsing self-referential files + arguments of simulated argv.
This test should print a warning to stderr of some sort.
"""
tmp_files = self._setup_test_files()
# specify our temp file on the fake cmd line
fake_cmd_line = ('fooScript --flagfile=%s --nounittest_boolflag' %
tmp_files[2])
fake_argv = fake_cmd_line.split(' ')
expected_results = [
'fooScript', '--unittest_message1=setFromTempFile3',
'--unittest_boolflag', '--nounittest_boolflag'
]
test_results = self._read_flags_from_files(fake_argv, False)
self.assertListEqual(expected_results, test_results)
def test_method_flagfiles_5(self):
"""Test that --flagfile parsing respects the '--' end-of-options marker."""
tmp_files = self._setup_test_files()
# specify our temp file on the fake cmd line
fake_cmd_line = 'fooScript --some_flag -- --flagfile=%s' % tmp_files[0]
fake_argv = fake_cmd_line.split(' ')
expected_results = [
'fooScript', '--some_flag', '--',
'--flagfile=%s' % tmp_files[0]
]
test_results = self._read_flags_from_files(fake_argv, False)
self.assertListEqual(expected_results, test_results)
def test_method_flagfiles_6(self):
"""Test that --flagfile parsing stops at non-options (non-GNU behavior)."""
tmp_files = self._setup_test_files()
# specify our temp file on the fake cmd line
fake_cmd_line = ('fooScript --some_flag some_arg --flagfile=%s' %
tmp_files[0])
fake_argv = fake_cmd_line.split(' ')
expected_results = [
'fooScript', '--some_flag', 'some_arg',
'--flagfile=%s' % tmp_files[0]
]
with _use_gnu_getopt(self.flag_values, False):
test_results = self._read_flags_from_files(fake_argv, False)
self.assertListEqual(expected_results, test_results)
def test_method_flagfiles_7(self):
"""Test that --flagfile parsing skips over a non-option (GNU behavior)."""
self.flag_values.set_gnu_getopt()
tmp_files = self._setup_test_files()
# specify our temp file on the fake cmd line
fake_cmd_line = ('fooScript --some_flag some_arg --flagfile=%s' %
tmp_files[0])
fake_argv = fake_cmd_line.split(' ')
expected_results = [
'fooScript', '--some_flag', 'some_arg',
'--unittest_message1=tempFile1!', '--unittest_number=54321',
'--nounittest_boolflag'
]
test_results = self._read_flags_from_files(fake_argv, False)
self.assertListEqual(expected_results, test_results)
def test_method_flagfiles_8(self):
"""Test that --flagfile parsing respects force_gnu=True."""
tmp_files = self._setup_test_files()
# specify our temp file on the fake cmd line
fake_cmd_line = ('fooScript --some_flag some_arg --flagfile=%s' %
tmp_files[0])
fake_argv = fake_cmd_line.split(' ')
expected_results = [
'fooScript', '--some_flag', 'some_arg',
'--unittest_message1=tempFile1!', '--unittest_number=54321',
'--nounittest_boolflag'
]
test_results = self._read_flags_from_files(fake_argv, True)
self.assertListEqual(expected_results, test_results)
def test_method_flagfiles_repeated_non_circular(self):
"""Tests that parsing repeated non-circular flagfiles works."""
tmp_files = self._setup_test_files()
# specify our temp files on the fake cmd line
fake_cmd_line = ('fooScript --flagfile=%s --flagfile=%s' %
(tmp_files[1], tmp_files[0]))
fake_argv = fake_cmd_line.split(' ')
expected_results = [
'fooScript', '--unittest_message1=tempFile1!',
'--unittest_number=54321', '--nounittest_boolflag',
'--unittest_message2=setFromTempFile2', '--unittest_number=6789a',
'--unittest_message1=tempFile1!', '--unittest_number=54321',
'--nounittest_boolflag'
]
test_results = self._read_flags_from_files(fake_argv, False)
self.assertListEqual(expected_results, test_results)
@unittest.skipIf(
os.name == 'nt',
'There is no good way to create an unreadable file on Windows.')
def test_method_flagfiles_no_permissions(self):
"""Test that --flagfile raises except on file that is unreadable."""
tmp_files = self._setup_test_files()
# specify our temp file on the fake cmd line
fake_cmd_line = ('fooScript --some_flag some_arg --flagfile=%s' %
tmp_files[3])
fake_argv = fake_cmd_line.split(' ')
self.assertRaises(flags.CantOpenFlagFileError, self._read_flags_from_files,
fake_argv, True)
def test_method_flagfiles_not_found(self):
"""Test that --flagfile raises except on file that does not exist."""
tmp_files = self._setup_test_files()
# specify our temp file on the fake cmd line
fake_cmd_line = ('fooScript --some_flag some_arg --flagfile=%sNOTEXIST' %
tmp_files[3])
fake_argv = fake_cmd_line.split(' ')
self.assertRaises(flags.CantOpenFlagFileError, self._read_flags_from_files,
fake_argv, True)
def test_flagfiles_user_path_expansion(self):
"""Test that user directory referenced paths are correctly expanded.
Test paths like ~/foo. 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.
"""
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 = self.flag_values._extract_filename(
fake_flagfile_item_style_1)
self.assertEqual(expected_results, test_results)
test_results = self.flag_values._extract_filename(
fake_flagfile_item_style_2)
self.assertEqual(expected_results, test_results)
def test_no_touchy_non_flags(self):
"""Test that the flags parser does not mutilate arguments.
The arguments are not supposed to be flags
"""
fake_argv = [
'fooScript', '--unittest_boolflag', 'command', '--command_arg1',
'--UnitTestBoom', '--UnitTestB'
]
with _use_gnu_getopt(self.flag_values, False):
argv = self.flag_values(fake_argv)
self.assertListEqual(argv, fake_argv[:1] + fake_argv[2:])
def test_parse_flags_after_args_if_using_gnugetopt(self):
"""Test that flags given after arguments are parsed if using gnu_getopt."""
self.flag_values.set_gnu_getopt()
fake_argv = [
'fooScript', '--unittest_boolflag', 'command', '--unittest_number=54321'
]
argv = self.flag_values(fake_argv)
self.assertListEqual(argv, ['fooScript', 'command'])
def test_set_default(self):
"""Test changing flag defaults."""
# Test that set_default changes both the default and the value,
# and that the value is changed when one is given as an option.
self.flag_values.set_default('unittest_message1', 'New value')
self.assertEqual(self.flag_values.unittest_message1, 'New value')
self.assertEqual(self.flag_values['unittest_message1'].default_as_str,
"'New value'")
self.flag_values(['dummyscript', '--unittest_message1=Newer value'])
self.assertEqual(self.flag_values.unittest_message1, 'Newer value')
# Test that setting the default to None works correctly.
self.flag_values.set_default('unittest_number', None)
self.assertEqual(self.flag_values.unittest_number, None)
self.assertEqual(self.flag_values['unittest_number'].default_as_str, None)
self.flag_values(['dummyscript', '--unittest_number=56'])
self.assertEqual(self.flag_values.unittest_number, 56)
# Test that setting the default to zero works correctly.
self.flag_values.set_default('unittest_number', 0)
self.assertEqual(self.flag_values['unittest_number'].default, 0)
self.assertEqual(self.flag_values.unittest_number, 56)
self.assertEqual(self.flag_values['unittest_number'].default_as_str, "'0'")
self.flag_values(['dummyscript', '--unittest_number=56'])
self.assertEqual(self.flag_values.unittest_number, 56)
# Test that setting the default to '' works correctly.
self.flag_values.set_default('unittest_message1', '')
self.assertEqual(self.flag_values['unittest_message1'].default, '')
self.assertEqual(self.flag_values.unittest_message1, 'Newer value')
self.assertEqual(self.flag_values['unittest_message1'].default_as_str, "''")
self.flag_values(['dummyscript', '--unittest_message1=fifty-six'])
self.assertEqual(self.flag_values.unittest_message1, 'fifty-six')
# Test that setting the default to false works correctly.
self.flag_values.set_default('unittest_boolflag', False)
self.assertEqual(self.flag_values.unittest_boolflag, False)
self.assertEqual(self.flag_values['unittest_boolflag'].default_as_str,
"'false'")
self.flag_values(['dummyscript', '--unittest_boolflag=true'])
self.assertEqual(self.flag_values.unittest_boolflag, True)
# Test that setting a list default works correctly.
self.flag_values.set_default('UnitTestList', '4,5,6')
self.assertListEqual(self.flag_values.UnitTestList, ['4', '5', '6'])
self.assertEqual(self.flag_values['UnitTestList'].default_as_str, "'4,5,6'")
self.flag_values(['dummyscript', '--UnitTestList=7,8,9'])
self.assertListEqual(self.flag_values.UnitTestList, ['7', '8', '9'])
# Test that setting invalid defaults raises exceptions
with self.assertRaises(flags.IllegalFlagValueError):
self.flag_values.set_default('unittest_number', 'oops')
with self.assertRaises(flags.IllegalFlagValueError):
self.flag_values.set_default('unittest_number', -1)
class FlagsParsingTest(absltest.TestCase):
"""Testing different aspects of parsing: '-f' vs '--flag', etc."""
def setUp(self):
self.flag_values = flags.FlagValues()
def test_two_dash_arg_first(self):
flags.DEFINE_string(
'twodash_name', 'Bob', 'namehelp', flag_values=self.flag_values)
flags.DEFINE_string(
'twodash_blame', 'Rob', 'blamehelp', flag_values=self.flag_values)
argv = ('./program', '--', '--twodash_name=Harry')
argv = self.flag_values(argv)
self.assertEqual('Bob', self.flag_values.twodash_name)
self.assertEqual(argv[1], '--twodash_name=Harry')
def test_two_dash_arg_middle(self):
flags.DEFINE_string(
'twodash2_name', 'Bob', 'namehelp', flag_values=self.flag_values)
flags.DEFINE_string(
'twodash2_blame', 'Rob', 'blamehelp', flag_values=self.flag_values)
argv = ('./program', '--twodash2_blame=Larry', '--',
'--twodash2_name=Harry')
argv = self.flag_values(argv)
self.assertEqual('Bob', self.flag_values.twodash2_name)
self.assertEqual('Larry', self.flag_values.twodash2_blame)
self.assertEqual(argv[1], '--twodash2_name=Harry')
def test_one_dash_arg_first(self):
flags.DEFINE_string(
'onedash_name', 'Bob', 'namehelp', flag_values=self.flag_values)
flags.DEFINE_string(
'onedash_blame', 'Rob', 'blamehelp', flag_values=self.flag_values)
argv = ('./program', '-', '--onedash_name=Harry')
with _use_gnu_getopt(self.flag_values, False):
argv = self.flag_values(argv)
self.assertEqual(len(argv), 3)
self.assertEqual(argv[1], '-')
self.assertEqual(argv[2], '--onedash_name=Harry')
def test_required_flag_not_specified(self):
flags.DEFINE_string(
'str_flag',
default=None,
help='help',
required=True,
flag_values=self.flag_values)
argv = ('./program',)
with _use_gnu_getopt(self.flag_values, False):
with self.assertRaises(flags.IllegalFlagValueError):
self.flag_values(argv)
def test_required_arg_works_with_other_validators(self):
flags.DEFINE_integer(
'int_flag',
default=None,
help='help',
required=True,
lower_bound=4,
flag_values=self.flag_values)
argv = ('./program', '--int_flag=2')
with _use_gnu_getopt(self.flag_values, False):
with self.assertRaises(flags.IllegalFlagValueError):
self.flag_values(argv)
def test_unrecognized_flags(self):
flags.DEFINE_string('name', 'Bob', 'namehelp', flag_values=self.flag_values)
# Unknown flag --nosuchflag
try:
argv = ('./program', '--nosuchflag', '--name=Bob', 'extra')
self.flag_values(argv)
raise AssertionError('Unknown flag exception not raised')
except flags.UnrecognizedFlagError as e:
self.assertEqual(e.flagname, 'nosuchflag')
self.assertEqual(e.flagvalue, '--nosuchflag')
# Unknown flag -w (short option)
try:
argv = ('./program', '-w', '--name=Bob', 'extra')
self.flag_values(argv)
raise AssertionError('Unknown flag exception not raised')
except flags.UnrecognizedFlagError as e:
self.assertEqual(e.flagname, 'w')
self.assertEqual(e.flagvalue, '-w')
# Unknown flag --nosuchflagwithparam=foo
try:
argv = ('./program', '--nosuchflagwithparam=foo', '--name=Bob', 'extra')
self.flag_values(argv)
raise AssertionError('Unknown flag exception not raised')
except flags.UnrecognizedFlagError as e:
self.assertEqual(e.flagname, 'nosuchflagwithparam')
self.assertEqual(e.flagvalue, '--nosuchflagwithparam=foo')
# Allow unknown flag --nosuchflag if specified with undefok
argv = ('./program', '--nosuchflag', '--name=Bob', '--undefok=nosuchflag',
'extra')
argv = self.flag_values(argv)
self.assertEqual(len(argv), 2, 'wrong number of arguments pulled')
self.assertEqual(argv[0], './program', 'program name not preserved')
self.assertEqual(argv[1], 'extra', 'extra argument not preserved')
# Allow unknown flag --noboolflag if undefok=boolflag is specified
argv = ('./program', '--noboolflag', '--name=Bob', '--undefok=boolflag',
'extra')
argv = self.flag_values(argv)
self.assertEqual(len(argv), 2, 'wrong number of arguments pulled')
self.assertEqual(argv[0], './program', 'program name not preserved')
self.assertEqual(argv[1], 'extra', 'extra argument not preserved')
# But not if the flagname is misspelled:
try:
argv = ('./program', '--nosuchflag', '--name=Bob', '--undefok=nosuchfla',
'extra')
self.flag_values(argv)
raise AssertionError('Unknown flag exception not raised')
except flags.UnrecognizedFlagError as e:
self.assertEqual(e.flagname, 'nosuchflag')
try:
argv = ('./program', '--nosuchflag', '--name=Bob',
'--undefok=nosuchflagg', 'extra')
self.flag_values(argv)
raise AssertionError('Unknown flag exception not raised')
except flags.UnrecognizedFlagError as e:
self.assertEqual(e.flagname, 'nosuchflag')
# Allow unknown short flag -w if specified with undefok
argv = ('./program', '-w', '--name=Bob', '--undefok=w', 'extra')
argv = self.flag_values(argv)
self.assertEqual(len(argv), 2, 'wrong number of arguments pulled')
self.assertEqual(argv[0], './program', 'program name not preserved')
self.assertEqual(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 = self.flag_values(argv)
self.assertEqual(len(argv), 2, 'wrong number of arguments pulled')
self.assertEqual(argv[0], './program', 'program name not preserved')
self.assertEqual(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 = self.flag_values(argv)
self.assertEqual(len(argv), 2, 'wrong number of arguments pulled')
self.assertEqual(argv[0], './program', 'program name not preserved')
self.assertEqual(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')
self.flag_values(argv)
raise AssertionError('Unknown flag exception not raised')
except flags.UnrecognizedFlagError as e:
self.assertEqual(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')
self.flag_values(argv)
raise AssertionError('Missing option parameter exception not raised')
except flags.UnrecognizedFlagError:
raise AssertionError('Wrong kind of error exception raised')
except flags.Error:
pass
# Test --undefok <list>
argv = ('./program', '--nosuchflag', '-w', '--nosuchflagwithparam=foo',
'--name=Bob', '--undefok', 'nosuchflag,w,nosuchflagwithparam',
'extra')
argv = self.flag_values(argv)
self.assertEqual(len(argv), 2, 'wrong number of arguments pulled')
self.assertEqual(argv[0], './program', 'program name not preserved')
self.assertEqual(argv[1], 'extra', 'extra argument not preserved')
# Test incorrect --undefok with no value.
argv = ('./program', '--name=Bob', '--undefok')
with self.assertRaises(flags.Error):
self.flag_values(argv)
class NonGlobalFlagsTest(absltest.TestCase):
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)
self.assertEqual(len(argv), 2, 'wrong number of arguments pulled')
self.assertEqual(argv[0], './program', 'program name not preserved')
self.assertEqual(argv[1], 'extra', 'extra argument not preserved')
self.assertEqual(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.UnrecognizedFlagError as e:
self.assertEqual(e.flagname, 'nosuchflag')
argv = ('./program', '--nosuchflag', '--undefok=nosuchflag')
argv = nonglobal_flags(argv)
self.assertEqual(len(argv), 1, 'wrong number of arguments pulled')
self.assertEqual(argv[0], './program', 'program name not preserved')
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.
_ = flags.Error()
_ = flags.Error('message')
_ = flags.DuplicateFlagError()
_ = flags.DuplicateFlagError('message')
_ = flags.IllegalFlagValueError()
_ = flags.IllegalFlagValueError('message')
def test_flag_values_del_attr(self):
"""Checks that del self.flag_values.flag_id works."""
default_value = 'default value for test_flag_values_del_attr'
# 1. Declare and delete a flag with no short name.
flag_values = flags.FlagValues()
flags.DEFINE_string(
'delattr_foo', default_value, 'A simple flag.', flag_values=flag_values)
flag_values.mark_as_parsed()
self.assertEqual(flag_values.delattr_foo, default_value)
flag_obj = flag_values['delattr_foo']
# We also check that _FlagIsRegistered works as expected :)
self.assertTrue(flag_values._flag_is_registered(flag_obj))
del flag_values.delattr_foo
self.assertFalse('delattr_foo' in flag_values._flags())
self.assertFalse(flag_values._flag_is_registered(flag_obj))
# If the previous del FLAGS.delattr_foo did not work properly, the
# next definition will trigger a redefinition error.
flags.DEFINE_integer(
'delattr_foo', 3, 'A simple flag.', flag_values=flag_values)
del flag_values.delattr_foo
self.assertFalse('delattr_foo' in flag_values)
# 2. Declare and delete a flag with a short name.
flags.DEFINE_string(
'delattr_bar',
default_value,
'flag with short name',
short_name='x5',
flag_values=flag_values)
flag_obj = flag_values['delattr_bar']
self.assertTrue(flag_values._flag_is_registered(flag_obj))
del flag_values.x5
self.assertTrue(flag_values._flag_is_registered(flag_obj))
del flag_values.delattr_bar
self.assertFalse(flag_values._flag_is_registered(flag_obj))
# 3. Just like 2, but del flag_values.name last
flags.DEFINE_string(
'delattr_bar',
default_value,
'flag with short name',
short_name='x5',
flag_values=flag_values)
flag_obj = flag_values['delattr_bar']
self.assertTrue(flag_values._flag_is_registered(flag_obj))
del flag_values.delattr_bar
self.assertTrue(flag_values._flag_is_registered(flag_obj))
del flag_values.x5
self.assertFalse(flag_values._flag_is_registered(flag_obj))
self.assertFalse('delattr_bar' in flag_values)
self.assertFalse('x5' in flag_values)
def test_list_flag_format(self):
"""Tests for correctly-formatted list flags."""
fv = flags.FlagValues()
flags.DEFINE_list('listflag', '', 'A list of arguments', flag_values=fv)
def _check_parsing(listval):
"""Parse a particular value for our test flag, --listflag."""
argv = fv(['./program', '--listflag=' + listval, 'plain-arg'])
self.assertEqual(['./program', 'plain-arg'], argv)
return fv.listflag
# Basic success case
self.assertEqual(_check_parsing('foo,bar'), ['foo', 'bar'])
# Success case: newline in argument is quoted.
self.assertEqual(_check_parsing('"foo","bar\nbar"'), ['foo', 'bar\nbar'])
# Failure case: newline in argument is unquoted.
self.assertRaises(flags.IllegalFlagValueError, _check_parsing,
'"foo",bar\nbar')
# Failure case: unmatched ".
self.assertRaises(flags.IllegalFlagValueError, _check_parsing,
'"foo,barbar')
def test_flag_definition_via_setitem(self):
with self.assertRaises(flags.IllegalFlagValueError):
flag_values = flags.FlagValues()
flag_values['flag_name'] = 'flag_value'
class SetDefaultTest(absltest.TestCase):
def setUp(self):
super().setUp()
self.flag_values = flags.FlagValues()
def test_success(self):
int_holder = flags.DEFINE_integer(
'an_int', 1, 'an int', flag_values=self.flag_values)
flags.set_default(int_holder, 2)
self.flag_values.mark_as_parsed()
self.assertEqual(int_holder.value, 2)
def test_update_after_parse(self):
int_holder = flags.DEFINE_integer(
'an_int', 1, 'an int', flag_values=self.flag_values)
self.flag_values.mark_as_parsed()
flags.set_default(int_holder, 2)
self.assertEqual(int_holder.value, 2)
def test_overridden_by_explicit_assignment(self):
int_holder = flags.DEFINE_integer(
'an_int', 1, 'an int', flag_values=self.flag_values)
self.flag_values.mark_as_parsed()
self.flag_values.an_int = 3
flags.set_default(int_holder, 2)
self.assertEqual(int_holder.value, 3)
def test_restores_back_to_none(self):
int_holder = flags.DEFINE_integer(
'an_int', None, 'an int', flag_values=self.flag_values)
self.flag_values.mark_as_parsed()
flags.set_default(int_holder, 3)
flags.set_default(int_holder, None)
self.assertIsNone(int_holder.value)
def test_failure_on_invalid_type(self):
int_holder = flags.DEFINE_integer(
'an_int', 1, 'an int', flag_values=self.flag_values)
self.flag_values.mark_as_parsed()
with self.assertRaises(flags.IllegalFlagValueError):
flags.set_default(int_holder, 'a')
def test_failure_on_type_protected_none_default(self):
int_holder = flags.DEFINE_integer(
'an_int', 1, 'an int', flag_values=self.flag_values)
self.flag_values.mark_as_parsed()
flags.set_default(int_holder, None) # NOTE: should be a type failure
with self.assertRaises(flags.IllegalFlagValueError):
_ = int_holder.value # Will also fail on later access.
class KeyFlagsTest(absltest.TestCase):
def setUp(self):
self.flag_values = flags.FlagValues()
def _get_names_of_defined_flags(self, module, flag_values):
"""Returns the list of names of flags defined by a module.
Auxiliary for the test_key_flags* methods.
Args:
module: A module object or a string module name.
flag_values: A FlagValues object.
Returns:
A list of strings.
"""
return [f.name for f in flag_values.get_flags_for_module(module)]
def _get_names_of_key_flags(self, module, flag_values):
"""Returns the list of names of key flags for a module.
Auxiliary for the test_key_flags* methods.
Args:
module: A module object or a string module name.
flag_values: A FlagValues object.
Returns:
A list of strings.
"""
return [f.name for f in flag_values.get_key_flags_for_module(module)]
def _assert_lists_have_same_elements(self, list_1, list_2):
# Checks that two lists have the same elements with the same
# multiplicity, in possibly different order.
list_1 = list(list_1)
list_1.sort()
list_2 = list(list_2)
list_2.sort()
self.assertListEqual(list_1, list_2)
def test_key_flags(self):
flag_values = flags.FlagValues()
# Before starting any testing, make sure no flags are already
# defined for module_foo and module_bar.
self.assertListEqual(
self._get_names_of_key_flags(module_foo, flag_values), [])
self.assertListEqual(
self._get_names_of_key_flags(module_bar, flag_values), [])
self.assertListEqual(
self._get_names_of_defined_flags(module_foo, flag_values), [])
self.assertListEqual(
self._get_names_of_defined_flags(module_bar, flag_values), [])
# Defines a few flags in module_foo and module_bar.
module_foo.define_flags(flag_values=flag_values)
try:
# Part 1. Check that all flags defined by module_foo are key for
# that module, and similarly for module_bar.
for module in [module_foo, module_bar]:
self._assert_lists_have_same_elements(
flag_values.get_flags_for_module(module),
flag_values.get_key_flags_for_module(module))
# Also check that each module defined the expected flags.
self._assert_lists_have_same_elements(
self._get_names_of_defined_flags(module, flag_values),
module.names_of_defined_flags())
# Part 2. Check that flags.declare_key_flag works fine.
# Declare that some flags from module_bar are key for
# module_foo.
module_foo.declare_key_flags(flag_values=flag_values)
# Check that module_foo has the expected list of defined flags.
self._assert_lists_have_same_elements(
self._get_names_of_defined_flags(module_foo, flag_values),
module_foo.names_of_defined_flags())
# Check that module_foo has the expected list of key flags.
self._assert_lists_have_same_elements(
self._get_names_of_key_flags(module_foo, flag_values),
module_foo.names_of_declared_key_flags())
# Part 3. Check that flags.adopt_module_key_flags works fine.
# Trigger a call to flags.adopt_module_key_flags(module_bar)
# inside module_foo. This should declare a few more key
# flags in module_foo.
module_foo.declare_extra_key_flags(flag_values=flag_values)
# Check that module_foo has the expected list of key flags.
self._assert_lists_have_same_elements(
self._get_names_of_key_flags(module_foo, flag_values),
module_foo.names_of_declared_key_flags() +
module_foo.names_of_declared_extra_key_flags())
finally:
module_foo.remove_flags(flag_values=flag_values)
def test_key_flags_with_non_default_flag_values_object(self):
# Check that key flags work even when we use a FlagValues object
# that is not the default flags.self.flag_values object. Otherwise, this
# test is similar to test_key_flags, but it uses only module_bar.
# The other test module (module_foo) uses only the default values
# for the flag_values keyword arguments. This way, test_key_flags
# and this method test both the default FlagValues, the explicitly
# specified one, and a mixed usage of the two.
# A brand-new FlagValues object, to use instead of flags.self.flag_values.
fv = flags.FlagValues()
# Before starting any testing, make sure no flags are already
# defined for module_foo and module_bar.
self.assertListEqual(self._get_names_of_key_flags(module_bar, fv), [])
self.assertListEqual(self._get_names_of_defined_flags(module_bar, fv), [])
module_bar.define_flags(flag_values=fv)
# Check that all flags defined by module_bar are key for that
# module, and that module_bar defined the expected flags.
self._assert_lists_have_same_elements(
fv.get_flags_for_module(module_bar),
fv.get_key_flags_for_module(module_bar))
self._assert_lists_have_same_elements(
self._get_names_of_defined_flags(module_bar, fv),
module_bar.names_of_defined_flags())
# Pick two flags from module_bar, declare them as key for the
# current (i.e., main) module (via flags.declare_key_flag), and
# check that we get the expected effect. The important thing is
# that we always use flags_values=fv (instead of the default
# self.flag_values).
main_module = sys.argv[0]
names_of_flags_defined_by_bar = module_bar.names_of_defined_flags()
flag_name_0 = names_of_flags_defined_by_bar[0]
flag_name_2 = names_of_flags_defined_by_bar[2]
flags.declare_key_flag(flag_name_0, flag_values=fv)
self._assert_lists_have_same_elements(
self._get_names_of_key_flags(main_module, fv), [flag_name_0])
flags.declare_key_flag(flag_name_2, flag_values=fv)
self._assert_lists_have_same_elements(
self._get_names_of_key_flags(main_module, fv),
[flag_name_0, flag_name_2])
# Try with a special (not user-defined) flag too:
flags.declare_key_flag('undefok', flag_values=fv)
self._assert_lists_have_same_elements(
self._get_names_of_key_flags(main_module, fv),
[flag_name_0, flag_name_2, 'undefok'])
flags.adopt_module_key_flags(module_bar, fv)
self._assert_lists_have_same_elements(
self._get_names_of_key_flags(main_module, fv),
names_of_flags_defined_by_bar + ['undefok'])
# Adopt key flags from the flags module itself.
flags.adopt_module_key_flags(flags, flag_values=fv)
self._assert_lists_have_same_elements(
self._get_names_of_key_flags(main_module, fv),
names_of_flags_defined_by_bar + ['flagfile', 'undefok'])
def test_key_flags_with_flagholders(self):
main_module = sys.argv[0]
self.assertListEqual(
self._get_names_of_key_flags(main_module, self.flag_values), [])
self.assertListEqual(
self._get_names_of_defined_flags(main_module, self.flag_values), [])
int_holder = flags.DEFINE_integer(
'main_module_int_fg',
1,
'Integer flag in the main module.',
flag_values=self.flag_values)
flags.declare_key_flag(int_holder, self.flag_values)
self.assertCountEqual(
self.flag_values.get_flags_for_module(main_module),
self.flag_values.get_key_flags_for_module(main_module))
bool_holder = flags.DEFINE_boolean(
'main_module_bool_fg',
False,
'Boolean flag in the main module.',
flag_values=self.flag_values)
flags.declare_key_flag(bool_holder) # omitted flag_values
self.assertCountEqual(
self.flag_values.get_flags_for_module(main_module),
self.flag_values.get_key_flags_for_module(main_module))
self.assertLen(self.flag_values.get_flags_for_module(main_module), 2)
def test_main_module_help_with_key_flags(self):
# Similar to test_main_module_help, but this time we make sure to
# declare some key flags.
# Safety check that the main module does not declare any flags
# at the beginning of this test.
expected_help = ''
self.assertMultiLineEqual(expected_help,
self.flag_values.main_module_help())
# Define one flag in this main module and some flags in modules
# a and b. Also declare one flag from module a and one flag
# from module b as key flags for the main module.
flags.DEFINE_integer(
'main_module_int_fg',
1,
'Integer flag in the main module.',
flag_values=self.flag_values)
try:
main_module_int_fg_help = (
' --main_module_int_fg: Integer flag in the main module.\n'
" (default: '1')\n"
' (an integer)')
expected_help += '\n%s:\n%s' % (sys.argv[0], main_module_int_fg_help)
self.assertMultiLineEqual(expected_help,
self.flag_values.main_module_help())
# The following call should be a no-op: any flag declared by a
# module is automatically key for that module.
flags.declare_key_flag('main_module_int_fg', flag_values=self.flag_values)
self.assertMultiLineEqual(expected_help,
self.flag_values.main_module_help())
# The definition of a few flags in an imported module should not
# change the main module help.
module_foo.define_flags(flag_values=self.flag_values)
self.assertMultiLineEqual(expected_help,
self.flag_values.main_module_help())
flags.declare_key_flag('tmod_foo_bool', flag_values=self.flag_values)
tmod_foo_bool_help = (
' --[no]tmod_foo_bool: Boolean flag from module foo.\n'
" (default: 'true')")
expected_help += '\n' + tmod_foo_bool_help
self.assertMultiLineEqual(expected_help,
self.flag_values.main_module_help())
flags.declare_key_flag('tmod_bar_z', flag_values=self.flag_values)
tmod_bar_z_help = (
' --[no]tmod_bar_z: Another boolean flag from module bar.\n'
" (default: 'false')")
# Unfortunately, there is some flag sorting inside
# main_module_help, so we can't keep incrementally extending
# the expected_help string ...
expected_help = ('\n%s:\n%s\n%s\n%s' %
(sys.argv[0], main_module_int_fg_help, tmod_bar_z_help,
tmod_foo_bool_help))
self.assertMultiLineEqual(self.flag_values.main_module_help(),
expected_help)
finally:
# At the end, delete all the flag information we created.
self.flag_values.__delattr__('main_module_int_fg')
module_foo.remove_flags(flag_values=self.flag_values)
def test_adoptmodule_key_flags(self):
# Check that adopt_module_key_flags raises an exception when
# called with a module name (as opposed to a module object).
self.assertRaises(flags.Error, flags.adopt_module_key_flags, 'pyglib.app')
def test_disclaimkey_flags(self):
original_disclaim_module_ids = _helpers.disclaim_module_ids
_helpers.disclaim_module_ids = set(_helpers.disclaim_module_ids)
try:
module_bar.disclaim_key_flags()
module_foo.define_bar_flags(flag_values=self.flag_values)
module_name = self.flag_values.find_module_defining_flag('tmod_bar_x')
self.assertEqual(module_foo.__name__, module_name)
finally:
_helpers.disclaim_module_ids = original_disclaim_module_ids
class FindModuleTest(absltest.TestCase):
"""Testing methods that find a module that defines a given flag."""
def test_find_module_defining_flag(self):
self.assertEqual(
'default',
FLAGS.find_module_defining_flag('__NON_EXISTENT_FLAG__', 'default'))
self.assertEqual(module_baz.__name__,
FLAGS.find_module_defining_flag('tmod_baz_x'))
def test_find_module_id_defining_flag(self):
self.assertEqual(
'default',
FLAGS.find_module_id_defining_flag('__NON_EXISTENT_FLAG__', 'default'))
self.assertEqual(
id(module_baz), FLAGS.find_module_id_defining_flag('tmod_baz_x'))
def test_find_module_defining_flag_passing_module_name(self):
my_flags = flags.FlagValues()
module_name = sys.__name__ # Must use an existing module.
flags.DEFINE_boolean(
'flag_name',
True,
'Flag with a different module name.',
flag_values=my_flags,
module_name=module_name)
self.assertEqual(module_name,
my_flags.find_module_defining_flag('flag_name'))
def test_find_module_id_defining_flag_passing_module_name(self):
my_flags = flags.FlagValues()
module_name = sys.__name__ # Must use an existing module.
flags.DEFINE_boolean(
'flag_name',
True,
'Flag with a different module name.',
flag_values=my_flags,
module_name=module_name)
self.assertEqual(
id(sys), my_flags.find_module_id_defining_flag('flag_name'))
class FlagsErrorMessagesTest(absltest.TestCase):
"""Testing special cases for integer and float flags error messages."""
def setUp(self):
self.flag_values = flags.FlagValues()
def test_integer_error_text(self):
# Make sure we get proper error text
flags.DEFINE_integer(
'positive',
4,
'non-negative flag',
lower_bound=1,
flag_values=self.flag_values)
flags.DEFINE_integer(
'non_negative',
4,
'positive flag',
lower_bound=0,
flag_values=self.flag_values)
flags.DEFINE_integer(
'negative',
-4,
'negative flag',
upper_bound=-1,
flag_values=self.flag_values)
flags.DEFINE_integer(
'non_positive',
-4,
'non-positive flag',
upper_bound=0,
flag_values=self.flag_values)
flags.DEFINE_integer(
'greater',
19,
'greater-than flag',
lower_bound=4,
flag_values=self.flag_values)
flags.DEFINE_integer(
'smaller',
-19,
'smaller-than flag',
upper_bound=4,
flag_values=self.flag_values)
flags.DEFINE_integer(
'usual',
4,
'usual flag',
lower_bound=0,
upper_bound=10000,
flag_values=self.flag_values)
flags.DEFINE_integer(
'another_usual',
0,
'usual flag',
lower_bound=-1,
upper_bound=1,
flag_values=self.flag_values)
self._check_error_message('positive', -4, 'a positive integer')
self._check_error_message('non_negative', -4, 'a non-negative integer')
self._check_error_message('negative', 0, 'a negative integer')
self._check_error_message('non_positive', 4, 'a non-positive integer')
self._check_error_message('usual', -4, 'an integer in the range [0, 10000]')
self._check_error_message('another_usual', 4,
'an integer in the range [-1, 1]')
self._check_error_message('greater', -5, 'integer >= 4')
self._check_error_message('smaller', 5, 'integer <= 4')
def test_float_error_text(self):
flags.DEFINE_float(
'positive',
4,
'non-negative flag',
lower_bound=1,
flag_values=self.flag_values)
flags.DEFINE_float(
'non_negative',
4,
'positive flag',
lower_bound=0,
flag_values=self.flag_values)
flags.DEFINE_float(
'negative',
-4,
'negative flag',
upper_bound=-1,
flag_values=self.flag_values)
flags.DEFINE_float(
'non_positive',
-4,
'non-positive flag',
upper_bound=0,
flag_values=self.flag_values)
flags.DEFINE_float(
'greater',
19,
'greater-than flag',
lower_bound=4,
flag_values=self.flag_values)
flags.DEFINE_float(
'smaller',
-19,
'smaller-than flag',
upper_bound=4,
flag_values=self.flag_values)
flags.DEFINE_float(
'usual',
4,
'usual flag',
lower_bound=0,
upper_bound=10000,
flag_values=self.flag_values)
flags.DEFINE_float(
'another_usual',
0,
'usual flag',
lower_bound=-1,
upper_bound=1,
flag_values=self.flag_values)
self._check_error_message('positive', 0.5, 'number >= 1')
self._check_error_message('non_negative', -4.0, 'a non-negative number')
self._check_error_message('negative', 0.5, 'number <= -1')
self._check_error_message('non_positive', 4.0, 'a non-positive number')
self._check_error_message('usual', -4.0, 'a number in the range [0, 10000]')
self._check_error_message('another_usual', 4.0,
'a number in the range [-1, 1]')
self._check_error_message('smaller', 5.0, 'number <= 4')
def _check_error_message(self, flag_name, flag_value,
expected_message_suffix):
"""Set a flag to a given value and make sure we get expected message."""
try:
self.flag_values.__setattr__(flag_name, flag_value)
raise AssertionError('Bounds exception not raised!')
except flags.IllegalFlagValueError as e:
expected = ('flag --%(name)s=%(value)s: %(value)s is not %(suffix)s' % {
'name': flag_name,
'value': flag_value,
'suffix': expected_message_suffix
})
self.assertEqual(str(e), expected)
if __name__ == '__main__':
absltest.main()
Reference in New Issue View Git Blame Copy Permalink