wiliot-certificate 4.5.0a2__py3-none-any.whl → 4.5.0a4__py3-none-any.whl

certificate/tests/cloud_connectivity/acl_test/acl_test.py

@@ -8,7 +8,7 @@ import certificate.cert_data_sim as cert_data_sim
 from certificate.ag.wlt_types_ag import *
 
 SCAN_TIMEOUT = 30
-
+NUM_OF_BRGS = 4
 # DEFINES
 test_indicator = cert_data_sim.PIXEL_SIM_INDICATOR
 
@@ -20,11 +20,11 @@ def run(test):
         return cert_common.test_epilog(test)
 
     # Generate management and data packets
-    bridge_ids = []
-    pixels_pkts, bridge_ids = cert_data_sim.brg_pkt_gen(num_of_pkts_per_brg=20, num_of_brgs=4,
-                                                        pkt_type=PIXELS_PKT, indicator=test_indicator)
+    bridge_ids = [cert_common.hex2alias_id_get(get_random_hex_str(12)) for _ in range(NUM_OF_BRGS)]
+    pixels_pkts, _ = cert_data_sim.brg_pkt_gen(num_of_pkts_per_brg=20, num_of_brgs=NUM_OF_BRGS, brgs_list=bridge_ids,
+                                               pkt_type=PIXELS_PKT, indicator=test_indicator)
 
-    mgmt_pkts, _ = cert_data_sim.brg_pkt_gen(num_of_pkts_per_brg=10, num_of_brgs=4, brgs_list=bridge_ids,
+    mgmt_pkts, _ = cert_data_sim.brg_pkt_gen(num_of_pkts_per_brg=10, num_of_brgs=NUM_OF_BRGS, brgs_list=bridge_ids,
                                              pkt_type=MGMT_PKT, indicator=test_indicator)
     # Use first 3 bridges for ACL, 4th bridge is not in ACL
     acl_bridge_ids = bridge_ids[:3]
@@ -41,7 +41,7 @@ def run(test):
         cfg = cert_config.get_default_gw_dict(test)
         cfg[ACL][ACL_BRIDGE_IDS] = acl_bridge_ids
         cfg[ACL][ACL_MODE] = param.value
-        test, ret = cert_config.gw_configure(test, cfg=cfg, wait=True)
+        test, _ = cert_config.gw_configure(test, cfg=cfg, wait=True)
         print_update_wait(1)
 
         test.get_mqttc_by_target(DUT).flush_pkts()
@@ -51,8 +51,8 @@ def run(test):
         # Analyze pass/fail
         # Get all received packets with the test indicator and filter packets by bridge IDs in ACL list
         received_pkts = cert_mqtt.get_unified_data_pkts(test, only_active_brg=False, indicator=test_indicator)
-        acl_bridge_pkts = [pkt for pkt in received_pkts if pkt[ALIAS_BRIDGE_ID] in acl_bridge_ids]
-        non_acl_bridge_pkts = [pkt for pkt in received_pkts if pkt[ALIAS_BRIDGE_ID] in non_acl_bridge_id]
+        acl_bridge_pkts = [pkt for pkt in received_pkts if any([id in pkt[PAYLOAD] for id in acl_bridge_ids])]
+        non_acl_bridge_pkts = [pkt for pkt in received_pkts if non_acl_bridge_id in pkt[PAYLOAD]]
 
         # In deny mode - we want to make sure bridges in ACL list are filtered
         if param.value == ACL_DENY:
@@ -71,20 +71,18 @@ def run(test):
                 test.add_reason(f"Phase failed! Bridge {non_acl_bridge_id} was not on the allow list "
                                 f"and {len(non_acl_bridge_pkts)} packets were found from it")
             # Check that we received packets from all expected bridges
-            received_bridge_ids = set([pkt[ALIAS_BRIDGE_ID] for pkt in acl_bridge_pkts])
-            if received_bridge_ids != set(acl_bridge_ids):
+            received_alias_bridge_ids = set([pkt[ALIAS_BRIDGE_ID] for pkt in acl_bridge_pkts])
+            if len(received_alias_bridge_ids) != len(acl_bridge_ids):
                 test.rc = TEST_FAILED
                 test.add_reason("Phase failed! Didn't receive packets from all bridges that were on the allow list")
 
         # Check that management packets are received from all bridges (ACL doesn't filter mgmt packets)
         all_mgmt_pkts = cert_mqtt.get_all_mgmt_pkts(test.get_mqttc_by_target(DUT), indicator=test_indicator)
-        mgmt_bridge_ids = set([pkt[ALIAS_BRIDGE_ID] for pkt in all_mgmt_pkts])
+        mgmt_alias_bridge_ids = set([pkt[ALIAS_BRIDGE_ID] for pkt in all_mgmt_pkts])
 
-        if not set(bridge_ids).issubset(mgmt_bridge_ids):
+        if len(mgmt_alias_bridge_ids) != NUM_OF_BRGS:
             test.rc = TEST_FAILED
-            missing_bridges = set(bridge_ids) - mgmt_bridge_ids
-            test.add_reason(f"Phase failed! Expected management packets from all bridges, "
-                            f"whether they are on the ACL or not, but missing from BRG {missing_bridges}")
+            test.add_reason("Phase failed! Didn't receive management packets from all bridges")
 
         field_functionality_pass_fail_print(test, "ACL", value=param.value)
         test.set_phase_rc(param.name, test.rc)

certificate/tests/cloud_connectivity/brg_ota_test/brg_ota_test.json

@@ -9,7 +9,7 @@
                   "Analyze if bridge was upgraded and action status message was uploaded",
                   "Test epilog"],
     "expectedOutcome": "Tester brg advertises ModuleIF packet with the new version and DUT Gateway publish an actionStatus message indicating success and  within timeout",
