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

brg_certificate/cert_config.py

@@ -161,7 +161,10 @@ def fields_n_vals_dict_get(fields, values):
     functionality_run_print(print_string)
     return fields_and_values
 
-def brg_configure(test, cfg_pkt=None, module=None, fields=None, values=None, wait=True, ret_cfg_pkt=False):
+def brg_configure(test, cfg_pkt=None, module=None, fields=None, values=None, wait=True, ret_cfg_pkt=False, ble5=False):
+    if ble5:
+        return brg_configure_ble5(test, cfg_pkt=cfg_pkt, module=module, fields=fields,
+                                  values=values, ret_cfg_pkt=ret_cfg_pkt, wait=wait)
     retries = 3
     if not cfg_pkt:
         fields_n_vals = fields_n_vals_dict_get(fields, values)
@@ -217,7 +220,9 @@ def brg_configure_ble5(test, cfg_pkt=None, module=None, fields=None, values=None
     wlt_pkt = WltPkt()
     start_time = datetime.datetime.now()
     gw_downlink(test=test, raw_tx_data=cfg_pkt.dump(), max_duration=BLE5_MAX_DURATION, max_retries=BLE5_MAX_RETRIES)
-    while not pkts_found and wait:
+    if wait is False:
+        return test, DONE
+    while not pkts_found:
         if ((datetime.datetime.now() - start_time).seconds > ((ag.BLE5_PARAM_PRIMARY_CHANNEL_SCAN_CYCLE/1000)+1)):
             if num_of_tries < 3:
                 num_of_tries += 1
@@ -279,16 +284,16 @@ def get_default_brg_pkt(test, pkt_type, group_id=ag.GROUP_ID_GW2BRG, seq_id=0, *
         brg_pkt = WltPkt(hdr=ag.Hdr(group_id=group_id), pkt=pkt_type(brg_mac=test.active_brg.id_int if test.active_brg else 0, seq_id=seq_id, **kwargs))
         return brg_pkt
 
-def config_brg_defaults(test, modules=[], ble5=False):
+def config_brg_defaults(test, modules=[], ble5=False, wait=True):
     failed_cfg = False
     modules = test.active_brg.modules if not modules else modules
     for module in modules:
         utPrint(f"Configuring {module.__name__} to defaults. board type[{test.active_brg.board_type}] api version[{test.active_brg.api_version}]", "BLUE")
         cfg_pkt = get_default_brg_pkt(test, module)
         if ble5:
-            test, res = brg_configure_ble5(test=test, cfg_pkt=cfg_pkt)
+            test, res = brg_configure_ble5(test=test, cfg_pkt=cfg_pkt, wait=wait)
         else:
-            test, res = brg_configure(test=test, cfg_pkt=cfg_pkt)
+            test, res = brg_configure(test=test, cfg_pkt=cfg_pkt, wait=wait)
         if res == NO_RESPONSE:
             utPrint(f"FAILURE: {module.__name__} not configured to defaults", "RED")
             failed_cfg = True
@@ -296,9 +301,9 @@ def config_brg_defaults(test, modules=[], ble5=False):
             utPrint(f"SUCCESS: {module.__name__} configured to defaults", "GREEN")
     return (test, DONE) if not failed_cfg else (test, NO_RESPONSE)
 
-def config_brg1_defaults(test, modules=[], ble5=False):
+def config_brg1_defaults(test, modules=[], ble5=False, wait=True):
     test.active_brg = test.brg1
-    test, res = config_brg_defaults(test, modules, ble5)
+    test, res = config_brg_defaults(test, modules=modules, ble5=ble5, wait=wait)
     test.active_brg = test.brg0
     return test, res
 

brg_certificate/cert_utils.py

@@ -25,7 +25,7 @@ ORIGINAL_AG_FILE = "wlt_types_ag.py"
 TEST_MODULES_MAP = {"calibration": ag.MODULE_CALIBRATION, "datapath": ag.MODULE_DATAPATH, "energy2400": ag.MODULE_ENERGY_2400, "energy_sub1g": ag.MODULE_ENERGY_SUB1G,
                     "pwr_mgmt": ag.MODULE_PWR_MGMT, "sensors": ag.MODULE_EXT_SENSORS, "custom": ag.MODULE_CUSTOM}
 
-STATIC_RANDOM_ADDR_MASK = 0x0000000000C0
+STATIC_RANDOM_ADDR_MASK = 0xC00000000000
 hex2alias_id_get = lambda id_str: cert_common.int2mac_get(int(id_str, 16) | STATIC_RANDOM_ADDR_MASK)
 
 def module2name(module_id):
@@ -85,6 +85,7 @@ class WltTest:
         self.internal_brg_obj = internal_brg_obj
         # Actual brg to cfg - can be brg0 or brg1
         self.active_brg = brg0
+        self.ab = self.active_brg  # alias name
         self.brg0 = brg0
         self.brg1 = brg1
         self.rc = TEST_PASSED
@@ -232,6 +233,7 @@ class Bridge:
                     if module in TEST_MODULES_MAP:
                         self.sup_caps += [TEST_MODULES_MAP[module]]
                         self.modules += [eval_pkt(ag.MODULES_DICT[TEST_MODULES_MAP[module]] + str(self.api_version))]
+                        setattr(self, module, eval_pkt(ag.MODULES_DICT[TEST_MODULES_MAP[module]] + str(self.api_version)))
 
     def update_modules(self):
         self.modules = []

brg_certificate/certificate_bcc_test_list.txt

@@ -14,8 +14,8 @@ energy2400/pattern_test ENERGY_PATTERN_2_4_NO_ENERGIZING ENERGY_PATTERN_2_4_CHAN
 energy2400/output_power_test -12 -8 -4 0 2 3
 energy2400/duty_cycle_test 1 25 50 75
 energy2400/signal_indicator_test internal_brg rssi_threshold brg0_rx_brg1_tx brg0_none_brg1_rx brg0_rxtx_brg1_rxtx brg0_tx_brg1_none
-energy2400/signal_indicator_ble5_10_500k_test internal_brg rssi_threshold brg0_rx_brg1_tx brg0_none_brg1_rx brg0_rxtx_brg1_rxtx brg0_tx_brg1_none
-energy2400/signal_indicator_ble5_10_250k_test internal_brg rssi_threshold brg0_rx_brg1_tx brg0_none_brg1_rx brg0_rxtx_brg1_rxtx brg0_tx_brg1_none 
+energy2400/signal_indicator_ble5_10_500k_test internal_brg rssi_threshold brg0_tx_brg1_rx brg0_none_brg1_rx brg0_rxtx_brg1_rxtx brg0_tx_brg1_none
+energy2400/signal_indicator_ble5_10_250k_test internal_brg rssi_threshold brg0_tx_brg1_rx brg0_none_brg1_rx brg0_rxtx_brg1_rxtx brg0_tx_brg1_none
 
 # ------------- energy_sub1g -------------
 energy_sub1g/pattern_test SUB1G_ENERGY_PATTERN_NO_ENERGIZING SUB1G_ENERGY_PATTERN_SINGLE_TONE_915000 SUB1G_ENERGY_PATTERN_FCC_HOPPING SUB1G_ENERGY_PATTERN_SINGLE_TONE_917500 SUB1G_ENERGY_PATTERN_NZ_HOPPING

brg_certificate/certificate_test_list.txt

@@ -14,8 +14,8 @@ energy2400/pattern_test ENERGY_PATTERN_2_4_NO_ENERGIZING ENERGY_PATTERN_2_4_CHAN
 energy2400/output_power_test -12 -8 -4 0 2 3
 energy2400/duty_cycle_test 1 25 50 75
 energy2400/signal_indicator_test internal_brg rssi_threshold brg0_rx_brg1_tx brg0_none_brg1_rx brg0_rxtx_brg1_rxtx brg0_tx_brg1_none
-energy2400/signal_indicator_ble5_10_500k_test internal_brg rssi_threshold brg0_rx_brg1_tx brg0_none_brg1_rx brg0_rxtx_brg1_rxtx brg0_tx_brg1_none
-energy2400/signal_indicator_ble5_10_250k_test internal_brg rssi_threshold brg0_rx_brg1_tx brg0_none_brg1_rx brg0_rxtx_brg1_rxtx brg0_tx_brg1_none
+energy2400/signal_indicator_ble5_10_500k_test internal_brg rssi_threshold brg0_tx_brg1_rx brg0_none_brg1_rx brg0_tx_brg1_none
+energy2400/signal_indicator_ble5_10_250k_test internal_brg rssi_threshold brg0_tx_brg1_rx brg0_none_brg1_rx brg0_tx_brg1_none
 
 # ------------- energy_sub1g -------------
 energy_sub1g/pattern_test SUB1G_ENERGY_PATTERN_NO_ENERGIZING SUB1G_ENERGY_PATTERN_SINGLE_TONE_915000 SUB1G_ENERGY_PATTERN_FCC_HOPPING SUB1G_ENERGY_PATTERN_SINGLE_TONE_917500 SUB1G_ENERGY_PATTERN_NZ_HOPPING
@@ -36,8 +36,8 @@ datapath/rx_channel_test RX_CHANNEL_37 RX_CHANNEL_38 RX_CHANNEL_39 RX_CHANNEL_10
 datapath/rx_rate_gen2_test mid_values diff_pacer min_value max_value  diff_rate
 datapath/rx_rate_gen3_test mid_values diff_pacer min_value max_value  diff_rate
 datapath/pacer_interval_tags_count_test 1 10 15 30
-datapath/stress_test rep3 rep2 rep1 rep1_adaptive_pacer pixel_burst
-datapath/stress_gen3_test rep3 rep2 rep1 rep1_adaptive_pacer pixel_burst
+datapath/stress_test rep3 rep2 rep1
+datapath/stress_gen3_test rep3 rep2 rep1
 datapath/aging_test low_pacer high_pacer
 datapath/num_of_tags_test 5000
 

brg_certificate/tests/calibration/interval_test/interval_test.py

@@ -8,7 +8,7 @@ import brg_certificate.cert_config as cert_config
 def run(test):
 
     fields = [BRG_CALIB_INTERVAL]
-    calib_module = eval_pkt(f'ModuleCalibrationV{test.active_brg.api_version}')
+    calib_module = test.active_brg.calibration
 
     test = cert_common.test_prolog(test)
     if test.rc == TEST_FAILED:
@@ -20,9 +20,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, modules=[calib_module])

brg_certificate/tests/calibration/output_power_test/output_power_test.py

@@ -8,7 +8,7 @@ import brg_certificate.cert_config as cert_config
 def run(test):
 
     fields = [BRG_OUTPUT_POWER]
-    calib_module = eval_pkt(f'ModuleCalibrationV{test.active_brg.api_version}')
+    calib_module = test.active_brg.calibration
 
     test = cert_common.test_prolog(test)
     if test.rc == TEST_FAILED:
@@ -20,9 +20,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, modules=[calib_module])

