Upstream changes to python tests.

build/android/pylib/python_test_sharder.py

 # Copyright (c) 2012 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.
 
 """Takes care of sharding the python-drive tests in multiple devices."""
 
+import copy
 import logging
 import multiprocessing
 
 from python_test_caller import CallPythonTest
 from run_java_tests import FatalTestException
 import sharded_tests_queue
 from test_result import TestResults
 
 
 def SetTestsContainer(tests_container):
@@ skipping 26 matching lines @@
 class PythonTestRunner(object):
   """Thin wrapper around a list of PythonTestBase instances.
 
   This is meant to be a long-lived object which can run multiple Python tests
   within its lifetime. Tests will receive the device_id and shard_index.
 
   The shard index affords the ability to create unique port numbers (e.g.
   DEFAULT_PORT + shard_index) if the test so wishes.
   """
 
-  def __init__(self, device_id, shard_index):
+  def __init__(self, options):
     """Constructor.
 
     Args:
-      device_id: ID of the device which this test will talk to.
-      shard_index: shard index, used to create such as unique port numbers.
+      options: Options to use for setting up tests.
     """
-    self.device_id = device_id
-    self.shard_index = shard_index
+    self.options = options
 
   def RunTests(self):
     """Runs tests from the shared pool of tests, aggregating results.
 
     Returns:
       A list of test results for all of the tests which this runner executed.
     """
     tests = PythonTestSharder.tests_container
 
     results = []
     for t in tests:
-      res = CallPythonTest(t, self.device_id, self.shard_index)
+      res = CallPythonTest(t, self.options)
       results.append(res)
 
     return TestResults.FromTestResults(results)
 
 
 class PythonTestSharder(object):
   """Runs Python tests in parallel on multiple devices.
 
   This is lifted more or less wholesale from BaseTestRunner.
 
   Under the covers, it creates a pool of long-lived PythonTestRunners, which
   execute tests from the pool of tests.
 
   Args:
     attached_devices: a list of device IDs attached to the host.
-    shard_retries: number of retries for any given test.
     available_tests: a list of tests to run which subclass PythonTestBase.
+    options: Options to use for setting up tests.
 
   Returns:
     An aggregated list of test results.
   """
   tests_container = None
 
-  def __init__(self, attached_devices, shard_retries, available_tests):
+  def __init__(self, attached_devices, available_tests, options):
+    self.options = options
     self.attached_devices = attached_devices
-    self.retries = shard_retries
+    self.retries = options.shard_retries
     self.tests = available_tests
 
   def _SetupSharding(self, tests):
     """Creates the shared pool of tests and makes it available to test runners.
 
     Args:
       tests: the list of tests which will be consumed by workers.
     """
     SetTestsContainer(sharded_tests_queue.ShardedTestsQueue(
         len(self.attached_devices), tests))
@@ skipping 61 matching lines @@
     Returns:
       A list of PythonTestRunners, one for each device.
     """
     test_runners = []
     for index, device in enumerate(attached_devices):
       logging.warning('*' * 80)
       logging.warning('Creating shard %d for %s', index, device)
       logging.warning('*' * 80)
       # Bind the PythonTestRunner to a device & shard index. Give it the
       # runnable which it will use to actually execute the tests.
-      test_runner = PythonTestRunner(device, index)
+      test_options = copy.deepcopy(self.options)
+      test_options.ensure_value('device_id', device)
+      test_options.ensure_value('shard_index', index)
+      test_runner = PythonTestRunner(test_options)
       test_runners.append(test_runner)
 
     return test_runners
 
   def _GetTestsToRetry(self, available_tests, failed_tests):
     """Infers a list of tests to retry from failed tests and available tests.
 
     Args:
       available_tests: a list of tests which subclass PythonTestBase.
       failed_tests: a list of SingleTestResults representing failed tests.
 
     Returns:
       A list of test objects which correspond to test names found in
       failed_tests, or an empty list if there is no correspondence.
     """
     failed_test_names = map(lambda t: t.test_name, failed_tests)
     tests_to_retry = [t for t in available_tests
                       if t.qualified_name in failed_test_names]
     return tests_to_retry