wiliot-certificate 1.5.2a1__py3-none-any.whl → 4.4.0a1__py3-none-any.whl

brg_certificate/tests/datapath/rssi_threshold_test/rssi_threshold_test.py

@@ -30,7 +30,7 @@ def rssi_threshold_analysis(test, df, threshold):
 def run(test):
 
     fields = [BRG_RSSI_THRESHOLD]
-    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
+    datapath_module = test.active_brg.datapath
 
     test = cert_common.test_prolog(test)
     if test.rc == TEST_FAILED:
@@ -39,14 +39,15 @@ def run(test):
     # Configure the BRG with RSSI threshold and check for packets violating the threshold
     for param in test.params:
         functionality_run_print(f"test for RSSI threshold of {param.value}")
-
         test = cert_config.brg_configure(test, fields=fields, values=[param.value], module=datapath_module)[0]
         test.set_phase_rc(param.name, test.rc)
         test.add_phase_reason(param.name, test.reason)
-        if test.rc == TEST_FAILED and test.exit_on_param_failure:
-            break
-        else:
-            test.reset_result()
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+            else:
+                test.reset_result()  # reset result and continue to next param
+                continue
         print("waiting 5 seconds for datapath to clear")
         print_update_wait(5)
 
@@ -67,9 +68,10 @@ def run(test):
         field_functionality_pass_fail_print(test, fields[0], value=param.name)
         test.set_phase_rc(param.name, test.rc)
         test.add_phase_reason(param.name, test.reason)
-        if test.rc == TEST_FAILED and test.exit_on_param_failure:
-            break
-        else:
-            test.reset_result()
-
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+            else:
+                test.reset_result()  # reset result and continue to next param
+                continue
     return cert_common.test_epilog(test, revert_brgs=True, revert_gws=test.internal_brg, modules=[datapath_module])

brg_certificate/tests/datapath/rx_channel_test/rx_channel_test.py

@@ -16,7 +16,7 @@ def run(test):
 
     fields = [BRG_RX_CHANNEL]
     print(test.params)
-    datapath_module = cert_common.get_module_by_name(test.active_brg.modules, "Datapath")
+    datapath_module = test.active_brg.datapath
 
     # We use this flag to know whether the BRG is currently in BLE5 mode and needs special configuration next time it is configured
     ble5_state = False
@@ -30,16 +30,16 @@ def run(test):
             test = cert_config.brg_configure_ble5(test, fields=fields, values=[param.value], module=datapath_module)[0]
         else:
             test = cert_config.brg_configure(test, fields=fields, values=[param.value], module=datapath_module)[0]
-
         # param epilog
         ble5_state = not is_primary_channel(param.value)
         generate_log_file(test, param.name)
         field_functionality_pass_fail_print(test, fields[0], value=param.name)
         test.set_phase_rc(param.name, test.rc)
         test.add_phase_reason(param.name, test.reason)
-        if test.rc == TEST_FAILED and test.exit_on_param_failure:
-            break
-        else:
-            test.reset_result()
-
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+            else:
+                test.reset_result()  # reset result and continue to next param
+                continue
     return cert_common.test_epilog(test, revert_brgs=True, modules=[datapath_module], ble5=ble5_state)

brg_certificate/tests/datapath/rx_rate_gen2_test/rx_rate_gen2_test.py

@@ -34,8 +34,8 @@ def scan_and_compare(test, pacer_interval, delay, expected_address_value):
     pixel_sim_thread.stop()
     cert_mqtt.dump_pkts(test, log="rx_rate")
     cert_common.display_data(df, tbc=True, nfpkt=True, rssi=True, dir=test.dir)
-
-    if df.empty:
+    # check if the dataframe is empty or not
+    if len(df) <= 1:
         print("Df is empty")
         test.rc = TEST_FAILED
         test.add_reason("Df is empty")
@@ -48,11 +48,16 @@ def scan_and_compare(test, pacer_interval, delay, expected_address_value):
         print(f"Most common tag: {most_common_tag}")
         df = df[df[TAG_ID] == most_common_tag]
         df = df[[TAG_ID, TBC, PACKET_TYPE, DATETIME]]
