def run(self, context):
"""
Runs the test step
:type context: TestStepContext
:param context: test case context
"""
TestStepBase.run(self, context)
self._http_downloader_obj = HttpDownloaderUtil(
url=self._pars.url,
destination=self._pars.destination,
proxy=self._pars.http_proxy,
creds=self._pars.credential,
http_timeout=self._pars.http_timeout,
override=self._pars.override_file,
download_timeout=self._pars.transfer_timeout,
logger=self._logger)
try:
response = self._http_downloader_obj.init()
except AcsConfigException:
raise
if not response:
error_msg = "Cannot get response from server"
raise AcsToolException(AcsToolException.OPERATION_FAILED,
error_msg)
verdict, output, _ = self._http_downloader_obj.download(response)
if verdict != Global.SUCCESS:
raise AcsToolException(AcsToolException.OPERATION_FAILED, output)
else:
self.ts_verdict_msg = output
def _run(self):
"""
Run stop acquisition
"""
if self._patlib is None:
raise AcsToolException(
AcsToolException.PROHIBITIVE_BEHAVIOR,
"Cannot do acquisition, PatLib has not been initialized")
acquisition_status = self._context.get_info("AcquisitionStatus")
if self._pars.action.lower() == "start":
# check acquisition status
if acquisition_status and acquisition_status != "Stopped":
raise AcsToolException(
AcsToolException.PROHIBITIVE_BEHAVIOR,
"Cannot start acquisition, wrong acquisition status : %s" %
acquisition_status)
# acquisition status is correct, start it!
self._patlib.start_acquisition(True)
# store in context a variable about acquisition status
self._context.set_info("AcquisitionStatus", "Started")
elif self._pars.action.lower() == "stop":
# check acquisition status
if not acquisition_status:
raise AcsToolException(
AcsToolException.PROHIBITIVE_BEHAVIOR,
"Cannot stop, no acquisition previously started!")
elif acquisition_status.lower() != "started":
raise AcsToolException(
AcsToolException.PROHIBITIVE_BEHAVIOR,
"Cannot stop acquisition, wrong initial acquisition status : %s"
% acquisition_status)
# acquisition status is correct, stop it!
self._patlib.stop_acquisition()
self._context.set_info("AcquisitionStatus", "Stopped")
def _run(self):
"""
Compute power verdict according to targets
"""
if self._patlib is None:
raise AcsToolException(
AcsToolException.PROHIBITIVE_BEHAVIOR,
"Cannot report acquisition, PatLib has not been initialized")
pnp_results = self._context.get_info(self._pars.stored_pnp_result)
if not pnp_results:
raise AcsToolException(
AcsToolException.PROHIBITIVE_BEHAVIOR,
"Context key '{0}' does not content initialized PnpResult object"
.format(self._pars.stored_pnp_result))
pnp_results.update({"verdict_rail": str(self._patlib_util.power_rail)})
# initialize store data to false
self._context.set_info(self._pars.store_raw_data, "False")
verdict_name = "POWER_MEASURE({0})"
# retrieve measure information
measures = pnp_results.retrieve_power_measures(
self._patlib_util.power_rail)
if not measures:
raise AcsToolException(AcsToolException.PROHIBITIVE_BEHAVIOR,
"Cannot retrieve measure information")
measure = None
verdict_msg = ""
for rail in measures:
output_measure = ""
for value_type, value in measures[rail][-1].items():
if value_type == "average":
measure = value
output_measure += "{0}={1};".format(value_type, value)
self.update_report(Global.SUCCESS, verdict_name.format(rail),
output_measure)
if verdict_msg:
verdict_msg += " | "
verdict_msg += verdict_name.format(rail) + ":" + output_measure
if verdict_msg:
pnp_results.update({"power_msg": verdict_msg})
if measure is None:
raise AcsToolException(AcsToolException.PROHIBITIVE_BEHAVIOR,
"Cannot retrieve average power measure")
if pnp_results.check_rail_verdict(measure) == Global.FAILURE:
self._context.set_info(self._pars.store_raw_data, "True")
def _run(self):
"""
Compute power verdict according to targets
"""
if self._patlib is None:
raise AcsToolException(
AcsToolException.PROHIBITIVE_BEHAVIOR,
"Cannot report acquisition, PatLib has not been initialized")
pnp_results = self._context.get_info(self._pars.stored_pnp_result)
if not pnp_results:
raise AcsToolException(
AcsToolException.PROHIBITIVE_BEHAVIOR,
"Context key '{0}' does not content initialized PnpResult object"
.format(self._pars.stored_pnp_result))
pnp_results.update({"verdict_rail": str(self._patlib_util.power_rail)})
verdict_name = "{0}#".format(self._pars.operation)
verdict_name += "POWER_MEASURE({0})"
# retrieve measure information
measures = pnp_results.retrieve_power_measures(
self._patlib_util.power_rail)
if not measures:
raise AcsToolException(AcsToolException.PROHIBITIVE_BEHAVIOR,
"Cannot retrieve measure information")
rail_to_report = self._patlib_util.power_rail
# compute the score
measure = self._compute_score(measures, rail_to_report)
code = pnp_results.check_rail_verdict(float(measure))
self.update_report(code, verdict_name.format(rail_to_report), measure)
if code == Global.FAILURE:
verdict_value = "FAIL"
else:
verdict_value = "PASS"
pnp_results.update({"power_verdict": verdict_value})
if not self._pars.verdict_criteria or "both" in str(
self._pars.verdict_criteria).lower():
if "fail" not in pnp_results.get_value("verdict").lower():
pnp_results.update({"verdict": verdict_value})
elif "power" in str(self._pars.verdict_criteria).lower():
pnp_results.update({"verdict": verdict_value})
def start_auto_logger_on_reboot(self,
polling_delay,
logger_type="sequenced"):
"""
Internal method that start an autolog sequenced function to poll every x seconds
only after next reboot
:type polling_delay: int
:param polling_delay: delay in seconds between 2 logs.
:type logger_type: str
:param logger_type: logger type to start, support only 'sequenced'.
"""
if logger_type == "sequenced":
function = "startSequenceLoggerOnReboot"
else:
txt = "not supported logger type" % logger_type
self._logger.error(txt)
raise AcsToolException(AcsToolException.OPERATION_FAILED, txt)
params = "--ei pollingDelay %s" % (polling_delay)
self._internal_exec_v2(self.__autolog_module,
function,
params,
is_system=True)
def __get_mms_box(self):
"""
Returns the message box number of the message described by the thread
id and message id passed as parameters.
:rtype: str
:return: the name of the box the message is in.
:raise AcsToolException: If the output is missing one of the expected
keys.
"""
# Defining keys for input and output of the embedded UE command.
thread_id_key = "thread_id"
message_id_key = "msg_id"
message_box_key = "msg_box_number"
# Defined the function name used on the embedded side.
function = "getMmsBoxFromId"
# Building the command to send to the embedded part.
# Launch the command and retreive the result.
output = self._internal_exec_v2(self._mms_module,
function,
"--es %s %s --es %s %s" %
(thread_id_key, self.sent_thread_id,
message_id_key, self.sent_msg_id),
is_system=True)
# Check the output contains the expected keys.
if message_box_key not in output:
raise AcsToolException(
AcsToolException.INVALID_PARAMETER,
"output key %s not found: %s" % (message_box_key, output))
# Return the output.
return output.get(message_box_key)
def _execute_at_command(self, at_command):
"""
Executes the given at_command.
:type at_command: str
:param at_command: the AT command to execute
:rtype: tuple
:return: the verdict and the message in a tuple
"""
# Check parameter
if not at_command:
return (Global.FAILURE, "Invalid input parameter")
self._logger.debug("Sending AT command: %s " % str(at_command))
# Escape quotes in AT command
at_command = at_command.replace('\"', '\\"')
# Build the adb command
adb_command = "adb -s %s shell %s %s %s \"%s\"" % (
self._device.get_serial_number(),
"teltbox",
"mdm_acm",
"/dev/gsmtty20",
at_command)
# Execute the AT command
(status, output) = internal_shell_exec(adb_command, 5) # pylint: disable=W0212
# Check the command output
if "-ERROR-" in output:
message = "Error during AT command execution: %s" % output
raise AcsToolException(
AcsToolException.OPERATION_FAILED,
message)
#Sleep arbitrary time
time.sleep(1)
# Return a status and a message
return (status, output)
def is_hdmi_connected(self):
"""
Check whether HDMI is connected or not by reading dumpsys SurfaceFlinger
:rtype: boolean
:return: return True if HDMI exists.
"""
cmd = 'adb shell "dumpsys SurfaceFlinger | grep External"'
(return_code, output) = self._device.run_cmd(cmd, timeout=10)
if return_code != Utils.Global.SUCCESS:
msg = "uecmd is_hdmi_connected: Error '%s' when trying to check HDMI" % (
output)
self._logger.error(msg)
raise AcsToolException(AcsToolException.OPERATION_FAILED, msg)
re_match = re.match(".*External \((.*)\)", output)
if re_match and len(re_match.groups()) == 1:
out_msg = re_match.group(1)
else:
return False
if out_msg == "connected":
return True
else:
return False
def _initialize_new_monkey_instance(self):
"""
Returns a new C{MonkeyUtilities} instance.
This method will allow test optimization (with
usage of mock implementation).
:rtype: MonkeyUtilities
:return: a new C{MonkeyUtilities} instance.
"""
if self.__monkey_port is None:
raise AcsConfigException(AcsConfigException.PROHIBITIVE_BEHAVIOR,
"Monkey port cannot be <None>")
if not isinstance(self.__monkey_port, int):
self.__monkey_port = int(self.__monkey_port)
oom_protection = self.__device.get_config("enableMonkeyOomProtection",
True, "str_to_bool")
monkey_util = MonkeyUtilities(host="localhost",
port=self.__monkey_port,
device=self.get_device(),
protect_from_oom=oom_protection)
result, status = monkey_util.connect()
if result == Global.FAILURE:
raise AcsToolException(AcsToolException.OPERATION_FAILED,
"Cannot start monkey util: %s" % status)
return monkey_util
def check_rpc_server_running(self):
"""
Check that a XML RPC server instance is listening for XML
RPC requests, if not, starts one.
"""
ping_status = self.ping()
if not ping_status:
if self._is_port_used(self._server_port):
raise AcsToolException(
AcsToolException.INVALID_PARAMETER,
"%s already in use, select another port" %
self._server_port)
self.get_logger().debug("Starting XML-RPC server on port %s" %
str(self._server_port))
# Does not work
# d = multiprocessing.Process(name='EquipementServerXMLRPC', target=start_server, args=(self._server_ip, self._server_port,))
# d.daemon = True
# d.start()
# So, use an uggly way to run the server process
log_folder = os.path.join(Folders.ACS_CACHE)
cmd = "python LockManagerServer.py %s %s %s" % (
self._server_ip, self._server_port, log_folder)
DEVNULL = open(os.devnull, 'wb')
subprocess.Popen(format_cmd_args(cmd),
shell=False,
stdout=DEVNULL,
stderr=subprocess.STDOUT,
cwd=os.path.abspath(os.path.dirname(__file__)),
close_fds=ON_POSIX)
# Wait some time in order to give a chance
# to the server to complete its starting procedure
time.sleep(3)
def _extract_results(self, tag_op_code, message):
"""
This method is used to extract the result formatted by the ACS Agent
into a readable dict.
:type tag_op_code: str
:param tag_op_code: The Operation Code reference
:type message: str
:param message: The input message to extract the I{ACS} results
:rtype: dict
:return: The dict builded from input message
"""
result = AcsDict()
payload = self._parse_reg.findall(message)
if payload:
for pair in re.split(Base.FIELDS_SEPARATOR, payload[0]):
split_result = pair.split(Base.PARAM_SEPARATOR)
if len(split_result) >= 2:
key = split_result[0].strip()
value = split_result[1].strip()
result[key] = value
if not result:
error_message = "(%s) " % (str(tag_op_code), )
error_message += "Cannot parse incoming result:" + message
raise AcsToolException(AcsToolException.PHONE_OUTPUT_ERROR,
error_message)
return result
def get_bt_tethering_power(self):
"""
Get Bluetooth Tethering feature state (Enable/disable).
:rtype: boolean
:return: True = enable
False = disable
"""
self._logger.info("Get BT Tethering state")
method = "getBluetoothTethering"
pan_state = (self._internal_exec_v2(self._BLUETOOTH_MODULE, method, is_system=True)).get("Pan_state")
if pan_state is None:
return_msg = "pan_state parameter not found"
self._logger.error(return_msg)
raise AcsToolException(AcsToolException.INVALID_PARAMETER, return_msg)
self._logger.info("BT tethering state: " + pan_state)
# pylint: disable=E1101
if pan_state == "ON":
pan_state = True
elif pan_state == "OFF":
pan_state = False
else:
return_msg = "Invalid BT tethering state: " + pan_state
self._logger.error(return_msg)
raise DeviceException(DeviceException.INVALID_DEVICE_STATE, return_msg)
return pan_state
def __sign_app(self, app_path, signing_key_folder, signing_key_name):
"""
Sign the given application with the given Signing key.
:param app_path: The application path to be signed
:type app_path: str
:param signing_key_folder: The folder where are stored Signing keys.
:type signing_key_folder: str
:param signing_key_name: The key name to look up into passed folder.
:type signing_key_name: str
:raise AcsToolException: Raised when an error occurs while signing the Application.
:return: The path of the signed application.
:rtype: str
"""
signing_tmp_folder = tempfile.mkdtemp()
signed_app = path.join(signing_tmp_folder, path.basename(app_path))
status, status_msg = self._app_api.sign_device_app(
app_path, signing_key_folder, signing_key_name, signed_app, 5)
if status != Global.SUCCESS:
raise AcsToolException(AcsToolException.OPERATION_FAILED,
status_msg)
else:
return signed_app
def set_file_owner(self, file_name, owner, owner_group=None):
"""
Set the file owner and groupe.
:type file_name: str
:param file_name: name of the file (the absolute pat of the file)
:type owner: str
:param owner: the owner to set
:type owner_group: str
:param owner_group: the owner group
:rtype: tuple (str,str)
:return: (owner, owner_group), these value can be equal to None if failed to be found
"""
if owner_group is None:
cmd = "adb shell chown %s %s" % (owner, file_name)
else:
cmd = "adb shell chown %s:%s %s" % (owner, owner_group, file_name)
# Sending the command.
output = self._exec(cmd, force_execution=True).strip()
if not self.is_shell_output_ok(output):
msg = "error when try to change file owner :" + output
self._logger.error(msg)
raise AcsToolException(AcsToolException.OPERATION_FAILED, msg)
def _build_list_from_dict(self, input_dict, input_string):
"""
Returns a list built from the given dict and given str key.
The input str's expected format shall be a python-like
list description.
:type input_dict: dictionary list
:param input_dict: the dictionnary list to parse
:type input_string: str
:param input_string: the str key to extract
:raise AcsToolException: if the provided parameter is not valid
:rtype: list
:return: a list of str built from the provided dict and str parameter
"""
try:
output_list = []
for input_dict_elt in input_dict:
if input_string in input_dict_elt:
output_list.append(input_dict_elt[input_string])
except (KeyboardInterrupt, SystemExit):
raise
except:
raise AcsToolException(
AcsToolException.INVALID_PARAMETER,
"Invalid input dict retrieved: %s" % (str(input_dict)))
return output_list
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 unzip(self, file_name):
"""
Unzip a file on the DUT.
:type file_name: str
:param file_name: name of the file (the absolute path of the file on DUT)
:rtype: str
:return: return path+name of unzipped file if successful. Throws AcsToolException.OPERATION_FAILED if there's an error.
"""
# Find out size of the file to use as a basis for calculating a timeout for the unzip command. ls -l should put that in column 4.
cmd = "adb shell stat -c %%s %s " % file_name
(return_code, output) = self._device.run_cmd(cmd, timeout=10)
if return_code != Utils.Global.SUCCESS:
msg = "uecmd unzip: Error '%s' when trying to list the file '%s'" % (
output, file_name)
self._logger.error(msg)
raise AcsToolException(AcsToolException.OPERATION_FAILED, msg)
# Trusting that 'ls -l' provided file size in column 4. If this does not have a number, then 'int' will throw an exception.
file_size = int(output)
timeout = int(file_size / 4096)
if timeout < 100000:
# Set a 100s minimum unzip timeout for small files
timeout = 100000
simple_filename = os.path.basename(file_name)
device_path = os.path.dirname(file_name)
cmd = "adb shell cd " + device_path + "; gunzip -f " + simple_filename
if simple_filename[-4:].lower() == ".tgz":
unzipped_name = file_name[:-4] + ".tar"
elif simple_filename[-3:].lower() == ".gz":
unzipped_name = file_name[:-3]
else:
msg = "uecmd unzip: unsupported filename extension in '%s'. Expected a .gz or .tgz file." % simple_filename
self._logger.error(msg)
raise AcsToolException(AcsToolException.OPERATION_FAILED, msg)
(return_code, output_msg) = self._device.run_cmd(cmd, timeout=timeout)
if return_code != Utils.Global.SUCCESS:
msg = "uecmd unzip: Error '%s' when running '%s'" % (output_msg,
cmd)
self._logger.error(msg)
raise AcsToolException(AcsToolException.OPERATION_FAILED, msg)
return unzipped_name
def __build_list_from_zip(self, flash_file):
# Check
if self.__check_zip_file_integrity(flash_file):
return self.__unzip_file_get_list(flash_file)
else:
err_msg = "FTE2: Unable to treat %s zip flash file" % str(
self._flash_file)
raise AcsToolException(AcsToolException.CRITICAL_FAILURE, err_msg)
def run(self, context):
"""
Runs the test step
:type context: TestStepContext
:param context: test case context
"""
TestStepBase.run(self, context)
self._logger.info(
"Saves input value (%s) into context using variable name (%s)...",
self._pars.input_1, self._pars.ctx_data_1)
context.set_info(self._pars.ctx_data_1, self._pars.input_1)
self._logger.info(
"Saves input values (%s and %s) into context bundle using variable name (%s)...",
self._pars.input_1, self._pars.input_2, self._pars.ctx_data_2)
context.set_nested_info([self._pars.ctx_data_2, "INPUT_1"],
self._pars.input_1)
context.set_nested_info([self._pars.ctx_data_2, "INPUT_2"],
self._pars.input_2)
self._logger.info("Generates return code (%s), with comment (%s)...",
self._pars.return_code, self._pars.comment)
self.ts_verdict_msg = self._pars.comment
if self._pars.return_code == "SUCCESS":
pass
elif self._pars.return_code == "FAILURE":
raise DeviceException(DeviceException.OPERATION_FAILED,
self._pars.comment)
elif self._pars.return_code == "BLOCKED":
raise AcsToolException(AcsToolException.OPERATION_FAILED,
self._pars.comment)
elif self._pars.return_code == "ACS_EXCEPTION":
raise AcsToolException(AcsToolException.OPERATION_FAILED,
self._pars.comment)
elif self._pars.return_code == "DEVICE_EXCEPTION":
raise DeviceException(DeviceException.OPERATION_FAILED,
self._pars.comment)
elif self._pars.return_code == "UNKNOWN_EXCEPTION":
raise ValueError(self._pars.comment)
else:
raise AcsToolException(AcsToolException.OPERATION_FAILED,
self._pars.comment)
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 run(self, context):
"""
Create a random file
:type context: TestStepContext
:param context: test case context
"""
TestStepBase.run(self, context)
destination_path = self._pars.destination_path # Destination path
if destination_path == '[TEMP]':
destination_path = tempfile.mkdtemp()
if self._pars.rand_file_size_min is not None:
if self._pars.rand_file_size_min >= self._pars.rand_file_size:
self._logger.error(
"{0}: RAND_FILE_SIZE_MIN of {1} cannot be <= to RAND_FILE_SIZE, which is = {2}"
.format(self._pars.id, self._pars.rand_file_size_min,
self._pars.rand_file_size))
msg = "{0}: RAND_FILE_SIZE_MIN of {1} cannot be <= to RAND_FILE_SIZE, which is = {2}".format(
self._pars.id, self._pars.rand_file_size_min,
self._pars.rand_file_size)
raise AcsBaseException(AcsBaseException.INVALID_PARAMETER, msg)
else:
rand_file_size_min = self._pars.rand_file_size_min
else:
rand_file_size_min = 0
if rand_file_size_min > 0:
rand_file_size = int(
random.randrange(rand_file_size_min,
self._pars.rand_file_size + 1))
else:
rand_file_size = self._pars.rand_file_size
rand_file_seed = self._pars.rand_file_seed
rand_file_name = self._pars.rand_file_name
self._logger.debug(
"%s: rand_file_size = %d, rand_file_seed = %d, rand_file_name = %s "
% (self._pars.id, rand_file_size, rand_file_seed, rand_file_name))
file_path = os.path.join(destination_path, rand_file_name)
try:
# Create the file
self.create_rand_bin_file(file_path=file_path,
file_size_mb=rand_file_size,
seed=rand_file_seed)
except Exception as e:
raise AcsToolException(AcsToolException.DEFAULT_ERROR_CODE, str(e))
# Check the file was created
if os.path.exists(file_path):
self._logger.info("{0}: Created {1} to {2}".format(
self._pars.id, rand_file_name, destination_path))
context.set_info(self._pars.ctx_destination_path, file_path)
else:
msg = "{0}: Failed to create {1} to {2}".format(
self._pars.id, rand_file_name, destination_path)
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
def _do_folder_operation(self, folder_level, folder_name_length, src_path):
"""
Do the file operation with parameters.
:type folder_level: int
:param folder_level: The folder level.
:type folder_sub_number: int
:param folder_sub_number: The sub folder number in each folder.
:type folder_name_length: int
:param folder_name_length: The folder name length, name will generate randomly.
:type src_path: str
:param src_path: The path of file or folder will be created.
:rtype: list
:return: operation status & output log
"""
# FOLDER CREATION TEST eg toto file on EMMC
# The path of file or folder will be created, emmc|mnt_sdcard|mnt_sdcard_ext
status = False
# Generate file name(s)
folder_name = binascii.b2a_hex(os.urandom(folder_name_length / 2))
folder_name = src_path + folder_name
# Check if sdcard requested, if requested, mount it
self._auto_mount_external_drive(folder_name)
# create folder(s)
self._logger.info("Create folder %s ..." % folder_name)
self.create_folder(folder_name)
self._logger.info("Check folder creation ...")
status, output = self.exist(folder_name)
if not status:
msg = "Folder %s does not exists !" % folder_name
raise AcsToolException(AcsToolException.OPERATION_FAILED, msg)
# delete folder
self.delete(folder_name)
if not status:
raise AcsToolException(AcsToolException.OPERATION_FAILED, output)
# If operations succeed, return True
return status
def untar(self, file_name, destination=None, unzip=False):
"""
Untar a file on the DUT. Throws AcsToolException.OPERATION_FAILED if there's an error.
:type file_name: str
:param file_name: name of the file (the absolute path of the file on DUT)
:type destination: str
:param destination: folder where to unzip the file (the absolute path of the folder on DUT).
:type unzip: boolean
:param unzip: if True archive will be unzipped before being extracted
"""
# Find out size of the file to use as a basis for calculating a timeout for the unzip command. ls -l should put that in column 4.
cmd = "adb shell stat -c %%s %s" % file_name
(return_code, output) = self._device.run_cmd(cmd, timeout=10)
if return_code != Utils.Global.SUCCESS:
msg = "uecmd untar: Error '%s' when trying to list the file '%s'" % (
output, file_name)
self._logger.error(msg)
raise AcsToolException(AcsToolException.OPERATION_FAILED, msg)
# Trusting that 'ls -l' provided file size in column 4. If this does not have a number, then 'int' will throw an exception.
file_size = int(output)
timeout = int(file_size / 4096)
if timeout < 100000:
# Set a 100s minimum unzip timeout for small files
timeout = 100000
device_path = os.path.dirname(file_name)
options = "-xzf" if unzip else "-xf"
cmd = "adb shell cd " + device_path + "; tar " + options + " " + file_name
if destination:
# add option to command
cmd += " -C " + destination
# create output folder if needed
_, dest_exists = self.exist(destination)
if not dest_exists:
self._exec("adb shell mkdir -p " + destination, 1)
(return_code, output_msg) = self._device.run_cmd(cmd, timeout=timeout)
if return_code != Utils.Global.SUCCESS:
msg = "uecmd untar: Error '%s' when running '%s'" % (output_msg,
cmd)
self._logger.error(msg)
raise AcsToolException(AcsToolException.OPERATION_FAILED, msg)
def _perform_ims_deregistration(self):
"""
Perform IMS de-registration using AT command / IMS config
:return: the verdict and its corresponding message
:rtype: int, str
:raise AcsToolException OPERATION_FAILED: if an error occurred during the
AT command execution.
"""
# Initialize local variables
verdict = Global.SUCCESS
message = "No error"
# AT Command for un register fails if the DUT is not registered to IMS
registration_status = self._get_registration_status()
self._logger.info("Registration status: %s (expected %s)." % (
str(registration_status),
str(ImsRegistrationStatus.in_service())))
state = (registration_status != ImsRegistrationStatus.in_service())
self._logger.debug("Comparison status: %s" % str(state))
if registration_status != ImsRegistrationStatus.in_service():
self._logger.info("DUT is not registered to IMS, nothing to do.")
return (Global.SUCCESS, "Nothing to do.")
if self._ims_configure_modem_procedure == "IMS_ANDROID":
# Turn off IMS
self._modem_api.turn_ims("OFF")
# Wait 5 seconds
time.sleep(5)
else:
# Execute at+xireg=0 command
(status, message) = self._execute_at_command("at+xireg=0")
if status != Global.SUCCESS:
message = "%s (%s)." % (
"An error occured during IMS de-registration",
message)
raise AcsToolException(
AcsToolException.OPERATION_FAILED,
message)
# Wait 15 seconds
time.sleep(15)
# Check the registration status for IMS, should be "OUT_OF_SERVICE"
ims_service_status = ImsRegistrationStatus.out_of_service()
# Log the latest IMS registration status
registration_status = self._get_registration_status()
self._logger.info("Registration status: %s (%d)" % (
str(registration_status),
registration_status.as_int()))
if registration_status != ims_service_status:
verdict = Global.FAILURE
message = "IMS is still registered after registration OFF."
return (verdict, message)
def _run(self):
"""
Run stop acquisition
"""
if self._patlib is None:
raise AcsToolException(
AcsToolException.PROHIBITIVE_BEHAVIOR,
"Cannot report acquisition, PatLib has not been initialized")
report = self._patlib.report(self._pars.do_power_calculation)
self._context.set_info(self._pars.save_as, report)
def _run(self):
"""
Run stop acquisition
"""
if self._patlib is None:
raise AcsToolException(
AcsToolException.PROHIBITIVE_BEHAVIOR,
"Cannot do acquisition, PatLib has not been initialized")
acquisition_status = self._context.get_info("AcquisitionStatus")
if acquisition_status == "Stopped":
# retrieve all measurements of previous acquisition
measures = self._patlib.get_measurements()
if not measures:
raise AcsToolException(AcsToolException.OPERATION_FAILED,
"Cannot retrieve any measure")
# retrieve all measures according to rail name
measures = [
measure for measure in measures
if measure.get("name") == self._pars.measure_name
]
if not measures:
raise AcsToolException(
AcsToolException.OPERATION_FAILED,
"Cannot retrieve measure for {0}".format(
self._pars.measure_name))
# retrieve all measures according to measure type (average or max or min)
measures = [
measure[self._pars.measure_type] for measure in measures
if measure.get(self._pars.measure_type) is not None
]
if not measures:
raise AcsToolException(
AcsToolException.OPERATION_FAILED,
"Cannot retrieve measure {0} for {1}".format(
self._pars.measure_type, self._pars.measure_name))
self._context.set_info(self._pars.save_as, measures[-1])
else:
raise AcsToolException(
AcsToolException.PROHIBITIVE_BEHAVIOR,
"Cannot get acquisition: Status %s instead of Stopped " %
acquisition_status)
def _compute_score(self, measures, rail):
"""
Compute result according to specified operation
"""
functor = get_math_function(self._pars.operation)
raw_results = []
if not rail in measures:
raise AcsToolException(
AcsToolException.PROHIBITIVE_BEHAVIOR,
"Measure does not contains '{0}' residency information".format(
rail))
for measure in measures[rail]:
value = measure.get("average")
if value is None:
raise AcsToolException(
AcsToolException.PROHIBITIVE_BEHAVIOR,
"Cannot retrieve residency {0}".format(rail))
raw_results.append(value)
computed_result = str(functor(raw_results))
return computed_result
def is_equal(self, file1, file2):
"""
compare the checksum of 2 files to see is they are equals
:type file1: str
:param file1: first file to compare from
:type file2: str
:param file2: second file to compare with
:rtype: tuple
:return: (boolean operation success, error msg)
"""
self._logger.info("comparing if file %s is equal to %s" %
(file1, file2))
cmd = "adb shell md5 %s" % file1
output = self._exec(cmd).strip()
if self.is_shell_output_ok(output):
sum1 = output.split(" ")[0].strip()
else:
msg = "error when generating md5sum value :" + output
self._logger.error(msg)
raise AcsToolException(AcsToolException.OPERATION_FAILED, msg)
cmd = "adb shell md5 %s" % file2
output = self._exec(cmd).strip()
if self.is_shell_output_ok(output):
sum2 = output.split(" ")[0].strip()
else:
msg = "error when generating md5sum value :" + output
self._logger.error(msg)
raise AcsToolException(AcsToolException.OPERATION_FAILED, msg)
if sum1 == sum2:
msg = "Files %s and %s are identical" % (file1, file2)
else:
msg = "Files %s and %s are different" % (file1, file2)
return sum1 == sum2, msg
def _download2cache(self, resp, a_name):
"""
:param resp: :class:`requests.Response <requests.Response>` (:mod:`requests`)
:type resp: HTTPResponse
:param a_name: Artifact's name
:type a_name: str
:return: A Cached Artifact instance
:rtype: Cache.CachedArtifact
:raises: AcsBaseException.OPERATION_FAILED
AcsToolException.HOST_OPERATION_TIMEOUT,
AcsConfigException.INVALID_PARAMETER,
ArtifactoryCacheManager.Error,
IOError,
OSError,
WindowsError (if windows platform)
"""
cache_exc = self.__cache_engine.Error
try:
_, _, local_path = self.__http_downloader.download(resp)
if not path.isfile(local_path):
raise AcsToolException(
AcsToolException.OPERATION_FAILED,
"Downloaded Artifact {0} with path: "
"{1} is not VALID!".format(a_name, local_path))
art = self.__cache_engine.add(a_name, local_path)
except (SysErrors, cache_exc):
# We ensure that if any exception occur, we wrapped it into more detailed one properly
msg = ("Exception occurred while Downloading "
"to Cache remote Artifact {0} - "
"Detailed exception below:\n{1}".format(
a_name, traceback.format_exc()))
raise AcsToolException(AcsToolException.OPERATION_FAILED, msg)
return art
def __is_mms_sent(self, time_out):
"""
Method that will wait for the MMS to be send.
It will wait for the MMS to be send until the timeout has been reached.
:type time_out: int
:param time_out: time to wait for the MMS to be send.
:rtype: str
:return: the time when the message has been sent.
:raise AcsToolException: if the output is missing one of the expected keys.
:raise DeviceException: if the message takes more time than the timeout to be sent.
"""
# Defining task id key for passing parameters to embedded.
message_id_key = "msg_id"
thread_id_key = "thread_id"
sent_time_key = "sent_time"
# Defining functions name.
function = "isMmsSent"
is_mms_sent = False
start_time = time.time()
while (time.time() - start_time) < time_out and is_mms_sent == False:
output = self._internal_exec_v2(
self._mms_module,
function,
"--es %s %s --es %s %s" % (message_id_key, self.sent_msg_id,
thread_id_key, self.sent_thread_id),
is_system=True)
if sent_time_key not in output:
raise AcsToolException(
AcsToolException.INVALID_PARAMETER,
"output key %s not found: %s" % (message_id_key, output))
if output.get(sent_time_key) != "-1":
is_mms_sent = True
else:
time.sleep(5)
if is_mms_sent:
msg = "Send Command was succesfull. Message found with id: %s in conversation: %s" \
% (self.sent_msg_id, self.sent_thread_id)
self._logger.info(msg)
return output.get(sent_time_key)
else:
message_box_name = self.__get_mms_box()
raise DeviceException(
DeviceException.TIMEOUT_REACHED,
"The Mms was not send in time (waited %s seconds). It is in the %s box "
% (time_out, message_box_name))
