# -*- coding: utf-8 -*-" # # # Copyright (c) 2019-2020 Diality Inc. - All Rights Reserved. # copyright # THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, # IN PART OR IN WHOLE, # WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER. # # file tst_main_treatment_pressure # date Apr/12/2022 # author Papiya Mandal import names from builtins import int as pyInt from configuration.config import * from configuration.utility import * from dialin.ui import utils from dialin.ui.hd_simulator import HDSimulator in_range_color = "#ffffff" out_of_range_color = "#c53b33" ART_LOW_VAL_MINUS_120 = -120 ART_HIGH_VAL_160 = 160 ART_LOW_VAL_MINUS_200 = -200 ART_HIGH_VAL_100 = 100 ART_LOW_VAL_MINUS_30 = -30 ART_HIGH_VAL_70 = 70 ART_LOW_VAL_MINUS_80 = -80 ART_HIGH_VAL_175 = 175 BUFFER_LOW_AND_HIGH_LIMITS = 30 VENOUS_LOW_VAL_MINUS_200 = -200 VENOUS_HIGH_VAL_150 = 150 VENOUS_LOW_VAL_MINUS_310 = -310 VENOUS_HIGH_VAL_170 = 170 VENOUS_LOW_VAL_MINUS_390 = -390 VENOUS_HIGH_VAL_300 = 300 VENOUS_LOW_VAL_110 = 110 VENOUS_HIGH_VAL_250 = 250 ARTERIAL_LOW_SLIDER_VALS = [-200, -100, -250, -270, -300] ARTERIAL_HIGH_SLIDER_VALS = [-100, -90, -110, -250, 0] VENOUS_HIGH_SLIDER_VALS = [500, 550, 200, 600] VENOUS_LOW_SLIDER_VALS = [500, 200, 50, 20] REJECTED = 1 ACCEPTED = 0 hd_simulator = HDSimulator() def verify_arterial_and_venous_value_in_main_treatment_screen(accepted, art_low, art_high, ven_low, ven_high): """ Method to verify Arterial low and high and Venous low and high value on main treatment screen @param accepted: (int) boolean accept/reject response @param arterial_low: (int) Arterial Pressure Limit Low (mmHg) @param arterial_high: (int) Arterial Pressure Limit High (mmHg) @param venous_low: (int) Venous Pressure Limit Low (mmHg) @param venous_high: (int) Venous Pressure Limit High (mmHg) @return: none """ test.startSection("Verifying Arterial low and high and Venous low and high value on main treatment screen") if accepted == ACCEPTED: arterial_low = waitForObject(pressure_text_obj(art_low)) arterial_low = arterial_low.text.toInt() arterial_high = waitForObject(pressure_text_obj(art_high)) arterial_high = arterial_high.text.toInt() venous_low = waitForObject(pressure_text_obj(ven_low)) venous_low = venous_low.text.toInt() venous_high = waitForObject(pressure_text_obj(ven_high)) venous_high = venous_high.text.toInt() test.compare(arterial_low, art_low, "Arterial low value should be '{}'".format(art_low)) test.compare(arterial_high, art_high, "Arterial high value should be '{}'".format(art_high)) test.compare(venous_low, ven_low, "Venous low value should be '{}'".format(ven_low)) test.compare(venous_high, ven_high, "Venous high value should not be '{}'".format(ven_high)) else: if object.exists(pressure_text_obj(art_low)): test.fail("Arterial value {} should not exists".format(art_low)) if object.exists(pressure_text_obj(art_high)): test.fail("Arterial value {} should not exists".format(art_high)) if object.exists(pressure_text_obj(ven_low)): test.fail("Venous value {} should not exists".format(ven_low)) if object.exists(pressure_text_obj(ven_high)): test.fail("Venous value {} should not exists".format(ven_high)) test.endSection() def verify_the_constants(): """ Method to open the pressure pop up and verify the arterial and venous scale minimum and maximum range value """ test.startSection("Open the pressure pop up and verify the arterial and venous scale minimum and maximum range value") open_pressure_pop_up() arterial_scale = waitForObject(names.o_arterial_range_slider) arterial_scale_min = arterial_scale.minimum arterial_scale_max = arterial_scale.maximum test.log("Verifying Arterial scale range minimum value") test.compare(arterial_scale_min, ARTERIAL_PRESSURE_MINIMUM, "Arterial scale range minimum value should be {}".format(ARTERIAL_PRESSURE_MINIMUM)) test.log("Verifying Arterial scale range maximum value") test.compare(arterial_scale_max, ARTERIAL_PRESSURE_MAXIMUM, "Arterial scale range maximum value should be {}".format(ARTERIAL_PRESSURE_MAXIMUM)) venous_scale = waitForObject(names.o_venous_range_slider) venous_scale_min = venous_scale.minimum venous_scale_max = venous_scale.maximum test.log("Verifying Venous scale range minimum value") test.compare(venous_scale_min, VENOUS_PRESSURE_MINIMUM, "Venous scale range minimum value should be {}".format(VENOUS_PRESSURE_MINIMUM)) test.log("Verifying Arterial scale range maximum value") test.compare(venous_scale_max, VENOUS_PRESSURE_MAXIMUM, "Venous scale range maximum value should be {}".format(VENOUS_PRESSURE_MAXIMUM)) close_the_pop_up() test.endSection() def set_arterial_ranges_min_val(art_low): """ Method to set the Arterial range maximum value to user expected value @param art_low - (int) user expected value """ test.startSection("Set Arterial range minimum value to {}".format(art_low)) arterial_min = waitForObjectExists(names.o_arterial_limitbar) arterial_min = pyInt(arterial_min.minimum) arterial_max = waitForObjectExists(names.o_arterial_limitbar) arterial_max = pyInt(arterial_max.maximum) # low_handler_parent = object.parent(waitForObjectExists(names.o_arterial_text_low)) # low_handler_children = object.children(low_handler_parent) low_handler = waitForObjectExists(names.o_arterial_slider_handle)#low_handler_children[-2] # adjusting the width and height of arterial low limit slider to click on the center of the object # TODO: FixMe: Review the constant values to be changed to "/2" width = pyInt(low_handler.width) - 15 height = pyInt(low_handler.height) - 10 if arterial_min == art_low: test.passes("Arterial range minimum is already set to {}".format(art_low)) elif arterial_min < art_low: while arterial_min != art_low: mouseDrag(low_handler, width, height, 1, 0, Qt.NoModifier, Qt.LeftButton) arterial_min += 10 # arterial blood pressure low limit should be lower than the high limit by at least 30mmHg if arterial_min == arterial_max - BUFFER_LOW_AND_HIGH_LIMITS: mouseDrag(low_handler, width, height, 1, 0, Qt.NoModifier, Qt.LeftButton) test.log("Arterial range minimum value cannot be moved beyond {}".format(arterial_min)) break else: continue elif arterial_min > art_low: while arterial_min != art_low: mouseDrag(low_handler, width, height, -1, 0, Qt.NoModifier, Qt.LeftButton) arterial_min -= 10 # arterial blood pressure low limit should be lower than the high limit by at least 30mmHg if arterial_min == arterial_max - BUFFER_LOW_AND_HIGH_LIMITS: mouseDrag(low_handler, width, height, -1, 0, Qt.NoModifier, Qt.LeftButton) test.log("Arterial range minimum value cannot be moved beyond {}".format(arterial_min)) break else: continue # arterial blood pressure low limit should be lower than the high limit by atleast 30mmHg if arterial_min == arterial_max - BUFFER_LOW_AND_HIGH_LIMITS: test.compare(waitForObjectExists(names.o_arterial_limitbar).minimum, arterial_min, "Arterial range minimum value cannot be moved beyond {}".format(arterial_min)) else: test.compare(arterial_min, art_low, "Actual Arterial range minimum value: {} is equal to Expected value: {}".format(arterial_min, art_low)) test.endSection() def set_arterial_ranges_max_val(art_high): """ Method to set the Arterial range maximum value to user expected value @param art_high - (int) user expected value """ test.startSection("Set Arterial range maximum value to {}".format(art_high)) arterial_max = waitForObjectExists(names.o_arterial_limitbar) arterial_max = pyInt(arterial_max.maximum) arterial_min = waitForObjectExists(names.o_arterial_limitbar) arterial_min = pyInt(arterial_min.minimum) # high_handler_parent = object.parent(waitForObjectExists(names.o_arterial_text_low)) # high_handler_children = object.children(high_handler_parent) high_handler = waitForObjectExists(names.o_arterial_slider_handle)#high_handler_children[-1] # adjusting the width and height of arterial high limit slider to click on the center of the object # TODO: FixMe: Review the constant values to be changed to "/2" width = pyInt(high_handler.width) - 15 height = pyInt(high_handler.height) - 10 if arterial_max == art_high: test.passes("Arterial range maximum is already set to {}".format(art_high)) elif arterial_max < art_high: while arterial_max != art_high: mouseDrag(high_handler, width, height, 1, 0, Qt.NoModifier, Qt.LeftButton) arterial_max += 10 # arterial blood pressure low limit should be lower than the high limit by at least 30mmHg if arterial_max == arterial_min + BUFFER_LOW_AND_HIGH_LIMITS: mouseDrag(high_handler, width, height, 1, 0, Qt.NoModifier, Qt.LeftButton) test.log("Arterial range maximum value cannot be moved beyond {}".format(arterial_max)) break else: continue elif arterial_max > art_high: while arterial_max != art_high: mouseDrag(high_handler, width, height, -1, 0, Qt.NoModifier, Qt.LeftButton) arterial_max -= 10 # arterial blood pressure low limit should be lower than the high limit by at least 30mmHg if arterial_max == arterial_min + BUFFER_LOW_AND_HIGH_LIMITS: mouseDrag(high_handler, width, height, -1, 0, Qt.NoModifier, Qt.LeftButton) test.log("Arterial range maximum value cannot be moved beyond {}".format(arterial_max)) break else: continue # arterial blood pressure low limit should be lower than the high limit by at least 30mmHg if arterial_max == arterial_min + BUFFER_LOW_AND_HIGH_LIMITS: test.compare(waitForObjectExists(names.o_arterial_limitbar).maximum, arterial_max, "Arterial range maximum value cannot be moved beyond {}".format(arterial_max)) else: test.compare(arterial_max, art_high, "Actual Arterial range maximum value: {} is equal to Expected value: {}".format(arterial_max, art_high)) test.endSection() def set_venous_ranges_min_val(ven_low): """ Method to set the Venous range maximum value to user expected value @param ven_low - (int) user expected value """ test.startSection("Set Venous range minimum value to {}".format(ven_low)) ven_min = waitForObjectExists(names.o_venous_limitbar) ven_min = pyInt(ven_min.minimum) ven_max = waitForObjectExists(names.o_venous_limitbar) ven_max = pyInt(ven_max.maximum) # low_handler_parent = object.parent(waitForObjectExists(names.o_venous_text_low)) # low_handler_children = object.children(low_handler_parent) low_handler = waitForObjectExists(names.o_venous_slider_handle)#low_handler_children[-2] # adjusting the width and height of venous low limit slider to click on the center of the object # TODO: FixMe: Review the constant values to be changed to "/2" width = pyInt(low_handler.width) - 15 height = pyInt(low_handler.height) - 10 if ven_min == ven_low: test.passes("Venous range minimum is already set to {}".format(ven_low)) elif ven_min < ven_low: while ven_min != ven_low: mouseDrag(low_handler, width, height, 1, 0, Qt.NoModifier, Qt.LeftButton) ven_min += 10 if ven_min == ven_max - BUFFER_LOW_AND_HIGH_LIMITS: # venous blood pressure low limit should be lower than the high limit by at least 30mmHg mouseDrag(low_handler, width, height, 1, 0, Qt.NoModifier, Qt.LeftButton) test.log("Venous range minimum value cannot be moved beyond {}".format(ven_min)) break else: continue elif ven_min > ven_low: while ven_min != ven_low: mouseDrag(low_handler, width, height, -1, 0, Qt.NoModifier, Qt.LeftButton) ven_min -= 10 # venous blood pressure low limit should be lower than the high limit by at least 30mmHg if ven_min == ven_max - BUFFER_LOW_AND_HIGH_LIMITS: mouseDrag(low_handler, width, height, -1, 0, Qt.NoModifier, Qt.LeftButton) test.log("Venous range minimum value cannot be moved beyond {}".format(ven_min)) break else: continue # venous blood pressure low limit should be lower than the high limit by at least 30mmHg if ven_min == ven_max - BUFFER_LOW_AND_HIGH_LIMITS: test.compare(waitForObjectExists(names.o_venous_limitbar).minimum, ven_min, "Venous range minimum value cannot be moved beyond {}".format(ven_min)) else: test.compare(ven_min, ven_low, "Actual Venous range minimum value: {} is equal to Expected value: {}".format(ven_min, ven_low)) test.endSection() def set_venous_ranges_max_val(ven_high): """ Method to set the Venous range maximum value to user expected value @param ven_high - (int) user expected value """ test.startSection("Set Venous range maximum value to {}".format(ven_high)) ven_max = waitForObjectExists(names.o_venous_limitbar) ven_max = pyInt(ven_max.maximum) ven_min = waitForObjectExists(names.o_venous_limitbar) ven_min = pyInt(ven_min.minimum) # high_handler_parent = object.parent(waitForObjectExists(names.o_venous_text_low)) # high_handler_children = object.children(high_handler_parent) high_handler = waitForObjectExists(names.o_venous_slider_handle)#high_handler_children[-1] # adjusting the width and height of venous high limit slider to click on the center of the object # TODO: FixMe: Review the constant values to be changed to "/2" width = pyInt(high_handler.width) - 15 height = pyInt(high_handler.height) - 10 if ven_max == ven_high: test.passes("Venous range maximum is already set to {}".format(ven_high)) elif ven_max < ven_high: while ven_max != ven_high: mouseDrag(high_handler, width, height, 1, 0, Qt.NoModifier, Qt.LeftButton) ven_max += 10 # venous blood pressure low limit should be lower than the high limit by at least 30mmHg if ven_max == ven_min + BUFFER_LOW_AND_HIGH_LIMITS: mouseDrag(high_handler, width, height, 1, 0, Qt.NoModifier, Qt.LeftButton) test.log("Venous range maximum value cannot be moved beyond {}".format(ven_max)) break else: continue elif ven_max > ven_high: while ven_max != ven_high: mouseDrag(high_handler, width, height, -1, 0, Qt.NoModifier, Qt.LeftButton) ven_max -= 10 # venous blood pressure low limit should be lower than the high limit by at least 30mmHg if ven_max == ven_min + BUFFER_LOW_AND_HIGH_LIMITS: mouseDrag(high_handler, width, height, -1, 0, Qt.NoModifier, Qt.LeftButton) test.log("Venous range maximum value cannot be moved beyond {}".format(ven_max)) break else: continue # venous blood pressure low limit should be lower than the high limit by at least 30mmHg if ven_max == ven_min + BUFFER_LOW_AND_HIGH_LIMITS: test.compare(waitForObjectExists(names.o_venous_limitbar).maximum, ven_max, "Venous range maximum value cannot be moved beyond {}".format(ven_max)) else: test.compare(ven_max, ven_high, "Actual Venous range maximum value: {} is equal to Expected value: {}".format(ven_max, ven_high)) test.endSection() def set_arterial_low_and_high_limits_using_slider(): """ Method to set the arterial low and high limits using slider """ test.startSection("Set the arterial low and high limits using slider") open_pressure_pop_up() for index in range(len(ARTERIAL_HIGH_SLIDER_VALS)): set_arterial_ranges_max_val(ARTERIAL_HIGH_SLIDER_VALS[index]) utils.waitForGUI(1) set_arterial_ranges_min_val(ARTERIAL_LOW_SLIDER_VALS[index]) close_the_pop_up() test.endSection() def set_venous_low_and_high_limits_using_slider(): """ Method to set the venous low and high limits using slider """ test.startSection("Set the venous low and high limits using slider") open_pressure_pop_up() utils.waitForGUI(1) for index in range(len(VENOUS_HIGH_SLIDER_VALS)): set_venous_ranges_max_val(VENOUS_HIGH_SLIDER_VALS[index]) utils.waitForGUI(1) set_venous_ranges_min_val(VENOUS_LOW_SLIDER_VALS[index]) close_the_pop_up() test.endSection() def verify_arterial_and_venous_value_on_pressure_pop_up(accepted, reason_id, art_low, art_high, ven_low, ven_high): """ Method to verify Arterial low and high and Venous low and high value on main treatment screen @param accepted: (int) boolean accept/reject response @param reason_id: (int) rejection reason id @param arterial_low: (int) Arterial Pressure Limit Low (mmHg) @param arterial_high: (int) Arterial Pressure Limit High (mmHg) @param venous_low: (int) Venous Pressure Limit Low (mmHg) @param venous_high: (int) Venous Pressure Limit High (mmHg) @return: none """ test.startSection("Verifying Arterial low and high and Venous low and high value on pressure pop up screen") arterial_low = waitForObject(pressure_pop_up_text_obj(art_low)) arterial_low = arterial_low.text.toInt() arterial_high = waitForObject(pressure_pop_up_text_obj(art_high)) arterial_high = arterial_high.text.toInt() venous_low = waitForObject(pressure_pop_up_text_obj(ven_low)) venous_low = venous_low.text.toInt() venous_high = waitForObject(pressure_pop_up_text_obj(ven_high)) venous_high = venous_high.text.toInt() if accepted == ACCEPTED: test.compare(arterial_low, art_low, "Arterial low value should be '{}'".format(art_low)) test.compare(arterial_high, art_high, "Arterial high value should be '{}'".format(art_high)) test.compare(venous_low, ven_low, "Venous low value should be '{}'".format(ven_low)) test.compare(venous_high, ven_high, "Venous high value should be '{}'".format(ven_high)) else: if object.exists(pressure_text_obj(art_low)): test.fail("{} should not exists".format(art_low)) if object.exists(pressure_text_obj(art_high)): test.fail("{} should not exists".format(art_high)) if object.exists(pressure_text_obj(ven_low)): test.fail("{} should not exists".format(ven_low)) if object.exists(pressure_text_obj(ven_high)): test.fail("{} should not exists".format(ven_high)) verify_reject_msg_on_pop_up(reason_id) test.endSection() def set_arterial_and_venous_pressure(accepted, reason, art_low, art_high, ven_low, ven_high): """ Method to set the Arterial and Venous high and low pressure value @param accepted: (int) boolean accept/reject response @param reason: (int) rejection reason @param arterial_low: (int) Arterial Pressure Limit Low (mmHg) @param arterial_high: (int) Arterial Pressure Limit High (mmHg) @param venous_low: (int) Venous Pressure Limit Low (mmHg) @param venous_high: (int) Venous Pressure Limit High (mmHg) @return: none """ test.log("Set Arterial Low to '{art_low}', Arterial High to '{art_high}', Venous Low to '{ven_low}', and Venous High to '{ven_high}'".format(art_low=art_low, art_high=art_high, ven_low=ven_low, ven_high=ven_high)) # Integration team needs to re-evaluate pressure adjustment values from low-high to windowed. hd_simulator.cmd_send_treatment_adjust_pressures_limit_response(accepted=accepted, reason=reason, art_pressure_limit_window=art_low, ven_pressure_limit_window=ven_low, ven_pressure_asym_limit_window=0) def open_pressure_pop_up(): """ Method to open the pressure pop up and verify pop is opened """ test.startSection("Open 'Pressure' pop up") utils.waitForGUI(1) mouseClick(waitForObjectExists(names.o_treatmentHome_pressure_mouseArea_MouseArea)) test.log("Verifying 'pressure' pop up is opened") test.log("Verifying 'Pressure' title") pressure_title = waitForObject(pressure_pop_up_text_obj(PRESSURE_TITLE)) pressure_title = pressure_title.text.toUtf8().constData() test.compare(pressure_title, PRESSURE_TITLE, "Pressure title should be '{}'".format(PRESSURE_TITLE)) arterial_title = waitForObject(pressure_pop_up_text_obj(ARTERIAL_TITLE)) arterial_title = arterial_title.text.toUtf8().constData() test.compare(arterial_title, ARTERIAL_TITLE, "Arterial title should be '{}'".format(ARTERIAL_TITLE)) # art_uom = waitForObject(pressure_pop_up_text_obj(ARTERIAL_UOM)) # art_uom = art_uom.text.toUtf8().constData() # test.compare(art_uom, ARTERIAL_UOM, # "Arterial unit of measurement should be '{}'".format(ARTERIAL_UOM)) # venous_title = waitForObject(pressure_pop_up_text_obj(VENOUS_TITLE)) venous_title = venous_title.text.toUtf8().constData() test.compare(venous_title, VENOUS_TITLE, "Venous title should be '{}'".format(VENOUS_TITLE)) # ven_uom = waitForObject(pressure_pop_up_text_obj(VENOUS_UOM)) # ven_uom = ven_uom.text.toUtf8().constData() # test.compare(ven_uom, VENOUS_UOM, # "Venous unit of measurement should be '{}'".format(VENOUS_UOM)) test.endSection() def close_the_pop_up(): test.log("Closing pressure pop up") mouseClick(waitForObjectExists(names.o_uf_close_button)) def click_on_confirm_btn(): test.log("Clicking on 'confirm' button") mouseClick(waitForObjectExists(names.o_pressure_pop_up_confirm_button)) def verify_reject_msg_on_pop_up(reason_id): """ Method verify the rejection message on pop up screen @param reason_id - (int) reason id """ test.startSection("Verify the rejection message on pop up screen") reason_msg = waitForObject(names.o_pop_up_rejected_msg) reason_msg = reason_msg.text.toUtf8().constData() test.compare(reason_msg, REJECTION_REASON[reason_id], "{} should display on on pop up when values are rejected".format(REJECTION_REASON[reason_id])) test.endSection() def verify_pressures_on_treatment_and_pop_up_screen(accepted=None, reason=None, art_low=None, art_high=None, ven_low=None, ven_high=None): """ Method to set the arterial low and high pressure and venous low and high pressure and verify the same on main-treatment screen and pressures pop up screen @param accepted: (int) boolean accept/reject response @param reason: (int) rejection reason @param arterial_low: (int) Arterial Pressure Limit Low (mmHg) @param arterial_high: (int) Arterial Pressure Limit High (mmHg) @param venous_low: (int) Venous Pressure Limit Low (mmHg) @param venous_high: (int) Venous Pressure Limit High (mmHg) @return: none """ test.startSection("Set the arterial low and high pressure and venous low and high pressure and verify the same on main-treatment screen and pressures pop up screen") set_arterial_and_venous_pressure(accepted=accepted, reason=reason, art_low=art_low, art_high=art_high, ven_low=ven_low, ven_high=ven_high) # verify_arterial_and_venous_value_in_main_treatment_screen(accepted=accepted, # art_low=art_low, art_high=art_high, # ven_low=ven_low, ven_high=ven_high) utils.waitForGUI(1) open_pressure_pop_up() # verify_arterial_and_venous_value_on_pressure_pop_up(accepted=accepted, # reason_id=reason, art_low=art_low, art_high=art_high, # ven_low=ven_low, ven_high=ven_high) test.endSection() def verify_adjusted_pressures_on_treatment_and_pop_up_screen(accepted=None, reason=None, art_low=None, art_high=None, ven_low=None, ven_high=None): """ Method to set the arterial low and high pressure and venous low and high pressure and verify the same on main-treatment screen and pressures pop up screen @param accepted: (int) boolean accept/reject response @param reason: (int) rejection reason @param arterial_low: (int) Arterial Pressure Limit Low (mmHg) @param arterial_high: (int) Arterial Pressure Limit High (mmHg) @param venous_low: (int) Venous Pressure Limit Low (mmHg) @param venous_high: (int) Venous Pressure Limit High (mmHg) @return: none """ test.startSection("Adjust and set the arterial low and high pressure and venous low and high pressure and verify the same on main-treatment screen and pressures pop up screen") set_arterial_ranges_max_val(art_high) set_arterial_ranges_min_val(art_low) set_venous_ranges_max_val(ven_high) set_venous_ranges_min_val(ven_low) click_on_confirm_btn() set_arterial_and_venous_pressure(accepted=accepted, reason=reason, art_low=art_low, art_high=art_high, ven_low=ven_low, ven_high=ven_high) # verify_arterial_and_venous_value_in_main_treatment_screen(accepted=accepted, # art_low=art_low, art_high=art_high, # ven_low=ven_low, ven_high=ven_high) utils.waitForGUI(1) open_pressure_pop_up() # verify_arterial_and_venous_value_on_pressure_pop_up(accepted=accepted, # reason_id=reason, art_low=art_low, art_high=art_high, # ven_low=ven_low, ven_high=ven_high) test.endSection() def set_arterial_pressure_and_verify_the_color(): """ Method to set arterial pressure verify the value and color """ test.startSection("Set arterial pressure and verify value and color") open_pressure_pop_up() for arterial_prs in range(ARTERIAL_PRESSURE_MINIMUM , ARTERIAL_PRESSURE_MAXIMUM + PRESSURE_STEPS, PRESSURE_STEPS * 10): test.log("Setting arterial pressure {}".format(arterial_prs)) hd_simulator.cmd_set_pressure_occlusion_data(arterial_prs=arterial_prs, venous_prs=0, blood_pump_occlusion=0, pressure_state=0, art_max_limit=0, art_min_limit=0, ven_max_limit=0, ven_min_limit=0) arterial_limit_min = waitForObjectExists(names.o_arterial_limitbar).minimum arterial_limit_max = waitForObjectExists(names.o_arterial_limitbar).maximum arterial_slider_value = waitForObjectExists(names.o_arterial_range_slider).value test.compare(arterial_slider_value, arterial_prs, "Actual arterial pressure: {} should be equal to expected arterial pressure: {}".format(arterial_slider_value, arterial_prs)) # arterial_progress_value = waitForObjectExists(names.o_arterial_progress_text_value) # test.compare(arterial_progress_value.text.toInt(), arterial_prs, # "Actual arterial pressure: {} should be equal to expected arterial pressure: {}".format(arterial_progress_value.text.toInt(), arterial_prs)) # if arterial_limit_min <= arterial_slider_value <= arterial_limit_max: # test.compare(arterial_progress_value.color.name, in_range_color, # "Arterial progress value {} is in range".format(arterial_slider_value)) # else: # test.compare(arterial_progress_value.color.name, out_of_range_color, # "Arterial progress value {} is out of range".format(arterial_slider_value)) close_the_pop_up() test.endSection() def set_venous_pressure_and_verify_the_color(): """ Method to set venous pressure verify the value and color """ test.startSection("Set Venous pressure and verify value and color") open_pressure_pop_up() for venous_prs in range(VENOUS_PRESSURE_MINIMUM, VENOUS_PRESSURE_MAXIMUM + PRESSURE_STEPS, PRESSURE_STEPS * 10): test.log("Setting Venous pressure {}".format(venous_prs)) hd_simulator.cmd_set_pressure_occlusion_data(arterial_prs=0, venous_prs=venous_prs, blood_pump_occlusion=0, pressure_state=0, art_max_limit=0, art_min_limit=0, ven_max_limit=0, ven_min_limit=0) # venous_current_value = waitForObjectExists(names.o_venous_marker).value venous_limit_min = waitForObjectExists(names.o_venous_limitbar).minimum venous_limit_max = waitForObjectExists(names.o_venous_limitbar).maximum venous_slider_value = waitForObjectExists(names.o_venous_range_slider).value test.compare(venous_slider_value, venous_prs, "Actual venous pressure: {} should be equal to expected venous pressure: {}".format(venous_slider_value, venous_prs)) # venous_progress_value = waitForObjectExists(names.o_venous_progress_text_value) # test.compare(venous_progress_value.text.toInt(), venous_prs, # "Actual venous pressure: {} should be equal to expected venous pressure: {}".format(venous_progress_value.text.toInt(), venous_prs)) # if venous_limit_min <= venous_current_value <= venous_limit_max: # test.compare(venous_progress_value.color.name, in_range_color, # "Venous progress value {} is in range".format(venous_current_value)) # else: # test.compare(venous_progress_value.color.name, out_of_range_color, # "Venous progress value {} is out of range".format(venous_current_value)) close_the_pop_up() test.endSection() def main(): utils.tstStart(__file__) startApplication(AUT_NAME) hd_simulator.cmd_send_power_on_self_test_version_request() hd_simulator.cmd_set_treatment_states_data(sub_mode=2, uf_state=0, saline_state=0, heparin_state=0, rinseback_state=0, recirculate_state=0, blood_prime_state=0, treatment_end_state=0, treatment_stop_state=0, dialysis_state=0) verify_the_constants() # set_arterial_low_and_high_limits_using_slider() # set_venous_low_and_high_limits_using_slider() set_arterial_pressure_and_verify_the_color() set_venous_pressure_and_verify_the_color() verify_pressures_on_treatment_and_pop_up_screen(accepted=ACCEPTED, reason=0, art_low=ART_LOW_VAL_MINUS_120, art_high=ART_HIGH_VAL_160, ven_low=VENOUS_LOW_VAL_MINUS_310, ven_high=VENOUS_HIGH_VAL_170) verify_adjusted_pressures_on_treatment_and_pop_up_screen(accepted=ACCEPTED, reason=0, art_low=ART_LOW_VAL_MINUS_120, art_high=ART_HIGH_VAL_160, ven_low=VENOUS_LOW_VAL_MINUS_310, ven_high=VENOUS_HIGH_VAL_170) # verify_pressures_on_treatment_and_pop_up_screen(accepted=REJECTED, reason=39, # art_low=ART_LOW_VAL_MINUS_200, art_high=ART_HIGH_VAL_70, # ven_low=VENOUS_LOW_VAL_MINUS_200, ven_high=VENOUS_HIGH_VAL_150) # # verify_adjusted_pressures_on_treatment_and_pop_up_screen(accepted=REJECTED, reason=39, # art_low=ART_LOW_VAL_MINUS_200, art_high=ART_HIGH_VAL_70, # ven_low=VENOUS_LOW_VAL_MINUS_200, ven_high=VENOUS_HIGH_VAL_150) verify_pressures_on_treatment_and_pop_up_screen(accepted=ACCEPTED, reason=0, art_low=ART_LOW_VAL_MINUS_80, art_high=ART_HIGH_VAL_175, ven_low=VENOUS_LOW_VAL_110, ven_high=VENOUS_HIGH_VAL_250) verify_pressures_on_treatment_and_pop_up_screen(accepted=ACCEPTED, reason=0, art_low=ART_LOW_VAL_MINUS_80, art_high=ART_HIGH_VAL_175, ven_low=VENOUS_LOW_VAL_110, ven_high=VENOUS_HIGH_VAL_250) # verify_pressures_on_treatment_and_pop_up_screen(accepted=REJECTED, reason=21, # art_low=ART_LOW_VAL_MINUS_30, art_high=ART_HIGH_VAL_100, # ven_low=VENOUS_LOW_VAL_MINUS_390, ven_high=VENOUS_HIGH_VAL_300) # # verify_pressures_on_treatment_and_pop_up_screen(accepted=REJECTED, reason=21, # art_low=ART_LOW_VAL_MINUS_30, art_high=ART_HIGH_VAL_100, # ven_low=VENOUS_LOW_VAL_MINUS_390, ven_high=VENOUS_HIGH_VAL_300) utils.tstDone()