apk-based test runner work for android

build/android/test_package.py

 # Copyright (c) 2011 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 logging
 import re
 import os
 import pexpect
 
@@ skipping 17 matching lines @@
     performance_test: Whether or not performance test(s).
     cleanup_test_files: Whether or not to cleanup test files on device.
     tool: Name of the Valgrind tool.
     dump_debug_info: A debug_info object.
   """
 
   def __init__(self, adb, device, test_suite, timeout, rebaseline,
                performance_test, cleanup_test_files, tool, dump_debug_info):
     self.adb = adb
     self.device = device
+    self.test_suite_full = test_suite
     self.test_suite = os.path.splitext(test_suite)[0]
     self.test_suite_basename = os.path.basename(self.test_suite)
     self.test_suite_dirname = os.path.dirname(self.test_suite)
     self.rebaseline = rebaseline
     self.performance_test = performance_test
     self.cleanup_test_files = cleanup_test_files
     self.tool = CreateTool(tool, self.adb)
     if timeout == 0:
       if self.test_suite_basename == 'page_cycler_tests':
         timeout = 900
@@ skipping 74 matching lines @@
     return ret
 
   def _WatchTestOutput(self, p):
     """Watches the test output.
     Args:
       p: the process generating output as created by pexpect.spawn.
     """
     ok_tests = []
     failed_tests = []
     timed_out = False
+    overall_fail = False
     re_run = re.compile('\[ RUN      \] ?(.*)\r\n')
     re_fail = re.compile('\[  FAILED  \] ?(.*)\r\n')
+    re_runner_fail = re.compile('\[ RUNNER_FAILED \] ?(.*)\r\n')
     re_ok = re.compile('\[       OK \] ?(.*)\r\n')
     (io_stats_before, ready_to_continue) = self._BeginGetIOStats()
     while ready_to_continue:
-      found = p.expect([re_run, pexpect.EOF], timeout=self.timeout)
+      found = p.expect([re_run, pexpect.EOF, re_runner_fail],
+                       timeout=self.timeout)
       if found == 1:  # matched pexpect.EOF
         break
+      if found == 2:  # RUNNER_FAILED
+        logging.error('RUNNER_FAILED')
+        overall_fail = True
+        break
       if self.dump_debug_info:
         self.dump_debug_info.TakeScreenshot('_Test_Start_Run_')
       full_test_name = p.match.group(1)
       found = p.expect([re_ok, re_fail, pexpect.EOF, pexpect.TIMEOUT],
                        timeout=self.timeout)
       if found == 0:  # re_ok
         ok_tests += [BaseTestResult(full_test_name.replace('\r', ''),
                                     p.before)]
         continue
       failed_tests += [BaseTestResult(full_test_name.replace('\r', ''),
                                       p.before)]
       if found >= 2:
         # The test crashed / bailed out (i.e., didn't print OK or FAIL).
         if found == 3:  # pexpect.TIMEOUT
           logging.error('Test terminated after %d second timeout.',
                         self.timeout)
           timed_out = True
         break
     p.close()
     if not self.rebaseline and ready_to_continue:
       ok_tests += self._EndGetIOStats(io_stats_before)
       ret_code = self._GetGTestReturnCode()
       if ret_code:
         failed_tests += [BaseTestResult('gtest exit code: %d' % ret_code,
                                         'pexpect.before: %s'
                                         '\npexpect.after: %s'
                                         % (p.before,
                                            p.after))]
-    return TestResults.FromOkAndFailed(ok_tests, failed_tests, timed_out)
+    return TestResults.FromOkAndFailed(ok_tests, failed_tests,
+                                       timed_out, overall_fail)