Remove all unused variables.

third_party/WebKit/Tools/Scripts/webkitpy/performance_tests/perftestsrunner_unittest.py

 # Copyright (C) 2012 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 29 matching lines @@
 from webkitpy.layout_tests.port.test import TestPort
 from webkitpy.performance_tests.perftest import ChromiumStylePerfTest
 from webkitpy.performance_tests.perftest import DEFAULT_TEST_RUNNER_COUNT
 from webkitpy.performance_tests.perftest import PerfTest
 from webkitpy.performance_tests.perftestsrunner import PerfTestsRunner
 
 
 class MainTest(unittest.TestCase):
 
     def create_runner(self, args=[]):
-        options, parsed_args = PerfTestsRunner._parse_args(args)
+        options, _ = PerfTestsRunner._parse_args(args)
         test_port = TestPort(host=MockHost(), options=options)
         runner = PerfTestsRunner(args=args, port=test_port)
         runner._host.filesystem.maybe_make_directory(runner._base_path, 'inspector')
         runner._host.filesystem.maybe_make_directory(runner._base_path, 'Bindings')
         runner._host.filesystem.maybe_make_directory(runner._base_path, 'Parser')
         return runner, test_port
 
     def _add_file(self, runner, dirname, filename, content=True):
         dirname = runner._host.filesystem.join(runner._base_path, dirname) if dirname else runner._base_path
         runner._host.filesystem.maybe_make_directory(dirname)
         runner._host.filesystem.files[runner._host.filesystem.join(dirname, filename)] = content
 
     def test_collect_tests(self):
-        runner, port = self.create_runner()
+        runner, _ = self.create_runner()
         self._add_file(runner, 'inspector', 'a_file.html', 'a content')
         tests = runner._collect_tests()
         self.assertEqual(len(tests), 1)
 
     def _collect_tests_and_sort_test_name(self, runner):
         return sorted([test.test_name() for test in runner._collect_tests()])
 
     def test_collect_tests_with_multile_files(self):
         runner, port = self.create_runner(args=['PerformanceTests/test1.html', 'test2.html'])
 
@@ skipping 36 matching lines @@
         self._add_file(runner, 'inspector', 'test1.html')
         self._add_file(runner, 'inspector', 'unsupported_test1.html')
         self._add_file(runner, 'inspector', 'test2.html')
         self._add_file(runner, 'inspector/resources', 'resource_file.html')
         self._add_file(runner, 'unsupported', 'unsupported_test2.html')
         port.skipped_perf_tests = lambda: ['inspector/unsupported_test1.html', 'unsupported']
         self.assertItemsEqual(self._collect_tests_and_sort_test_name(runner), [
                               'inspector/test1.html', 'inspector/test2.html', 'inspector/unsupported_test1.html', 'unsupported/unsupported_test2.html'])
 
     def test_default_args(self):
-        runner, port = self.create_runner()
-        options, args = PerfTestsRunner._parse_args([])
+        options, _ = PerfTestsRunner._parse_args([])
         self.assertTrue(options.build)
         self.assertEqual(options.time_out_ms, 600 * 1000)
         self.assertTrue(options.generate_results)
         self.assertTrue(options.show_results)
         self.assertTrue(options.use_skipped_list)
         self.assertEqual(options.repeat, 1)
         self.assertEqual(options.test_runner_count, DEFAULT_TEST_RUNNER_COUNT)
 
     def test_parse_args(self):
