text: #!/usr/bin/env python
  import unittest
  
  import gflags
  import _helpers
  
  FLAGS = gflags.FLAGS
  
  
  class FlagsUnitTest(unittest.TestCase):
    """Flags formatting Unit Test."""
  
    def testGetHelpWidth(self):
      """Verify that GetHelpWidth() reflects _help_width."""
      default_help_width = _helpers._DEFAULT_HELP_WIDTH  # Save.
      self.assertEqual(80, _helpers._DEFAULT_HELP_WIDTH)
      self.assertEqual(_helpers._DEFAULT_HELP_WIDTH, gflags.GetHelpWidth())
      _helpers._DEFAULT_HELP_WIDTH = 10
      self.assertEqual(_helpers._DEFAULT_HELP_WIDTH, gflags.GetHelpWidth())
      _helpers._DEFAULT_HELP_WIDTH = default_help_width  # restore
  
    def testTextWrap(self):
      """Test that wrapping works as expected.
  
      Also tests that it is using global gflags._help_width by default.
      """
      default_help_width = _helpers._DEFAULT_HELP_WIDTH
      _helpers._DEFAULT_HELP_WIDTH = 10
  
      # Generate a string with length 40, no spaces
      text = ''
      expect = []
      for n in range(4):
        line = str(n)
        line += '123456789'
        text += line
        expect.append(line)
  
      # Verify we still break
      wrapped = gflags.TextWrap(text).split('\n')
      self.assertEqual(4, len(wrapped))
      self.assertEqual(expect, wrapped)
  
      wrapped = gflags.TextWrap(text, 80).split('\n')
      self.assertEqual(1, len(wrapped))
      self.assertEqual([text], wrapped)
  
      # Normal case, breaking at word boundaries and rewriting new lines
      input_value = 'a b c d e f g h'
      expect = {1: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'],
                2: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'],
                3: ['a b', 'c d', 'e f', 'g h'],
                4: ['a b', 'c d', 'e f', 'g h'],
                5: ['a b c', 'd e f', 'g h'],
                6: ['a b c', 'd e f', 'g h'],
                7: ['a b c d', 'e f g h'],
                8: ['a b c d', 'e f g h'],
                9: ['a b c d e', 'f g h'],
                10: ['a b c d e', 'f g h'],
                11: ['a b c d e f', 'g h'],
                12: ['a b c d e f', 'g h'],
                13: ['a b c d e f g', 'h'],
                14: ['a b c d e f g', 'h'],
                15: ['a b c d e f g h']}
      for width, exp in expect.items():
        self.assertEqual(exp, gflags.TextWrap(input_value, width).split('\n'))
  
      # We turn lines with only whitespace into empty lines
      # We strip from the right up to the first new line
      self.assertEqual('', gflags.TextWrap('  '))
      self.assertEqual('\n', gflags.TextWrap('  \n  '))
      self.assertEqual('\n', gflags.TextWrap('\n\n'))
      self.assertEqual('\n\n', gflags.TextWrap('\n\n\n'))
      self.assertEqual('\n', gflags.TextWrap('\n '))
      self.assertEqual('a\n\nb', gflags.TextWrap('a\n  \nb'))
      self.assertEqual('a\n\n\nb', gflags.TextWrap('a\n  \n  \nb'))
      self.assertEqual('a\nb', gflags.TextWrap('  a\nb  '))
      self.assertEqual('\na\nb', gflags.TextWrap('\na\nb\n'))
      self.assertEqual('\na\nb\n', gflags.TextWrap('  \na\nb\n  '))
      self.assertEqual('\na\nb\n', gflags.TextWrap('  \na\nb\n\n'))
  
      # Double newline.
      self.assertEqual('a\n\nb', gflags.TextWrap(' a\n\n b'))
  
      # We respect prefix
      self.assertEqual(' a\n b\n c', gflags.TextWrap('a\nb\nc', 80, ' '))
      self.assertEqual('a\n b\n c', gflags.TextWrap('a\nb\nc', 80, ' ', ''))
  
      # tabs
      self.assertEqual('a\n b   c',
                       gflags.TextWrap('a\nb\tc', 80, ' ', ''))
      self.assertEqual('a\n bb  c',
                       gflags.TextWrap('a\nbb\tc', 80, ' ', ''))
      self.assertEqual('a\n bbb c',
                       gflags.TextWrap('a\nbbb\tc', 80, ' ', ''))
      self.assertEqual('a\n bbbb    c',
                       gflags.TextWrap('a\nbbbb\tc', 80, ' ', ''))
      self.assertEqual('a\n b\n c\n d',
                       gflags.TextWrap('a\nb\tc\td', 3, ' ', ''))
      self.assertEqual('a\n b\n c\n d',
                       gflags.TextWrap('a\nb\tc\td', 4, ' ', ''))
      self.assertEqual('a\n b\n c\n d',
                       gflags.TextWrap('a\nb\tc\td', 5, ' ', ''))
      self.assertEqual('a\n b   c\n d',
                       gflags.TextWrap('a\nb\tc\td', 6, ' ', ''))
      self.assertEqual('a\n b   c\n d',
                       gflags.TextWrap('a\nb\tc\td', 7, ' ', ''))
      self.assertEqual('a\n b   c\n d',
                       gflags.TextWrap('a\nb\tc\td', 8, ' ', ''))
      self.assertEqual('a\n b   c\n d',
                       gflags.TextWrap('a\nb\tc\td', 9, ' ', ''))
      self.assertEqual('a\n b   c   d',
                       gflags.TextWrap('a\nb\tc\td', 10, ' ', ''))
  
      # multiple tabs
      self.assertEqual('a       c',
                       gflags.TextWrap('a\t\tc', 80, ' ', ''))
  
      _helpers._DEFAULT_HELP_WIDTH = default_help_width  # restore
  
    def testDocToHelp(self):
      self.assertEqual('', gflags.DocToHelp('  '))
      self.assertEqual('', gflags.DocToHelp('  \n  '))
      self.assertEqual('a\n\nb', gflags.DocToHelp('a\n  \nb'))
      self.assertEqual('a\n\n\nb', gflags.DocToHelp('a\n  \n  \nb'))
      self.assertEqual('a b', gflags.DocToHelp('  a\nb  '))
      self.assertEqual('a b', gflags.DocToHelp('\na\nb\n'))
      self.assertEqual('a\n\nb', gflags.DocToHelp('\na\n\nb\n'))
      self.assertEqual('a b', gflags.DocToHelp('  \na\nb\n  '))
      # Different first line, one line empty - erm double new line.
      self.assertEqual('a b c\n\nd', gflags.DocToHelp('a\n  b\n  c\n\n  d'))
      self.assertEqual('a b\n      c d', gflags.DocToHelp('a\n  b\n  \tc\n  d'))
      self.assertEqual('a b\n      c\n      d',
                       gflags.DocToHelp('a\n  b\n  \tc\n  \td'))
  
    def testDocToHelp_FlagValues(self):
      # !!!!!!!!!!!!!!!!!!!!
      # The following doc string is taken as is directly from gflags.py:FlagValues
      # The intention of this test is to verify 'live' performance
      # !!!!!!!!!!!!!!!!!!!!
      """Used as a registry for 'Flag' objects.
  
      A 'FlagValues' can then scan command line arguments, passing flag
      arguments through to the 'Flag' objects that it owns.  It also
      provides easy access to the flag values.  Typically only one
      'FlagValues' object is needed by an application:  gflags.FLAGS
  
      This class is heavily overloaded:
  
      'Flag' objects are registered via __setitem__:
           FLAGS['longname'] = x   # register a new flag
  
      The .value member of the registered 'Flag' objects can be accessed as
      members of this 'FlagValues' object, through __getattr__.  Both the
      long and short name of the original 'Flag' objects can be used to
      access its value:
           FLAGS.longname          # parsed flag value
           FLAGS.x                 # parsed flag value (short name)
  
      Command line arguments are scanned and passed to the registered 'Flag'
      objects through the __call__ method.  Unparsed arguments, including
      argv[0] (e.g. the program name) are returned.
           argv = FLAGS(sys.argv)  # scan command line arguments
  
      The original registered Flag objects can be retrieved through the use
      """
      doc = gflags.DocToHelp(self.testDocToHelp_FlagValues.__doc__)
      # Test the general outline of the converted docs
      lines = doc.splitlines()
      self.assertEqual(17, len(lines))
      empty_lines = [index for index in range(len(lines)) if not lines[index]]
      self.assertEqual([1, 3, 5, 8, 12, 15], empty_lines)
      # test that some starting prefix is kept
      flags_lines = [index for index in range(len(lines))
                     if lines[index].startswith('     FLAGS')]
      self.assertEqual([7, 10, 11], flags_lines)
      # but other, especially common space has been removed
      space_lines = [index for index in range(len(lines))
                     if lines[index] and lines[index][0].isspace()]
      self.assertEqual([7, 10, 11, 14], space_lines)
      # No right space was kept
      rspace_lines = [index for index in range(len(lines))
                      if lines[index] != lines[index].rstrip()]
      self.assertEqual([], rspace_lines)
      # test double spaces are kept
      self.assertEqual(True, lines[2].endswith('application:  gflags.FLAGS'))
  
    def testTextWrapRaisesOnExcessiveIndent(self):
      """Ensure an indent longer than line length raises."""
      self.assertRaises(ValueError,
                        gflags.TextWrap, 'dummy', length=10, indent=' ' * 10)
  
    def testTextWrapRaisesOnExcessiveFirstLine(self):
      """Ensure a first line indent longer than line length raises."""
      self.assertRaises(
          ValueError,
          gflags.TextWrap, 'dummy', length=80, firstline_indent=' ' * 80)
  
  
  if __name__ == '__main__':
    unittest.main()
  