brg_certificate/tests/calibration/pattern_test/pattern_test.py

@@ -8,8 +8,8 @@ import brg_certificate.cert_config as cert_config
 def run(test):
 
     fields = [BRG_PATTERN]
-    calib_module = eval_pkt(f'ModuleCalibrationV{test.active_brg.api_version}')
-    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
+    calib_module = test.active_brg.calibration
+    datapath_module = test.active_brg.datapath
 
     test = cert_common.test_prolog(test)
     if test.rc == TEST_FAILED:
@@ -25,6 +25,12 @@ def run(test):
                 # Configure the BRG, wait=False
                 test = cert_config.brg_configure(test, fields=[BRG_PATTERN, BRG_CALIB_INTERVAL],
                                                  values=[param.value, 1], module=calib_module, wait=False)[0]
+                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
                 cert_common.wait_time_n_print(CLEAR_DATA_PATH_TIMEOUT)
                 # MQTT scan
                 if test.data == DATA_SIMULATION:
@@ -51,19 +57,23 @@ 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
         else:
             test = cert_config.brg_configure(test, fields=fields, values=[param.value], module=calib_module)[0]
             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=[calib_module, datapath_module])

brg_certificate/tests/datapath/aging_test/aging_test.py

@@ -31,7 +31,7 @@ def combination_func(test, datapath_module, pacer_interval, num_of_sim_tags, agi
     if test.rc == TEST_FAILED and test.reason != TEST_PASSED:
         for i in range(2):
             if test.rc == TEST_PASSED:
-                return test
+                break  # exist the loop and continue, if succeeded
             test = cert_config.brg_configure(test, fields=[BRG_PACER_INTERVAL], values=[pacer_interval], module=datapath_module)[0]
         test = test.add_reason("Didn't succeed to configure after two attempts - No pkt was found!")
         return test
@@ -118,25 +118,27 @@ def high_pacer(test, 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)
 
-    STRESS_TEST_MAP = {"low_pacer": low_pacer, "high_pacer": high_pacer}
+    AGING_TEST_MAP = {"low_pacer": low_pacer, "high_pacer": high_pacer}
     num_of_pixels = 500
 
     for param in test.params:
         functionality_run_print(param.name)
-        test = STRESS_TEST_MAP[param.value](test, datapath_module, num_of_pixels)
+        test = AGING_TEST_MAP[param.value](test, datapath_module, num_of_pixels)
         generate_log_file(test, param.name)
         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()
+                continue
         time.sleep(5)
 
-    return cert_common.test_epilog(test, revert_brgs=True, revert_gws=False, modules=[datapath_module])
+    return cert_common.test_epilog(test, revert_brgs=True, modules=[datapath_module])

brg_certificate/tests/datapath/num_of_tags_test/num_of_tags_test.py

@@ -10,7 +10,7 @@ GW_CYCLE_TIME = 0.02  # GW sends BLE packet every 20 nsec
 
 def run(test):
 
-    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
+    datapath_module = test.active_brg.datapath
     print(f"values: {[param.value for param in test.params]}")
 
     test = cert_common.test_prolog(test)
@@ -60,25 +60,23 @@ def run(test):
 
         # compare the numbers of tags that come from the brg, success in 95% from number of tags (value) or more.
         if num_of_tags < (param.value * 0.95):
-            test.rc = TEST_FAILED
-            test.add_reason(f"Found {num_of_tags} pixels instead of {param.name} pixels!")
-            test.add_reason(f"Note - HB was {num_of_tags_HB}")
+            test.add_reason(f"Found {num_of_tags} pixels expected: {param.name} pixels!")
+            test.add_reason(f"HB: {num_of_tags_HB}, Df: {num_of_tags}")
 
         # compare the counter tags in the HB packet
-        if num_of_tags_HB < param.value or num_of_tags_HB > (param.value + 100):
-            test.rc = TEST_FAILED
-            test.add_reason(f"pixels counter in HB packet is  {num_of_tags_HB} instead of {param.name} pixels!")
-            test.add_reason(f"Note - tag counter field = {num_of_tags}")
-
+        if num_of_tags_HB < 0.95 * param.value or num_of_tags_HB > (param.value + 100):
+            test.add_reason(f"Found {num_of_tags_HB} pixels expected: {param.name} pixels!")
+            test.add_reason(f"HB: {num_of_tags_HB}, Df: {num_of_tags}")
         # param epilog
         time.sleep(10)
         generate_log_file(test, param.name)
         field_functionality_pass_fail_print(test, "num_of_tags", 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
+            else:
+                test.reset_result()
 
     return cert_common.test_epilog(test)

brg_certificate/tests/datapath/output_power_test/output_power_test.py

@@ -8,7 +8,7 @@ import brg_certificate.cert_config as cert_config
 def run(test):
 
     fields = [BRG_OUTPUT_POWER]
-    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:
@@ -20,9 +20,11 @@ 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, modules=[datapath_module])

brg_certificate/tests/datapath/pacer_interval_ble5_test/pacer_interval_ble5_test.py

@@ -8,7 +8,7 @@ import brg_certificate.cert_config as cert_config
 def run(test):
 
     fields = [BRG_PACER_INTERVAL, BRG_RX_CHANNEL, BRG_PKT_FILTER]
-    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:
@@ -17,8 +17,12 @@ def run(test):
     for param in test.params:
         test = cert_config.brg_configure_ble5(test, fields=fields, values=[param.value, ag.RX_CHANNEL_10_250K, ag.PKT_FILTER_TEMP_PKT],
                                               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
         num_of_pixels = 0
         if test.data == DATA_SIMULATION:
             # start generating pkts and send them using data simulator
@@ -38,9 +42,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], ble5=True)

