Reformat webkitpy.layout_tests w/ format-webkitpy.

Tools/Scripts/webkitpy/layout_tests/port/android_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 33 matching lines @@
 
 # Type of tombstone test which the mocked Android Debug Bridge should execute.
 VALID_TOMBSTONE_TEST_TYPE = 0
 NO_FILES_TOMBSTONE_TEST_TYPE = 1
 NO_PERMISSION_TOMBSTONE_TEST_TYPE = 2
 INVALID_ENTRY_TOMBSTONE_TEST_TYPE = 3
 INVALID_ENTRIES_TOMBSTONE_TEST_TYPE = 4
 
 # Any "adb" commands will be interpret by this class instead of executing actual
 # commansd on the file system, which we don't want to do.
+
+
 class MockAndroidDebugBridge:
+
     def __init__(self, device_count):
         self._device_count = device_count
         self._last_command = None
         self._tombstone_output = None
 
     # Local public methods.
 
     def run_command(self, args):
         self._last_command = ' '.join(args)
         if args[0].startswith('path'):
@@ skipping 40 matching lines @@
     def _get_device_output(self):
         serials = ['123456789ABCDEF0', '123456789ABCDEF1', '123456789ABCDEF2',
                    '123456789ABCDEF3', '123456789ABCDEF4', '123456789ABCDEF5']
         output = 'List of devices attached\n'
         for serial in serials[:self._device_count]:
             output += '%s\tdevice\n' % serial
         return output
 
 
 class AndroidCommandsTest(unittest.TestCase):
+
     def setUp(self):
         android.AndroidCommands._adb_command_path = None
         android.AndroidCommands._adb_command_path_options = ['adb']
 
     def make_executive(self, device_count):
         self._mock_executive = MockAndroidDebugBridge(device_count)
         return MockExecutive2(run_command_fn=self._mock_executive.run_command)
 
     def make_android_commands(self, device_count, serial):
         return android.AndroidCommands(self.make_executive(device_count), serial, debug_logging=False)
@@ skipping 66 matching lines @@
     def test_requires_http_server(self):
         self.assertTrue(self.make_port(device_count=1).requires_http_server())
 
     # Tests the default timeouts for Android, which are different than the rest of Chromium.
     def test_default_timeout_ms(self):
         self.assertEqual(self.make_port(options=optparse.Values({'configuration': 'Release'})).default_timeout_ms(), 10000)
         self.assertEqual(self.make_port(options=optparse.Values({'configuration': 'Debug'})).default_timeout_ms(), 10000)
 
 
 class ChromiumAndroidDriverTest(unittest.TestCase):
+
     def setUp(self):
         self._mock_adb = MockAndroidDebugBridge(1)
         self._mock_executive = MockExecutive2(run_command_fn=self._mock_adb.run_command)
 
         android_commands = android.AndroidCommands(self._mock_executive, '123456789ABCDEF0', debug_logging=False)
         self._port = android.AndroidPort(MockSystemHost(executive=self._mock_executive), 'android')
         self._driver = android.ChromiumAndroidDriver(self._port, worker_number=0,
-            pixel_tests=True, driver_details=android.ContentShellDriverDetails(), android_devices=self._port._devices)
+                                                     pixel_tests=True, driver_details=android.ContentShellDriverDetails(), android_devices=self._port._devices)
 
     # The cmd_line() method in the Android port is used for starting a shell, not the test runner.
     def test_cmd_line(self):
         self.assertEquals(['adb', '-s', '123456789ABCDEF0', 'shell'], self._driver.cmd_line(False, []))
 
     # Test that the Chromium Android port can interpret Android's shell output.
     def test_read_prompt(self):
         self._driver._server_process = driver_unittest.MockServerProcess(lines=['root@android:/ # '])
         self.assertIsNone(self._driver._read_prompt(time.time() + 1))
         self._driver._server_process = driver_unittest.MockServerProcess(lines=['$ '])
         self.assertIsNone(self._driver._read_prompt(time.time() + 1))
 
 
 class ChromiumAndroidDriverTwoDriversTest(unittest.TestCase):
     # Test two drivers getting the right serial numbers, and that we disregard per-test arguments.
