Remove all unused variables.

third_party/WebKit/Tools/Scripts/webkitpy/style/checkers/cpp_unittest.py

 # -*- coding: utf-8; -*-
 #
 # Copyright (C) 2011 Google Inc. All rights reserved.
 # Copyright (C) 2009 Torch Mobile Inc.
 # Copyright (C) 2009 Apple Inc. All rights reserved.
 # 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:
@@ skipping 522 matching lines @@
              'body_start_position': (2, 1),
              'end_position': (2, 2),
              'is_pure': False,
              'is_declaration': True})
 
         # Simple test case with something that is not a function.
         self.perform_function_detection(['class Stuff;'], None)
 
     def test_parameter_list(self):
         # A function with no arguments.
-        function_state = self.perform_function_detection(
+        self.perform_function_detection(
             ['void functionName();'],
             {'name': 'functionName',
              'modifiers_and_return_type': 'void',
              'function_name_start_position': (0, 5),
              'parameter_start_position': (0, 17),
              'parameter_end_position': (0, 19),
              'body_start_position': (0, 19),
              'end_position': (0, 20),
              'is_pure': False,
              'is_declaration': True,
              'parameter_list': ()})
 
         # A function with one argument.
-        function_state = self.perform_function_detection(
+        self.perform_function_detection(
             ['void functionName(int);'],
             {'name': 'functionName',
              'modifiers_and_return_type': 'void',
              'function_name_start_position': (0, 5),
              'parameter_start_position': (0, 17),
              'parameter_end_position': (0, 22),
              'body_start_position': (0, 22),
              'end_position': (0, 23),
              'is_pure': False,
              'is_declaration': True,
              'parameter_list':
                  ({'type': 'int', 'name': '', 'row': 0},)})
 
         # A function with unsigned and short arguments
-        function_state = self.perform_function_detection(
+        self.perform_function_detection(
             ['void functionName(unsigned a, short b, long c, long long short unsigned int);'],
             {'name': 'functionName',
              'modifiers_and_return_type': 'void',
              'function_name_start_position': (0, 5),
              'parameter_start_position': (0, 17),
              'parameter_end_position': (0, 76),
              'body_start_position': (0, 76),
              'end_position': (0, 77),
              'is_pure': False,
              'is_declaration': True,
              'parameter_list':
                  ({'type': 'unsigned', 'name': 'a', 'row': 0},
                   {'type': 'short', 'name': 'b', 'row': 0},
                   {'type': 'long', 'name': 'c', 'row': 0},
                   {'type': 'long long short unsigned int', 'name': '', 'row': 0})})
 
         # Some parameter type with modifiers and no parameter names.
-        function_state = self.perform_function_detection(
+        self.perform_function_detection(
             [
                 'virtual void determineARIADropEffects(Vector<String>*&, const unsigned long int*&, const MediaPlayer::Preload, Other<Other2, Other3<P1, P2> >, int);'],
             {'name': 'determineARIADropEffects',
              'modifiers_and_return_type': 'virtual void',
              'parameter_start_position': (0, 37),
              'function_name_start_position': (0, 13),
              'parameter_end_position': (0, 147),
              'body_start_position': (0, 147),
              'end_position': (0, 148),
              'is_pure': False,
              'is_declaration': True,
              'parameter_list':
                  ({'type': 'Vector<String>*&', 'name': '', 'row': 0},
                   {'type': 'const unsigned long int*&', 'name': '', 'row': 0},
                   {'type': 'const MediaPlayer::Preload', 'name': '', 'row': 0},
                   {'type': 'Other<Other2, Other3<P1, P2> >', 'name': '', 'row': 0},
                   {'type': 'int', 'name': '', 'row': 0})})
 
         # Try parsing a function with a very complex definition.
-        function_state = self.perform_function_detection(
+        self.perform_function_detection(
             ['#define MyMacro(a) a',
              'virtual',
              'AnotherTemplate<Class1, Class2> aFunctionName(PassRefPtr<MyClass> paramName,',
              'const Other1Class& foo,',
              'const ComplexTemplate<Class1, NestedTemplate<P1, P2> >* const * param = new ComplexTemplate<Class1, NestedTemplate<P1, P2> >(34, 42),',
              'int* myCount = 0);'],
             {'name': 'aFunctionName',
              'modifiers_and_return_type': 'virtual AnotherTemplate<Class1, Class2>',
              'function_name_start_position': (2, 32),
              'parameter_start_position': (2, 45),
@@ skipping 1853 matching lines @@
                          build_storage_class_error_message)
 
         self.assert_lint('int register foo = 0;',
                          build_storage_class_error_message)
 
         # Since there are a very large number of possibilities, randomly
         # construct declarations.
         # Make sure that the declaration is logged if there's an error.
         # Seed generator with an integer for absolute reproducibility.
         random.seed(25)
-        for unused_i in range(10):
+        for _ in range(10):
             # Build up random list of non-storage-class declaration specs.
             other_decl_specs = [random.choice(qualifiers), random.choice(signs),
                                 random.choice(types)]
             # remove None
             other_decl_specs = filter(lambda x: x is not None, other_decl_specs)
 
             # shuffle
             random.shuffle(other_decl_specs)
 
             # insert storage class after the first
@@ skipping 25 matching lines @@
         # There should be a copyright message in the first 10 lines
         error_collector = ErrorCollector(self.assertTrue)
         self.process_file_data(file_path, 'cpp', [], error_collector)
         self.assertEqual(
             1,
             error_collector.result_list().count(legal_copyright_message))
 
         error_collector = ErrorCollector(self.assertTrue)
         self.process_file_data(
             file_path, 'cpp',
-            ['' for unused_i in range(10)] + [copyright_line],
+            ['' for _ in range(10)] + [copyright_line],
             error_collector)
         self.assertEqual(
             1,
             error_collector.result_list().count(legal_copyright_message))
 
         # Test that warning isn't issued if Copyright line appears early enough.
         error_collector = ErrorCollector(self.assertTrue)
         self.process_file_data(file_path, 'cpp', [copyright_line], error_collector)
         for message in error_collector.result_list():
             if message.find('legal/copyright') != -1:
                 self.fail('Unexpected error: %s' % message)
 
         error_collector = ErrorCollector(self.assertTrue)
         self.process_file_data(
             file_path, 'cpp',
-            ['' for unused_i in range(9)] + [copyright_line],
+            ['' for _ in range(9)] + [copyright_line],
             error_collector)
         for message in error_collector.result_list():
             if message.find('legal/copyright') != -1:
                 self.fail('Unexpected error: %s' % message)
 
     def test_invalid_increment(self):
         self.assert_lint('*count++;',
                          'Changing pointer instead of value (or unused value of '
                          'operator*).  [runtime/invalid_increment] [5]')
 
@@ skipping 732 matching lines @@
             ('Small and focused functions are preferred: '
              'TEST_F(GoogleUpdateRecoveryRegistryProtectedTest, '  # 1 space
              'FixGoogleUpdate_AllValues_MachineApp) has %d non-comment lines '
              '(error triggered by exceeding %d lines).'
              '  [readability/fn_size] [%d]')
             % (error_lines, trigger_level, error_level))
 
     def test_function_length_check_definition_severity1_for_bad_test_doesnt_break(self):
         error_level = 1
         error_lines = self.trigger_test_lines(error_level) + 1
-        trigger_level = self.trigger_test_lines(self.min_confidence)
         # Since the function name isn't valid, the function detection algorithm
         # will skip it, so no error is produced.
         self.assert_function_lengths_check(
             ('TEST_F('
              + self.function_body(error_lines)),
             '')
 
     def test_function_length_check_definition_severity1_with_embedded_no_lints(self):
         error_level = 1
         error_lines = self.trigger_lines(error_level) + 1
@@ skipping 1981 matching lines @@
     def test_ne(self):
         """Test __ne__ inequality function."""
         checker1 = self._checker()
         checker2 = self._checker()
 
         # != calls __ne__.
         # By default, __ne__ always returns true on different objects.
         # Thus, just check the distinguishing case to verify that the
         # code defines __ne__.
         self.assertFalse(checker1 != checker2)