[Android] Rewrite base test result classes.

build/android/pylib/host_driven/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 pylib.base import base_test_result
 from pylib.base import sharded_tests_queue
-from pylib.base.test_result import TestResults
 
 from python_test_caller import CallPythonTest
 
 
 def SetTestsContainer(tests_container):
   """Sets PythonTestSharder as a top-level field.
 
   PythonTestSharder uses multiprocessing.Pool, which creates a pool of
   processes. This is used to initialize each worker in the pool, ensuring that
   each worker has access to this shared pool of tests.
@@ skipping 37 matching lines @@
     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 = []
+    results = base_test_result.TestRunResults()
     for t in tests:
-      res = CallPythonTest(t, self.options)
-      results.append(res)
-
-    return TestResults.FromTestResults(results)
+      results.AddTestRunResults(CallPythonTest(t, self.options))
+    return 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.
 
@@ skipping 27 matching lines @@
 
     Returns:
       A list of test results aggregated from all test runs.
     """
     logging.warning('*' * 80)
     logging.warning('Sharding in ' + str(len(self.attached_devices)) +
                     ' devices.')
     logging.warning('Note that the output is not synchronized.')
     logging.warning('Look for the "Final result" banner in the end.')
     logging.warning('*' * 80)
-    all_passed = []
-    test_results = TestResults()
+    final_results = base_test_result.TestRunResults()
     tests_to_run = self.tests
     for retry in xrange(self.retries):
       logging.warning('Try %d of %d', retry + 1, self.retries)
       self._SetupSharding(self.tests)
       test_runners = self._MakeTestRunners(self.attached_devices)
       logging.warning('Starting...')
       pool = multiprocessing.Pool(len(self.attached_devices),
                                   SetTestsContainer,
                                   [PythonTestSharder.tests_container])
 
-      # List of TestResults objects from each test execution.
+      # List of TestRunResults objects from each test execution.
       try:
         results_lists = pool.map(_DefaultRunnable, test_runners)
       except Exception:
         logging.exception('Unable to run tests. Something with the '
                           'PythonTestRunners has gone wrong.')
         raise Exception('PythonTestRunners were unable to run tests.')
 
-      test_results = TestResults.FromTestResults(results_lists)
+      test_results = base_test_result.TestRunResults()
+      for t in results_lists:
+        test_results.AddTestRunResults(t)
       # Accumulate passing results.
-      all_passed += test_results.ok
+      final_results.AddResults(test_results.GetPass())
       # If we have failed tests, map them to tests to retry.
-      failed_tests = test_results.GetAllBroken()
-      tests_to_run = self._GetTestsToRetry(self.tests,
-                                           failed_tests)
+      failed_tests = [t.GetName() for t in test_results.GetNotPass()]
+      tests_to_run = self._GetTestsToRetry(self.tests, failed_tests)
 
       # Bail out early if we have no more tests. This can happen if all tests
       # pass before we're out of retries, for example.
       if not tests_to_run:
         break
 
-    final_results = TestResults()
     # all_passed has accumulated all passing test results.
     # test_results will have the results from the most recent run, which could
     # include a variety of failure modes (unknown, crashed, failed, etc).
+    test_results.AddResults(final_results.GetPass())
     final_results = test_results
-    final_results.ok = all_passed
 
     return final_results
 
   def _MakeTestRunners(self, attached_devices):
     """Initialize and return a list of PythonTestRunners.
 
     Args:
       attached_devices: list of device IDs attached to host.
 
     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_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):
+  def _GetTestsToRetry(self, available_tests, failed_test_names):
     """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.
+      failed_test_names: a list of failed test names.
 
     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, 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