-    "mandatory": 1,
+    "mandatory": 0,
     "multiBridgeTest": 0,
     "gwOnlyTest": 1,
     "internalBridge": 1,

certificate/tests/cloud_connectivity/channel_scan_behaviour_test/channel_scan_behaviour_test.py

@@ -3,7 +3,6 @@ from certificate.cert_defines import *
 from certificate.wlt_types import *
 from certificate.ag.wlt_types_ag import OUTPUT_POWER_2_4_MAX
 import certificate.cert_common as cert_common
-import certificate.cert_utils as cert_utils
 import certificate.cert_mqtt as cert_mqtt
 import certificate.cert_config as cert_config
 import certificate.cert_gw_sim as cert_gw_sim
@@ -18,7 +17,7 @@ from collections import defaultdict
 # DEFINES
 CHANNELS = [37, 38, 39]  # channel to check in DUT
 DEFAULT_WAIT_TIME = 5  # How much extra time to wait after the transmition is over
-SCAN_TEST_INDICATOR = cert_utils.get_random_hex_str(len=6)  # Unique identifier for the pkt sent
+SCAN_TEST_INDICATOR = get_random_hex_str(6)  # Unique identifier for the pkt sent
 ADV_DURATION = 20  # How long to transmit to the DUT
 # cmd_ble_sm defines
 BLE_SIM_RADIO_1MBPS = 1
