organicmaps/gflags
13
Fork 0
mirror of https://github.com/gflags/gflags.git synced 2025-04-06 05:55:05 +00:00
Code Issues 1 Projects Releases Wiki Activity Actions

gflags 0.2

Browse source 
git-svn-id: https://gflags.googlecode.com/svn/trunk@9 6586e3c6-dcc4-952a-343f-ff74eb82781d
This commit is contained in:
Craig Silverstein 2007-03-22 00:18:13 +00:00
parent b9f23483e1
commit 573580dcd6
10 changed files with 2392 additions and 108 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
ChangeLog
View file

@ -6,3 +6,9 @@ Wed Dec 13 12:37:19 2006 Google Inc. <opensource@google.com>
has increased flexibility, including built-in support for C++
types like string, and the ability to define flags in the source
file in which they're used.
Mon Jan 22 15:33:06 2007 Google Inc. <opensource@google.com>
* google-gflags: version 0.2
* added support for python commandlineflags, as well as c++
* gflags2man, a script to turn flags into a man page (dchristian)

17
README
View file

@ -1 +1,16 @@
TODO
This repository contains both a C++ and a python implementation of the
Google commandline flags module. Documentation for the C++
implementation is in doc/. Documentation for the python
implementation is at the top of gflags/flags.py.
See INSTALL for (generic) installation instructions for C++: basically
./configure && make && make install
To install the python module, run
cd python; python ./setup.py install
When you install the python library, you also get a helper
application, gflags2man.py, installed into /usr/local/bin. You can
run gflags2man.py to create an instant man page, with all the
commandline flags and their docs, for any C++ or python program you've
written using the gflags library.

20
configure vendored
View file

