from _core.constants import DeviceLabelType
from _core.constants import SchedulerType
from _core.constants import HostDrivenTestType
from _core.constants import ListenerType
from _core.executor.concurrent import Concurrent
from _core.executor.concurrent import DriversThread
from _core.executor.concurrent import QueueMonitorThread
from _core.executor.source import TestSetSource
from _core.executor.source import find_test_descriptors
from _core.executor.source import find_testdict_descriptors
from _core.logger import platform_logger
from _core.logger import add_task_file_handler
from _core.logger import remove_task_file_handler
__all__ = ["Scheduler"]
LOG = platform_logger("Scheduler")
@Plugin(type=Plugin.SCHEDULER, id=SchedulerType.scheduler)
class Scheduler(object):
"""
The Scheduler is the main entry point for client code that wishes to
discover and execute tests.
"""
# factory params
is_execute = True
terminate_result = queue.Queue()
upload_address = ""
task_type = ""
task_name = ""
mode = ""
from _core.constants import SchedulerType
from _core.constants import ToolCommandType
from _core.environment.manager_env import EnvironmentManager
from _core.exception import ParamError
from _core.exception import ExecuteTerminate
from _core.executor.request import Task
from _core.executor.scheduler import Scheduler
from _core.logger import platform_logger
from _core.plugin import Plugin
from _core.plugin import get_plugin
from _core.utils import SplicingAction
from _core.utils import get_instance_name
__all__ = ["Console"]
LOG = platform_logger("Console")
try:
if platform.system() != 'Windows':
import readline
except ModuleNotFoundError:
LOG.warning("readline module is not exist.")
class Console(object):
"""
Class representing an console for executing test.
Main xDevice console providing user with the interface to interact
"""
__instance = None
def __new__(cls, *args, **kwargs):
import os
import shutil
import time
import zipfile
from ast import literal_eval
from _core.logger import platform_logger
from _core.report.encrypt import check_pub_key_exist
from _core.report.encrypt import do_rsa_encrypt
from _core.report.encrypt import get_file_summary
from _core.report.reporter_helper import DataHelper
from _core.report.reporter_helper import VisionHelper
from _core.report.reporter_helper import ReportConstant
LOG = platform_logger("ResultReporter")
class ResultReporter:
def __init__(self, report_path, task_info):
self.report_path = report_path
self.task_info = task_info
self.data_helper = DataHelper()
self.vision_helper = VisionHelper()
self.summary_data_path = os.path.join(
self.report_path, ReportConstant.summary_data_report)
self.exec_info = task_info
def generate_reports(self):
LOG.info("")
LOG.info("**************************************************")
from _core.plugin import Plugin
from _core.plugin import get_plugin
from _core.logger import platform_logger
from _core.report.reporter_helper import DataHelper
from _core.testkit.json_parser import JsonParser
from _core.testkit.kit_lite import DeployKit
from _core.utils import get_config_value
from _core.utils import get_kit_instances
from _core.utils import check_result_report
from _core.utils import get_device_log_file
from _core.utils import get_filename_extension
from _core.utils import get_file_absolute_path
from _core.utils import get_test_component_version
__all__ = ["CppTestDriver", "CTestDriver", "init_remote_server"]
LOG = platform_logger("DriversLite")
FAILED_RUN_TEST_ATTEMPTS = 2
def get_nfs_server(request):
config_manager = UserConfigManager(env=request.config.test_environment)
remote_info = config_manager.get_user_config("testcases/server",
filter_name="NfsServer")
if not remote_info:
err_msg = "The name of remote nfs server does not match"
LOG.error(err_msg)
raise TypeError(err_msg)
return remote_info
def init_remote_server(lite_instance, request=None):
from _core.constants import CKit
from _core.constants import ComType
from _core.constants import DeviceLiteKernel
from _core.constants import DeviceTestType
from _core.exception import LiteDeviceMountError
from _core.exception import ParamError
from _core.interface import ITestKit
from _core.utils import get_config_value
from _core.utils import get_file_absolute_path
from _core.utils import get_local_ip
from _core.utils import get_test_component_version
from _core.exception import LiteDeviceConnectError
from _core.constants import DeviceLabelType
__all__ = ["DeployKit", "MountKit", "RootFsKit", "QueryKit"]
LOG = platform_logger("KitLite")
RESET_CMD = "0xEF, 0xBE, 0xAD, 0xDE, 0x0C, 0x00, 0x87, 0x78, 0x00, 0x00, " \
"0x61, 0x94"
@Plugin(type=Plugin.TEST_KIT, id=CKit.deploy)
class DeployKit(ITestKit):
def __init__(self):
self.burn_file = ""
self.burn_command = ""
self.timeout = ""
self.paths = ""
def __check_config__(self, config):
self.timeout = str(
# 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 os
import time
from enum import Enum
from threading import RLock
from _core.logger import platform_logger
from _core.report.encrypt import check_pub_key_exist
from _core.report.reporter_helper import DataHelper
from _core.report.reporter_helper import ReportConstant
LOG = platform_logger("SuiteReporter")
SUITE_REPORTER_LOCK = RLock()
class ResultCode(Enum):
UNKNOWN = -1010
PASSED = 0
FAILED = 1
SKIPPED = 2
class SuiteReporter:
suite_list = []
suite_report_result = []
failed_case_list = []
#
import datetime
import os
from _core.exception import ParamError
from _core.executor.source import TestSource
from _core.logger import platform_logger
from _core.plugin import Config
from _core.plugin import Plugin
from _core.plugin import get_plugin
from _core.testkit.json_parser import JsonParser
from _core.utils import get_kit_instances
__all__ = ["Descriptor", "Task", "Request"]
LOG = platform_logger("Request")
class Descriptor:
"""
The descriptor for a test or suite
"""
def __init__(self, uuid=None, name=None, source=None, container=False):
self.unique_id = uuid
self.display_name = name
self.tags = {}
self.source = source
self.parent = None
self.children = []
self.container = container
from _core.constants import DeviceOsType
from _core.constants import ComType
from _core.constants import DeviceLabelType
from _core.environment.dmlib_lite import LiteHelper
from _core.exception import LiteDeviceConnectError
from _core.exception import ParamError
from _core.exception import DeviceError
from _core.interface import IDevice
from _core.exception import ExecuteTerminate
from _core.logger import platform_logger
from _core.environment.manager_env import DeviceAllocationState
from _core.plugin import Plugin
from _core.utils import exec_cmd
LOG = platform_logger("DeviceLite")
TIMEOUT = 90
HDC = "litehdc.exe"
def get_hdc_path():
from xdevice import Variables
user_path = os.path.join(Variables.exec_dir, "resource/tools")
top_user_path = os.path.join(Variables.top_dir, "config")
config_path = os.path.join(Variables.res_dir, "config")
paths = [user_path, top_user_path, config_path]
file_path = ""
for path in paths:
if os.path.exists(os.path.abspath(os.path.join(path, HDC))):
file_path = os.path.abspath(os.path.join(path, HDC))
# limitations under the License.
#
import os
import shutil
import threading
import time
from concurrent.futures import ThreadPoolExecutor
from concurrent.futures import wait
from _core.executor.request import Request
from _core.logger import platform_logger
from _core.plugin import Config
from _core.utils import get_instance_name
LOG = platform_logger("Concurrent")
class Concurrent:
@classmethod
def executor_callback(cls, worker):
worker_exception = worker.exception()
if worker_exception:
LOG.error("Worker return exception: {}".format(worker_exception))
@classmethod
def concurrent_execute(cls, func, params_list, max_size=8):
"""
Provider the ability to execute target function concurrently
:param func: target function name
:param params_list: the list of params in these target functions
from _core.plugin import Plugin
from _core.constants import ListenerType
from _core.interface import LifeCycle
from _core.interface import IListener
from _core.logger import platform_logger
from _core.report.result_reporter import ResultReporter
from _core.report.suite_reporter import SuiteReporter
from _core.report.suite_reporter import ResultCode
from _core.report.encrypt import check_pub_key_exist
__all__ = ["LogListener", "ReportListener", "UploadListener",
"CollectingTestListener", "CollectingLiteGTestListener",
"CaseResult", "SuiteResult", "SuitesResult", "StateRecorder",
"TestDescription"]
LOG = platform_logger("Listener")
@dataclass
class CaseResult:
index = ""
code = ResultCode.FAILED.value
test_name = None
test_class = None
stacktrace = ""
run_time = 0
is_completed = False
num_tests = 0
current = 0
def is_running(self):
import time
from _core.config.config_manager import UserConfigManager
from _core.constants import DeviceOsType
from _core.constants import ManagerType
from _core.environment.manager_env import DeviceAllocationState
from _core.exception import LiteDeviceConnectError
from _core.exception import ParamError
from _core.plugin import Plugin
from _core.plugin import get_plugin
from _core.interface import IDeviceManager
from _core.logger import platform_logger
__all__ = ["ManagerLite"]
LOG = platform_logger("ManagerLite")
@Plugin(type=Plugin.MANAGER, id=ManagerType.lite_device)
class ManagerLite(IDeviceManager):
"""
Class representing device manager
managing the set of available devices for testing
"""
def __init__(self):
self.devices_list = []
def init_environment(self, environment=""):
device_lite = get_plugin(plugin_type=Plugin.DEVICE,
plugin_id=DeviceOsType.lite)[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 os
from _core.exception import ParamError
from _core.logger import platform_logger
from _core.plugin import Config
__all__ = ["JsonParser"]
LOG = platform_logger("JsonParser")
class JsonParser:
"""
This class parses json files or string, sample:
{
"description": "Config for lite cpp test cases",
"environment": [
{
"type": "device",
"label": "ipcamera"
}
],
"kits": [
{
_CTEST_END_TEST_RUN_TAG = "Framework finished."
_CTEST_SUITE_TEST_RUN_TAG = "Start to run test suite:"
_CTEST_SUITE_TIME_RUN_TAG = "Run test suite "
_CTEST_SETUP_TAG = "setup"
_CTEST_RUN_TAG = "-----------------------"
_TEST_PASSED_LOWER = "test pass"
_COMPILE_PASSED = "compile PASSED"
_COMPILE_PARA = r"(.* compile .*)"
_PRODUCT_PARA = r"(.*The .* is .*)"
_PRODUCT_PARA_START = r"To Obtain Product Params Start"
_PRODUCT_PARA_END = r"To Obtain Product Params End"
LOG = platform_logger("ParserLite")
@Plugin(type=Plugin.PARSER, id=ParserType.cpp_test_lite)
class CppTestParserLite(IParser):
def __init__(self):
self.state_machine = StateRecorder()
self.suite_name = ""
self.listeners = []
self.product_params = {}
self.is_params = False
def get_suite_name(self):
return self.suite_name
def get_listeners(self):
from _core.constants import DeviceLabelType
from _core.driver.drivers_lite import init_remote_server
from _core.exception import DeviceError
from _core.exception import ParamError
from _core.exception import ReportException
from _core.exception import ExecuteTerminate
from _core.interface import IDriver
from _core.logger import platform_logger
from _core.plugin import Plugin
from _core.testkit.json_parser import JsonParser
from _core.utils import get_config_value
from _core.utils import get_kit_instances
from _core.utils import check_result_report
from _core.report.suite_reporter import SuiteReporter
LOG = platform_logger("DeviceTest")
def start_task(test_file, configs, device, logger):
from xdevice import Variables
# insert& devicetest path for loading devicetest module
devicetest_module = os.path.join(Variables.modules_dir, "_devicetest")
if os.path.exists(devicetest_module):
sys.path.insert(1, devicetest_module)
if configs["testcases_path"]:
sys.path.insert(1, configs["testcases_path"])
from _devicetest.devicetest.main import DeviceTest
device_test = DeviceTest(test_list=test_file, configs=configs,
devices=[device], log=logger)
from _core.exception import LiteDeviceExecuteCommandError
from _core.logger import platform_logger
__all__ = ["generate_report", "LiteHelper"]
CPP_TEST_STANDARD_SIGN = "[==========]"
CPP_TEST_END_SIGN = "Global test environment tear-down"
CPP_SYS_STANDARD_SIGN = " #"
CPP_ERR_MESSAGE = "[ERR]No such file or directory: "
TIMEOUT = 90
CTEST_STANDARD_SIGN = "Start to run test suite"
AT_CMD_ENDS = "OK"
CTEST_END_SIGN = "Framework finished."
PATTERN = re.compile(r'\x1B(\[([0-9]{1,2}(;[0-9]{1,2})*)?m)*')
LOG = platform_logger("DmlibLite")
def check_read_test_end(result=None, input_command=None):
if input_command not in result:
return False
index = result.find(input_command) + len(input_command)
result_output = result[index:]
if input_command.startswith("./"):
if result_output.find(CPP_TEST_STANDARD_SIGN) != -1:
if result_output.count(CPP_TEST_STANDARD_SIGN) == 2 or \
result_output.find(CPP_TEST_END_SIGN) != -1:
return True
if result_output.find(CPP_TEST_STANDARD_SIGN) == -1 and \
("test pass" in result_output.lower() or
"test fail" in result_output.lower()):
# See the License for the specific language governing permissions and
# limitations under the License.
#
import os
import hashlib
from _core.logger import platform_logger
__all__ = [
"check_pub_key_exist", "do_rsa_encrypt", "do_rsa_decrypt",
"generate_key_file", "get_file_summary"
]
PUBLIC_KEY_FILE = "config/pub.key"
LOG = platform_logger("Encrypt")
def check_pub_key_exist():
from xdevice import Variables
if Variables.report_vars.pub_key_file is not None:
if Variables.report_vars.pub_key_file == "":
return False
if not os.path.exists(Variables.report_vars.pub_key_file):
Variables.report_vars.pub_key_file = None
return False
return True
pub_key_path = os.path.join(Variables.exec_dir, PUBLIC_KEY_FILE)
if os.path.exists(pub_key_path):
Variables.report_vars.pub_key_file = pub_key_path
#
# 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 os
import xml.etree.ElementTree as ElementTree
from _core.logger import platform_logger
LOG = platform_logger("ResourceManager")
DEFAULT_TIMEOUT = "300"
class ResourceManager(object):
def __init__(self):
pass
def get_resource_data(self, xml_filepath, target_name):
data_dic = {}
if os.path.exists(xml_filepath):
data_dic = self._parse_test_xml_file(xml_filepath, target_name)
return data_dic
def _parse_test_xml_file(self, filepath, targetname):
data_dic = {}
import argparse
import subprocess
import signal
import uuid
import json
from tempfile import NamedTemporaryFile
from _core.executor.listener import SuiteResult
from _core.driver.parser_lite import ShellHandler
from _core.exception import ParamError
from _core.logger import platform_logger
from _core.report.suite_reporter import SuiteReporter
from _core.plugin import get_plugin
from _core.plugin import Plugin
LOG = platform_logger("Utils")
def get_filename_extension(file_path):
_, fullname = os.path.split(file_path)
filename, ext = os.path.splitext(fullname)
return filename, ext
def unique_id(type_name, value):
return "{}_{}_{:0>8}".format(type_name, value,
str(uuid.uuid1()).split("-")[0])
def start_standing_subprocess(cmd, pipe=subprocess.PIPE, return_result=False):
"""Starts a non-blocking subprocess that is going to continue running after
TEST_TYPE_DICT = {"DEX": DeviceTestType.dex_test,
"HAP": DeviceTestType.hap_test,
"APK": DeviceTestType.hap_test,
"PYT": HostDrivenTestType.device_test,
"JST": DeviceTestType.jsunit_test,
"CXX": DeviceTestType.cpp_test,
"BIN": DeviceTestType.lite_cpp_test}
EXT_TYPE_DICT = {".dex": DeviceTestType.dex_test,
".hap": DeviceTestType.hap_test,
".apk": DeviceTestType.hap_test,
".py": HostDrivenTestType.device_test,
".js": DeviceTestType.jsunit_test,
".bin": DeviceTestType.lite_cpp_test,
"default": DeviceTestType.cpp_test}
MODULE_CONFIG_SUFFIX = ".json"
LOG = platform_logger("TestSource")
def find_test_descriptors(config):
if config.testfile == "" and config.testlist == "" and config.task == "":
return None
# get test sources
testcases_dirs = _get_testcases_dirs(config)
test_sources = _get_test_sources(config, testcases_dirs)
LOG.debug("test sources: %s", test_sources)
# normalize test sources
test_sources = _normalize_test_sources(testcases_dirs, test_sources)
# make test descriptors
# See the License for the specific language governing permissions and
# limitations under the License.
#
import os
import platform
import time
from ast import literal_eval
from dataclasses import dataclass
from xml.etree import ElementTree
from _core.logger import platform_logger
from _core.report.encrypt import check_pub_key_exist
from _core.report.encrypt import do_rsa_encrypt
LOG = platform_logger("ReporterHelper")
@dataclass
class ReportConstant:
# report name constants
summary_data_report = "summary_report.xml"
summary_vision_report = "summary_report.html"
details_vision_report = "details_report.html"
failures_vision_report = "failures_report.html"
summary_ini = "summary.ini"
summary_report_hash = "summary_report.hash"
title_name = "title_name"
summary_title = "Summary Report"
details_title = "Details Report"
failures_title = "Failures Report"