@@ -84,6 +83,7 @@ def analyze_listening_timeline(test, all_pkts_received_from_tester, num_of_sent_
     channel_cards = []
 
     # Parse data into {ts, channel pairs} - X and Y axis
+    all_pkts_received_from_tester = sorted(all_pkts_received_from_tester, key=lambda pkt: float(pkt.get(TIMESTAMP)))
     for idx, pkt in enumerate(all_pkts_received_from_tester):
         payload = pkt.get(PAYLOAD)
         channel = int(payload[-10:-8], 16)

certificate/tests/cloud_connectivity/connection_test/connection_test.py

@@ -25,19 +25,10 @@ def run(test):
     if not cert_common.pipeline_running():
         warning_prefix = COLORS["WARNING"]
         warning_suffix = COLORS["ENDC"]
-        input(
-            (
-                f"{warning_prefix}The GW is expected to publish a configuration "
-                "JSON/Protobuf message through the status topic upon connecting "
-                "to mqtt:\nPlease unplug GW from power. Press enter when unplugged"
-                f"{warning_suffix}"
-            )
-        )
         dut_mqttc.flush_pkts()
-        input(
-            f"{warning_prefix}Please plug GW back to power. "
-            f"Press enter when plugged{warning_suffix}"
-        )
+        input((f'{warning_prefix}TESTING CONNECTION RECOVERY AFTER POWER CYCLE OF THE GATEWAY\n'
+               "Please unplug and then plug GW back into power. Press enter when finished"
+               f"{warning_suffix}"))
     else:
         # If this test runs as part of a pipeline, act like the reboot test and don't demand a manual disconnect & connect
         utPrint(f"Publishing reboot action to {dut_mqttc.update_topic}. Awaiting reconnect.. (timeout is {TIMEOUT_IN_MINUTES} minutes)")
@@ -55,7 +46,7 @@ def run(test):
         print_update_wait(5)
 
     # generate logs
-    cert_mqtt.generate_log_file(test, "reboot")
+    cert_mqtt.generate_log_file(test, "connection")
 
     # Analyze results
     if gw_type is None:

certificate/tests/cloud_connectivity/deduplication_test/deduplication_test.py

@@ -3,14 +3,13 @@ from certificate.cert_prints import *
 from certificate.cert_defines import *
 from certificate.wlt_types import *
 import certificate.cert_common as cert_common
-import certificate.cert_utils as cert_utils
 import certificate.cert_mqtt as cert_mqtt
 import certificate.cert_data_sim as cert_data_sim
 import pandas as pd
 
 
 # DEFINES
-UPLINK_TEST_INDICATOR = cert_utils.get_random_hex_str(len=6)
+UPLINK_TEST_INDICATOR = get_random_hex_str(6)
 NUM_OF_BRGS = 3
 
 

certificate/tests/cloud_connectivity/downlink_test/downlink_test.py

@@ -121,10 +121,7 @@ def report_and_results(test, sniffed_pkts):
         test.reason = 'No packets collected.'
         return
 
-    if test.active_brg.board_type == ag.BOARD_TYPE_FANSTEL_WIFI_V0:
-        x_value = ('tx_max_retries', 'TX Max Retries')
-    else:
-        x_value = ('tx_max_duration', 'TX Max Duration')
+    x_value = ('tx_max_duration', 'TX Max Duration')
 
     # Create scatter with OLS trendline per channel
     fig = px.scatter(

certificate/tests/cloud_connectivity/ext_adv_stress_test/ext_adv_stress_test.py

@@ -12,7 +12,7 @@ import math
 
 
 # DEFINES
-STRESS_TEST_INDICATOR = cert_utils.get_random_hex_str(len=6)
+STRESS_TEST_INDICATOR = get_random_hex_str(6)
 
 DUPLICATES = 1
 ADVA_ASCII_LEN = 12
@@ -76,16 +76,19 @@ def run(test):
 
         cert_mqtt.dump_pkts(test, log=str(pps))
         phase_pkts_received = cert_mqtt.get_all_aggregated_data_pkts(test.get_mqttc_by_target(DUT), indicator=STRESS_TEST_INDICATOR)
-
+        valid, reason = cert_common.validate_received_packets(phase_pkts_received)
+        test.add_phase(cert_utils.Phase(pps))
+        if valid is False:
+            test.set_phase_rc(str(pps), TEST_FAILED)
+            test.add_phase_reason(str(pps), reason)
+            utPrint(f"Phase {pps} failed validation: {reason}", "RED")
+            continue
         test, received_pps = cert_common.stress_analysis(
             test, pps, generated_payloads,
             [(p[ALIAS_BRIDGE_ID] + p[AGGREGATED_PAYLOAD]) for p in phase_pkts_received])
         results.extend([pps, received_pps])
         cert_mqtt.generate_log_file(test, str(pps))
 
-        test.add_phase(cert_utils.Phase(pps))
-        test.set_phase_rc(str(pps), test.rc)
-        test.add_phase_reason(str(pps), test.reason)
         if test.rc == TEST_FAILED and 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
@@ -94,6 +97,9 @@ def run(test):
     cert_config.gw_action(test, f'{cert_gw_sim.BLE_SIM_INIT} 0', TESTER)
 
     # Generate stress test graphs
-    cert_common.generate_graph_stress_test(test, results, data_pkts_received)
+    if len(data_pkts_received) > 0:
+        cert_common.generate_graph_stress_test(test, results, data_pkts_received)
+    else:
+        utPrint("No data packets received - skipping graph generation", "RED")
 
     return cert_common.test_epilog(test)

certificate/tests/cloud_connectivity/registration_test/registration_test_cli.py

@@ -77,7 +77,7 @@ def main():
     cert_common.wait_time_n_print(2)
 
     # Print results
-    cert_results.generate_results_files(test.dut, test.tester, html=True, pdf=True, failures=failures,
+    cert_results.generate_results_files(html=True, pdf=True, failures=failures,
                                         skipped=skipped, start_time=start_time, tests=tests)
     if not pipeline_running():
         webbrowser.open('file://' + os.path.realpath(os.path.join(ARTIFACTS_DIR, UT_RESULT_FILE_PDF)))

certificate/tests/cloud_connectivity/stress_test/stress_test.py

@@ -12,7 +12,7 @@ import math
 
 
 # DEFINES
-STRESS_TEST_INDICATOR = cert_utils.get_random_hex_str(len=6)
+STRESS_TEST_INDICATOR = get_random_hex_str(6)
 
 DUPLICATES = 1
 ADVA_ASCII_LEN = 12
@@ -74,16 +74,19 @@ def run(test):
 
         cert_mqtt.dump_pkts(test, log=str(pps))
         phase_pkts_received = cert_mqtt.get_all_data_pkts(test.get_mqttc_by_target(DUT), indicator=STRESS_TEST_INDICATOR)
-
+        test.add_phase(cert_utils.Phase(pps))
+        valid, reason = cert_common.validate_received_packets(phase_pkts_received)
+        if valid is False:
+            test.set_phase_rc(str(pps), TEST_FAILED)
+            test.add_phase_reason(str(pps), reason)
+            utPrint(f"Phase {pps} failed validation: {reason}", "RED")
+            continue
         test, received_pps = cert_common.stress_analysis(
             test, pps, generated_payloads,
             [(p[ALIAS_BRIDGE_ID] + p[PAYLOAD]) for p in phase_pkts_received])
         results.extend([pps, received_pps])
         cert_mqtt.generate_log_file(test, str(pps))
 
-        test.add_phase(cert_utils.Phase(pps))
-        test.set_phase_rc(str(pps), test.rc)
-        test.add_phase_reason(str(pps), test.reason)
         if test.rc == TEST_FAILED and 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
@@ -91,7 +94,9 @@ def run(test):
         test_pkts_received.extend(test.get_mqttc_by_target(DUT)._userdata[PKTS].data)
     cert_config.gw_action(test, f'{cert_gw_sim.BLE_SIM_INIT} 0', TESTER)
 
-    # Generate stress test graphs
-    cert_common.generate_graph_stress_test(test, results, data_pkts_received)
+    if len(data_pkts_received) > 0:
+        cert_common.generate_graph_stress_test(test, results, data_pkts_received)
+    else:
+        utPrint("No data packets received - skipping graph generation", "RED")
 
     return cert_common.test_epilog(test)

certificate/tests/cloud_connectivity/uplink_ext_adv_test/uplink_ext_adv_test.py

@@ -4,14 +4,13 @@ from certificate.cert_prints import *
 from certificate.cert_defines import *
 from certificate.wlt_types import *
 import certificate.cert_common as cert_common
-import certificate.cert_utils as cert_utils
 import certificate.cert_mqtt as cert_mqtt
 import certificate.cert_config as cert_config
 import certificate.cert_data_sim as cert_data_sim
 from certificate.cert_gw_sim import GW_CERT_TESTER
 
 # DEFINES
-EXT_ADV_TEST_INDICATOR = cert_utils.get_random_hex_str(len=6)
+EXT_ADV_TEST_INDICATOR = get_random_hex_str(6)
 EXPECTED_REPEAT_COUNT = 7
 
 

certificate/tests/cloud_connectivity/uplink_test/uplink_test.py

@@ -4,7 +4,6 @@ from certificate.cert_defines import *
 from certificate.wlt_types import *
 from common.api_if.api_validation import api_validation
 import certificate.cert_common as cert_common
-import certificate.cert_utils as cert_utils
 import certificate.cert_mqtt as cert_mqtt
 import certificate.cert_data_sim as cert_data_sim
 import pandas as pd
@@ -13,24 +12,27 @@ import pandas as pd
 # DEFINES
 
 API_VALIDATION = "API Validation"
-UPLINK_TEST_INDICATOR = cert_utils.get_random_hex_str(len=6)
+UPLINK_TEST_INDICATOR = get_random_hex_str(6)
 NUM_OF_BRGS = 3
 
 
 # HELPER FUNCTIONS
-def uplink_analysis(test, pkts, received_pkts, pkt_type):
+def uplink_analysis(test, sent_pkts, received_pkts, pkt_type):
     if len(received_pkts) == 0:
         test.set_phase_rc(pkt_type, TEST_FAILED)
         test.add_phase_reason(pkt_type, "No packets were received!")
-        return test, 0
+        return test
 
-    _sent_pkts = []
-    for pkt in pkts:
-        pkt_str = pkt.get_pkt()
-        adva_endianness_change = cert_common.change_endianness(pkt_str[:12]) + pkt_str[12:]  # Switch to big endian adva
-        _sent_pkts.append(adva_endianness_change)
+    # Verify packets were received from NUM_OF_BRGS bridges
+    received_brgs = len(set([p[ALIAS_BRIDGE_ID] for p in received_pkts]))
+    if received_brgs != NUM_OF_BRGS:
+        test.set_phase_rc(pkt_type, TEST_FAILED)
+        test.add_phase_reason(pkt_type, f"Received packets from {received_brgs} bridges instead of {NUM_OF_BRGS} bridges!")
+        return test
 
+    _sent_pkts = [p.get_pkt()[12:] for p in sent_pkts]
     sent_df = pd.DataFrame(_sent_pkts, columns=[PACKETS])
+    received_pkts = [p[PAYLOAD] for p in received_pkts]
     received_df = pd.DataFrame(received_pkts, columns=[PACKETS])
 
     merged_df = pd.merge(sent_df, received_df, on=PACKETS, how='inner')
@@ -47,16 +49,17 @@ def uplink_analysis(test, pkts, received_pkts, pkt_type):
     if pkts_sent_count == 0:
         test.set_phase_rc(pkt_type, TEST_FAILED)
         test.add_phase_reason(pkt_type, "No packets were sent!")
-        return test, 0
+        return test
 
     percentage_received = round(pkts_received_count * 100 / pkts_sent_count)
 
     # PASS/FAIL logic
     if percentage_received < 80:
-        test.rc = TEST_FAILED
-        test.reason = f"Insufficient amount of {pkt_type} packets were scanned & uploaded by the gateway"
+        test.set_phase_rc(pkt_type, TEST_FAILED)
+        test.add_phase_reason(pkt_type, f'{percentage_received}% of {pkt_type} packets received')
     else:
-        test.reason = f'{percentage_received}% of {pkt_type} packets received'
+        test.set_phase_rc(pkt_type, TEST_PASSED)
+        test.add_phase_reason(pkt_type, f'{percentage_received}% of {pkt_type} packets received')
 
     return test
 
@@ -134,22 +137,25 @@ def run(test):
         all_data_messages_in_test.extend(dut_mqttc._userdata[PKTS].data)
         all_data_pkts.extend(cert_mqtt.get_all_data_pkts(dut_mqttc))
         recieved_pkts = cert_mqtt.get_all_data_pkts(dut_mqttc, indicator=UPLINK_TEST_INDICATOR)
+        valid, reason = cert_common.validate_received_packets(recieved_pkts)
+        if valid is False:
+            test.set_phase_rc(param.name, TEST_FAILED)
+            test.add_phase_reason(param.name, reason)
+            utPrint(f"Phase {param.name} failed validation: {reason}", "RED")
+            continue
 
-        test = uplink_analysis(test, pkts, [p[ALIAS_BRIDGE_ID] + p[PAYLOAD] for p in recieved_pkts], param.name)
+        test = uplink_analysis(test, pkts, recieved_pkts, param.name)
 
         cert_mqtt.generate_log_file(test, param.name)
-        field_functionality_pass_fail_print(test, 'pkt_type', value=param.name)
-        test.set_phase_rc(param.name, test.rc)
-        test.add_phase_reason(param.name, test.reason)
-        if test.rc == TEST_FAILED:
+        field_functionality_pass_fail_print(test.get_phase_by_name(param.name), 'pkt_type', value=param.name)
+        if test.get_phase_by_name(param.name).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
 
     # Other Validations
     # Api Validation
-    if not test.dut.protobuf:
-        test = api_validation(test)
+    test = api_validation(test)
     test = cert_common.wiliot_pkts_validation(test, all_data_messages_in_test, all_data_pkts)
 
     # Geolocation phase

certificate/tests/datapath/event_ble5_test/event_ble5_test.json

@@ -12,5 +12,5 @@
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
     "dataSimOnlyTest": 1,
-    "allSupportedValues": ["rssi_event", "new_tag_event_seconds", "new_tag_event_minutes", "new_tag_event_hours", "temp_event", "tx_rate_event"]
+    "allSupportedValues": ["rssi_event", "new_tag_event_seconds", "new_tag_event_minutes", "temp_event", "tx_rate_event"]
 }

certificate/tests/datapath/event_ble5_test/event_ble5_test.py

@@ -7,17 +7,9 @@ import certificate.cert_config as cert_config
 
 NEW_TAG_EVENT_SCAN_TIME = 100             # in seconds
 TAG_EVENT_SCAN_TIME = 60                 # in seconds
-NEW_TAG_HOURS_EVENT_SCAN_TIME = 62 * 60   # 62 minutes
 RSSI_MOVEMENT_THRESHOLD = 15
 
 
-def test_new_tag_event_hours(test, phase, datapath_module):
-    values = [ag.EVENT_TIME_UNIT_HOURS, TEST_EVENT_WINDOW_HR_CFG, ag.RX_CHANNEL_10_500K, ag.EVENT_TRIGGER_NEW_TAG, 0]
-    return cert_common.run_event_test_phase(test, phase, datapath_module, values, NEW_TAG_HOURS_EVENT_SCAN_TIME,
-                                            ag.EVENT_TIME_UNIT_HOURS, ble5_test=True,
-                                            pkt_filter_cfg=ag.PKT_FILTER_TEMP_AND_ADVANCED_PKTS)
-
-
 def test_new_tag_event_minutes(test, phase, datapath_module):
     values = [ag.EVENT_TIME_UNIT_MINUTES, TEST_EVENT_WINDOW_MIN_CFG, ag.RX_CHANNEL_10_500K, ag.EVENT_TRIGGER_NEW_TAG, 0]
     return cert_common.run_event_test_phase(test, phase, datapath_module, values, NEW_TAG_EVENT_SCAN_TIME,
@@ -54,7 +46,7 @@ def test_rssi_event(test, phase, datapath_module):
 
 
 EVENT_TEST_MAP = {"rssi_event": test_rssi_event, "new_tag_event_seconds": test_new_tag_event_seconds,
-                  "new_tag_event_minutes": test_new_tag_event_minutes, "new_tag_event_hours": test_new_tag_event_hours,
+                  "new_tag_event_minutes": test_new_tag_event_minutes,
                   "temp_event": test_temp_event, "tx_rate_event": test_tx_rate_event}
 
 
@@ -63,10 +55,11 @@ def run(test):
     test = cert_common.test_prolog(test)
     if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
+    dut = cert_config.get_brg_by_target(test, DUT)
 
     for param in test.params:
         phase_run_print(param.name)
-        test = EVENT_TEST_MAP[param.value](test, param.name, test.active_brg.datapath)
+        test = EVENT_TEST_MAP[param.value](test, param.name, dut.datapath)
         cert_mqtt.generate_log_file(test, param.name)
         field_functionality_pass_fail_print(test, param.name)
         test.set_phase_rc(param.name, test.rc)
@@ -79,10 +72,11 @@ def run(test):
                 continue
 
         # Reset to defaults after every phase (don't fail the phase on that)
-        test = cert_config.config_brg_defaults(test, modules=[test.active_brg.datapath], ble5=True)[0]
-        print_update_wait(2 * BLE5_MAX_DURATION_SEC)
+        test = cert_config.config_brg_defaults(test, modules=[dut.datapath], ble5=test.dut_is_bridge())[0]
         if test.rc == TEST_FAILED:
             test.add_reason("Failed to restore brg to defaults")
+        if test.dut_is_bridge():
+            wait_time_n_print(BLE5_MAX_DURATION_SEC)
 
         if test.rc == TEST_FAILED:
             test.set_phase_rc(param.name, test.rc)
@@ -92,4 +86,4 @@ def run(test):
         else:
             test.reset_result()
 
-    return cert_common.test_epilog(test, revert_brgs=True, modules=[test.active_brg.datapath], ble5=True)
+    return cert_common.test_epilog(test, revert_brgs=True, modules=[dut.datapath], ble5=test.dut_is_bridge())

certificate/tests/datapath/event_test/event_test.json

@@ -12,5 +12,5 @@
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
     "dataSimOnlyTest": 1,
-    "allSupportedValues": ["rssi_event", "new_tag_event_seconds", "new_tag_event_minutes", "new_tag_event_hours", "temp_event", "tx_rate_event"]
+    "allSupportedValues": ["rssi_event", "new_tag_event_seconds", "new_tag_event_minutes", "temp_event", "tx_rate_event"]
 }

certificate/tests/datapath/event_test/event_test.py

@@ -7,15 +7,9 @@ import certificate.cert_config as cert_config
 
 NEW_TAG_EVENT_SCAN_TIME = 100             # in seconds
 TAG_EVENT_SCAN_TIME = 60                 # in seconds
-NEW_TAG_HOURS_EVENT_SCAN_TIME = 62 * 60   # 62 minutes
 RSSI_MOVEMENT_THRESHOLD = 15
 
 
-def test_new_tag_event_hours(test, phase, datapath_module):
-    values = [ag.EVENT_TIME_UNIT_HOURS, TEST_EVENT_WINDOW_HR_CFG, ag.RX_CHANNEL_37, ag.EVENT_TRIGGER_NEW_TAG, 0]
-    return cert_common.run_event_test_phase(test, phase, datapath_module, values, NEW_TAG_HOURS_EVENT_SCAN_TIME, ag.EVENT_TIME_UNIT_HOURS)
-
-
 def test_new_tag_event_minutes(test, phase, datapath_module):
     values = [ag.EVENT_TIME_UNIT_MINUTES, TEST_EVENT_WINDOW_MIN_CFG, ag.RX_CHANNEL_37, ag.EVENT_TRIGGER_NEW_TAG, 0]
     return cert_common.run_event_test_phase(test, phase, datapath_module, values, NEW_TAG_EVENT_SCAN_TIME, ag.EVENT_TIME_UNIT_MINUTES)
@@ -45,7 +39,7 @@ def test_rssi_event(test, phase, datapath_module):
 
 
 EVENT_TEST_MAP = {"rssi_event": test_rssi_event, "new_tag_event_seconds": test_new_tag_event_seconds,
-                  "new_tag_event_minutes": test_new_tag_event_minutes, "new_tag_event_hours": test_new_tag_event_hours,
+                  "new_tag_event_minutes": test_new_tag_event_minutes,
                   "temp_event": test_temp_event, "tx_rate_event": test_tx_rate_event}
 
 
@@ -54,10 +48,11 @@ def run(test):
     test = cert_common.test_prolog(test)
     if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
+    dut = cert_config.get_brg_by_target(test, DUT)
 
     for param in test.params:
         phase_run_print(param.name)
-        test = EVENT_TEST_MAP[param.value](test, param.name, test.active_brg.datapath)
+        test = EVENT_TEST_MAP[param.value](test, param.name, dut.datapath)
         cert_mqtt.generate_log_file(test, param.name)
         field_functionality_pass_fail_print(test, param.name)
         test.set_phase_rc(param.name, test.rc)
@@ -70,7 +65,7 @@ def run(test):
                 continue
 
         # Reset to defaults after every phase (don't fail the phase on that)
-        test = cert_config.config_brg_defaults(test, modules=[test.active_brg.datapath])[0]
+        test = cert_config.config_brg_defaults(test, modules=[dut.datapath])[0]
         if test.rc == TEST_FAILED:
             test.add_reason("Failed to restore brg to defaults")
 
@@ -82,4 +77,4 @@ def run(test):
         else:
             test.reset_result()
 
-    return cert_common.test_epilog(test, revert_brgs=True, modules=[test.active_brg.datapath])
+    return cert_common.test_epilog(test, revert_brgs=True, modules=[dut.datapath])

certificate/tests/datapath/pacer_interval_ble5_test/pacer_interval_ble5_test.py

@@ -10,15 +10,15 @@ import certificate.cert_data_sim as cert_data_sim
 def run(test):
 
     fields = [BRG_PACER_INTERVAL, BRG_RX_CHANNEL, BRG_PKT_FILTER]
-    datapath_module = test.active_brg.datapath
+    dut = cert_config.get_brg_by_target(test, DUT)
 
     test = cert_common.test_prolog(test)
     if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
 
     for param in test.params:
-        test = cert_config.brg_configure_ble5(test, fields=fields, values=[param.value, ag.RX_CHANNEL_10_500K, ag.PKT_FILTER_TEMP_PKT],
-                                              module=datapath_module)[0]
+        test = cert_config.brg_configure(test, fields=fields, values=[param.value, ag.RX_CHANNEL_10_500K, ag.PKT_FILTER_TEMP_PKT],
+                                         module=dut.datapath, ble5=test.dut_is_bridge())[0]
         if test.rc == TEST_FAILED:
             if test.exit_on_param_failure:
                 break  # break the whole for loop and keep the test as failed
@@ -49,4 +49,4 @@ def run(test):
                 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], ble5=True)
