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

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,9 @@ 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
+        test.reset_result()  # reset result and continue to next param
 
     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.json

@@ -9,7 +9,7 @@
                   "Checking for packets violating RSSI threshold",
                   "Test epilog and revert to defaults"],
     "expectedOutcome": "RSSI Threshold configured successfully and no pixel packets with RSSI weaker than the threshold have been echoed.",
-    "mandatory": 1,
+    "mandatory": 0,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
     "internalBridge": 1,

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,9 @@ 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
+        test.reset_result()  # reset result and continue to next param
 
     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.json

@@ -8,7 +8,7 @@
                   "For each supported value - configure the BRG and verify the value",
                   "Test epilog and revert to defaults"],
     "expectedOutcome": "All values configured successfully",
-    "mandatory": 1,
+    "mandatory": 0,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
     "internalBridge": 1,

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,15 @@ 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
+        test.reset_result()  # reset result and continue to next param
 
     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,50 +162,46 @@ 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}')
-    test = cert_common.test_prolog(test)
-    if test.rc == TEST_FAILED:
-        return cert_common.test_epilog(test)
+    datapath_module = test.active_brg.datapath
 
+    test = cert_common.test_prolog(test)
     pacer_interval = 1
     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
+    name = test.phases[0].name
+    test.set_phase_rc(name, test.rc)
+    test.add_phase_reason(name, test.reason)
+
+    if test.rc == TEST_FAILED:
+        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 +212,9 @@ 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
+        test.reset_result()  # reset result and continue to next param
 
     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,50 +162,46 @@ 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}')
-    test = cert_common.test_prolog(test)
-    if test.rc == TEST_FAILED:
-        return cert_common.test_epilog(test)
+    datapath_module = test.active_brg.datapath
 
+    test = cert_common.test_prolog(test)
     pacer_interval = 1
     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
+    name = test.phases[0].name
+    test.set_phase_rc(name, test.rc)
+    test.add_phase_reason(name, test.reason)
+
+    if test.rc == TEST_FAILED:
+        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 +212,9 @@ 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
+        test.reset_result()  # reset result and continue to next param
 
     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,
+    "mandatory": 0,
     "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

@@ -11,8 +11,13 @@ import time
 
 def metric_checking_HB(test, check, mgmt_type_list, tx_queue_expected, pacer_increment_expected):
     if not mgmt_type_list:
-        test.add_reason("\nDidn't find HB pkt, therefore skip all checks\n")
-        print("Didn't find HB pkt, therefore will not check tx_queue and pacer increment")
+        if check:
+            test.add_reason("\nDidn't find HB pkt, therefore skip all checks\n")
+            print("Didn't find HB pkt, therefore will not check tx_queue and pacer increment")
+        else:
+            test.rc = TEST_PASSED  # skip the rc result if we didn't find HB pkt
+            print("Didn't find HB pkt, therefore will not check tx_queue and pacer increment")
+
     else:
         # check tx queue
         watermarks = [pkt.tx_queue_watermark for pkt in mgmt_type_list]
@@ -30,7 +35,7 @@ def metric_checking_HB(test, check, mgmt_type_list, tx_queue_expected, pacer_inc
             print(f"\npacer_increment value is wrong\nexpected: {pacer_increment_expected}\ngot: {average_pacer_increment_HB}")
             if check:
                 test.rc = TEST_FAILED
-                test.add_reason(f"pacer_increment:{average_pacer_increment_HB}")
+                test.add_reason(f"pacer_increment: {average_pacer_increment_HB} expected: {pacer_increment_expected}")
         else:
             print(f"\naverage pacer_increment from HB: {average_pacer_increment_HB}\n")
             if check:
@@ -96,7 +101,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)
@@ -107,8 +112,8 @@ def combination_func(test, param, datapath_module, pacer_interval, num_of_sim_ta
     hbs = [p[MGMT_PKT].pkt for p in hbs]
     print("result of first df\n")
     check = False
-    test = metric_checking_HB(test, check, hbs, tx_queue_expected, pacer_increment_expected)
     test = metric_checking_df(test, check, pacer_interval, df, repetition_value_expected, brg_latency_expected, num_of_sim_tags)
+    test = metric_checking_HB(test, check, hbs, tx_queue_expected, pacer_increment_expected)
     time.sleep(30)
     # second df
     df = cert_common.data_scan(test, scan_time=60, brg_data=(not test.internal_brg), gw_data=test.internal_brg)
@@ -117,8 +122,10 @@ def combination_func(test, param, datapath_module, pacer_interval, num_of_sim_ta
     hbs = [p[MGMT_PKT].pkt for p in hbs]
     print("result of second df\n")
     check = True
-    test = metric_checking_HB(test, check, hbs, tx_queue_expected, pacer_increment_expected)
     test = metric_checking_df(test, check, pacer_interval, df, repetition_value_expected, brg_latency_expected, num_of_sim_tags)
+    if param.name != "rep1":
+        check = False
+    test = metric_checking_HB(test, check, hbs, tx_queue_expected, pacer_increment_expected)
     return test
 
 
@@ -147,7 +154,7 @@ def rep1(test, param, datapath_module, num_of_sim_tags):
     pacer_interval = 7
     test = combination_func(test, param, datapath_module, pacer_interval=pacer_interval, num_of_sim_tags=num_of_sim_tags,
                             repetition_value_expected=[1, 2], tx_queue_expected=[20, 40],
-                            pacer_increment_expected=[0, 2], brg_latency_expected=[200, 300])
+                            pacer_increment_expected=[0, 25], brg_latency_expected=[200, 300])
     time.sleep(5)
     return test
 
@@ -165,17 +172,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,11 +196,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()
-        time.sleep(5)
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+        test.reset_result()  # reset result and continue to next param
+
     pixel_sim_thread.stop()
     # Re-enable unified packets deduplication
     cert_config.gw_action(test, f"{DEDUPLICATION_PKTS} 1")

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,
+    "mandatory": 0,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
     "internalBridge": 0,
-    "allSupportedValues": ["rep3", "rep2", "rep1", "rep1_adaptive_pacer"]
+    "allSupportedValues": ["rep3", "rep2", "rep1"]
 }