Add option to specify ADB binary in test runner.

build/android/pylib/device/device_utils_test.py

 #!/usr/bin/env python
 # Copyright 2014 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """
 Unit tests for the contents of device_utils.py (mostly DeviceUtils).
 """
 
 # pylint: disable=C0321
@@ skipping 162 matching lines @@
       if sys.exc_info()[0] is None:
         on_failure_fmt = ('\n'
                           '  received command: %s\n'
                           '  expected command: %s')
         self._test_case.assertGreater(
             len(self._cmds), self._total_received,
             msg=on_failure_fmt % (actual_cmd, None))
         expected_cmd, ret = self._cmds[self._total_received]
         self._total_received += 1
         self._test_case.assertTrue(
-            self._comp(expected_cmd, actual_cmd),
+            self._comp(expected_cmd, re.sub(r'/.*/adb', 'adb', actual_cmd)),

[jbudorick, 2014/11/17 23:01:07]

I'm not a fan of this (even if these tests are gradually being deprecated).
re.sub seems like overkill, and there are corner cases where this could do the
wrong thing.

What about mocking out the call to GetAdbPath()?

             msg=on_failure_fmt % (actual_cmd, expected_cmd))
         return ret
       return ''
 
     def __exit__(self, exc_type, exc_val, exc_tb):
       self._run_command.patched.__exit__(exc_type, exc_val, exc_tb)
       if exc_type is None:
         on_failure = "adb commands don't match.\nExpected:%s\nActual:%s" % (
             ''.join('\n  %s' % c for c, _ in self._cmds),
             ''.join('\n  %s' % a[0]
                     for _, a, kw in self._run_command.mocked.mock_calls))
         self._test_case.assertEqual(
           len(self._cmds), len(self._run_command.mocked.mock_calls),
           msg=on_failure)
         for (expected_cmd, _r), (_n, actual_args, actual_kwargs) in zip(
             self._cmds, self._run_command.mocked.mock_calls):
           self._test_case.assertEqual(1, len(actual_args), msg=on_failure)
-          self._test_case.assertTrue(self._comp(expected_cmd, actual_args[0]),
-                                     msg=on_failure)
+          self._test_case.assertTrue(self._comp(expected_cmd,
+              re.sub(r'/.*/adb', 'adb', actual_args[0])), msg=on_failure)
           self._test_case.assertTrue('timeout_time' in actual_kwargs,
                                      msg=on_failure)
           self._test_case.assertTrue('retry_count' in actual_kwargs,
                                      msg=on_failure)
 
   def assertNoAdbCalls(self):
     return type(self).AndroidCommandsCalls(self, [], str.__eq__)
 
   def assertCalls(self, cmd, ret, comp=str.__eq__):
     return type(self).AndroidCommandsCalls(self, [(cmd, ret)], comp)
@@ skipping 1411 matching lines @@
     self.device = device_utils.DeviceUtils(None)
     with self.assertCalls('adb  get-serialno', 'unknown'), (
          self.assertRaises(device_errors.NoDevicesError)):
       str(self.device)
 
 
 if __name__ == '__main__':
   logging.getLogger().setLevel(logging.DEBUG)
   unittest.main(verbosity=2)