Update from https://crrev.com/316786

build/android/pylib/instrumentation/instrumentation_test_instance.py

 # Copyright 2015 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 os
 import pickle
 import re
 import sys
 
 from pylib import cmd_helper
 from pylib import constants
 from pylib import flag_changer
 from pylib.base import base_test_result
 from pylib.base import test_instance
 from pylib.instrumentation import test_result
+from pylib.instrumentation import instrumentation_parser
 from pylib.utils import apk_helper
 from pylib.utils import md5sum
 from pylib.utils import proguard
 
 sys.path.append(
     os.path.join(constants.DIR_SOURCE_ROOT, 'build', 'util', 'lib', 'common'))
 import unittest_util
 
 _DEFAULT_ANNOTATIONS = [
     'Smoke', 'SmallTest', 'MediumTest', 'LargeTest',
@@ skipping 13 matching lines @@
   Returns:
     A 3-tuple containing:
       - the instrumentation code as an integer
       - the instrumentation result as a list of lines
       - the instrumentation statuses received as a list of 2-tuples
         containing:
         - the status code as an integer
         - the bundle dump as a dict mapping string keys to a list of
           strings, one for each line.
   """
-  INSTR_STATUS = 'INSTRUMENTATION_STATUS: '
-  INSTR_STATUS_CODE = 'INSTRUMENTATION_STATUS_CODE: '
-  INSTR_RESULT = 'INSTRUMENTATION_RESULT: '
-  INSTR_CODE = 'INSTRUMENTATION_CODE: '
-
-  last = None
-  instr_code = None
-  instr_result = []
-  instr_statuses = []
-  bundle = {}
-  for line in raw_output:
-    if line.startswith(INSTR_STATUS):
-      instr_var = line[len(INSTR_STATUS):]
-      if '=' in instr_var:
-        k, v = instr_var.split('=', 1)
-        bundle[k] = [v]
-        last = INSTR_STATUS
-        last_key = k
-      else:
-        logging.debug('Unknown "%s" line: %s' % (INSTR_STATUS, line))
-
-    elif line.startswith(INSTR_STATUS_CODE):
-      instr_status = line[len(INSTR_STATUS_CODE):]
-      instr_statuses.append((int(instr_status), bundle))
-      bundle = {}
-      last = INSTR_STATUS_CODE
-
-    elif line.startswith(INSTR_RESULT):
-      instr_result.append(line[len(INSTR_RESULT):])
-      last = INSTR_RESULT
-
-    elif line.startswith(INSTR_CODE):
-      instr_code = int(line[len(INSTR_CODE):])
-      last = INSTR_CODE
-
-    elif last == INSTR_STATUS:
-      bundle[last_key].append(line)
-
-    elif last == INSTR_RESULT:
-      instr_result.append(line)
-
-  return (instr_code, instr_result, instr_statuses)
+  parser = instrumentation_parser.InstrumentationParser(raw_output)
+  statuses = list(parser.IterStatus())
+  code, bundle = parser.GetResult()
+  return (code, bundle, statuses)
 
 
 def GenerateTestResult(test_name, instr_statuses, start_ms, duration_ms):
   """Generate the result of |test| from |instr_statuses|.
 
   Args:
     test_name: The name of the test as "class#method"
     instr_statuses: A list of 2-tuples containing:
       - the status code as an integer
       - the bundle dump as a dict mapping string keys to string values
       Note that this is the same as the third item in the 3-tuple returned by
       |_ParseAmInstrumentRawOutput|.
     start_ms: The start time of the test in milliseconds.
     duration_ms: The duration of the test in milliseconds.
   Returns:
     An InstrumentationTestResult object.
   """
-  INSTR_STATUS_CODE_START = 1
-  INSTR_STATUS_CODE_OK = 0
-  INSTR_STATUS_CODE_ERROR = -1
-  INSTR_STATUS_CODE_FAIL = -2
-
   log = ''
   result_type = base_test_result.ResultType.UNKNOWN
 
   for status_code, bundle in instr_statuses:
-    if status_code == INSTR_STATUS_CODE_START:
+    if status_code == instrumentation_parser.STATUS_CODE_START:
       pass
-    elif status_code == INSTR_STATUS_CODE_OK:
-      bundle_test = '%s#%s' % (
-          ''.join(bundle.get('class', [''])),
-          ''.join(bundle.get('test', [''])))
-      skipped = ''.join(bundle.get('test_skipped', ['']))
+    elif status_code == instrumentation_parser.STATUS_CODE_OK:
+      bundle_test = '%s#%s' % (bundle.get('class', ''), bundle.get('test', ''))
+      skipped = bundle.get('test_skipped', '')
 
       if (test_name == bundle_test and
           result_type == base_test_result.ResultType.UNKNOWN):
         result_type = base_test_result.ResultType.PASS
       elif skipped.lower() in ('true', '1', 'yes'):
         result_type = base_test_result.ResultType.SKIP
         logging.info('Skipped ' + test_name)
     else:
-      if status_code not in (INSTR_STATUS_CODE_ERROR,
-                             INSTR_STATUS_CODE_FAIL):
+      if status_code not in (instrumentation_parser.STATUS_CODE_ERROR,
+                             instrumentation_parser.STATUS_CODE_FAILURE):
         logging.error('Unrecognized status code %d. Handling as an error.',
                       status_code)
       result_type = base_test_result.ResultType.FAIL
       if 'stack' in bundle:
-        log = '\n'.join(bundle['stack'])
+        log = bundle['stack']
 
   return test_result.InstrumentationTestResult(
       test_name, result_type, start_ms, duration_ms, log=log)
 
 
 class InstrumentationTestInstance(test_instance.TestInstance):
 
   def __init__(self, args, isolate_delegate, error_func):
     super(InstrumentationTestInstance, self).__init__()
 
@@ skipping 309 matching lines @@
         a.update(m['annotations'])
         inflated_tests.append({
             'class': c['class'],
             'method': m['method'],
             'annotations': a,
         })
     return inflated_tests
 
   @staticmethod
   def GenerateMultiTestResult(errors, statuses):
-    INSTR_STATUS_CODE_START = 1
     results = []
     skip_counter = 1
     for status_code, bundle in statuses:
-      if status_code != INSTR_STATUS_CODE_START:
+      if status_code != instrumentation_parser.STATUS_CODE_START:
         # TODO(rnephew): Make skipped tests still output test name. This is only
         # there to give skipped tests a unique name so they are counted
         if 'test_skipped' in bundle:
           test_name = str(skip_counter)
           skip_counter += 1
         else:
-          test_name = '%s#%s' % (
-              ''.join(bundle.get('class', [''])),
-              ''.join(bundle.get('test', [''])))
+          test_name = '%s#%s' % (bundle.get('class', ''),
+                                 bundle.get('test', ''))
 
         results.append(
             GenerateTestResult(test_name, [(status_code, bundle)], 0, 0))
-    for error in errors:
+    for error in errors.itervalues():
       if _NATIVE_CRASH_RE.search(error):
         results.append(
             base_test_result.BaseTestResult(
             'Crash detected', base_test_result.ResultType.CRASH))
 
     return results
 
   @staticmethod
   def ParseAmInstrumentRawOutput(raw_output):
     return ParseAmInstrumentRawOutput(raw_output)
 
   @staticmethod
   def GenerateTestResult(test_name, instr_statuses, start_ms, duration_ms):
     return GenerateTestResult(test_name, instr_statuses, start_ms, duration_ms)
 
   #override
   def TearDown(self):
     if self._isolate_delegate:
       self._isolate_delegate.Clear()