Run auto-formatter (autopep8) on webkitpy.

third_party/WebKit/Tools/Scripts/webkitpy/style/optparser_unittest.py

 # 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.
@@ skipping 32 matching lines @@
                         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))
+                         '--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))
+                         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"]
+        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):
@@ skipping 16 matching lines @@
 
         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
+        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
+        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
+        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)
@@ skipping 17 matching lines @@
         (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"])
+                         ["+build", "-whitespace"])
 
         # Pass spurious white space in user rules.
         (files, options) = parse(['--filter=+build, -whitespace'])
         self.assertEqual(options.filter_rules,
-                          ["+build", "-whitespace"])
+                         ["+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
+        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
+        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)
@@ skipping 22 matching lines @@
         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()))
-