Run pyformat on all the toolchain-utils files.

This gets rid of a lot of lint issues.
Ran by doing this:

for f in *.py; do echo -n "$f " ; if [ -x $f ]; then pyformat -i
--remove_trailing_comma --yapf --force_quote_type=double $f ; else
pyformat -i --remove_shebang --remove_trailing_comma --yapf
--force_quote_type=double $f ; fi ; done

BUG=chromium:567921
TEST=Ran simple crosperf run.

Change-Id: I59778835fdaa5f706d2e1765924389f9e97433d1
Reviewed-on: https://chrome-internal-review.googlesource.com/242031
Reviewed-by: Luis Lozano <llozano@chromium.org>
Commit-Queue: Luis Lozano <llozano@chromium.org>
Tested-by: Luis Lozano <llozano@chromium.org>
Reviewed-by: Yunlian Jiang <yunlian@google.com>

1 files changed, 178 insertions, 166 deletions

diff --git a/crosperf/machine_manager_unittest.py b/crosperf/machine_manager_unittest.py
index 7aed09d4..abbbaff7 100755
--- a/crosperf/machine_manager_unittest.py
+++ b/crosperf/machine_manager_unittest.py
@@ -1,7 +1,6 @@
 #!/usr/bin/python
 
 # Copyright 2012 Google Inc. All Rights Reserved.
-
 """Unittest for machine_manager."""
 import os.path
 import time
@@ -22,35 +21,37 @@ from benchmark_run import MockBenchmarkRun
 from cros_utils import command_executer
 from cros_utils import logger
 
+
 class MyMachineManager(machine_manager.MachineManager):
 
   def __init__(self, chromeos_root):
