[gyp][Android] Implement TestGypAndroid.run_built_executable.

test/lib/TestGyp.py

 # Copyright (c) 2012 Google Inc. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """
 TestGyp.py:  a testing framework for GYP integration tests.
 """
 
 import collections
 from contextlib import contextmanager
@@ skipping 388 matching lines @@
 
   def __init__(self, gyp=None, *args, **kw):
     self.format = kw.pop("format")
     super(TestGypCustom, self).__init__(*args, **kw)
 
 
 class TestGypAndroid(TestGypBase):
   """
   Subclass for testing the GYP Android makefile generator. Note that
   build/envsetup.sh and lunch must have been run before running tests.
-
-  TODO: This is currently an incomplete implementation. We do not support
-  run_built_executable(), so we pass only tests which do not use this. As a
-  result, support for host targets is not properly tested.
   """
   format = 'android'
 
   # Note that we can't use mmm as the build tool because ...
   # - it builds all targets, whereas we need to pass a target
   # - it is a function, whereas the test runner assumes the build tool is a file
   # Instead we use make and duplicate the logic from mmm.
   build_tool_list = ['make']
 
   # We use our custom target 'gyp_all_modules', as opposed to the 'all_modules'
@@ skipping 22 matching lines @@
     for x in ['EXECUTABLES', 'STATIC_LIBRARIES', 'SHARED_LIBRARIES']:
       for d in os.listdir(os.path.join(obj_dir, x)):
         if d.endswith('_gyp_intermediates'):
           shutil.rmtree(os.path.join(obj_dir, x, d), ignore_errors = True)
     for x in [os.path.join('obj', 'lib'), os.path.join('system', 'lib')]:
       for d in os.listdir(os.path.join(out_dir, x)):
         if d.endswith('_gyp.so'):
           os.remove(os.path.join(out_dir, x, d))
 
     super(TestGypAndroid, self).__init__(*args, **kw)
+    self._adb_path = os.path.join(os.environ['ANDROID_HOST_OUT'], 'bin', 'adb')
+    self._device_serial = None
+    adb_devices_out = self._call_adb(['devices'])
+    devices = [l.split()[0] for l in adb_devices_out.splitlines()[1:-1]
+               if l.split()[1] == 'device']
+    if len(devices) == 0:
+      self._device_serial = None
+    else:
+      if len(devices) > 1:
+        self._device_serial = random.choice(devices)
+      else:
+        self._device_serial = devices[0]
+      self._call_adb(['root'])
+    self._to_install = []
 
   def target_name(self, target):
     if target == self.ALL:
       return self.ALL
     # The default target is 'droid'. However, we want to use our special target
     # to build only the gyp target 'all'.
     if target in (None, self.DEFAULT):
       return self.ALL
     return target
 
+  _installable_target_regex = re.compile('target Strip:\s*\S+\s+\((\S+)\)')
+
   def build(self, gyp_file, target=None, **kw):
     """
     Runs a build using the Android makefiles generated from the specified
     gyp_file. This logic is taken from Android's mmm.
     """
     arguments = kw.get('arguments', [])[:]
     arguments.append(self.target_name(target))
     arguments.append('-C')
     arguments.append(os.environ['ANDROID_BUILD_TOP'])
     kw['arguments'] = arguments
     chdir = kw.get('chdir', '')
     makefile = os.path.join(self.workdir, chdir, 'GypAndroid.mk')
     os.environ['ONE_SHOT_MAKEFILE'] = makefile
     result = self.run(program=self.build_tool, **kw)
+    for l in self.stdout().splitlines():
+      target_result = TestGypAndroid._installable_target_regex.match(l)
+      if target_result:
+        self._to_install.append(os.path.abspath(os.path.join(
+            os.environ['ANDROID_BUILD_TOP'], target_result.group(1))))
     del os.environ['ONE_SHOT_MAKEFILE']
     return result
 
   def android_module(self, group, name, subdir):
     if subdir:
       name = '%s_%s' % (subdir, name)
     if group == 'SHARED_LIBRARIES':
       name = 'lib_%s' % name
     return '%s_gyp' % name
 
@@ skipping 23 matching lines @@
       module_name = self.android_module(group, name, subdir)
       return os.path.join(self.intermediates_dir(group, module_name),
                           '%s.a' % module_name)
     if type == self.SHARED_LIB:
       group = 'SHARED_LIBRARIES'
       module_name = self.android_module(group, name, subdir)
       return os.path.join(self.intermediates_dir(group, module_name), 'LINKED',
                           '%s.so' % module_name)
     assert False, 'Unhandled type'
 
+  def _call_adb(self, command):
+    """ Calls the provided adb command.
+
+    If the command fails, the test fails.
+
+    Args:
+      command: The adb command to call.
+    Returns:
+      The command's output.
+    """
+    with tempfile.TemporaryFile(bufsize=0) as adb_out:
+      with tempfile.TemporaryFile(bufsize=0) as adb_err:
+        adb_command = [self._adb_path]
+        if self._device_serial:
+          adb_command += ['-s', self._device_serial]
+        adb_command += command
+        if subprocess.call(adb_command, stdout=adb_out, stderr=adb_err) != 0:

[jbudorick, 2014/06/11 16:30:22]

(tests should fail here for nonzero exit codes)

+          print '%s failed:' % ' '.join(adb_command)
+          print self.banner('STDOUT ')
+          adb_out.seek(0)
+          print adb_out.read()
+          print self.banner('STDERR ')
+          adb_err.seek(0)
+          print adb_err.read()
+          self.fail_test()
+        else:
+          adb_out.seek(0)
+          output = adb_out.read()
+          return output
+
   def run_built_executable(self, name, *args, **kw):
     """
     Runs an executable program built from a gyp-generated configuration.