+        length = len(df)
+        mid_index = int(length // 2)
+        if mid_index == 0:
+            mid_index = 1
+        print(f"Length of df: {length}, mid index: {mid_index}")
         print(f"df:\n {df}")
 
         tag = df.iloc[0][TAG_ID]
         # iloc [1:] to skip the first value of tbc_values which could be 0 sometimes.
-        actual_address_value = round(df.iloc[1:][TBC].mean(), 2)  # extract the tbc value from df
+        actual_address_value = round(df.iloc[mid_index:][TBC].mean(), 2)  # extract the tbc value from df
         print(f"\nactual address value: {actual_address_value}\nexpected address value: {expected_address_value}")
         THRESHOLD_ADDRESS_VALUE = 5
         # check if the actual address value is in the range of -+5 of the expected address value
@@ -147,8 +152,9 @@ def diff_rate(test, datapath_module):
     df = cert_common.data_scan(test, scan_time=scan_time, brg_data=(not test.internal_brg), gw_data=test.internal_brg)
     pixel_sim_thread.stop()
     df = df[[TAG_ID, TBC]]
+    lenght = len(df)
 
-    if df.empty:
+    if len(df) <= 1:
         test.add_reason("Df is empty")
         test.rc = TEST_FAILED
         return test
@@ -156,41 +162,33 @@ def diff_rate(test, datapath_module):
         print(f"Df:\n {df}")
     # NOTE: all next rows are specific for the values: delay 0.5 and 3, and in relation address values 128 and 235
     # check if the last tbc value is as we expected  for delay 3 sec we need to get 235 according to LUT  table
-    # we define tolerance of +-2 units for address value
+    # we define tolerance of +-10 units for address value
+
+    # Most important check, verify it converges to the correct value
     if df.iloc[-1][TBC] not in range(232, 237):
         test.rc = TEST_FAILED
         test.add_reason(f"TBC value: {df.iloc[-1][TBC]}, expected value [232,236]")
         print(f"TBC value: {df.iloc[-1][TBC]}, expected value [232,236] according to delay:{second_delay / 1000} sec")
-    # skip the first packet in case the second one is still from the last delay value
-    index = 0
-    if df.iloc[1][TBC] in range(232, 237):
-        index = 1
-
-    # verify the first tbc value
-    first_tbc = df.iloc[index][TBC]
-    if first_tbc not in range(120, 145):
-        test.rc = TEST_FAILED
-        test.add_reason(f"TBC value: {first_tbc}, expected value [120,144]")
-        print(f"TBC value of last packet before the delay change is wrong\n"
-              f"TBC value: {first_tbc}, expected value [120,144] according to delay:{first_delay / 1000} sec")
-
-    # check the first change of tbc value after delay changing which is verify the calculation of alpha filter
-    second_tbc = df.iloc[index + 1][TBC]
-    expected_address_value = 200
-    # 4 is equal to 0.09 sec error
-    threshold = 4  # 2 equal to 0.04 sec error
-    if not expected_address_value - threshold <= second_tbc <= expected_address_value + threshold:
+        return test
+    # for loop that skip the first row and check if somewhere there is the expected gap 130 to 200
+    result = False
+    for i in range(0, lenght - 1):
+        prev = df.iloc[i][TBC]
+        current = df.iloc[i + 1][TBC]
+        if prev in range(120, 140) and current in range(190, 210):
+            print(f"Found the gap between {prev} and {current}")
+            print(f"row {i}: {df.iloc[i][TBC]}")
+            print(f"row {i + 1}: {df.iloc[i + 1][TBC]}")
+            result = True
+    if not result:
         test.rc = TEST_FAILED
-        test.add_reason(f"TBC value: {second_tbc}, expected value [196,204]")
-        print(f"first change of address value is wrong.\n"
-              f"alpha filter probably is not define well\n"
-              f"TBC value: {second_tbc}, expected value [196,204]")
+        test.add_reason("Didn't find the correct gap according to alpha filter calculation")
     return test
 
 
 def run(test):
     # "Test prolog"
-    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
+    datapath_module = test.active_brg.datapath
     test = cert_common.test_prolog(test)
     if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
@@ -199,7 +197,7 @@ def run(test):
     test = cert_config.brg_configure(test, fields=[BRG_PACER_INTERVAL], values=[pacer_interval], module=datapath_module)[0]
     if test.rc == TEST_FAILED:
         test.add_reason(f"Didn't succeed to config pacer interval {pacer_interval}")
-        return test
+        return cert_common.test_epilog(test)
 
     RX_RATE_TEST_MAP = {"mid_values": mid_values, "diff_pacer": diff_pacer, "min_value": min_value,
                         "max_value": max_value, "diff_rate": diff_rate}
@@ -210,9 +208,10 @@ def run(test):
         field_functionality_pass_fail_print(test, param.name)
         test.set_phase_rc(param.name, test.rc)
         test.add_phase_reason(param.name, test.reason)
-        if test.rc == TEST_FAILED and test.exit_on_param_failure:
-            break
-        else:
-            test.reset_result()
-
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+            else:
+                test.reset_result()  # reset result and continue to next param
+                continue
     return cert_common.test_epilog(test)

brg_certificate/tests/datapath/rx_rate_gen3_test/rx_rate_gen3_test.py

@@ -11,7 +11,7 @@ import time
 def cal_scan_time(test, delay, pacer_interval):
     # Calculate the scan time to ensure at least 5 packets are captured in data scan
     # define the num of packet that you want to get
-    num_of_sending_pkt = 3  # actually it will be 3 because the first one always send
+    num_of_sending_pkt = 2  # actually it will be 3 because the first one always send
     delay = delay / 1000
     if delay < pacer_interval:
         scan_time = (pacer_interval * num_of_sending_pkt) + 10
@@ -34,8 +34,8 @@ def scan_and_compare(test, pacer_interval, delay, expected_address_value):
     pixel_sim_thread.stop()
     cert_mqtt.dump_pkts(test, log="rx_rate")
     cert_common.display_data(df, tbc=True, nfpkt=True, rssi=True, dir=test.dir)
-
-    if df.empty:
+    # check if the dataframe is empty or not
+    if len(df) <= 1:
         print("Df is empty")
         test.rc = TEST_FAILED
         test.add_reason("Df is empty")
@@ -48,11 +48,16 @@ def scan_and_compare(test, pacer_interval, delay, expected_address_value):
         print(f"Most common tag: {most_common_tag}")
         df = df[df[TAG_ID] == most_common_tag]
         df = df[[TAG_ID, TBC, PACKET_TYPE, DATETIME]]
+        length = len(df)
+        mid_index = int(length // 2)
+        if mid_index == 0:
+            mid_index = 1
+        print(f"Length of df: {length}, mid index: {mid_index}")
         print(f"df:\n {df}")
 
         tag = df.iloc[0][TAG_ID]
         # iloc [1:] to skip the first value of tbc_values which could be 0 sometimes.
-        actual_address_value = round(df.iloc[1:][TBC].mean(), 2)  # extract the tbc value from df
+        actual_address_value = round(df.iloc[mid_index:][TBC].mean(), 2)  # extract the tbc value from df
         print(f"\nactual address value: {actual_address_value}\nexpected address value: {expected_address_value}")
         THRESHOLD_ADDRESS_VALUE = 5
         # check if the actual address value is in the range of -+5 of the expected address value
@@ -128,29 +133,28 @@ def max_value(test, datapath_module):
 def diff_rate(test, datapath_module):
     # diff rate - a filter: Generate packets with delay 1 and change to 5, according the delay change test the tolerance address value
     pacer_interval = 1
-    delay = {500: 5, 3000: 30}  # key=delay and value = the duration it will be activated
-    first_delay = list(delay.keys())[0]
-    first_duration = list(delay.values())[0]
-    second_delay = list(delay.keys())[1]
-
+    delay_duration = [[500, 5], [3000, 3]]
+    first_delay = delay_duration[0][0]
+    first_duration = delay_duration[0][1]
+    second_delay = delay_duration[1][0]
     test = cert_config.brg_configure(test, fields=[BRG_PACER_INTERVAL], values=[pacer_interval], module=datapath_module)[0]
     if test.rc == TEST_FAILED:
         test.add_reason(f"Didn't succeed to config pacer interval {pacer_interval}")
         return test
-    pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=1, duplicates=3,
+    pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=1, duplicates=2,
                                                    delay=first_delay, pkt_types=[0], pixels_type=GEN3)
     pixel_sim_thread.start()
     time_sleep = first_duration - ((first_delay / 1000) / 2)
     print(f"sleep for {time_sleep} sec\n")
     time.sleep(time_sleep)
     pixel_sim_thread.delay = second_delay
-    print(f"changing delay value to {second_delay}\n")
-    scan_time = sum(delay.values()) + 20
+    scan_time = sum(duration for _, duration in delay_duration) + 20
     df = cert_common.data_scan(test, scan_time=scan_time, brg_data=(not test.internal_brg), gw_data=test.internal_brg)
     pixel_sim_thread.stop()
     df = df[[TAG_ID, TBC]]
+    lenght = len(df)
 
-    if df.empty:
+    if len(df) <= 1:
         test.add_reason("Df is empty")
         test.rc = TEST_FAILED
         return test
@@ -158,41 +162,33 @@ def diff_rate(test, datapath_module):
         print(f"Df:\n {df}")
     # NOTE: all next rows are specific for the values: delay 0.5 and 3, and in relation address values 128 and 235
     # check if the last tbc value is as we expected  for delay 3 sec we need to get 235 according to LUT  table
-    # we define tolerance of +-2 units for address value
+    # we define tolerance of +-10 units for address value
+
+    # Most important check, verify it converges to the correct value
     if df.iloc[-1][TBC] not in range(232, 237):
         test.rc = TEST_FAILED
         test.add_reason(f"TBC value: {df.iloc[-1][TBC]}, expected value [232,236]")
         print(f"TBC value: {df.iloc[-1][TBC]}, expected value [232,236] according to delay:{second_delay / 1000} sec")
-    # skip the first packet in case the second one is still from the last delay value
-    index = 0
-    if df.iloc[1][TBC] in range(232, 237):
-        index = 1
-
-    # verify the first tbc value
-    first_tbc = df.iloc[index][TBC]
-    if first_tbc not in range(120, 145):
-        test.rc = TEST_FAILED
-        test.add_reason(f"TBC value: {first_tbc}, expected value [120,144]")
-        print(f"TBC value of last packet before the delay change is wrong\n"
-              f"TBC value: {first_tbc}, expected value [120,144] according to delay:{first_delay / 1000} sec")
-
-    # check the first change of tbc value after delay changing which is verify the calculation of alpha filter
-    second_tbc = df.iloc[index + 1][TBC]
-    expected_address_value = 200
-    # 4 is equal to 0.09 sec error
-    threshold = 4  # 2 equal to 0.04 sec error
-    if not expected_address_value - threshold <= second_tbc <= expected_address_value + threshold:
+        return test
+    # for loop that skip the first row and check if somewhere there is the expected gap 130 to 200
+    result = False
+    for i in range(0, lenght - 1):
+        prev = df.iloc[i][TBC]
+        current = df.iloc[i + 1][TBC]
+        if prev in range(120, 140) and current in range(190, 210):
+            print(f"Found the gap between {prev} and {current}")
+            print(f"row {i}: {df.iloc[i][TBC]}")
+            print(f"row {i + 1}: {df.iloc[i + 1][TBC]}")
+            result = True
+    if not result:
         test.rc = TEST_FAILED
-        test.add_reason(f"TBC value: {second_tbc}, expected value [196,204]")
-        print(f"first change of address value is wrong.\n"
-              f"alpha filter probably is not define well\n"
-              f"TBC value: {second_tbc}, expected value [196,204]")
+        test.add_reason("Didn't find the correct gap according to alpha filter calculation")
     return test
 
 
 def run(test):
     # "Test prolog"
-    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
+    datapath_module = test.active_brg.datapath
     test = cert_common.test_prolog(test)
     if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
@@ -201,7 +197,7 @@ def run(test):
     test = cert_config.brg_configure(test, fields=[BRG_PACER_INTERVAL], values=[pacer_interval], module=datapath_module)[0]
     if test.rc == TEST_FAILED:
         test.add_reason(f"Didn't succeed to config pacer interval {pacer_interval}")
-        return test
+        return cert_common.test_epilog(test)
 
     RX_RATE_TEST_MAP = {"mid_values": mid_values, "diff_pacer": diff_pacer, "min_value": min_value,
                         "max_value": max_value, "diff_rate": diff_rate}
@@ -212,9 +208,10 @@ def run(test):
         field_functionality_pass_fail_print(test, param.name)
         test.set_phase_rc(param.name, test.rc)
         test.add_phase_reason(param.name, test.reason)
-        if test.rc == TEST_FAILED and test.exit_on_param_failure:
-            break
-        else:
-            test.reset_result()
-
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+            else:
+                test.reset_result()  # reset result and continue to next param
+                continue
     return cert_common.test_epilog(test)

brg_certificate/tests/datapath/stress_gen3_test/stress_gen3_test.json

@@ -11,12 +11,11 @@
                   "rep 3 - config pacer interval 22, then check repetition value = 3, pacer increment = 0, num of tags = all tags",
                   "rep 2 - config pacer interval 12, then check repetition value = 2, pacer increment = 0, num of tags = all tags",
                   "rep 1 - config pacer interval 7, then check repetition value = 1, pacer increment = 0, num of tags = all tags",
-                  "rep 1 adaptive pacer - config pacer interval 1, then check repetition value = 1, pacer increment = 3 , num of tags = all tags",
                   "Test epilog"],
     "expectedOutcome": "all metrics values will be as expected then the bridge is working correctly and the algorithms are working correctly",
     "mandatory": 1,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
     "internalBridge": 0,
