Run format-webkitpy and fix long lines.

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 96 matching lines @@
 
     def test_collect_tests_with_ignored_skipped_list(self):
         runner, port = self.create_runner(args=['--force'])
 
         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'])
+        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):
         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):
         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',
             '--additional-driver-flag=--enable-threaded-parser',
             '--additional-driver-flag=--awesomesauce',
             '--repeat=5',
             '--test-runner-count=5',
-            '--debug'])
+            '--debug'
+        ])
         self.assertTrue(options.build)
         self.assertEqual(options.build_directory, 'folder42')
         self.assertEqual(options.platform, 'platform42')
         self.assertEqual(options.builder_name, 'webkit-mac-1')
         self.assertEqual(options.build_number, '56')
         self.assertEqual(options.time_out_ms, '42')
         self.assertEqual(options.configuration, 'Debug')
         self.assertFalse(options.show_results)
         self.assertTrue(options.reset_results)
         self.assertEqual(options.output_json_path, 'a/output.json')
@@ skipping 384 matching lines @@
         self._test_run_with_json_output(runner, port.host.filesystem, upload_succeeds=True)
         self.assertEqual(self._load_output_json(runner), [{
             "buildTime": "2013-02-08T15:19:37.460000", "tests": self._event_target_wrapper_and_inspector_results,
             "revisions": {"chromium": {"timestamp": "2013-02-01 08:48:05 +0000", "revision": "5678"}}}])
 
         filesystem = port.host.filesystem
         self.assertTrue(filesystem.isfile(runner._output_json_path()))
         self.assertTrue(filesystem.isfile(filesystem.splitext(runner._output_json_path())[0] + '.html'))
 
     def test_run_with_description(self):
-        runner, port = self.create_runner_and_setup_results_template(args=['--output-json-path=/mock-checkout/output.json',
-                                                                           '--test-results-server=some.host', '--description', 'some description'])
+        runner, port = self.create_runner_and_setup_results_template(
+            args=['--output-json-path=/mock-checkout/output.json',
+                  '--test-results-server=some.host', '--description', 'some description'])
         self._test_run_with_json_output(runner, port.host.filesystem, upload_succeeds=True)
         self.assertEqual(self._load_output_json(runner), [{
             "buildTime": "2013-02-08T15:19:37.460000", "description": "some description",
             "tests": self._event_target_wrapper_and_inspector_results,
             "revisions": {"chromium": {"timestamp": "2013-02-01 08:48:05 +0000", "revision": "5678"}}}])
 
     def create_runner_and_setup_results_template(self, args=[]):
         runner, port = self.create_runner(args)
         filesystem = port.host.filesystem
-        filesystem.write_text_file(runner._base_path + '/resources/results-template.html',
-                                   'BEGIN<script src="%AbsolutePathToWebKitTrunk%/some.js"></script>'
-                                   '<script src="%AbsolutePathToWebKitTrunk%/other.js"></script><script>%PeformanceTestsResultsJSON%</script>END')
+        filesystem.write_text_file(
+            runner._base_path + '/resources/results-template.html',  # pylint: disable=protected-access
+            ('BEGIN<script src="%AbsolutePathToWebKitTrunk%/some.js"></script>'
+             '<script src="%AbsolutePathToWebKitTrunk%/other.js"></script><script>%PeformanceTestsResultsJSON%</script>END'))
         filesystem.write_text_file(runner._base_path + '/Dromaeo/resources/dromaeo/web/lib/jquery-1.6.4.js', 'jquery content')
         return runner, port
 
     def test_run_respects_no_results(self):
         runner, port = self.create_runner(args=['--output-json-path=/mock-checkout/output.json',
                                                 '--test-results-server=some.host', '--no-results'])
         self._test_run_with_json_output(runner, port.host.filesystem, upload_succeeds=False, results_shown=False)
         self.assertFalse(port.host.filesystem.isfile('/mock-checkout/output.json'))
 
     def test_run_generates_json_by_default(self):
         runner, port = self.create_runner_and_setup_results_template()
         filesystem = port.host.filesystem
         output_json_path = runner._output_json_path()
         results_page_path = filesystem.splitext(output_json_path)[0] + '.html'
 
         self.assertFalse(filesystem.isfile(output_json_path))
         self.assertFalse(filesystem.isfile(results_page_path))
 
         self._test_run_with_json_output(runner, port.host.filesystem)
 