-    super(MyMachineManager, self).__init__(chromeos_root, 0, "average",
+    super(MyMachineManager, self).__init__(chromeos_root, 0, 'average',
                                            file_lock_machine.Machine.LOCKS_DIR)
 
   def _TryToLockMachine(self, cros_machine):
     self._machines.append(cros_machine)
-    cros_machine.checksum = ""
+    cros_machine.checksum = ''
 
   def AddMachine(self, machine_name):
     with self._lock:
       for m in self._all_machines:
-        assert m.name != machine_name, "Tried to double-add %s" % machine_name
+        assert m.name != machine_name, 'Tried to double-add %s' % machine_name
       cm = machine_manager.MockCrosMachine(machine_name, self.chromeos_root,
-                                           "average")
-      assert cm.machine_checksum, ("Could not find checksum for machine %s" %
+                                           'average')
+      assert cm.machine_checksum, ('Could not find checksum for machine %s' %
                                    machine_name)
       self._all_machines.append(cm)
 
-CHROMEOS_ROOT = "/tmp/chromeos-root"
-MACHINE_NAMES = ["lumpy1", "lumpy2", "lumpy3", "daisy1", "daisy2"]
-LABEL_LUMPY = label.MockLabel("lumpy", "lumpy_chromeos_image", CHROMEOS_ROOT,
-                              "lumpy",
-                              ["lumpy1", "lumpy2", "lumpy3", "lumpy4"],
-                              "", "", False, "average," "gcc", None)
-LABEL_MIX = label.MockLabel("mix", "chromeos_image", CHROMEOS_ROOT, "mix",
-                            ["daisy1", "daisy2", "lumpy3", "lumpy4"],
-                            "", "", False, "average", "gcc", None)
+
+CHROMEOS_ROOT = '/tmp/chromeos-root'
+MACHINE_NAMES = ['lumpy1', 'lumpy2', 'lumpy3', 'daisy1', 'daisy2']
+LABEL_LUMPY = label.MockLabel('lumpy', 'lumpy_chromeos_image', CHROMEOS_ROOT,
+                              'lumpy', ['lumpy1', 'lumpy2', 'lumpy3', 'lumpy4'],
+                              '', '', False, 'average,'
+                              'gcc', None)
+LABEL_MIX = label.MockLabel('mix', 'chromeos_image', CHROMEOS_ROOT, 'mix',
+                            ['daisy1', 'daisy2', 'lumpy3', 'lumpy4'], '', '',
+                            False, 'average', 'gcc', None)
 
 
 class MachineManagerTest(unittest.TestCase):
@@ -66,15 +67,14 @@ class MachineManagerTest(unittest.TestCase):
   mock_daisy1 = mock.Mock(spec=machine_manager.CrosMachine)
   mock_daisy2 = mock.Mock(spec=machine_manager.CrosMachine)
 
-  @mock.patch.object (os.path, 'isdir')
+  @mock.patch.object(os.path, 'isdir')
   def setUp(self, mock_isdir):
 
     mock_isdir.return_value = True
-    self.mm = machine_manager.MachineManager("/usr/local/chromeos", 0,
-                                             "average",
-                                             file_lock_machine.Machine.LOCKS_DIR,
-                                             self.mock_cmd_exec,
-                                             self.mock_logger)
+    self.mm = machine_manager.MachineManager(
+        '/usr/local/chromeos', 0, 'average',
+        file_lock_machine.Machine.LOCKS_DIR, self.mock_cmd_exec,
+        self.mock_logger)
 
     self.mock_lumpy1.name = 'lumpy1'
     self.mock_lumpy2.name = 'lumpy2'
@@ -94,25 +94,24 @@ class MachineManagerTest(unittest.TestCase):
     self.mock_lumpy4.checksum_string = 'lumpy_checksum_str'
     self.mock_daisy1.checksum_string = 'daisy_checksum_str'
     self.mock_daisy2.checksum_string = 'daisy_checksum_str'
-    self.mock_lumpy1.cpuinfo = "lumpy_cpu_info"
-    self.mock_lumpy2.cpuinfo = "lumpy_cpu_info"
-    self.mock_lumpy3.cpuinfo = "lumpy_cpu_info"
-    self.mock_lumpy4.cpuinfo = "lumpy_cpu_info"
-    self.mock_daisy1.cpuinfo = "daisy_cpu_info"
-    self.mock_daisy2.cpuinfo = "daisy_cpu_info"
+    self.mock_lumpy1.cpuinfo = 'lumpy_cpu_info'
+    self.mock_lumpy2.cpuinfo = 'lumpy_cpu_info'
+    self.mock_lumpy3.cpuinfo = 'lumpy_cpu_info'
+    self.mock_lumpy4.cpuinfo = 'lumpy_cpu_info'
+    self.mock_daisy1.cpuinfo = 'daisy_cpu_info'
+    self.mock_daisy2.cpuinfo = 'daisy_cpu_info'
     self.mm._all_machines.append(self.mock_daisy1)
     self.mm._all_machines.append(self.mock_daisy2)
     self.mm._all_machines.append(self.mock_lumpy1)
     self.mm._all_machines.append(self.mock_lumpy2)
     self.mm._all_machines.append(self.mock_lumpy3)
 
-
   def testGetMachines(self):
     manager = MyMachineManager(CHROMEOS_ROOT)
     for m in MACHINE_NAMES:
       manager.AddMachine(m)
     names = [m.name for m in manager.GetMachines(LABEL_LUMPY)]
-    self.assertEqual(names, ["lumpy1", "lumpy2", "lumpy3"])
+    self.assertEqual(names, ['lumpy1', 'lumpy2', 'lumpy3'])
 
   def testGetAvailableMachines(self):
     manager = MyMachineManager(CHROMEOS_ROOT)
@@ -122,17 +121,17 @@ class MachineManagerTest(unittest.TestCase):
       if int(m.name[-1]) % 2:
         manager._TryToLockMachine(m)
     names = [m.name for m in manager.GetAvailableMachines(LABEL_LUMPY)]
-    self.assertEqual(names, ["lumpy1", "lumpy3"])
+    self.assertEqual(names, ['lumpy1', 'lumpy3'])
 
   @mock.patch.object(time, 'sleep')
   @mock.patch.object(command_executer.CommandExecuter, 'RunCommand')
   @mock.patch.object(command_executer.CommandExecuter, 'CrosRunCommand')
   @mock.patch.object(image_checksummer.ImageChecksummer, 'Checksum')
-  def test_image_machine(self, mock_checksummer, mock_run_croscmd,
-                         mock_run_cmd, mock_sleep):
+  def test_image_machine(self, mock_checksummer, mock_run_croscmd, mock_run_cmd,
+                         mock_sleep):
 
     def FakeMD5Checksum(input_str):
-      return "machine_fake_md5_checksum"
+      return 'machine_fake_md5_checksum'
 
     self.fake_logger_count = 0
     self.fake_logger_msgs = []
@@ -148,7 +147,7 @@ class MachineManagerTest(unittest.TestCase):
       mock_run_croscmd.reset_mock()
       mock_checksummer.reset_mock()
       mock_sleep.reset_mock()
-      machine.checksum = "fake_md5_checksum"
+      machine.checksum = 'fake_md5_checksum'
       self.mm.checksum = None
       self.mm.num_reimages = 0
 
@@ -158,20 +157,20 @@ class MachineManagerTest(unittest.TestCase):
     self.mm.logger.LogOutput = FakeLogOutput
     machine = self.mock_lumpy1
     machine._GetMD5Checksum = FakeMD5Checksum
-    machine.checksum = "fake_md5_checksum"
-    mock_checksummer.return_value = "fake_md5_checksum"
-    self.mock_cmd_exec.log_level = "verbose"
+    machine.checksum = 'fake_md5_checksum'
+    mock_checksummer.return_value = 'fake_md5_checksum'
+    self.mock_cmd_exec.log_level = 'verbose'
 
     test_flag.SetTestMode(True)
     # Test 1: label.image_type == "local"
-    LABEL_LUMPY.image_type = "local"
+    LABEL_LUMPY.image_type = 'local'
     self.mm.ImageMachine(machine, LABEL_LUMPY)
     self.assertEqual(mock_run_cmd.call_count, 0)
     self.assertEqual(mock_run_croscmd.call_count, 0)
 
     #Test 2: label.image_type == "trybot"
     ResetValues()
-    LABEL_LUMPY.image_type = "trybot"
+    LABEL_LUMPY.image_type = 'trybot'
     mock_run_cmd.return_value = 0
     self.mm.ImageMachine(machine, LABEL_LUMPY)
     self.assertEqual(mock_run_croscmd.call_count, 0)
@@ -180,7 +179,7 @@ class MachineManagerTest(unittest.TestCase):
     # Test 3: label.image_type is neither local nor trybot; retval from
     # RunCommand is 1, i.e. image_chromeos fails...
     ResetValues()
-    LABEL_LUMPY.image_type = "other"
+    LABEL_LUMPY.image_type = 'other'
     mock_run_cmd.return_value = 1
     try:
       self.mm.ImageMachine(machine, LABEL_LUMPY)
@@ -195,10 +194,10 @@ class MachineManagerTest(unittest.TestCase):
       self.assertEqual(image_call_args[1].split('/')[-1], 'image_chromeos.pyc')
       image_call_args = image_call_args[2:]
       self.assertEqual(image_call_args,
-                       [ '--chromeos_root=/tmp/chromeos-root',
-                         '--image=lumpy_chromeos_image',
-                         '--image_args=', '--remote=lumpy1',
-                         '--logging_level=average', '--board=lumpy'])
+                       ['--chromeos_root=/tmp/chromeos-root',
+                        '--image=lumpy_chromeos_image', '--image_args=',
+                        '--remote=lumpy1', '--logging_level=average',
+                        '--board=lumpy'])
       self.assertEqual(mock_run_croscmd.call_args[0][0], 'reboot && exit')
 
     # Test 4: Everything works properly. Trybot image type.