-        runner, port = self.create_runner()
-        options, args = PerfTestsRunner._parse_args([
+        options, _ = PerfTestsRunner._parse_args([
             '--build-directory=folder42',
             '--platform=platform42',
             '--builder-name', 'webkit-mac-1',
             '--build-number=56',
             '--time-out-ms=42',
             '--no-show-results',
             '--reset-results',
             '--output-json-path=a/output.json',
             '--slave-config-json-path=a/source.json',
             '--test-results-server=somehost',
@@ skipping 234 matching lines @@
 class IntegrationTest(unittest.TestCase):
 
     def _normalize_output(self, log):
         return re.sub(r'(stdev=\s+\d+\.\d{5})\d+', r'\1', re.sub(r'Finished: [0-9\.]+ s', 'Finished: 0.1 s', log))
 
     def _load_output_json(self, runner):
         json_content = runner._host.filesystem.read_text_file(runner._output_json_path())
         return json.loads(re.sub(r'("stdev":\s*\d+\.\d{5})\d+', r'\1', json_content))
 
     def create_runner(self, args=[], driver_class=TestDriver):
-        options, parsed_args = PerfTestsRunner._parse_args(args)
+        options, _ = PerfTestsRunner._parse_args(args)
         test_port = TestPort(host=MockHost(), options=options)
         test_port.create_driver = lambda worker_number=None, no_timeout=False: driver_class()
 
         runner = PerfTestsRunner(args=args, port=test_port)
         runner._host.filesystem.maybe_make_directory(runner._base_path, 'inspector')
         runner._host.filesystem.maybe_make_directory(runner._base_path, 'Bindings')
         runner._host.filesystem.maybe_make_directory(runner._base_path, 'Parser')
 
         return runner, test_port
 
@@ skipping 18 matching lines @@
         self.assertFalse(self.run_test('timeout.html'))
 
     def test_run_crash_test(self):
         self.assertFalse(self.run_test('crash.html'))
 
     def _tests_for_runner(self, runner, test_names):
         filesystem = runner._host.filesystem
         tests = []
         for test in test_names:
             path = filesystem.join(runner._base_path, test)
-            dirname = filesystem.dirname(path)
             if test.startswith('inspector/'):
                 tests.append(ChromiumStylePerfTest(runner._port, test, path))
             else:
                 tests.append(PerfTest(runner._port, test, path))
         return tests
 
     def test_run_test_set(self):
-        runner, port = self.create_runner()
+        runner, _ = self.create_runner()
         tests = self._tests_for_runner(runner, ['inspector/pass.html', 'inspector/silent.html', 'inspector/failed.html',
                                                 'inspector/tonguey.html', 'inspector/timeout.html', 'inspector/crash.html'])
         output = OutputCapture()
         output.capture_output()
         try:
             unexpected_result_count = runner._run_tests_set(tests)
         finally:
-            stdout, stderr, log = output.restore_output()
+            _, _, log = output.restore_output()
         self.assertEqual(unexpected_result_count, len(tests) - 1)
         self.assertTrue('\nRESULT group_name: test_name= 42 ms\n' in log)
 
     def test_run_test_set_kills_drt_per_run(self):
 
         class TestDriverWithStopCount(TestDriver):
             stop_count = 0
 
             def stop(self):
                 TestDriverWithStopCount.stop_count += 1
 
-        runner, port = self.create_runner(driver_class=TestDriverWithStopCount)
+        runner, _ = self.create_runner(driver_class=TestDriverWithStopCount)
 
         tests = self._tests_for_runner(runner, ['inspector/pass.html', 'inspector/silent.html', 'inspector/failed.html',
                                                 'inspector/tonguey.html', 'inspector/timeout.html', 'inspector/crash.html'])
-        unexpected_result_count = runner._run_tests_set(tests)
+        runner._run_tests_set(tests)
 
         self.assertEqual(TestDriverWithStopCount.stop_count, 6)
 
     def test_run_test_set_for_parser_tests(self):
-        runner, port = self.create_runner()
+        runner, _ = self.create_runner()
         tests = self._tests_for_runner(runner, ['Bindings/event-target-wrapper.html', 'Parser/some-parser.html'])
         output = OutputCapture()
         output.capture_output()
         try:
             unexpected_result_count = runner._run_tests_set(tests)
         finally:
-            stdout, stderr, log = output.restore_output()
+            _, _, log = output.restore_output()
         self.assertEqual(unexpected_result_count, 0)
         self.assertEqual(self._normalize_output(log), EventTargetWrapperTestData.output + SomeParserTestData.output)
 
     def test_run_memory_test(self):
         runner, port = self.create_runner_and_setup_results_template()
         runner._timestamp = 123456789
         port.host.filesystem.write_text_file(runner._base_path + '/Parser/memory-test.html', 'some content')
 
         output = OutputCapture()
         output.capture_output()
         try:
             unexpected_result_count = runner.run()
         finally:
-            stdout, stderr, log = output.restore_output()
+            _, _, log = output.restore_output()
         self.assertEqual(unexpected_result_count, 0)
         self.assertEqual(self._normalize_output(log), MemoryTestData.output + '\nMOCK: user.open_url: file://...\n')
         parser_tests = self._load_output_json(runner)[0]['tests']['Parser']['tests']
         self.assertEqual(parser_tests['memory-test']['metrics']['Time'], MemoryTestData.results)
         self.assertEqual(parser_tests['memory-test']['metrics']['JSHeap'], MemoryTestData.js_heap_results)
         self.assertEqual(parser_tests['memory-test']['metrics']['Malloc'], MemoryTestData.malloc_results)
 
     def _test_run_with_json_output(
             self, runner, filesystem, upload_succeeds=False, results_shown=True, expected_exit_code=0, repeat=1, compare_logs=True):
         filesystem.write_text_file(runner._base_path + '/inspector/pass.html', 'some content')
@@ skipping 10 matching lines @@
             return upload_succeeds
 
         runner._upload_json = mock_upload_json
         runner._timestamp = 123456789
         runner._utc_timestamp = datetime.datetime(2013, 2, 8, 15, 19, 37, 460000)
         output_capture = OutputCapture()
         output_capture.capture_output()
         try:
             self.assertEqual(runner.run(), expected_exit_code)
         finally:
-            stdout, stderr, logs = output_capture.restore_output()
+            _, _, logs = output_capture.restore_output()
 
         if not expected_exit_code and compare_logs:
             expected_logs = ''
             for i in xrange(repeat):
                 runs = ' (Run %d of %d)' % (i + 1, repeat) if repeat > 1 else ''
                 expected_logs += 'Running 2 tests%s\n' % runs + EventTargetWrapperTestData.output + InspectorPassTestData.output
             if results_shown:
                 expected_logs += 'MOCK: user.open_url: file://...\n'
             self.assertEqual(self._normalize_output(logs), expected_logs)
 
@@ skipping 245 matching lines @@
         self._test_run_with_json_output(runner, port.host.filesystem, compare_logs=False)
         generated_json = json.loads(port.host.filesystem.files['/mock-checkout/output.json'])
         self.assertTrue(isinstance(generated_json, list))
         self.assertEqual(len(generated_json), 1)
 
         output = generated_json[0]['tests']['Bindings']['tests']['event-target-wrapper']['metrics']['Time']['current']
         self.assertEqual(len(output), 3)
         expectedMetrics = EventTargetWrapperTestData.results['metrics']['Time']['current'][0]
         for metrics in output:
             self.assertEqual(metrics, expectedMetrics)