build/android/pylib/gtest/test_package_apk.py

   1 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4
   5 """Defines TestPackageApk to help run APK-based native tests."""
   6 # pylint: disable=W0212
   7
   8 import logging
   9 import os
  10 import shlex
  11 import sys
  12 import tempfile
  13 import time
  14
  15 from pylib import android_commands
  16 from pylib import constants
  17 from pylib import pexpect
  18 from pylib.device import device_errors
  19 from pylib.device import intent
  20 from pylib.gtest import gtest_test_instance
  21 from pylib.gtest.test_package import TestPackage
  22
  23
  24 class TestPackageApk(TestPackage):
  25   """A helper class for running APK-based native tests."""
  26
  27   def __init__(self, suite_name):
  28     """
  29     Args:
  30       suite_name: Name of the test suite (e.g. base_unittests).
  31     """
  32     TestPackage.__init__(self, suite_name)
  33     if suite_name == 'content_browsertests':
  34       self.suite_path = os.path.join(
  35           constants.GetOutDirectory(), 'apks', '%s.apk' % suite_name)
  36       self._package_info = constants.PACKAGE_INFO['content_browsertests']
  37     else:
  38       self.suite_path = os.path.join(
  39           constants.GetOutDirectory(), '%s_apk' % suite_name,
  40           '%s-debug.apk' % suite_name)
  41       self._package_info = constants.PACKAGE_INFO['gtest']
  42
  43   def _CreateCommandLineFileOnDevice(self, device, options):
  44     device.WriteFile(self._package_info.cmdline_file,
  45                      self.suite_name + ' ' + options)
  46
  47   def _GetFifo(self):
  48     # The test.fifo path is determined by:
  49     # testing/android/java/src/org/chromium/native_test/
  50     #     ChromeNativeTestActivity.java and
  51     # testing/android/native_test_launcher.cc
  52     return '/data/data/' + self._package_info.package + '/files/test.fifo'
  53
  54   def _ClearFifo(self, device):
  55     device.RunShellCommand('rm -f ' + self._GetFifo())
  56
  57   def _WatchFifo(self, device, timeout, logfile=None):
  58     for i in range(100):
  59       if device.FileExists(self._GetFifo()):
  60         logging.info('Fifo created. Slept for %f secs' % (i * 0.5))
  61         break
  62       time.sleep(0.5)
  63     else:
  64       raise device_errors.DeviceUnreachableError(
  65           'Unable to find fifo on device %s ' % self._GetFifo())
  66     args = shlex.split(device.old_interface.Adb()._target_arg)
  67     args += ['shell', 'cat', self._GetFifo()]
  68     return pexpect.spawn('adb', args, timeout=timeout, logfile=logfile)
  69
  70   def _StartActivity(self, device, force_stop=True):
  71     device.StartActivity(
  72         intent.Intent(package=self._package_info.package,
  73                       activity=self._package_info.activity,
  74                       action='android.intent.action.MAIN'),
  75         # No wait since the runner waits for FIFO creation anyway.
  76         blocking=False,
  77         force_stop=force_stop)
  78
  79   #override
  80   def ClearApplicationState(self, device):
  81     device.ClearApplicationState(self._package_info.package)
  82     # Content shell creates a profile on the sdscard which accumulates cache
  83     # files over time.
  84     if self.suite_name == 'content_browsertests':
  85       try:
  86         device.RunShellCommand(
  87             'rm -r %s/content_shell' % device.GetExternalStoragePath(),
  88             timeout=60 * 2)
  89       except device_errors.CommandFailedError:
  90         # TODO(jbudorick) Handle this exception appropriately once the
  91         #                 conversions are done.
  92         pass
  93
  94   #override
  95   def CreateCommandLineFileOnDevice(self, device, test_filter, test_arguments):
  96     self._CreateCommandLineFileOnDevice(
  97         device, '--gtest_filter=%s %s' % (test_filter, test_arguments))
  98
  99   #override
 100   def GetAllTests(self, device):
 101     self._CreateCommandLineFileOnDevice(device, '--gtest_list_tests')
 102     try:
 103       self.tool.SetupEnvironment()
 104       # Clear and start monitoring logcat.
 105       self._ClearFifo(device)
 106       self._StartActivity(device)
 107       # Wait for native test to complete.
 108       p = self._WatchFifo(device, timeout=30 * self.tool.GetTimeoutScale())
 109       p.expect('<<ScopedMainEntryLogger')
 110       p.close()
 111     finally:
 112       self.tool.CleanUpEnvironment()
 113     # We need to strip the trailing newline.
 114     content = [line.rstrip() for line in p.before.splitlines()]
 115     return gtest_test_instance.ParseGTestListTests(content)
 116
 117   #override
 118   def SpawnTestProcess(self, device):
 119     try:
 120       self.tool.SetupEnvironment()
 121       self._ClearFifo(device)
 122       # Doesn't need to stop an Activity because ClearApplicationState() is
 123       # always called before this call and so it is already stopped at this
 124       # point.
 125       self._StartActivity(device, force_stop=False)
 126     finally:
 127       self.tool.CleanUpEnvironment()
 128     logfile = android_commands.NewLineNormalizer(sys.stdout)
 129     return self._WatchFifo(device, timeout=10, logfile=logfile)
 130
 131   #override
 132   def Install(self, device):
 133     self.tool.CopyFiles(device)
 134     device.Install(self.suite_path)