def run_test(self):
"""
Execute the test
"""
# Call LAB_EGPRS_BASE Run function
LabEgprsBase.run_test(self)
# init values
self._error.Code = Global.FAILURE
self._error.Msg = "ping failed"
time.sleep(self._wait_btwn_cmd)
packet_loss = self._networking_api.\
ping(self._server_ip_address,
self._packet_size,
self._nb_pings)
# Compute verdict depending on % of packet loss
if packet_loss.value > self._target_ping_packet_loss_rate:
self._error.Code = Global.FAILURE
else:
self._error.Code = Global.SUCCESS
self._error.Msg = "Measured Packet Loss: %.0f%s (Target: %.0f%s)"\
% (packet_loss.value,
packet_loss.units,
self._target_ping_packet_loss_rate,
packet_loss.units)
return self._error.Code, self._error.Msg
def run_test(self):
"""
Execute the test
"""
# Call LAB_EGPRS_BASE Run function
LabEgprsBase.run_test(self)
# Run FTP transfer using FTP parameters :
# - LAB_SERVER parameters (ip, username, password)
# - DIRECTION
# - DL_FILE or UL_FILE
# - XFER_TIMEOUT
time.sleep(self._wait_btwn_cmd)
return perform_ftp_transfer(self._direction,
self._server_ip_address,
self._username,
self._password,
self._filename,
self._xfer_timeout,
self._device.multimedia_path,
self._ns_DUT_IP_Address,
self._ftp_api,
self._throughput_targets.ul_failure.value,
self._logger,
self._dlfilename,
self._throughput_targets.dl_failure.value,
self._device.multimedia_path)
def run_test(self):
"""
Execute the test
"""
# Call LAB_EGPRS_BASE Run function
LabEgprsBase.run_test(self)
# Start IPERF measurement using PORT
# and DURATION and LAB_SERVER ip_address parameters
time.sleep(self._wait_btwn_cmd)
throughput = self._networking_api.iperf(self._iperf_settings)
# Compute verdict depending on throughputs
return compute_iperf_verdict(throughput, self._throughput_targets,
self._iperf_direction)
def run_test(self):
"""
Execute the test
"""
# Call LAB_EGPRS_BASE Run function
LabEgprsBase.run_test(self)
time.sleep(self._wait_btwn_cmd)
# Ping ftp server to verify pdp context actived.
# Ping should be successful
packet_loss = self._networking_api.ping(self._server_ip_address,
self._packet_size,
self._nb_pings)
self._error.Msg = "Measured Packet Loss: %.0f%s (Target: %.0f%s)" % (
packet_loss.value, packet_loss.units,
self._target_ping_packet_loss_rate, packet_loss.units)
# Compute verdict depending on % of packet loss
# Pdp Context active, ping should be successful
if packet_loss.value > self._target_ping_packet_loss_rate:
raise DeviceException(DeviceException.OPERATION_FAILED,
self._error.Msg)
else:
self._logger.info("Ping successful: %s" % self._error.Msg)
# Deactivate pdp context
self._networking_api.deactivate_pdp_context(self._ssid)
# Ping ftp server to verify pdp context deactivated.
# The test should be failed
try:
packet_loss = self._networking_api.ping(self._server_ip_address,
self._packet_size,
self._nb_pings)
except AcsBaseException as error:
self._logger.info(error.get_error_message())
except:
raise DeviceException(
DeviceException.OPERATION_FAILED,
"PDP context isn't correctly deactivated,"
" ping packets reach the server.")
# Re-activate pdp context
self._networking_api.activate_pdp_context(self._ssid)
self._ns_data_2g.check_data_connection_state(
"PDP_ACTIVE", self._registration_timeout, blocking=False)
packet_loss = self._networking_api.ping(self._server_ip_address,
self._packet_size,
self._nb_pings)
# Compute verdict depending on % of packet loss
# Pdp Context active, ping should be successful
if packet_loss.value > self._target_ping_packet_loss_rate:
raise DeviceException(DeviceException.OPERATION_FAILED,
self._error.Msg)
else:
self._logger.info("Ping successful: %s" % self._error.Msg)
return Global.SUCCESS, "No errors"
def run_test(self):
"""
Execute the test
"""
# Call LAB_HSPA_BASE Run function
LabEgprsBase.run_test(self)
result = Global.SUCCESS
measure_throughput_msg = "Measured throughput:"
failure_throughput_msg = "Failure throughput:"
# Run FTP transfer using FTP parameters :
# - LAB_SERVER parameters (ip, username, password)
# - DIRECTION
# - DL_FILE or UL_FILE
# - XFER_TIMEOUT
time.sleep(self._wait_btwn_cmd)
# Start to search the trigger_msg in the logcat log
self._device_logger = self._device.get_device_logger()
self._start_ftp_trigger_msg = "status::SUCCESS - output::RECEIVED - " \
"function::startFtpXfer"
self._device_logger.add_trigger_message(self._start_ftp_trigger_msg)
self._logger.info("FTP transfer " + str(self._direction) + " for " +
str(self._ftp_filename) + "...")
self._ftp_task_id = self._networking_api.start_ftp_xfer(
self._direction, self._server_ip_address, self._username,
self._password, self._ftp_filename, self._device.get_ftpdir_path())
# Get the ftp start log msg and retrieve the OP code from the message
self._op_code_message = self._device_logger.\
get_message_triggered_status(self._start_ftp_trigger_msg)
self._device_logger.remove_trigger_message(self._start_ftp_trigger_msg)
self._op_code = re.findall(r'ACS\_\d*', str(self._op_code_message))[0]
# wait 5 seconds for ensure that transfer is established
self._logger.info(
"Wait %d seconds for ensure that transfer is established" %
self._wait_time_before_measure)
time.sleep(self._wait_time_before_measure)
data_throughput_dict = self._ns.get_data_throughput(
self._measurement_duration, self._failure_throughput_dict.keys())
# Timeout to wait for the ftp success message
self._timeout = self._xfer_timeout - self._measurement_duration\
- self._wait_time_before_measure
self._device_logger.add_trigger_message(self._op_code)
# Create success_msg which send by ACS_AGENT.apk
ftp_filename = os.path.split(self._ftp_filename)[1]
success_msg = "Ftp %s of file %s finish success" % (self._direction,
ftp_filename)
# Parse the logcat log, Wait for the success_msg
while self._timeout > 0:
triggered_status = self._device_logger.\
get_message_triggered_status(self._op_code)
# When the success message is in the message of ACS op code
if success_msg in str(triggered_status):
self._logger.info(str(triggered_status))
self._device_logger.remove_trigger_message(self._op_code)
break
else:
time.sleep(1)
self._timeout -= 1
else:
self._device_logger.remove_trigger_message(self._op_code)
self._networking_api.stop_ftp_xfer(self._ftp_task_id)
self._error.Msg = "The FTP transfer doesn't finish in the timeout"
raise DeviceException(DeviceException.TIMEOUT_REACHED,
self._error.Msg)
for data_type in data_throughput_dict.keys():
if "Mbps" in data_throughput_dict[data_type][0]:
# Convert to kbps for result compare
if float(data_throughput_dict[data_type][0][0:-4]) * 1000 < \
self._failure_throughput_dict[data_type]:
result = Global.FAILURE
elif "Kbps" in data_throughput_dict[data_type][0]:
if float(data_throughput_dict[data_type][0][0:-4]) < \
self._failure_throughput_dict[data_type]:
result = Global.FAILURE
elif "bps" in data_throughput_dict[data_type][0]:
if float(data_throughput_dict[data_type][0][0:-4]) / 1000 < \
self._failure_throughput_dict[data_type]:
result = Global.FAILURE
else:
self._error.Msg = "unknown measure result unit: %s " % \
str(data_throughput_dict[data_type][0])
raise DeviceException(DeviceException.PROHIBITIVE_MEASURE,
self._error.Msg)
measure_throughput_msg = measure_throughput_msg + str(data_type) \
+ ":" + str(data_throughput_dict[data_type][0]) + " "
failure_throughput_msg = failure_throughput_msg + str(data_type) \
+ ":" + str(self._failure_throughput_dict[data_type]) + "Kbps" + " "
self._error.Msg = measure_throughput_msg + "- " + failure_throughput_msg
return result, self._error.Msg