You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
219 lines
8.2 KiB
219 lines
8.2 KiB
#
|
|
# Copyright (C) 2017 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 json
|
|
import logging
|
|
|
|
from vts.runners.host import const
|
|
from vts.runners.host import errors
|
|
from vts.runners.host import keys
|
|
from vts.utils.python.file import target_file_utils
|
|
from vts.utils.python.hal import hal_service_name_utils
|
|
|
|
|
|
def CanRunHidlHalTest(test_instance,
|
|
dut,
|
|
shell=None,
|
|
run_as_compliance_test=False):
|
|
"""Checks HAL precondition of a test instance.
|
|
|
|
Args:
|
|
test_instance: the test instance which inherits BaseTestClass.
|
|
dut: the AndroidDevice under test.
|
|
shell: the ShellMirrorObject to execute command on the device.
|
|
If not specified, the function creates one from dut.
|
|
run_as_compliance_test: boolean, whether it is a compliance test.
|
|
|
|
Returns:
|
|
True if the precondition is satisfied; False otherwise.
|
|
"""
|
|
if shell is None:
|
|
dut.shell.InvokeTerminal("check_hal_preconditions")
|
|
shell = dut.shell.check_hal_preconditions
|
|
|
|
opt_params = [
|
|
keys.ConfigKeys.IKEY_ABI_BITNESS,
|
|
keys.ConfigKeys.IKEY_PRECONDITION_HWBINDER_SERVICE,
|
|
keys.ConfigKeys.IKEY_PRECONDITION_FILE_PATH_PREFIX,
|
|
keys.ConfigKeys.IKEY_PRECONDITION_LSHAL,
|
|
]
|
|
test_instance.getUserParams(opt_param_names=opt_params)
|
|
|
|
bitness = str(getattr(test_instance, keys.ConfigKeys.IKEY_ABI_BITNESS, ""))
|
|
|
|
hwbinder_service_name = str(
|
|
getattr(test_instance,
|
|
keys.ConfigKeys.IKEY_PRECONDITION_HWBINDER_SERVICE, ""))
|
|
if hwbinder_service_name:
|
|
if not hwbinder_service_name.startswith("android.hardware."):
|
|
logging.error("The given hwbinder service name %s is invalid.",
|
|
hwbinder_service_name)
|
|
else:
|
|
cmd_results = shell.Execute("ps -A")
|
|
hwbinder_service_name += "@"
|
|
if (any(cmd_results[const.EXIT_CODE]) or
|
|
hwbinder_service_name not in cmd_results[const.STDOUT][0]):
|
|
logging.warn("The required hwbinder service %s not found.",
|
|
hwbinder_service_name)
|
|
return False
|
|
|
|
file_path_prefix = getattr(test_instance, "file_path_prefix", "")
|
|
if file_path_prefix and bitness:
|
|
logging.debug("FILE_PATH_PREFIX: %s", file_path_prefix)
|
|
logging.debug("Test bitness: %s", bitness)
|
|
tag = "_" + bitness + "bit"
|
|
if tag in file_path_prefix:
|
|
for path_prefix in file_path_prefix[tag]:
|
|
if not target_file_utils.Exists(path_prefix, shell):
|
|
msg = (
|
|
"The required file (prefix: {}) for {}-bit testcase "
|
|
"not found.").format(path_prefix, bitness)
|
|
logging.warn(msg)
|
|
return False
|
|
|
|
hal = str(
|
|
getattr(test_instance, keys.ConfigKeys.IKEY_PRECONDITION_LSHAL, ""))
|
|
if hal:
|
|
testable, _ = hal_service_name_utils.GetHalServiceName(
|
|
shell, hal, bitness, run_as_compliance_test)
|
|
return testable
|
|
|
|
logging.debug("Precondition check pass.")
|
|
return True
|
|
|
|
def CheckFeaturePrecondition(test_instance, dut, shell=None):
|
|
"""Checks feature precondition of a test instance.
|
|
|
|
Args:
|
|
test_instance: the test instance which inherits BaseTestClass.
|
|
dut: the AndroidDevice under test.
|
|
shell: the ShellMirrorObject to execute command on the device.
|
|
If not specified, the function creates one from dut.
|
|
|
|
Returns:
|
|
True if the devise has the required feature; False otherwise.
|
|
"""
|
|
opt_params = [
|
|
keys.ConfigKeys.IKEY_PRECONDITION_FEATURE,
|
|
]
|
|
test_instance.getUserParams(opt_param_names=opt_params)
|
|
|
|
feature = str(
|
|
getattr(test_instance, keys.ConfigKeys.IKEY_PRECONDITION_FEATURE, ""))
|
|
if feature:
|
|
# If system is not running, needs to start the framework first.
|
|
if not dut.isFrameworkRunning():
|
|
if not dut.start():
|
|
logging.warn("Failed to start Android framework.")
|
|
return False
|
|
|
|
if shell is None:
|
|
dut.shell.InvokeTerminal("check_feature_precondition")
|
|
shell = dut.shell.check_feature_precondition
|
|
|
|
cmd_results = shell.Execute("LD_LIBRARY_PATH= pm list features")
|
|
if (any(cmd_results[const.EXIT_CODE])
|
|
or feature not in cmd_results[const.STDOUT][0]):
|
|
logging.warn("The required feature %s not found.", feature)
|
|
return False
|
|
logging.debug("Feature precondition check pass.")
|
|
return True
|
|
|
|
def MeetFirstApiLevelPrecondition(test_instance, dut=None):
|
|
"""Checks first API level precondition of a test instance.
|
|
|
|
If the device's ro.product.first_api_level is 0, this function checks
|
|
ro.build.version.sdk.
|
|
|
|
Args:
|
|
test_instance: the test instance which inherits BaseTestClass.
|
|
dut: the AndroidDevice under test.
|
|
|
|
Returns:
|
|
True if the device's first API level is greater than or equal to the
|
|
value of the precondition; False otherwise.
|
|
"""
|
|
opt_params = [keys.ConfigKeys.IKEY_PRECONDITION_FIRST_API_LEVEL]
|
|
test_instance.getUserParams(opt_param_names=opt_params)
|
|
if not hasattr(test_instance,
|
|
keys.ConfigKeys.IKEY_PRECONDITION_FIRST_API_LEVEL):
|
|
return True
|
|
|
|
precond_level_attr = getattr(
|
|
test_instance, keys.ConfigKeys.IKEY_PRECONDITION_FIRST_API_LEVEL, 0)
|
|
try:
|
|
precond_level = int(precond_level_attr)
|
|
except ValueError:
|
|
logging.error("Cannot parse first API level precondition: %s",
|
|
precond_level_attr)
|
|
return True
|
|
|
|
if not dut:
|
|
logging.debug("Read first API level from the first device.")
|
|
dut = test_instance.android_devices[0]
|
|
device_level = dut.getLaunchApiLevel(strict=False)
|
|
if not device_level:
|
|
logging.error("Cannot read first API level from device. "
|
|
"Assume it meets the precondition.")
|
|
return True
|
|
|
|
logging.debug("Device's first API level=%d; precondition=%d", device_level,
|
|
precond_level)
|
|
return device_level >= precond_level
|
|
|
|
|
|
def CheckSysPropPrecondition(test_instance, dut, shell=None):
|
|
"""Checks sysprop precondition of a test instance.
|
|
|
|
Args:
|
|
test_instance: the test instance which inherits BaseTestClass.
|
|
dut: the AndroidDevice under test.
|
|
shell: the ShellMirrorObject to execute command on the device.
|
|
If not specified, the function creates one from dut.
|
|
|
|
Returns:
|
|
False if precondition is not met (i.e., to skip tests),
|
|
True otherwise (e.g., when no sysprop precondition is set;
|
|
the precondition is satisfied;
|
|
there is an error in retrieving the target sysprop; or
|
|
the specified sysprop is undefined)
|
|
"""
|
|
if not hasattr(test_instance, keys.ConfigKeys.IKEY_PRECONDITION_SYSPROP):
|
|
return True
|
|
|
|
precond_sysprop = str(
|
|
getattr(test_instance, keys.ConfigKeys.IKEY_PRECONDITION_SYSPROP, ''))
|
|
if "=" not in precond_sysprop:
|
|
logging.error("precondition-sysprop value is invalid.")
|
|
return True
|
|
|
|
if shell is None:
|
|
dut.shell.InvokeTerminal("check_sysprop_precondition")
|
|
shell = dut.shell.check_sysprop_precondition
|
|
|
|
sysprop_key, sysprop_value = precond_sysprop.split('=')
|
|
cmd_results = shell.Execute('getprop %s' % sysprop_key)
|
|
if any(cmd_results[const.EXIT_CODE]):
|
|
logging.error('Failed to read sysprop:\n%s', sysprop_key)
|
|
return True
|
|
else:
|
|
value = cmd_results[const.STDOUT][0].strip()
|
|
if len(value) == 0:
|
|
return True
|
|
elif value != sysprop_value:
|
|
return False
|
|
return True
|