Android: Instrumentation tests in gradle

build/android/gradle/generate_gradle.py

Index: build/android/gradle/generate_gradle.py
diff --git a/build/android/gradle/generate_gradle.py b/build/android/gradle/generate_gradle.py
index 3c08114cfe43ddddd14f35c4908cab32690f1953..0112926e631a3fc5d292f54bd701160c64c3d662 100755
--- a/build/android/gradle/generate_gradle.py
+++ b/build/android/gradle/generate_gradle.py
@@ -122,6 +122,8 @@ class _ProjectEntry(object):
       gn_target = '%s:%s' % (gn_target, os.path.basename(gn_target))
     self._gn_target = gn_target
     self._build_config = None
+    self._test_entry = None
+    self._android_test_entry = None
 
   @classmethod
   def FromBuildConfigPath(cls, path):
@@ -137,6 +139,53 @@ class _ProjectEntry(object):
   def __eq__(self, other):
     return self._gn_target == other.GnTarget()
 
+  def SetTest(self, test_entry):

[agrieve, 2017/01/12 21:28:35]

It'd be more python-y to just make test_entry and android_test_entry a public
property. (you can always add setters/getters later if need be)

[Peter Wen, 2017/01/18 20:54:40]

Done.

+    self._test_entry = test_entry
+
+  def SetAndroidTest(self, test_entry):
+    self._android_test_entry = test_entry
+
+  def Test(self):
+    return self._test_entry
+
+  def AndroidTest(self):
+    return self._android_test_entry
+
+  def Srcjars(self, use_gradle_process_resources):
+    srcjars = _RebasePath(self.Gradle().get('bundled_srcjars', []))

[agrieve, 2017/01/12 21:28:35]

I think it'd be nicer to not rebase in these methods. rebasing should be done by
the thing using it.

[Peter Wen, 2017/01/18 20:54:41]

Hmm... now that they're in GradleGenerator do you still feel the same way?

+    if not use_gradle_process_resources:
+      srcjars += _RebasePath(self.BuildConfig()['javac']['srcjars'])
+    return srcjars
+
+  def JavaFiles(self):
+    java_sources_file = self.Gradle().get('java_sources_file')
+    java_files = []
+    if java_sources_file:
+      java_sources_file = _RebasePath(java_sources_file)
+      java_files = build_utils.ReadSourcesList(java_sources_file)
+    return java_files
+
+  def JavaDirs(self, gradle_output_dir, use_gradle_process_resources):
+    entry_output_dir = self.EntryOutputDir(gradle_output_dir)
+    java_dirs = _CreateJavaSourceDir(

[agrieve, 2017/01/12 21:28:35]

This seems a bit odd as well. The method seems like a getter, but has the
side-effect of modifying the filesystem.

[Peter Wen, 2017/01/18 20:54:41]

Now it's called GenJavaDirs. :)

+        constants.GetOutDirectory(), entry_output_dir, self.JavaFiles())
+    if self.Srcjars(use_gradle_process_resources):
+      java_dirs.append(os.path.join(entry_output_dir, _SRCJARS_SUBDIR))
+    return java_dirs
+
+  def JniLibs(self, gradle_output_dir):
+    native_section = self.BuildConfig().get('native')
+    if native_section:
+      jni_libs = _CreateJniLibsDir(
+          constants.GetOutDirectory(), self.EntryOutputDir(gradle_output_dir),
+          native_section.get('libraries'))
+    else:
+      jni_libs = []
+    return jni_libs
+
+  def EntryOutputDir(self, gradle_output_dir):
+    return os.path.join(gradle_output_dir, self.GradleSubdir())
+
   def GnTarget(self):
     return self._gn_target
 
@@ -164,9 +213,44 @@ class _ProjectEntry(object):
       self._build_config = build_utils.ReadJson(_RebasePath(path))
     return self._build_config
 
