Remove all unused variables.

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 48 matching lines @@
         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):
+        def write(self, _):
             # 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()
@@ skipping 56 matching lines @@
         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'])
+        _, options = parse(['--min-confidence=4'])
         self.assertEqual(options.min_confidence, 4)
-        (files, options) = parse(['--output=emacs'])
+        _, options = parse(['--output=emacs'])
         self.assertEqual(options.output_format, 'emacs')
-        (files, options) = parse(['-g', 'commit'])
+        _, options = parse(['-g', 'commit'])
         self.assertEqual(options.git_commit, 'commit')
-        (files, options) = parse(['--git-commit=commit'])
+        _, options = parse(['--git-commit=commit'])
         self.assertEqual(options.git_commit, 'commit')
-        (files, options) = parse(['--git-diff=commit'])
+        _, options = parse(['--git-diff=commit'])
         self.assertEqual(options.git_commit, 'commit')
-        (files, options) = parse(['--verbose'])
+        _, options = parse(['--verbose'])
         self.assertTrue(options.is_verbose)
-        (files, options) = parse(['--diff-files', 'file.txt'])
+        _, options = parse(['--diff-files', 'file.txt'])
         self.assertTrue(options.diff_files)
 
         # Pass user_rules.
-        (files, options) = parse(['--filter=+build,-whitespace'])
+        _, 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'])
+        _, 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'])
+        files, _ = parse(['foo.cpp'])
         self.assertEqual(files, ['foo.cpp'])
 
         # Pass multiple files.
-        (files, options) = parse(['--output=emacs', 'foo.cpp', 'bar.cpp'])
+        files, _ = 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.
@@ skipping 47 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()))