Reland allow JUnit3/4 tests within the same apk to be run by test_runner

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 collections
 import copy
 import logging
 import os
 import pickle
 import re
@@ skipping 33 matching lines @@
 _EXTRA_DRIVER_TARGET_CLASS = (
     'org.chromium.test.driver.OnDeviceInstrumentationDriver.TargetClass')
 _EXTRA_TIMEOUT_SCALE = (
     'org.chromium.test.driver.OnDeviceInstrumentationDriver.TimeoutScale')
 
 _PARAMETERIZED_TEST_ANNOTATION = 'ParameterizedTest'
 _PARAMETERIZED_TEST_SET_ANNOTATION = 'ParameterizedTest$Set'
 _NATIVE_CRASH_RE = re.compile('(process|native) crash', re.IGNORECASE)
 _CMDLINE_NAME_SEGMENT_RE = re.compile(
     r' with(?:out)? \{[^\}]*\}')
-_PICKLE_FORMAT_VERSION = 10
+_PICKLE_FORMAT_VERSION = 11
 
 
 class MissingSizeAnnotationError(test_exception.TestException):
   def __init__(self, class_name):
     super(MissingSizeAnnotationError, self).__init__(class_name +
         ': Test method is missing required size annotation. Add one of: ' +
         ', '.join('@' + a for a in _VALID_ANNOTATIONS))
 
 
 class TestListPickleException(test_exception.TestException):
@@ skipping 283 matching lines @@
     else:
       a = {}
     a.update(c['annotations'])
     return a
 
   def stripped_test_class(c):
     return {
       'class': c['class'],
       'annotations': recursive_class_annotations(c),
       'methods': [m for m in c['methods'] if is_test_method(m)],
+      'superclass': c['superclass'],
     }
 
   return [stripped_test_class(c) for c in p['classes']
           if is_test_class(c)]
 
 
 def _GetTestsFromDexdump(test_apk):
-  d = dexdump.Dump(test_apk)
+  dump = dexdump.Dump(test_apk)
   tests = []
 
   def get_test_methods(methods):
     return [
         {
           'method': m,
           # No annotation info is available from dexdump.
           # Set MediumTest annotation for default.
           'annotations': {'MediumTest': None},
         } for m in methods if m.startswith('test')]
 
-  for package_name, package_info in d.iteritems():
+  for package_name, package_info in dump.iteritems():
     for class_name, class_info in package_info['classes'].iteritems():
       if class_name.endswith('Test'):
         tests.append({
             'class': '%s.%s' % (package_name, class_name),
             'annotations': {},
             'methods': get_test_methods(class_info['methods']),
+            'superclass': class_info['superclass'],
         })
   return tests
 
 
 def _SaveTestsToPickle(pickle_path, jar_path, tests):
   jar_md5 = md5sum.CalculateHostMd5Sums(jar_path)[jar_path]
   pickle_data = {
     'VERSION': _PICKLE_FORMAT_VERSION,
     'JAR_MD5SUM': jar_md5,
     'TEST_METHODS': tests,
   }
   with open(pickle_path, 'w') as pickle_file:
     pickle.dump(pickle_data, pickle_file)
 
 