+    return cert_common.test_epilog(test, revert_brgs=True, revert_gws=test.internal_brg, modules=[dut.datapath], ble5=test.dut_is_bridge())

certificate/tests/datapath/pkt_filter_ble5_chl21_test/pkt_filter_ble5_chl21_test.py

@@ -12,16 +12,16 @@ PKT_FILTER_TEST_PACER_INTERVAL = 10
 def run(test):
 
     fields = [BRG_PKT_FILTER, BRG_RX_CHANNEL, BRG_PACER_INTERVAL]
-    datapath_module = eval(f'ModuleDatapathV{test.active_brg.api_version}')
+    dut = cert_config.get_brg_by_target(test, DUT)
 
     test = cert_common.test_prolog(test)
     if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
 
     for param in test.params:
-        test = cert_config.brg_configure_ble5(test, fields=fields,
-                                              values=[param.value, RX_CHANNEL_21, PKT_FILTER_TEST_PACER_INTERVAL],
-                                              module=datapath_module)[0]
+        test = cert_config.brg_configure(test, fields=fields,
+                                         values=[param.value, RX_CHANNEL_21, PKT_FILTER_TEST_PACER_INTERVAL],
+                                         module=dut.datapath, ble5=test.dut_is_bridge())[0]
         test.set_phase_rc(param.name, test.rc)
         test.add_phase_reason(param.name, test.reason)
         if test.rc == TEST_FAILED:
