Re-format all codes to Google style. (#713)

* Add a config file for yapf
* Clarify the pre-submit steps in CONTRIBUTION.

1 files changed, 381 insertions, 406 deletions

diff --git a/tests/mobly/controllers/android_device_test.py b/tests/mobly/controllers/android_device_test.py
index 579b50f..12b4b04 100755
--- a/tests/mobly/controllers/android_device_test.py
+++ b/tests/mobly/controllers/android_device_test.py
@@ -62,30 +62,30 @@ class AndroidDeviceTest(unittest.TestCase):
   # These tests use mock AndroidDevice instances.
 
   @mock.patch.object(android_device,
-             'get_all_instances',
-             new=mock_android_device.get_all_instances)
+                     'get_all_instances',
+                     new=mock_android_device.get_all_instances)
   @mock.patch.object(android_device,
-             'list_adb_devices',
-             new=mock_android_device.list_adb_devices)
+                     'list_adb_devices',
+                     new=mock_android_device.list_adb_devices)
   @mock.patch.object(android_device,
-             'list_adb_devices_by_usb_id',
-             new=mock_android_device.list_adb_devices)
+                     'list_adb_devices_by_usb_id',
+                     new=mock_android_device.list_adb_devices)
   def test_create_with_pickup_all(self):
     pick_all_token = android_device.ANDROID_DEVICE_PICK_ALL_TOKEN
     actual_ads = android_device.create(pick_all_token)
     for actual, expected in zip(actual_ads,
-                  mock_android_device.get_mock_ads(5)):
+                                mock_android_device.get_mock_ads(5)):
       self.assertEqual(actual.serial, expected.serial)
 
   @mock.patch.object(android_device,
-             'get_instances',
-             new=mock_android_device.get_instances)
+                     'get_instances',
+                     new=mock_android_device.get_instances)
   @mock.patch.object(android_device,
-             'list_adb_devices',
-             new=mock_android_device.list_adb_devices)
+                     'list_adb_devices',
+                     new=mock_android_device.list_adb_devices)
   @mock.patch.object(android_device,
-             'list_adb_devices_by_usb_id',
-             new=mock_android_device.list_adb_devices)
+                     'list_adb_devices_by_usb_id',
+                     new=mock_android_device.list_adb_devices)
   def test_create_with_string_list(self):
     string_list = [u'1', '2']
     actual_ads = android_device.create(string_list)
@@ -93,14 +93,14 @@ class AndroidDeviceTest(unittest.TestCase):
       self.assertEqual(actual_ad.serial, expected_serial)
 
   @mock.patch.object(android_device,
-             'get_instances_with_configs',
-             new=mock_android_device.get_instances_with_configs)
+                     'get_instances_with_configs',
+                     new=mock_android_device.get_instances_with_configs)
   @mock.patch.object(android_device,
-             'list_adb_devices',
-             new=mock_android_device.list_adb_devices)
+                     'list_adb_devices',
+                     new=mock_android_device.list_adb_devices)
   @mock.patch.object(android_device,
-             'list_adb_devices_by_usb_id',
-             new=mock_android_device.list_adb_devices)
+                     'list_adb_devices_by_usb_id',
+                     new=mock_android_device.list_adb_devices)
   def test_create_with_dict_list(self):
     string_list = [{'serial': '1'}, {'serial': '2'}]
     actual_ads = android_device.create(string_list)
@@ -108,14 +108,14 @@ class AndroidDeviceTest(unittest.TestCase):
       self.assertEqual(actual_ad.serial, expected_serial)
 
   @mock.patch.object(android_device,
-             'get_instances_with_configs',
-             new=mock_android_device.get_instances_with_configs)
+                     'get_instances_with_configs',
+                     new=mock_android_device.get_instances_with_configs)
   @mock.patch.object(android_device,
-             'list_adb_devices',
-             new=mock_android_device.list_adb_devices)
+                     'list_adb_devices',
+                     new=mock_android_device.list_adb_devices)
   @mock.patch.object(android_device,
-             'list_adb_devices_by_usb_id',
-             return_value=['usb:1'])
+                     'list_adb_devices_by_usb_id',
+                     return_value=['usb:1'])
   def test_create_with_usb_id(self, mock_list_adb_devices_by_usb_id):
     string_list = [{'serial': '1'}, {'serial': '2'}, {'serial': 'usb:1'}]
     actual_ads = android_device.create(string_list)
@@ -151,7 +151,7 @@ class AndroidDeviceTest(unittest.TestCase):
   def test_get_devices_no_match(self):
     ads = mock_android_device.get_mock_ads(5)
     expected_msg = ('Could not find a target device that matches condition'
-            ": {'label': 'selected'}.")
+                    ": {'label': 'selected'}.")
     with self.assertRaisesRegex(android_device.Error, expected_msg):
       selected_ads = android_device.get_devices(ads, label='selected')
 
@@ -167,15 +167,15 @@ class AndroidDeviceTest(unittest.TestCase):
     expected_h_port = 5555
     ads[1].h_port = expected_h_port
     ad = android_device.get_device(ads,
-                     serial=expected_serial,
-                     h_port=expected_h_port)
+                                   serial=expected_serial,
+                                   h_port=expected_h_port)
     self.assertEqual(ad.serial, expected_serial)
     self.assertEqual(ad.h_port, expected_h_port)
 
   def test_get_device_no_match(self):
     ads = mock_android_device.get_mock_ads(5)
     expected_msg = ('Could not find a target device that matches condition'
-            ": {'serial': 5}.")
+                    ": {'serial': 5}.")
     with self.assertRaisesRegex(android_device.Error, expected_msg):
       ad = android_device.get_device(ads, serial=len(ads))
 
@@ -198,7 +198,7 @@ class AndroidDeviceTest(unittest.TestCase):
       ad.skip_logcat = False
       ad.is_required = True
     ads[1].services.logcat.start = mock.MagicMock(
-      side_effect=android_device.Error(msg))
+        side_effect=android_device.Error(msg))
     with self.assertRaisesRegex(android_device.Error, msg):
       android_device._start_services_on_ads(ads)
     ads[0].services.stop_all.assert_called_once_with()
@@ -210,58 +210,60 @@ class AndroidDeviceTest(unittest.TestCase):
     ads[0].services.logcat.start = mock.MagicMock()
     ads[1].services.logcat.start = mock.MagicMock()
     ads[2].services.logcat.start = mock.MagicMock(
-      side_effect=Exception('Should not have called this.'))
+        side_effect=Exception('Should not have called this.'))
     ads[2].skip_logcat = True
     android_device._start_services_on_ads(ads)
 
   def test_take_bug_reports(self):
     ads = mock_android_device.get_mock_ads(3)
     android_device.take_bug_reports(ads, 'test_something', 'sometime')
-    ads[0].take_bug_report.assert_called_once_with(
-      test_name='test_something',
-      begin_time='sometime',
-      destination=None)
-    ads[1].take_bug_report.assert_called_once_with(
-      test_name='test_something',
-      begin_time='sometime',
-      destination=None)
-    ads[2].take_bug_report.assert_called_once_with(
-      test_name='test_something',
-      begin_time='sometime',
-      destination=None)
+    ads[0].take_bug_report.assert_called_once_with(test_name='test_something',
+                                                   begin_time='sometime',
+                                                   destination=None)
+    ads[1].take_bug_report.assert_called_once_with(test_name='test_something',
+                                                   begin_time='sometime',
+                                                   destination=None)
+    ads[2].take_bug_report.assert_called_once_with(test_name='test_something',
+                                                   begin_time='sometime',
+                                                   destination=None)
 
   def test_take_bug_reports_with_int_begin_time(self):
     ads = mock_android_device.get_mock_ads(3)
     android_device.take_bug_reports(ads, 'test_something', 123)
