[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_PREFIX = 'Install: '
+
   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():
+      if l.startswith(TestGypAndroid._INSTALLABLE_PREFIX):
+        self._to_install.append(os.path.abspath(os.path.join(
+            os.environ['ANDROID_BUILD_TOP'],
+            l[len(TestGypAndroid._INSTALLABLE_PREFIX):])))
     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
 
   def intermediates_dir(self, group, module_name):
     return os.path.join(os.environ['ANDROID_PRODUCT_OUT'], 'obj', group,
                         '%s_intermediates' % module_name)
 
   def built_file_path(self, name, type=None, **kw):
     """
     Returns a path to the specified file name, of the specified type,
     as built by Android. Note that we don't support the configuration
     parameter.
     """
     # Built files are in $ANDROID_PRODUCT_OUT. This requires copying logic from
     # the Android build system.
-    if type == None:
+    if type == None or type == self.EXECUTABLE:
       return os.path.join(os.environ['ANDROID_PRODUCT_OUT'], 'obj', 'GYP',
                           'shared_intermediates', name)
     subdir = kw.get('subdir')
-    if type == self.EXECUTABLE:
-      # We don't install executables
-      group = 'EXECUTABLES'
-      module_name = self.android_module(group, name, subdir)
-      return os.path.join(self.intermediates_dir(group, module_name), name)
     if type == self.STATIC_LIB:
       group = 'STATIC_LIBRARIES'
       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:
+          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)
+    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