[Android] Move getting the list of devices out of test_dispatcher.

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.
 
-To dispatch, performs the following steps:
+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.
-* Get the list of devices to run on
-* Create test runners
-* Run each test runner in its own thread, pulling tests from the test collection
-  generated from the test collection factory until there are no tests left.
+* 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.utils import reraiser_thread
 from pylib.utils import watchdog_timer
 
@@ skipping 270 matching lines @@
     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:])
        for r in runners])
   threads.StartAll()
   threads.JoinAll(watchdog_timer.WatchdogTimer(timeout))
 
 
-
-def _GetAttachedDevices(wait_for_debugger=False, test_device=None):
-  """Get all attached devices.
-
-  If we are using a debugger, limit to only one device.
-
-  Args:
-    wait_for_debugger: True if this run will use a debugger.
-    test_device: Name of a specific device to use.
-
-  Returns:
-    A list of attached devices.
-  """
-  attached_devices = []
-
-  attached_devices = android_commands.GetAttachedDevices()
-  if test_device:
-    assert test_device in attached_devices, (
-        'Did not find device %s among attached device. Attached devices: %s'
-        % (test_device, ', '.join(attached_devices)))
-    attached_devices = [test_device]
-
-  if len(attached_devices) > 1 and wait_for_debugger:
-    logging.warning('Debugger can not be sharded, using first available device')
-    attached_devices = attached_devices[:1]
-
-  return sorted(attached_devices)
-
-
-def RunTests(tests, runner_factory, wait_for_debugger, test_device,
-             shard=True,
-             test_timeout=DEFAULT_TIMEOUT,
-             setup_timeout=DEFAULT_TIMEOUT,
+def RunTests(tests, runner_factory, devices, shard=True,

[craigdh, 2013/08/19 18:22:35]

Update the unittest as well.

[frankf, 2013/08/19 19:05:50]

Good catch. Done.

On 2013/08/19 18:22:35, craigdh wrote:

+             test_timeout=DEFAULT_TIMEOUT, setup_timeout=DEFAULT_TIMEOUT,
              num_retries=2):
   """Run all tests on attached devices, retrying tests that don't pass.
 
   Args:
     tests: List of tests to run.
     runner_factory: Callable that takes a device and index and returns a
         TestRunner object.
-    wait_for_debugger: True if this test is using a debugger.
-    test_device: A specific device to run tests on, or None.
+    devices: List of attached devices.
     shard: True if we should shard, False if we should replicate tests.
       - Sharding tests will distribute tests across all test runners through a
         shared test collection.
       - Replicating tests will copy all tests to each test runner through a
         unique test collection for each test runner.
     test_timeout: Watchdog timeout in seconds for running tests.
     setup_timeout: Watchdog timeout in seconds for creating and cleaning up
         test runners.
     num_retries: Number of retries for a test.
 
   Returns:
     A tuple of (base_test_result.TestRunResults object, exit code).
   """
   if not tests:
     logging.critical('No tests to run.')
     return (base_test_result.TestRunResults(), constants.ERROR_EXIT_CODE)
+
   if shard:
     # Generate a shared _TestCollection object for all test runners, so they
     # draw from a common pool of tests.
     shared_test_collection = _TestCollection([_Test(t) for t in tests])
     test_collection_factory = lambda: shared_test_collection
     tag_results_with_device = False
     log_string = 'sharded across devices'
   else:
     # Generate a unique _TestCollection object for each test runner, but use
     # the same set of tests.
     test_collection_factory = lambda: _TestCollection([_Test(t) for t in tests])
     tag_results_with_device = True
     log_string = 'replicated on each device'
 
-  devices = _GetAttachedDevices(wait_for_debugger, test_device)
-  if not devices:
-    logging.critical('No attached devices.')
-    return (base_test_result.TestRunResults(), constants.ERROR_EXIT_CODE)
-
   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:
       logging.warning('Device unresponsive during TearDown: [%s]', e)