Makes host driven tests use the common sharder.

build/android/pylib/base/shard.py

 # Copyright (c) 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.
 
 """Implements test sharding logic."""
 
 import logging
 import threading
 
 from pylib import android_commands
@@ skipping 166 matching lines @@
   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:
     logging.warning('Failed to create shard for %s: [%s]', device, e)
 
 
-def _RunAllTests(runners, tests, num_retries, timeout=None):
+def _RunAllTests(runners, test_collection_factory, num_retries, timeout=None):
   """Run all tests using the given TestRunners.
 
   Args:
     runners: a list of TestRunner objects.
-    tests: a list of Tests to run using the given TestRunners.
+    test_collection_factory: a callable to generate a _TestCollection object for
+        each test runner.
     num_retries: number of retries for a test.
     timeout: watchdog timeout in seconds, defaults to the default timeout.
 
   Returns:
     A tuple of (TestRunResults object, exit code)
   """
-  logging.warning('Running %s tests with %s test runners.' %
-                  (len(tests), len(runners)))
-  tests_collection = _TestCollection([_Test(t) for t in tests])
+  logging.warning('Running tests with %s test runners.' % (len(runners)))
   results = []
   exit_code = 0
   watcher = watchdog_timer.WatchdogTimer(timeout)
+
   workers = reraiser_thread.ReraiserThreadGroup(
       [reraiser_thread.ReraiserThread(
           _RunTestsFromQueue,
-          [r, tests_collection, results, watcher, num_retries],
+          [r, test_collection_factory(), results, watcher, num_retries],
           name=r.device[-4:])
        for r in runners])
   run_results = base_test_result.TestRunResults()
   workers.StartAll()
 
   # Catch DeviceUnresponsiveErrors and set a warning exit code
   try:
     workers.JoinAll(watcher)
   except android_commands.errors.DeviceUnresponsiveError as e:
     logging.error(e)
@@ skipping 41 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 ShardAndRunTests(runner_factory, devices, tests, build_type='Debug',
-                     test_timeout=DEFAULT_TIMEOUT,
-                     setup_timeout=DEFAULT_TIMEOUT,
-                     num_retries=2):
+def ReplicateAndRunTests(tests, *args, **kwargs):
+  """Replicates the tests for each device, so all devices run every test.
+
+  Args:
+    tests: A list of tests to run.
+    *args, **kwargs: Args and kwargs to RunTests which we pass through.
+
+  Returns:
+    A tuple of (base_test_result.TestRunResults object, exit code).
+  """
+
+  if not tests:
+    logging.error('No tests to run.')
+    return (base_test_result.TestRunResults(), constants.ERROR_EXIT_CODE)
+
+  logging.info('Will run %d tests: %s', len(tests), str(tests))
+
+  # Genereate a unique _TestCollection object for each test runner, but use
+  # the same set of tests.
+  TestCollectionFactory = lambda: _TestCollection([_Test(t) for t in tests])
+  return RunTests(TestCollectionFactory, *args, **kwargs)
+
+
+def ShardAndRunTests(tests, *args, **kwargs):
+  """Distrbutes all tests over devices through a shared pool of tests.
+
+  Args:
+    tests: A list of tests to run.
+    *args, **kwargs: Args and kwargs to RunTests which we pass through.
+
+  Returns:
+    A tuple of (base_test_result.TestRunResults object, exit code).
+  """
+
+  if not tests:
+    logging.error('No tests to run.')
+    return (base_test_result.TestRunResults(), constants.ERROR_EXIT_CODE)
+
+  logging.info('Will run %d tests: %s', len(tests), str(tests))
+
+  # Genereate 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])
+  TestCollectionFactory = lambda: shared_test_collection
+  return RunTests(TestCollectionFactory, *args, **kwargs)
+
+
+def RunTests(test_collection_factory, runner_factory, devices,
+             build_type='Debug',
+             test_timeout=DEFAULT_TIMEOUT,
+             setup_timeout=DEFAULT_TIMEOUT,
+             num_retries=2):
   """Run all tests on attached devices, retrying tests that don't pass.
 
   Args:
     runner_factory: callable that takes a device and index and returns a
-      TestRunner object.
+        TestRunner object.
+    test_collection_factory: callable that is used to generate a _TestCollection
+        object for each test runner.
     devices: list of attached device serial numbers as strings.
     tests: list of tests to run.
     build_type: either 'Debug' or 'Release'.
     test_timeout: watchdog timeout in seconds for running tests, defaults to the
-      default timeout.
+        default timeout.
     setup_timeout: watchdog timeout in seconds for creating and cleaning up
-      test runners, defaults to the default timeout.
+        test runners, defaults to the default timeout.
     num_retries: number of retries for a test.
 
   Returns:
     A tuple of (base_test_result.TestRunResults object, exit code).
   """
-  if not tests:
-    logging.error('No tests to run.')
-    return (base_test_result.TestRunResults(), constants.ERROR_EXIT_CODE)
-
-  logging.info('Will run %d tests: %s', len(tests), str(tests))
   forwarder.Forwarder.KillHost(build_type)
   runners = _CreateRunners(runner_factory, devices, setup_timeout)
   try:
-    return _RunAllTests(runners, tests, num_retries, test_timeout)
+    return _RunAllTests(runners, test_collection_factory,
+                        num_retries, test_timeout)
   finally:
     try:
       _TearDownRunners(runners, setup_timeout)
     except android_commands.errors.DeviceUnresponsiveError as e:
       logging.warning('Device unresponsive during TearDown: [%s]', e)
     finally:
       forwarder.Forwarder.KillHost(build_type)