wiliot-certificate 4.5.0a1__py3-none-any.whl → 4.5.0a3__py3-none-any.whl

certificate/cert_common.py

@@ -606,8 +606,8 @@ def run_event_test_phase(test, phase, datapath_module, values, scan_time, event_
         scan_time_multiplier = (1 / 3)
         fields += [BRG_RSSI_MOVEMENT_THRESHOLD]
 
-    test = (cert_config.brg_configure_ble5(test, fields=fields, values=values, module=datapath_module)[0] if ble5_test
-            else cert_config.brg_configure(test, fields=fields, values=values, module=datapath_module)[0])
+    ble5 = ble5_test and test.dut_is_bridge()  # ble5 only for bridge dut (with combo we don't need to wait)
+    test = cert_config.brg_configure(test, fields=fields, values=values, module=datapath_module, ble5=ble5)[0]
     test.set_phase_rc(phase, test.rc)
     test.add_phase_reason(phase, test.reason)
     if test.rc == TEST_FAILED and test.exit_on_param_failure:
@@ -1273,7 +1273,6 @@ def output_power_supported(board_type, output_power):
     else:
         return output_power in ag.OUTPUT_POWER_2_4_SUPPORTED_VALUES
 
-
 def wiliot_pkts_validation(test, all_messages_in_test, all_data_pkts):
     PHASE_NAME = "Wiliot packets validation"
     phase_run_print(PHASE_NAME)
@@ -1290,7 +1289,7 @@ def wiliot_pkts_validation(test, all_messages_in_test, all_data_pkts):
         wiliot_pkts_validation_phase = seq_id_validation(wiliot_pkts_validation_phase, all_data_pkts)
 
     field_functionality_pass_fail_print(wiliot_pkts_validation_phase, PHASE_NAME)
-    test.phases[-1:-1] = [wiliot_pkts_validation_phase]
+    test.add_phase(wiliot_pkts_validation_phase)
     return test
 
 
@@ -1373,19 +1372,19 @@ def generate_graph_stress_test(test, results, test_pkts_received):
     graph_data = []
     for i in range(0, len(results), 2):
         if i + 1 < len(results):
-            graph_data.append({'pkts_per_sec': results[i], 'percent_received': results[i + 1]})
+            graph_data.append({'pkts_per_sec': results[i], 'received_pps': results[i + 1]})
     
     graph_df = pd.DataFrame(graph_data)
     html_file_path = os.path.join(ARTIFACTS_DIR, test.dir, 'stress_graph.html')
     
     # First graph: percentage received vs packets per second
-    fig1 = px.line(graph_df, x='pkts_per_sec', y='percent_received',
-                   title='Percentage of packets uploaded by packets per second advertised',
-                   labels={'pkts_per_sec': 'Packets Sent Per Second', 'percent_received': 'Percentage of packets received'},
-                   markers=True, text='percent_received')
+    fig1 = px.line(graph_df, x='pkts_per_sec', y='received_pps',
+                   title='Packets Per Second Uploaded vs Packets Per Second Advertised',
+                   labels={'pkts_per_sec': 'Advertised PPS', 'received_pps': 'Uploaded PPS'},
+                   markers=True, text='received_pps')
     
-    # Set y-axis to 1-100 scale
-    fig1.update_yaxes(range=[1, 100])
+    # Set y-axis to [0 - highest_pps] scale
+    fig1.update_yaxes(range=[0, results[-2]])
     
     # Position text labels next to the markers
     fig1.update_traces(textposition="top right")
@@ -1435,16 +1434,16 @@ def stress_analysis(test, pps, sent_pkts, received_pkts):
     print(f'Number of packets sent: {pkts_sent_count}')
     print(f'Number of packets received: {pkts_received_count}')
     percentage_received = round(pkts_received_count * 100 / pkts_sent_count)
+    received_pps = pps * percentage_received / 100
     
     # PASS/FAIL logic
-    stage_pass = pkts_received_count / pkts_sent_count * 100
-    if stage_pass < 1: # If less than 1% of the packets were received, fail the test
+    if percentage_received < 1: # If less than 1% of the packets were received, fail the test
         test.rc = TEST_FAILED
         test.reason = "Insufficient amount of packets were scanned & uploaded by the gateway"
     else:
-        test.reason = f'{percentage_received}% of packets received, average pps: {pps * percentage_received / 100}'
+        test.reason = f'received pps: {received_pps} ({percentage_received}% of packets)'
 
-    return test, percentage_received
+    return test, received_pps
 
 
 def generate_adv_payload(test_indicator, unique_pkt=False):

certificate/cert_config.py

@@ -313,14 +313,14 @@ def brg_configure_ble5(test, cfg_pkt=None, module=None, fields=None, values=None
     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 ((datetime.datetime.now() - start_time).seconds > BLE5_MAX_DURATION_SEC):
             if num_of_tries < 3:
                 num_of_tries += 1
                 start_time = datetime.datetime.now()
                 gw_downlink(test=test, raw_tx_data=cfg_pkt.dump(), max_duration=BLE5_MAX_DURATION_MS, max_retries=BLE5_MAX_RETRIES, target=target)
-                print(f"Brg configure - BLE5 mode : No pkts found after {(ag.BLE5_PARAM_PRIMARY_CHANNEL_SCAN_CYCLE/1000)+1} seconds, in try number {num_of_tries}")
+                print(f"Brg configure - BLE5 mode : No pkts found after {BLE5_MAX_DURATION_SEC} seconds, in try number {num_of_tries}")
             else:
-                test.add_reason(f"Brg configure - BLE5 mode : No pkts found after {BLE5_MAX_DURATION_MS} seconds, in 3 tries")
+                test.add_reason(f"Brg configure - BLE5 mode : No pkts found after {BLE5_MAX_DURATION_SEC} seconds, in 3 tries")
                 test.rc = TEST_FAILED
                 time.sleep(1)
                 mqttc.flush_pkts()

certificate/cert_defines.py

@@ -14,6 +14,7 @@ except importlib.metadata.PackageNotFoundError:
     CERT_VERSION = LOCAL_DEV
 CERT_MQTT_LOG_FILE =            "cert_mqtt_log.json"
 DATA_SIM_LOG_FILE =             "data_sim_log.txt"
+RESULT_NOTES_FILE =             "results_notes.txt"
 UT_RESULT_FILE_HTML =           "results.html"
 UT_RESULT_FILE_PDF =            "results.pdf"
 UTILS_BASE_REL_PATH =           "../../../utils"

certificate/cert_gw_sim.py

@@ -255,6 +255,9 @@ def interference_analysis(ble_serial):
         for key in CNTRS_KEYS:
             diff_dict[key] = handle_wrap_around(end_cntrs[key] - start_cntrs[key])
         bad_crc_percentage = round((diff_dict[BAD_CRC] / (diff_dict[WLT_RX] + diff_dict[NON_WLT_RX])) * 100)
+        notes_file_path = os.path.join(ARTIFACTS_DIR, RESULT_NOTES_FILE)
+        with open(notes_file_path, "a") as f:
+            f.write(f'Channel {channel[0]} ({channel[1]} MHz) Ambient Interference (bad CRC percentage): {bad_crc_percentage}%\n')
         print(color('WARNING', f'Channel {channel[0]} ({channel[1]} MHz) Ambient Interference (bad CRC percentage) is: {bad_crc_percentage}%'))
         print(f'Good CRC packets = {diff_dict[NON_WLT_RX] + diff_dict[WLT_RX] - diff_dict[BAD_CRC]}, bad CRC packets: {diff_dict[BAD_CRC]}')
 

certificate/cert_results.py

@@ -36,6 +36,7 @@ BLE_MAC_ADDRESS =                  "BLE MAC Address"
 BOARD_TYPE =                       "Board Type"
 BLE_VER =                          "BLE Version"
 SUP_API_VER =                      "Supported API Version"
+ADD_INFO =                         "Additional information"
 # TODO: This is a temporary list of all schema module names - remove this when auto generated
 MODULE_SCHEMA_NAMES_LIST = ["Cloud Connectivity", "Edge Management", "Calibration", "Datapath", "Energizer 2.4GHz",
                             "Energizer Sub-1GHz", "Power Management", "BLE Sensor", "Custom"]
@@ -256,6 +257,13 @@ def generate_results_files(dut=None, tester=None, html=True, pdf=True, failures=
             hdr_page.append(Paragraph(f"{SIM} {BOARD_TYPE}: {ag.BOARD_TYPES_LIST[internal_brg.board_type]}", bold_text_style))
             hdr_page.append(Paragraph(f"{SIM} {BLE_VER}: {internal_brg.version}", bold_text_style))
             hdr_page.append(Paragraph(f"{SIM} {SUP_API_VER}: {internal_brg.api_version}", bold_text_style))
+        notes_file_path = os.path.join(ARTIFACTS_DIR, RESULT_NOTES_FILE)
+        if os.path.exists(notes_file_path):
+            hdr_page.append(Paragraph(f"<u>{ADD_INFO}:</u>", bold_text_style))
+            with open(notes_file_path, 'r') as f:
+                for line in f.readlines():
+                    hdr_page.append(Paragraph(f"{line}", bold_text_style))
+
         hdr_page.append(Spacer(1, 20))
 
         # Analyze results per module and generate results per module for PDF

certificate/cert_utils.py

@@ -220,6 +220,9 @@ class WltTest:
                 return phase
         return None
 
+    def add_phase(self, phase):
+        self.phases[-1:-1] = [phase]
+
     def update_overall_rc(self):
         if any([phase.rc == TEST_FAILED for phase in self.phases]):
             self.rc = TEST_FAILED

certificate/certificate_eth_test_list.txt

@@ -22,6 +22,7 @@ energy2400/output_power_test OUTPUT_POWER_2_4_MAX_MINUS_26 OUTPUT_POWER_2_4_MAX_
 energy2400/duty_cycle_test 1 25 50 75
 energy2400/signal_indicator_test rssi_threshold rx tx_eu_pattern disable_rx disable_tx rx_tx
 energy2400/signal_indicator_ble5_test rssi_threshold rx tx disable_rx disable_tx rx_tx
+energy2400/signal_indicator_ext_adv_test ext_adv_rx37 ext_adv_rx10
 
 # ------------- 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
@@ -67,8 +68,9 @@ cloud_connectivity/uplink_test mgmt_pkt pixels_pkt sensor_pkt
 cloud_connectivity/downlink_test
 cloud_connectivity/uplink_ext_adv_test
 cloud_connectivity/reboot_test
-cloud_connectivity/stress_test 20 40 60 80 100 120 140 160 180 200 222 250 285 333
-cloud_connectivity/ext_adv_stress_test 20 40 60 80 100 120 140 160 180 200
+cloud_connectivity/stress_test
+cloud_connectivity/ext_adv_stress_test
 cloud_connectivity/channel_scan_behaviour_test
 cloud_connectivity/acl_test deny allow
-cloud_connectivity/acl_ext_adv_test deny allow
+cloud_connectivity/acl_ext_adv_test deny allow
+cloud_connectivity/deduplication_test

certificate/certificate_sanity_test_list.txt

@@ -22,6 +22,7 @@ energy2400/output_power_test OUTPUT_POWER_2_4_MAX_MINUS_14 OUTPUT_POWER_2_4_MAX_
 energy2400/duty_cycle_test 1 50 75
 energy2400/signal_indicator_test rx_tx
 energy2400/signal_indicator_ble5_test rx_tx
+energy2400/signal_indicator_ext_adv_test ext_adv_rx37
 
 # ------------- energy_sub1g -------------
 energy_sub1g/pattern_test SUB1G_ENERGY_PATTERN_NO_ENERGIZING SUB1G_ENERGY_PATTERN_FCC_HOPPING SUB1G_ENERGY_PATTERN_SINGLE_TONE_917500 SUB1G_ENERGY_PATTERN_NZ_HOPPING
@@ -59,7 +60,7 @@ cloud_connectivity/uplink_test mgmt_pkt pixels_pkt
 cloud_connectivity/downlink_test
 cloud_connectivity/uplink_ext_adv_test
 cloud_connectivity/reboot_test
-cloud_connectivity/stress_test 100 222
-cloud_connectivity/ext_adv_stress_test 20 100
+cloud_connectivity/stress_test
+cloud_connectivity/ext_adv_stress_test
 cloud_connectivity/acl_test deny
 cloud_connectivity/acl_ext_adv_test allow

certificate/certificate_test_list.txt

@@ -22,7 +22,7 @@ energy2400/output_power_test OUTPUT_POWER_2_4_MAX_MINUS_26 OUTPUT_POWER_2_4_MAX_
 energy2400/duty_cycle_test 1 25 50 75
 energy2400/signal_indicator_test rssi_threshold rx tx_eu_pattern disable_rx disable_tx rx_tx
 energy2400/signal_indicator_ble5_test rssi_threshold rx tx disable_rx disable_tx rx_tx
-#energy2400/signal_indicator_ext_adv_test rssi_threshold brg0_tx_brg1_rx brg0_rxtx_brg1_rxtx
+energy2400/signal_indicator_ext_adv_test ext_adv_rx37 ext_adv_rx10
 
 # ------------- 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
@@ -67,9 +67,10 @@ cloud_connectivity/uplink_test mgmt_pkt pixels_pkt sensor_pkt geolocation
 cloud_connectivity/downlink_test
 cloud_connectivity/uplink_ext_adv_test
 cloud_connectivity/reboot_test
-cloud_connectivity/stress_test 20 40 60 80 100 120 140 160 180 200 222 250 285 333
-cloud_connectivity/ext_adv_stress_test 20 40 60 80 100 120 140 160 180 200
+cloud_connectivity/stress_test
+cloud_connectivity/ext_adv_stress_test
 cloud_connectivity/channel_scan_behaviour_test
 cloud_connectivity/acl_test deny allow
 cloud_connectivity/acl_ext_adv_test deny allow
 cloud_connectivity/brg_ota_test
+cloud_connectivity/deduplication_test

certificate/tests/cloud_connectivity/acl_ext_adv_test/acl_ext_adv_test.json

@@ -2,7 +2,7 @@
     "name": "Access Control List using Extended Advertising",
     "module": "Cloud Connectivity",
     "purpose": "Test the access control list (ACL) functionality, configure allow list and deny list and test the behavior, while the Bridge is transmitting in extended advertising",
-    "documentation": "<TEST_DOCUMENTATION_LINK>",
+    "documentation": "https://community.wiliot.com/customers/s/article/Wiliot-Network---Gateway-Extended-Advertising-Implementation",
     "initialCondition": "Gateway configured to defaults",
     "procedure": ["Test prolog", "configure the brg to be on the deny list", "configure the brg to be on the allow list", "Test epilog"],
     "expectedOutcome": "For the deny list - no unified packets are found, for the allow list - unified packets are found",

certificate/tests/cloud_connectivity/acl_test/acl_test.json

@@ -2,7 +2,7 @@
     "name": "Access Control List",
     "module": "Cloud Connectivity",
     "purpose": "Test the access control list (ACL) functionality, configure allow list and deny list and test the behavior",
-    "documentation": "<TEST_DOCUMENTATION_LINK>",
+    "documentation": "https://community.wiliot.com/customers/s/article/Access-Control-List",
     "initialCondition": "Gateway configured to defaults",
     "procedure": ["Test prolog", "configure the brg to be on the deny list", "configure the brg to be on the allow list", "Test epilog"],
     "expectedOutcome": "For the deny list - no unified packets are found, for the allow list - unified packets are found",

certificate/tests/cloud_connectivity/channel_scan_behaviour_test/channel_scan_behaviour_test.json

@@ -2,7 +2,7 @@
     "name": "Gateway Channel behavior",
     "module": "Cloud Connectivity",
     "purpose": "Test gateway's channel scanning time cycles on all main channels",
-    "documentation": "<TEST_DOCUMENTATION_LINK>",
+    "documentation": "",
     "initialCondition": "Gateway configured with default settings",
     "procedure": ["Test prolog",
                   "Send packets as close as possible to continuously on all 3 channels, with a unique channel identifier",

certificate/tests/cloud_connectivity/deduplication_test/deduplication_test.json

@@ -0,0 +1,14 @@
+{
+    "name": "Gateway Deduplication",
+    "module": "Cloud Connectivity",
+    "purpose": "Test gateway's packet deduplication capability when receiving identical BLE packets",
+    "documentation": "",
+    "initialCondition": "Gateway configured to defaults",
+    "procedure": ["Test prolog", "Send mixed packet types (pixels, mgmt, sensor, side_info_sensor) via data simulator", "Collect received packets from MQTT", "Analyze duplicate packets and calculate duplicate percentage", "Test epilog"],
+    "expectedOutcome": "Duplicate percentage should be <= 5% of total received packets",
+    "mandatory": 0,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 1,
+    "dataSimOnlyTest": 1,
+    "allSupportedValues": []
+}

certificate/tests/cloud_connectivity/deduplication_test/deduplication_test.py

@@ -0,0 +1,85 @@
+# This test meant to show the GW performance when is put in a pkt stress generated from the BLE via the UART
+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)
+NUM_OF_BRGS = 3
+
+
+# HELPER FUNCTIONS
+def duplication_analysis(test, pkts, received_pkts):
+    if len(received_pkts) == 0:
+        test.rc = TEST_FAILED
+        test.reason = "No packets were received!"
+        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)
+
+    sent_df = pd.DataFrame(_sent_pkts, columns=[PACKETS])
+    received_df = pd.DataFrame(received_pkts, columns=[PACKETS])
+
+    merged_df = pd.merge(sent_df, received_df, on=PACKETS, how='inner')
+    # Count total received packets (including duplicates) and unique packets
+    pkts_received_total = len(merged_df)
+    merged_df_unique = merged_df.drop_duplicates(subset=[PACKETS])
+    pkts_duplicates = pkts_received_total - len(merged_df_unique)
+
+    # Prints
+    print(f'Number of packets sent: {len(sent_df)}')
+    print(f'Number of packets received in total: {pkts_received_total}, out of them {pkts_duplicates} are duplicates')
+
+    duplicate_percentage = (pkts_duplicates / pkts_received_total) * 100
+    print(f'{duplicate_percentage:.2f}% of the received packets are duplicates')
+
+    if duplicate_percentage > 5.0:
+        test.rc = TEST_FAILED
+        test.reason = f"{duplicate_percentage:.2f}% of the received packets are duplicates"
+        return test
+
+    return test
+
+
+def run(test):
+    test = cert_common.test_prolog(test)
+    if test.rc == TEST_FAILED:
+        return cert_common.test_epilog(test)
+
+    dut_mqttc = test.get_mqttc_by_target(DUT)
+    dut_mqttc.flush_pkts()
+    pkts = []
+
+    # generate pkts and send them using data simulator
+    data_pkts, _ = cert_data_sim.brg_pkt_gen(num_of_pkts_per_brg=10, num_of_brgs=NUM_OF_BRGS,
+                                             pkt_type=PIXELS_PKT, indicator=UPLINK_TEST_INDICATOR)
+
+    mgmt_pkts, _ = cert_data_sim.brg_pkt_gen(num_of_pkts_per_brg=10, num_of_brgs=NUM_OF_BRGS,
+                                             pkt_type=MGMT_PKT, indicator=UPLINK_TEST_INDICATOR)
+    sensor_pkts, _ = cert_data_sim.brg_pkt_gen(num_of_pkts_per_brg=10, num_of_brgs=NUM_OF_BRGS,
+                                               pkt_type=SENSOR_PKT, indicator=UPLINK_TEST_INDICATOR)
+    si_pkts, _ = cert_data_sim.brg_pkt_gen(num_of_pkts_per_brg=10, num_of_brgs=NUM_OF_BRGS,
+                                           pkt_type=SIDE_INFO_SENSOR_PKT, indicator=UPLINK_TEST_INDICATOR)
+    pkts = data_pkts + mgmt_pkts + sensor_pkts + si_pkts
+
+    pixel_sim_thread = cert_data_sim.GenericSimThread(test=test, pkts=pkts, send_single_cycle=True)
+    pixel_sim_thread.start()
+
+    mqtt_scan_wait(test, 10 + test.dut.upload_wait_time)
+    cert_mqtt.dump_pkts(test, log="deduplication_test")
+    recieved_pkts = cert_mqtt.get_all_data_pkts(dut_mqttc, indicator=UPLINK_TEST_INDICATOR)
+    pixel_sim_thread.stop()
+
+    test = duplication_analysis(test, pkts, [p[ALIAS_BRIDGE_ID] + p[PAYLOAD] for p in recieved_pkts])
+
+    return cert_common.test_epilog(test)

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.json

@@ -12,5 +12,5 @@
     "multiBridgeTest": 0,
     "gwOnlyTest": 1,
     "dataSimOnlyTest": 1,
-    "allSupportedValues": [20, 40, 60, 80, 100, 120, 140, 160, 180, 200]
+    "allSupportedValues": []
 }

certificate/tests/cloud_connectivity/ext_adv_stress_test/ext_adv_stress_test.py

@@ -51,13 +51,13 @@ def run(test):
 
     cert_config.gw_action(test, f'{cert_gw_sim.BLE_SIM_INIT} 1', TESTER)
 
+    ppses = [20, 40, 60, 80, 100, 120, 140, 160, 180, 200]
     test_pkts_received = []
     data_pkts_received = []
     results = []
-    for param in test.params:
-        phase_run_print(f"PPS = {param}")
+    for pps in ppses:
+        phase_run_print(f"PPS = {pps}")
         test.flush_all_mqtt_packets()
-        pps = param.value
         # adv_duration is increased only for lowest pps to increase packets sample for reliable results
         adv_duration = ADV_DURATION_LOWEST_PPS if pps == LOWEST_PPS else ADV_DURATION_DEFAULT
         delay = math.floor(1000 / pps)  # This should be bigger than 2ms
@@ -74,17 +74,18 @@ def run(test):
         cert_config.gw_action(test, gw_action_cmd, TESTER)
         mqtt_scan_wait(test, adv_duration + upload_wait_time)
 
-        cert_mqtt.dump_pkts(test, log=param.name)
+        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)
 