-    ads[0].take_bug_report.assert_called_once_with(
-      test_name='test_something', begin_time='123', destination=None)
-    ads[1].take_bug_report.assert_called_once_with(
-      test_name='test_something', begin_time='123', destination=None)
-    ads[2].take_bug_report.assert_called_once_with(
-      test_name='test_something', begin_time='123', destination=None)
+    ads[0].take_bug_report.assert_called_once_with(test_name='test_something',
+                                                   begin_time='123',
+                                                   destination=None)
+    ads[1].take_bug_report.assert_called_once_with(test_name='test_something',
+                                                   begin_time='123',
+                                                   destination=None)
+    ads[2].take_bug_report.assert_called_once_with(test_name='test_something',
+                                                   begin_time='123',
+                                                   destination=None)
 
   @mock.patch('mobly.logger.get_log_file_timestamp')
-  def test_take_bug_reports_with_none_values(self,
-                         get_log_file_timestamp_mock):
+  def test_take_bug_reports_with_none_values(self, get_log_file_timestamp_mock):
     mock_timestamp = '07-22-2019_17-55-30-765'
     get_log_file_timestamp_mock.return_value = mock_timestamp
     ads = mock_android_device.get_mock_ads(3)
     android_device.take_bug_reports(ads)
-    ads[0].take_bug_report.assert_called_once_with(
-      test_name=None, begin_time=mock_timestamp, destination=None)
-    ads[1].take_bug_report.assert_called_once_with(
-      test_name=None, begin_time=mock_timestamp, destination=None)
-    ads[2].take_bug_report.assert_called_once_with(
-      test_name=None, begin_time=mock_timestamp, destination=None)
+    ads[0].take_bug_report.assert_called_once_with(test_name=None,
+                                                   begin_time=mock_timestamp,
+                                                   destination=None)
+    ads[1].take_bug_report.assert_called_once_with(test_name=None,
+                                                   begin_time=mock_timestamp,
+                                                   destination=None)
+    ads[2].take_bug_report.assert_called_once_with(test_name=None,
+                                                   begin_time=mock_timestamp,
+                                                   destination=None)
 
   # Tests for android_device.AndroidDevice class.
   # These tests mock out any interaction with the OS and real android device
   # in AndroidDeivce.
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   def test_AndroidDevice_instantiation(self, MockFastboot, MockAdbProxy):
     """Verifies the AndroidDevice object's basic attributes are correctly
     set after instantiation.
@@ -271,24 +273,20 @@ class AndroidDeviceTest(unittest.TestCase):
     self.assertEqual(ad.serial, '1')
     self.assertEqual(ad.model, 'fakemodel')
     expected_lp = os.path.join(logging.log_path,
-                   'AndroidDevice%s' % mock_serial)
+                               'AndroidDevice%s' % mock_serial)
     self.assertEqual(ad.log_path, expected_lp)
     self.assertIsNotNone(ad.services.logcat)
     self.assertIsNotNone(ad.services.snippets)
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy(1))
+              return_value=mock_android_device.MockAdbProxy(1))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy(1))
+              return_value=mock_android_device.MockFastbootProxy(1))
   @mock.patch('mobly.utils.create_dir')
   def test_AndroidDevice_load_config(self, create_dir_mock, FastbootProxy,
-                     MockAdbProxy):
+                                     MockAdbProxy):
     mock_serial = '1'
-    config = {
-      'space': 'the final frontier',
-      'number': 1,
-      'debug_tag': 'my_tag'
-    }
+    config = {'space': 'the final frontier', 'number': 1, 'debug_tag': 'my_tag'}
     ad = android_device.AndroidDevice(serial=mock_serial)
     ad.load_config(config)
     self.assertEqual(ad.space, 'the final frontier')
@@ -296,23 +294,23 @@ class AndroidDeviceTest(unittest.TestCase):
     self.assertEqual(ad.debug_tag, 'my_tag')
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy(1))
+              return_value=mock_android_device.MockAdbProxy(1))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy(1))
+              return_value=mock_android_device.MockFastbootProxy(1))
   @mock.patch('mobly.utils.create_dir')
-  def test_AndroidDevice_load_config_dup(self, create_dir_mock,
-                       FastbootProxy, MockAdbProxy):
+  def test_AndroidDevice_load_config_dup(self, create_dir_mock, FastbootProxy,
+                                         MockAdbProxy):
     mock_serial = '1'
     config = {'serial': 'new_serial'}
     ad = android_device.AndroidDevice(serial=mock_serial)
     with self.assertRaisesRegex(android_device.DeviceError,
-                  'Attribute serial already exists with'):
+                                'Attribute serial already exists with'):
       ad.load_config(config)
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   def test_AndroidDevice_build_info(self, MockFastboot, MockAdbProxy):
     """Verifies the AndroidDevice object's basic attributes are correctly
     set after instantiation.
@@ -328,18 +326,17 @@ class AndroidDeviceTest(unittest.TestCase):
     self.assertEqual(build_info['product_name'], 'FakeModel')
     self.assertEqual(build_info['debuggable'], '1')
     self.assertEqual(build_info['hardware'], 'marlin')
-    self.assertEqual(len(build_info),
-             len(android_device.CACHED_SYSTEM_PROPS))
+    self.assertEqual(len(build_info), len(android_device.CACHED_SYSTEM_PROPS))
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy(
-          '1',
-          mock_properties={
-            'ro.build.id': 'AB42',
-            'ro.build.type': 'userdebug',
-          }))
+              return_value=mock_android_device.MockAdbProxy(
+                  '1',
+                  mock_properties={
+                      'ro.build.id': 'AB42',
+                      'ro.build.type': 'userdebug',
+                  }))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   def test_AndroidDevice_build_info_with_minimal_properties(
       self, MockFastboot, MockAdbProxy):
     ad = android_device.AndroidDevice(serial='1')