+  def DepsInfo(self):
+    return self.BuildConfig()['deps_info']
+
+  def Gradle(self):
+    return self.BuildConfig()['gradle']
+
+  def GeneratedInputs(self, use_gradle_process_resources):
+    generated_inputs = []
+    generated_inputs.extend(self.Srcjars(use_gradle_process_resources))
+    generated_inputs.extend(
+        p for p in self.JavaFiles() if not p.startswith('..'))
+    generated_inputs.extend(self.Gradle()['dependent_prebuilt_jars'])
+    return generated_inputs
+
+  def Generate(self, gradle_output_dir, use_gradle_process_resources,
+      relativize):
+    variables = {}
+    android_test_manifest = self.Gradle().get(
+        'android_manifest', _DEFAULT_ANDROID_MANIFEST_PATH)
+    variables['android_manifest'] = relativize(android_test_manifest)
+    variables['java_dirs'] = relativize(self.JavaDirs(
+        gradle_output_dir, use_gradle_process_resources))
+    variables['jni_libs'] = relativize(self.JniLibs(gradle_output_dir))
+    deps = [_ProjectEntry.FromBuildConfigPath(p)
+            for p in self.Gradle()['dependent_android_projects']]
+    variables['android_project_deps'] = [d.ProjectName() for d in deps]
+    # TODO(agrieve): Add an option to use interface jars and see if that speeds
+    # things up at all.
+    variables['prebuilts'] = relativize(
+        self.Gradle()['dependent_prebuilt_jars'])
+    deps = [_ProjectEntry.FromBuildConfigPath(p)
+            for p in self.Gradle()['dependent_java_projects']]
+    variables['java_project_deps'] = [d.ProjectName() for d in deps]
+    return variables
+
   def GetType(self):
     """Returns the target type from its .build_config."""
-    return self.BuildConfig()['deps_info']['type']
+    return self.DepsInfo()['type']
 
 
 def _ComputeJavaSourceDirs(java_files):
@@ -278,12 +362,11 @@ def _GenerateLocalProperties(sdk_dir):
       ''])
 
 
-def _GenerateGradleFile(build_config, build_vars, java_dirs, jni_libs,
-                        relativize, use_gradle_process_resources,
-                        jinja_processor):
+def _GenerateGradleFile(entry, gradle_output_dir, build_vars, relativize,
+                        use_gradle_process_resources, jinja_processor):
   """Returns the data for a project's build.gradle."""