-        test, percentage_received = cert_common.stress_analysis(
+        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, percentage_received])
-        cert_mqtt.generate_log_file(test, param.name)
+        results.extend([pps, received_pps])
+        cert_mqtt.generate_log_file(test, str(pps))
 
-        test.set_phase_rc(param.name, test.rc)
-        test.add_phase_reason(param.name, test.reason)
+        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

certificate/tests/cloud_connectivity/stress_test/stress_test.json

@@ -12,5 +12,5 @@
     "multiBridgeTest": 0,
     "gwOnlyTest": 1,
     "dataSimOnlyTest": 1,
-    "allSupportedValues": [20, 40, 60, 80, 100, 120, 140, 160, 180, 200, 222, 250, 285, 333]
+    "allSupportedValues": []
 }

certificate/tests/cloud_connectivity/stress_test/stress_test.py

@@ -50,14 +50,13 @@ def run(test):
         return cert_common.test_epilog(test)
 
     cert_config.gw_action(test, f'{cert_gw_sim.BLE_SIM_INIT} 1', TESTER)
-
+    ppses = [20, 40, 60, 80, 100, 120, 140, 160, 180, 200, 222, 250, 285, 333]
     test_pkts_received = []
     data_pkts_received = []
     results = []
-    for param in test.params:
-        phase_run_print(f"PPS = {param}")
+    for pps in ppses:
+        phase_run_print(f"PPS = {pps}")
         test.flush_all_mqtt_packets()
