def convert_parameter_value(self,
tc_param_value,
tc_param_name,
default_cast_type=str):
"""
convert value according to a cast type
This function returns the value of a parameter.
:type tc_param_value: string
:param tc_param_value: value to convert
:type default_cast_type: type object
:param default_cast_type: type to cast (int, str, list ...)
By default cast into str type.
:rtype: depends on default_cast_type
:return: test case parameter value
"""
if default_cast_type == "str_to_bool":
if Utils.is_bool(str(tc_param_value)):
tc_param_value = Utils.str_to_bool(str(tc_param_value))
else:
self._logger.warning(
"%s='%s', invalid value in campaign for test %s" %
(tc_param_name, tc_param_value, self._name))
tc_param_value = None
elif default_cast_type is int or default_cast_type is float:
if Utils.is_number(str(tc_param_value)):
tc_param_value = default_cast_type(str(tc_param_value))
else:
tc_param_value = None
else:
tc_param_value = default_cast_type(tc_param_value)
return tc_param_value
def _get_ucase_class_from_ucase(self, ucase):
"""
This function gets the use case class from the use case name.
:type ucase: string
:param ucase: use case name
:rtype: object
:return: use case class
"""
if not self._ucase_catalogs:
error_msg = "No use case catalog has been found!"
raise AcsConfigException(AcsConfigException.FILE_NOT_FOUND,
error_msg)
ucase_dic = self._ucase_catalogs.get(ucase)
if not ucase_dic:
error_msg = "Use case {0} not found in UC catalog!".format(ucase)
raise AcsConfigException(AcsConfigException.XML_PARSING_ERROR,
error_msg)
# Presence of ClassName element is already checked by CatalogParser using xsd
ucase_class_name = ucase_dic.get(CatalogParser.CLASSNAME_ELEM)
ucase_class = Utils.get_class(ucase_class_name)
return ucase_class
def run(self, context):
"""
Display an image given in parameter on host screen using Tkinter
"""
TestStepBase.run(self, context)
host_screen = Util.str_to_bool(
DeviceManager().get_device_config("PHONE1").get(
"DisplayScreenAvailable", "False"))
if host_screen is not None and host_screen:
# On windows, Tk main window must be instanciated here, otherwise
# an exception will be raise.
if platform.system() == "Windows":
self.__root = Tkinter.Tk()
self.__root.attributes("-fullscreen", True)
wthread = Thread(target=self.__start_tk_thread)
wthread.start()
wthread.join(0.2)
while not self.__root.attributes("-fullscreen"):
wthread.join(0.1)
self._logger.debug("Tk main window loaded")
wimgthread = Thread(target=self.__show_tk_img)
wimgthread.start()
context.set_info("DisplayImageOnHost_Event", self.__event)
else:
self._logger.info(
"Host screen not available, nothing will be displayed")
def _extract_cts_results_summary(self, cts_result_file_path):
"""
Extract summary report data from CTS XML report:
<Summary failed="0" notExecuted="0" timeout="0" pass="******" />
:return:
"""
verdict = Global.SUCCESS
msg = ""
try:
tree = et.parse(cts_result_file_path)
self._logger.debug("CTS - Parsing of the CTS report XML file completed")
except et.XMLSyntaxError:
error_msg = "CTS report file: " + str(cts_result_file_path) + \
"- parsing-reading issue (exception= " + str(Utils.format_exception_info()) + ")"
raise AcsToolException(AcsToolException.XML_PARSING_ERROR, error_msg)
summary = tree.find('Summary')
if summary is not None:
failed_t = int(summary.get("failed"))
not_executed_t = int(summary.get("notExecuted"))
timeout_t = int(summary.get("timeout"))
passed_t = int(summary.get("pass"))
msg = "CTS results Summary: failed=%s notExecuted=%s timeout=%s pass=%s"\
%(failed_t, not_executed_t, timeout_t, passed_t)
if (failed_t + not_executed_t + timeout_t) > 0:
verdict = Global.FAILURE
else:
verdict = Global.FAILURE
msg = "Summary section was not found in CTS result XML file: %s" %cts_result_file_path
return verdict, msg
def _load_bench_conf(self):
"""
Loads The Bench Configuration from its XML representation into a dict
"""
self._bench_conf = AttributeDict()
# New way of defining device parameters == as defined in the device catalog
try:
self._bench_tree_node = etree.parse(self.bench_conf_filename)
except XMLParsingErrors:
_error("Corrupted file {0}: {1}".format(
self.bench_conf_filename,
Utils.get_exception_info()[1]))
node = self.bench_device_node
if node is not None and len(node) > 0:
# To load proper device config, need to get device model name
device_conf = self.device_conf
if device_conf:
self._device_model_name = device_conf.get("DeviceModel")
if self._device_model_name in ('', "", None, 'multi'):
self._device_model_name = node[0].get("deviceModel")
conf = self._parse_bench_node(node[0])
if conf:
self._bench_conf.update(conf)
def _start_logging(self):
"""
Starts logging required by ACS for UECmd response
:return: None
"""
remote_app_serial_number = ""
# Start logging thread required for UECmd response
file_path = ""
if self.write_logcat_enabled or self._device.get_config(
"writeAcsLogcat", "False", "str_to_bool"):
timestamp = Util.get_timestamp()
if remote_app_serial_number not in ["", None]:
file_name = "%s_%s_%s_logcat.log" % (
self.get_phone_model(),
re.sub(':', '_', remote_app_serial_number),
timestamp,
)
else:
file_name = "%s_%s_logcat.log" % (
self.get_phone_model(),
timestamp,
)
file_path = os.path.join(
self._device.get_report_tree().get_subfolder_path(
subfolder_name="LOGCAT",
device_name=self.get_phone_model()), file_name)
self.__log_file_name = file_path
self._device_logger.set_output_file(self.__log_file_name)
self._device_logger.start()
def init(self):
"""
Initializes the equipment. The equipment is ready to use.
- Load equipment driver
- Connection to the equipment is established
- Show equipment informations
- Reset equipment
"""
self.get_logger().info("Initialization")
# Loads the driver
self.load_driver()
serial_number = self.get_bench_params().get_param_value(
"serialNumber", "")
if serial_number not in [None, ""]:
serial_number = int(
self.get_bench_params().get_param_value("serialNumber"))
# get if we use external power supply as charger
self._use_ext_ps = self.get_bench_params().get_param_value(
"ExtPowerSupplyAsCharger", False)
if type(self._use_ext_ps) is str:
self._use_ext_ps = Util.str_to_bool(self._use_ext_ps)
# Tries to connect to equipment
self.__device_index = W.Connect(self, serial_number)
if self.__device_index == -1:
raise TestEquipmentException(
TestEquipmentException.CONNECTION_ERROR,
"Failed to connect to %s" % self.get_name())
W.ShowInfo(self)
W.Reset(self)
self.battery_connector(False, self.BAT_INVALID)
def parse(self):
try:
parsed_doc = et.parse(self.__script)
self.__doc = parsed_doc.getroot()
except et.XMLSyntaxError:
_, error_msg, _ = Utils.get_exception_info()
raise AcsConfigException(AcsConfigException.XML_PARSING_ERROR, error_msg)
return self.__parse_cmds(self.__doc)
def _extract_cts_results_for_bulk_tcr_upload(self, cts_result_file_path):
"""
This function will extract CTS results from default XML into acceptable
TCR for bulk results upload
:return:
payload - results structure to be uploaded into TCR as bulk update
"""
verdict = Global.SUCCESS
msg = ""
payload = []
rt = {}
try:
tree = et.parse(cts_result_file_path)
self._logger.debug("CTS - Parsing of the CTS report XML file completed")
except et.XMLSyntaxError:
error_msg = "CTS report file: " + str(cts_result_file_path) + \
"- parsing-reading issue (exception= " + str(Utils.format_exception_info()) + ")"
raise AcsToolException(AcsToolException.XML_PARSING_ERROR, error_msg)
package_list = tree.getroot().xpath("//TestPackage")
for package in package_list:
self._logger.debug("CTS - Packages results processing")
package_name = package.get('appPackageName')
if package_name is not None:
rt['useCase'] = package_name
test_case = ""
element = package.find("TestSuite")
while element is not None:
test_case += '.' + element.get('name')
element = element.find("TestSuite")
tcs = package.xpath(".//TestCase")
for tc_node in tcs:
tc_name = tc_node.get('name')
if tc_name is not None:
tests = tc_node.xpath(".//Test")
for test_node in tests:
test_name = test_node.get('name')
if test_name is not None:
test_name = '.' + tc_name + '.' + test_name
result = test_node.get('result')
if result == "pass":
result = Verdict.PASS
elif result == "fail":
result = Verdict.FAIL
elif result == "timeout":
result = Verdict.INTERRUPTED
elif result == "notExecuted":
result = "NA"
rt['verdict'] = result
rt['testCase'] = package_name + test_case + test_name
payload.append(copy.deepcopy(rt))
nr_elem = len(payload)
if nr_elem == 0:
msg = "Calculated CTS bulk upload payload is empty. Was this an empty CTS test plan execution?"
verdict = Global.FAILURE
else:
msg = "calculated CTS bulk upload payload contains %s elements"% nr_elem
LiveReporting.instance().create_bulk_tc(payload)
return verdict, msg
def display_acs_version(option, opt_str, value, parser):
"""
:param option:
:param opt_str:
:param value:
:param parser:
:return:
"""
print "ACS " + Util.get_acs_release_version()
sys.exit(0)
def get_ucase_class(self):
"""
This function returns usecase class if present.
"""
ucase_class = None
ucase_class_node = self.get_testcase_property(USECASE_CLASS_NAME_NODE,
None)
if ucase_class_node is not None:
ucase_class = Utils.get_class(ucase_class_node)
return ucase_class
def _init_logger(self):
"""
Initializes the logger.
"""
log_port = int(self._device_config.get("logPort", "8003"))
self._device_logger = Win8Logger(self._device_ip, log_port)
time = Util.get_timestamp()
file_name = self.get_phone_model() + "_" + str(log_port) + time + "_win8.log"
file_path = path.join(self.get_report_tree().get_report_path(),
file_name)
self._device_logger.set_output_file(file_path)
def _parse_campaign_file_path(self, campaign_file_path):
# XML parser parses the campaign config file
try:
return et.parse(campaign_file_path)
except et.XMLSyntaxError:
_, error_msg, _ = Utils.get_exception_info()
self._logger.error(
"Campaign file is corrupted : parsing-reading issue in {0}".
format(campaign_file_path))
raise AcsConfigException(AcsConfigException.XML_PARSING_ERROR,
error_msg)
def install_device_executable(self, bin_path, destination, timeout=0):
"""
Install a binary as device executable file
:type bin_path: str
:param bin_path: file to be installed
:type destination: str
:param destination: destination on device
:type timeout: int
:param timeout: operation timeout
:rtype: tuple (bool, str)
:return: Output status and output log
"""
status = Util.Global.FAILURE
status_msg = "Undefined error while pushing binary on device"
binary_filename = os.path.basename(bin_path)
if os.path.isfile(bin_path):
if destination is not None:
# Initialize timeout if not set
if not timeout:
timeout = Util.compute_timeout_from_file_size(
bin_path, self._device.min_file_install_timeout)
# Build chmod commands
dest_path = posixpath.join(destination, binary_filename)
bin_chmod_cmd = "chmod +x {0}".format(dest_path)
# Push the binary file
self._logger.info("Pushing %s -> %s ..." %
(str(bin_path), str(dest_path)))
# status, status_msg = self._run_cmd_and_check_failure(bin_push_cmd, timeout)
status, status_msg = self._device.push(bin_path, destination,
timeout)
if status == Util.Global.SUCCESS:
# Modify access right on the binary file
status, status_msg = self._run_cmd_and_check_failure(
bin_chmod_cmd, timeout)
if status == Util.Global.SUCCESS:
status_msg = "Binary has been successfully installed on the device!"
else:
status_msg = "Impossible to push %s, no destination given" % (
str(bin_path), )
else:
status_msg = "Impossible to install, no file given"
return status, status_msg
def find_report_file(self):
"""
This function will search for the ACS Report XML file inside ACS Report
folder provided as input
:rtype: string
:return: Report file found if found in input Report folder
"""
for root, dirnames, filenames in os.walk(self.failed_folder_path):
for filename in filenames:
if filename.endswith(".xml"):
filename = os.path.join(root, filename)
if Util.is_report_file(filename):
return filename
return ""
def run(self, context):
"""
Close image Tkinter viewer
"""
TestStepBase.run(self, context)
host_screen = Util.str_to_bool(
DeviceManager().get_device_config("PHONE1").get(
"DisplayScreenAvailable", "False"))
if host_screen is not None and host_screen:
event = context.get_info("DisplayImageOnHost_Event")
event.set()
else:
self._logger.info(
"Host screen not available, nothing will be closed")
def get_action_nodes(self):
"""
Returns the list of all I{ACTION} XML nodes.
:rtype: NodeList
:return: the list of all I{ACTION} XML nodes
"""
ui_seq = None
actions = []
try:
ui_seq = et.parse(self.__script)
except et.XMLSyntaxError:
_, error_msg, _ = Utils.get_exception_info()
raise AcsConfigException(AcsConfigException.XML_PARSING_ERROR, error_msg)
actions = ui_seq.xpath("//ACTION")
return actions
def __init__(self):
super(ExtendedDebugModule, self).__init__()
self._retrieve_dmesg = None
self._retrieve_anr_traces = None
self._retrieve_tombstone = None
self._retrieve_logcat = None
self._only_for_failed_tests = None
self._retrieve_data = None
self._device_id = Util.AcsConstants.NOT_AVAILABLE
self._verdict = Util.Verdict()
self.result_folder_path = None
self.result_file_name = None
self.anrs_number = None
self.tombs_number = None
self.tombs_list = None
self.tc_verdict = None
def _load_device_conf(self):
"""
Loads The Device Configuration from its XML representation into a dict
"""
try:
self._device_tree_node = etree.parse(self.device_conf_filename)
except XMLParsingErrors:
_error("Corrupted file {0}: {1}".format(
self.device_conf_filename,
Utils.get_exception_info()[1]))
self._parse_device_node()
self._device_schema = self.extract_schema(
self.device_root_node,
schema_folder=Paths.FWK_DEVICE_MODELS_CATALOG,
file_only=False)
def create_report_folder(self):
"""
Create report folder path from either a path specified by report_path
or by creating one by computing timestamp, campaign and hw variant name.
"""
if not self.__campaign_report_path:
# Initialize the report path
# Create the report folder for the current campaign
if self._report_path is None:
# No path specified (from ACS cmd line)
# We are going to generate one report folder name
# Adding timestamp
campaign_folder_name = Util.get_timestamp()
if self._hw_variant_name:
# Adding hw variant
campaign_folder_name += "_" + self._hw_variant_name
if self._campaign_name:
# Adding current campaign name
campaign_name = os.path.splitext(
os.path.basename(self._campaign_name))[0]
campaign_folder_name += "_" + campaign_name
campaign_report_path = os.path.join(os.getcwd(),
Folders.REPORTS,
campaign_folder_name)
else:
# Path specified (from ACS cmd line
# Use it!
campaign_report_path = self._report_path
index = 1
campaign_report_path_orig = campaign_report_path
while os.path.exists(campaign_report_path):
# Increment the folder name until it does not exists
campaign_report_path = campaign_report_path_orig + "_" + str(
index)
index += 1
os.makedirs(campaign_report_path)
self._logger.info("Campaign report path is %s" %
campaign_report_path)
# Store the path of the folder
self.__campaign_report_path = campaign_report_path
def pid_of(self, process_name):
"""
Get the pid of a process by its name.
:rtype: str
:return: the pid of the process or empty str if process as not been found.
"""
cmd = "pidof " + str(process_name)
cmd = self._internal_exec(cmd)
self._logger.info("Getting the pid of the process with name: %s" %
process_name)
(_result, pid) = Util.internal_shell_exec(cmd, 10)
if not pid.isdigit() and not pid == "":
raise DeviceException(DeviceException.INTERNAL_EXEC_ERROR,
"The pid should be a int. Is: %s" % str(pid))
self._logger.debug("PID of %s is: %s" % (process_name, pid))
return pid
def run_cts(self):
'''
This function will deal with running CTS
'''
current_time = time.time()
test_cmd_line = "%s %s" % (self._cts_exec_path, self._test_cmd_lines)
result, output = Utils.internal_shell_exec(test_cmd_line,
self._test_timeout)
if result != Global.SUCCESS:
return Global.FAILURE
for root, _, filenames in os.walk(self._cts_path):
for file_ in filenames:
if CTS_RESULT_FILENAME in file_:
cts_results = os.path.join(root, file_)
left_time = time.time() - current_time
self._test_timeout = self._test_timeout - left_time
xml_file = open(cts_results, 'r')
xml_cont = xml_file.read()
xml_file.close()
if 'result="notExecuted"' in xml_cont:
if self._test_timeout > 0:
self._test_cmd_lines = CTS_CONTINUE_SESSION_COMMAND
self._logger.debug("CTS - Not Executed retry")
self.run_cts()
elif 'result="fail"' in xml_cont:
if self._test_timeout > 600 and self._test_failed_retry_no > 0:
self._test_failed_retry_no -= 1
x_res = os.path.join(
os.path.dirname(cts_results),
'backup_cts_res_' +
str(self._test_failed_retry_no))
shutil.copyfile(cts_results, x_res)
xml_cont = xml_cont.replace('result="fail"', \
'result="notExecuted"')
xml_file = open(cts_results, 'w')
xml_file.write(xml_cont)
xml_file.close()
#self.motc_library.reboot_device()
self._test_cmd_lines = CTS_CONTINUE_SESSION_COMMAND
self._logger.debug("CTS - Failed retry:%s" %
self._test_failed_retry_no)
self.run_cts()
def _init_bench_info_node(self):
"""
Initialize the DeviceInfo Node with theses values:
DeviceInfo:
- Bench Name (hostname)
- Bench user
- Bench IP
- Bench OS
- ACS Version (host)
:rtype: None
"""
# Create the <BenchInfo> element
self.bench_info = etree.SubElement(self.document, "BenchInfo")
# Create the <BenchName> node for hostInfo
bench_name = etree.SubElement(self.bench_info, "BenchName")
# Set BenchName value
bench_name.text = clean_xml_text(self.__get_bench_name())
# Create the <BenchUser> node for hostInfo
bench_user = etree.SubElement(self.bench_info, "BenchUser")
# Set BenchUser value
bench_user.text = clean_xml_text(self.__get_bench_user())
# Create the <BenchIp> node for hostInfo
bench_ip = etree.SubElement(self.bench_info, "BenchIp")
# Set BenchIp value
bench_ip.text = self.__get_bench_ip()
# Create the <BenchOs> node for hostInfo
bench_os = etree.SubElement(self.bench_info, "BenchOs")
# Set BenchName value
bench_os.text = self.__get_bench_os()
# Create the <AcsVersion> node for hostInfo
acs_version = etree.SubElement(self.bench_info, "AcsVersion")
# Set AcsVersion value
acs_version.text = Util.get_acs_release_version()
def run(self, context):
"""
Generic method to run MediaPlayer test steps
"""
TestStepBase.run(self, context)
host_screen = Util.str_to_bool(
DeviceManager().get_device_config("PHONE1").get(
"DisplayScreenAvailable", "False"))
if host_screen is not None and host_screen:
from acs_test_scripts.Lib.EM.VideoPlayback import MediaPlayer as MediaPlayer
self._media_player = context.get_info(self._pars.instance_name)
if self._media_player is None:
self._media_player = MediaPlayer()
context.set_info(self._pars.instance_name, self._media_player)
self._run()
else:
self._logger.info(
"Host screen not available, nothing will be displayed")
def run(self, context):
"""
Runs the test step
:type context: TestStepContext
:param context: test case context
"""
TestStepBase.run(self, context)
# Looks for the key in the campaign configuration file.
value = Utils.get_config_value(
DeviceManager().get_global_config().campaignConfig,
"Campaign Config", self._pars.key)
if value is None:
self._logger.info(
"{0}: Value found for {1} in campaign config was None, storing the default value of {2} instead"
.format(self._pars.id, self._pars.key,
self._pars.default_value))
value = self._pars.default_value
# Write value to the context so that it can be used by other TestSteps.
context.set_info(self._pars.param_value, value)
def __is_stock_msg_app_running(self):
"""
Checks id the stock messaging application is running.
:rtype: boolean
:return: True if the application is running False otherwise.
"""
result_key = "isMessagingAppRunning"
self._logger.info("Check if stock messaging is running.")
function = "checkIfMmsStockAppIsRunning"
output = self._internal_exec_v2(self._mms_module,
function,
is_system=True)
if result_key not in output:
raise AcsToolException(
AcsToolException.INVALID_PARAMETER,
"output key %s not found : %s" % (result_key, str(output)))
# Convert result to bool.
result = Util.str_to_bool(output[result_key])
return result
def install_device_app(self, app_path, timeout=0, allow_downgrade=False):
"""
Install a device application
:type app_path: str
:param app_path: file to be installed
:type timeout: int
:param timeout: operation timeout
:type allow_downgrade: bool
:param allow_downgrade: allow the downgrade of application
:rtype: tuple (bool, str)
:return: Output status and output log
"""
status = Util.Global.FAILURE
status_msg = "Undefined error while installing application on device"
cmd_options = "-r"
if allow_downgrade:
cmd_options += " -d"
if os.path.isfile(app_path):
# Define the timeout from the file size
if not timeout:
timeout = Util.compute_timeout_from_file_size(
app_path, self._device.min_file_install_timeout)
self._logger.info("Installing {0} ...".format(app_path))
cmd = 'adb install {0} "{1}"'.format(cmd_options, app_path)
status, status_msg = self._run_cmd_and_check_failure(cmd, timeout)
else:
status_msg = "Impossible to install {0}, file does not exist".format(
app_path)
return status, status_msg
class ACBP(IIOCard, DllLoader):
"""
Class ACBP: implementation of UsbDIO prototype
"""
# Defining possible usb devices (Usb host, DCP, ...)
SUPPORTED_DEVICE_TYPE = [IIOCard.USB_HOST_PC, IIOCard.SDP]
LINES = Util.enum(
'battery', # ctrl00 on=inserted / off=removed
'usb_5v_gnd', # ctrl01
'usb_dp_dm_id', # ctrl02
'batt_id_ctrl3', # ctrl03
'batt_id_ctrl4', # ctrl04
'batt_id_ctrl5', # ctrl05
'temp_value_ctrl6', # ctrl06
'temp_value_ctrl7', # ctrl07
'usb_charger', # ctrl08 on=CP / off=DP
'batt_id_glitch', # ctrl09 on=start the glitch
# off= rearm
'batt_id_glitch_duration', # ctrl10 on=5p2ms / off=165us
'sim_card', # ctrl11 on=insertion
# off=removal
'button_ctrl12', # ctrl12 on=close connection
# off=open connection
'usb_charger_select', # ctrl13 on=DC source / off=USBPC source
'digital_battery_protocol', # ctrl14 on=logical 0 / off=logical 1
'supply1_switch', # ctrl15 on=SDcard Vss1 / off=AC charger
'temp_value_ctrl16', # ctrl16
'sd_card', # ctrl17 on=insertion / off=removal
'usb_switch_select', # ctrl18 on=USB accessories | USB Host PC
# off=USB charger
'usb_switch_select2', # ctrl19 on=USB Host PC
# off=USB accessories
# (depends on ',usb_switch_select',)
'button_ctrl20', # ctrl20 on=close connection
# off=open connection
'button_ctrl21', # ctrl21 on=close connection
# off=open connection
'button_ctrl22', # ctrl22 on=close connection
# off=open connection
'button_ctrl23', # ctrl23 on=close connection
# off=open connection
'button_ctrl24', # ctrl24 on=close connection
# off=open connection
'button_ctrl25', # ctrl25 on=close connection
# off=open connection
'button_ctrl26', # ctrl26 on=close connection
# off=open connection
'power_supply1_ac_charger' # ctrl27 depends on 'supply1_switch'
)
def __init__(self, name, model, eqt_params, bench_params):
"""
Constructor
:type name: str
:param name: the bench configuration name of the equipment
:type model: str
:param model: the model of the equipment
:type eqt_params: dict
:param eqt_params: the dictionary containing equipment parameters
:type bench_params: dict
:param bench_params: the dictionary containing equipment bench parameters
"""
IIOCard.__init__(self)
DllLoader.__init__(self, name, model, eqt_params)
self.__bench_params = bench_params
self.__device_index = -1
self.__wall_charger = None
def get_bench_params(self):
"""
:rtype: bench configuration
:return: the bench configuration dictionary of the equipment
"""
return self.__bench_params
def get_dev_idx(self):
"""
:rtype: integer
:return: the index of the device
"""
return self.__device_index
def init(self):
"""
Initializes the equipment. The equipment is ready to use.
- Load equipment driver
- Connection to the equipment is established
- Show equipment informations
- Reset equipment
"""
self.get_logger().info("Initialization")
# Loads the driver
self.load_driver()
serial_number = None
if self.get_bench_params().has_parameter("serialNumber"):
serial_number = \
int(self.get_bench_params().get_param_value("serialNumber"))
# Tries to connect to equipment
self.__device_index = W.Connect(self, serial_number)
if self.__device_index == -1:
raise TestEquipmentException(
TestEquipmentException.CONNECTION_ERROR,
"Failed to connect to %s" % self.get_name())
W.ShowInfo(self)
W.Reset(self)
def release(self):
"""
Releases all resources allocated to equipment
"""
self.get_logger().info("Release")
self.unload_driver()
self.__device_index = -1
def reset(self):
"""
Reset the IO card to default states
"""
self._logger.warning("reset method is not implemented !")
def usb_connector(self, plug):
"""
Handles USB connector connection and disconnection
:type plug: boolean
:param plug: action to be done:
- True => plug currently selected USB device
- False => unplug currently selected USB device
"""
if plug:
self.get_logger().info("Plug USB")
W.Enable(self, self.LINES.usb_5v_gnd)
else:
self.get_logger().info("Unplug USB")
W.Disable(self, self.LINES.usb_dp_dm_id)
time.sleep(0.2)
if plug:
W.Enable(self, self.LINES.usb_dp_dm_id)
# Waiting for enumeration
time.sleep(3)
else:
W.Disable(self, self.LINES.usb_5v_gnd)
def usb_device_selector(self, usb_device):
"""
Handles USB device selection
:param usb_device: USB device to select:
- "USB_HOST_PC" -> USB Host PC (ACS, FW/SW Updates)
"""
self.get_logger().info("Select USB device: %s", usb_device)
if usb_device == ACBP.USB_HOST_PC:
W.Enable(self, self.LINES.usb_switch_select)
W.Disable(self, self.LINES.usb_switch_select2)
else:
raise TestEquipmentException(
TestEquipmentException.INVALID_PARAMETER,
"Unknown USB device: %s!" % usb_device)
def simulate_insertion(self, device_type):
"""
Do a cable insertion (usb or other)
If this function is called twice then it will unplug then plug again instead of doing nothing.
:type device_type: str
:param device_type: cable device to select. Possible values:
- "USB_HOST_PC": USB Host PC (ACS, FW/SW Updates)
"""
self.get_logger().info("Select cable type: %s", device_type)
if device_type == self.USB_HOST_PC:
# remove usb
self.usb_connector(False)
# switch to wanted usb
self.usb_device_selector(device_type)
# plug usb
self.usb_connector(True)
else:
raise TestEquipmentException(
TestEquipmentException.INVALID_PARAMETER,
"Unknown USB device: %s!" % device_type)
def usb_host_pc_connector(self, plug):
"""
Handles USB connector connection and disconnection of USB host PC device
:type plug: boolean
:param plug: action to be done
- True => plug USB to host PC
- False => unplug USB from host PC
:rtype:None
"""
# Select USB host PC device
self.usb_device_selector(ACBP.USB_HOST_PC)
# Plug or unplug USB
self.usb_connector(plug)
return True
def press_power_button(self, duration):
"""
Presses power button.
Allow to simulate special behavior on the board like S3 mode.
:type duration: float
:param duration: time while the power button is pressed
The value should be superior than 0 seconds
"""
self.get_logger().info("Press power button during %f second(s)",
duration)
W.Enable(self, self.LINES.button_ctrl12)
time.sleep(duration)
W.Disable(self, self.LINES.button_ctrl12)
def load_specific_dut_config(self, dut_name):
"""
Configure different setting on your io card related to dut name,
This is useful in multi device campaign.
The setting will depending of your current dut name and what you declared on
benchconfig.
:type dut_name: str
:param dut_name: phone name
.. warning:: not functional for this io card, put only for compatibility reason
"""
self.get_logger().warning(
"load_specific_dut_config: NOT implemented for ACBP")
def set_default_battery_type(self, batt_type):
"""
set default battery type.
all function that play with battery type will take this value if the type is omitted.
:type batt_type: str
:param batt_type: default battery type supported by the device
"""
self.get_logger().warning(
"set_default_battery_type: NOT implemented for ACBP")
def get_default_battery_type(self):
"""
get default battery type.
:rtype: str
:return: default battery type
return None if not set
"""
self.get_logger().warning(
"get_default_battery_type: NOT implemented for ACBP")
def set_default_wall_charger(self, device_default_charger):
"""
set default wall charger.
:type device_default_charger: str
:param device_default_charger: default wall charger supported by the device
"""
self.get_logger().warning(
"set_default_wall_charger: NOT implemented for ACBP")
def get_default_wall_charger(self):
"""
get default wall charger.
:rtype: str
:return: default wall charger supported by the device
return None if not set
"""
self.get_logger().warning(
"get_default_wall_charger: NOT implemented for ACBP")
"""
Super class in order to create set_logger accessor
"""
def set_logger(self, logger):
"""
Set logger accessor
"""
self._logger = logger
if __name__ == "__main__":
bench_config = "bench_config_conformance"
equipment_catalog = "Equipment_Catalog"
global_config = Util.Dictionary(attribute1='benchConfig',
attribute2='deviceConfig',
attribute3='campaignConfig',
attribute4='equipmentCatalog',
attribute5='campaignReportTree')
global_config.benchConfig = {}
global_config.deviceConfig = {}
global_config.campaignConfig = {}
global_config.equipmentCatalog = {}
global_config.campaignReportTree = None
flash_file_path = None
file_parsing_manager = FileParsingManager(bench_config, equipment_catalog,
global_config)
file_parsing_manager.parse_bench_config()
bench_name = "CONFIGURABLE_AP1"
equipment_model = "AP_CONTROLLER"
class ACBT(ACBE):
"""
Class ACBT: implementation of enhanced ACB for tablet
"""
# Defining possible usb devices (Usb host, DCP, ...)
SUPPORTED_DEVICE_TYPE = [ACBE.DCP, ACBE.CDP, ACBE.USB_HOST_PC,
ACBE.SDP, ACBE.AC_CHGR, ACBE.WALL_CHARGER]
LINES = Util.enum('battery', # ctrl00 on=inserted / off=removed
'usb_5v_gnd', # ctrl01
'usb_dp_dm_id', # ctrl02
'batt_id_ctrl3', # ctrl03
'batt_id_ctrl4', # ctrl04
'batt_id_ctrl5', # ctrl05
'temp_value_ctrl6', # ctrl06
'temp_value_ctrl7', # ctrl07
'usb_charger', # ctrl08 on=CP / off=DP
'batt_id_glitch', # ctrl09 on=start the glitch
# off= rearm
'batt_id_glitch_duration', # ctrl10 on=5p2ms / off=165us
'sim_card', # ctrl11 on=insertion
# off=removal
'button_ctrl12', # ctrl12 on=close connection
# off=open connection
'usb_charger_select', # ctrl13 on=DC source / off=USBPC source
'digital_battery_protocol', # ctrl14 on=logical 0 / off=logical 1
'supply1_switch', # ctrl15 on=SDcard Vss1 / off=AC charger
'temp_value_ctrl16', # ctrl16
'sd_card', # ctrl17 on=insertion / off=removal
'usb_switch_select', # ctrl18 on=USB accessories | USB Host PC
# off=USB charger
'usb_switch_select2', # ctrl19 on=USB Host PC
# off=USB accessories
# (depends on ',usb_switch_select',)
'button_ctrl20', # ctrl20 volume down
'button_ctrl21', # ctrl21 volume up
'button_ctrl22', # ctrl22 on=close connection
# off=open connection
'button_ctrl23', # ctrl23 on=close connection
# off=open connection
'button_ctrl24', # ctrl24 on=close connection
# off=open connection
'button_ctrl25', # ctrl25 on=close connection
# off=open connection
'button_ctrl26', # ctrl26 on=close connection
# off=open connection
'power_supply1_ac_charger', # ctrl27 depends on 'supply1_switch'
'OTG_ctrl28', # ctrl28
'OTG_ctrl29', # ctrl29
'OTG_ctrl30' # ctrl30
)
ACCESSORY_TO_ACB = {
ACBE.SDP: [ # SDP
(True, LINES.usb_charger), # ctrl08
(True, LINES.usb_switch_select), # ctrl18
(False, LINES.usb_switch_select2)], # ctrl19
ACBE.DCP: [ # DCP
(False, LINES.usb_charger), # ctrl08
(False, LINES.usb_switch_select), # ctrl18
(False, LINES.usb_switch_select2)], # ctrl19
ACBE.CDP: [ # CDP
(True, LINES.usb_charger), # ctrll08
(True, LINES.usb_switch_select), # ctrl18
(True, LINES.usb_switch_select2), # ctrl19
# ID in normal mode
(False, LINES.OTG_ctrl28), # ctrl28
(True, LINES.OTG_ctrl29), # ctrl29
(False, LINES.OTG_ctrl30)], # ctrl30
ACBE.OTG: [ # OTG
(False, LINES.usb_charger), # ctrl08
(True, LINES.usb_switch_select), # ctrl18
(True, LINES.usb_switch_select2), # ctrl19
(False, LINES.OTG_ctrl28), # ctrl28
(True, LINES.OTG_ctrl29), # ctrl29
(False, LINES.OTG_ctrl30)], # ctrl30
ACBE.EXTERNAL_PS_ON: [
(True, LINES.usb_charger_select)], # ctrl01
ACBE.EXTERNAL_PS_OFF: [
(False, LINES.usb_charger_select)], # ctrl01
ACBE.AC_CHGR_ON: [
(False, LINES.usb_charger_select, 1)], # ctrl13
ACBE.AC_CHGR_OFF: [
(True, LINES.usb_charger_select, 1)] # ctrl13
}
def __init__(self, name, model, eqt_params, bench_params):
"""
Constructor
:type name: str
:param name: the bench configuration name of the equipment
:type model: str
:param model: the model of the equipment
:type eqt_params: dict
:param eqt_params: the dictionary containing equipment parameters
:type bench_params: dict
:param bench_params: the dictionary containing equipment bench parameters
"""
ACBE.__init__(self, name, model, eqt_params, bench_params)
def init(self):
"""
Initializes the equipment. The equipment is ready to use.
- connect sense & force of the alim in order to avoid
overprotection
"""
ACBE.init(self)
W.Enable(self, self.LINES.usb_charger_select) # ctrl13
self.usb_connector(False)
def battery_connector(self, plug, battery_type="DEFAULT"):
"""
Handles battery insertion / removal
:type plug: boolean
:param plug: action to be done:
- True => insert battery
- False => remove battery
:type battery_type: str
:param battery_type: battery to plug
"""
if plug:
self.get_logger().info("Battery insertion")
# Insert battery
W.Disable(self, self.LINES.power_supply1_ac_charger) # ctrl27
time.sleep(0.3)
W.Enable(self, self.LINES.battery) # ctrl00
W.Enable(self, self.LINES.supply1_switch) # ctrl15
time.sleep(0.3)
W.Enable(self, self.LINES.power_supply1_ac_charger) # ctrl27
W.Disable(self, self.LINES.button_ctrl12) # ctrl12
time.sleep(0.3)
W.Disable(self, self.LINES.button_ctrl12) # ctrl12
# work around for bench batt id bug
self.set_battery_type(battery_type)
else:
self.get_logger().info("Battery removal")
# remove battery
W.Disable(self, self.LINES.power_supply1_ac_charger) # ctrl27
time.sleep(0.3)
W.Disable(self, self.LINES.battery) # ctrl00
W.Enable(self, self.LINES.supply1_switch) # ctrl15
# work around for bench batt id bug
self.set_battery_type(self.BAT_INVALID)
def ac_charger_connector(self, plug):
"""
handle AC charger insertion.
:type plug: boolean
:param plug: action to be done:
- True => insert charger
- False => remove charger
"""
if plug:
self.get_logger().info("Plug AC CHGR")
if not self._acb_com_cmd_list(self.ACCESSORY_TO_ACB[self.AC_CHGR_ON]):
self._logger.debug("ac_charger_connector: already plug")
else:
self.get_logger().info("Unplug AC CHGR")
if self._acb_com_cmd_list(self.ACCESSORY_TO_ACB[self.AC_CHGR_OFF]):
if self._use_ext_ps:
self.ext_supply_connector(False)
else:
self._logger.debug("ac_charger_connector: already unplug")
def ext_supply_connector(self, plug):
"""
Handles external power supply connection and disconnection
:type plug: boolean
:param plug: action to be done:
- True => plug external power supply
- False => unplug external power supply
"""
self.get_logger().warning("Plug external power supply NOT implemented for ACBT")
def reset(self):
"""
Reset the IO card to default states
"""
self.ac_charger_connector(False)
self.usb_connector(False)
self.battery_connector(False)
self.battery_temperature(25)