mirror of
https://github.com/flutter/flutter.git
synced 2026-02-20 02:29:02 +08:00
259 lines
11 KiB
Python
259 lines
11 KiB
Python
# Copyright (C) 2010 Chris Jerdonek (cjerdonek@webkit.org)
|
|
#
|
|
# Redistribution and use in source and binary forms, with or without
|
|
# modification, are permitted provided that the following conditions
|
|
# are met:
|
|
# 1. Redistributions of source code must retain the above copyright
|
|
# notice, this list of conditions and the following disclaimer.
|
|
# 2. 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.
|
|
#
|
|
# THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS 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 APPLE INC. OR ITS 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.
|
|
|
|
"""Unit tests for parser.py."""
|
|
|
|
import unittest
|
|
|
|
from webkitpy.common.system.logtesting import LoggingTestCase
|
|
from webkitpy.style.optparser import ArgumentParser
|
|
from webkitpy.style.optparser import ArgumentPrinter
|
|
from webkitpy.style.optparser import CommandOptionValues as ProcessorOptions
|
|
from webkitpy.style.optparser import DefaultCommandOptionValues
|
|
|
|
|
|
class ArgumentPrinterTest(unittest.TestCase):
|
|
|
|
"""Tests the ArgumentPrinter class."""
|
|
|
|
_printer = ArgumentPrinter()
|
|
|
|
def _create_options(self,
|
|
output_format='emacs',
|
|
min_confidence=3,
|
|
filter_rules=[],
|
|
git_commit=None):
|
|
return ProcessorOptions(filter_rules=filter_rules,
|
|
git_commit=git_commit,
|
|
min_confidence=min_confidence,
|
|
output_format=output_format)
|
|
|
|
def test_to_flag_string(self):
|
|
options = self._create_options('vs7', 5, ['+foo', '-bar'], 'git')
|
|
self.assertEqual('--filter=+foo,-bar --git-commit=git '
|
|
'--min-confidence=5 --output=vs7',
|
|
self._printer.to_flag_string(options))
|
|
|
|
# This is to check that --filter and --git-commit do not
|
|
# show up when not user-specified.
|
|
options = self._create_options()
|
|
self.assertEqual('--min-confidence=3 --output=emacs',
|
|
self._printer.to_flag_string(options))
|
|
|
|
|
|
class ArgumentParserTest(LoggingTestCase):
|
|
|
|
"""Test the ArgumentParser class."""
|
|
|
|
class _MockStdErr(object):
|
|
|
|
def write(self, message):
|
|
# We do not want the usage string or style categories
|
|
# to print during unit tests, so print nothing.
|
|
return
|
|
|
|
def _parse(self, args):
|
|
"""Call a test parser.parse()."""
|
|
parser = self._create_parser()
|
|
return parser.parse(args)
|
|
|
|
def _create_defaults(self):
|
|
"""Return a DefaultCommandOptionValues instance for testing."""
|
|
base_filter_rules = ["-", "+whitespace"]
|
|
return DefaultCommandOptionValues(min_confidence=3,
|
|
output_format="vs7")
|
|
|
|
def _create_parser(self):
|
|
"""Return an ArgumentParser instance for testing."""
|
|
default_options = self._create_defaults()
|
|
|
|
all_categories = ["build" ,"whitespace"]
|
|
|
|
mock_stderr = self._MockStdErr()
|
|
|
|
return ArgumentParser(all_categories=all_categories,
|
|
base_filter_rules=[],
|
|
default_options=default_options,
|
|
mock_stderr=mock_stderr,
|
|
usage="test usage")
|
|
|
|
def test_parse_documentation(self):
|
|
parse = self._parse
|
|
|
|
# FIXME: Test both the printing of the usage string and the
|
|
# filter categories help.
|
|
|
|
# Request the usage string.
|
|
self.assertRaises(SystemExit, parse, ['--help'])
|
|
# Request default filter rules and available style categories.
|
|
self.assertRaises(SystemExit, parse, ['--filter='])
|
|
|
|
def test_parse_bad_values(self):
|
|
parse = self._parse
|
|
|
|
# Pass an unsupported argument.
|
|
self.assertRaises(SystemExit, parse, ['--bad'])
|
|
self.assertLog(['ERROR: no such option: --bad\n'])
|
|
|
|
self.assertRaises(SystemExit, parse, ['--min-confidence=bad'])
|
|
self.assertLog(['ERROR: option --min-confidence: '
|
|
"invalid integer value: 'bad'\n"])
|
|
self.assertRaises(SystemExit, parse, ['--min-confidence=0'])
|
|
self.assertLog(['ERROR: option --min-confidence: invalid integer: 0: '
|
|
'value must be between 1 and 5\n'])
|
|
self.assertRaises(SystemExit, parse, ['--min-confidence=6'])
|
|
self.assertLog(['ERROR: option --min-confidence: invalid integer: 6: '
|
|
'value must be between 1 and 5\n'])
|
|
parse(['--min-confidence=1']) # works
|
|
parse(['--min-confidence=5']) # works
|
|
|
|
self.assertRaises(SystemExit, parse, ['--output=bad'])
|
|
self.assertLog(['ERROR: option --output-format: invalid choice: '
|
|
"'bad' (choose from 'emacs', 'vs7')\n"])
|
|
parse(['--output=vs7']) # works
|
|
|
|
# Pass a filter rule not beginning with + or -.
|
|
self.assertRaises(SystemExit, parse, ['--filter=build'])
|
|
self.assertLog(['ERROR: Invalid filter rule "build": '
|
|
'every rule must start with + or -.\n'])
|
|
parse(['--filter=+build']) # works
|
|
|
|
def test_parse_default_arguments(self):
|
|
parse = self._parse
|
|
|
|
(files, options) = parse([])
|
|
|
|
self.assertEqual(files, [])
|
|
|
|
self.assertEqual(options.filter_rules, [])
|
|
self.assertIsNone(options.git_commit)
|
|
self.assertFalse(options.diff_files)
|
|
self.assertFalse(options.is_verbose)
|
|
self.assertEqual(options.min_confidence, 3)
|
|
self.assertEqual(options.output_format, 'vs7')
|
|
|
|
def test_parse_explicit_arguments(self):
|
|
parse = self._parse
|
|
|
|
# Pass non-default explicit values.
|
|
(files, options) = parse(['--min-confidence=4'])
|
|
self.assertEqual(options.min_confidence, 4)
|
|
(files, options) = parse(['--output=emacs'])
|
|
self.assertEqual(options.output_format, 'emacs')
|
|
(files, options) = parse(['-g', 'commit'])
|
|
self.assertEqual(options.git_commit, 'commit')
|
|
(files, options) = parse(['--git-commit=commit'])
|
|
self.assertEqual(options.git_commit, 'commit')
|
|
(files, options) = parse(['--git-diff=commit'])
|
|
self.assertEqual(options.git_commit, 'commit')
|
|
(files, options) = parse(['--verbose'])
|
|
self.assertTrue(options.is_verbose)
|
|
(files, options) = parse(['--diff-files', 'file.txt'])
|
|
self.assertTrue(options.diff_files)
|
|
|
|
# Pass user_rules.
|
|
(files, options) = parse(['--filter=+build,-whitespace'])
|
|
self.assertEqual(options.filter_rules,
|
|
["+build", "-whitespace"])
|
|
|
|
# Pass spurious white space in user rules.
|
|
(files, options) = parse(['--filter=+build, -whitespace'])
|
|
self.assertEqual(options.filter_rules,
|
|
["+build", "-whitespace"])
|
|
|
|
def test_parse_files(self):
|
|
parse = self._parse
|
|
|
|
(files, options) = parse(['foo.cpp'])
|
|
self.assertEqual(files, ['foo.cpp'])
|
|
|
|
# Pass multiple files.
|
|
(files, options) = parse(['--output=emacs', 'foo.cpp', 'bar.cpp'])
|
|
self.assertEqual(files, ['foo.cpp', 'bar.cpp'])
|
|
|
|
|
|
class CommandOptionValuesTest(unittest.TestCase):
|
|
|
|
"""Tests CommandOptionValues class."""
|
|
|
|
def test_init(self):
|
|
"""Test __init__ constructor."""
|
|
# Check default parameters.
|
|
options = ProcessorOptions()
|
|
self.assertEqual(options.filter_rules, [])
|
|
self.assertIsNone(options.git_commit)
|
|
self.assertFalse(options.is_verbose)
|
|
self.assertEqual(options.min_confidence, 1)
|
|
self.assertEqual(options.output_format, "emacs")
|
|
|
|
# Check argument validation.
|
|
self.assertRaises(ValueError, ProcessorOptions, output_format="bad")
|
|
ProcessorOptions(output_format="emacs") # No ValueError: works
|
|
ProcessorOptions(output_format="vs7") # works
|
|
self.assertRaises(ValueError, ProcessorOptions, min_confidence=0)
|
|
self.assertRaises(ValueError, ProcessorOptions, min_confidence=6)
|
|
ProcessorOptions(min_confidence=1) # works
|
|
ProcessorOptions(min_confidence=5) # works
|
|
|
|
# Check attributes.
|
|
options = ProcessorOptions(filter_rules=["+"],
|
|
git_commit="commit",
|
|
is_verbose=True,
|
|
min_confidence=3,
|
|
output_format="vs7")
|
|
self.assertEqual(options.filter_rules, ["+"])
|
|
self.assertEqual(options.git_commit, "commit")
|
|
self.assertTrue(options.is_verbose)
|
|
self.assertEqual(options.min_confidence, 3)
|
|
self.assertEqual(options.output_format, "vs7")
|
|
|
|
def test_eq(self):
|
|
"""Test __eq__ equality function."""
|
|
self.assertTrue(ProcessorOptions().__eq__(ProcessorOptions()))
|
|
|
|
# Also verify that a difference in any argument causes equality to fail.
|
|
|
|
# Explicitly create a ProcessorOptions instance with all default
|
|
# values. We do this to be sure we are assuming the right default
|
|
# values in our self.assertFalse() calls below.
|
|
options = ProcessorOptions(filter_rules=[],
|
|
git_commit=None,
|
|
is_verbose=False,
|
|
min_confidence=1,
|
|
output_format="emacs")
|
|
# Verify that we created options correctly.
|
|
self.assertTrue(options.__eq__(ProcessorOptions()))
|
|
|
|
self.assertFalse(options.__eq__(ProcessorOptions(filter_rules=["+"])))
|
|
self.assertFalse(options.__eq__(ProcessorOptions(git_commit="commit")))
|
|
self.assertFalse(options.__eq__(ProcessorOptions(is_verbose=True)))
|
|
self.assertFalse(options.__eq__(ProcessorOptions(min_confidence=2)))
|
|
self.assertFalse(options.__eq__(ProcessorOptions(output_format="vs7")))
|
|
|
|
def test_ne(self):
|
|
"""Test __ne__ inequality function."""
|
|
# By default, __ne__ always returns true on different objects.
|
|
# Thus, just check the distinguishing case to verify that the
|
|
# code defines __ne__.
|
|
self.assertFalse(ProcessorOptions().__ne__(ProcessorOptions()))
|
|
|