-        pps = param.value
         # adv_duration is increased only for lowest pps to increase packets sample for reliable results
         adv_duration = ADV_DURATION_LOWEST_PPS if pps == LOWEST_PPS else ADV_DURATION_DEFAULT
         delay = math.floor(1000 / pps)
@@ -73,17 +72,18 @@ def run(test):
                               f'{BLE_SIM_ADV_37_38_39} {delay} {BLE_SIM_RADIO_1MBPS} {adv_duration * pps}', TESTER)
         mqtt_scan_wait(test, adv_duration + upload_wait_time)
 
-        cert_mqtt.dump_pkts(test, log=param.name)
+        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, percentage_received = cert_common.stress_analysis(
+        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, percentage_received])
-        cert_mqtt.generate_log_file(test, param.name)
+        results.extend([pps, received_pps])
+        cert_mqtt.generate_log_file(test, str(pps))
 
-        test.set_phase_rc(param.name, test.rc)
-        test.add_phase_reason(param.name, test.reason)
+        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

certificate/tests/cloud_connectivity/uplink_test/uplink_test.py

@@ -130,6 +130,7 @@ def run(test):
 
         mqtt_scan_wait(test, 10 + test.dut.upload_wait_time)
         cert_mqtt.dump_pkts(test, log=param.name)
+        pixel_sim_thread.stop()
         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)

certificate/tests/datapath/event_ble5_test/event_ble5_test.py

@@ -63,10 +63,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 +80,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 +94,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.py

@@ -54,10 +54,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 +71,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 +83,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/num_of_tags_test/num_of_tags_test.json

@@ -2,7 +2,7 @@
     "name": "Supported Pixels",
     "module": "Datapath",
     "purpose": "Test pixels handling in the bridge for different amount of pixels",
-    "documentation": "<TEST_DOCUMENTATION_LINK>",
+    "documentation": "",
     "initialCondition": "Bridge & data simulator configured to defaults",
     "procedure": ["Test prolog",
                   "Generate packets from the given amount of pixels & scan for packets in the bridge",

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())