@@ -210,7 +209,6 @@ class MachineManagerTest(unittest.TestCase):
     self.assertEqual(mock_run_croscmd.call_count, 0)
     self.assertEqual(mock_sleep.call_count, 0)
 
-
   def test_compute_common_checksum(self):
 
     self.mm.machine_checksum = {}
@@ -219,8 +217,8 @@ class MachineManagerTest(unittest.TestCase):
     self.assertEqual(len(self.mm.machine_checksum), 1)
 
     self.mm.machine_checksum = {}
-    self.assertRaises(machine_manager.BadChecksum, self.mm.ComputeCommonCheckSum, LABEL_MIX)
-
+    self.assertRaises(machine_manager.BadChecksum,
+                      self.mm.ComputeCommonCheckSum, LABEL_MIX)
 
   def test_compute_common_checksum_string(self):
     self.mm.machine_checksum_string = {}
@@ -235,19 +233,18 @@ class MachineManagerTest(unittest.TestCase):
     self.assertEqual(self.mm.machine_checksum_string['mix'],
                      'daisy_checksum_str')
 
-
   @mock.patch.object(command_executer.CommandExecuter, 'CrosRunCommandWOutput')
   def test_try_to_lock_machine(self, mock_cros_runcmd):
 
     self.assertRaises(self.mm._TryToLockMachine, None)
 
-    mock_cros_runcmd.return_value = [0, "false_lock_checksum", ""]
+    mock_cros_runcmd.return_value = [0, 'false_lock_checksum', '']
     self.mock_cmd_exec.CrosRunCommand = mock_cros_runcmd
     self.mm._machines = []
     self.mm._TryToLockMachine(self.mock_lumpy1)
     self.assertEqual(len(self.mm._machines), 1)
     self.assertEqual(self.mm._machines[0], self.mock_lumpy1)
-    self.assertEqual(self.mock_lumpy1.checksum, "false_lock_checksum")
+    self.assertEqual(self.mock_lumpy1.checksum, 'false_lock_checksum')
     self.assertEqual(mock_cros_runcmd.call_count, 1)
     cmd_str = mock_cros_runcmd.call_args[0][0]
     self.assertEqual(cmd_str, 'cat /usr/local/osimage_checksum_file')
@@ -256,31 +253,28 @@ class MachineManagerTest(unittest.TestCase):
     self.assertEqual(args_dict['machine'], self.mock_lumpy1.name)
     self.assertEqual(args_dict['chromeos_root'], '/usr/local/chromeos')
 
-
   @mock.patch.object(machine_manager, 'CrosMachine')
   def test_add_machine(self, mock_machine):
 
     mock_machine.machine_checksum = 'daisy123'
-    self.assertEqual (len(self.mm._all_machines), 5)
+    self.assertEqual(len(self.mm._all_machines), 5)
     self.mm.AddMachine('daisy3')
-    self.assertEqual (len(self.mm._all_machines), 6)
+    self.assertEqual(len(self.mm._all_machines), 6)
 
     self.assertRaises(Exception, self.mm.AddMachine, 'lumpy1')
 
-
   def test_remove_machine(self):
     self.mm._machines = self.mm._all_machines
     self.assertTrue(self.mock_lumpy2 in self.mm._machines)
     self.mm.RemoveMachine(self.mock_lumpy2.name)
     self.assertFalse(self.mock_lumpy2 in self.mm._machines)
 
-
   def test_force_same_image_to_all_machines(self):
     self.image_log = []
 
     def FakeImageMachine(machine, label_arg):
       image = label_arg.chromeos_image
-      self.image_log.append("Pushed %s onto %s" % (image, machine.name))
+      self.image_log.append('Pushed %s onto %s' % (image, machine.name))
 
     def FakeSetUpChecksumInfo():
       pass
@@ -299,17 +293,15 @@ class MachineManagerTest(unittest.TestCase):
     self.assertEqual(self.image_log[2],
                      'Pushed lumpy_chromeos_image onto lumpy3')
 
-
-
   @mock.patch.object(image_checksummer.ImageChecksummer, 'Checksum')
-  @mock.patch.object(hashlib,'md5')
+  @mock.patch.object(hashlib, 'md5')
   def test_acquire_machine(self, mock_md5, mock_checksum):
 
     self.msgs = []
     self.log_fatal_msgs = []
 
     def FakeLock(machine):
