[Android] Change object types from AndroidCommands to DeviceUtils in build/android/.

build/android/pylib/base/test_dispatcher.py

 # Copyright 2013 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.
 
 """Dispatches tests, either sharding or replicating them.
 
 Performs the following steps:
 * Create a test collection factory, using the given tests
   - If sharding: test collection factory returns the same shared test collection
     to all test runners
   - If replciating: test collection factory returns a unique test collection to
     each test runner, with the same set of tests in each.
 * Create a test runner for each device.
 * Run each test runner in its own thread, grabbing tests from the test
   collection until there are no tests left.
 """
 
 import logging
 import threading
 
 from pylib import android_commands
 from pylib import constants
 from pylib.base import base_test_result
+from pylib.device import adb_wrapper
 from pylib.utils import reraiser_thread
 from pylib.utils import watchdog_timer
 
 
 DEFAULT_TIMEOUT = 7 * 60  # seven minutes
 
 
 class _ThreadSafeCounter(object):
   """A threadsafe counter."""
 
@@ skipping 119 matching lines @@
 
   def TagTestRunResults(test_run_results):
     """Tags all results with the last 4 digits of the device id.
 
     Used when replicating tests to distinguish the same tests run on different
     devices. We use a set to store test results, so the hash (generated from
     name and tag) must be unique to be considered different results.
     """
     new_test_run_results = base_test_result.TestRunResults()
     for test_result in test_run_results.GetAll():
-      test_result.SetName('%s_%s' % (runner.device[-4:], test_result.GetName()))
+      test_result.SetName('%s_%s' % (runner.device_serial[-4:],
+                                     test_result.GetName()))
       new_test_run_results.AddResult(test_result)
     return new_test_run_results
 
   for test in test_collection:
     watcher.Reset()
     try:
-      if not android_commands.IsDeviceAttached(runner.device):
+      if runner.device_serial not in android_commands.GetAttachedDevices():
         # Device is unresponsive, stop handling tests on this device.
-        msg = 'Device %s is unresponsive.' % runner.device
+        msg = 'Device %s is unresponsive.' % runner.device_serial
         logging.warning(msg)
-        raise android_commands.errors.DeviceUnresponsiveError(msg)
+        raise adb_wrapper.DeviceUnreachableError(msg)
       result, retry = runner.RunTest(test.test)
       if tag_results_with_device:
         result = TagTestRunResults(result)
       test.tries += 1
       if retry and test.tries <= num_retries:
         # Retry non-passing results, only record passing results.
         pass_results = base_test_result.TestRunResults()
         pass_results.AddResults(result.GetPass())
         out_results.append(pass_results)
         logging.warning('Will retry test, try #%s.' % test.tries)
@@ skipping 23 matching lines @@
     device: The device serial number to set up.
     out_runners: List to add the successfully set up TestRunner object.
     threadsafe_counter: A _ThreadSafeCounter object used to get shard indices.
   """
   try:
     index = threadsafe_counter.GetAndIncrement()
     logging.warning('Creating shard %s for device %s.', index, device)
     runner = runner_factory(device, index)
     runner.SetUp()
     out_runners.append(runner)
-  except android_commands.errors.DeviceUnresponsiveError as e:
+  except adb_wrapper.DeviceUnreachableError as e:
     logging.warning('Failed to create shard for %s: [%s]', device, e)
 
 
 def _RunAllTests(runners, test_collection_factory, num_retries, timeout=None,
                  tag_results_with_device=False):
   """Run all tests using the given TestRunners.
 
   Args:
     runners: A list of TestRunner objects.
     test_collection_factory: A callable to generate a _TestCollection object for
@@ skipping 12 matching lines @@
   results = []
   exit_code = 0
   run_results = base_test_result.TestRunResults()
   watcher = watchdog_timer.WatchdogTimer(timeout)
   test_collections = [test_collection_factory() for _ in runners]
 
   threads = [
       reraiser_thread.ReraiserThread(
           _RunTestsFromQueue,
           [r, tc, results, watcher, num_retries, tag_results_with_device],
-          name=r.device[-4:])
+          name=r.device_serial[-4:])
       for r, tc in zip(runners, test_collections)]
 
   workers = reraiser_thread.ReraiserThreadGroup(threads)
   workers.StartAll()
 
-  # Catch DeviceUnresponsiveErrors and set a warning exit code
+  # Catch DeviceUnreachableErrors and set a warning exit code
   try:
     workers.JoinAll(watcher)
-  except android_commands.errors.DeviceUnresponsiveError as e:
+  except adb_wrapper.DeviceUnreachableError as e:
     logging.error(e)
     exit_code = constants.WARNING_EXIT_CODE
 
   assert all([len(tc) == 0 for tc in test_collections]), (
       'Some tests were not run, all devices are likely offline (ran %d tests)' %
       len(run_results.GetAll()))
 
   for r in results:
     run_results.AddTestRunResults(r)
   if not run_results.DidRunPass():
@@ skipping 30 matching lines @@
 
 
 def _TearDownRunners(runners, timeout=None):
   """Calls TearDown() for each test runner in parallel.
 
   Args:
     runners: A list of TestRunner objects.
     timeout: Watchdog timeout in seconds, defaults to the default timeout.
   """
   threads = reraiser_thread.ReraiserThreadGroup(
-      [reraiser_thread.ReraiserThread(r.TearDown, name=r.device[-4:])
+      [reraiser_thread.ReraiserThread(r.TearDown, name=r.device_serial[-4:])
        for r in runners])
   threads.StartAll()
   threads.JoinAll(watchdog_timer.WatchdogTimer(timeout))
 
 
 def RunTests(tests, runner_factory, devices, shard=True,
              test_timeout=DEFAULT_TIMEOUT, setup_timeout=DEFAULT_TIMEOUT,
              num_retries=2):
   """Run all tests on attached devices, retrying tests that don't pass.
 
@@ skipping 34 matching lines @@
     log_string = 'replicated on each device'
 
   logging.info('Will run %d tests (%s): %s', len(tests), log_string, str(tests))
   runners = _CreateRunners(runner_factory, devices, setup_timeout)
   try:
     return _RunAllTests(runners, test_collection_factory,
                         num_retries, test_timeout, tag_results_with_device)
   finally:
     try:
       _TearDownRunners(runners, setup_timeout)
-    except android_commands.errors.DeviceUnresponsiveError as e:
+    except adb_wrapper.DeviceUnreachableError as e:
       logging.warning('Device unresponsive during TearDown: [%s]', e)