def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call LAB_EM_BASE Init function
UseCaseBase.__init__(self, tc_name, global_config)
# Read the unplug/plug timeout from testcase
self._unplug_plug_timeout = int(
self._tc_parameters.get_param_value("UNPLUG_PLUG_TIMEOUT"))
# Read minimum charge variation from testcase
self._min_capacity_variation = int(
self._tc_parameters.get_param_value("CAPACITY_VARIATION"))
# Read maximum battery capacity from testcase
self.__max_capacity = int(
self._tc_parameters.get_param_value("MAXIMUM_CAPACITY"))
# Read charging timeout from testcase
self._charging_timeout = int(
self._tc_parameters.get_param_value("CHARGING_TIMEOUT"))
# Get uecmd api
self.__networking_api = self._device.get_uecmd("Networking")
self.__em_api = self._device.get_uecmd("EnergyManagement")
self.__phonesystem_api = self._device.get_uecmd("PhoneSystem")
self.__camera_api = self._device.get_uecmd("Camera")
self.__initial_brightness_value = None
self.__initial_sleep_timeout_value = None
def __init__(self, tc_name, global_config):
"""
Initializes this instance.
"""
# Call UseCase base __init__ method
UseCaseBase.__init__(self, tc_name, global_config)
# Retrieve testcase parameters
self.__launch_mode = self._tc_parameters.get_param_value("LAUNCH_MODE")
self.__command = self._tc_parameters.get_param_value("COMMAND")
self.__expected_result = \
self._tc_parameters.get_param_value("EXPECTED_RESULT")
self.__command_timeout = \
self._tc_parameters.get_param_value("COMMAND_TIMEOUT")
# initialize at proxy connection parameters
self.__serial_handler = SerialHandler()
# Instantiate the modem UE commands
self.__modem_flashing_api = self._device.get_uecmd("ModemFlashing")
# Check input parameter LAUNCH_MODE
possible_launch_mode = {"NORMAL": ModemFlashing.AT_PROXY_NORMAL_MODE,
"TUNNELING": ModemFlashing.AT_PROXY_TUNNELING_MODE}
if self.__launch_mode in possible_launch_mode.keys():
self.__launch_mode = possible_launch_mode[self.__launch_mode]
else:
self.__launch_mode = None
# Check input parameter COMMAND_TIMEOUT
if is_number(self.__command_timeout) is True:
self.__command_timeout = int(self.__command_timeout)
else:
self.__command_timeout = None
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call UseCase base Init function
UseCaseBase.__init__(self, tc_name, global_config)
# Read callSetupTimeout from Phone_Catalog.xml
self._call_setup_time = \
int(self._dut_config.get("callSetupTimeout"))
# Get TC Parameters
self._target_sim = int(
self._tc_parameters.get_param_value("TARGET_SIM"))
self._restore_initial = \
str_to_bool(self._tc_parameters.get_param_value("RESTORE_INITIAL"))
# Get UECmdLayer
self._modem_api = self._device.get_uecmd("Modem")
self._phone_system = self._device.get_uecmd("PhoneSystem")
self._networking_api = self._device.get_uecmd("Networking")
self._initial_target_sim = None
self._initial_pdp_context_status = None
def __init__(self, tc_name, global_config):
"""
Constructor
"""
UseCaseBase.__init__(self, tc_name, global_config)
# Read parameters from test case parameters :
# - EQUIPMENT_IP_ADDRESS
# - EQUIPMENT_PORT
# - CONFIGURATION_FILE
# - TESTCASE_NAME
self._eqp_ip_address = \
str(self._tc_parameters.get_param_value("EQUIPMENT_IP_ADDRESS"))
self._eqp_port = \
str(self._tc_parameters.get_param_value("EQUIPMENT_PORT"))
self._conf_filename = \
str(self._tc_parameters.get_param_value("CONFIGURATION_FILE"))
self._testcase_name = \
str(self._tc_parameters.get_param_value("TESTCASE_NAME"))
# Initialize equipment parameters (MLAPI ip, port)
self._mlapi_table = {}
self._xdd_explorer_service = \
"http://%s:%s/axis2/services/XDDExplorerRemoteControlService" % \
(self._eqp_ip_address, self._eqp_port)
self._prj_explorer_service = \
"http://%s:%s/axis2/services/ProjectExplorerRemoteControlService" % \
(self._eqp_ip_address, self._eqp_port)
# Get Computer instance from Bench Config
self._computer = self._em.get_computer("COMPUTER1")
self._is_eqp_network_reachable = False
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call UseCase base Init function
UseCaseBase.__init__(self, tc_name, global_config)
# get IMAGE_URI from TC parameters
self.__image_to_display_uri = self._tc_parameters.get_param_value(
"IMAGE_URI")
# get SCRIPT_PATH from TC parameters
self.__script = \
str(self._tc_parameters.get_param_value("SCRIPT_PATH"))
# get ERROR_MANAGEMENT_POLICY from TC parameters
self._error_policy = str(
self._tc_parameters.get_param_value("ERROR_MANAGEMENT_POLICY"))
# get ENABLE_UI_AUTOMATOR_EVENT from TC parameters
self._ui_automator_event = self._tc_parameters.get_param_value(
"ENABLE_UI_AUTOMATOR_EVENT",
default_value=False,
default_cast_type="str_to_bool")
# get LIBRARY_IMAGE_PATH from TC parameters
self.__library_image_path = self._tc_parameters.get_param_value(
"LIBRARY_IMAGE_PATH")
# get REFERENCE_IMAGE_ZOOM_IN from TC parameters
self.__ref_image_zoom_in = self._tc_parameters.get_param_value(
"REFERENCE_IMAGE_ZOOM_IN")
# get PHOTOS_ICON from TC parameters
self.__photos_icon = self._tc_parameters.get_param_value("PHOTOS_ICON")
# get JUST_ONCE_ICON from TC parameters
self.__just_once_icon = self._tc_parameters.get_param_value(
"JUST_ONCE_ICON")
# get DEFAULT_ORIENTATION from TC parameters
self.__default_orientation = self._tc_parameters.get_param_value(
"DEFAULT_ORIENTATION")
# Get UECmdLayer.
self.__image_api = self._device.get_uecmd("Image")
self.__phone_system_api = self._device.get_uecmd("PhoneSystem")
self.__display_api = self._device.get_uecmd("Display")
self.__multimedia_api = self._device.get_uecmd("Multimedia")
self.__key_event_api = self._device.get_uecmd("KeyEvent")
self._ui_api = self._device.get_uecmd("Ui")
self._ui_api.set_global_config(global_config)
#Image library
self.__dic_image = Imagecheck.generate_dictionary_image_path(
self.__library_image_path)
self.__pictures_uri = []
self.__wait_for_icons = 5
self.__time_for_display = 3
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call UseCase base Init function
UseCaseBase.__init__(self, tc_name, global_config)
# Get UECmdLayer for Data Use Cases
self._networking_api = self._device.get_uecmd("Networking")
self._modem_api = self._device.get_uecmd("Modem")
# Initialize some attributes
self._boot_timeout = None
self._settledown_duration = None
# Get bootTimeout value either from parameter file or
# default value from phone catalog
if self._tc_parameters.get_param_value("BOOT_TIMEOUT") != "":
self._boot_timeout = \
int(self._tc_parameters.get_param_value("BOOT_TIMEOUT"))
# Get settledown duration value either from parameter file or
# default value from phone catalog
if self._tc_parameters.get_param_value("SETTLEDOWN_DURATION") != "":
self._settledown_duration = \
int(self._tc_parameters.get_param_value("SETTLEDOWN_DURATION"))
# turn on mobile broadband
self._networking_api.reset_mobile_broadband_mode(1)
def __init__(self, tc_name, global_config):
"""
Constructor
"""
UseCaseBase.__init__(self, tc_name, global_config)
self._system_api = self._device.get_uecmd("System")
self._app_api = self._device.get_uecmd("AppMgmt")
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call UseCase base Init function
UseCaseBase.__init__(self, tc_name, global_config)
# get CAMERA name from TC parameters
self.__camera = self._tc_parameters.get_param_value("CAMERA")
# get RECORD_DURATION from TC parameters
self.__record_duration = self._tc_parameters.get_param_value(
"RECORD_DURATION", default_cast_type=int)
# get SAVE_DIRECTORY from TC parameters
self.__save_directory = self._tc_parameters.get_param_value(
"SAVE_DIRECTORY")
# Get UECmdLayer
self.__camera_api = self._device.get_uecmd("Camera")
self.__save_folder = os.path.join(
self._name + "-" +
datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S'), "")
self.__hd_resolution = (1920, 1080)
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call UseCase base Init function
UseCaseBase.__init__(self, tc_name, global_config)
# get ICON_DICT from TC param
self.__icon_dict_mode = str_to_dict(
self._tc_parameters.get_param_value("ICON_DICT_MODE"))
self.__icon_dict_option = str_to_dict(
self._tc_parameters.get_param_value("ICON_DICT_OPTION"))
self.__hardware = self._tc_parameters.get_param_value(
"HARDWARE").lower()
# Get UECmdLayer
self._image_api = self._device.get_uecmd("Image")
self._system_api = self._device.get_uecmd("System")
self._phonesystem_api = self._device.get_uecmd("PhoneSystem")
self._keyevent_api = self._device.get_uecmd("KeyEvent")
self._multimedia_api = self._device.get_uecmd("Multimedia")
self._camera_api = self._device.get_uecmd("Camera")
# store initial Sleep Timeout value
self._initial_sleep_timeout_value = self._phonesystem_api.get_screen_timeout(
)
time.sleep(self._wait_btwn_cmd)
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call UseCaseBase initializer
UseCaseBase.__init__(self, tc_name, global_config)
# Initialize required parameters
self._initial_flight_mode_state = None
# Read parameters and convert them to their final type
self._check_bt = \
str(self._tc_parameters.get_param_value("CHECK_BT"))
self._check_bt = str_to_bool(self._check_bt)
self._check_nfc = \
str(self._tc_parameters.get_param_value("CHECK_NFC"))
self._check_nfc = str_to_bool(self._check_nfc)
self._check_wlan = \
str(self._tc_parameters.get_param_value("CHECK_WLAN"))
self._check_wlan = str_to_bool(self._check_wlan)
self._check_gps = \
str(self._tc_parameters.get_param_value("CHECK_GPS"))
self._check_gps = str_to_bool(self._check_gps)
# Arbitrary value for timeout in seconds
self._radio_activation_timeout = 40
# Instantiate UE Command categories
self._networking_api = self._device.get_uecmd("Networking")
self._connectivity_api = self._device.get_uecmd("LocalConnectivity")
self._phonesystem_api = self._device.get_uecmd("PhoneSystem")
self._location_api = self._device.get_uecmd("Location")
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call UseCase base Init function
UseCaseBase.__init__(self, tc_name, global_config)
self._global_config = global_config
# Initialize variables
self._audio_filename = str(self._tc_parameters.get_param_value("FILENAME", ""))
self._multimedia_volume = self._tc_parameters.get_param_value("VOLUME", -1, int)
self._audio_duration = self._tc_parameters.get_param_value("DURATION")
if self._audio_duration in [None, ""]:
self._audio_duration = ""
elif not str(self._audio_duration).isdigit():
self._audio_duration = -1
else:
self._audio_duration = float(self._audio_duration)
# Initialize variable for data connection
self._use_data_connection = False
# Get UECmdLayer
self._multimedia_api = self._device.get_uecmd("Multimedia")
self._audio_api = self._device.get_uecmd("Audio")
self._networking_api = self._device.get_uecmd("Networking")
self._phonesystem_api = self._device.get_uecmd("PhoneSystem")
self._system_api = self._device.get_uecmd("System")
def __init__(self, tc_name, global_config):
"""
Constructor
"""
UseCaseBase.__init__(self, tc_name, global_config)
# Read registrationTimeout from Device_Catalog.xml
self._registration_timeout = \
int(self._dut_config.get("registrationTimeout"))
# Get TC Parameters
self._destination_number = \
str(self._tc_parameters.get_param_value("DESTINATION_NUMBER"))
# Check if the sim phone number is used
if self._destination_number.upper() == "[PHONE_NUMBER]":
self._destination_number = self._device.get_phone_number()
self._message = \
str(self._tc_parameters.get_param_value("MESSAGE_CONTENT", ""))
# Read optional parameter PREFERRED_NETWORK_TYPE from xml parameters
self._network_pref = self._tc_parameters.get_param_value(
"PREFERRED_NETWORK_TYPE", None)
if self._network_pref:
self._network_pref = self._network_pref.upper()
self._initial_pref_network = None
# Retrieve ue commands instances
self._sms_api = self._device.get_uecmd("SmsMessaging")
self._mms_api = self._device.get_uecmd("MmsMessaging")
self._networking_api = self._device.get_uecmd("Networking")
self._modem_api = self._device.get_uecmd("Modem")
def __init__(self, tc_name, global_config):
"""
Constructor
"""
UseCaseBase.__init__(self, tc_name, global_config)
# Read callSetupTimeout from Phone_Catalog.xml
self._call_setup_time = \
int(self._dut_config.get("callSetupTimeout"))
# Initialize test case parameters
self._numtocall = None
self._callduration = None
self._msg_waiting_time = None
# Get Test Cases Parameters
self._numtocall = self._tc_parameters.get_param_value("PHONE_NUMBER")
self._callduration = \
self._tc_parameters.get_param_value("CALL_DURATION", 0)
self._msg_waiting_time = \
self._tc_parameters.get_param_value("MSG_WAITING_TIME", 0)
# Get UECmdLayer
self._vc_api = self._device.get_uecmd("VoiceCall")
# Getting the Networking API.
self._networking_api = self._device.get_uecmd("Networking")
# Getting the audio API.
self._audio_api = self._device.get_uecmd("AudioHost")
# Getting the messaging API.
self._msg_api = self._device.get_uecmd("SmsMessaging")
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call UseCase base constructor
UseCaseBase.__init__(self, tc_name, global_config)
# Sleep time
if self._tc_parameters.get_param_value("DURATION") is not None:
self._duration = \
int(self._tc_parameters.get_param_value("DURATION"))
self._sleep_mode = self._tc_parameters.get_param_value("MODE", "s3")
audio_file = self._tc_parameters.get_param_value("AUDIO_FILE", None)
self._audio_file = None
if audio_file:
self._audio_file = self._device.get_device_os_path().join(self._device.multimedia_path + audio_file)
if self._audio_file is None and self._sleep_mode == "lpmp3":
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER,
"Audio file is not set in test case parameter")
self._use_flightmode = self._tc_parameters.get_param_value("USE_FLIGHT_MODE", "false")
self._settle_time = int(self._tc_parameters.get_param_value("SETTLE_TIME", 0, int))
# Get UECmdLayer
self._phonesystem_api = self._device.get_uecmd("PhoneSystem")
self._sleep_mode_api = self._device.get_uecmd("SleepMode")
self._networking_api = self._device.get_uecmd("Networking")
self._residency_api = self._device.get_uecmd("Residencies")
# Retrieve targets
self._failure_file = os.path.join(self._execution_config_path,
self._device.get_config("FailureFile"))
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call UseCase base Init function
UseCaseBase.__init__(self, tc_name, global_config)
self._image_filename = "DUTScreenshot"
self._screenshot_path = ""
self._screenshot_state = False
self._swipe_timeout = 500
#Read the path of image library from testcase
self._library_image_path = self._tc_parameters.get_param_value("LIBRARY_IMAGE_PATH")
#Read value of different image from testcase
self._unlock_icon = self._tc_parameters.get_param_value("UNLOCK_ICON")
#Read value of force_orientation form testcase
self._force_orientation = self._tc_parameters.get_param_value("FORCE_ORIENTATION")
#Image library
self._dic_image = Imagecheck.generate_dictionary_image_path(self._library_image_path)
# Get UECmdLayer
self._image_api = self._device.get_uecmd("Image")
self._phonesystem_api = self._device.get_uecmd("PhoneSystem")
self._keyevent_api = self._device.get_uecmd("KeyEvent")
self._system_api = self._device.get_uecmd("System")
self._display_api = self._device.get_uecmd("Display")
def __init__(self, tc_name, global_config):
"""
Constructor
"""
UseCaseBase.__init__(self, tc_name, global_config)
self._oglconform = OGLConform()
self._report_pathname = self._device.get_report_tree().get_report_path(
)
self._output_filename = "%s/interim_results.csv" % self._report_pathname
# get TestCase parameters
self._feature_name = str(
self._tc_parameters.get_param_value("FEATURE_NAME", ""))
self._diag_parameter = str(
self._tc_parameters.get_param_value("DIAG_PARAMETER",
"")).split(";")
self._test_parameter = str(
self._tc_parameters.get_param_value("TEST_PARAMETER",
"")).replace("\n",
"").split(";")
self._khronos_parameter = str(
self._tc_parameters.get_param_value("KHRONOS_PARAMETER", ""))
self._remove_parameter = str(
self._tc_parameters.get_param_value("REMOVE_PARAMS",
"")).replace("\n",
"").split(";")
self.__tc_report = SecondaryTestReport(
self._device.get_report_tree().get_report_path())
self._khronos_output = "khronos_output.csv"
self.acs_gfx_results = ""
self._adb_remove = "adb shell rm -rf /data/app/"
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call UseCase base Init function
UseCaseBase.__init__(self, tc_name, global_config)
# Initialize some attributes
self._boot_timeout = None
self._settledown_duration = None
# Get bootTimeout value either from parameter file or
# default value from phone catalog
if self._tc_parameters.get_param_value("BOOT_TIMEOUT") != "":
self._boot_timeout = \
int(self._tc_parameters.get_param_value("BOOT_TIMEOUT"))
# Get settledown duration value either from parameter file or
# default value from phone catalog
if self._tc_parameters.get_param_value("SETTLEDOWN_DURATION") != "":
self._settledown_duration = \
int(self._tc_parameters.get_param_value("SETTLEDOWN_DURATION"))
# Instiate the PhoneSystem UE Command category
self._phone_system_api = self._device.get_uecmd("PhoneSystem")
def __init__(self, tc_name, global_config):
"""
Constructor
"""
UseCaseBase.__init__(self, tc_name, global_config)
self._log_dir = "TEMP"
self._logger.info("The log directory returned is: " + self._log_dir)
self._temp_folder_name = 'temporary_libs'
self._temp_folder_path = os.path.join(Folders.REPORTS, self._log_dir, self._temp_folder_name)
self._logger.info("The temporary directory is: " + str(self._temp_folder_path))
self._timeout = 60000
self._white_list_library = ['libdvm.so', 'libart.so', 'libc_malloc_debug_leak.so', 'libc_malloc_debug_qemu.so',
'libhoudini.so', 'libgcam.so', 'libvorbisidec.so', 'libcrypto.so', 'libaudioresample.so']
#get the white list libraries
_white_list_library_parameter = self._tc_parameters.get_param_value("white_list_libraries")
self._white_list_library = filter(None, re.split('\s+', _white_list_library_parameter))
self._scanelf_path = ""
self._pre_reboot_device = False
self._post_reboot_device = False
self._post_reboot_nok_device = False
if self._device.get_config("DisableTcReboot", False, default_cast_type='str_to_bool'):
self._pre_reboot_device = self._tc_parameters.get_param_value("PRE_REBOOT", default_value="False",
default_cast_type="str_to_bool")
# Reboot the board after test execution
# AKA "POST_REBOOT" in ATF
self._post_reboot_device = self._tc_parameters.get_param_value("POST_REBOOT", default_value="False",
default_cast_type="str_to_bool")
# Reboot the board after test execution if test verdict is failure
# AKA "POST_REBOOT_NOK" in ATF
self._post_reboot_nok_device = self._tc_parameters.get_param_value("POST_REBOOT_NOK", default_value="False",
default_cast_type="str_to_bool")
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call init of use case base
UseCaseBase.__init__(self, tc_name, global_config)
# Get Test Cases Parameters
self._callduration = \
int(self._tc_parameters.get_param_value("CALL_DURATION"))
# Read callSetupTimeout from Phone_Catalog.xml
self._call_setup_time = \
int(self._dut_config.get("callSetupTimeout"))
# Get UECmdLayer
self._voice_call_api = self._device.get_uecmd("VoiceCall")
self._networking_api = self._device.get_uecmd("Networking")
# Load instance of the PHONE2
self._phone2 = DeviceManager().get_device("PHONE2")
if self._phone2 is not None:
self._voice_call_api2 = self._phone2.get_uecmd("VoiceCall")
self._networking_api2 = self._phone2.get_uecmd("Networking")
else:
self._voice_call_api2 = None
self._networking_api2 = None
# Instantiate the instances for phone caller, receiver and releaser
self._caller_phone = None
self._receiver_phone = None
self._releaser_phone = None
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call UseCase base Init function
UseCaseBase.__init__(self, tc_name, global_config)
# get ICON_DICT from TC param
self.__icon_dict_text = str_to_dict(
self._tc_parameters.get_param_value("ICON_DICT_TEXT"))
self.__icon_dict_id = str_to_dict(
self._tc_parameters.get_param_value("ICON_DICT_ID"))
self.__rotation = self._tc_parameters.get_param_value("ROTATION")
# Get UECmdLayer
self._image_api = self._device.get_uecmd("Image")
self._system_api = self._device.get_uecmd("System")
self._phonesystem_api = self._device.get_uecmd("PhoneSystem")
self._keyevent_api = self._device.get_uecmd("KeyEvent")
self._multimedia_api = self._device.get_uecmd("Multimedia")
self._camera_api = self._device.get_uecmd("Camera")
self._display_api = self._device.get_uecmd("Display")
# store initial Sleep Timeout value
self._initial_sleep_timeout_value = self._phonesystem_api.get_screen_timeout(
)
time.sleep(self._wait_btwn_cmd)
def __init__(self, tc_name, global_config):
"""
Constructor
"""
UseCaseBase.__init__(self, tc_name, global_config)
self._pre_reboot_device = False
self._post_reboot_device = False
self._post_reboot_nok_device = False
if self._device.get_config("DisableTcReboot", False, default_cast_type='str_to_bool'):
self._pre_reboot_device = self._tc_parameters.get_param_value("PRE_REBOOT", default_value="False",
default_cast_type="str_to_bool")
self._post_reboot_device = self._tc_parameters.get_param_value("POST_REBOOT", default_value="False",
default_cast_type="str_to_bool")
self._post_reboot_nok_device = self._tc_parameters.get_param_value("POST_REBOOT_NOK", default_value="False",
default_cast_type="str_to_bool")
self.__camera = self._tc_parameters.get_param_value("CAMERA")
self.__save_directory = self._tc_parameters.get_param_value("SAVE_DIRECTORY")
self.__exif_parameter_to_check = self._tc_parameters.get_param_value("EXIF_PARAMETER")
self.__exif_parameter_value = self._tc_parameters.get_param_value("EXIF_VALUE")
self.__save_folder = os.path.join(self._name + "-" + datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S'), "")
# get UECmd layer
self.__camera_api = self._device.get_uecmd("Camera")
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call UseCase base Init function
UseCaseBase.__init__(self, tc_name, global_config)
self._global_config = global_config
# Initialize variables
self._video_filename = str(
self._tc_parameters.get_param_value("FILENAME", ""))
self._multimedia_volume = self._tc_parameters.get_param_value(
"VOLUME", -1, int)
self._screen_orientation = self._tc_parameters.get_param_value(
"SCREEN_ORIENTATION", "")
self._video_duration = self._tc_parameters.get_param_value("DURATION")
if self._video_duration in [None, ""]:
self._video_duration = ""
elif not str(self._video_duration).isdigit():
self._video_duration = -1
else:
self._video_duration = float(self._video_duration)
self._repeat_playback = False
self._play_whole_file = False
self._settledown_duration = 0
# Get UECmdLayer
self._multimedia_api = self._device.get_uecmd("Multimedia")
self._video_api = self._device.get_uecmd("Video")
self._phonesystem_api = self._device.get_uecmd("PhoneSystem")
self._system_api = self._device.get_uecmd("System")
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call UseCase base Init function
UseCaseBase.__init__(self, tc_name, global_config)
# get CAMERA name from TC parameters
self.__camera = self._tc_parameters.get_param_value("CAMERA")
# get RECORD_DURATION from TC parameters
self.__record_duration = self._tc_parameters.get_param_value(
"RECORD_DURATION", default_cast_type=int)
# get SAVE_DIRECTORY from TC parameters
self.__save_directory = self._tc_parameters.get_param_value(
"SAVE_DIRECTORY")
# Get UECmdLayer
self.__camera_api = self._device.get_uecmd("Camera")
self.__multimedia = self._device.get_uecmd("Multimedia")
self.__video = self._device.get_uecmd("Video")
self.__camera_opened = False
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call UseCase base Init function
UseCaseBase.__init__(self, tc_name, global_config)
# get CAMERA name from TC parameters
self.__camera = self._tc_parameters.get_param_value("CAMERA")
# get PICTURE_SIZE from TC parameters
self.__picture_size = self._tc_parameters.get_param_value("PICTURE_SIZE")
# get WHITE_BALANCE from TC parameters
self.__camera_white_balance = self._tc_parameters.get_param_value("WHITE_BALANCE")
# get FLASH_MODE from TC parameters
self.__camera_flash_mode = self._tc_parameters.get_param_value("FLASH_MODE")
# get SAVE_DIRECTORY from TC parameters
self.__save_directory = self._tc_parameters.get_param_value("SAVE_DIRECTORY")
# Get UECmdLayer
self.__camera_api = self._device.get_uecmd("Camera")
self.__save_folder = os.path.join(self._name + "-" + datetime.datetime.now().strftime("%Y-%m-%d-%H-%M-%S"), "")
self.__picture_file = None
def __init__(self, tc_name, global_config):
"""
Initializes this instance.
"""
# Call UseCase base Init function
UseCaseBase.__init__(self, tc_name, global_config)
# Initialize CRM test parameters
self._cmd_str = None
self._expected_result = None
self._test_timeout = None
# Get the command to execute
self._cmd_str = self._tc_parameters.get_param_value("RUN_CMD")
# Get the expect.ed result
expected_result = \
self._tc_parameters.get_param_value("EXPECTED_RESULT")
if expected_result is not None and expected_result != "":
self._expected_result = expected_result
# Get the execution timeout
test_timeout = self._tc_parameters.get_param_value("EXECUTION_TIMEOUT")
if test_timeout is not None and test_timeout != "":
self._test_timeout = int(test_timeout)
def __init__(self, tc_name, global_config):
"""
Initializes this instance.
"""
# Run the inherited '__init__' method
UseCaseBase.__init__(self, tc_name, global_config)
# retrieve SIM card UE commands
self.sim_card_api = self._device.get_uecmd("SimCard")
# retrieve Networking UE commands
self.networking_api = self._device.get_uecmd("Networking")
# retrieve Modem UE commands
self.__modem_api = self._device.get_uecmd("Modem")
# retrieve testcase parameters
self.__puk_code = self._tc_parameters.get_param_value("PUKCode")
self.__default_pin = self._tc_parameters.get_param_value(
"defaultPINCode")
self.__new_pin = self._tc_parameters.get_param_value("NEW_PIN")
self.__check_after_reboot = \
str_to_bool(self._tc_parameters.get_param_value("DOUBLE_CHECK_AFTER_REBOOT"))
if not is_pin_valid(self.__new_pin):
raise AcsConfigException(
AcsConfigException.INVALID_PARAMETER,
"NEW_PIN testcase parameter is incorrect : it must "
"be a number containing 4 to 8 digits.")
def __init__(self, tc_name, global_config):
"""
Constructor
"""
UseCaseBase.__init__(self, tc_name, global_config)
# Read registrationTimeout from Device_Catalog.xml
self._registration_timeout = \
int(self._dut_config.get("registrationTimeout"))
# Read callSetupTimeout from Phone_Catalog.xml
self._call_setup_time = \
int(self._dut_config.get("callSetupTimeout"))
# Get Test Cases Parameters
self._numtocall = self._tc_parameters.get_param_value("PHONE_NUMBER")
self._callduration = \
int(self._tc_parameters.get_param_value("CALL_DURATION"))
self._initial_pref_network = None
# Get UECmdLayer
self._voicecall_api = self._device.get_uecmd("VoiceCall")
self._networking_api = self._device.get_uecmd("Networking")
self._modem_api = self._device.get_uecmd("Modem")
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call UseCase base Init function
UseCaseBase.__init__(self, tc_name, global_config)
self._networking_api = self._device.get_uecmd("Networking")
def __init__(self, tc_conf, global_config):
"""
Constructor
"""
UseCaseBase.__init__(self, tc_conf, global_config)
# Get TC Parameters
self._step = self._tc_parameters.get_param_value("STEP", "RUNTEST")
self._return_code = self._tc_parameters.get_param_value(
"RETURN_CODE", Verdict.PASS)
# Update return code for retro-compatibility
self._return_code = self._return_code.replace("SUCCESS", Verdict.PASS)
self._return_code = self._return_code.replace("FAILURE", Verdict.FAIL)
self._comment = self._tc_parameters.get_param_value(
"COMMENT", "No Comment")
self._duration = int(self._tc_parameters.get_param_value(
"DURATION", 0))
self._init_exception = self._tc_parameters.get_param_value(
"INIT_EXCEPTION", False, "str_to_bool")
if self._init_exception is True:
raise AcsConfigException(
AcsConfigException.PROHIBITIVE_BEHAVIOR,
"Exception raised according to TC param 'INIT_EXCEPTION'")
# Clear existing queue to avoid unexpected behavior
if not Dummy.returns_code.empty():
with Dummy.returns_code.mutex:
Dummy.returns_code.queue.clear()
if not Dummy.steps.empty():
with Dummy.steps.mutex:
Dummy.steps.queue.clear()
# Fill the FIFO queue taking into account the b2b iteration number
for _i in range(self.get_b2b_iteration()):
for code in self._return_code.split(";"):
if code.strip() == "RANDOM":
code = random.choice(Verdict2Global.map.keys())
Dummy.returns_code.put(code.strip())
for step in self._step.split(";"):
if step.strip() == "RANDOM":
step = random.choice(["SETUP", "RUNTEST", "TEARDOWN"])
Dummy.steps.put(step.strip())
# Get return code and step only if queue is not empty.
# By default verdict = PASS, step = RUNTEST
self._current_verdict = Verdict.PASS
self._current_step = "RUNTEST"
if not Dummy.returns_code.empty():
self._current_verdict = Dummy.returns_code.get()
if not Dummy.steps.empty():
self._current_step = Dummy.steps.get()
def __init__(self, tc_name, global_config):
"""
Constructor
"""
UseCaseBase.__init__(self, tc_name, global_config)
self._test_script_logger = LOGGER_TEST_SCRIPT
self._global_config = global_config
self._run_from_tc_directory = self._tc_parameters.get_param_value("RUN_FROM_TCDIRECTORY", default_value="False",
default_cast_type="str_to_bool")