xref: /frameworks/rs/tests/lldb/tests/harness/util_bundle.py

# Copyright (C) 2016 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

'''Module that contains the class UtilBundle, representing a collection of RS
binaries.'''

from __future__ import absolute_import

import os
import time
from . import util_constants
from . import util_log
from .exception import TestSuiteException


class UtilBundle(object):
    '''Represents the collection of RS binaries that are debugged.'''

    # Map of binary name to package name of all Java apps debugged
    _tests_apk = {
        'JavaInfiniteLoop': 'com.android.rs.infiniteloop',
        'JavaDebugWaitAttach': 'com.android.rs.waitattachdebug',
        'JavaNoDebugWaitAttach': 'com.android.rs.waitattachnodebug',
        'BranchingFunCalls': 'com.android.rs.branchingfuncalls',
        'KernelVariables': 'com.android.rs.kernelvariables',
        'Allocations': 'com.android.rs.allocations',
        'MultipleRSFiles': 'com.android.rs.multiplersfiles',
        'SingleSource': 'com.android.rs.singlesource',
        'ScriptGroup': 'com.android.rs.scriptgroup',
        'Reduction': 'com.android.rs.lldbreductiontest',
    }

    _tests_jni = {
        'JNIInfiniteLoop': 'com.android.rs.jniinfiniteloop',
        'JNIDebugWaitAttach': 'com.android.rs.jnidebugwaitattach',
        'JNINoDebugWaitAttach': 'com.android.rs.jninodebugwaitattach',
        'JNIBranchingFunCalls': 'com.android.rs.jnibranchingfuncalls',
        'JNIKernelVariables': 'com.android.rs.jnikernelvariables',
        'JNIAllocations': 'com.android.rs.jniallocations',
        'JNIMultipleRSFiles': 'com.android.rs.jnimultiplersfiles'
    }

    _tests_ndk = {'CppInfiniteLoop', 'CppNoDebugWaitAttach',
                  'CppDebugWaitAttach', 'CppBranchingFunCalls',
                  'CppKernelVariables', 'CppAllocations', 'CppMultipleRSFiles'}

    _missing_path_msg = (
        'No product path has been provided. If using `lunch` ensure '
        'the `ANDROID_PRODUCT_OUT` environment variable has been set correctly. '
        'Alternatively, include it in the config file or specify it explicitly '
        'on the command line (`--aosp-product-path`)'
    )

    def __init__(self, android, aosp_product_path):
        assert android
        self._android = android # Link to the android module
        self._aosp_product_path = aosp_product_path
        self._log = util_log.get_logger()

    def is_apk(self, name):
        '''Checks if a binary of a given name is an apk.

        Checks whether the name of the apk is in the dictionary of apks.

        Args:
            name: The string that is the name of the binary to check.

        Returns:
            True if the binary is an apk, False if it is not.

        Raises:
            TestSuiteException: The string does not match any item in the list
            of APK or NDK binaries.
        '''
        if name in self._tests_apk:
            return True
        if name not in self._tests_ndk and name not in self._tests_jni:
            raise TestSuiteException('test not apk or ndk')
        return False

    def uninstall_all(self):
        '''Uninstall/Delete all the testsuite's apks and binaries on the device.

        Raises:
            TestSuiteException: One or more apks could not be uninstalled.
        '''
        self.uninstall_all_apk()
        self._delete_all_ndk()
        self._uninstall_all_jni()

    def uninstall_all_apk(self):
        '''Uninstall all apks used by the test suite from the device.

        Raises:
            TestSuiteException: An apk could not be uninstalled.
        '''
        max_num_attempts = 3
        timeout = 180

        for app, package in self._tests_apk.items():
            self._log.info('Uninstalling the application: %s', app)
            output = self._android.adb_retry('uninstall ' + package,
                                             max_num_attempts, timeout)

            if output is None:
                raise TestSuiteException('Repeated timeouts when uninstalling '
                                         'the application: ' + app)
            elif 'Success' not in output:
                outmsg = '\n' + output.rstrip() if output else '<empty>'
                self._log.error('Cannot match the string "Success" in the '
                                'output: %s', outmsg)
                raise TestSuiteException('Unable to uninstall app ' + app)
            else:
                self._log.debug('Application uninstalled: %r', app)

            if 'Success' not in output:
                self._log.warning('unable to uninstall app ' + app)

    def _uninstall_all_jni(self):
        '''Uninstall all apks used by the test suite from the device.

        Raises:
            TestSuiteException: An apk could not be uninstalled.
        '''
        for app, package in self._tests_jni.items():
            output = self._android.adb('uninstall ' + package)

            if 'Success' not in output:
                raise TestSuiteException('unable to uninstall app ' + app)

    def _delete_all_ndk(self):
        '''Delete all ndk binaries that were pushed to the device.

        Raises:
            TestSuiteException: A binary could not be deleted from the device.
        '''
        for app in self._tests_ndk:
            output = self._android.shell('rm /data/' + app)
            if 'No such file or directory' in output:
                self._log.warning('unable to uninstall app ' + app)


    def push_all(self):
        '''Push all apk and ndk binaries required by the testsuite to the device

        Raises:
            TestSuiteException: One or more apks could not be installed or
                                previously running processes thereof could not
                                be killed.
        '''
        self._push_all_java()
        self._push_all_ndk()
        self._push_all_jni()

    def _install_apk(self, app, package):
        '''Push an apk files to the device.

        This involves uninstalling any old installation and installing again.

        Args:
            app: A string that is the name of the apk.
            package: A string that is the name of the package of the apk.

        Raises:
            TestSuiteException: The apk could not be installed.
        '''
        self._log.info('pushing {0}'.format(app))

        self._android.stop_app(package)

        self._android.adb('uninstall ' + package)
        # Ignore the output of uninstall.
        # The app may not have been installed in the first place. That's ok.

        flags = ''

        product_folder = self._aosp_product_path
        if not product_folder:
            raise TestSuiteException(self._missing_path_msg)

        app_folder = os.path.join(product_folder, 'data/app')

        cmd = 'install {0} {1}/{2}/{2}.apk'.format(flags, app_folder, app)
        output = self._android.adb(cmd, False, True,
                                   util_constants.PUSH_TIMEOUT)
        if ('Success' not in output) or ("can't find" in output):
            raise TestSuiteException('unable to install app {}: {}'.format(
                app, output))

    def _push_all_java(self):
        '''Push all apk files to the device.

        This involves uninstalling any old installations and installing again.

        Raises:
            TestSuiteException: An apk could not be installed.
        '''
        for app, package in self._tests_apk.items():
            self._install_apk(app, package)

    def _push_all_ndk(self):
        '''Push all ndk binaries to the device.

        Raises:
            TestSuiteException: A binary could not be pushed to the device or
                                a previous process could not be killed.
        '''
        product_folder = self._aosp_product_path
        if not product_folder:
            raise TestSuiteException(self._missing_path_msg)

        bin_folder = os.path.join(product_folder, 'system/bin')

        for app in self._tests_ndk:
            self._log.info('pushing {0}'.format(app))

            self._android.kill_all_processes(app)

            cmd = 'push %s/%s /data' % (bin_folder, app)
            output = self._android.adb(cmd, False, True,
                                       util_constants.PUSH_TIMEOUT)
            if ('failed to copy' in output or
                'No such file or directory' in output):
                raise TestSuiteException('unable to push binary ' + app)

            # be sure to set the execute bit for NDK binaries
            self._android.shell('chmod 777 /data/{0}'.format(app))

    def _push_all_jni(self):
        '''Push all JNI apk files to the device.

        This involves uninstalling any old installations and installing again.

        Raises:
            TestSuiteException: An apk could not be installed.
        '''
        product_folder = self._aosp_product_path
        if not product_folder:
            raise TestSuiteException(self._missing_path_msg)

        app_folder = os.path.join(product_folder, 'system/lib')

        # Ensure the system/lib directory is writable
        self._android.make_device_writeable()

        for app, package in self._tests_jni.items():
            self._install_apk(app, package)

    def delete_ndk_cache(self):
        '''Deletes NDK cached scripts from the device.

        The NDK caches compiled scripts as shared libraries in
        the folder specified when calling `rs->init()`.

        For all out tests this is set to '/data/rscache'.
        '''
        self._android.shell('rm -r /data/rscache')

    def get_package(self, app_name):
        '''From a given apk name get the name of its package.

        Args:
            app_name: The string that is the name of the apk.

        Returns:
            A string representing the name of the package of the app.

        Raises:
            TestSuiteException: The app name is not in the list of apks.
        '''
        if app_name in self._tests_apk:
            return self._tests_apk[app_name]
        elif app_name in self._tests_jni:
            return self._tests_jni[app_name]
        else:
            msg = ('unknown app %s. (Do you need to add an '
                  'entry to bundle.py :: test_apps_?)' % app_name)
            raise TestSuiteException(msg)
        return self._tests_apk[app_name]

    def launch(self, app_name):
        '''Launch an apk/ndk app on a remote device.

        Args:
            app_name: The string that is the name of the APK or NDK executable.

        Returns:
            The Process ID of the launched executable, otherwise None

        Raises:
            TestSuiteException: Previous processes of this apk could not be
                                killed.
        '''
        process_name = ''
        success = False
        if app_name in self._tests_apk:
            process_name = self._tests_apk[app_name]

            self._android.kill_all_processes(process_name)

            success = self._android.launch_app(process_name, 'MainActivity')
        elif app_name in self._tests_ndk:
            process_name = app_name
            self._android.kill_all_processes(process_name)
            success = self._android.launch_elf(process_name)
        elif app_name in self._tests_jni:
            package = self._tests_jni[app_name]

            self._android.kill_process(package)

            success = self._android.launch_app(package, 'MainActivity')
            if not success:
                self._log.log_and_print(app_name +
                    ' is not installed. Try removing the --no-install option?')
                return None

            return self._android.find_app_pid(package)
        else:
            self._log.error('Executable {0} neither Java nor NDK.'
                            .format(app_name))

            self._log.fatal('Failed to launch test executable {0}'
                            .format(app_name))
            return None

        if not success:
            self._log.log_and_print(app_name +
                ' is not installed. Try removing the --no-install option?')
            return None

        return self._android.find_app_pid(process_name)

    def check_apps_installed(self, java_only):
        ''' Check whether all Java/JNI/NDK apps are installed on the device.

        Args:
            java_only: Boolean to specify whether only the Java apks should be
                       checked (in case of --wimpy mode for example).

        Raises:
            TestSuiteException: Not all apps are installed.
        '''
        java_and_jni_apks = self._tests_apk.copy()

        if not java_only:
            java_and_jni_apks.update(self._tests_jni)

        installed = self._android.shell('pm list packages -f')

        for app, package in java_and_jni_apks.items():
            if package not in installed:
                raise TestSuiteException('apk %s is not installed.' % app)

        if not java_only:
            ls_data = self._android.shell('ls /data')
            for app in self._tests_ndk:
                if app not in ls_data:
                    raise TestSuiteException('app %s is not installed.' % app)