-        self.assertEqual(self._load_output_json(runner), [{
-            "buildTime": "2013-02-08T15:19:37.460000", "tests": self._event_target_wrapper_and_inspector_results,
-            "revisions": {"chromium": {"timestamp": "2013-02-01 08:48:05 +0000", "revision": "5678"}}}])
+        self.assertEqual(
+            self._load_output_json(runner),
+            [
+                {
+                    "buildTime": "2013-02-08T15:19:37.460000",
+                    "tests": self._event_target_wrapper_and_inspector_results,
+                    "revisions": {"chromium": {"timestamp": "2013-02-01 08:48:05 +0000", "revision": "5678"}}
+                }
+            ])
 
         self.assertTrue(filesystem.isfile(output_json_path))
         self.assertTrue(filesystem.isfile(results_page_path))
 
     def test_run_merges_output_by_default(self):
         runner, port = self.create_runner_and_setup_results_template()
         filesystem = port.host.filesystem
         output_json_path = runner._output_json_path()
 
         filesystem.write_text_file(output_json_path, '[{"previous": "results"}]')
@@ skipping 62 matching lines @@
         self.assertEqual(page_shown, [])
 
     def test_run_with_bad_output_json(self):
         runner, port = self.create_runner_and_setup_results_template(args=['--output-json-path=/mock-checkout/output.json'])
         port.host.filesystem.write_text_file('/mock-checkout/output.json', 'bad json')
         self._test_run_with_json_output(runner, port.host.filesystem, expected_exit_code=PerfTestsRunner.EXIT_CODE_BAD_MERGE)
         port.host.filesystem.write_text_file('/mock-checkout/output.json', '{"another bad json": "1"}')
         self._test_run_with_json_output(runner, port.host.filesystem, expected_exit_code=PerfTestsRunner.EXIT_CODE_BAD_MERGE)
 
     def test_run_with_slave_config_json(self):
-        runner, port = self.create_runner_and_setup_results_template(args=['--output-json-path=/mock-checkout/output.json',
-                                                                           '--slave-config-json-path=/mock-checkout/slave-config.json', '--test-results-server=some.host'])
+        runner, port = self.create_runner_and_setup_results_template(
+            args=['--output-json-path=/mock-checkout/output.json',
+                  '--slave-config-json-path=/mock-checkout/slave-config.json',
+                  '--test-results-server=some.host'])
         port.host.filesystem.write_text_file('/mock-checkout/slave-config.json', '{"key": "value"}')
         self._test_run_with_json_output(runner, port.host.filesystem, upload_succeeds=True)
         self.assertEqual(self._load_output_json(runner), [{
             "buildTime": "2013-02-08T15:19:37.460000", "tests": self._event_target_wrapper_and_inspector_results,
             "revisions": {"chromium": {"timestamp": "2013-02-01 08:48:05 +0000", "revision": "5678"}}, "builderKey": "value"}])
 
     def test_run_with_bad_slave_config_json(self):
-        runner, port = self.create_runner_and_setup_results_template(args=['--output-json-path=/mock-checkout/output.json',
-                                                                           '--slave-config-json-path=/mock-checkout/slave-config.json', '--test-results-server=some.host'])
+        runner, port = self.create_runner_and_setup_results_template(
+            args=['--output-json-path=/mock-checkout/output.json',
+                  '--slave-config-json-path=/mock-checkout/slave-config.json',
+                  '--test-results-server=some.host'])
         logs = self._test_run_with_json_output(runner, port.host.filesystem,
                                                expected_exit_code=PerfTestsRunner.EXIT_CODE_BAD_SOURCE_JSON)
         self.assertTrue('Missing slave configuration JSON file: /mock-checkout/slave-config.json' in logs)
         port.host.filesystem.write_text_file('/mock-checkout/slave-config.json', 'bad json')
         self._test_run_with_json_output(runner, port.host.filesystem, expected_exit_code=PerfTestsRunner.EXIT_CODE_BAD_SOURCE_JSON)
         port.host.filesystem.write_text_file('/mock-checkout/slave-config.json', '["another bad json"]')
         self._test_run_with_json_output(runner, port.host.filesystem, expected_exit_code=PerfTestsRunner.EXIT_CODE_BAD_SOURCE_JSON)
 
     def test_run_with_multiple_repositories(self):
         runner, port = self.create_runner_and_setup_results_template(args=['--output-json-path=/mock-checkout/output.json',
@@ skipping 85 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)