[Android] Converts host driven tests to common test_dispatcher

build/android/pylib/host_driven/test_runner.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.
 
-"""Helper module for calling python-based tests."""
+"""Runs host-driven tests on a particular device."""
+
+import copy
+import logging
+import multiprocessing
+
+from pylib.base import base_test_result
+from pylib.base import base_test_runner
+from pylib.base import sharded_tests_queue
+from pylib.instrumentation import test_result
+
+import test_case
 
 
-import logging
-import sys
-import time
-import traceback
-
-from pylib.base import base_test_result
-from pylib.instrumentation import test_result
-
-
-class PythonExceptionTestResult(test_result.InstrumentationTestResult):
-  """Helper class for creating a test result from python exception."""
+class HostDrivenExceptionTestResult(test_result.InstrumentationTestResult):

[frankf, 2013/07/24 23:33:43]

Where is this used?

[gkanwar1, 2013/07/25 00:27:55]

Ah, this is not used any more (all references were removed below). Removed.

[gkanwar1, 2013/07/25 21:58:55]

I thought this over some more -- we actually only want to trigger exceptions in
the testing framework itself on the main thread. Exceptions here should be
converted into an exception test result... adding this back, and tweaking to fit
with the new host-driven tagging.

+  """A test result from an exception in a host-driven test."""

[frankf, 2013/07/24 23:33:43]

Rephrase

 
   def __init__(self, test_name, start_date_ms, exc_info):
-    """Constructs an PythonExceptionTestResult object.
+    """Constructs an HostDrivenExceptionTestResult object.
 
     Args:
       test_name: name of the test which raised an exception.
       start_date_ms: the starting time for the test.
       exc_info: exception info, ostensibly from sys.exc_info().
     """
     exc_type, exc_value, exc_traceback = exc_info
     trace_info = ''.join(traceback.format_exception(exc_type, exc_value,
                                                     exc_traceback))
     log_msg = 'Exception:\n' + trace_info
     duration_ms = (int(time.time()) * 1000) - start_date_ms
 
-    super(PythonExceptionTestResult, self).__init__(
-        'PythonWrapper#' + test_name,
+    super(HostDrivenExceptionTestResult, self).__init__(
+        'HostDrivenWrapper#' + test_name,
         base_test_result.ResultType.FAIL,
         start_date_ms,
         duration_ms,
         log=str(exc_type) + ' ' + log_msg)
 
 
-def CallPythonTest(test, options):
-  """Invokes a test function and translates Python exceptions into test results.
+class HostDrivenTestRunner(base_test_runner.BaseTestRunner):
+  """Thin wrapper around a list of HostDrivenTestCase instances.
 
-  This method invokes SetUp()/TearDown() on the test. It is intended to be
-  resilient to exceptions in SetUp(), the test itself, and TearDown(). Any
-  Python exception means the test is marked as failed, and the test result will
-  contain information about the exception.
+  This is meant to be a long-lived object which can run multiple host-driven
+  tests within its lifetime. Tests will receive the device_id and shard_index.
 
-  If SetUp() raises an exception, the test is not run.
-
-  If TearDown() raises an exception, the test is treated as a failure. However,
-  if the test itself raised an exception beforehand, that stack trace will take
-  precedence whether or not TearDown() also raised an exception.
-
-  shard_index is not applicable in single-device scenarios, when test execution
-  is serial rather than parallel. Tests can use this to bring up servers with
-  unique port numbers, for example. See also python_test_sharder.
-
-  Args:
-    test: an object which is ostensibly a subclass of PythonTestBase.
-    options: Options to use for setting up tests.
-
-  Returns:
-    A TestRunResults object which contains any results produced by the test or,
-    in the case of a Python exception, the Python exception info.
+  The shard index affords the ability to create unique port numbers (e.g.
+  DEFAULT_PORT + shard_index) if the test so wishes.
   """
 
