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

brg_certificate/certificate_test_list.txt

@@ -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

@@ -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

@@ -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

@@ -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
@@ -123,20 +123,22 @@ def run(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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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])

brg_certificate/tests/datapath/rssi_threshold_test/rssi_threshold_test.py

@@ -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

@@ -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,35 +162,27 @@ 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
 
 
@@ -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)