-    "allSupportedValues": ["rep3", "rep2", "rep1", "rep1_adaptive_pacer"]
+    "allSupportedValues": ["rep3", "rep2", "rep1"]
 }

brg_certificate/tests/datapath/stress_gen3_test/stress_gen3_test.py

@@ -165,17 +165,14 @@ def rep1_adaptive_pacer(test, param, datapath_module, num_of_sim_tags):
 
 def run(test):
     # Test prolog
-    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
+    datapath_module = test.active_brg.datapath
     test = cert_common.test_prolog(test)
     if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test, revert_brgs=True, modules=[datapath_module])
     # config GW deduplication pkts = 0
     print("Configuring GW with !deduplication_pkts 0")
     cert_config.gw_action(test, f"{DEDUPLICATION_PKTS} 0")
-    if test.rc == TEST_FAILED and test.exit_on_param_failure:
-        return cert_common.test_epilog(test, revert_gws=True)
-
-    STRESS_TEST_MAP = {"rep3": rep3, "rep2": rep2, "rep1": rep1, "rep1_adaptive_pacer": rep1_adaptive_pacer}
+    STRESS_TEST_MAP = {"rep3": rep3, "rep2": rep2, "rep1": rep1}
     num_of_pixels = 300
     pixel_sim_thread = cert_data_sim.DataSimThread(test=test,
                                                    num_of_pixels=num_of_pixels,
@@ -192,10 +189,11 @@ def run(test):
         field_functionality_pass_fail_print(test, param.name)
         test.set_phase_rc(param.name, test.rc)
         test.add_phase_reason(param.name, test.reason)
-        if test.rc == TEST_FAILED and test.exit_on_param_failure:
-            break
-        else:
-            test.reset_result()
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break
+            else:
+                test.reset_result()
         time.sleep(5)
     pixel_sim_thread.stop()
     # Re-enable unified packets deduplication

brg_certificate/tests/datapath/stress_test/stress_test.json

@@ -11,12 +11,11 @@
                   "rep 3 - config pacer interval 22, then check repetition value = 3, pacer increment = 0, num of tags = all tags",
                   "rep 2 - config pacer interval 12, then check repetition value = 2, pacer increment = 0, num of tags = all tags",
                   "rep 1 - config pacer interval 7, then check repetition value = 1, pacer increment = 0, num of tags = all tags",
-                  "rep 1 adaptive pacer - config pacer interval 1, then check repetition value = 1, pacer increment = 3 , num of tags = all tags",
                   "Test epilog"],
     "expectedOutcome": "all metrics values will be as expected then the bridge is working correctly and the algorithms are working correctly",
     "mandatory": 1,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
     "internalBridge": 0,