@@ -58,4 +58,4 @@ def run(test):
                 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], ble5=True)
+    return cert_common.test_epilog(test, revert_brgs=True, revert_gws=test.internal_brg, modules=[dut.datapath], ble5=test.dut_is_bridge())

certificate/tests/datapath/pkt_filter_ble5_test/pkt_filter_ble5_test.py

@@ -12,16 +12,16 @@ PKT_FILTER_TEST_PACER_INTERVAL = 10
 def run(test):
 
     fields = [BRG_PKT_FILTER, BRG_RX_CHANNEL, BRG_PACER_INTERVAL]
-    datapath_module = eval(f'ModuleDatapathV{test.active_brg.api_version}')
+    dut = cert_config.get_brg_by_target(test, DUT)
 
     test = cert_common.test_prolog(test)
     if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
 
     for param in test.params:
-        test = cert_config.brg_configure_ble5(test, fields=fields,
-                                              values=[param.value, RX_CHANNEL_10_500K, PKT_FILTER_TEST_PACER_INTERVAL],
-                                              module=datapath_module)[0]
+        test = cert_config.brg_configure(test, fields=fields,
+                                         values=[param.value, RX_CHANNEL_10_500K, PKT_FILTER_TEST_PACER_INTERVAL],
+                                         module=dut.datapath, ble5=test.dut_is_bridge())[0]
         test.set_phase_rc(param.name, test.rc)
         test.add_phase_reason(param.name, test.reason)
         if test.rc == TEST_FAILED:
@@ -57,4 +57,4 @@ def run(test):
                 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], ble5=True)
+    return cert_common.test_epilog(test, revert_brgs=True, revert_gws=test.internal_brg, modules=[dut.datapath], ble5=test.dut_is_bridge())

certificate/tests/datapath/pkt_filter_brg2gw_ext_adv_test/pkt_filter_brg2gw_ext_adv_test.py

@@ -12,15 +12,16 @@ PKT_FILTER_TEST_PACER_INTERVAL = 4
 def run(test):
 
     fields = [BRG_PKT_FILTER, BRG_RX_CHANNEL, BRG_PACER_INTERVAL, BRG_PATTERN]
-    datapath_module = eval(f'ModuleDatapathV{test.active_brg.api_version}')
+    dut = cert_config.get_brg_by_target(test, DUT)
 
     test = cert_common.test_prolog(test)
     if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
 
-    test = cert_config.brg_configure_ble5(test, fields=fields, values=[PKT_FILTER_TEMP_AND_ADVANCED_PKTS,
-                                          RX_CHANNEL_10_500K, PKT_FILTER_TEST_PACER_INTERVAL,
-                                          DATAPATH_PATTERN_EXTENDED_ADV], module=datapath_module)[0]
+    test = cert_config.brg_configure(test, fields=fields,
+                                     values=[PKT_FILTER_TEMP_AND_ADVANCED_PKTS, RX_CHANNEL_10_500K,
+                                             PKT_FILTER_TEST_PACER_INTERVAL, DATAPATH_PATTERN_EXTENDED_ADV],
+                                     module=dut.datapath, ble5=test.dut_is_bridge())[0]
     if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
 