@@ -355,9 +352,9 @@ class AndroidDeviceTest(unittest.TestCase):
     self.assertEqual(build_info['hardware'], '')
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   def test_AndroidDevice_build_info_cached(self, MockFastboot, MockAdbProxy):
     """Verifies the AndroidDevice object's basic attributes are correctly
     set after instantiation.
@@ -369,39 +366,39 @@ class AndroidDeviceTest(unittest.TestCase):
     self.assertEqual(ad.adb.getprops_call_count, 1)
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy(
-          '1',
-          mock_properties={
-            'ro.build.id': 'AB42',
-            'ro.build.type': 'userdebug',
-            'ro.debuggable': '1',
-          }))
+              return_value=mock_android_device.MockAdbProxy(
+                  '1',
+                  mock_properties={
+                      'ro.build.id': 'AB42',
+                      'ro.build.type': 'userdebug',
+                      'ro.debuggable': '1',
+                  }))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   def test_AndroidDevice_is_rootable_when_userdebug_device(
       self, MockFastboot, MockAdbProxy):
     ad = android_device.AndroidDevice(serial='1')
     self.assertTrue(ad.is_rootable)
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy(
-          '1',
-          mock_properties={
-            'ro.build.id': 'AB42',
-            'ro.build.type': 'user',
-            'ro.debuggable': '0',
-          }))
+              return_value=mock_android_device.MockAdbProxy(
+                  '1',
+                  mock_properties={
+                      'ro.build.id': 'AB42',
+                      'ro.build.type': 'user',
+                      'ro.debuggable': '0',
+                  }))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
-  def test_AndroidDevice_is_rootable_when_user_device(
-      self, MockFastboot, MockAdbProxy):
+              return_value=mock_android_device.MockFastbootProxy('1'))
+  def test_AndroidDevice_is_rootable_when_user_device(self, MockFastboot,
+                                                      MockAdbProxy):
     ad = android_device.AndroidDevice(serial='1')
     self.assertFalse(ad.is_rootable)
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   def test_AndroidDevice_device_info(self, MockFastboot, MockAdbProxy):
     ad = android_device.AndroidDevice(serial=1)
     device_info = ad.device_info
@@ -416,9 +413,9 @@ class AndroidDeviceTest(unittest.TestCase):
     self.assertEqual(device_info['user_added_info']['build_id'], 'CD42')
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   def test_AndroidDevice_serial_is_valid(self, MockFastboot, MockAdbProxy):
     """Verifies that the serial is a primitive string type and serializable.
     """
@@ -433,19 +430,19 @@ class AndroidDeviceTest(unittest.TestCase):
     yaml.safe_dump(ad.serial)
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   def test_AndroidDevice_is_emulator_when_realish_device(
       self, MockFastboot, MockAdbProxy):
     ad = android_device.AndroidDevice(serial='1')
     self.assertFalse(ad.is_emulator)
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('localhost:123'))
+              return_value=mock_android_device.MockAdbProxy('localhost:123'))
   @mock.patch(
-    'mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-    return_value=mock_android_device.MockFastbootProxy('localhost:123'))
+      'mobly.controllers.android_device_lib.fastboot.FastbootProxy',
+      return_value=mock_android_device.MockFastbootProxy('localhost:123'))
   def test_AndroidDevice_is_emulator_when_local_networked_device(
       self, MockFastboot, MockAdbProxy):
     # Although these devices are usually emulators, there might be a reason
@@ -453,122 +450,121 @@ class AndroidDeviceTest(unittest.TestCase):
     ad = android_device.AndroidDevice(serial='localhost:123')
     self.assertFalse(ad.is_emulator)
 
-  @mock.patch(
-    'mobly.controllers.android_device_lib.adb.AdbProxy',
-    return_value=mock_android_device.MockAdbProxy('example.com:123'))
-  @mock.patch(
-    'mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-    return_value=mock_android_device.MockFastbootProxy('example:123'))
+  @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
+              return_value=mock_android_device.MockAdbProxy('example.com:123'))
+  @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
+              return_value=mock_android_device.MockFastbootProxy('example:123'))
   def test_AndroidDevice_is_emulator_when_remote_networked_device(
       self, MockFastboot, MockAdbProxy):
     ad = android_device.AndroidDevice(serial='example.com:123')
     self.assertFalse(ad.is_emulator)
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy(
-          'localhost:5554',
-          mock_properties={
-            'ro.hardware': 'ranchu',
-            'ro.build.id': 'AB42',
-            'ro.build.type': 'userdebug',
-          }))
+              return_value=mock_android_device.MockAdbProxy(
+                  'localhost:5554',
+                  mock_properties={
+                      'ro.hardware': 'ranchu',
+                      'ro.build.id': 'AB42',
+                      'ro.build.type': 'userdebug',
+                  }))
   @mock.patch(
-    'mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-    return_value=mock_android_device.MockFastbootProxy('localhost:5554'))
-  def test_AndroidDevice_is_emulator_when_ranchu_device(
-      self, MockFastboot, MockAdbProxy):
+      'mobly.controllers.android_device_lib.fastboot.FastbootProxy',
+      return_value=mock_android_device.MockFastbootProxy('localhost:5554'))
+  def test_AndroidDevice_is_emulator_when_ranchu_device(self, MockFastboot,
+                                                        MockAdbProxy):
     ad = android_device.AndroidDevice(serial='localhost:5554')
     self.assertTrue(ad.is_emulator)
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy(
-          '1',
-          mock_properties={
-            'ro.build.id': 'AB42',
-            'ro.build.type': 'userdebug',
-            'ro.hardware': 'goldfish',
-          }))
+              return_value=mock_android_device.MockAdbProxy(
+                  '1',
+                  mock_properties={
+                      'ro.build.id': 'AB42',
+                      'ro.build.type': 'userdebug',
+                      'ro.hardware': 'goldfish',
+                  }))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   def test_AndroidDevice_is_emulator_when_goldfish_device(
       self, MockFastboot, MockAdbProxy):
     ad = android_device.AndroidDevice(serial='1')
     self.assertTrue(ad.is_emulator)
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy(
-          'example.com:123',
-          mock_properties={
-            'ro.build.id': 'AB42',
-            'ro.build.type': 'userdebug',
-            'ro.build.characteristics': 'emulator',
-          }))
+              return_value=mock_android_device.MockAdbProxy(
+                  'example.com:123',
+                  mock_properties={
+                      'ro.build.id': 'AB42',
+                      'ro.build.type': 'userdebug',
+                      'ro.build.characteristics': 'emulator',
+                  }))
   @mock.patch(
-    'mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-    return_value=mock_android_device.MockFastbootProxy('example.com:123'))
+      'mobly.controllers.android_device_lib.fastboot.FastbootProxy',
+      return_value=mock_android_device.MockFastbootProxy('example.com:123'))
   def test_AndroidDevice_is_emulator_when_emulator_characteristic(
       self, MockFastboot, MockAdbProxy):
     ad = android_device.AndroidDevice(serial='example.com:123')
     self.assertTrue(ad.is_emulator)
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('emulator-5554'))
+              return_value=mock_android_device.MockAdbProxy('emulator-5554'))
   @mock.patch(
-    'mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-    return_value=mock_android_device.MockFastbootProxy('emulator-5554'))
+      'mobly.controllers.android_device_lib.fastboot.FastbootProxy',
+      return_value=mock_android_device.MockFastbootProxy('emulator-5554'))
   def test_AndroidDevice_is_emulator_when_emulator_serial(
       self, MockFastboot, MockAdbProxy):
     ad = android_device.AndroidDevice(serial='emulator-5554')
     self.assertTrue(ad.is_emulator)
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   @mock.patch('mobly.logger.get_log_file_timestamp')
-  def test_AndroidDevice_generate_filename_default(
-      self, get_log_file_timestamp_mock, MockFastboot, MockAdbProxy):
+  def test_AndroidDevice_generate_filename_default(self,
+                                                   get_log_file_timestamp_mock,
+                                                   MockFastboot, MockAdbProxy):
     mock_serial = 1
     ad = android_device.AndroidDevice(serial=mock_serial)
     get_log_file_timestamp_mock.return_value = '07-22-2019_17-53-34-450'
     filename = ad.generate_filename('MagicLog')
-    self.assertEqual(filename,
-             'MagicLog,1,fakemodel,07-22-2019_17-53-34-450')
+    self.assertEqual(filename, 'MagicLog,1,fakemodel,07-22-2019_17-53-34-450')
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   @mock.patch('mobly.logger.get_log_file_timestamp')
   @mock.patch('mobly.logger.sanitize_filename')
   def test_AndroidDevice_generate_filename_assert_sanitation(
-      self, sanitize_filename_mock, get_log_file_timestamp_mock,
-      MockFastboot, MockAdbProxy):
+      self, sanitize_filename_mock, get_log_file_timestamp_mock, MockFastboot,
+      MockAdbProxy):
     mock_serial = 1
     ad = android_device.AndroidDevice(serial=mock_serial)
     get_log_file_timestamp_mock.return_value = '07-22-2019_17-53-34-450'
     filename = ad.generate_filename('MagicLog')
     sanitize_filename_mock.assert_called_with(
-      'MagicLog,1,fakemodel,07-22-2019_17-53-34-450')
+        'MagicLog,1,fakemodel,07-22-2019_17-53-34-450')
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   @mock.patch('mobly.logger.get_log_file_timestamp')
-  def test_AndroidDevice_generate_filename_with_ext(
-      self, get_log_file_timestamp_mock, MockFastboot, MockAdbProxy):
+  def test_AndroidDevice_generate_filename_with_ext(self,
+                                                    get_log_file_timestamp_mock,
+                                                    MockFastboot, MockAdbProxy):
     mock_serial = 1
     ad = android_device.AndroidDevice(serial=mock_serial)
     get_log_file_timestamp_mock.return_value = '07-22-2019_17-53-34-450'
     filename = ad.generate_filename('MagicLog', extension_name='log')
     self.assertEqual(filename,
-             'MagicLog,1,fakemodel,07-22-2019_17-53-34-450.log')
+                     'MagicLog,1,fakemodel,07-22-2019_17-53-34-450.log')
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   @mock.patch('mobly.logger.get_log_file_timestamp')
   def test_AndroidDevice_generate_filename_with_debug_tag(
       self, get_log_file_timestamp_mock, MockFastboot, MockAdbProxy):
@@ -578,12 +574,12 @@ class AndroidDeviceTest(unittest.TestCase):
     ad.debug_tag = 'RoleX'
     filename = ad.generate_filename('MagicLog')
     self.assertEqual(filename,
-             'MagicLog,RoleX,1,fakemodel,07-22-2019_17-53-34-450')
+                     'MagicLog,RoleX,1,fakemodel,07-22-2019_17-53-34-450')
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   @mock.patch('mobly.logger.get_log_file_timestamp')
   def test_AndroidDevice_generate_filename_with_runtime_info(
       self, get_log_file_timestamp_mock, MockFastboot, MockAdbProxy):
@@ -591,16 +587,15 @@ class AndroidDeviceTest(unittest.TestCase):
     ad = android_device.AndroidDevice(serial=mock_serial)
     get_log_file_timestamp_mock.return_value = '07-22-2019_17-53-34-450'
     mock_record = mock.MagicMock(begin_time='1234567')
-    mock_test_info = runtime_test_info.RuntimeTestInfo(
-      'test_xyz', '/tmp/blah/', mock_record)
-    filename = ad.generate_filename('MagicLog',
-                    time_identifier=mock_test_info)
+    mock_test_info = runtime_test_info.RuntimeTestInfo('test_xyz', '/tmp/blah/',
+                                                       mock_record)
+    filename = ad.generate_filename('MagicLog', time_identifier=mock_test_info)
     self.assertEqual(filename, 'MagicLog,1,fakemodel,test_xyz-1234567')
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   @mock.patch('mobly.logger.get_log_file_timestamp')
   def test_AndroidDevice_generate_filename_with_custom_timestamp(
       self, get_log_file_timestamp_mock, MockFastboot, MockAdbProxy):
@@ -608,40 +603,38 @@ class AndroidDeviceTest(unittest.TestCase):
     ad = android_device.AndroidDevice(serial=mock_serial)
     get_log_file_timestamp_mock.return_value = '07-22-2019_17-53-34-450'
     filename = ad.generate_filename('MagicLog',
-                    time_identifier='my_special_time')
+                                    time_identifier='my_special_time')
     self.assertEqual(filename, 'MagicLog,1,fakemodel,my_special_time')
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy(1))
+              return_value=mock_android_device.MockAdbProxy(1))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy(1))
+              return_value=mock_android_device.MockFastbootProxy(1))
   @mock.patch('mobly.utils.create_dir')
-  def test_AndroidDevice_take_bug_report(self, create_dir_mock,
-                       FastbootProxy, MockAdbProxy):
+  def test_AndroidDevice_take_bug_report(self, create_dir_mock, FastbootProxy,
+                                         MockAdbProxy):
     """Verifies AndroidDevice.take_bug_report calls the correct adb command
     and writes the bugreport file to the correct path.
     """
     mock_serial = '1'
     ad = android_device.AndroidDevice(serial=mock_serial)
     output_path = ad.take_bug_report(test_name='test_something',
-                     begin_time='sometime')
+                                     begin_time='sometime')
     expected_path = os.path.join(logging.log_path,
-                   'AndroidDevice%s' % ad.serial,
-                   'BugReports')
+                                 'AndroidDevice%s' % ad.serial, 'BugReports')
     create_dir_mock.assert_called_with(expected_path)
     self.assertEqual(
-      output_path,
-      os.path.join(expected_path,
-             'bugreport,test_something,1,fakemodel,sometime.zip'))
+        output_path,
+        os.path.join(expected_path,
+                     'bugreport,test_something,1,fakemodel,sometime.zip'))
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1',
-                                fail_br=True))
+              return_value=mock_android_device.MockAdbProxy('1', fail_br=True))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   @mock.patch('mobly.utils.create_dir')
   def test_AndroidDevice_take_bug_report_fail(self, create_dir_mock,
-                        FastbootProxy, MockAdbProxy):
+                                              FastbootProxy, MockAdbProxy):
     """Verifies AndroidDevice.take_bug_report writes out the correct message
     when taking bugreport fails.
     """
@@ -649,13 +642,12 @@ class AndroidDeviceTest(unittest.TestCase):
     ad = android_device.AndroidDevice(serial=mock_serial)
     expected_msg = '.* Failed to take bugreport.'
     with self.assertRaisesRegex(android_device.Error, expected_msg):
-      ad.take_bug_report(test_name='test_something',
-                 begin_time='sometime')
+      ad.take_bug_report(test_name='test_something', begin_time='sometime')
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   @mock.patch('mobly.utils.create_dir')
   @mock.patch('mobly.logger.get_log_file_timestamp')
   def test_AndroidDevice_take_bug_report_without_args(
@@ -666,17 +658,16 @@ class AndroidDeviceTest(unittest.TestCase):
     ad = android_device.AndroidDevice(serial=mock_serial)
     output_path = ad.take_bug_report()
     expected_path = os.path.join(logging.log_path,
-                   'AndroidDevice%s' % ad.serial,
-                   'BugReports')
+                                 'AndroidDevice%s' % ad.serial, 'BugReports')
     self.assertEqual(
-      output_path,
-      os.path.join(expected_path,
-             'bugreport,1,fakemodel,07-22-2019_17-53-34-450.zip'))
+        output_path,
+        os.path.join(expected_path,
+                     'bugreport,1,fakemodel,07-22-2019_17-53-34-450.zip'))
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   @mock.patch('mobly.utils.create_dir')
   @mock.patch('mobly.logger.get_log_file_timestamp')
   def test_AndroidDevice_take_bug_report_with_only_test_name(
@@ -687,20 +678,18 @@ class AndroidDeviceTest(unittest.TestCase):
     ad = android_device.AndroidDevice(serial=mock_serial)
     output_path = ad.take_bug_report(test_name='test_something')
     expected_path = os.path.join(logging.log_path,
-                   'AndroidDevice%s' % ad.serial,
-                   'BugReports')
+                                 'AndroidDevice%s' % ad.serial, 'BugReports')
     create_dir_mock.assert_called_with(expected_path)
     self.assertEqual(
-      output_path,
-      os.path.join(
-        expected_path,
-        'bugreport,test_something,1,fakemodel,07-22-2019_17-53-34-450.zip'
-      ))
+        output_path,
+        os.path.join(
+            expected_path,
+            'bugreport,test_something,1,fakemodel,07-22-2019_17-53-34-450.zip'))
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy(1))
+              return_value=mock_android_device.MockAdbProxy(1))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy(1))
+              return_value=mock_android_device.MockFastbootProxy(1))
   @mock.patch('mobly.utils.create_dir')
   def test_AndroidDevice_take_bug_report_with_only_begin_time(
       self, create_dir_mock, FastbootProxy, MockAdbProxy):
@@ -708,17 +697,16 @@ class AndroidDeviceTest(unittest.TestCase):
     ad = android_device.AndroidDevice(serial=mock_serial)
     output_path = ad.take_bug_report(begin_time='sometime')
     expected_path = os.path.join(logging.log_path,
-                   'AndroidDevice%s' % ad.serial,
-                   'BugReports')
+                                 'AndroidDevice%s' % ad.serial, 'BugReports')
     create_dir_mock.assert_called_with(expected_path)
     self.assertEqual(
-      output_path,
-      os.path.join(expected_path, 'bugreport,1,fakemodel,sometime.zip'))
+        output_path,
+        os.path.join(expected_path, 'bugreport,1,fakemodel,sometime.zip'))
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy(1))
+              return_value=mock_android_device.MockAdbProxy(1))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy(1))
+              return_value=mock_android_device.MockFastbootProxy(1))
   @mock.patch('mobly.utils.create_dir')
   def test_AndroidDevice_take_bug_report_with_int_begin_time(
       self, create_dir_mock, FastbootProxy, MockAdbProxy):
@@ -726,17 +714,16 @@ class AndroidDeviceTest(unittest.TestCase):
     ad = android_device.AndroidDevice(serial=mock_serial)
     output_path = ad.take_bug_report(begin_time=123)
     expected_path = os.path.join(logging.log_path,
-                   'AndroidDevice%s' % ad.serial,
-                   'BugReports')
+                                 'AndroidDevice%s' % ad.serial, 'BugReports')
     create_dir_mock.assert_called_with(expected_path)
     self.assertEqual(
-      output_path,
-      os.path.join(expected_path, 'bugreport,1,fakemodel,123.zip'))
+        output_path, os.path.join(expected_path,
+                                  'bugreport,1,fakemodel,123.zip'))
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy(1))
+              return_value=mock_android_device.MockAdbProxy(1))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy(1))
+              return_value=mock_android_device.MockFastbootProxy(1))
   @mock.patch('mobly.utils.create_dir')
   def test_AndroidDevice_take_bug_report_with_positional_args(
       self, create_dir_mock, FastbootProxy, MockAdbProxy):
@@ -744,18 +731,17 @@ class AndroidDeviceTest(unittest.TestCase):
     ad = android_device.AndroidDevice(serial=mock_serial)
     output_path = ad.take_bug_report('test_something', 'sometime')
     expected_path = os.path.join(logging.log_path,
-                   'AndroidDevice%s' % ad.serial,
-                   'BugReports')
+                                 'AndroidDevice%s' % ad.serial, 'BugReports')
     create_dir_mock.assert_called_with(expected_path)
     self.assertEqual(
-      output_path,
-      os.path.join(expected_path,
-             'bugreport,test_something,1,fakemodel,sometime.zip'))
+        output_path,
+        os.path.join(expected_path,
+                     'bugreport,test_something,1,fakemodel,sometime.zip'))
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   @mock.patch('mobly.utils.create_dir')
   def test_AndroidDevice_take_bug_report_with_destination(
       self, create_dir_mock, FastbootProxy, MockAdbProxy):
@@ -763,68 +749,64 @@ class AndroidDeviceTest(unittest.TestCase):
     ad = android_device.AndroidDevice(serial=mock_serial)
     dest = tempfile.gettempdir()
     output_path = ad.take_bug_report(test_name="test_something",
-                     begin_time="sometime",
-                     destination=dest)
+                                     begin_time="sometime",
+                                     destination=dest)
     expected_path = os.path.join(dest)
     create_dir_mock.assert_called_with(expected_path)
     self.assertEqual(
-      output_path,
-      os.path.join(expected_path,
-             'bugreport,test_something,1,fakemodel,sometime.zip'))
+        output_path,
+        os.path.join(expected_path,
+                     'bugreport,test_something,1,fakemodel,sometime.zip'))
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy(
-          '1', fail_br_before_N=True))
+              return_value=mock_android_device.MockAdbProxy(
+                  '1', fail_br_before_N=True))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   @mock.patch('mobly.utils.create_dir')
   def test_AndroidDevice_take_bug_report_fallback(self, create_dir_mock,
-                          FastbootProxy,
-                          MockAdbProxy):
+                                                  FastbootProxy, MockAdbProxy):
     """Verifies AndroidDevice.take_bug_report falls back to traditional
     bugreport on builds that do not have bugreportz.
     """
     mock_serial = '1'
     ad = android_device.AndroidDevice(serial=mock_serial)
     output_path = ad.take_bug_report(test_name='test_something',
-                     begin_time='sometime')
+                                     begin_time='sometime')
     expected_path = os.path.join(logging.log_path,
-                   'AndroidDevice%s' % ad.serial,
-                   'BugReports')
+                                 'AndroidDevice%s' % ad.serial, 'BugReports')
     create_dir_mock.assert_called_with(expected_path)
     self.assertEqual(
-      output_path,
-      os.path.join(expected_path,
-             'bugreport,test_something,1,fakemodel,sometime.txt'))
+        output_path,
+        os.path.join(expected_path,
+                     'bugreport,test_something,1,fakemodel,sometime.txt'))
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   @mock.patch('mobly.utils.create_dir')
   @mock.patch('mobly.logger.get_log_file_timestamp')
   def test_AndroidDevice_take_screenshot(self, get_log_file_timestamp_mock,
-                       create_dir_mock, FastbootProxy,
-                       MockAdbProxy):
+                                         create_dir_mock, FastbootProxy,
+                                         MockAdbProxy):
     get_log_file_timestamp_mock.return_value = '07-22-2019_17-53-34-450'
     mock_serial = '1'
     ad = android_device.AndroidDevice(serial=mock_serial)
     full_pic_path = ad.take_screenshot(self.tmp_dir)
     self.assertEqual(
-      full_pic_path,
-      os.path.join(self.tmp_dir,
-             'screenshot,1,fakemodel,07-22-2019_17-53-34-450.png'))
+        full_pic_path,
+        os.path.join(self.tmp_dir,
+                     'screenshot,1,fakemodel,07-22-2019_17-53-34-450.png'))
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
-  @mock.patch('mobly.utils.start_standing_subprocess',
-        return_value='process')
+              return_value=mock_android_device.MockFastbootProxy('1'))
+  @mock.patch('mobly.utils.start_standing_subprocess', return_value='process')
   @mock.patch('mobly.utils.stop_standing_subprocess')
-  def test_AndroidDevice_change_log_path(self, stop_proc_mock,
-                       start_proc_mock, FastbootProxy,
-                       MockAdbProxy):
+  def test_AndroidDevice_change_log_path(self, stop_proc_mock, start_proc_mock,
+                                         FastbootProxy, MockAdbProxy):
     ad = android_device.AndroidDevice(serial='1')
     old_path = ad.log_path
     new_log_path = tempfile.mkdtemp()
@@ -833,15 +815,15 @@ class AndroidDeviceTest(unittest.TestCase):
     self.assertFalse(os.path.exists(old_path))
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
-  @mock.patch('mobly.utils.start_standing_subprocess',
-        return_value='process')
+              return_value=mock_android_device.MockFastbootProxy('1'))
+  @mock.patch('mobly.utils.start_standing_subprocess', return_value='process')
   @mock.patch('mobly.utils.stop_standing_subprocess')
-  def test_AndroidDevice_change_log_path_no_log_exists(
-      self, stop_proc_mock, start_proc_mock, FastbootProxy,
-      MockAdbProxy):
+  def test_AndroidDevice_change_log_path_no_log_exists(self, stop_proc_mock,
+                                                       start_proc_mock,
+                                                       FastbootProxy,
+                                                       MockAdbProxy):
     ad = android_device.AndroidDevice(serial='1')
     old_path = ad.log_path
     new_log_path = tempfile.mkdtemp()
@@ -850,33 +832,29 @@ class AndroidDeviceTest(unittest.TestCase):
     self.assertFalse(os.path.exists(old_path))
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('127.0.0.1:5557')
-        )
+              return_value=mock_android_device.MockAdbProxy('127.0.0.1:5557'))
   @mock.patch(
-    'mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-    return_value=mock_android_device.MockFastbootProxy('127.0.0.1:5557'))
-  @mock.patch('mobly.utils.start_standing_subprocess',
-        return_value='process')
+      'mobly.controllers.android_device_lib.fastboot.FastbootProxy',
+      return_value=mock_android_device.MockFastbootProxy('127.0.0.1:5557'))
+  @mock.patch('mobly.utils.start_standing_subprocess', return_value='process')
   @mock.patch('mobly.utils.stop_standing_subprocess')
   def test_AndroidDevice_with_reserved_character_in_serial_log_path(
-      self, stop_proc_mock, start_proc_mock, FastbootProxy,
-      MockAdbProxy):
+      self, stop_proc_mock, start_proc_mock, FastbootProxy, MockAdbProxy):
     ad = android_device.AndroidDevice(serial='127.0.0.1:5557')
     base_log_path = os.path.basename(ad.log_path)
     self.assertEqual(base_log_path, 'AndroidDevice127.0.0.1-5557')
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   @mock.patch('mobly.utils.create_dir')
-  @mock.patch('mobly.utils.start_standing_subprocess',
-        return_value='process')
+  @mock.patch('mobly.utils.start_standing_subprocess', return_value='process')
   @mock.patch('mobly.utils.stop_standing_subprocess')
   @mock.patch.object(logcat.Logcat, '_open_logcat_file')
   def test_AndroidDevice_change_log_path_with_service(
-      self, open_logcat_mock, stop_proc_mock, start_proc_mock,
-      creat_dir_mock, FastbootProxy, MockAdbProxy):
+      self, open_logcat_mock, stop_proc_mock, start_proc_mock, creat_dir_mock,
+      FastbootProxy, MockAdbProxy):
     ad = android_device.AndroidDevice(serial='1')
     ad.services.logcat.start()
     new_log_path = tempfile.mkdtemp()
@@ -885,16 +863,15 @@ class AndroidDeviceTest(unittest.TestCase):
       ad.log_path = new_log_path
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   @mock.patch('mobly.utils.create_dir')
-  @mock.patch('mobly.utils.start_standing_subprocess',
-        return_value='process')
+  @mock.patch('mobly.utils.start_standing_subprocess', return_value='process')
   @mock.patch('mobly.utils.stop_standing_subprocess')
   def test_AndroidDevice_change_log_path_with_existing_file(
-      self, stop_proc_mock, start_proc_mock, creat_dir_mock,
-      FastbootProxy, MockAdbProxy):
+      self, stop_proc_mock, start_proc_mock, creat_dir_mock, FastbootProxy,
+      MockAdbProxy):
     ad = android_device.AndroidDevice(serial='1')
     new_log_path = tempfile.mkdtemp()
     new_file_path = os.path.join(new_log_path, 'file.txt')
@@ -905,16 +882,15 @@ class AndroidDeviceTest(unittest.TestCase):
       ad.log_path = new_log_path
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   @mock.patch('mobly.utils.create_dir')
-  @mock.patch('mobly.utils.start_standing_subprocess',
-        return_value='process')
+  @mock.patch('mobly.utils.start_standing_subprocess', return_value='process')
   @mock.patch('mobly.utils.stop_standing_subprocess')
   def test_AndroidDevice_update_serial(self, stop_proc_mock, start_proc_mock,
-                     creat_dir_mock, FastbootProxy,
-                     MockAdbProxy):
+                                       creat_dir_mock, FastbootProxy,
+                                       MockAdbProxy):
     ad = android_device.AndroidDevice(serial='1')
     ad.update_serial('2')
     self.assertEqual(ad.serial, '2')
@@ -923,17 +899,16 @@ class AndroidDeviceTest(unittest.TestCase):
     self.assertEqual(ad.fastboot.serial, ad.serial)
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   @mock.patch('mobly.utils.create_dir')
-  @mock.patch('mobly.utils.start_standing_subprocess',
-        return_value='process')
+  @mock.patch('mobly.utils.start_standing_subprocess', return_value='process')
   @mock.patch('mobly.utils.stop_standing_subprocess')
   @mock.patch.object(logcat.Logcat, '_open_logcat_file')
   def test_AndroidDevice_update_serial_with_service_running(
-      self, open_logcat_mock, stop_proc_mock, start_proc_mock,
-      creat_dir_mock, FastbootProxy, MockAdbProxy):
+      self, open_logcat_mock, stop_proc_mock, start_proc_mock, creat_dir_mock,
+      FastbootProxy, MockAdbProxy):
     ad = android_device.AndroidDevice(serial='1')
     ad.services.logcat.start()
     expected_msg = '.* Cannot change device serial number when there is service running.'
@@ -941,27 +916,27 @@ class AndroidDeviceTest(unittest.TestCase):
       ad.update_serial('2')
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   @mock.patch(
-    'mobly.controllers.android_device_lib.snippet_client.SnippetClient')
+      'mobly.controllers.android_device_lib.snippet_client.SnippetClient')
   @mock.patch('mobly.utils.get_available_host_port')
   def test_AndroidDevice_load_snippet(self, MockGetPort, MockSnippetClient,
-                    MockFastboot, MockAdbProxy):
+                                      MockFastboot, MockAdbProxy):
     ad = android_device.AndroidDevice(serial='1')
     ad.load_snippet('snippet', MOCK_SNIPPET_PACKAGE_NAME)
     self.assertTrue(hasattr(ad, 'snippet'))
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   @mock.patch(
-    'mobly.controllers.android_device_lib.snippet_client.SnippetClient')
+      'mobly.controllers.android_device_lib.snippet_client.SnippetClient')
   @mock.patch('mobly.utils.get_available_host_port')
   def test_AndroidDevice_getattr(self, MockGetPort, MockSnippetClient,
-                   MockFastboot, MockAdbProxy):
+                                 MockFastboot, MockAdbProxy):
     ad = android_device.AndroidDevice(serial='1')
     ad.load_snippet('snippet', MOCK_SNIPPET_PACKAGE_NAME)
     value = {'value': 42}
@@ -969,65 +944,68 @@ class AndroidDeviceTest(unittest.TestCase):
     self.assertEqual(actual_value, value)
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   @mock.patch(
-    'mobly.controllers.android_device_lib.snippet_client.SnippetClient',
-    return_value=MockSnippetClient)
+      'mobly.controllers.android_device_lib.snippet_client.SnippetClient',
+      return_value=MockSnippetClient)
   @mock.patch('mobly.utils.get_available_host_port')
   def test_AndroidDevice_load_snippet_dup_package(self, MockGetPort,
-                          MockSnippetClient,
-                          MockFastboot,
-                          MockAdbProxy):
+                                                  MockSnippetClient,
+                                                  MockFastboot, MockAdbProxy):
     ad = android_device.AndroidDevice(serial='1')
     ad.load_snippet('snippet', MOCK_SNIPPET_PACKAGE_NAME)
     expected_msg = ('Snippet package "%s" has already been loaded under '
-            'name "snippet".') % MOCK_SNIPPET_PACKAGE_NAME
+                    'name "snippet".') % MOCK_SNIPPET_PACKAGE_NAME
     with self.assertRaisesRegex(android_device.Error, expected_msg):
       ad.load_snippet('snippet2', MOCK_SNIPPET_PACKAGE_NAME)
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   @mock.patch(
-    'mobly.controllers.android_device_lib.snippet_client.SnippetClient',
-    return_value=MockSnippetClient)
+      'mobly.controllers.android_device_lib.snippet_client.SnippetClient',
+      return_value=MockSnippetClient)
   @mock.patch('mobly.utils.get_available_host_port')
-  def test_AndroidDevice_load_snippet_dup_snippet_name(
-      self, MockGetPort, MockSnippetClient, MockFastboot, MockAdbProxy):
+  def test_AndroidDevice_load_snippet_dup_snippet_name(self, MockGetPort,
+                                                       MockSnippetClient,
+                                                       MockFastboot,
+                                                       MockAdbProxy):
     ad = android_device.AndroidDevice(serial='1')
     ad.load_snippet('snippet', MOCK_SNIPPET_PACKAGE_NAME)
     expected_msg = ('.* Attribute "snippet" already exists, please use a '
-            'different name.')
+                    'different name.')
     with self.assertRaisesRegex(android_device.Error, expected_msg):
       ad.load_snippet('snippet', MOCK_SNIPPET_PACKAGE_NAME + 'haha')
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   @mock.patch(
-    'mobly.controllers.android_device_lib.snippet_client.SnippetClient')
+      'mobly.controllers.android_device_lib.snippet_client.SnippetClient')
   @mock.patch('mobly.utils.get_available_host_port')
   def test_AndroidDevice_load_snippet_dup_attribute_name(
       self, MockGetPort, MockSnippetClient, MockFastboot, MockAdbProxy):
     ad = android_device.AndroidDevice(serial='1')
     expected_msg = ('Attribute "%s" already exists, please use a different'
-            ' name') % 'adb'
+                    ' name') % 'adb'
     with self.assertRaisesRegex(android_device.Error, expected_msg):
       ad.load_snippet('adb', MOCK_SNIPPET_PACKAGE_NAME)
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   @mock.patch(
-    'mobly.controllers.android_device_lib.snippet_client.SnippetClient')
+      'mobly.controllers.android_device_lib.snippet_client.SnippetClient')
   @mock.patch('mobly.utils.get_available_host_port')
-  def test_AndroidDevice_load_snippet_start_app_fails(
-      self, MockGetPort, MockSnippetClient, MockFastboot, MockAdbProxy):
+  def test_AndroidDevice_load_snippet_start_app_fails(self, MockGetPort,
+                                                      MockSnippetClient,
+                                                      MockFastboot,
+                                                      MockAdbProxy):
     """Verifies that the correct exception is raised if start app failed.
 
     It's possible that the `stop_app` call as part of the start app failure