-    "allSupportedValues": ["rep3", "rep2", "rep1", "rep1_adaptive_pacer"]
+    "allSupportedValues": ["rep3", "rep2", "rep1"]
 }

brg_certificate/tests/datapath/stress_test/stress_test.py

@@ -96,7 +96,7 @@ def combination_func(test, param, datapath_module, pacer_interval, num_of_sim_ta
             test = metric_checking_HB(test, check, hbs, tx_queue_expected, pacer_increment_expected)
             return test
         else:
-            # in case it failed because the repetition value.
+            # in case it failed because the repetition value. the reason has been added in the metric_checking_df function
             return test
 
     time.sleep(30)
@@ -165,17 +165,14 @@ def rep1_adaptive_pacer(test, param, datapath_module, num_of_sim_tags):
 
 def run(test):
     # Test prolog
-    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
+    datapath_module = test.active_brg.datapath
     test = cert_common.test_prolog(test)
     if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test, revert_brgs=True, modules=[datapath_module])
     # config GW deduplication pkts = 0
     print("Configuring GW with !deduplication_pkts 0")
     cert_config.gw_action(test, f"{DEDUPLICATION_PKTS} 0")
-    if test.rc == TEST_FAILED and test.exit_on_param_failure:
-        return cert_common.test_epilog(test, revert_gws=True)
-
-    STRESS_TEST_MAP = {"rep3": rep3, "rep2": rep2, "rep1": rep1, "rep1_adaptive_pacer": rep1_adaptive_pacer}
+    STRESS_TEST_MAP = {"rep3": rep3, "rep2": rep2, "rep1": rep1}
     num_of_pixels = 300
     pixel_sim_thread = cert_data_sim.DataSimThread(test=test,
                                                    num_of_pixels=num_of_pixels,
@@ -192,10 +189,11 @@ def run(test):
         field_functionality_pass_fail_print(test, param.name)
         test.set_phase_rc(param.name, test.rc)
         test.add_phase_reason(param.name, test.reason)
-        if test.rc == TEST_FAILED and test.exit_on_param_failure:
-            break
-        else:
-            test.reset_result()
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break
+            else:
+                test.reset_result()
         time.sleep(5)
     pixel_sim_thread.stop()
     # Re-enable unified packets deduplication

brg_certificate/tests/datapath/tx_repetition_algo_test/tx_repetition_algo_test.py

@@ -100,7 +100,7 @@ def run(test):
     if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
 
-    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
+    datapath_module = test.active_brg.datapath
 
     print("Configuring GW")
     # Set packets deduplication off to count the number of pkts from the BRG

brg_certificate/tests/datapath/tx_repetition_test/tx_repetition_test.py

@@ -50,7 +50,7 @@ def tx_repetitions_analysis(test, repetitions):
 def run(test):
 
     fields = [BRG_TX_REPETITION, BRG_PKT_FILTER, BRG_RX_CHANNEL]
-    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
+    datapath_module = test.active_brg.datapath
 
     test = cert_common.test_prolog(test)
     if test.rc == TEST_FAILED:
@@ -58,24 +58,27 @@ def run(test):
 
     print("Configuring GW with !deduplication_pkts 0")
     cert_config.gw_action(test, f"{DEDUPLICATION_PKTS} 0")
-    if test.rc == TEST_FAILED and test.exit_on_param_failure:
-        return cert_common.test_epilog(test, revert_gws=True)
 
     for param in test.params:
         test = cert_config.brg_configure(test, fields=fields,
                                          values=[param.value, ag.PKT_FILTER_RANDOM_FIRST_ARRIVING_PKT, ag.RX_CHANNEL_37],
                                          module=datapath_module)[0]
-        if test.rc == TEST_FAILED and test.exit_on_param_failure:
-            break
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+            else:
+                test.reset_result()   # reset result and continue to next param
+                continue
         tx_repetitions_analysis(test, param.name)
         field_functionality_pass_fail_print(test, fields[0], value=param.name)
         test.set_phase_rc(param.name, test.rc)
         test.add_phase_reason(param.name, test.reason)
-        if test.rc == TEST_FAILED and test.exit_on_param_failure:
-            break
-        else:
-            test.reset_result()
-
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+            else:
+                test.reset_result()   # reset result and continue to next param
+                continue
     # Re-enable unified packets deduplication
     cert_config.gw_action(test, f"{DEDUPLICATION_PKTS} 1")
-    return cert_common.test_epilog(test, revert_brgs=True, revert_gws=True, modules=[datapath_module])
+    return cert_common.test_epilog(test, revert_brgs=True, modules=[datapath_module])

brg_certificate/tests/edge_mgmt/actions_test/actions_test.py

@@ -34,26 +34,26 @@ LIS2DW12_NON_DEFAULT_SLEEP_DURATION = 35
 
 def get_brg_non_default_module_pkt(test, module):
     if 'Energy2400' in module.__name__:
-        return cert_config.get_default_brg_pkt(test, pkt_type=eval_pkt(f'ModuleEnergy2400V{test.active_brg.api_version}'),
+        return cert_config.get_default_brg_pkt(test, pkt_type=test.active_brg.energy2400,
                                                duty_cycle=BRG_NON_DEFAULT_DUTY_CYCLE,
                                                output_power=BRG_NON_DEFAULT_OP_2_4, pattern=BRG_NON_DEFAULT_EP_2_4,
                                                signal_indicator_cycle=BRG_NON_DEFAULT_SIGNAL_INDICATOR_CYCLE_2_4,
                                                signal_indicator_rep=BRG_NON_DEFAULT_SIGNAL_INDICATOR_REP_2_4)
     elif 'EnergySub1G' in module.__name__:
-        return cert_config.get_default_brg_pkt(test, pkt_type=eval_pkt(f'ModuleEnergySub1GV{test.active_brg.api_version}'),
+        return cert_config.get_default_brg_pkt(test, pkt_type=test.active_brg.energy_sub1g,
                                                duty_cycle=BRG_NON_DEFAULT_DUTY_CYCLE,
                                                signal_indicator_cycle=BRG_NON_DEFAULT_SIGNAL_INDICATOR_CYCLE_SUB1G,
                                                signal_indicator_rep=BRG_NON_DEFAULT_SIGNAL_INDICATOR_REP_SUB1G)
     elif 'PwrMgmt' in module.__name__:
-        return cert_config.get_default_brg_pkt(test, pkt_type=eval_pkt(f'ModulePwrMgmtV{test.active_brg.api_version}'),
+        return cert_config.get_default_brg_pkt(test, pkt_type=test.active_brg.pwr_mgmt,
                                                dynamic_keep_alive_scan=BRG_NON_DEFAULT_PWR_MGMT_KEEP_ALIVE_SCAN)
     elif 'Custom' in module.__name__:
-        return cert_config.get_default_brg_pkt(test, pkt_type=eval_pkt(f'ModuleCustomV{test.active_brg.api_version}'),
+        return cert_config.get_default_brg_pkt(test, pkt_type=test.active_brg.custom,
                                                motion_sensitivity_threshold=LIS2DW12_NON_DEFAULT_STATE_THRESHOLD,
                                                s2d_transition_time=LIS2DW12_NON_DEFAULT_WAKE_UP_DURATION,
                                                d2s_transition_time=LIS2DW12_NON_DEFAULT_SLEEP_DURATION)
     elif 'Datapath' in module.__name__:
-        return cert_config.get_default_brg_pkt(test, pkt_type=eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}'),
+        return cert_config.get_default_brg_pkt(test, pkt_type=test.active_brg.datapath,
                                                tx_repetition=BRG_NON_DEFAULT_TX_REPETITION,
                                                pkt_filter=BRG_NON_DEFAULT_PKT_FILTER,
                                                output_power=BRG_NON_DEFAULT_OP_2_4,
@@ -61,12 +61,12 @@ def get_brg_non_default_module_pkt(test, module):
                                                pacer_interval=BRG_NON_DEFAULT_PACER_INTERVAL,
                                                rssi_threshold=BRG_NON_DEFAULT_RSSI_THRESHOLD)
     elif 'Calibration' in module.__name__:
-        return cert_config.get_default_brg_pkt(test, pkt_type=eval_pkt(f'ModuleCalibrationV{test.active_brg.api_version}'),
+        return cert_config.get_default_brg_pkt(test, pkt_type=test.active_brg.calibration,
                                                output_power=BRG_NON_DEFAULT_CALIB_OUTPUT_POWER,
                                                interval=BRG_NON_DEFAULT_CALIB_INTERVAL,
                                                pattern=BRG_NON_DEFAULT_CALIB_PATTERN)
     elif 'ExtSensors' in module.__name__:
-        return cert_config.get_default_brg_pkt(test, pkt_type=eval_pkt(f'ModuleExtSensorsV{test.active_brg.api_version}'),
+        return cert_config.get_default_brg_pkt(test, pkt_type=test.active_brg.sensors,
                                                sensor0=ag.EXTERNAL_SENSORS_MINEWS1,
                                                sensor1=ag.EXTERNAL_SENSORS_VOLTAIC_BATT_LEVEL_DONGLE,
                                                rssi_threshold=BRG_NON_DEFAULT_RSSI_THRESHOLD,
@@ -253,7 +253,7 @@ def test_action_get_module(test):
     cert_config.send_brg_action(test, ag.ACTION_GET_MODULE, datapath=1)
     # analysis
     test = search_action_ack(test, ag.ACTION_GET_MODULE, datapath=1)
-    test = scan_for_modules(test, [eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')])
+    test = scan_for_modules(test, [test.active_brg.datapath])
     if test.rc == TEST_FAILED:
         return test
 
@@ -349,7 +349,7 @@ def test_action_restore_defaults(test):
                         if ag.MODULE_ENERGY_SUB1G in test.active_brg.sup_caps and cfg_once:
                             cfg_once = False
                             cfg_pkt = cert_config.get_default_brg_pkt(test,
-                                                                      eval_pkt(f'ModuleEnergySub1GV{test.active_brg.api_version}'),
+                                                                      test.active_brg.energy_sub1g,
                                                                       **{BRG_PATTERN: ag.SUB1G_ENERGY_PATTERN_ISRAEL})
                             test = cert_config.brg_configure(test, cfg_pkt=cfg_pkt)[0]
                             if test.rc == TEST_FAILED:
@@ -388,9 +388,11 @@ def run(test):
         field_functionality_pass_fail_print(test, param.name)
         test.set_phase_rc(param.name, test.rc)
         test.add_phase_reason(param.name, test.reason)
-        if test.rc == TEST_FAILED and test.exit_on_param_failure:
-            break
-        else:
-            test.reset_result()
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+            else:
+                test.reset_result()  # reset result and continue to next param
+                continue
 
     return cert_common.test_epilog(test)

brg_certificate/tests/edge_mgmt/brg2brg_ota_ble5_test/brg2brg_ota_ble5_test.py

@@ -65,7 +65,7 @@ def run(test):
     utPrint(f"Configuring destination BRG {dest_brg.id_str} to RX Channel 10!")
     test.active_brg = dest_brg
     test = cert_config.brg_configure_ble5(test, fields=[BRG_RX_CHANNEL], values=[ag.RX_CHANNEL_10_250K],
-                                          module=eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}'))[0]
+                                          module=test.active_brg.datapath)[0]
     test.active_brg = src_brg
     time.sleep(5)
 

brg_certificate/tests/edge_mgmt/leds_test/leds_test.py

@@ -114,7 +114,7 @@ def run(test):
     # Energizing is OFF
     #  Default cfg for 2400 is 0 == no energizing so we only eliminating sub1g energizing
     utPrint("Configuring the BRG to no energizing in sub1g", "WARNING")
-    sub1g_module = eval_pkt(f'ModuleEnergySub1GV{test.active_brg.api_version}')
+    sub1g_module = test.active_brg.energy_sub1g
     test = cert_config.brg_configure(test, fields=[BRG_PATTERN], values=[ag.SUB1G_ENERGY_PATTERN_NO_ENERGIZING], module=sub1g_module)[0]
     if test.rc == TEST_FAILED and test.exit_on_param_failure:
         return cert_common.test_epilog(test, revert_brgs=True, modules=[sub1g_module])
@@ -190,7 +190,7 @@ def run(test):
     # ------------- Power management sleep & Keep Alive Mode ------------- #
     utPrint("Power management Sleep state & Keep Alive Mode check!", "HEADER")
     utPrint("Sending the BRG power management configuration in order to enter sleep state", "WARNING")
-    pwr_mgmt_module = eval_pkt(f'ModulePwrMgmtV{test.active_brg.api_version}')
+    pwr_mgmt_module = test.active_brg.pwr_mgmt
     test, wltpkt = cert_common.brg_pwr_mgmt_turn_on(test)
     if test.rc == TEST_FAILED and test.exit_on_param_failure:
         # Preventing leaving brg in pwr mgmt, protection for on that worked yet no ack was received