+class MissingJUnit4RunnerException(test_exception.TestException):
+  """Raised when JUnit4 runner is not provided or specified in apk manifest"""
+
+  def __init__(self):
+    super(MissingJUnit4RunnerException, self).__init__(
+        'JUnit4 runner is not provided or specified in test apk manifest.')
+
+
 class UnmatchedFilterException(test_exception.TestException):
   """Raised when a user specifies a filter that doesn't match any tests."""
 
   def __init__(self, test_filter):
     super(UnmatchedFilterException, self).__init__(
         'Test filter "%s" matched no tests.' % test_filter)
 
 
 def GetTestName(test, sep='#'):
   """Gets the name of the given test.
@@ skipping 40 matching lines @@
     self._additional_apks = []
     self._apk_under_test = None
     self._apk_under_test_incremental_install_script = None
     self._package_info = None
     self._suite = None
     self._test_apk = None
     self._test_apk_incremental_install_script = None
     self._test_jar = None
     self._test_package = None
     self._test_runner = None
+    self._test_runner_junit4 = None
     self._test_support_apk = None
     self._initializeApkAttributes(args, error_func)
 
     self._data_deps = None
     self._data_deps_delegate = None
     self._runtime_deps_path = None
     self._initializeDataDependencyAttributes(args, data_deps_delegate)
 
     self._annotations = None
     self._excluded_annotations = None
@@ skipping 73 matching lines @@
     if not os.path.exists(self._test_apk.path):
       error_func('Unable to find test APK: %s' % self._test_apk.path)
     if not self._test_jar:
       logging.warning('Test jar not specified. Test runner will not have '
                       'Java annotation info available. May not handle test '
                       'timeouts correctly.')
     elif not os.path.exists(self._test_jar):
       error_func('Unable to find test JAR: %s' % self._test_jar)
 
     self._test_package = self._test_apk.GetPackageName()
-    self._test_runner = self._test_apk.GetInstrumentationName()
+    all_instrumentations = self._test_apk.GetAllInstrumentations()
+    junit3_runners = [
+        x for x in all_instrumentations if ('true' not in x.get(
+            'chromium-junit4', ''))]
+    junit4_runners = [
+        x for x in all_instrumentations if ('true' in x.get(
+            'chromium-junit4', ''))]
+
+    if len(junit3_runners) > 1:
+      logging.warning('This test apk has more than one JUnit3 instrumentation')
+    if len(junit4_runners) > 1:
+      logging.warning('This test apk has more than one JUnit4 instrumentation')
+
+    self._test_runner = (
+      junit3_runners[0]['android:name'] if junit3_runners else
+      self.test_apk.GetInstrumentationName())
+    self._test_runner_junit4 = (
+      junit4_runners[0]['android:name'] if junit4_runners else None)
 
     self._package_info = None
     if self._apk_under_test:
       package_under_test = self._apk_under_test.GetPackageName()
       for package_info in constants.PACKAGE_INFO.itervalues():
         if package_under_test == package_info.package:
           self._package_info = package_info
           break
     if not self._package_info:
       logging.warning('Unable to find package info for %s', self._test_package)
@@ skipping 154 matching lines @@
 
   @property
   def test_package(self):
     return self._test_package
 
   @property
   def test_runner(self):
     return self._test_runner
 
   @property
+  def test_runner_junit4(self):
+    return self._test_runner_junit4
+
+  @property
   def timeout_scale(self):
     return self._timeout_scale
 
   #override
   def TestType(self):
     return 'instrumentation'
 
   #override
   def SetUp(self):
     self._data_deps.extend(
         self._data_deps_delegate(self._runtime_deps_path))
 
   def GetDataDependencies(self):
     return self._data_deps
 
   def GetTests(self):
     if self.test_jar:
       tests = GetAllTestsFromJar(self.test_jar)
     else:
       tests = GetAllTestsFromApk(self.test_apk.path)
     inflated_tests = self._ParametrizeTestsWithFlags(self._InflateTests(tests))
+    if self._test_runner_junit4 is None and any(
+        t['is_junit4'] for t in inflated_tests):
+      raise MissingJUnit4RunnerException()
     filtered_tests = FilterTests(
         inflated_tests, self._test_filter, self._annotations,
         self._excluded_annotations)
     if self._test_filter and not filtered_tests:
       for t in inflated_tests:
         logging.debug('  %s', GetUniqueTestName(t))
       raise UnmatchedFilterException(self._test_filter)
     return filtered_tests
 
   # pylint: disable=no-self-use
   def _InflateTests(self, tests):
     inflated_tests = []
     for c in tests:
       for m in c['methods']:
         a = dict(c['annotations'])
         a.update(m['annotations'])
         inflated_tests.append({
             'class': c['class'],
             'method': m['method'],
             'annotations': a,
+            'is_junit4': c['superclass'] == 'java.lang.Object'
         })
     return inflated_tests
 
   def _ParametrizeTestsWithFlags(self, tests):
     new_tests = []
     for t in tests:
       parameters = ParseCommandLineFlagParameters(t['annotations'])
       if parameters:
         t['flags'] = parameters[0]
         for p in parameters[1:]:
@@ skipping 25 matching lines @@
 
   @staticmethod
   def GenerateTestResults(
       result_code, result_bundle, statuses, start_ms, duration_ms):
     return GenerateTestResults(result_code, result_bundle, statuses,
                                start_ms, duration_ms)
 
   #override
   def TearDown(self):
     pass