-      self.msgs.append("Tried to lock %s" % machine.name)
+      self.msgs.append('Tried to lock %s' % machine.name)
 
     def FakeLogFatal(msg):
       self.log_fatal_msgs.append(msg)
@@ -317,17 +309,17 @@ class MachineManagerTest(unittest.TestCase):
     self.mm._TryToLockMachine = FakeLock
     self.mm.logger.LogFatal = FakeLogFatal
 
-    mock_md5.return_value = "123456"
-    mock_checksum.return_value = "fake_md5_checksum"
+    mock_md5.return_value = '123456'
+    mock_checksum.return_value = 'fake_md5_checksum'
 
     self.mm._machines = self.mm._all_machines
     self.mock_lumpy1.locked = True
     self.mock_lumpy2.locked = True
     self.mock_lumpy3.locked = False
-    self.mock_lumpy3.checksum = "fake_md5_checksum"
+    self.mock_lumpy3.checksum = 'fake_md5_checksum'
     self.mock_daisy1.locked = True
     self.mock_daisy2.locked = False
-    self.mock_daisy2.checksum = "fake_md5_checksum"
+    self.mock_daisy2.checksum = 'fake_md5_checksum'
 
     self.mock_lumpy1.released_time = time.time()
     self.mock_lumpy2.released_time = time.time()
@@ -341,8 +333,7 @@ class MachineManagerTest(unittest.TestCase):
     self.assertEqual(m, self.mock_lumpy1)
     self.assertTrue(self.mock_lumpy1.locked)
     self.assertEqual(mock_md5.call_count, 0)
