[Android] Add experimental gtest xml result handling.

build/android/pylib/local/device/local_device_gtest_run.py

 # Copyright 2014 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.
 
 import collections
 import itertools
 import logging
 import os
 import posixpath
+import tempfile
 
 from devil.android import device_errors
 from devil.android import device_temp_file
 from devil.android import ports
 from devil.utils import reraiser_thread
 from pylib import constants
 from pylib.base import base_test_result
 from pylib.gtest import gtest_test_instance
 from pylib.local import local_test_server_spawner
 from pylib.local.device import local_device_environment
 from pylib.local.device import local_device_test_run
 
-_COMMAND_LINE_FLAGS_SUPPORTED = True
-
 _MAX_INLINE_FLAGS_LENGTH = 50  # Arbitrarily chosen.
 _EXTRA_COMMAND_LINE_FILE = (
     'org.chromium.native_test.NativeTest.CommandLineFile')
 _EXTRA_COMMAND_LINE_FLAGS = (
     'org.chromium.native_test.NativeTest.CommandLineFlags')
 _EXTRA_TEST_LIST = (
     'org.chromium.native_test.NativeTestInstrumentationTestRunner'
         '.TestList')
 _EXTRA_TEST = (
     'org.chromium.native_test.NativeTestInstrumentationTestRunner'
@@ skipping 75 matching lines @@
     self._extras = test_instance.extras
 
   def Install(self, device):
     if self._test_apk_incremental_install_script:
       local_device_test_run.IncrementalInstall(device, self._apk_helper,
           self._test_apk_incremental_install_script)
     else:
       device.Install(self._apk_helper, reinstall=True,
                      permissions=self._permissions)
 
+  def ResultsDirectory(self, device):
+    return device.GetApplicationDataDirectory(self._package)
+
   def Run(self, test, device, flags=None, **kwargs):
     extras = dict(self._extras)
 
     if ('timeout' in kwargs
         and gtest_test_instance.EXTRA_SHARD_NANO_TIMEOUT not in extras):
       # Make sure the instrumentation doesn't kill the test before the
       # scripts do. The provided timeout value is in seconds, but the
       # instrumentation deals with nanoseconds because that's how Android
       # handles time.
       extras[gtest_test_instance.EXTRA_SHARD_NANO_TIMEOUT] = int(
@@ skipping 39 matching lines @@
     self._device_dist_dir = posixpath.join(
         constants.TEST_EXECUTABLE_DIR, os.path.basename(dist_dir))
     self._test_run = tr
 
   def Install(self, device):
     # TODO(jbudorick): Look into merging this with normal data deps pushing if
     # executables become supported on nonlocal environments.
     device.PushChangedFiles([(self._host_dist_dir, self._device_dist_dir)],
                             delete_device_stale=True)
 
+  def ResultsDirectory(self, device):
+    # pylint: disable=no-self-use
+    # pylint: disable=unused-argument
+    return constants.TEST_EXECUTABLE_DIR
+
   def Run(self, test, device, flags=None, **kwargs):
     tool = self._test_run.GetTool(device).GetTestWrapper()
     if tool:
       cmd = [tool]
     else:
       cmd = []
     cmd.append(posixpath.join(self._device_dist_dir, self._exe_file_name))
 
     if test:
       cmd.append('--gtest_filter=%s' % ':'.join(test))
@@ skipping 146 matching lines @@
     if all(not tl for tl in test_lists):
       raise device_errors.CommandFailedError(
           'Failed to list tests on any device')
     return list(sorted(set().union(*[set(tl) for tl in test_lists if tl])))
 
   #override
   def _RunTest(self, device, test):
     # Run the test.
     timeout = (self._test_instance.shard_timeout
                * self.GetTool(device).GetTimeoutScale())
-    output = self._delegate.Run(
-        test, device, flags=self._test_instance.test_arguments,
-        timeout=timeout, retries=0)
-    for s in self._servers[str(device)]:
-      s.Reset()
-    if self._test_instance.app_files:
-      self._delegate.PullAppFiles(device, self._test_instance.app_files,
-                                  self._test_instance.app_file_dir)
-    if not self._env.skip_clear_data:
-      self._delegate.Clear(device)
+    flags = self._test_instance.test_arguments or ''
+    with tempfile.NamedTemporaryFile(suffix='.xml') as host_tmp_results_file:
+      with device_temp_file.DeviceTempFile(
+          adb=device.adb,
+          dir=self._delegate.ResultsDirectory(device),
+          suffix='.xml') as device_tmp_results_file:
+        flags += ' --gtest_output=xml:%s' % device_tmp_results_file.name

[rnephew (Reviews Here), 2016/09/23 14:10:51]

Do we want this always on, or should we check for
self._test_instance.enable_xml_resullts_parsing to be true? Or does that not
matter and it will still output the stdout for the old style of parsing?

[jbudorick, 2016/09/23 15:23:02]

It works w/ the flag off, but it's unnecessary. I've put both the addition of
this flag and the PullFile call below behind
self._test_instance.enable_xml_results_parsing.

+        output = self._delegate.Run(
+            test, device, flags=flags,
+            timeout=timeout, retries=0)
+        device.PullFile(
+            device_tmp_results_file.name,
+            host_tmp_results_file.name)
 
-    # Parse the output.
-    # TODO(jbudorick): Transition test scripts away from parsing stdout.
-    results = gtest_test_instance.ParseGTestOutput(output)
+      for s in self._servers[str(device)]:
+        s.Reset()
+      if self._test_instance.app_files:
+        self._delegate.PullAppFiles(device, self._test_instance.app_files,
+                                    self._test_instance.app_file_dir)
+      if not self._env.skip_clear_data:
+        self._delegate.Clear(device)
+
+      # Parse the output.
+      # TODO(jbudorick): Transition test scripts away from parsing stdout.
+      if self._test_instance.enable_xml_result_parsing:
+        with open(host_tmp_results_file.name) as xml_results_file:
+          results = gtest_test_instance.ParseGTestXML(xml_results_file.read())
+      else:
+        results = gtest_test_instance.ParseGTestOutput(output)
 
     # Check whether there are any crashed testcases.
     self._crashes.update(r.GetName() for r in results
                          if r.GetType() == base_test_result.ResultType.CRASH)
     return results
 
   #override
   def TearDown(self):
     @local_device_environment.handle_shard_failures
     def individual_device_tear_down(dev):
       for s in self._servers.get(str(dev), []):
         s.TearDown()
 
       tool = self.GetTool(dev)
       tool.CleanUpEnvironment()
 
     self._env.parallel_devices.pMap(individual_device_tear_down)