| #!/usr/bin/env python |
| # |
| # Copyright 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. |
| # |
| |
| # Create the configuration files for a hidl hal test. |
| # This script copy a template which contains Android.mk and AndroidTest.xml |
| # files under test/vts-testcases/hal/ based on the hal package name. |
| |
| import datetime |
| import os |
| import sys |
| |
| from build.vts_spec_parser import VtsSpecParser |
| from xml.dom import minidom |
| from xml.etree import cElementTree as ET |
| from xml.sax.saxutils import unescape |
| |
| VTS_TEST_CASE_PATH = 'test/vts-testcase/hal' |
| HAL_INTERFACE_PATH = 'hardware/interfaces' |
| HAL_TRACE_PATH = 'test/vts-testcase/hal-trace' |
| HAL_PACKAGE_PREFIX = 'android.hardware.' |
| |
| ANDROID_MK_FILE_NAME = 'Android.mk' |
| ANDROID_TEST_XML_FILE_NAME = 'AndroidTest.xml' |
| |
| |
| class TestCaseCreator(object): |
| """Init a test case directory with helloworld test case. |
| |
| Attributes: |
| hal_package_name: string, package name of the testing hal. e.g. android.hardware.nfc@1.0. |
| hal_name: name of the testing hal, derived from hal_package_name. e.g. nfc. |
| hal_version: version of the testing hal, derived from hal_package_name. |
| test_type: string, type of the test, currently support host and target. |
| test_name_prefix: prefix of generated test name. e.g. android.hardware.nfc@1.0-test-target. |
| test_name: test name generated. e.g. android.hardware.nfc@1.0-test-target-profiling. |
| test_plan: string, the plan that the test belongs to. |
| test_dir: string, test case absolute directory. |
| time_out: string, timeout of the test, default is 1m. |
| is_profiling: boolean, whether to create a profiling test case. |
| stop_runtime: boolean whether to stop framework before the test. |
| build_top: string, equal to environment variable ANDROID_BUILD_TOP. |
| vts_spec_parser: tools that generates and parses vts spec with hidl-gen. |
| current_year: current year. |
| """ |
| |
| def __init__(self, vts_spec_parser, hal_package_name): |
| '''Initialize class attributes.''' |
| self._hal_package_name = hal_package_name |
| |
| build_top = os.getenv('ANDROID_BUILD_TOP') |
| if not build_top: |
| print('Error: Missing ANDROID_BUILD_TOP env variable. Please run ' |
| '\'. build/envsetup.sh; lunch <build target>\' Exiting...') |
| sys.exit(1) |
| self._build_top = build_top |
| self._vts_spec_parser = vts_spec_parser |
| |
| [package, version] = hal_package_name.split('@') |
| self._hal_name = package[len(HAL_PACKAGE_PREFIX):] |
| self._hal_version = version |
| |
| self._current_year = datetime.datetime.now().year |
| |
| def LaunchTestCase(self, |
| test_type, |
| time_out='1m', |
| is_profiling=False, |
| is_replay=False, |
| stop_runtime=False, |
| update_only=False): |
| """Create the necessary configuration files to launch a test case. |
| |
| Args: |
| test_type: type of the test. |
| time_out: timeout of the test. |
| is_profiling: whether to create a profiling test case. |
| stop_runtime: whether to stop framework before the test. |
| update_only: flag to only update existing test configure. |
| |
| Returns: |
| boolean, whether created/updated a test case successfully. |
| """ |
| self._test_type = test_type |
| self._time_out = time_out |
| self._is_profiling = is_profiling |
| self._is_replay = is_replay |
| self._stop_runtime = stop_runtime |
| |
| self._test_module_name = self.GetVtsHalTestModuleName() |
| self._test_name = self._test_module_name |
| self._test_plan = 'vts-staging-default' |
| if is_replay: |
| self._test_name = self._test_module_name + 'Replay' |
| self._test_plan = 'vts-hal-replay' |
| if is_profiling: |
| self._test_name = self._test_module_name + 'Profiling' |
| self._test_plan = 'vts-hal-profiling' |
| |
| self._test_dir = self.GetHalTestCasePath() |
| # Check whether the host side test script and target test binary is available. |
| if self._test_type == 'host': |
| test_script_file = self.GetVtsHostTestScriptFileName() |
| if not os.path.exists(test_script_file): |
| print('Could not find the host side test script: %s.' % |
| test_script_file) |
| return False |
| else: |
| test_binary_file = self.GetVtsTargetTestSourceFileName() |
| if not os.path.exists(test_binary_file): |
| print('Could not find the target side test binary: %s.' % |
| test_binary_file) |
| return False |
| |
| if os.path.exists(self._test_dir): |
| print 'WARNING: Test directory already exists. Continuing...' |
| elif not update_only: |
| try: |
| os.makedirs(self._test_dir) |
| except: |
| print('Error: Failed to create test directory at %s. ' |
| 'Exiting...' % self.test_dir) |
| return False |
| else: |
| print('WARNING: Test directory does not exists, stop updating.') |
| return True |
| |
| self.CreateAndroidMk() |
| self.CreateAndroidTestXml() |
| return True |
| |
| def GetVtsTargetTestSourceFileName(self): |
| """Get the name of target side test source file .""" |
| test_binary_name = self._test_module_name + 'Test.cpp' |
| return os.path.join(self.GetHalInterfacePath(), 'vts/functional', |
| test_binary_name) |
| |
| def GetVtsHostTestScriptFileName(self): |
| """Get the name of host side test script file .""" |
| test_script_name = self._test_module_name + 'Test.py' |
| return os.path.join( |
| self.GetHalTestCasePath(ignore_profiling=True), test_script_name) |
| |
| def GetVtsHalTestModuleName(self): |
| """Get the test model name with format VtsHalHalNameVersionTestType.""" |
| sub_names = self._hal_name.split('.') |
| hal_name_upper_camel = ''.join(x.title() for x in sub_names) |
| return 'VtsHal' + hal_name_upper_camel + self.GetHalVersionToken( |
| ) + self._test_type.title() |
| |
| def GetVtsHalReplayTraceFiles(self): |
| """Get the trace files for replay test.""" |
| trace_files = [] |
| for filename in os.listdir(self.GetHalTracePath()): |
| if filename.endswith(".trace"): |
| trace_files.append(filename) |
| return trace_files |
| |
| def GetHalPath(self): |
| """Get the hal path based on hal name.""" |
| return self._hal_name.replace('.', '/') |
| |
| def GetHalVersionToken(self): |
| """Get a string of the hal version.""" |
| return 'V' + self._hal_version.replace('.', '_') |
| |
| def GetHalInterfacePath(self): |
| """Get the directory that stores the .hal files.""" |
| return os.path.join(self._build_top, HAL_INTERFACE_PATH, |
| self.GetHalPath(), self._hal_version) |
| |
| def GetHalTestCasePath(self, ignore_profiling=False): |
| """Get the directory that stores the test case.""" |
| test_dir = self._test_type |
| if self._is_replay: |
| test_dir = test_dir + '_replay' |
| if self._is_profiling and not ignore_profiling: |
| test_dir = test_dir + '_profiling' |
| return os.path.join(self._build_top, VTS_TEST_CASE_PATH, |
| self.GetHalPath(), |
| self.GetHalVersionToken(), test_dir) |
| |
| def GetHalTracePath(self): |
| """Get the directory that stores the hal trace files.""" |
| return os.path.join(self._build_top, HAL_TRACE_PATH, |
| self.GetHalPath(), self.GetHalVersionToken()) |
| |
| def CreateAndroidMk(self): |
| """Create Android.mk.""" |
| vts_dir = os.path.join(self._build_top, VTS_TEST_CASE_PATH) |
| target = os.path.join(self._test_dir, ANDROID_MK_FILE_NAME) |
| |
| with open(target, 'w') as f: |
| print 'Creating %s' % target |
| f.write(LICENSE_STATEMENT_POUND.format(year=self._current_year)) |
| f.write('\n') |
| f.write( |
| ANDROID_MK_TEMPLATE.format( |
| test_name=self._test_name, |
| config_src_dir=self._test_dir[len(vts_dir) + 1:])) |
| |
| def CreateAndroidTestXml(self): |
| """Create AndroidTest.xml.""" |
| VTS_FILE_PUSHER = 'com.android.compatibility.common.tradefed.targetprep.VtsFilePusher' |
| VTS_TEST_CLASS = 'com.android.tradefed.testtype.VtsMultiDeviceTest' |
| |
| configuration = ET.Element('configuration', { |
| 'description': 'Config for VTS ' + self._test_name + ' test cases' |
| }) |
| |
| ET.SubElement(configuration, 'option', { |
| 'name': 'config-descriptor:metadata', |
| 'key': 'plan', |
| 'value': self._test_plan |
| }) |
| |
| file_pusher = ET.SubElement(configuration, 'target_preparer', |
| {'class': VTS_FILE_PUSHER}) |
| |
| self.GeneratePushFileConfigure(file_pusher) |
| test = ET.SubElement(configuration, 'test', {'class': VTS_TEST_CLASS}) |
| |
| self.GenerateTestOptionConfigure(test) |
| |
| target = os.path.join(self._test_dir, ANDROID_TEST_XML_FILE_NAME) |
| with open(target, 'w') as f: |
| print 'Creating %s' % target |
| f.write(XML_HEADER) |
| f.write(LICENSE_STATEMENT_XML.format(year=self._current_year)) |
| f.write(self.Prettify(configuration)) |
| |
| def GeneratePushFileConfigure(self, file_pusher): |
| """Create the push file configuration within AndroidTest.xml |
| |
| Args: |
| file_pusher: parent xml element for push file configure. |
| """ |
| ET.SubElement(file_pusher, 'option', |
| {'name': 'abort-on-push-failure', |
| 'value': 'false'}) |
| |
| if self._test_type == 'target': |
| if self._is_replay: |
| ET.SubElement(file_pusher, 'option', { |
| 'name': 'push-group', |
| 'value': 'HalHidlHostTest.push' |
| }) |
| elif self._is_profiling: |
| ET.SubElement(file_pusher, 'option', { |
| 'name': 'push-group', |
| 'value': 'HalHidlTargetProfilingTest.push' |
| }) |
| else: |
| ET.SubElement(file_pusher, 'option', { |
| 'name': 'push-group', |
| 'value': 'HalHidlTargetTest.push' |
| }) |
| else: |
| if self._is_profiling: |
| ET.SubElement(file_pusher, 'option', { |
| 'name': 'push-group', |
| 'value': 'HalHidlHostProfilingTest.push' |
| }) |
| else: |
| ET.SubElement(file_pusher, 'option', { |
| 'name': 'push-group', |
| 'value': 'HalHidlHostTest.push' |
| }) |
| |
| imported_package_lists = self._vts_spec_parser.ImportedPackagesList( |
| self._hal_name, self._hal_version) |
| imported_package_lists.append(self._hal_package_name) |
| # Generate additional push files e.g driver/profiler/vts_spec |
| if self._test_type == 'host' or self._is_replay: |
| ET.SubElement(file_pusher, 'option', |
| {'name': 'cleanup', |
| 'value': 'true'}) |
| for imported_package in imported_package_lists: |
| if imported_package.startswith(HAL_PACKAGE_PREFIX): |
| imported_package_str, imported_package_version = imported_package.split( |
| '@') |
| imported_package_name = imported_package_str[len( |
| HAL_PACKAGE_PREFIX):] |
| imported_vts_spec_lists = self._vts_spec_parser.VtsSpecNames( |
| imported_package_name, imported_package_version) |
| for vts_spec in imported_vts_spec_lists: |
| push_spec = VTS_SPEC_PUSH_TEMPLATE.format( |
| hal_path=imported_package_name.replace('.', '/'), |
| hal_version=imported_package_version, |
| package_path=imported_package_str.replace('.', |
| '/'), |
| vts_file=vts_spec) |
| ET.SubElement(file_pusher, 'option', |
| {'name': 'push', |
| 'value': push_spec}) |
| |
| dirver_package_name = imported_package + '-vts.driver.so' |
| push_driver = VTS_LIB_PUSH_TEMPLATE_32.format( |
| lib_name=dirver_package_name) |
| ET.SubElement(file_pusher, 'option', |
| {'name': 'push', |
| 'value': push_driver}) |
| push_driver = VTS_LIB_PUSH_TEMPLATE_64.format( |
| lib_name=dirver_package_name) |
| ET.SubElement(file_pusher, 'option', |
| {'name': 'push', |
| 'value': push_driver}) |
| |
| if self._is_profiling: |
| if self._test_type == 'target': |
| ET.SubElement(file_pusher, 'option', |
| {'name': 'cleanup', |
| 'value': 'true'}) |
| for imported_package in imported_package_lists: |
| if imported_package.startswith(HAL_PACKAGE_PREFIX): |
| profiler_package_name = imported_package + '-vts.profiler.so' |
| push_profiler = VTS_LIB_PUSH_TEMPLATE_32.format( |
| lib_name=profiler_package_name) |
| ET.SubElement(file_pusher, 'option', |
| {'name': 'push', |
| 'value': push_profiler}) |
| push_profiler = VTS_LIB_PUSH_TEMPLATE_64.format( |
| lib_name=profiler_package_name) |
| ET.SubElement(file_pusher, 'option', |
| {'name': 'push', |
| 'value': push_profiler}) |
| |
| def GenerateTestOptionConfigure(self, test): |
| """Create the test option configuration within AndroidTest.xml |
| |
| Args: |
| test: parent xml element for test option configure. |
| """ |
| ET.SubElement(test, 'option', |
| {'name': 'test-module-name', |
| 'value': self._test_name}) |
| |
| if self._test_type == 'target': |
| if self._is_replay: |
| ET.SubElement(test, 'option', { |
| 'name': 'binary-test-type', |
| 'value': 'hal_hidl_replay_test' |
| }) |
| for trace in self.GetVtsHalReplayTraceFiles(): |
| ET.SubElement( |
| test, |
| 'option', { |
| 'name': 'hal-hidl-replay-test-trace-path', |
| 'value': TEST_TRACE_TEMPLATE.format( |
| hal_path=self.GetHalPath(), |
| hal_version=self.GetHalVersionToken(), |
| trace_file=trace) |
| }) |
| ET.SubElement(test, 'option', { |
| 'name': 'hal-hidl-package-name', |
| 'value': self._hal_package_name |
| }) |
| else: |
| test_binary = TEST_BINEARY_TEMPLATE_32.format( |
| test_name=self._test_module_name + 'Test') |
| ET.SubElement(test, 'option', { |
| 'name': 'binary-test-source', |
| 'value': test_binary |
| }) |
| test_binary = TEST_BINEARY_TEMPLATE_64.format( |
| test_name=self._test_module_name + 'Test') |
| ET.SubElement(test, 'option', { |
| 'name': 'binary-test-source', |
| 'value': test_binary |
| }) |
| ET.SubElement(test, 'option', { |
| 'name': 'binary-test-type', |
| 'value': 'hal_hidl_gtest' |
| }) |
| if self._stop_runtime: |
| ET.SubElement(test, 'option', { |
| 'name': 'binary-test-disable-framework', |
| 'value': 'true' |
| }) |
| ET.SubElement(test, 'option', { |
| 'name': 'binary-test-stop-native-servers', |
| 'value': 'true' |
| }) |
| else: |
| test_script = TEST_SCRIPT_TEMPLATE.format( |
| hal_path=self.GetHalPath(), |
| hal_version=self.GetHalVersionToken(), |
| test_name=self._test_module_name + 'Test') |
| ET.SubElement(test, 'option', |
| {'name': 'test-case-path', |
| 'value': test_script}) |
| |
| if self._is_profiling: |
| ET.SubElement(test, 'option', |
| {'name': 'enable-profiling', |
| 'value': 'true'}) |
| |
| ET.SubElement(test, 'option', { |
| 'name': 'precondition-lshal', |
| 'value': self._hal_package_name |
| }) |
| ET.SubElement(test, 'option', |
| {'name': 'test-timeout', |
| 'value': self._time_out}) |
| |
| def Prettify(self, elem): |
| """Create a pretty-printed XML string for the Element. |
| |
| Args: |
| elem: a xml element. |
| |
| Regurns: |
| A pretty-printed XML string for the Element. |
| """ |
| if elem: |
| doc = minidom.Document() |
| declaration = doc.toxml() |
| rough_string = ET.tostring(elem, 'utf-8') |
| reparsed = minidom.parseString(rough_string) |
| return unescape( |
| reparsed.toprettyxml(indent=" ")[len(declaration) + 1:]) |
| |
| |
| LICENSE_STATEMENT_POUND = """# |
| # Copyright (C) {year} 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. |
| # |
| """ |
| |
| LICENSE_STATEMENT_XML = """<!-- Copyright (C) {year} 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. |
| --> |
| """ |
| |
| ANDROID_MK_TEMPLATE = """LOCAL_PATH := $(call my-dir) |
| |
| include $(CLEAR_VARS) |
| |
| LOCAL_MODULE := {test_name} |
| VTS_CONFIG_SRC_DIR := testcases/hal/{config_src_dir} |
| include test/vts/tools/build/Android.host_config.mk |
| """ |
| |
| XML_HEADER = """<?xml version="1.0" encoding="utf-8"?> |
| """ |
| |
| TEST_BINEARY_TEMPLATE_32 = '_32bit::DATA/nativetest/{test_name}/{test_name}' |
| TEST_BINEARY_TEMPLATE_64 = '_64bit::DATA/nativetest64/{test_name}/{test_name}' |
| |
| TEST_SCRIPT_TEMPLATE = 'vts/testcases/hal/{hal_path}/{hal_version}/host/{test_name}' |
| TEST_TRACE_TEMPLATE = 'test/vts-testcase/hal-trace/{hal_path}/{hal_version}/{trace_file}' |
| VTS_SPEC_PUSH_TEMPLATE = ( |
| 'spec/hardware/interfaces/{hal_path}/{hal_version}/vts/{vts_file}->' |
| '/data/local/tmp/spec/{package_path}/{hal_version}/{vts_file}') |
| VTS_LIB_PUSH_TEMPLATE_32 = 'DATA/lib/{lib_name}->/data/local/tmp/32/{lib_name}' |
| VTS_LIB_PUSH_TEMPLATE_64 = 'DATA/lib64/{lib_name}->/data/local/tmp/64/{lib_name}' |