-  start_date_ms = int(time.time()) * 1000
-  failed = False
+  #override
+  def __init__(self, device, shard_index, tool, build_type, push_deps,
+               cleanup_test_files):
+    """Create a new HostDrivenTestRunner
 
-  try:
-    test.SetUp(options)
-  except Exception:
-    failed = True
-    logging.exception(
-        'Caught exception while trying to run SetUp() for test: ' +
-        test.qualified_name)
-    # Tests whose SetUp() method has failed are likely to fail, or at least
-    # yield invalid results.
-    exc_info = sys.exc_info()
-    results = base_test_result.TestRunResults()
-    results.AddResult(PythonExceptionTestResult(
-        test.qualified_name, start_date_ms, exc_info))
-    return results
+    Args:
+      device: Attached android device.
+      shard_index: Shard index.
+      tool: Name of the Valgrind tool.
+      build_type: 'Release' or 'Debug'.
+      push_deps: If True, push all dependencies to the device.
+      cleanup_test_files: Whether or not to cleanup test files on device.
+    """
 
-  try:
-    results = test.Run()
-  except Exception:
-    # Setting this lets TearDown() avoid stomping on our stack trace from Run()
-    # should TearDown() also raise an exception.
-    failed = True
-    logging.exception('Caught exception while trying to run test: ' +
-                      test.qualified_name)
-    exc_info = sys.exc_info()
-    results = base_test_result.TestRunResults()
-    results.AddResult(PythonExceptionTestResult(
-        test.qualified_name, start_date_ms, exc_info))
+    super(HostDrivenTestRunner, self).__init__(device, tool, build_type,
+                                               push_deps, cleanup_test_files)
+    self.shard_index = shard_index
 
-  try:
-    test.TearDown()
-  except Exception:
-    logging.exception(
-        'Caught exception while trying run TearDown() for test: ' +
-        test.qualified_name)
-    if not failed:
-      # Don't stomp the error during the test if TearDown blows up. This is a
-      # trade-off: if the test fails, this will mask any problem with TearDown
-      # until the test is fixed.
-      exc_info = sys.exc_info()
-      results = base_test_result.TestRunResults()
-      results.AddResult(PythonExceptionTestResult(
-          test.qualified_name, start_date_ms, exc_info))
+  #override
+  def RunTest(self, test):
+    """Sets up and runs a test case.
 
-  return results
+    Args:
+      test: An object which is ostensibly a subclass of HostDrivenTestCase.
+
+    Returns:
+      A TestRunResults object which contains any results produced by the test

[frankf, 2013/07/24 23:33:43]

Although you use TestRunResults(), name variables singular if it holds a single
test result

[gkanwar1, 2013/07/25 00:27:55]

Done.

+      or, in the case of a Python exception, the Python exception info, and
+      which tests to retry or None.
+    """
+
+    assert(isinstance(test, test_case.HostDrivenTestCase))
+    test.SetUp(self.device, self.shard_index, self.build_type, self._push_deps,
+               self._cleanup_test_files)
+    try:
+      failed = False

[frankf, 2013/07/24 23:33:43]

failed -> exception_thrown

[gkanwar1, 2013/07/25 00:27:55]

Done.

+      results = test.Run()

[frankf, 2013/07/24 23:33:43]

Document what kind of exception can be thrown by Run() in its module

[gkanwar1, 2013/07/25 00:27:55]

Done for InstrumentationHostDrivenTestCase (regular TestCase has no defined
exceptions, since the method could be any arbitrary Python).

+    except:
+      # Set a flag to make sure exceptions in Run() take priority
+      failed = True
+      raise
+    finally:
+      try:
+        test.TearDown()
+      except:
+        # Re-raise only if Run() didn't fail, since exceptions in Run() take
+        # priority for reporting.
+        if not failed:
+          raise
+
+    if not results.DidRunPass():
+      return results, test
+    else:
+      return results, None