-  deps_info = build_config['deps_info']
-  gradle = build_config['gradle']
+  deps_info = entry.DepsInfo()
+  gradle = entry.Gradle()
 
   variables = {
       'sourceSetName': 'main',
@@ -316,21 +399,14 @@ def _GenerateGradleFile(build_config, build_vars, java_dirs, jni_libs,
   variables['build_tools_version'] = (
       build_vars['android_sdk_build_tools_version'])
   variables['compile_sdk_version'] = build_vars['android_sdk_version']
-  android_manifest = gradle.get('android_manifest',
-                                _DEFAULT_ANDROID_MANIFEST_PATH)
-  variables['android_manifest'] = relativize(android_manifest)
-  variables['java_dirs'] = relativize(java_dirs)
-  variables['jni_libs'] = relativize(jni_libs)
-  # TODO(agrieve): Add an option to use interface jars and see if that speeds
-  # things up at all.
-  variables['prebuilts'] = relativize(gradle['dependent_prebuilt_jars'])
-  deps = [_ProjectEntry.FromBuildConfigPath(p)
-          for p in gradle['dependent_android_projects']]
-
-  variables['android_project_deps'] = [d.ProjectName() for d in deps]
-  deps = [_ProjectEntry.FromBuildConfigPath(p)
-          for p in gradle['dependent_java_projects']]
-  variables['java_project_deps'] = [d.ProjectName() for d in deps]
+  variables['main'] = entry.Generate(
+      gradle_output_dir, use_gradle_process_resources, relativize)
+  if entry.Test():
+    variables['test'] = entry.Test().Generate(
+        gradle_output_dir, use_gradle_process_resources, relativize)
+  if entry.AndroidTest():
+    variables['android_test'] = entry.AndroidTest().Generate(
+        gradle_output_dir, use_gradle_process_resources, relativize)
 
   return jinja_processor.Render(
       _TemplatePath(target_type.split('_')[0]), variables)
@@ -380,13 +456,38 @@ def _FindAllProjectEntries(main_entries):
     if cur_entry in found:
       continue
     found.add(cur_entry)
-    build_config = cur_entry.BuildConfig()
-    sub_config_paths = build_config['deps_info']['deps_configs']
+    sub_config_paths = cur_entry.DepsInfo()['deps_configs']
     to_scan.extend(
         _ProjectEntry.FromBuildConfigPath(p) for p in sub_config_paths)
   return list(found)
 
 
+def _CombineTestEntries(entries):
+  combined_entries = []
+  test_entries = {}
+  android_test_entries = {}
+  for entry in entries:
+    target_name = entry.GnTarget()
+    if (target_name.endswith('_test_apk__apk') and
+        'apk_under_test' in entry.Gradle()):
+      apk_name = entry.Gradle()['apk_under_test']
+      android_test_entries[apk_name] = entry
+    elif (target_name.endswith('_junit_tests__java_binary') and
+          'lib_under_test' in entry.Gradle()):
+      lib_name = entry.Gradle()['lib_under_test']
+      test_entries[lib_name] = entry
+    else:
+      combined_entries.append(entry)
+  for entry in combined_entries:
+    target_name = entry.DepsInfo()['name']
+    gn_target_name = entry.GnTarget()
+    if target_name in test_entries:
+      entry.SetTest(test_entries[gn_target_name])
+    if target_name in android_test_entries:
+      entry.SetAndroidTest(android_test_entries[target_name])
+  return combined_entries

[agrieve, 2017/01/12 21:28:35]

From inspection, it seems like there's risk of there being entries in the dicts
that didn't match up with a target. Should this instead remove entries from the
dicts as they are found, and then have the remaining added as top-level entries?

[Peter Wen, 2017/01/18 20:54:40]

Done.

+
+
 def main():
   parser = argparse.ArgumentParser()
   parser.add_argument('--output-directory',
@@ -425,7 +526,7 @@ def main():
 
   if args.all:
     # Run GN gen if necessary (faster than running "gn gen" in the no-op case).
-    _RunNinja(output_dir, ['build.ninja'])
+    _RunNinja(constants.GetOutDirectory(), ['build.ninja'])
     # Query ninja for all __build_config targets.
     targets = _QueryForAllGnTargets(output_dir)
   else:
@@ -455,47 +556,25 @@ def main():
   project_entries = []
   srcjar_tuples = []
   generated_inputs = []
-  for entry in all_entries:
+  entries = _CombineTestEntries(all_entries)

[agrieve, 2017/01/12 21:28:35]

nit: move this above the "writing gradle files" log

[Peter Wen, 2017/01/18 20:54:41]

Done.

+  for entry in entries:
     if entry.GetType() not in ('android_apk', 'java_library', 'java_binary'):
       continue
 
-    entry_output_dir = os.path.join(gradle_output_dir, entry.GradleSubdir())
+    entry_output_dir = entry.EntryOutputDir(gradle_output_dir)
     relativize = lambda x, d=entry_output_dir: _RebasePath(x, d)
-    build_config = entry.BuildConfig()
-
-    srcjars = _RebasePath(build_config['gradle'].get('bundled_srcjars', []))
-    if not args.use_gradle_process_resources:
-      srcjars += _RebasePath(build_config['javac']['srcjars'])
-
-    java_sources_file = build_config['gradle'].get('java_sources_file')
-    java_files = []
-    if java_sources_file:
-      java_sources_file = _RebasePath(java_sources_file)
-      java_files = build_utils.ReadSourcesList(java_sources_file)
-
-    java_dirs = _CreateJavaSourceDir(output_dir, entry_output_dir, java_files)
-    if srcjars:
-      java_dirs.append(os.path.join(entry_output_dir, _SRCJARS_SUBDIR))
 
-    native_section = build_config.get('native')
-    if native_section:
-      jni_libs = _CreateJniLibsDir(
-          output_dir, entry_output_dir, native_section.get('libraries'))
-    else:
-      jni_libs = []
-
-    data = _GenerateGradleFile(build_config, build_vars, java_dirs, jni_libs,
+    data = _GenerateGradleFile(entry, gradle_output_dir, build_vars,
                                relativize, args.use_gradle_process_resources,
                                jinja_processor)
     if data:
       project_entries.append(entry)
       # Build all paths references by .gradle that exist within output_dir.
-      generated_inputs.extend(srcjars)
-      generated_inputs.extend(p for p in java_files if not p.startswith('..'))
-      generated_inputs.extend(build_config['gradle']['dependent_prebuilt_jars'])
-
+      generated_inputs.extend(entry.GeneratedInputs(
+          args.use_gradle_process_resources))
       srcjar_tuples.extend(
-          (s, os.path.join(entry_output_dir, _SRCJARS_SUBDIR)) for s in srcjars)
+          (s, os.path.join(entry_output_dir, _SRCJARS_SUBDIR))
+          for s in entry.Srcjars(args.use_gradle_process_resources))
       _WriteFile(os.path.join(entry_output_dir, 'build.gradle'), data)
 
   _WriteFile(os.path.join(gradle_output_dir, 'build.gradle'),