Remove all unused variables.

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

 # -*- coding: utf-8; -*-
 #
 # Copyright (C) 2009 Google Inc. All rights reserved.
 # Copyright (C) 2009 Torch Mobile Inc.
 # Copyright (C) 2009 Apple Inc. All rights reserved.
 # Copyright (C) 2010 Chris Jerdonek (chris.jerdonek@gmail.com)
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
@@ skipping 144 matching lines @@
     """Tests validity of the global variables."""
 
     def _all_categories(self):
         return _all_categories()
 
     def defaults(self):
         return style._check_webkit_style_defaults()
 
     def test_webkit_base_filter_rules(self):
         base_filter_rules = _BASE_FILTER_RULES
-        defaults = self.defaults()
         already_seen = []
         validate_filter_rules(base_filter_rules, self._all_categories())
         # Also do some additional checks.
         for rule in base_filter_rules:
             # Check no leading or trailing white space.
             self.assertEqual(rule, rule.strip())
             # All categories are on by default, so defaults should
             # begin with -.
             self.assertTrue(rule.startswith('-'))
             # Check no rule occurs twice.
             self.assertNotIn(rule, already_seen)
             already_seen.append(rule)
 
     def test_defaults(self):
         """Check that default arguments are valid."""
         default_options = self.defaults()
 
         # FIXME: We should not need to call parse() to determine
         #        whether the default arguments are valid.
         parser = ArgumentParser(all_categories=self._all_categories(),
                                 base_filter_rules=[],
                                 default_options=default_options)
         # No need to test the return value here since we test parse()
         # on valid arguments elsewhere.
         #
         # The default options are valid: no error or SystemExit.
         parser.parse(args=[])
 
     def test_path_rules_specifier(self):
-        all_categories = self._all_categories()
-        for (sub_paths, path_rules) in PATH_RULES_SPECIFIER:
+        for _, path_rules in PATH_RULES_SPECIFIER:
             validate_filter_rules(path_rules, self._all_categories())
 
         config = FilterConfiguration(path_specific=PATH_RULES_SPECIFIER)
 
         def assertCheck(path, category):
             """Assert that the given category should be checked."""
-            message = ('Should check category "%s" for path "%s".'
-                       % (category, path))
             self.assertTrue(config.should_check(category, path))
 
         def assertNoCheck(path, category):
             """Assert that the given category should not be checked."""
             message = ('Should not check category "%s" for path "%s".'
                        % (category, path))
             self.assertFalse(config.should_check(category, path), message)
 
         assertCheck("random_path.cpp",
                     "build/include")
@@ skipping 18 matching lines @@
                           'Key "%s" is not a category' % category)
 
 
 class CheckWebKitStyleFunctionTest(unittest.TestCase):
 
     """Tests the functions with names of the form check_webkit_style_*."""
 
     def test_check_webkit_style_configuration(self):
         # Exercise the code path to make sure the function does not error out.
         option_values = CommandOptionValues()
-        configuration = check_webkit_style_configuration(option_values)
+        check_webkit_style_configuration(option_values)
 
     def test_check_webkit_style_parser(self):
         # Exercise the code path to make sure the function does not error out.
-        parser = check_webkit_style_parser()
+        check_webkit_style_parser()
 
 
 class CheckerDispatcherSkipTest(unittest.TestCase):
 
     """Tests the "should skip" methods of the CheckerDispatcher class."""
 
     def setUp(self):
         self._dispatcher = CheckerDispatcher()
 
     def test_should_skip_with_warning(self):
@@ skipping 554 matching lines @@
         """Test that carriage returns aren't stripped from files that are allowed to contain them."""
         file_path = 'carriage_returns_allowed.txt'
         lines = ['line1\r', 'line2\r']
         line_numbers = [100]
         self._processor.process(lines=lines,
                                 file_path=file_path,
                                 line_numbers=line_numbers)
         # The carriage return checker should never have been invoked, and so
         # should not have saved off any lines.
         self.assertFalse(hasattr(self.carriage_checker, 'lines'))