List Java Instru Test Information From JUnit 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 copy
+import json
 import logging
 import os
 import pickle
 import re
 
 from devil.android import apk_helper
 from devil.android import md5sum
 from pylib import constants
 from pylib.base import base_test_result
 from pylib.base import test_exception
 from pylib.base import test_instance
 from pylib.constants import host_paths
 from pylib.instrumentation import test_result
 from pylib.instrumentation import instrumentation_parser
 from pylib.utils import dexdump
 from pylib.utils import proguard
 from pylib.utils import shared_preference_utils
+from py_utils import tempfile_ext
 
 with host_paths.SysPath(host_paths.BUILD_COMMON_PATH):
   import unittest_util # pylint: disable=import-error
 
 # Ref: http://developer.android.com/reference/android/app/Activity.html
 _ACTIVITY_RESULT_CANCELED = 0
 _ACTIVITY_RESULT_OK = -1
 
 _COMMAND_LINE_PARAMETER = 'cmdlinearg-parameter'
 _DEFAULT_ANNOTATIONS = [
@@ skipping 145 matching lines @@
     unqualified_class_test = {
       'class': t['class'].split('.')[-1],
       'method': t['method']
     }
     names = [
       GetTestName(t, sep='.'),
       GetTestName(unqualified_class_test, sep='.'),
       GetUniqueTestName(t, sep='.')
     ]
 
+    if t['is_junit4']:
+      names += [
+          GetTestNameWithoutParameterPostfix(t, sep='.'),

[jbudorick, 2017/07/14 18:43:55]

These make it so that, if someone passes the test name with the parameter
postfix, we run both? I'm not sure we ought to do that.

[the real yoland, 2017/07/18 04:20:21]

I think this just makes that if someone pass in test name without parameter
postfix, we run both.
If the -f argument has parameter postfix, it will only match the parameterized
test.

+          GetTestNameWithoutParameterPostfix(unqualified_class_test, sep='.')
+      ]
+
     pattern_groups = test_filter.split('-')
     if len(pattern_groups) > 1:
       negative_filter = pattern_groups[1]
       if unittest_util.FilterTestNames(names, negative_filter):
         return []
 
     positive_filter = pattern_groups[0]
     return unittest_util.FilterTestNames(names, positive_filter)
 
   def annotation_filter(all_annotations):
@@ skipping 34 matching lines @@
 
     if (not annotation_filter(t['annotations'])
         or not excluded_annotation_filter(t['annotations'])):
       continue
 
     filtered_tests.append(t)
 
   return filtered_tests
 
 
+def GetAllTestsFromRunner(device, test_apk_path, test_package, filename,
+                          test_runner=None, test_runner_junit4=None):
+  pickle_path = '%s-runner.pickle' % test_apk_path
+  try:
+    tests = _GetAllTestsFromRunner(device, test_package, filename,

[jbudorick, 2017/07/14 18:43:55]

What's going on here? Why does it get the tests from the runner, then from the
pickle, then if fails to get tests from the pickle, get them from the runner
again?

[the real yoland, 2017/07/18 04:20:21]

oops, my bad
Done

+                                   test_runner, test_runner_junit4)
+    tests = _GetTestsFromPickle(pickle_path, test_apk_path)
+  except TestListPickleException as e:
+    logging.info('Could not get tests from pickle: %s', e)
+    logging.info('Getting tests by print tests in instrumentation runner')
+    tests = _GetAllTestsFromRunner(device, test_package, filename,
+                                   test_runner, test_runner_junit4)
+    _SaveTestsToPickle(pickle_path, test_apk_path, tests)
+  return tests
+
+
+# TODO(yolandyan): remove this once the tests are converted to junit4
 def GetAllTestsFromJar(test_jar):
   pickle_path = '%s-proguard.pickle' % test_jar
   try:
     tests = _GetTestsFromPickle(pickle_path, test_jar)
   except TestListPickleException as e:
     logging.info('Could not get tests from pickle: %s', e)
     logging.info('Getting tests from JAR via proguard.')
     tests = _GetTestsFromProguard(test_jar)
     _SaveTestsToPickle(pickle_path, test_jar, tests)
   return tests
@@ skipping 77 matching lines @@
     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 _GetAllTestsFromRunner(device, test_package, filename,
+                          test_runner=None, test_runner_junit4=None):
+  device_path = os.path.join(device.GetExternalStoragePath(),

[jbudorick, 2017/07/14 18:43:55]

just use a device temp file:
https://codesearch.chromium.org/chromium/src/third_party/catapult/devil/devil...

[the real yoland, 2017/07/18 04:20:22]

Done

+                             'chromium_tests_root', filename)
+  device.RunShellCommand(['rm', device_path], check_return=False)
+  if test_runner is None and test_runner_junit4 is None:
+    raise Exception('Test runner does NOT exist for this test apk')
+  if test_runner_junit4:

[jbudorick, 2017/07/14 18:43:56]

If there is no test_runner_junit4, it looks like we do nothing and then pulling
the file fails below. We should instead either:
 - do something; or
 - raise an exception

[the real yoland, 2017/07/18 04:20:21]

Done

+    extras = {}
+    extras['listAllTests'] = filename
+    extras['log'] = 'true'
+    extras['package'] = 'org.chromium'
+    target = '%s/%s' % (test_package, test_runner_junit4)
+    output_string = ''.join(device.StartInstrumentation(
+        target, extras=extras, timeout=30, retries=0))

[jbudorick, 2017/07/14 18:43:55]

No retries?

[the real yoland, 2017/07/18 04:20:22]

Set retries to 2?
Done

+    if output_string:
+      raise Exception('Test listing through %s failed on device:\n%s' % (
+          test_runner_junit4, output_string))
+  with tempfile_ext.NamedTemporaryDirectory() as host_dir:
+    host_file = os.path.join(host_dir, filename)
+    device.PullFile(device_path, host_dir)
+    with open(host_file, 'r') as f:
+      json_string = f.read()
+      return json.loads(json_string)
+
 
 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)