+
     def test_two_drivers(self):
         mock_adb = MockAndroidDebugBridge(2)
         mock_executive = MockExecutive2(run_command_fn=mock_adb.run_command)
 
         port = android.AndroidPort(MockSystemHost(executive=mock_executive), 'android')
         driver0 = android.ChromiumAndroidDriver(port, worker_number=0, pixel_tests=True,
-            driver_details=android.ContentShellDriverDetails(), android_devices=port._devices)
+                                                driver_details=android.ContentShellDriverDetails(), android_devices=port._devices)
         driver1 = android.ChromiumAndroidDriver(port, worker_number=1, pixel_tests=True,
-            driver_details=android.ContentShellDriverDetails(), android_devices=port._devices)
+                                                driver_details=android.ContentShellDriverDetails(), android_devices=port._devices)
 
         self.assertEqual(['adb', '-s', '123456789ABCDEF0', 'shell'], driver0.cmd_line(True, []))
         self.assertEqual(['adb', '-s', '123456789ABCDEF1', 'shell'], driver1.cmd_line(True, ['anything']))
 
 
 class ChromiumAndroidTwoPortsTest(unittest.TestCase):
     # Test that the driver's command line indeed goes through to the driver.
+
     def test_options_with_two_ports(self):
         mock_adb = MockAndroidDebugBridge(2)
         mock_executive = MockExecutive2(run_command_fn=mock_adb.run_command)
 
         port0 = android.AndroidPort(MockSystemHost(executive=mock_executive),
-            'android', options=MockOptions(additional_drt_flag=['--foo=bar']))
+                                    'android', options=MockOptions(additional_drt_flag=['--foo=bar']))
         port1 = android.AndroidPort(MockSystemHost(executive=mock_executive),
-            'android', options=MockOptions(driver_name='content_shell'))
+                                    'android', options=MockOptions(driver_name='content_shell'))
 
         self.assertEqual(1, port0.driver_cmd_line().count('--foo=bar'))
         self.assertEqual(0, port1.driver_cmd_line().count('--create-stdin-fifo'))
 
 
 class ChromiumAndroidDriverTombstoneTest(unittest.TestCase):
     EXPECTED_STACKTRACE = '-rw------- 1000 1000 3604 2013-11-19 16:16 tombstone_10\ntombstone content'
 
     def setUp(self):
         self._mock_adb = MockAndroidDebugBridge(1)
         self._mock_executive = MockExecutive2(run_command_fn=self._mock_adb.run_command)
 
         self._port = android.AndroidPort(MockSystemHost(executive=self._mock_executive), 'android')
         self._driver = android.ChromiumAndroidDriver(self._port, worker_number=0,
-            pixel_tests=True, driver_details=android.ContentShellDriverDetails(), android_devices=self._port._devices)
+                                                     pixel_tests=True, driver_details=android.ContentShellDriverDetails(), android_devices=self._port._devices)
 
         self._errors = []
         self._driver._log_error = lambda msg: self._errors.append(msg)
 
         self._warnings = []
         self._driver._log_warning = lambda msg: self._warnings.append(msg)
 
     # Tests that we return an empty string and log an error when no tombstones could be found.
     def test_no_tombstones_found(self):
         self._mock_adb.set_tombstone_output('/data/tombstones/tombstone_*: No such file or directory')
@@ skipping 38 matching lines @@
     # Tests that valid tombstone listings will return the contents of the most recent file.
     def test_read_valid_tombstone_file(self):
         self._mock_adb.set_tombstone_output('-rw------- 1000 1000 3604 2013-11-19 16:15 tombstone_00\n' +
                                             '-rw------- 1000 1000 3604 2013-11-19 16:16 tombstone_10\n' +
                                             '-rw------- 1000 1000 3604 2013-11-19 16:15 tombstone_02')
         stacktrace = self._driver._get_last_stacktrace()
 
         self.assertEqual(0, len(self._warnings))
         self.assertEqual(0, len(self._errors))
         self.assertEqual(ChromiumAndroidDriverTombstoneTest.EXPECTED_STACKTRACE, stacktrace)