+    """
+    match = kw.pop('match', self.match)
 
-    This is not correctly implemented for Android. For now, we simply check
-    that the executable file exists.
-    """
-    # Running executables requires a device. Even if we build for target x86,
-    # the binary is not built with the correct toolchain options to actually
-    # run on the host.
+    executable_file = self.built_file_path(name, type=self.EXECUTABLE, **kw)
+    if executable_file not in self._to_install:
+      self.fail_test()
 
-    # Copied from TestCommon.run()
-    match = kw.pop('match', self.match)
-    status = None
-    if os.path.exists(self.built_file_path(name)):
-      status = 1
-    self._complete(None, None, None, None, status, match)
+    if not self._device_serial:
+      self.skip_test(message='No devices attached.\n')
+
+    storage = self._call_adb(['shell', 'echo', '$ANDROID_DATA']).strip()
+    if not len(storage):
+      self.fail_test()
+
+    installed = []
+    try:
+      for i in self._to_install:
+        a = os.path.abspath(
+            os.path.join(os.environ['ANDROID_BUILD_TOP'], i))
+        dest = '%s/%s' % (storage, os.path.basename(a))
+        self._call_adb(['push', os.path.abspath(a), dest])
+        installed.append(dest)
+        if i == executable_file:
+          device_executable = dest
+          self._call_adb(['shell', 'chmod', '755', device_executable])
+
+      out = self._call_adb(
+          ['shell', 'LD_LIBRARY_PATH=$LD_LIBRARY_PATH:%s' % storage,
+           device_executable])
+      out = out.replace('\r\n', '\n')
+      self._complete(out, kw.pop('stdout', None), None, None, None, match)

[Torne, 2014/06/11 12:44:18]

Is there a way to return the program's exit status here?

[jbudorick, 2014/06/11 16:30:22]

If a program exits with a nonzero exit code, _call_adb should cause the test to
fail. (See above.) Do we need to be more specific?

[Torne, 2014/06/11 16:41:39]

adb does not return the error code of the program run by adb shell, it always
returns 0 unless adb itself failed. To get the error code you need to wrap the
program itself in a script that prints $? after it exits and parse the output to
retrieve it, as far as I know. This is done in various places in chromium :/

In theory the gyp tests could test the specific error code returned by the
program. I guess they probably don't currently, but it's supported by the test
framework being used here.

Whether it's worth it probably depends how difficult it is..

+    finally:
+      if len(installed):
+        self._call_adb(['shell', 'rm'] + installed)
 
   def match_single_line(self, lines = None, expected_line = None):
     """
     Checks that specified line appears in the text.
     """
     for line in lines.split('\n'):
         if line == expected_line:
             return 1
     return
 
@@ skipping 671 matching lines @@
 
 def TestGyp(*args, **kw):
   """
   Returns an appropriate TestGyp* instance for a specified GYP format.
   """
   format = kw.pop('format', os.environ.get('TESTGYP_FORMAT'))
   for format_class in format_class_list:
     if format == format_class.format:
       return format_class(*args, **kw)
   raise Exception, "unknown format %r" % format