code.vuplus.com Git - vuplus_webkit/blob - Tools/Scripts/webkitpy/style/optparser_unittest.py

   1 # Copyright (C) 2010 Chris Jerdonek (cjerdonek@webkit.org)
   2 #
   3 # Redistribution and use in source and binary forms, with or without
   4 # modification, are permitted provided that the following conditions
   5 # are met:
   6 # 1.  Redistributions of source code must retain the above copyright
   7 #     notice, this list of conditions and the following disclaimer.
   8 # 2.  Redistributions in binary form must reproduce the above copyright
   9 #     notice, this list of conditions and the following disclaimer in the
  10 #     documentation and/or other materials provided with the distribution.
  11 #
  12 # THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
  13 # EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  14 # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  15 # DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  16 # DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  17 # (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  18 # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  19 # ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  20 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  21 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  22
  23 """Unit tests for parser.py."""
  24
  25 import unittest
  26
  27 from webkitpy.common.system.logtesting import LoggingTestCase
  28 from webkitpy.style.optparser import ArgumentParser
  29 from webkitpy.style.optparser import ArgumentPrinter
  30 from webkitpy.style.optparser import CommandOptionValues as ProcessorOptions
  31 from webkitpy.style.optparser import DefaultCommandOptionValues
  32
  33
  34 class ArgumentPrinterTest(unittest.TestCase):
  35
  36     """Tests the ArgumentPrinter class."""
  37
  38     _printer = ArgumentPrinter()
  39
  40     def _create_options(self,
  41                         output_format='emacs',
  42                         min_confidence=3,
  43                         filter_rules=[],
  44                         git_commit=None):
  45         return ProcessorOptions(filter_rules=filter_rules,
  46                                 git_commit=git_commit,
  47                                 min_confidence=min_confidence,
  48                                 output_format=output_format)
  49
  50     def test_to_flag_string(self):
  51         options = self._create_options('vs7', 5, ['+foo', '-bar'], 'git')
  52         self.assertEquals('--filter=+foo,-bar --git-commit=git '
  53                           '--min-confidence=5 --output=vs7',
  54                           self._printer.to_flag_string(options))
  55
  56         # This is to check that --filter and --git-commit do not
  57         # show up when not user-specified.
  58         options = self._create_options()
  59         self.assertEquals('--min-confidence=3 --output=emacs',
  60                           self._printer.to_flag_string(options))
  61
  62
  63 class ArgumentParserTest(LoggingTestCase):
  64
  65     """Test the ArgumentParser class."""
  66
  67     class _MockStdErr(object):
  68
  69         def write(self, message):
  70             # We do not want the usage string or style categories
  71             # to print during unit tests, so print nothing.
  72             return
  73
  74     def _parse(self, args):
  75         """Call a test parser.parse()."""
  76         parser = self._create_parser()
  77         return parser.parse(args)
  78
  79     def _create_defaults(self):
  80         """Return a DefaultCommandOptionValues instance for testing."""
  81         base_filter_rules = ["-", "+whitespace"]
  82         return DefaultCommandOptionValues(min_confidence=3,
  83                                           output_format="vs7")
  84
  85     def _create_parser(self):
  86         """Return an ArgumentParser instance for testing."""
  87         default_options = self._create_defaults()
  88
  89         all_categories = ["build" ,"whitespace"]
  90
  91         mock_stderr = self._MockStdErr()
  92
  93         return ArgumentParser(all_categories=all_categories,
  94                               base_filter_rules=[],
  95                               default_options=default_options,
  96                               mock_stderr=mock_stderr,
  97                               usage="test usage")
  98
  99     def test_parse_documentation(self):
 100         parse = self._parse
 101
 102         # FIXME: Test both the printing of the usage string and the
 103         #        filter categories help.
 104
 105         # Request the usage string.
 106         self.assertRaises(SystemExit, parse, ['--help'])
 107         # Request default filter rules and available style categories.
 108         self.assertRaises(SystemExit, parse, ['--filter='])
 109
 110     def test_parse_bad_values(self):
 111         parse = self._parse
 112
 113         # Pass an unsupported argument.
 114         self.assertRaises(SystemExit, parse, ['--bad'])
 115         self.assertLog(['ERROR: no such option: --bad\n'])
 116
 117         self.assertRaises(SystemExit, parse, ['--min-confidence=bad'])
 118         self.assertLog(['ERROR: option --min-confidence: '
 119                         "invalid integer value: 'bad'\n"])
 120         self.assertRaises(SystemExit, parse, ['--min-confidence=0'])
 121         self.assertLog(['ERROR: option --min-confidence: invalid integer: 0: '
 122                         'value must be between 1 and 5\n'])
 123         self.assertRaises(SystemExit, parse, ['--min-confidence=6'])
 124         self.assertLog(['ERROR: option --min-confidence: invalid integer: 6: '
 125                         'value must be between 1 and 5\n'])
 126         parse(['--min-confidence=1']) # works
 127         parse(['--min-confidence=5']) # works
 128
 129         self.assertRaises(SystemExit, parse, ['--output=bad'])
 130         self.assertLog(['ERROR: option --output-format: invalid choice: '
 131                         "'bad' (choose from 'emacs', 'vs7')\n"])
 132         parse(['--output=vs7']) # works
 133
 134         # Pass a filter rule not beginning with + or -.
 135         self.assertRaises(SystemExit, parse, ['--filter=build'])
 136         self.assertLog(['ERROR: Invalid filter rule "build": '
 137                         'every rule must start with + or -.\n'])
 138         parse(['--filter=+build']) # works
 139
 140     def test_parse_default_arguments(self):
 141         parse = self._parse
 142
 143         (files, options) = parse([])
 144
 145         self.assertEquals(files, [])
 146
 147         self.assertEquals(options.filter_rules, [])
 148         self.assertEquals(options.git_commit, None)
 149         self.assertEquals(options.diff_files, False)
 150         self.assertEquals(options.is_verbose, False)
 151         self.assertEquals(options.min_confidence, 3)
 152         self.assertEquals(options.output_format, 'vs7')
 153
 154     def test_parse_explicit_arguments(self):
 155         parse = self._parse
 156
 157         # Pass non-default explicit values.
 158         (files, options) = parse(['--min-confidence=4'])
 159         self.assertEquals(options.min_confidence, 4)
 160         (files, options) = parse(['--output=emacs'])
 161         self.assertEquals(options.output_format, 'emacs')
 162         (files, options) = parse(['-g', 'commit'])
 163         self.assertEquals(options.git_commit, 'commit')
 164         (files, options) = parse(['--git-commit=commit'])
 165         self.assertEquals(options.git_commit, 'commit')
 166         (files, options) = parse(['--git-diff=commit'])
 167         self.assertEquals(options.git_commit, 'commit')
 168         (files, options) = parse(['--verbose'])
 169         self.assertEquals(options.is_verbose, True)
 170         (files, options) = parse(['--diff-files', 'file.txt'])
 171         self.assertEquals(options.diff_files, True)
 172
 173         # Pass user_rules.
 174         (files, options) = parse(['--filter=+build,-whitespace'])
 175         self.assertEquals(options.filter_rules,
 176                           ["+build", "-whitespace"])
 177
 178         # Pass spurious white space in user rules.
 179         (files, options) = parse(['--filter=+build, -whitespace'])
 180         self.assertEquals(options.filter_rules,
 181                           ["+build", "-whitespace"])
 182
 183     def test_parse_files(self):
 184         parse = self._parse
 185
 186         (files, options) = parse(['foo.cpp'])
 187         self.assertEquals(files, ['foo.cpp'])
 188
 189         # Pass multiple files.
 190         (files, options) = parse(['--output=emacs', 'foo.cpp', 'bar.cpp'])
 191         self.assertEquals(files, ['foo.cpp', 'bar.cpp'])
 192
 193
 194 class CommandOptionValuesTest(unittest.TestCase):
 195
 196     """Tests CommandOptionValues class."""
 197
 198     def test_init(self):
 199         """Test __init__ constructor."""
 200         # Check default parameters.
 201         options = ProcessorOptions()
 202         self.assertEquals(options.filter_rules, [])
 203         self.assertEquals(options.git_commit, None)
 204         self.assertEquals(options.is_verbose, False)
 205         self.assertEquals(options.min_confidence, 1)
 206         self.assertEquals(options.output_format, "emacs")
 207
 208         # Check argument validation.
 209         self.assertRaises(ValueError, ProcessorOptions, output_format="bad")
 210         ProcessorOptions(output_format="emacs") # No ValueError: works
 211         ProcessorOptions(output_format="vs7") # works
 212         self.assertRaises(ValueError, ProcessorOptions, min_confidence=0)
 213         self.assertRaises(ValueError, ProcessorOptions, min_confidence=6)
 214         ProcessorOptions(min_confidence=1) # works
 215         ProcessorOptions(min_confidence=5) # works
 216
 217         # Check attributes.
 218         options = ProcessorOptions(filter_rules=["+"],
 219                                    git_commit="commit",
 220                                    is_verbose=True,
 221                                    min_confidence=3,
 222                                    output_format="vs7")
 223         self.assertEquals(options.filter_rules, ["+"])
 224         self.assertEquals(options.git_commit, "commit")
 225         self.assertEquals(options.is_verbose, True)
 226         self.assertEquals(options.min_confidence, 3)
 227         self.assertEquals(options.output_format, "vs7")
 228
 229     def test_eq(self):
 230         """Test __eq__ equality function."""
 231         self.assertTrue(ProcessorOptions().__eq__(ProcessorOptions()))
 232
 233         # Also verify that a difference in any argument causes equality to fail.
 234
 235         # Explicitly create a ProcessorOptions instance with all default
 236         # values.  We do this to be sure we are assuming the right default
 237         # values in our self.assertFalse() calls below.
 238         options = ProcessorOptions(filter_rules=[],
 239                                    git_commit=None,
 240                                    is_verbose=False,
 241                                    min_confidence=1,
 242                                    output_format="emacs")
 243         # Verify that we created options correctly.
 244         self.assertTrue(options.__eq__(ProcessorOptions()))
 245
 246         self.assertFalse(options.__eq__(ProcessorOptions(filter_rules=["+"])))
 247         self.assertFalse(options.__eq__(ProcessorOptions(git_commit="commit")))
 248         self.assertFalse(options.__eq__(ProcessorOptions(is_verbose=True)))
 249         self.assertFalse(options.__eq__(ProcessorOptions(min_confidence=2)))
 250         self.assertFalse(options.__eq__(ProcessorOptions(output_format="vs7")))
 251
 252     def test_ne(self):
 253         """Test __ne__ inequality function."""
 254         # By default, __ne__ always returns true on different objects.
 255         # Thus, just check the distinguishing case to verify that the
 256         # code defines __ne__.
 257         self.assertFalse(ProcessorOptions().__ne__(ProcessorOptions()))
 258