brg_certificate/tests/datapath/pacer_interval_tags_count_test/pacer_interval_tags_count_test.py

@@ -9,7 +9,7 @@ def run(test):
     pacer_threshold = PACER_INTERVAL_THRESHOLD_HIGH if test.private_setup else PACER_INTERVAL_THRESHOLD
 
     fields = [BRG_PACER_INTERVAL, BRG_TX_REPETITION]
-    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:
@@ -30,9 +30,12 @@ def run(test):
     tags_count_per_pacer = {}
     for param in test.params:
         test = cert_config.brg_configure(test, fields=fields, values=[param.value, 1], module=datapath_module)[0]
-        if test.rc == TEST_FAILED and test.exit_on_param_failure:
-            generate_log_file(test, param.name)
-            return cert_common.test_epilog(test, revert_brgs=True, revert_gws=test.internal_brg, modules=[datapath_module])
+        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
         df = cert_common.data_scan(test, scan_time=120, brg_data=True)
         cert_common.display_data(df, nfpkt=True, tbc=True, name_prefix=f"brg_pacer_tags_count_{param.name}_", dir=test.dir)
         tags_count_per_pacer[param.value] = df[TAG_ID].nunique()
@@ -52,6 +55,10 @@ def run(test):
     print("tags_count_per_pacer: ", tags_count_per_pacer)
     max_count = max([tags_count_per_pacer[pacer] for pacer in tags_count_per_pacer])
     for param in test.params:
+        if param.value not in tags_count_per_pacer:
+            test.set_phase_rc(param.name, TEST_FAILED)
+            test.add_phase_reason(param.name, f"param value {param.value} not found in tags_count_per_pacer")
+            continue  # Skip this param because the scan wasn't performed
         if test.data == DATA_SIMULATION:
             if tags_count_per_pacer[param.value] < num_of_pixels * 0.99 or tags_count_per_pacer[param.value] > num_of_pixels * 1.01:
                 test.set_phase_rc(param.name, TEST_FAILED)

brg_certificate/tests/datapath/pacer_interval_test/pacer_interval_test.py

@@ -8,7 +8,7 @@ import brg_certificate.cert_config as cert_config
 def run(test):
 
     fields = [BRG_PACER_INTERVAL, 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:
@@ -19,10 +19,12 @@ def run(test):
                                          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
 
         num_of_pixels = 0
         if test.data == DATA_SIMULATION:
@@ -42,11 +44,11 @@ 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:
-            break
+            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/pattern_test/pattern_test.py

@@ -8,7 +8,7 @@ import brg_certificate.cert_config as cert_config
 def run(test):
 
     fields = [BRG_PATTERN]
-    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:
@@ -21,9 +21,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, modules=[datapath_module])

brg_certificate/tests/datapath/pkt_filter_ble5_test/pkt_filter_ble5_test.py

