#!/usr/bin/env python3
#
# Copyright (C) 2020 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.
#
import logging
import os
import posixpath as target_path_module
import sys
import unittest
from vts.testcases.vndk import utils
from vts.testcases.vndk.golden import vndk_data
from vts.utils.python.vndk import vndk_utils
class VtsVndkFilesTest(unittest.TestCase):
"""A test for VNDK files and directories.
Attributes:
_dut: The AndroidDevice under test.
_vndk_version: The VNDK version of the device.
"""
# Some LL-NDK libraries may load the implementations with the same names
# from /vendor/lib. Since a vendor may install an implementation of an
# LL-NDK library with the same name, testNoLlndkInVendor doesn't raise
# errors on these LL-NDK libraries.
_LL_NDK_COLLIDING_NAMES = ("libEGL.so", "libGLESv1_CM.so", "libGLESv2.so",
"libGLESv3.so")
_TARGET_ODM_LIB = "/odm/{LIB}"
_TARGET_VENDOR_LIB = "/vendor/{LIB}"
def setUp(self):
"""Initializes attributes."""
serial_number = os.environ.get("ANDROID_SERIAL")
self.assertTrue(serial_number, "$ANDROID_SERIAL is empty.")
self._dut = utils.AndroidDevice(serial_number)
self.assertTrue(self._dut.IsRoot(), "This test requires adb root.")
self._vndk_version = self._dut.GetVndkVersion()
def _ListFiles(self, dir_path):
"""Lists all files in a directory except subdirectories.
Args:
dir_path: A string, path to the directory on device.
Returns:
A list of strings, the file paths in the directory.
"""
if not self._dut.Exists(dir_path):
logging.info("%s not found", dir_path)
return []
return self._dut.FindFiles(dir_path, "*", "!", "-type", "d")
def _Fail(self, unexpected_paths):
"""Logs error and fails current test.
Args:
unexpected_paths: A list of strings, the paths to be shown in the
log message.
"""
logging.error("Unexpected files:\n%s", "\n".join(unexpected_paths))
assert_lines = unexpected_paths[:20]
if len(unexpected_paths) > 20:
assert_lines.append("...")
assert_lines.append(
"Total number of errors: %d" % len(unexpected_paths))
self.fail("\n".join(assert_lines))
def _TestVndkDirectory(self, vndk_dir, vndk_list_names):
"""Verifies that the VNDK directory doesn't contain extra files.
Args:
vndk_dir: The path to the VNDK directory on device.
vndk_list_names: Strings, the categories of the VNDK libraries
that can be in the directory.
"""
vndk_lists = vndk_data.LoadVndkLibraryListsFromResources(
self._vndk_version, *vndk_list_names)
self.assertTrue(vndk_lists, "Cannot load VNDK library lists.")
vndk_set = set().union(*vndk_lists)
logging.debug("vndk set: %s", vndk_set)
unexpected = [x for x in self._ListFiles(vndk_dir) if
target_path_module.basename(x) not in vndk_set]
if unexpected:
self._Fail(unexpected)
def _TestNotInVndkDirecotory(self, vndk_dir, vndk_list_names, except_libs):
"""Verifies that VNDK directory doesn't contain specific files.
Args:
vndk_dir, The path to the VNDK directory on device.
vndk_list_names: A list of strings, the categories of the VNDK
libraries that should not be in the directory.
except_libs: A set of strings, the file names of the libraries that
are exceptions to this test.
"""
vndk_lists = vndk_data.LoadVndkLibraryListsFromResources(
self._vndk_version, *vndk_list_names)
self.assertTrue(vndk_lists, "Cannot load VNDK library lists.")
vndk_set = set().union(*vndk_lists)
vndk_set.difference_update(except_libs)
logging.debug("vndk set: %s", vndk_set)
unexpected = [x for x in self._ListFiles(vndk_dir) if
target_path_module.basename(x) in vndk_set]
if unexpected:
self._Fail(unexpected)
def _TestVndkCoreDirectory(self, bitness):
"""Verifies that VNDK directory doesn't contain extra files."""
if not vndk_utils.IsVndkRuntimeEnforced(self._dut):
logging.info("Skip the test as VNDK runtime is not enforced on "
"the device.")
return
self._TestVndkDirectory(
vndk_utils.GetVndkDirectory(bitness, self._vndk_version),
(vndk_data.VNDK, vndk_data.VNDK_PRIVATE, vndk_data.VNDK_SP,
vndk_data.VNDK_SP_PRIVATE,))
def testVndkCoreDirectory32(self):
"""Runs _TestVndkCoreDirectory for 32-bit libraries."""
self._TestVndkCoreDirectory(32)
def testVndkCoreDirectory64(self):
"""Runs _TestVndkCoreDirectory for 64-bit libraries."""
if self._dut.GetCpuAbiList(64):
self._TestVndkCoreDirectory(64)
else:
logging.info("Skip the test as the device doesn't support 64-bit "
"ABI.")
def _TestNoLlndkInVendor(self, bitness):
"""Verifies that vendor partition has no LL-NDK libraries."""
self._TestNotInVndkDirecotory(
vndk_utils.FormatVndkPath(self._TARGET_VENDOR_LIB, bitness),
(vndk_data.LL_NDK,),
self._LL_NDK_COLLIDING_NAMES)
def testNoLlndkInVendor32(self):
"""Runs _TestNoLlndkInVendor for 32-bit libraries."""
self._TestNoLlndkInVendor(32)
def testNoLlndkInVendor64(self):
"""Runs _TestNoLlndkInVendor for 64-bit libraries."""
if self._dut.GetCpuAbiList(64):
self._TestNoLlndkInVendor(64)
else:
logging.info("Skip the test as the device doesn't support 64-bit "
"ABI.")
def _TestNoLlndkInOdm(self, bitness):
"""Verifies that odm partition has no LL-NDK libraries."""
self._TestNotInVndkDirecotory(
vndk_utils.FormatVndkPath(self._TARGET_ODM_LIB, bitness),
(vndk_data.LL_NDK,),
self._LL_NDK_COLLIDING_NAMES)
def testNoLlndkInOdm32(self):
"""Runs _TestNoLlndkInOdm for 32-bit libraries."""
self._TestNoLlndkInOdm(32)
def testNoLlndkInOdm64(self):
"""Runs _TestNoLlndkInOdm for 64-bit libraries."""
if self._dut.GetCpuAbiList(64):
self._TestNoLlndkInOdm(64)
else:
logging.info("Skip the test as the device doesn't support 64-bit "
"ABI.")
if __name__ == "__main__":
# The logs are written to stdout so that TradeFed test runner can parse the
# results from stderr.
logging.basicConfig(stream=sys.stdout)
# Setting verbosity is required to generate output that the TradeFed test
# runner can parse.
unittest.main(verbosity=3)