@@ -41,9 +42,10 @@ def run(test):
 
         # Configure the BRG to DATAPATH_PATTERN_EXTENDED_ADV_CH_10 if the GW listens to channel 10
         if param.value == RX_CHANNEL_10_500K:
-            test = cert_config.brg_configure_ble5(test, fields=fields, values=[PKT_FILTER_TEMP_AND_ADVANCED_PKTS,
-                                                  RX_CHANNEL_10_500K, PKT_FILTER_TEST_PACER_INTERVAL,
-                                                  DATAPATH_PATTERN_EXTENDED_ADV_CH_10], module=datapath_module)[0]
+            test = cert_config.brg_configure(test, fields=fields,
+                                             values=[PKT_FILTER_TEMP_AND_ADVANCED_PKTS, RX_CHANNEL_10_500K,
+                                                     PKT_FILTER_TEST_PACER_INTERVAL, DATAPATH_PATTERN_EXTENDED_ADV_CH_10],
+                                             module=dut.datapath, ble5=test.dut_is_bridge())[0]
             if test.rc == TEST_FAILED:
                 if test.exit_on_param_failure:
                     break  # break the whole for loop and keep the test as failed
@@ -80,4 +82,4 @@ def run(test):
         # Revert tester's rx channel
         test = cert_config.brg_configure(test, module=test.tester.internal_brg.datapath, target=TESTER)[0]
 
-    return cert_common.test_epilog(test, revert_brgs=True, modules=[datapath_module], ble5=True)
+    return cert_common.test_epilog(test, revert_brgs=True, modules=[dut.datapath], ble5=test.dut_is_bridge())

certificate/tests/datapath/rx_rate_gen2_test/rx_rate_gen2_test.py

@@ -31,7 +31,7 @@ def cal_scan_time(test, delay, pacer_interval):
 
 def scan_and_compare(test, pacer_interval, delay, expected_TBC_value):
 
-    pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=1, duplicates=3, delay=delay, pkt_types=[0], pixels_type=GEN3)
+    pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=1, duplicates=3, delay=delay, pkt_types=[0], pixels_type=GEN2)
     pixel_sim_thread.start()
     test, scan_time = cal_scan_time(test, delay, pacer_interval)
     df = cert_common.data_scan(test, scan_time=scan_time, brg_data=(not test.internal_brg), gw_data=test.internal_brg)