@@ skipping 23 matching lines @@
 
   Args:
     test: the instrumentation test dict.
     sep: the character(s) that should join the class name and the method name.
   Returns:
     The test name as a string.
   """
   return '%s%s%s' % (test['class'], sep, test['method'])
 
 
+def GetTestNameWithoutParameterPostfix(
+      test, sep='#', parameter_postfix='__'):
+  """Gets the name of the given JUnit4 test withouth parameter postfix.
+
+  For most WebView JUnit4 javatests, each test is parameterizatized with
+  "__sandboxed_mode" to run in both non-sandboxed mode and sandboxed mode.
+
+  This function returns the name of the test without parameterization
+  so test filters can match both parameterized and non-parameterized tests.
+
+  Args:
+    test: the instrumentation test dict.
+    sep: the character(s) that should join the class name and the method name.
+    parameterization_sep: the character(s) that seperate method name and method
+                          parameterization postfix.
+  Returns:
+    The test name without parameter postfix as a string.
+  """
+  name = GetTestName(test, sep=sep)
+  return name.split(parameter_postfix)[0]
+
+
 def GetUniqueTestName(test, sep='#'):
   """Gets the unique name of the given test.
 
   This will include text to disambiguate between tests for which GetTestName
   would return the same name.
 
   Args:
     test: the instrumentation test dict.
     sep: the character(s) that should join the class name and the method name.
   Returns:
@@ skipping 369 matching lines @@
     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:
+  def GetTests(self, device=None):
+    filename = 'list_all_tests.json'
+    if self._test_runner_junit4 and device:
+      tests = GetAllTestsFromRunner(
+          device, self.test_apk.path, self.test_package, filename,
+          test_runner=self._test_runner,
+          test_runner_junit4=self.test_runner_junit4)
+    elif self.test_jar:
       tests = GetAllTestsFromJar(self.test_jar)
     else:
       tests = GetAllTestsFromApk(self.test_apk.path)
     inflated_tests = self._ParameterizeTestsWithFlags(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)
@@ skipping 57 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