-    self.assertEqual(self.msgs, ['Tried to lock lumpy1',
-                                 'Tried to lock lumpy2',
+    self.assertEqual(self.msgs, ['Tried to lock lumpy1', 'Tried to lock lumpy2',
                                  'Tried to lock lumpy3'])
 
     # Test the second return statment (machine is unlocked, has no checksum)
@@ -358,7 +349,7 @@ class MachineManagerTest(unittest.TestCase):
     #   - checksums don't match
     #   - current time minus release time is > 20.
     self.mock_lumpy1.locked = False
-    self.mock_lumpy1.checksum = "123"
+    self.mock_lumpy1.checksum = '123'
     self.mock_lumpy1.released_time = time.time() - 8
     m = self.mm.AcquireMachine(LABEL_LUMPY)
     self.assertEqual(m, self.mock_lumpy1)
@@ -370,8 +361,7 @@ class MachineManagerTest(unittest.TestCase):
 
     # Restore values of mock_lumpy1, so other tests succeed.
     self.mock_lumpy1.locked = save_locked
-    self.mock_lumpy1.checksum = "123"
-
+    self.mock_lumpy1.checksum = '123'
 
   def test_get_available_machines(self):
     self.mm._machines = self.mm._all_machines
@@ -387,7 +377,6 @@ class MachineManagerTest(unittest.TestCase):
     self.assertEqual(machine_list, [self.mock_lumpy1, self.mock_lumpy2,
                                     self.mock_lumpy3])
 
-
   def test_get_machines(self):
     machine_list = self.mm.GetMachines()
     self.assertEqual(machine_list, self.mm._all_machines)
@@ -400,7 +389,6 @@ class MachineManagerTest(unittest.TestCase):
     self.assertEqual(machine_list, [self.mock_lumpy1, self.mock_lumpy2,
                                     self.mock_lumpy3])
 
-
   def test_release_machines(self):
 
     self.mm._machines = [self.mock_lumpy1, self.mock_daisy2]
@@ -411,45 +399,49 @@ class MachineManagerTest(unittest.TestCase):
     self.assertTrue(self.mock_lumpy1.locked)
     self.mm.ReleaseMachine(self.mock_lumpy1)
     self.assertFalse(self.mock_lumpy1.locked)
-    self.assertEqual(self.mock_lumpy1.status, "Available")
+    self.assertEqual(self.mock_lumpy1.status, 'Available')
 
     self.assertTrue(self.mock_daisy2.locked)
     self.mm.ReleaseMachine(self.mock_daisy2)
     self.assertFalse(self.mock_daisy2.locked)
-    self.assertEqual(self.mock_daisy2.status, "Available")
+    self.assertEqual(self.mock_daisy2.status, 'Available')
 
     # Test double-relase...
     self.assertRaises(AssertionError, self.mm.ReleaseMachine, self.mock_lumpy1)
 
-
   def test_cleanup(self):
     self.mock_logger.reset_mock()
     self.mm.Cleanup()
     self.assertEqual(self.mock_logger.call_count, 0)
 
-  OUTPUT_STR = 'Machine Status:\nMachine                        Thread     Lock Status                    Checksum                        \nlumpy1                         test run   True PENDING                   123                             \nlumpy2                         test run   False PENDING                   123                             \nlumpy3                         test run   False PENDING                   123                             \ndaisy1                         test run   False PENDING                   678                             \ndaisy2                         test run   True PENDING                   678                             '
+  OUTPUT_STR = ('Machine Status:\nMachine                        Thread     '
+                'Lock Status                    Checksum'
+                '                        \nlumpy1                         test '
+                'run   True PENDING                   123'
+                '                             \nlumpy2                         '
+                'test run   False PENDING                   123'
+                '                             \nlumpy3                         '
+                'test run   False PENDING                   123'
+                '                             \ndaisy1                         '
+                'test run   False PENDING                   678'
+                '                             \ndaisy2                         '
+                'test run   True PENDING                   678'
+                '                             ')
 
   def test_as_string(self):
 
     mock_logger = mock.Mock(spec=logger.Logger)
 
-    bench = Benchmark("page_cycler.netsim.top_10",    # name
-                      "page_cycler.netsim.top_10",    # test_name
-                      "",             # test_args
+    bench = Benchmark('page_cycler.netsim.top_10',    # name
+                      'page_cycler.netsim.top_10',    # test_name
+                      '',             # test_args
                       1,              # iteratins
                       False,          # rm_chroot_tmp
-                      "",             # perf_args
-                      suite="telemetry_Crosperf")     # suite
-
-    test_run = MockBenchmarkRun("test run",
-                         bench,
-                         LABEL_LUMPY,
-                         1,
-                         [],
-                         self.mm,
-                         mock_logger,
-                         "verbose",
-                         "")
+                      '',             # perf_args
+                      suite='telemetry_Crosperf')     # suite
+
+    test_run = MockBenchmarkRun('test run', bench, LABEL_LUMPY, 1, [], self.mm,
+                                mock_logger, 'verbose', '')
 
     self.mm._machines = [self.mock_lumpy1, self.mock_lumpy2, self.mock_lumpy3,
                          self.mock_daisy1, self.mock_daisy2]
@@ -466,16 +458,15 @@ class MachineManagerTest(unittest.TestCase):
     self.mock_daisy1.locked = False
     self.mock_daisy2.locked = True
 
-    self.mock_lumpy1.checksum = "123"
-    self.mock_lumpy2.checksum = "123"
-    self.mock_lumpy3.checksum = "123"
-    self.mock_daisy1.checksum = "678"
-    self.mock_daisy2.checksum = "678"
+    self.mock_lumpy1.checksum = '123'
+    self.mock_lumpy2.checksum = '123'
+    self.mock_lumpy3.checksum = '123'
+    self.mock_daisy1.checksum = '678'
+    self.mock_daisy2.checksum = '678'
 
     output = self.mm.AsString()
     self.assertEqual(output, self.OUTPUT_STR)
 
-
   def test_get_all_cpu_info(self):
     info = self.mm.GetAllCPUInfo([LABEL_LUMPY, LABEL_MIX])
     self.assertEqual(info,
@@ -483,7 +474,6 @@ class MachineManagerTest(unittest.TestCase):
                      '------------------\ndaisy_cpu_info\n\n\n')
 
 
-
 MEMINFO_STRING = """MemTotal:        3990332 kB
 MemFree:         2608396 kB
 Buffers:          147168 kB
@@ -574,7 +564,35 @@ address sizes: 36 bits physical, 48 bits virtual
 power management:
 """
 
-CHECKSUM_STRING = "processor: 0vendor_id: GenuineIntelcpu family: 6model: 42model name: Intel(R) Celeron(R) CPU 867 @ 1.30GHzstepping: 7microcode: 0x25cache size: 2048 KBphysical id: 0siblings: 2core id: 0cpu cores: 2apicid: 0initial apicid: 0fpu: yesfpu_exception: yescpuid level: 13wp: yesflags: fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe syscall nx rdtscp lm constant_tsc arch_perfmon pebs bts rep_good nopl xtopology nonstop_tsc aperfmperf pni pclmulqdq dtes64 monitor ds_cpl vmx est tm2 ssse3 cx16 xtpr pdcm pcid sse4_1 sse4_2 x2apic popcnt tsc_deadline_timer xsave lahf_lm arat epb xsaveopt pln pts dts tpr_shadow vnmi flexpriority ept vpidclflush size: 64cache_alignment: 64address sizes: 36 bits physical, 48 bits virtualpower management:processor: 1vendor_id: GenuineIntelcpu family: 6model: 42model name: Intel(R) Celeron(R) CPU 867 @ 1.30GHzstepping: 7microcode: 0x25cache size: 2048 KBphysical id: 0siblings: 2core id: 1cpu cores: 2apicid: 2initial apicid: 2fpu: yesfpu_exception: yescpuid level: 13wp: yesflags: fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe syscall nx rdtscp lm constant_tsc arch_perfmon pebs bts rep_good nopl xtopology nonstop_tsc aperfmperf pni pclmulqdq dtes64 monitor ds_cpl vmx est tm2 ssse3 cx16 xtpr pdcm pcid sse4_1 sse4_2 x2apic popcnt tsc_deadline_timer xsave lahf_lm arat epb xsaveopt pln pts dts tpr_shadow vnmi flexpriority ept vpidclflush size: 64cache_alignment: 64address sizes: 36 bits physical, 48 bits virtualpower management: 4194304"
+CHECKSUM_STRING = ('processor: 0vendor_id: GenuineIntelcpu family: 6model: '
+                   '42model name: Intel(R) Celeron(R) CPU 867 @ '
+                   '1.30GHzstepping: 7microcode: 0x25cache size: 2048 '
+                   'KBphysical id: 0siblings: 2core id: 0cpu cores: 2apicid: '
+                   '0initial apicid: 0fpu: yesfpu_exception: yescpuid level: '
+                   '13wp: yesflags: fpu vme de pse tsc msr pae mce cx8 apic sep'
+                   ' mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse '
+                   'sse2 ss ht tm pbe syscall nx rdtscp lm constant_tsc '
+                   'arch_perfmon pebs bts rep_good nopl xtopology nonstop_tsc '
+                   'aperfmperf pni pclmulqdq dtes64 monitor ds_cpl vmx est tm2 '
+                   'ssse3 cx16 xtpr pdcm pcid sse4_1 sse4_2 x2apic popcnt '
+                   'tsc_deadline_timer xsave lahf_lm arat epb xsaveopt pln pts '
+                   'dts tpr_shadow vnmi flexpriority ept vpidclflush size: '
+                   '64cache_alignment: 64address sizes: 36 bits physical, 48 '
+                   'bits virtualpower management:processor: 1vendor_id: '
+                   'GenuineIntelcpu family: 6model: 42model name: Intel(R) '
+                   'Celeron(R) CPU 867 @ 1.30GHzstepping: 7microcode: 0x25cache'
+                   ' size: 2048 KBphysical id: 0siblings: 2core id: 1cpu cores:'
+                   ' 2apicid: 2initial apicid: 2fpu: yesfpu_exception: yescpuid'
+                   ' level: 13wp: yesflags: fpu vme de pse tsc msr pae mce cx8 '
+                   'apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx '
+                   'fxsr sse sse2 ss ht tm pbe syscall nx rdtscp lm '
+                   'constant_tsc arch_perfmon pebs bts rep_good nopl xtopology '
+                   'nonstop_tsc aperfmperf pni pclmulqdq dtes64 monitor ds_cpl '
+                   'vmx est tm2 ssse3 cx16 xtpr pdcm pcid sse4_1 sse4_2 x2apic '
+                   'popcnt tsc_deadline_timer xsave lahf_lm arat epb xsaveopt '
+                   'pln pts dts tpr_shadow vnmi flexpriority ept vpidclflush '
+                   'size: 64cache_alignment: 64address sizes: 36 bits physical,'
+                   ' 48 bits virtualpower management: 4194304')
 
 DUMP_VPD_STRING = """
 "PBA_SN"="Pba.txt"
@@ -592,7 +610,6 @@ DUMP_VPD_STRING = """
 "ActivateDate"="2013-38"
 """
 
-
 IFCONFIG_STRING = """
 eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
         inet 172.17.129.247  netmask 255.255.254.0  broadcast 172.17.129.255
@@ -640,12 +657,11 @@ class CrosMachineTest(unittest.TestCase):
   @mock.patch.object(machine_manager.CrosMachine, 'SetUpChecksumInfo')
   def test_init(self, mock_setup):
 
-    cm = machine_manager.CrosMachine("daisy.cros", "/usr/local/chromeos",
-                                     "average", self.mock_cmd_exec)
+    cm = machine_manager.CrosMachine('daisy.cros', '/usr/local/chromeos',
+                                     'average', self.mock_cmd_exec)
     self.assertEqual(mock_setup.call_count, 1)
-    self.assertEqual(cm.chromeos_root, "/usr/local/chromeos")
-    self.assertEqual(cm.log_level, "average")
-
+    self.assertEqual(cm.chromeos_root, '/usr/local/chromeos')
+    self.assertEqual(cm.log_level, 'average')
 
   @mock.patch.object(machine_manager.CrosMachine, 'IsReachable')
   @mock.patch.object(machine_manager.CrosMachine, '_GetMemoryInfo')
@@ -661,19 +677,19 @@ class CrosMachineTest(unittest.TestCase):
     # Test 1. Machine is not reachable; SetUpChecksumInfo is called via
     # __init__.
     mock_isreachable.return_value = False
-    mock_md5sum.return_value = "md5_checksum"
-    cm = machine_manager.CrosMachine("daisy.cros", "/usr/local/chromeos",
-                                     "average", self.mock_cmd_exec)
-    cm.checksum_string = "This is a checksum string."
-    cm.machine_id = "machine_id1"
+    mock_md5sum.return_value = 'md5_checksum'
+    cm = machine_manager.CrosMachine('daisy.cros', '/usr/local/chromeos',
+                                     'average', self.mock_cmd_exec)
+    cm.checksum_string = 'This is a checksum string.'
+    cm.machine_id = 'machine_id1'
     self.assertEqual(mock_isreachable.call_count, 1)
     self.assertIsNone(cm.machine_checksum)
     self.assertEqual(mock_meminfo.call_count, 0)
 
     # Test 2. Machine is reachable. Call explicitly.
     mock_isreachable.return_value = True
-    cm.checksum_string = "This is a checksum string."
-    cm.machine_id = "machine_id1"
+    cm.checksum_string = 'This is a checksum string.'
+    cm.machine_id = 'machine_id1'
     cm.SetUpChecksumInfo()
     self.assertEqual(mock_isreachable.call_count, 2)
     self.assertEqual(mock_meminfo.call_count, 1)
@@ -681,19 +697,18 @@ class CrosMachineTest(unittest.TestCase):
     self.assertEqual(mock_checkstring.call_count, 1)
     self.assertEqual(mock_machineid.call_count, 1)
     self.assertEqual(mock_md5sum.call_count, 2)
-    self.assertEqual(cm.machine_checksum, "md5_checksum")
-    self.assertEqual(cm.machine_id_checksum, "md5_checksum")
+    self.assertEqual(cm.machine_checksum, 'md5_checksum')
+    self.assertEqual(cm.machine_id_checksum, 'md5_checksum')
     self.assertEqual(mock_md5sum.call_args_list[0][0][0],
-                     "This is a checksum string.")
-    self.assertEqual(mock_md5sum.call_args_list[1][0][0],
-                     "machine_id1")
+                     'This is a checksum string.')
+    self.assertEqual(mock_md5sum.call_args_list[1][0][0], 'machine_id1')
 
   @mock.patch.object(command_executer.CommandExecuter, 'CrosRunCommand')
-  @mock.patch.object(machine_manager.CrosMachine, "SetUpChecksumInfo")
+  @mock.patch.object(machine_manager.CrosMachine, 'SetUpChecksumInfo')
   def test_is_reachable(self, mock_setup, mock_run_cmd):
 
-    cm = machine_manager.CrosMachine("daisy.cros", "/usr/local/chromeos",
-                                     "average", self.mock_cmd_exec)
+    cm = machine_manager.CrosMachine('daisy.cros', '/usr/local/chromeos',
+                                     'average', self.mock_cmd_exec)
     self.mock_cmd_exec.CrosRunCommand = mock_run_cmd
 
     # Test 1. CrosRunCommand returns 1 (fail)
@@ -710,106 +725,103 @@ class CrosMachineTest(unittest.TestCase):
     self.assertEqual(mock_run_cmd.call_count, 2)
     first_args = mock_run_cmd.call_args_list[0]
     second_args = mock_run_cmd.call_args_list[1]
-    self.assertEqual (first_args[0], second_args[0])
-    self.assertEqual (first_args[1], second_args[1])
-    self.assertEqual (len(first_args[0]), 1)
-    self.assertEqual (len(first_args[1]), 2)
-    self.assertEqual (first_args[0][0], 'ls')
+    self.assertEqual(first_args[0], second_args[0])
+    self.assertEqual(first_args[1], second_args[1])
+    self.assertEqual(len(first_args[0]), 1)
+    self.assertEqual(len(first_args[1]), 2)
+    self.assertEqual(first_args[0][0], 'ls')
     args_dict = first_args[1]
-    self.assertEqual (args_dict['machine'], 'daisy.cros')
-    self.assertEqual (args_dict['chromeos_root'], '/usr/local/chromeos')
-
+    self.assertEqual(args_dict['machine'], 'daisy.cros')
+    self.assertEqual(args_dict['chromeos_root'], '/usr/local/chromeos')
 
-  @mock.patch.object(machine_manager.CrosMachine, "SetUpChecksumInfo")
+  @mock.patch.object(machine_manager.CrosMachine, 'SetUpChecksumInfo')
   def test_parse_memory_info(self, mock_setup):
-    cm = machine_manager.CrosMachine("daisy.cros", "/usr/local/chromeos",
-                                     "average", self.mock_cmd_exec)
+    cm = machine_manager.CrosMachine('daisy.cros', '/usr/local/chromeos',
+                                     'average', self.mock_cmd_exec)
     cm.meminfo = MEMINFO_STRING
     cm._ParseMemoryInfo()
     self.assertEqual(cm.phys_kbytes, 4194304)
 
-
   @mock.patch.object(command_executer.CommandExecuter, 'CrosRunCommandWOutput')
-  @mock.patch.object(machine_manager.CrosMachine, "SetUpChecksumInfo")
+  @mock.patch.object(machine_manager.CrosMachine, 'SetUpChecksumInfo')
   def test_get_memory_info(self, mock_setup, mock_run_cmd):
-    cm = machine_manager.CrosMachine("daisy.cros", "/usr/local/chromeos",
-                                     "average", self.mock_cmd_exec)
+    cm = machine_manager.CrosMachine('daisy.cros', '/usr/local/chromeos',
+                                     'average', self.mock_cmd_exec)
     self.mock_cmd_exec.CrosRunCommand = mock_run_cmd
-    mock_run_cmd.return_value = [0, MEMINFO_STRING, ""]
+    mock_run_cmd.return_value = [0, MEMINFO_STRING, '']
     cm._GetMemoryInfo()
     self.assertEqual(mock_run_cmd.call_count, 1)
     call_args = mock_run_cmd.call_args_list[0]
-    self.assertEqual(call_args[0][0], "cat /proc/meminfo")
+    self.assertEqual(call_args[0][0], 'cat /proc/meminfo')
     args_dict = call_args[1]
     self.assertEqual(args_dict['machine'], 'daisy.cros')
     self.assertEqual(args_dict['chromeos_root'], '/usr/local/chromeos')
     self.assertEqual(cm.meminfo, MEMINFO_STRING)
     self.assertEqual(cm.phys_kbytes, 4194304)
 
-    mock_run_cmd.return_value = [1, MEMINFO_STRING, ""]
-    self.assertRaises (cm._GetMemoryInfo)
-
+    mock_run_cmd.return_value = [1, MEMINFO_STRING, '']
+    self.assertRaises(cm._GetMemoryInfo)
 
   @mock.patch.object(command_executer.CommandExecuter, 'CrosRunCommandWOutput')
-  @mock.patch.object(machine_manager.CrosMachine, "SetUpChecksumInfo")
+  @mock.patch.object(machine_manager.CrosMachine, 'SetUpChecksumInfo')
   def test_get_cpu_info(self, mock_setup, mock_run_cmd):
-    cm = machine_manager.CrosMachine("daisy.cros", "/usr/local/chromeos",
-                                     "average", self.mock_cmd_exec)
+    cm = machine_manager.CrosMachine('daisy.cros', '/usr/local/chromeos',
+                                     'average', self.mock_cmd_exec)
     self.mock_cmd_exec.CrosRunCommand = mock_run_cmd
-    mock_run_cmd.return_value = [0, CPUINFO_STRING, ""]
+    mock_run_cmd.return_value = [0, CPUINFO_STRING, '']
     cm._GetCPUInfo()
     self.assertEqual(mock_run_cmd.call_count, 1)
     call_args = mock_run_cmd.call_args_list[0]
-    self.assertEqual(call_args[0][0], "cat /proc/cpuinfo")
+    self.assertEqual(call_args[0][0], 'cat /proc/cpuinfo')
     args_dict = call_args[1]
     self.assertEqual(args_dict['machine'], 'daisy.cros')
     self.assertEqual(args_dict['chromeos_root'], '/usr/local/chromeos')
     self.assertEqual(cm.cpuinfo, CPUINFO_STRING)
 
-
-  @mock.patch.object(machine_manager.CrosMachine, "SetUpChecksumInfo")
+  @mock.patch.object(machine_manager.CrosMachine, 'SetUpChecksumInfo')
   def test_compute_machine_checksum_string(self, mock_setup):
-    cm = machine_manager.CrosMachine("daisy.cros", "/usr/local/chromeos",
-                                     "average", self.mock_cmd_exec)
+    cm = machine_manager.CrosMachine('daisy.cros', '/usr/local/chromeos',
+                                     'average', self.mock_cmd_exec)
     cm.cpuinfo = CPUINFO_STRING
     cm.meminfo = MEMINFO_STRING
     cm._ParseMemoryInfo()
     cm._ComputeMachineChecksumString()
     self.assertEqual(cm.checksum_string, CHECKSUM_STRING)
 
-
-  @mock.patch.object(machine_manager.CrosMachine, "SetUpChecksumInfo")
+  @mock.patch.object(machine_manager.CrosMachine, 'SetUpChecksumInfo')
   def test_get_md5_checksum(self, mock_setup):
-    cm = machine_manager.CrosMachine("daisy.cros", "/usr/local/chromeos",
-                                     "average", self.mock_cmd_exec)
-    temp_str = "abcde"
+    cm = machine_manager.CrosMachine('daisy.cros', '/usr/local/chromeos',
+                                     'average', self.mock_cmd_exec)
+    temp_str = 'abcde'
     checksum_str = cm._GetMD5Checksum(temp_str)
-    self.assertEqual(checksum_str, "ab56b4d92b40713acc5af89985d4b786")
+    self.assertEqual(checksum_str, 'ab56b4d92b40713acc5af89985d4b786')
 
-    temp_str = ""
+    temp_str = ''
     checksum_str = cm._GetMD5Checksum(temp_str)
-    self.assertEqual(checksum_str, "")
-
+    self.assertEqual(checksum_str, '')
 
   @mock.patch.object(command_executer.CommandExecuter, 'CrosRunCommand')
-  @mock.patch.object(machine_manager.CrosMachine, "SetUpChecksumInfo")
+  @mock.patch.object(machine_manager.CrosMachine, 'SetUpChecksumInfo')
   def test_get_machine_id(self, mock_setup, mock_run_cmd):
-    cm = machine_manager.CrosMachine("daisy.cros", "/usr/local/chromeos",
-                                     "average", self.mock_cmd_exec)
+    cm = machine_manager.CrosMachine('daisy.cros', '/usr/local/chromeos',
+                                     'average', self.mock_cmd_exec)
     self.mock_cmd_exec.CrosRunCommand = mock_run_cmd
-    mock_run_cmd.return_value = [0, DUMP_VPD_STRING, ""]
+    mock_run_cmd.return_value = [0, DUMP_VPD_STRING, '']
 
     cm._GetMachineID()
     self.assertEqual(cm.machine_id, '"Product_S/N"="HT4L91SC300208"')
 
-    mock_run_cmd.return_value = [0, IFCONFIG_STRING, ""]
+    mock_run_cmd.return_value = [0, IFCONFIG_STRING, '']
     cm._GetMachineID()
-    self.assertEqual(cm.machine_id, "        ether 00:50:b6:63:db:65  txqueuelen 1000  (Ethernet)_        ether e8:03:9a:9c:50:3d  txqueuelen 1000  (Ethernet)_        ether 44:6d:57:20:4a:c5  txqueuelen 1000  (Ethernet)")
+    self.assertEqual(
+        cm.machine_id,
+        '        ether 00:50:b6:63:db:65  txqueuelen 1000  (Ethernet)_        '
+        'ether e8:03:9a:9c:50:3d  txqueuelen 1000  (Ethernet)_        ether '
+        '44:6d:57:20:4a:c5  txqueuelen 1000  (Ethernet)')
 
-    mock_run_cmd.return_value = [0, "invalid hardware config", ""]
+    mock_run_cmd.return_value = [0, 'invalid hardware config', '']
     self.assertRaises(cm._GetMachineID)
 
 
-
-if __name__ == "__main__":
+if __name__ == '__main__':
   unittest.main()