@@ -22,11 +22,12 @@ def run(test):
                                               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:
-            test.add_reason(f"Failed to configure BRG with {param.name} filter")
-            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)
         num_of_pixels = 0
@@ -50,9 +51,11 @@ 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], ble5=True)

brg_certificate/tests/datapath/pkt_filter_gen3_test/pkt_filter_gen3_test.py

@@ -11,7 +11,7 @@ def run(test):
 
     # We add the field BRG_RX_CHANNEL so internal BRGs will be configured to channel 37 (default is 39)
     fields = [BRG_PKT_FILTER, BRG_RX_CHANNEL, BRG_PACER_INTERVAL]
-    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:
@@ -22,11 +22,12 @@ def run(test):
                                          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:
-            test.add_reason(f"Failed to configure BRG with {param.name} filter")
-            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)
 
@@ -51,9 +52,11 @@ 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/pkt_filter_test/pkt_filter_test.py

@@ -11,7 +11,7 @@ def run(test):
 
     # We add the field BRG_RX_CHANNEL so internal BRGs will be configured to channel 37 (default is 39)
     fields = [BRG_PKT_FILTER, BRG_RX_CHANNEL, BRG_PACER_INTERVAL]
-    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:
@@ -22,11 +22,12 @@ def run(test):
                                          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:
-            test.add_reason(f"Failed to configure BRG with {param.name} filter")
-            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)
 
@@ -51,9 +52,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])