@ -1,6 +1,6 @@
#! /bin/sh
# Guess values for system-dependent variables and create Makefiles.
# Generated by GNU Autoconf 2.59 for gflags 0.1.
# Generated by GNU Autoconf 2.59 for gflags 0.2.
#
# Report bugs to <opensource@google.com>.
#
@ -423,8 +423,8 @@ SHELL=${CONFIG_SHELL-/bin/sh}
# Identity of this package.
PACKAGE_NAME='gflags'
PACKAGE_TARNAME='gflags'
PACKAGE_VERSION='0.1'
PACKAGE_STRING='gflags 0.1'
PACKAGE_VERSION='0.2'
PACKAGE_STRING='gflags 0.2'
PACKAGE_BUGREPORT='opensource@google.com'
ac_unique_file="README"
@ -954,7 +954,7 @@ if test "$ac_init_help" = "long"; then
# Omit some internal or obsolete options to make the list less imposing.
# This message is too long to be a string in the A/UX 3.1 sh.
cat <<_ACEOF
\`configure' configures gflags 0.1 to adapt to many kinds of systems.
\`configure' configures gflags 0.2 to adapt to many kinds of systems.
Usage: $0 [OPTION]... [VAR=VALUE]...
@ -1020,7 +1020,7 @@ fi
if test -n "$ac_init_help"; then
case $ac_init_help in
short | recursive ) echo "Configuration of gflags 0.1:";;
short | recursive ) echo "Configuration of gflags 0.2:";;
esac
cat <<\_ACEOF
@ -1163,7 +1163,7 @@ fi
test -n "$ac_init_help" && exit 0
if $ac_init_version; then
cat <<\_ACEOF
gflags configure 0.1
gflags configure 0.2
generated by GNU Autoconf 2.59
Copyright (C) 2003 Free Software Foundation, Inc.
@ -1177,7 +1177,7 @@ cat >&5 <<_ACEOF
This file contains any messages produced by compilers while
running configure, to aid debugging if configure makes a mistake.
It was created by gflags $as_me 0.1, which was
It was created by gflags $as_me 0.2, which was
generated by GNU Autoconf 2.59. Invocation command line was
$ $0 $@
@ -1823,7 +1823,7 @@ fi
# Define the identity of the package.
PACKAGE='gflags'
VERSION='0.1'
VERSION='0.2'
cat >>confdefs.h <<_ACEOF
@ -21158,7 +21158,7 @@ _ASBOX
} >&5
cat >&5 <<_CSEOF
This file was extended by gflags $as_me 0.1, which was
This file was extended by gflags $as_me 0.2, which was
generated by GNU Autoconf 2.59. Invocation command line was
CONFIG_FILES = $CONFIG_FILES
@ -21221,7 +21221,7 @@ _ACEOF
cat >>$CONFIG_STATUS <<_ACEOF
ac_cs_version="\\
gflags config.status 0.1
gflags config.status 0.2
configured by $0, generated by GNU Autoconf 2.59,
with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"

2
configure.ac
View file

@ -10,7 +10,7 @@
# make sure we're interpreted by some minimal autoconf
AC_PREREQ(2.57)
AC_INIT(gflags, 0.1, opensource@google.com)
AC_INIT(gflags, 0.2, opensource@google.com)
# The argument here is just something that should be in the current directory
# (for sanity checking)
AC_CONFIG_SRCDIR(README)

5
packages/rpm/rpm.spec
View file

@ -8,11 +8,11 @@ Summary: A commandline flags library that allows for distributed flags
Version: %ver
Release: %rel
Group: Development/Libraries
URL: http://goog-gflags.sourceforge.net
URL: http://code.google.com/p/google-gflags
License: BSD
Vendor: Google
Packager: Google Inc. <opensource@google.com>
Source: http://goog-gflags.sourceforge.net/%{NAME}-%{PACKAGE_VERSION}.tar.gz
Source: http://google-gflags.googlecode.com/files/%{NAME}-%{PACKAGE_VERSION}.tar.gz
Distribution: Redhat 7 and above.
Buildroot: %{_tmppath}/%{name}-root
Prefix: %prefix
@ -61,7 +61,6 @@ rm -rf $RPM_BUILD_ROOT
%defattr(-,root,root)
%{prefix}/include/google
%{prefix}/lib/debug
%{prefix}/lib/libgflags.a
%{prefix}/lib/libgflags.la
%{prefix}/lib/libgflags.so

1368
python/gflags.py Executable file
View file

File diff suppressed because it is too large Load diff

239
contrib/gflags2man.py → python/gflags2man.py
View file

@ -1,6 +1,33 @@
#!/usr/bin/python2.4
#!/usr/bin/env python
#
# Copyright 2006 Google Inc. All Rights Reserved.
# Copyright (c) 2007, Google Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above
# copyright notice, this list of conditions and the following disclaimer
# in the documentation and/or other materials provided with the
# distribution.
# * Neither the name of Google Inc. nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"""gflags2man runs a Google flags base program and generates a man page.
@ -8,26 +35,29 @@ Run the program, parse the output, and then format that into a man
page.
Usage:
gflags2man program...
gflags2man <program> [program] ...
"""
# TODO(csilvers): work with windows paths (\) as well as unix (/)
# This may seem a bit of an end run, but it: doesn't bloat flags, can
# support python/java/C++, supports older executables, and can be
# extended to other document formats.
# Inspired by help2man.
__author__ = 'dchristian@google.com (Dan Christian)'
__author__ = 'Dan Christian'
import os
import re
import sys
import stat
import datetime
import time
import subprocess
from google3.pyglib import app
from google3.pyglib import flags
from google3.pyglib import logging
import gflags
_VERSION = '0.1'
def _GetDefaultDestDir():
home = os.environ.get('HOME', '')
@ -35,17 +65,29 @@ def _GetDefaultDestDir():
if home and os.path.exists(homeman):
return homeman
else:
return '/tmp'
return os.environ.get('TMPDIR', '/tmp')
FLAGS = flags.FLAGS
flags.DEFINE_string('dest_dir', _GetDefaultDestDir(),
'Directory to write resulting manpage to.'
' Specify \'-\' for stdout')
flags.DEFINE_string('help_flag', '--help',
'Option to pass to target program in to get help')
FLAGS = gflags.FLAGS
gflags.DEFINE_string('dest_dir', _GetDefaultDestDir(),
'Directory to write resulting manpage to.'
' Specify \'-\' for stdout')
gflags.DEFINE_string('help_flag', '--help',
'Option to pass to target program in to get help')
gflags.DEFINE_integer('v', 0, 'verbosity level to use for output')
_MIN_VALID_USAGE_MSG = 9 # if fewer lines than this, help is suspect
class Logging:
"""A super-simple logging class"""
def error(self, msg): print >>sys.stderr, "ERROR: ", msg
def warn(self, msg): print >>sys.stderr, "WARNING: ", msg
def info(self, msg): print msg
def debug(self, msg): self.vlog(1, msg)
def vlog(self, level, msg):
if FLAGS.v >= level: print msg
logging = Logging()
MIN_VALID_USAGE_MSG = 9 # minimum output likely to be valid
_version = '0.1'
def GetRealPath(filename):
"""Given an executable filename, find in the PATH or find absolute path.
@ -55,7 +97,7 @@ def GetRealPath(filename):
Absolute version of filename.
None if filename could not be found locally, absolutely, or in PATH
"""
if '/' == filename[0]: # already absolute
if os.path.isabs(filename): # already absolute
return filename
if filename.startswith('./') or filename.startswith('../'): # relative
@ -65,7 +107,7 @@ def GetRealPath(filename):
for directory in path.split(':'):
tryname = os.path.join(directory, filename)
if os.path.exists(tryname):
if not directory or '/' != directory[0]: # directory is relative
if not os.path.isabs(directory): # relative directory
return os.path.abspath(tryname)
return tryname
if os.path.exists(filename):
@ -88,31 +130,31 @@ class Flag(object):
class ProgramInfo(object):
"""All the information gleened from running a program with --help."""
"""All the information gleaned from running a program with --help."""
# Match a module block start
# google3.pyglib.logging:
# Match a module block start, for python scripts --help
# "goopy.logging:"
module_py_re = re.compile(r'(\S.+):$')
# match the start of a flag listing
# -v,--verbosity: Logging verbosity
# " -v,--verbosity: Logging verbosity"
flag_py_re = re.compile(r'\s+(-\S+):\s+(.*)$')
# (default: '0')
# " (default: '0')"
flag_default_py_re = re.compile(r'\s+\(default:\s+\'(.*)\'\)$')
# (an integer)
# " (an integer)"
flag_tips_py_re = re.compile(r'\s+\((.*)\)$')
# Match a module block start
# google3/base/commandlineflags
# Match a module block start, for c++ programs --help
# "google/base/commandlineflags"
module_c_re = re.compile(r'\s+Flags from (\S.+):$')
# match the start of a flag listing
# -v,--verbosity: Logging verbosity
# " -v,--verbosity: Logging verbosity"
flag_c_re = re.compile(r'\s+(-\S+)\s+(.*)$')
# Match a module block start
# com.google.common.flags
# Match a module block start, for java programs --help
# "com.google.common.flags"
module_java_re = re.compile(r'\s+Flags for (\S.+):$')
# match the start of a flag listing
# -v,--verbosity: Logging verbosity
# " -v,--verbosity: Logging verbosity"
flag_java_re = re.compile(r'\s+(-\S+)\s+(.*)$')
def __init__(self, executable):
@ -121,29 +163,29 @@ class ProgramInfo(object):
executable Program to execute (string)
"""
self.long_name = executable
self.name = os.path.basename(executable) # name
self.name = os.path.basename(executable) # name
# Get name without extension (PAR files)
self.short_name, self.ext = os.path.splitext(self.name)
self.executable = GetRealPath(executable) # name of the program
self.output = [] # output from the program. List of lines.
self.desc = [] # top level description. List of lines
self.modules = {} # { section_name(string), [ flags ] }
self.module_list = [] # list of module names in their original order
self.date = datetime.date.today() # default date info
(self.short_name, self.ext) = os.path.splitext(self.name)
self.executable = GetRealPath(executable) # name of the program
self.output = [] # output from the program. List of lines.
self.desc = [] # top level description. List of lines
self.modules = {} # { section_name(string), [ flags ] }
self.module_list = [] # list of module names in their original order
self.date = time.localtime(time.time()) # default date info
def Run(self):
"""Run it and collect output.
Returns:
True If everything went well.
False If there were problems.
1 (true) If everything went well.
0 (false) If there were problems.
"""
if not self.executable:
logging.error('Could not locate "%s"' % self.long_name)
return False
return 0
finfo = os.stat(self.executable)
self.date = datetime.date.fromtimestamp(finfo[stat.ST_MTIME])
self.date = time.localtime(finfo[stat.ST_MTIME])
logging.info('Running: %s %s </dev/null 2>&1'
% (self.executable, FLAGS.help_flag))
@ -157,70 +199,71 @@ class ProgramInfo(object):
stdin=open('/dev/null', 'r'))
except OSError, msg:
logging.error('Error executing "%s": %s' % (self.name, msg))
return False
return 0
#read output progressively so the pipe doesn't fill up (fileutil).
# read output progressively so the pipe doesn't fill up (fileutil).
self.output = runstate.stdout.readlines()
status = runstate.wait()
logging.debug('Program exited with %s' % status)
output = runstate.communicate()[0]
if output:
self.output = output.splitlines()
if len(self.output) < MIN_VALID_USAGE_MSG:
if len(self.output) < _MIN_VALID_USAGE_MSG:
logging.error(
'Error: "%s %s" returned %d and only %d lines: %s'
% (self.name, FLAGS.help_flag, status, len(self.output), output))
return False
return True
return 0
return 1
def Parse(self):
"""Parse program output."""
cnt, lang = self.ParseDesc()
if cnt < 0:
(start_line, lang) = self.ParseDesc()
if start_line < 0:
return
if 'python' == lang:
self.ParsePythonFlags(cnt)
self.ParsePythonFlags(start_line)
elif 'c' == lang:
self.ParseCFlags(cnt)
self.ParseCFlags(start_line)
elif 'java' == lang:
self.ParseJavaFlags(cnt)
self.ParseJavaFlags(start_line)
def ParseDesc(self, cnt=0):
def ParseDesc(self, start_line=0):
"""Parse the initial description.
This could be Python or C++.
Returns:
(line_count, lang_type)
line_count Line to start parsing flags on (int)
(start_line, lang_type)
start_line Line to start parsing flags on (int)
lang_type Either 'python' or 'c'
(-1, '') if the flags start could not be found
"""
exec_mod_start = self.executable + ':'
after_blank = False
cnt = 0
for cnt in range(cnt, len(self.output)): # collect top description
line = self.output[cnt].rstrip()
after_blank = 0
start_line = 0 # ignore the passed-in arg for now (?)
for start_line in range(start_line, len(self.output)): # collect top description
line = self.output[start_line].rstrip()
# Python flags start with 'flags:\n'
if ('flags:' == line
and len(self.output) > cnt+1 and '' == self.output[cnt+1].rstrip()):
cnt += 2
and len(self.output) > start_line+1
and '' == self.output[start_line+1].rstrip()):
start_line += 2
logging.debug('Flags start (python): %s' % line)
return (cnt, 'python')
return (start_line, 'python')
# SWIG flags just have the module name followed by colon.
if exec_mod_start == line:
logging.debug('Flags start (swig): %s' % line)
return (cnt, 'python')
return (start_line, 'python')
# C++ flags begin after a blank line and with a constant string
if after_blank and line.startswith(' Flags from '):
logging.debug('Flags start (c): %s' % line)
return (cnt, 'c')
return (start_line, 'c')
# java flags begin with a constant string
if line == 'where flags are':
logging.debug('Flags start (java): %s' % line)
cnt += 2 # skip "Standard flags:"
return (cnt, 'java')
start_line += 2 # skip "Standard flags:"
return (start_line, 'java')
logging.debug('Desc: %s' % line)
self.desc.append(line)
@ -230,12 +273,13 @@ class ProgramInfo(object):
% self.long_name)
return (-1, '')
def ParsePythonFlags(self, cnt=0):
def ParsePythonFlags(self, start_line=0):
"""Parse python/swig style flags."""
modname = None # name of current module
modlist = []
flag = None
for cnt in range(cnt, len(self.output)): # collect flags
line = self.output[cnt].rstrip()
for line_num in range(start_line, len(self.output)): # collect flags
line = self.output[line_num].rstrip()
if not line: # blank
continue
@ -278,12 +322,13 @@ class ProgramInfo(object):
if flag:
modlist.append(flag)
def ParseCFlags(self, cnt=0):
def ParseCFlags(self, start_line=0):
"""Parse C style flags."""
modname = None # name of current module
modlist = []
flag = None
for cnt in range(cnt, len(self.output)): # collect flags
line = self.output[cnt].rstrip()
for line_num in range(start_line, len(self.output)): # collect flags
line = self.output[line_num].rstrip()
if not line: # blank lines terminate flags
if flag: # save last flag
modlist.append(flag)
@ -318,7 +363,7 @@ class ProgramInfo(object):
if flag:
modlist.append(flag)
def ParseJavaFlags(self, cnt=0):
def ParseJavaFlags(self, start_line=0):
"""Parse Java style flags (com.google.common.flags)."""
# The java flags prints starts with a "Standard flags" "module"
# that doesn't follow the standard module syntax.
@ -328,8 +373,8 @@ class ProgramInfo(object):
modlist = self.modules[modname]
flag = None
for cnt in range(cnt, len(self.output)): # collect flags
line = self.output[cnt].rstrip()
for line_num in range(start_line, len(self.output)): # collect flags
line = self.output[line_num].rstrip()
logging.vlog(2, 'Line: "%s"' % line)
if not line: # blank lines terminate module
if flag: # save last flag
@ -371,9 +416,9 @@ class ProgramInfo(object):
self.short_desc = ''
return
for cnt in range(len(self.desc)): # replace full path with name
if self.desc[cnt].find(self.executable) >= 0:
self.desc[cnt] = self.desc[cnt].replace(self.executable, self.name)
for i in range(len(self.desc)): # replace full path with name
if self.desc[i].find(self.executable) >= 0:
self.desc[i] = self.desc[i].replace(self.executable, self.name)
self.short_desc = self.desc[0]
word_list = self.short_desc.split(' ')
@ -407,6 +452,11 @@ class GenerateDoc(object):
self.Body()
self.Footer()
def Open(self): raise NotImplementedError # define in subclass
def Header(self): raise NotImplementedError # define in subclass
def Body(self): raise NotImplementedError # define in subclass
def Footer(self): raise NotImplementedError # define in subclass
class GenerateMan(GenerateDoc):
"""Output a man page."""
@ -431,10 +481,10 @@ class GenerateMan(GenerateDoc):
def Header(self):
self.fp.write(
'.\\" DO NOT MODIFY THIS FILE! It was generated by gflags2man %s\n'
% _version)
% _VERSION)
self.fp.write(
'.TH %s "1" "%s" "%s" "User Commands"\n'
% (self.info.name, self.info.date.strftime('%x'), self.info.name))
% (self.info.name, time.strftime('%x', self.info.date), self.info.name))
self.fp.write(
'.SH NAME\n%s \\- %s\n' % (self.info.name, self.info.short_desc))
self.fp.write(
@ -455,30 +505,33 @@ class GenerateMan(GenerateDoc):
mod = modname
self.fp.write('\n.P\n.I %s\n' % mod)
for flag in self.info.modules[modname]:
help = flag.help
help_string = flag.help
if flag.default or flag.tips:
help += '\n.br\n'
help_string += '\n.br\n'
if flag.default:
help += ' (default: \'%s\')' % flag.default
help_string += ' (default: \'%s\')' % flag.default
if flag.tips:
help += ' (%s)' % flag.tips
help_string += ' (%s)' % flag.tips
self.fp.write(
'.TP\n%s\n%s\n' % (flag.desc, help))
'.TP\n%s\n%s\n' % (flag.desc, help_string))
def Footer(self):
self.fp.write(
'.SH COPYRIGHT\nCopyright \(co %s Google.\n'
% self.info.date.strftime('%Y'))
self.fp.write('Gflags2man.par created this page from "%s %s" output.\n'
% time.strftime('%Y', self.info.date))
self.fp.write('Gflags2man created this page from "%s %s" output.\n'
% (self.info.name, FLAGS.help_flag))
self.fp.write('\nGflags2man.par was written by Dan Christian'
' (dchristian@google.com). Note that the date on this'
self.fp.write('\nGflags2man was written by Dan Christian. '
' Note that the date on this'
' page is the modification date of %s.\n' % self.info.name)
def main(argv):
argv = FLAGS(argv) # handles help as well
if len(argv) <= 1:
app.usage(shorthelp=1)
print >>sys.stderr, __doc__
print >>sys.stderr, "flags:"
print >>sys.stderr, str(FLAGS)
return 1
for arg in argv[1:]:
@ -489,7 +542,7 @@ def main(argv):
prog.Filter()
doc = GenerateMan(prog, FLAGS.dest_dir)
doc.Output()
return 0
if __name__ == '__main__':
app.run()
main(sys.argv)

800
python/gflags_unittest.py Executable file
View file

@ -0,0 +1,800 @@
#!/usr/bin/env python
# Copyright (c) 2007, Google Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above
# copyright notice, this list of conditions and the following disclaimer
# in the documentation and/or other materials provided with the
# distribution.
# * Neither the name of Google Inc. nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"Unittest for flags.py module"
__pychecker__ = "no-local" # for unittest
import sys
import os
import shutil
import unittest
# We use the name 'flags' internally in this test, for historical reasons.
# Don't do this yourself! :-) Just do 'import gflags; FLAGS=gflags.FLAGS; etc'
import gflags as flags
FLAGS=flags.FLAGS
class FlagsUnitTest(unittest.TestCase):
"Flags Unit Test"
def test_flags(self):
##############################################
# Test normal usage with no (expected) errors.
# Define flags
number_test_framework_flags = len(FLAGS.RegisteredFlags())
repeatHelp = "how many times to repeat (0-5)"
flags.DEFINE_integer("repeat", 4, repeatHelp,
lower_bound=0, short_name='r')
flags.DEFINE_string("name", "Bob", "namehelp")
flags.DEFINE_boolean("debug", 0, "debughelp")
flags.DEFINE_boolean("q", 1, "quiet mode")
flags.DEFINE_boolean("quack", 0, "superstring of 'q'")
flags.DEFINE_boolean("noexec", 1, "boolean flag with no as prefix")
flags.DEFINE_integer("x", 3, "how eXtreme to be")
flags.DEFINE_integer("l", 0x7fffffff00000000L, "how long to be")
assert FLAGS.repeat == 4, "integer default values not set:" + FLAGS.repeat
assert FLAGS.name == 'Bob', "default values not set:" + FLAGS.name
assert FLAGS.debug == 0, "boolean default values not set:" + FLAGS.debug
assert FLAGS.q == 1, "boolean default values not set:" + FLAGS.q
assert FLAGS.x == 3, "integer default values not set:" + FLAGS.x
assert FLAGS.l == 0x7fffffff00000000L, "integer default values not set:" + FLAGS.l
flag_values = FLAGS.FlagValuesDict()
assert flag_values['repeat'] == 4
assert flag_values['name'] == 'Bob'
assert flag_values['debug'] == 0
assert flag_values['r'] == 4 # short for of repeat
assert flag_values['q'] == 1
assert flag_values['quack'] == 0
assert flag_values['x'] == 3
assert flag_values['l'] == 0x7fffffff00000000L
# Verify string form of defaults
assert FLAGS['repeat'].default_as_str == "'4'"
assert FLAGS['name'].default_as_str == "'Bob'"
assert FLAGS['debug'].default_as_str == "'false'"
assert FLAGS['q'].default_as_str == "'true'"
assert FLAGS['quack'].default_as_str == "'false'"
assert FLAGS['noexec'].default_as_str == "'true'"
assert FLAGS['x'].default_as_str == "'3'"
assert FLAGS['l'].default_as_str == "'9223372032559808512'"
# Verify that the iterator for flags yields all the keys
keys = list(FLAGS)
keys.sort()
reg_flags = FLAGS.RegisteredFlags()
reg_flags.sort()
self.assertEqual(keys, reg_flags)
# Parse flags
# .. empty command line
argv = ('./program',)
argv = FLAGS(argv)
assert len(argv) == 1, "wrong number of arguments pulled"
assert argv[0]=='./program', "program name not preserved"
# .. non-empty command line
argv = ('./program', '--debug', '--name=Bob', '-q', '--x=8')
argv = FLAGS(argv)
assert len(argv) == 1, "wrong number of arguments pulled"
assert argv[0]=='./program', "program name not preserved"
assert FLAGS['debug'].present == 1
FLAGS['debug'].present = 0 # Reset
assert FLAGS['name'].present == 1
FLAGS['name'].present = 0 # Reset
assert FLAGS['q'].present == 1
FLAGS['q'].present = 0 # Reset
assert FLAGS['x'].present == 1
FLAGS['x'].present = 0 # Reset
# Flags list
assert len(FLAGS.RegisteredFlags()) == 9 + number_test_framework_flags
assert 'name' in FLAGS.RegisteredFlags()
assert 'debug' in FLAGS.RegisteredFlags()
assert 'repeat' in FLAGS.RegisteredFlags()
assert 'r' in FLAGS.RegisteredFlags()
assert 'q' in FLAGS.RegisteredFlags()
assert 'quack' in FLAGS.RegisteredFlags()
assert 'x' in FLAGS.RegisteredFlags()
assert 'l' in FLAGS.RegisteredFlags()
# has_key
assert FLAGS.has_key('name')
assert not FLAGS.has_key('name2')
assert 'name' in FLAGS
assert 'name2' not in FLAGS
# try deleting a flag
del FLAGS.r
assert len(FLAGS.RegisteredFlags()) == 8 + number_test_framework_flags
assert not 'r' in FLAGS.RegisteredFlags()
# .. command line with extra stuff
argv = ('./program', '--debug', '--name=Bob', 'extra')
argv = FLAGS(argv)
assert len(argv) == 2, "wrong number of arguments pulled"
assert argv[0]=='./program', "program name not preserved"
assert argv[1]=='extra', "extra argument not preserved"
assert FLAGS['debug'].present == 1
FLAGS['debug'].present = 0 # Reset
assert FLAGS['name'].present == 1
FLAGS['name'].present = 0 # Reset
# Test reset
argv = ('./program', '--debug')
argv = FLAGS(argv)
assert len(argv) == 1, "wrong number of arguments pulled"
assert argv[0] == './program', "program name not preserved"
assert FLAGS['debug'].present == 1
assert FLAGS['debug'].value == True
FLAGS.Reset()
assert FLAGS['debug'].present == 0
assert FLAGS['debug'].value == False
# Test integer argument passing
argv = ('./program', '--x', '0x12345')
argv = FLAGS(argv)
# 0x12345 == 74565
self.assertEquals(FLAGS.x, 74565)
self.assertEquals(type(FLAGS.x), int)
argv = ('./program', '--x', '0x123456789A')
argv = FLAGS(argv)
# 0x123456789A == 78187493530L
self.assertEquals(FLAGS.x, 78187493530L)
self.assertEquals(type(FLAGS.x), long)
# Treat 0-prefixed parameters as base-10, not base-8
argv = ('./program', '--x', '012345')
argv = FLAGS(argv)
self.assertEquals(FLAGS.x, 12345)
self.assertEquals(type(FLAGS.x), int)
argv = ('./program', '--x', '0123459')
argv = FLAGS(argv)
self.assertEquals(FLAGS.x, 123459)
self.assertEquals(type(FLAGS.x), int)
argv = ('./program', '--x', '0x123efg')
try:
argv = FLAGS(argv)
raise AssertionError("failed to detect invalid hex argument")
except flags.IllegalFlagValue:
pass
argv = ('./program', '--x', '0X123efg')
try:
argv = FLAGS(argv)
raise AssertionError("failed to detect invalid hex argument")
except flags.IllegalFlagValue:
pass
# Test boolean argument parsing
flags.DEFINE_boolean("test0", None, "test boolean parsing")
argv = ('./program', '--notest0')
argv = FLAGS(argv)
assert FLAGS.test0 == 0
flags.DEFINE_boolean("test1", None, "test boolean parsing")
argv = ('./program', '--test1')
argv = FLAGS(argv)
assert FLAGS.test1 == 1
FLAGS.test0 = None
argv = ('./program', '--test0=false')
argv = FLAGS(argv)
assert FLAGS.test0 == 0
FLAGS.test1 = None
argv = ('./program', '--test1=true')
argv = FLAGS(argv)
assert FLAGS.test1 == 1
FLAGS.test0 = None
argv = ('./program', '--test0=0')
argv = FLAGS(argv)
assert FLAGS.test0 == 0
FLAGS.test1 = None
argv = ('./program', '--test1=1')
argv = FLAGS(argv)
assert FLAGS.test1 == 1
# Test booleans that already have 'no' as a prefix
FLAGS.noexec = None
argv = ('./program', '--nonoexec', '--name', 'Bob')
argv = FLAGS(argv)
assert FLAGS.noexec == 0
FLAGS.noexec = None
argv = ('./program', '--name', 'Bob', '--noexec')
argv = FLAGS(argv)
assert FLAGS.noexec == 1
# Test unassigned booleans
flags.DEFINE_boolean("testnone", None, "test boolean parsing")
argv = ('./program',)
argv = FLAGS(argv)
assert FLAGS.testnone == None
# Test get with default
flags.DEFINE_boolean("testget1", None, "test parsing with defaults")
flags.DEFINE_boolean("testget2", None, "test parsing with defaults")
flags.DEFINE_boolean("testget3", None, "test parsing with defaults")
flags.DEFINE_integer("testget4", None, "test parsing with defaults")
argv = ('./program','--testget1','--notestget2')
argv = FLAGS(argv)
assert FLAGS.get('testget1', 'foo') == 1
assert FLAGS.get('testget2', 'foo') == 0
assert FLAGS.get('testget3', 'foo') == 'foo'
assert FLAGS.get('testget4', 'foo') == 'foo'
# test list code
lists = [['hello','moo','boo','1'],
[],]
flags.DEFINE_list('testlist', '', 'test lists parsing')
flags.DEFINE_spaceseplist('testspacelist', '', 'tests space lists parsing')
for name, sep in (('testlist', ','), ('testspacelist', ' '),
('testspacelist', '\n')):
for lst in lists:
argv = ('./program', '--%s=%s' % (name, sep.join(lst)))
argv = FLAGS(argv)
self.assertEquals(getattr(FLAGS, name), lst)
# Test help text
flagsHelp = str(FLAGS)
assert flagsHelp.find("repeat") != -1, "cannot find flag in help"
assert flagsHelp.find(repeatHelp) != -1, "cannot find help string in help"
# Test flag specified twice
argv = ('./program', '--repeat=4', '--repeat=2', '--debug', '--nodebug')
argv = FLAGS(argv)
self.assertEqual(FLAGS.get('repeat', None), 2)
self.assertEqual(FLAGS.get('debug', None), 0)
# Test MultiFlag with single default value
flags.DEFINE_multistring('s_str', 'sing1',
'string option that can occur multiple times',
short_name='s')
self.assertEqual(FLAGS.get('s_str', None), [ 'sing1', ])
# Test MultiFlag with list of default values
multi_string_defs = [ 'def1', 'def2', ]
flags.DEFINE_multistring('m_str', multi_string_defs,
'string option that can occur multiple times',
short_name='m')
self.assertEqual(FLAGS.get('m_str', None), multi_string_defs)
# Test flag specified multiple times with a MultiFlag
argv = ('./program', '--m_str=str1', '-m', 'str2')
argv = FLAGS(argv)
self.assertEqual(FLAGS.get('m_str', None), [ 'str1', 'str2', ])
# Test single-letter flags; should support both single and double dash
argv = ('./program', '-q', '-x8')
argv = FLAGS(argv)
self.assertEqual(FLAGS.get('q', None), 1)
self.assertEqual(FLAGS.get('x', None), 8)
argv = ('./program', '--q', '--x', '9', '--noqu')
argv = FLAGS(argv)
self.assertEqual(FLAGS.get('q', None), 1)
self.assertEqual(FLAGS.get('x', None), 9)
# --noqu should match '--noquack since it's a unique prefix
self.assertEqual(FLAGS.get('quack', None), 0)
argv = ('./program', '--noq', '--x=10', '--qu')
argv = FLAGS(argv)
self.assertEqual(FLAGS.get('q', None), 0)
self.assertEqual(FLAGS.get('x', None), 10)
self.assertEqual(FLAGS.get('quack', None), 1)
####################################
# Test flag serialization code:
oldtestlist = FLAGS.testlist
oldtestspacelist = FLAGS.testspacelist
argv = ('./program',
FLAGS['test0'].Serialize(),
FLAGS['test1'].Serialize(),
FLAGS['testnone'].Serialize(),
FLAGS['s_str'].Serialize())
argv = FLAGS(argv)
self.assertEqual(FLAGS['test0'].Serialize(), '--notest0')
self.assertEqual(FLAGS['test1'].Serialize(), '--test1')
self.assertEqual(FLAGS['testnone'].Serialize(), '')
self.assertEqual(FLAGS['s_str'].Serialize(), '--s_str=sing1')
testlist1 = ['aa', 'bb']
testspacelist1 = ['aa', 'bb', 'cc']
FLAGS.testlist = list(testlist1)
FLAGS.testspacelist = list(testspacelist1)
argv = ('./program',
FLAGS['testlist'].Serialize(),
FLAGS['testspacelist'].Serialize())
argv = FLAGS(argv)
self.assertEqual(FLAGS.testlist, testlist1)
self.assertEqual(FLAGS.testspacelist, testspacelist1)
testlist1 = ['aa some spaces', 'bb']
testspacelist1 = ['aa', 'bb,some,commas,', 'cc']
FLAGS.testlist = list(testlist1)
FLAGS.testspacelist = list(testspacelist1)
argv = ('./program',
FLAGS['testlist'].Serialize(),
FLAGS['testspacelist'].Serialize())
argv = FLAGS(argv)
self.assertEqual(FLAGS.testlist, testlist1)
self.assertEqual(FLAGS.testspacelist, testspacelist1)
FLAGS.testlist = oldtestlist
FLAGS.testspacelist = oldtestspacelist
####################################
# Test flag-update:
def ArgsString():
flagnames = FLAGS.RegisteredFlags()
flagnames.sort()
nonbool_flags = ['--%s %s' % (name, FLAGS.get(name, None))
for name in flagnames
if not isinstance(FLAGS[name], flags.BooleanFlag)]
truebool_flags = ['--%s' % (name)
for name in flagnames
if isinstance(FLAGS[name], flags.BooleanFlag) and
FLAGS.get(name, None)]
falsebool_flags = ['--no%s' % (name)
for name in flagnames
if isinstance(FLAGS[name], flags.BooleanFlag) and
not FLAGS.get(name, None)]
return ' '.join(nonbool_flags + truebool_flags + falsebool_flags)
argv = ('./program', '--repeat=3', '--name=giants', '--nodebug')
FLAGS(argv)
self.assertEqual(FLAGS.get('repeat', None), 3)
self.assertEqual(FLAGS.get('name', None), 'giants')
self.assertEqual(FLAGS.get('debug', None), 0)
self.assertEqual(ArgsString(),
"--l 9223372032559808512 "
"--m ['str1', 'str2'] --m_str ['str1', 'str2'] "
"--name giants "
"--repeat 3 "
"--s ['sing1'] --s_str ['sing1'] "
"--testget4 None --testlist [] "
"--testspacelist [] --x 10 "
"--noexec --quack "
"--test1 "
"--testget1 --no? --nodebug --nohelp --nohelpshort "
"--noq --notest0 --notestget2 "
"--notestget3 --notestnone")
argv = ('./program', '--debug', '--m_str=upd1', '-s', 'upd2')
FLAGS(argv)
self.assertEqual(FLAGS.get('repeat', None), 3)
self.assertEqual(FLAGS.get('name', None), 'giants')
self.assertEqual(FLAGS.get('debug', None), 1)
# items appended to existing non-default value lists for --m/--m_str
# new value overwrites default value (not appended to it) for --s/--s_str
self.assertEqual(ArgsString(),
"--l 9223372032559808512 "
"--m ['str1', 'str2', 'upd1'] "
"--m_str ['str1', 'str2', 'upd1'] "
"--name giants "
"--repeat 3 "
"--s ['upd2'] --s_str ['upd2'] "
"--testget4 None --testlist [] "
"--testspacelist [] --x 10 "
"--debug --noexec --quack "
"--test1 "
"--testget1 --no? --nohelp --nohelpshort "
"--noq --notest0 --notestget2 "
"--notestget3 --notestnone")
####################################
# Test all kind of error conditions.
# Duplicate flag detection
try:
flags.DEFINE_boolean("run", 0, "runhelp", short_name='q')
raise AssertionError("duplicate flag detection failed")
except flags.DuplicateFlag, e:
pass
try:
flags.DEFINE_boolean("zoom1", 0, "runhelp z1", short_name='z')
flags.DEFINE_boolean("zoom2", 0, "runhelp z2", short_name='z')
raise AssertionError("duplicate flag detection failed")
except flags.DuplicateFlag, e:
pass
# Make sure allow_override works
try:
flags.DEFINE_boolean("dup1", 0, "runhelp d11", short_name='u',
allow_override=0)
flag = FLAGS.FlagDict()['dup1']
self.assertEqual(flag.default, 0)
flags.DEFINE_boolean("dup1", 1, "runhelp d12", short_name='u',
allow_override=1)
flag = FLAGS.FlagDict()['dup1']
self.assertEqual(flag.default, 1)
except flags.DuplicateFlag, e:
raise AssertionError("allow_override did not permit a flag duplication")
# Make sure allow_override works
try:
flags.DEFINE_boolean("dup2", 0, "runhelp d21", short_name='u',
allow_override=1)
flag = FLAGS.FlagDict()['dup2']
self.assertEqual(flag.default, 0)
flags.DEFINE_boolean("dup2", 1, "runhelp d22", short_name='u',
allow_override=0)
flag = FLAGS.FlagDict()['dup2']
self.assertEqual(flag.default, 1)
except flags.DuplicateFlag, e:
raise AssertionError("allow_override did not permit a flag duplication")
# Make sure allow_override doesn't work with None default
try:
flags.DEFINE_boolean("dup3", 0, "runhelp d31", short_name='u',
allow_override=0)
flag = FLAGS.FlagDict()['dup3']
self.assertEqual(flag.default, 0)
flags.DEFINE_boolean("dup3", None, "runhelp d32", short_name='u',
allow_override=1)
raise AssertionError('Cannot override a flag with a default of None')
except flags.DuplicateFlag, e:
pass
# Make sure that when we override, the help string gets updated correctly
flags.DEFINE_boolean("dup3", 0, "runhelp d31", short_name='u',
allow_override=1)
flags.DEFINE_boolean("dup3", 1, "runhelp d32", short_name='u',
allow_override=1)
self.assert_(str(FLAGS).find('runhelp d31') == -1)
self.assert_(str(FLAGS).find('runhelp d32') != -1)
# Integer out of bounds
try:
argv = ('./program', '--repeat=-4')
FLAGS(argv)
raise AssertionError('integer bounds exception not thrown:'
+ str(FLAGS.repeat))
except flags.IllegalFlagValue:
pass
# Non-integer
try:
argv = ('./program', '--repeat=2.5')
FLAGS(argv)
raise AssertionError("malformed integer value exception not thrown")
except flags.IllegalFlagValue:
pass
# Missing required arugment
try:
argv = ('./program', '--name')
FLAGS(argv)
raise AssertionError("Flag argument required exception not thrown")
except flags.FlagsError:
pass
# Argument erroneously supplied for boolean
try:
argv = ('./program', '--debug=goofup')
FLAGS(argv)
raise AssertionError("No argument allowed exception not thrown")
except flags.FlagsError:
pass
# Unknown argument --nosuchflag
try:
argv = ('./program', '--nosuchflag', '--name=Bob', 'extra')
FLAGS(argv)
raise AssertionError("Unknown argument exception not thrown")
except flags.FlagsError:
pass
# Non-numeric argument for integer flag --repeat
try:
argv = ('./program', '--repeat', 'Bob', 'extra')
FLAGS(argv)
raise AssertionError("Illegal flag value exception not thrown")
except flags.IllegalFlagValue:
pass
################################################
# Code to test the flagfile=<> loading behavior
################################################
def _SetupTestFiles(self):
""" Creates and sets up some dummy flagfile files with bogus flags"""
# Figure out where to create temporary files
tmp_path = '/tmp/flags_unittest'
if os.path.exists(tmp_path):
shutil.rmtree(tmp_path)
os.makedirs(tmp_path)
try:
tmp_flag_file_1 = open((tmp_path + '/UnitTestFile1.tst'), 'w')
tmp_flag_file_2 = open((tmp_path + '/UnitTestFile2.tst'), 'w')
tmp_flag_file_3 = open((tmp_path + '/UnitTestFile3.tst'), 'w')
except IOError, e_msg:
print e_msg
print 'FAIL\n File Creation problem in Unit Test'
sys.exit(1)
# put some dummy flags in our test files
tmp_flag_file_1.write('#A Fake Comment\n')
tmp_flag_file_1.write('--UnitTestMessage1=tempFile1!\n')
tmp_flag_file_1.write('\n')
tmp_flag_file_1.write('--UnitTestNumber=54321\n')
tmp_flag_file_1.write('--noUnitTestBoolFlag\n')
file_list = [tmp_flag_file_1.name]
# this one includes test file 1
tmp_flag_file_2.write('//A Different Fake Comment\n')
tmp_flag_file_2.write('--flagfile=%s\n' % tmp_flag_file_1.name)
tmp_flag_file_2.write('--UnitTestMessage2=setFromTempFile2\n')
tmp_flag_file_2.write('\t\t\n')
tmp_flag_file_2.write('--UnitTestNumber=6789a\n')
file_list.append(tmp_flag_file_2.name)
# this file points to itself
tmp_flag_file_3.write('--flagfile=%s\n' % tmp_flag_file_3.name)
tmp_flag_file_3.write('--UnitTestMessage1=setFromTempFile3\n')
tmp_flag_file_3.write('#YAFC\n')
tmp_flag_file_3.write('--UnitTestBoolFlag\n')
file_list.append(tmp_flag_file_3.name)
tmp_flag_file_1.close()
tmp_flag_file_2.close()
tmp_flag_file_3.close()
return file_list # these are just the file names
# end SetupFiles def
def _RemoveTestFiles(self, tmp_file_list):
"""Closes the files we just created. tempfile deletes them for us """
for file_name in tmp_file_list:
try:
os.remove(file_name)
except OSError, e_msg:
print '%s\n, Problem deleting test file' % e_msg
#end RemoveTestFiles def
def __DeclareSomeFlags(self):
flags.DEFINE_string('UnitTestMessage1', 'Foo!', 'You Add Here.')
flags.DEFINE_string('UnitTestMessage2', 'Bar!', 'Hello, Sailor!')
flags.DEFINE_boolean('UnitTestBoolFlag', 0, 'Some Boolean thing')
flags.DEFINE_integer('UnitTestNumber', 12345, 'Some integer',
lower_bound=0)
def _UndeclareSomeFlags(self):
FLAGS.__delattr__('UnitTestMessage1')
FLAGS.__delattr__('UnitTestMessage2')
FLAGS.__delattr__('UnitTestBoolFlag')
FLAGS.__delattr__('UnitTestNumber')
#### Flagfile Unit Tests ####
def testMethod_flagfiles_1(self):
""" Test trivial case with no flagfile based options. """
self.__DeclareSomeFlags()
fake_cmd_line = 'fooScript --UnitTestBoolFlag'
fake_argv = fake_cmd_line.split(' ')
FLAGS(fake_argv)
self.assertEqual( FLAGS.UnitTestBoolFlag, 1)
self.assertEqual( fake_argv, FLAGS.ReadFlagsFromFiles(fake_argv))
self._UndeclareSomeFlags()
# end testMethodOne
def testMethod_flagfiles_2(self):
"""Tests parsing one file + arguments off simulated argv"""
self.__DeclareSomeFlags()
tmp_files = self._SetupTestFiles()
# specify our temp file on the fake cmd line
fake_cmd_line = 'fooScript --q --flagfile=%s' % tmp_files[0]
fake_argv = fake_cmd_line.split(' ')
# We should see the original cmd line with the file's contents spliced in.
# Note that these will be in REVERSE order from order encountered in file
# This is done so arguements we encounter sooner will have priority.
expected_results = ['fooScript',
'--UnitTestMessage1=tempFile1!',
'--UnitTestNumber=54321',
'--noUnitTestBoolFlag',
'--q']
test_results = FLAGS.ReadFlagsFromFiles(fake_argv)
self.assertEqual(expected_results, test_results)
self._RemoveTestFiles(tmp_files)
self._UndeclareSomeFlags()
# end testTwo def
def testMethod_flagfiles_3(self):
"""Tests parsing nested files + arguments of simulated argv"""
self.__DeclareSomeFlags()
tmp_files = self._SetupTestFiles()
# specify our temp file on the fake cmd line
fake_cmd_line = ('fooScript --UnitTestNumber=77 --flagfile=%s'
% tmp_files[1])
fake_argv = fake_cmd_line.split(' ')
expected_results = ['fooScript',
'--UnitTestMessage1=tempFile1!',
'--UnitTestNumber=54321',
'--noUnitTestBoolFlag',
'--UnitTestMessage2=setFromTempFile2',
'--UnitTestNumber=6789a',
'--UnitTestNumber=77']
test_results = FLAGS.ReadFlagsFromFiles(fake_argv)
self.assertEqual(expected_results, test_results)
self._RemoveTestFiles(tmp_files)
self._UndeclareSomeFlags()
# end testThree def
def testMethod_flagfiles_4(self):
"""Tests parsing self referetial files + arguments of simulated argv.
This test should print a warning to stderr of some sort.
"""
self.__DeclareSomeFlags()
tmp_files = self._SetupTestFiles()
# specify our temp file on the fake cmd line
fake_cmd_line = ('fooScript --flagfile=%s --noUnitTestBoolFlag'
% tmp_files[2])
fake_argv = fake_cmd_line.split(' ')
expected_results = ['fooScript',
'--UnitTestMessage1=setFromTempFile3',
'--UnitTestBoolFlag',
'--noUnitTestBoolFlag' ]
test_results = FLAGS.ReadFlagsFromFiles(fake_argv)
self.assertEqual(expected_results, test_results)
self._RemoveTestFiles(tmp_files)
self._UndeclareSomeFlags()
def test_flagfiles_user_path_expansion(self):
"""Test that user directory referenced paths (ie. ~/foo) are correctly
expanded. This test depends on whatever account's running the unit test
to have read/write access to their own home directory, otherwise it'll
FAIL.
"""
self.__DeclareSomeFlags()
fake_flagfile_item_style_1 = '--flagfile=~/foo.file'
fake_flagfile_item_style_2 = '-flagfile=~/foo.file'
expected_results = os.path.expanduser('~/foo.file')
test_results = FLAGS.ExtractFilename(fake_flagfile_item_style_1)
self.assertEqual(expected_results, test_results)
test_results = FLAGS.ExtractFilename(fake_flagfile_item_style_2)
self.assertEqual(expected_results, test_results)
self._UndeclareSomeFlags()
# end testFour def
def test_no_touchy_non_flags(self):
"""
Test that the flags parser does not mutilate arguments which are
not supposed to be flags
"""
self.__DeclareSomeFlags()
fake_argv = ['fooScript', '--UnitTestBoolFlag',
'command', '--command_arg1', '--UnitTestBoom', '--UnitTestB']
argv = FLAGS(fake_argv)
self.assertEqual(argv, fake_argv[:1] + fake_argv[2:])
self._UndeclareSomeFlags()
def test_SetDefault(self):
"""
Test changing flag defaults.
"""
self.__DeclareSomeFlags()
# Test that SetDefault changes both the default and the value,
# and that the value is changed when one is given as an option.
FLAGS['UnitTestMessage1'].SetDefault('New value')
self.assertEqual(FLAGS.UnitTestMessage1, 'New value')
self.assertEqual(FLAGS['UnitTestMessage1'].default_as_str,"'New value'")
FLAGS([ 'dummyscript', '--UnitTestMessage1=Newer value' ])
self.assertEqual(FLAGS.UnitTestMessage1, 'Newer value')
# Test that setting the default to None works correctly.
FLAGS['UnitTestNumber'].SetDefault(None)
self.assertEqual(FLAGS.UnitTestNumber, None)
self.assertEqual(FLAGS['UnitTestNumber'].default_as_str, None)
FLAGS([ 'dummyscript', '--UnitTestNumber=56' ])
self.assertEqual(FLAGS.UnitTestNumber, 56)
# Test that setting invalid defaults raises exceptions
self.assertRaises(flags.IllegalFlagValue,
FLAGS['UnitTestNumber'].SetDefault, 'oops')
self.assertRaises(flags.IllegalFlagValue,
FLAGS['UnitTestNumber'].SetDefault, -1)
self.assertRaises(flags.IllegalFlagValue,
FLAGS['UnitTestBoolFlag'].SetDefault, 'oops')
self._UndeclareSomeFlags()
def testMethod_ShortestUniquePrefixes(self):
"""
Test FlagValues.ShortestUniquePrefixes
"""
flags.DEFINE_string('a', '', '')
flags.DEFINE_string('abc', '', '')
flags.DEFINE_string('common_a_string', '', '')
flags.DEFINE_boolean('common_b_boolean', 0, '')
flags.DEFINE_boolean('common_c_boolean', 0, '')
flags.DEFINE_boolean('common', 0, '')
flags.DEFINE_integer('commonly', 0, '')
flags.DEFINE_boolean('zz', 0, '')
flags.DEFINE_integer('nozz', 0, '')
shorter_flags = FLAGS.ShortestUniquePrefixes(FLAGS.FlagDict())
expected_results = {'nocommon_b_boolean': 'nocommon_b',
'common_c_boolean': 'common_c',
'common_b_boolean': 'common_b',
'a': 'a',
'abc': 'ab',
'zz': 'z',
'nozz': 'nozz',
'common_a_string': 'common_a',
'commonly': 'commonl',
'nocommon_c_boolean': 'nocommon_c',
'nocommon': 'nocommon',
'common': 'common'}
for name, shorter in expected_results.iteritems():
self.assertEquals(shorter_flags[name], shorter)
FLAGS.__delattr__('a')
FLAGS.__delattr__('abc')
FLAGS.__delattr__('common_a_string')
FLAGS.__delattr__('common_b_boolean')
FLAGS.__delattr__('common_c_boolean')
FLAGS.__delattr__('common')
FLAGS.__delattr__('commonly')
FLAGS.__delattr__('zz')
FLAGS.__delattr__('nozz')
if __name__ == '__main__':
unittest.main()

42
python/setup.py Executable file
View file

@ -0,0 +1,42 @@
#!/usr/bin/python2.2
# Copyright (c) 2007, Google Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above
# copyright notice, this list of conditions and the following disclaimer
# in the documentation and/or other materials provided with the
# distribution.
# * Neither the name of Google Inc. nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
from distutils.core import setup
setup(name='gflags',
version='0.2',
description='Google Commandline Flags Module',
license='BSD',
author='Google Inc.',
author_email='opensource@google.com',
url='http://code.google.com/p/google-gflags',
py_modules=["gflags"],
data_files=["/usr/local/bin", "gflags2man.py"])

1
src/google/gflags.h.in
View file

@ -55,6 +55,7 @@
#define BASE_COMMANDLINEFLAGS_H__
#include <string>
#include <vector>
// We care a lot about number of bits things take up. Unfortunately,
// systems define their bit-specific ints in a lot of different ways.