@@ -1035,10 +1013,9 @@ class AndroidDeviceTest(unittest.TestCase):
     failure.
     """
     expected_e = Exception('start failed.')
-    MockSnippetClient.start_app_and_connect = mock.Mock(
-      side_effect=expected_e)
+    MockSnippetClient.start_app_and_connect = mock.Mock(side_effect=expected_e)
     MockSnippetClient.stop_app = mock.Mock(
-      side_effect=Exception('stop failed.'))
+        side_effect=Exception('stop failed.'))
     ad = android_device.AndroidDevice(serial='1')
     try:
       ad.load_snippet('snippet', MOCK_SNIPPET_PACKAGE_NAME)
@@ -1046,14 +1023,14 @@ class AndroidDeviceTest(unittest.TestCase):
       assertIs(e, expected_e)
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   @mock.patch(
-    'mobly.controllers.android_device_lib.snippet_client.SnippetClient')
+      'mobly.controllers.android_device_lib.snippet_client.SnippetClient')
   @mock.patch('mobly.utils.get_available_host_port')
   def test_AndroidDevice_unload_snippet(self, MockGetPort, MockSnippetClient,
-                      MockFastboot, MockAdbProxy):
+                                        MockFastboot, MockAdbProxy):
     ad = android_device.AndroidDevice(serial='1')
     ad.load_snippet('snippet', MOCK_SNIPPET_PACKAGE_NAME)
     ad.unload_snippet('snippet')
@@ -1067,16 +1044,16 @@ class AndroidDeviceTest(unittest.TestCase):
     self.assertTrue(hasattr(ad, 'snippet'))
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   @mock.patch(
-    'mobly.controllers.android_device_lib.snippet_client.SnippetClient')
+      'mobly.controllers.android_device_lib.snippet_client.SnippetClient')
   @mock.patch('mobly.utils.get_available_host_port')
   @mock.patch.object(logcat.Logcat, '_open_logcat_file')
   def test_AndroidDevice_snippet_cleanup(self, open_logcat_mock, MockGetPort,
-                       MockSnippetClient, MockFastboot,
-                       MockAdbProxy):
+                                         MockSnippetClient, MockFastboot,
+                                         MockAdbProxy):
     ad = android_device.AndroidDevice(serial='1')
     ad.services.start_all()
     ad.load_snippet('snippet', MOCK_SNIPPET_PACKAGE_NAME)
@@ -1084,9 +1061,9 @@ class AndroidDeviceTest(unittest.TestCase):
     self.assertFalse(hasattr(ad, 'snippet'))
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   def test_AndroidDevice_debug_tag(self, MockFastboot, MockAdbProxy):
     mock_serial = '1'
     ad = android_device.AndroidDevice(serial=mock_serial)
@@ -1108,18 +1085,18 @@ class AndroidDeviceTest(unittest.TestCase):
       self.assertEqual("(<AndroidDevice|Mememe>, 'Something')", str(e))
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
-  @mock.patch('mobly.utils.start_standing_subprocess',
-        return_value='process')
+              return_value=mock_android_device.MockFastbootProxy('1'))
+  @mock.patch('mobly.utils.start_standing_subprocess', return_value='process')
   @mock.patch('mobly.utils.stop_standing_subprocess')
   @mock.patch.object(logcat.Logcat, '_open_logcat_file')
   def test_AndroidDevice_handle_usb_disconnect(self, open_logcat_mock,
-                         stop_proc_mock,
-                         start_proc_mock,
-                         FastbootProxy, MockAdbProxy):
+                                               stop_proc_mock, start_proc_mock,
+                                               FastbootProxy, MockAdbProxy):
+
     class MockService(base_service.BaseService):
+
       def __init__(self, device, configs=None):
         self._alive = False
         self.pause_called = False
@@ -1154,17 +1131,18 @@ class AndroidDeviceTest(unittest.TestCase):
     self.assertTrue(ad.services.mock_service.resume_called)
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
-  @mock.patch('mobly.utils.start_standing_subprocess',
-        return_value='process')
+              return_value=mock_android_device.MockFastbootProxy('1'))
+  @mock.patch('mobly.utils.start_standing_subprocess', return_value='process')
   @mock.patch('mobly.utils.stop_standing_subprocess')
   @mock.patch.object(logcat.Logcat, '_open_logcat_file')
-  def test_AndroidDevice_handle_reboot(self, open_logcat_mock,
-                     stop_proc_mock, start_proc_mock,
-                     FastbootProxy, MockAdbProxy):
+  def test_AndroidDevice_handle_reboot(self, open_logcat_mock, stop_proc_mock,
+                                       start_proc_mock, FastbootProxy,
+                                       MockAdbProxy):
+
     class MockService(base_service.BaseService):
+
       def __init__(self, device, configs=None):
         self._alive = False
         self.pause_called = False
@@ -1199,16 +1177,15 @@ class AndroidDeviceTest(unittest.TestCase):
     self.assertFalse(ad.services.mock_service.resume_called)
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
-  @mock.patch('mobly.utils.start_standing_subprocess',
-        return_value='process')
+              return_value=mock_android_device.MockFastbootProxy('1'))
+  @mock.patch('mobly.utils.start_standing_subprocess', return_value='process')
   @mock.patch('mobly.utils.stop_standing_subprocess')
   @mock.patch.object(logcat.Logcat, '_open_logcat_file')
   def test_AndroidDevice_handle_reboot_changes_build_info(
-      self, open_logcat_mock, stop_proc_mock, start_proc_mock,
-      FastbootProxy, MockAdbProxy):
+      self, open_logcat_mock, stop_proc_mock, start_proc_mock, FastbootProxy,
+      MockAdbProxy):
     ad = android_device.AndroidDevice(serial='1')
     with ad.handle_reboot():
       ad.adb.mock_properties['ro.build.type'] = 'user'
@@ -1219,16 +1196,15 @@ class AndroidDeviceTest(unittest.TestCase):
     self.assertEqual(ad.adb.getprops_call_count, 2)
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
-  @mock.patch('mobly.utils.start_standing_subprocess',
-        return_value='process')
+              return_value=mock_android_device.MockFastbootProxy('1'))
+  @mock.patch('mobly.utils.start_standing_subprocess', return_value='process')
   @mock.patch('mobly.utils.stop_standing_subprocess')
   @mock.patch.object(logcat.Logcat, '_open_logcat_file')
   def test_AndroidDevice_handle_reboot_changes_build_info_with_caching(
-      self, open_logcat_mock, stop_proc_mock, start_proc_mock,
-      FastbootProxy, MockAdbProxy):
+      self, open_logcat_mock, stop_proc_mock, start_proc_mock, FastbootProxy,
+      MockAdbProxy):
     ad = android_device.AndroidDevice(serial='1')  # Call getprops 1.
     rootable_states = [ad.is_rootable]
     with ad.handle_reboot():
@@ -1242,22 +1218,24 @@ class AndroidDeviceTest(unittest.TestCase):
     self.assertEqual(rootable_states, [True, True, False, False, False])
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   @mock.patch(
-    'mobly.controllers.android_device.AndroidDevice.is_boot_completed',
-    side_effect=[
-      False, False,
-      adb.AdbTimeoutError(['adb', 'shell', 'getprop sys.boot_completed'],
-                timeout=5,
-                serial=1), True
-    ])
+      'mobly.controllers.android_device.AndroidDevice.is_boot_completed',
+      side_effect=[
+          False, False,
+          adb.AdbTimeoutError(['adb', 'shell', 'getprop sys.boot_completed'],
+                              timeout=5,
+                              serial=1), True
+      ])
   @mock.patch('time.sleep', return_value=None)
   @mock.patch('time.time', side_effect=[0, 5, 10, 15, 20, 25, 30])
-  def test_AndroidDevice_wait_for_completion_completed(
-      self, MockTime, MockSleep, MockIsBootCompleted, FastbootProxy,
-      MockAdbProxy):
+  def test_AndroidDevice_wait_for_completion_completed(self, MockTime,
+                                                       MockSleep,
+                                                       MockIsBootCompleted,
+                                                       FastbootProxy,
+                                                       MockAdbProxy):
     ad = android_device.AndroidDevice(serial='1')
     raised = False
     try:
@@ -1265,27 +1243,28 @@ class AndroidDeviceTest(unittest.TestCase):
     except (adb.AdbError, adb.AdbTimeoutError):
       raised = True
     self.assertFalse(
-      raised,
-      'adb.AdbError or adb.AdbTimeoutError exception raised but not handled.'
-    )
+        raised,
+        'adb.AdbError or adb.AdbTimeoutError exception raised but not handled.')
 
   @mock.patch('mobly.controllers.android_device_lib.adb.AdbProxy',
-        return_value=mock_android_device.MockAdbProxy('1'))
+              return_value=mock_android_device.MockAdbProxy('1'))
   @mock.patch('mobly.controllers.android_device_lib.fastboot.FastbootProxy',
-        return_value=mock_android_device.MockFastbootProxy('1'))
+              return_value=mock_android_device.MockFastbootProxy('1'))
   @mock.patch(
-    'mobly.controllers.android_device.AndroidDevice.is_boot_completed',
-    side_effect=[
-      False, False,
-      adb.AdbTimeoutError(['adb', 'shell', 'getprop sys.boot_completed'],
-                timeout=5,
-                serial=1), False, False, False, False
-    ])
+      'mobly.controllers.android_device.AndroidDevice.is_boot_completed',
+      side_effect=[
+          False, False,
+          adb.AdbTimeoutError(['adb', 'shell', 'getprop sys.boot_completed'],
+                              timeout=5,
+                              serial=1), False, False, False, False
+      ])
   @mock.patch('time.sleep', return_value=None)
   @mock.patch('time.time', side_effect=[0, 5, 10, 15, 20, 25, 30])
-  def test_AndroidDevice_wait_for_completion_never_boot(
-      self, MockTime, MockSleep, MockIsBootCompleted, FastbootProxy,
-      MockAdbProxy):
+  def test_AndroidDevice_wait_for_completion_never_boot(self, MockTime,
+                                                        MockSleep,
+                                                        MockIsBootCompleted,
+                                                        FastbootProxy,
+                                                        MockAdbProxy):
     ad = android_device.AndroidDevice(serial='1')
     raised = False
     try:
@@ -1294,9 +1273,8 @@ class AndroidDeviceTest(unittest.TestCase):
     except (adb.AdbError, adb.AdbTimeoutError):
       raised = True
     self.assertFalse(
-      raised,
-      'adb.AdbError or adb.AdbTimeoutError exception raised but not handled.'
-    )
+        raised,
+        'adb.AdbError or adb.AdbTimeoutError exception raised but not handled.')
 
   def test_AndroidDevice_parse_device_list_when_decode_error(self):
     gbk_str = b'\xc4\xe3\xba\xc3'
@@ -1305,10 +1283,7 @@ class AndroidDeviceTest(unittest.TestCase):
       android_device.parse_device_list(gbk_str, 'some_key')
     except UnicodeDecodeError:
       raised = True
-    self.assertTrue(
-      raised,
-      'did not raise an exception when parsing gbk bytes'
-    )
+    self.assertTrue(raised, 'did not raise an exception when parsing gbk bytes')
 
 
 if __name__ == '__main__':