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

certificate/cert_common.py

@@ -479,8 +479,8 @@ def pacing_analysis(test, pacer_interval, df, pkt_filter_cfg=ag.PKT_FILTER_RANDO
                 # In non-sterile runs - rssi is less stable and can trigger more events
                 max_count_threshold = float('inf')
             else:
-                # In rssi movement events the alpha filter takes about 10 packets to stabilize 
-                max_count_threshold = 1 + (10 / expected_event_pkt_count)
+                # In rssi movement events the alpha filter takes about 13 packets to stabilize 
+                max_count_threshold = 1 + (RSSI_EVENT_PKTS_TO_STABILIZE / expected_event_pkt_count)
         else:
             max_count_threshold = PACER_INTERVAL_CEIL_THRESHOLD
 
@@ -490,12 +490,14 @@ def pacing_analysis(test, pacer_interval, df, pkt_filter_cfg=ag.PKT_FILTER_RANDO
 
             if not (PACER_INTERVAL_THRESHOLD <= len(event_pkts) / expected_event_pkt_count <= max_count_threshold):
                 test.rc = TEST_FAILED
-                test.add_reason(f"Packet count for dynamic tag {tag} is wrong!")
-                print(f"expected_event_pkt_count = {expected_event_pkt_count}, received pkt count = {len(event_pkts)}")
+                msg = f"Packet count for dynamic tag {tag} is wrong! expected_event_pkt_count = {expected_event_pkt_count}, received pkt count = {len(event_pkts)}"
+                test.add_reason(msg)
+                utPrint(msg, "RED")
             if not (PACER_INTERVAL_THRESHOLD <= avg_event_pacer / event_pacing <= PACER_INTERVAL_CEIL_THRESHOLD):
                 test.rc = TEST_FAILED
-                print(f"Tag {tag} with diff_time {list(event_pkts.timestamp.diff().div(1000))}, avg_event_pacer={avg_event_pacer} exceeds threshold!")
-                test.add_reason(f"Tag {tag} has a wrong avg time diff")
+                msg = f"Tag {tag} has a wrong avg time diff. diff_time {list(event_pkts.timestamp.diff().div(1000))}, avg_event_pacer={avg_event_pacer} exceeds threshold!"
+                test.add_reason(msg)
+                utPrint(msg, "RED")
 
     # Verify the tags pacer interval (without event)
     failed_tags = 0
@@ -510,8 +512,9 @@ def pacing_analysis(test, pacer_interval, df, pkt_filter_cfg=ag.PKT_FILTER_RANDO
         if ((avg_pacer / pacer_interval) < PACER_INTERVAL_THRESHOLD_HIGH and (pacer_interval - avg_pacer) > 1):
             failed_tags += 1
             test.rc = TEST_FAILED
-            print(f"Tag {tag} with diff_time {list(pkts.timestamp.diff().div(1000))}, avg_pacer={avg_pacer} exceeds {PACER_INTERVAL_THRESHOLD_HIGH} minimum threshold!")
-            test.add_reason(f"{failed_tags}/{tags_count} tags with wrong time diff")
+            msg = f"Tag {tag} with diff_time {list(pkts.timestamp.diff().div(1000))}, avg_pacer={avg_pacer} exceeds {PACER_INTERVAL_THRESHOLD_HIGH} minimum threshold!"
+            utPrint(msg, "RED")
+            test.add_reason(msg)
             # Pass the test with real tags when less than 5% tag failed
             if test.data != DATA_SIMULATION and failed_tags / tags_count < 0.05:
                 test.rc = TEST_PASSED
@@ -520,7 +523,9 @@ def pacing_analysis(test, pacer_interval, df, pkt_filter_cfg=ag.PKT_FILTER_RANDO
             if max_received_pkts == len(pkts):
                 # we fail the tag only if it received all expected pkts and pacer caluculation is valid
                 failed_tags += 1
-                print(f"Tag {tag} with diff_time {list(pkts.timestamp.diff().div(1000))}, avg_pacer={avg_pacer} exceeds {PACER_INTERVAL_CEIL_THRESHOLD} maximum threshold!")
+                msg = f"Tag {tag} with diff_time {list(pkts.timestamp.diff().div(1000))}, avg_pacer={avg_pacer} exceeds {PACER_INTERVAL_CEIL_THRESHOLD} maximum threshold!"
+                utPrint(msg, "RED")
+                test.add_reason(msg)
             else:
                 print(f"Tag {tag} received only {len(pkts)} pkts out of {max_received_pkts}, avg_pacer failed but skipping pacer ceil validation")
             if failed_tags / tags_count > 0.2:  # Fail the test on ceil threshold only when more than 20% tag failed
@@ -600,6 +605,7 @@ def run_event_test_phase(test, phase, datapath_module, values, scan_time, event_
     scan_time_multiplier = 1
     delay = DATA_SIM_EVENT_TESTING_DELAY_MS
     if "rssi" in phase:
+        test.sterile_run = is_quiet_setup_running()
         delay = DATA_SIM_RSSI_EVENT_TESTING_DELAY_MS
         scan_time_multiplier = (1 / 3)
         fields += [BRG_RSSI_MOVEMENT_THRESHOLD]
@@ -1057,6 +1063,15 @@ def get_module_if_pkt(test):
         print(pkts[-1][MGMT_PKT].pkt)
         return test, pkts[-1][MGMT_PKT].pkt
 
+def get_gw_api_version(mqttc):
+    messages = cert_mqtt.get_all_status_pkts(mqttc)
+    for msg in messages:
+        if GW_CONF in msg: # JSON
+            return msg[GW_CONF][GW_API_VERSION]
+        if GW_STATUS in msg: # protobuf
+            return msg[GW_STATUS][GW_API_VERSION]
+    return None
+
 def get_cfg_hash(test):
     utPrint(f"Fetching BRG cfg hash for BRG {test.active_brg.id_str}", "BLUE")
     test, module_if_pkt = get_module_if_pkt(test)
@@ -1374,7 +1389,7 @@ def timestamps_validation(wiliot_pkts_validation_phase, all_messages_in_test, up
                         return wiliot_pkts_validation_phase
                     previous_ts = inner_pkt[TIMESTAMP]
                 else:
-                    if inner_pkt[TIMESTAMP] <= previous_ts:
+                    if inner_pkt[TIMESTAMP] < previous_ts:
                         wiliot_pkts_validation_phase.rc = TEST_FAILED
                         wiliot_pkts_validation_phase.reason = f'Timestamp is not incremental for inner packet {inner_pkt[PAYLOAD]}'
                         return wiliot_pkts_validation_phase
@@ -1433,11 +1448,8 @@ def generate_graph_stress_test(test, results, test_pkts_received):
 
 
 def stress_analysis(test, pps, sent_pkts, received_pkts):
-    _sent_pkts = []
-    for pkt in sent_pkts:
-        adva_endianness_change = change_endianness(pkt[:12]) + pkt[12:]  # Switch to big endian adva
-        _sent_pkts.append(adva_endianness_change)
-    
+
+    _sent_pkts = [p[12:] for p in sent_pkts]
     sent_df = pd.DataFrame(_sent_pkts, columns=[PACKETS])
     received_df = pd.DataFrame(received_pkts, columns=[PACKETS])
 
@@ -1446,16 +1458,15 @@ def stress_analysis(test, pps, sent_pkts, received_pkts):
     pkts_sent_count = len(sent_df)
     pkts_received_count = len(merged_df)
 
-    # Prints
-    print(f'Number of packets sent: {pkts_sent_count}')
-    print(f'Number of packets received: {pkts_received_count}')
+    # Prints and calculations
     percentage_received = round(pkts_received_count * 100 / pkts_sent_count)
+    utPrint(f'Sent: {pkts_sent_count}, Received: {pkts_received_count} ({percentage_received}%)', "BLUE")
     received_pps = pps * percentage_received / 100
     
     # PASS/FAIL logic
     if percentage_received < 1: # If less than 1% of the packets were received, fail the test
         test.set_phase_rc(str(pps), TEST_FAILED)
-        test.add_phase_reason(str(pps), "Insufficient amount of packets were scanned & uploaded by the gateway")
+        test.add_phase_reason(str(pps), f"{percentage_received}% of the packets were scanned & uploaded by the gateway")
     else:
         test.set_phase_rc(str(pps), TEST_PASSED)
         test.add_phase_reason(str(pps), f"received pps: {received_pps} ({percentage_received}% of packets)")

certificate/cert_config.py

@@ -40,7 +40,7 @@ def gw_configure(test, cfg={}, version="", extended_cfg={}, ret_pkt=False, wait=
         while (datetime.datetime.now() - start_time).seconds < DEFAULT_GW_FIELD_UPDATE_TIMEOUT:
             for p in cert_mqtt.get_all_status_pkts(mqttc):
                 if GW_CONF in p or GW_STATUS in p:
-                    test.gw_api_version = p[GW_CONF][GW_API_VERSION] if GW_CONF in p else p[GW_STATUS][GW_API_VERSION]
+                    test.gw_api_version = (p.get(GW_CONF, {}).get(GW_API_VERSION) or p.get(GW_STATUS, {}).get(GW_API_VERSION))
                     if target == DUT and is_gw(test.dut):
                         test.dut.gw_api_version = test.gw_api_version
                     print_pkt(p)
@@ -79,15 +79,18 @@ def gw_fw_upgrade(test, version, board_type, target=DUT):
 def create_gw_config(test, cfg, target=DUT, version=""):
     gw = test.dut if is_gw(test.dut) and target == DUT else test.tester
     if version:
-        return dict({GW_CONF:{LAT: GW_LATITUDE_DEFAULT, LNG: GW_LONGITUDE_DEFAULT, WIFI_VERSION: version[WIFI_VERSION],
-                     BLE_VERSION: version[BLE_VERSION], GW_API_VERSION: gw.gw_api_version, ADDITIONAL:dict(cfg)}})
+        conf = {LAT: GW_LATITUDE_DEFAULT, LNG: GW_LONGITUDE_DEFAULT, WIFI_VERSION: version[WIFI_VERSION],
+                BLE_VERSION: version[BLE_VERSION], ADDITIONAL: dict(cfg)}
     elif gw.gw_orig_versions:
-        return dict({GW_CONF:{LAT: GW_LATITUDE_DEFAULT, LNG: GW_LONGITUDE_DEFAULT, WIFI_VERSION: gw.gw_orig_versions[WIFI_VERSION],
-                     BLE_VERSION: gw.gw_orig_versions[BLE_VERSION], GW_API_VERSION:  gw.gw_api_version, ADDITIONAL:dict(cfg)}})
+        conf = {LAT: GW_LATITUDE_DEFAULT, LNG: GW_LONGITUDE_DEFAULT, WIFI_VERSION: gw.gw_orig_versions[WIFI_VERSION],
+                BLE_VERSION: gw.gw_orig_versions[BLE_VERSION], ADDITIONAL: dict(cfg)}
     # Protection for FDM gw config
     else:
-        return dict({GW_CONF:{LAT: GW_LATITUDE_DEFAULT, LNG: GW_LONGITUDE_DEFAULT, GW_API_VERSION: gw.gw_api_version,
-                     ADDITIONAL:dict(cfg)}})
+        conf = {LAT: GW_LATITUDE_DEFAULT, LNG: GW_LONGITUDE_DEFAULT, ADDITIONAL: dict(cfg)}
+    # If api version was not sent in gw info then the gw_api_version is None, we don't want to set it in the config
+    if gw.gw_api_version is not None:
+        conf[GW_API_VERSION] = gw.gw_api_version
+    return dict({GW_CONF: conf})
 
 def gw_downlink(test, raw_tx_data="", is_ota=False, version="", max_duration=100, max_retries=8, target=DUT):
     mqttc = test.get_mqttc_by_target(target)

certificate/cert_defines.py

@@ -307,6 +307,7 @@ BLE5_MAX_DURATION_SEC =                             BLE5_MAX_DURATION_MS // 1000
 DATA_SIM_EVENT_TESTING_DELAY_SEC =                  DATA_SIM_EVENT_TESTING_DELAY_MS / 1000
 DATA_SIM_RSSI_EVENT_TESTING_DELAY_SEC =             DATA_SIM_RSSI_EVENT_TESTING_DELAY_MS / 1000
 DATA_SIM_EVENT_PACER_INTERVAL_TESTING =             10
+RSSI_EVENT_PKTS_TO_STABILIZE =                      13 # The alpha filter takes about 13 packets to stabilize
 PACKETS_ECHO_OFF =                                  16
 TEST_PASSED =                                       0
 TEST_FAILED =                                       -1

certificate/cert_gw_sim.py

@@ -198,7 +198,7 @@ def gw_app_reponse(ble_serial):
     start_time = datetime.datetime.now()
     while (datetime.datetime.now() - start_time).seconds < 2:
         input = read_from_ble(ble_serial)
-        if GW_APP_VERSION_HEADER in input:
+        if input is not None and GW_APP_VERSION_HEADER in input:
             print(input)
             ble_chip_sw_ver = re.search(r'WILIOT_GW_BLE_CHIP_SW_VER=(\d+\.\d+\.\d+)', input).group(1)
             ble_mac_address = re.search(r'WILIOT_GW_BLE_CHIP_MAC_ADDRESS=([0-9A-F]{12})', input).group(1)
@@ -333,6 +333,22 @@ def handle_cmds(input, ble_serial):
         utPrint(f"COM tester recovered", "CYAN")
         write_to_ble(ble_serial, f"{CONNECTIVITY_STATUS} 1 1")
 
+def validate_port(port):
+    try:
+        with serial.serial_for_url(url=port, baudrate=921600, timeout=SERIAL_TIMEOUT) as ser:
+            ser.flushInput()
+            write_to_ble(ser, txt=VERSION, print_enable=True)
+            start_time = datetime.datetime.now()
+            while (datetime.datetime.now() - start_time).seconds < 2:
+                input = read_from_ble(ser)
+                if input is not None and GW_APP_VERSION_HEADER in input:
+                    return True
+            return False
+    except Exception as e:
+        utPrint(f"Failed to open serial: {e}", "RED")
+        return False
+
+
 def gw_sim_run(port, gw_id, custom_broker, disable_interference_analyzer=False):
 
     # Init serial side
@@ -340,8 +356,11 @@ def gw_sim_run(port, gw_id, custom_broker, disable_interference_analyzer=False):
         print("\nNo COM port given. Scanning for available ports:")
         for port, desc, hwid in sorted(serial.tools.list_ports.comports()):
             print("{}: {} [{}]".format(port, desc, hwid))
+            if validate_port(port):
+                utPrint(f"Found the tester's port ({port})", "GREEN")
+                break
     if not port:
-        print("\nNo available COM port found!")
+        print("\nNo available COM port found! Please verify a tester is connected and set the correct --port parameter.")
         sys.exit(-1)
     print(f"###>>> GW SIM STARTED WITH PORT {port}")
     ble_serial = serial.serial_for_url(url=port, baudrate=921600, timeout=SERIAL_TIMEOUT)
@@ -370,8 +389,8 @@ def gw_sim_run(port, gw_id, custom_broker, disable_interference_analyzer=False):
     write_to_ble(ble_serial, RESET_GW, sleep=5)
     gw_app_res = gw_app_reponse(ble_serial)
     if gw_app_res[0] == TEST_FAILED:
-        print("ERROR: didn't get version response!")
-        return
+        utPrint("ERROR: didn't get version response! Please verify a tester is connected and set the correct --port parameter.", "RED")
+        sys.exit(1)
     os.environ[GW_SIM_BLE_MAC_ADDRESS] = gw_app_res[1]
     os.environ[GW_APP_VERSION_HEADER] = gw_app_res[2]
     write_to_ble(ble_serial, STOP_ADVERTISING, sleep=2)

certificate/cert_mqtt.py

@@ -299,6 +299,14 @@ def mqttc_init(gw_id, custom_broker, data=DATA_REAL_TAGS):
     mqttc.subscribe(mqttc.status_topic)
     print(f"Subscribed to status topic: {mqttc.status_topic}")
 
+    # v2 protobuf topics
+    mqttc.data_topic_pb = re.sub(r'^([^/]+)', r'\1-v2', custom_broker[CUSTOM_BROKER_DATA_TOPIC])
+    mqttc.subscribe(mqttc.data_topic_pb)
+    print(f"Subscribed to data topic: {mqttc.data_topic_pb}")
+    mqttc.status_topic_pb = re.sub(r'^([^/]+)', r'\1-v2', custom_broker[CUSTOM_BROKER_STATUS_TOPIC])
+    mqttc.subscribe(mqttc.status_topic_pb)
+    print(f"Subscribed to status topic: {mqttc.status_topic_pb}")
+
     mqttc.flush_pkts = mqttc._userdata[PKTS].flush
     mqttc.flush_data_pkts = mqttc._userdata[PKTS].flush_data
     mqttc.flush_status_pkts = mqttc._userdata[PKTS].flush_status

certificate/cert_prints.py

@@ -18,6 +18,7 @@ COLORS = {
 }
 color = lambda c, t : COLORS["BOLD"]+COLORS[c]+t+COLORS["ENDC"]
 pipeline_running = lambda : True if 'BITBUCKET_BUILD_NUMBER' in os.environ else False
+is_quiet_setup_running = lambda : True if 'CI_GW' in os.environ else False
 camelcase_to_title = lambda s: ' '.join(word.capitalize() for word in re.split('(?=[A-Z])', s))
 SEP = '\n' + '#'*100 + '\n'
 SEP2 = '\n' + '#'*100 + '\n' + '#'*100 + '\n'

certificate/certificate_cli.py

@@ -40,7 +40,7 @@ class CertificateCLI:
         self.parser.add_argument('--dut', required=True, help="Tested device ID. When DUT is a combo device, use <Gateway_ID>:<BLE_MAC>")
         self.parser.add_argument('--combo_ble_addr', default="", help="Combo device BLE MAC address" + argparse.SUPPRESS)
         self.parser.add_argument('--tester', default=GW_SIM_PREFIX, help='Tester id to run on the test, SIM prefix is default and used for COM tester')
-        self.parser.add_argument('--port', '-p', default='', help='UART PORT connection to use for the run, if not provided last available port is used')
+        self.parser.add_argument('--port', '-p', default='', help='UART PORT connection to use for the run, if not provided tries to scan for tester port')
         self.parser.add_argument('--custom_broker', '-cb', required=True, help='Choose custom MQTT broker configuration json file to use for the run,' \
                                                                               ' for explanation of the format see https://community.wiliot.com/customers/s/article/Wiliot-Gateway-Certification')
         self.parser.add_argument('--clean', default=False, action='store_true', help='Clean old logs before running the tests')

certificate/certificate_eth_test_list.txt

@@ -49,7 +49,7 @@ datapath/rx_rate_gen2_test mid_values diff_pacer min_value max_value diff_rate
 datapath/rx_rate_gen3_test mid_values diff_pacer min_value max_value diff_rate
 datapath/stress_test rep3 rep2 rep1
 datapath/stress_gen3_test rep3 rep2 rep1
-datapath/num_of_tags_test 5000
+datapath/num_of_tags_test 2500
 
 # ------------- pwr_mgmt -------------
 pwr_mgmt/pwr_mgmt_test

certificate/certificate_test_list.txt

@@ -49,7 +49,7 @@ datapath/rx_rate_gen2_test mid_values diff_pacer min_value max_value diff_rate
 datapath/rx_rate_gen3_test mid_values diff_pacer min_value max_value diff_rate
 datapath/stress_test rep3 rep2 rep1
 datapath/stress_gen3_test rep3 rep2 rep1
-datapath/num_of_tags_test 5000
+datapath/num_of_tags_test 4500
 
 # ------------- pwr_mgmt -------------
 pwr_mgmt/pwr_mgmt_test

certificate/tests/cloud_connectivity/channel_scan_behaviour_test/channel_scan_behaviour_test.py

@@ -188,7 +188,7 @@ def run(test):
     payload = cert_common.generate_adv_payload(SCAN_TEST_INDICATOR, unique_pkt=True)
 
     # Transmitting packets on all channels
-    utPrint(f"Transmitting in parallel on all 3 main cahnnels for {ADV_DURATION} seconds", "WARNING")
+    utPrint(f"Transmitting in parallel on all 3 main channels for {ADV_DURATION} seconds", "WARNING")
     num_of_sent_pkts = ADV_DURATION * PPS
     strat_trans_time_ms = time.time() * 1000
 

certificate/tests/cloud_connectivity/connection_test/connection_test.py

@@ -41,9 +41,11 @@ def run(test):
     timeout = datetime.datetime.now() + datetime.timedelta(minutes=TIMEOUT_IN_MINUTES)
     while datetime.datetime.now() < timeout:
         gw_type, msg = cert_common.get_gw_type(dut_mqttc)
+        gw_api_version = cert_common.get_gw_api_version(dut_mqttc)
         if gw_type is not None:
             break
         print_update_wait(5)
+    test.dut.gw_api_version = gw_api_version
 
     # generate logs
     cert_mqtt.generate_log_file(test, "connection")

certificate/tests/cloud_connectivity/deduplication_test/deduplication_test.py

@@ -14,19 +14,15 @@ NUM_OF_BRGS = 3
 
 
 # HELPER FUNCTIONS
-def duplication_analysis(test, pkts, received_pkts):
+def duplication_analysis(test, sent_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_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')
@@ -74,11 +70,11 @@ def run(test):
     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)
+    mqtt_scan_wait(test, 12 + 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])
+    test = duplication_analysis(test, pkts, recieved_pkts)
 
     return cert_common.test_epilog(test)

certificate/tests/cloud_connectivity/ext_adv_stress_test/ext_adv_stress_test.py

@@ -83,9 +83,8 @@ def run(test):
             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])
+        phase_pkts_received = [p[AGGREGATED_PAYLOAD] for p in phase_pkts_received]
+        test, received_pps = cert_common.stress_analysis(test, pps, generated_payloads, phase_pkts_received)
         results.extend([pps, received_pps])
         cert_mqtt.generate_log_file(test, str(pps))
 

certificate/tests/cloud_connectivity/reboot_test/reboot_test.py

@@ -33,9 +33,11 @@ def run(test):
     timeout = datetime.datetime.now() + datetime.timedelta(minutes=TIMEOUT_IN_MINUTES)
     while datetime.datetime.now() < timeout:
         gw_type, msg = cert_common.get_gw_type(dut_mqttc)
+        gw_api_version = cert_common.get_gw_api_version(dut_mqttc)
         if gw_type is not None:
             break
         print_update_wait(5)
+    test.dut.gw_api_version = gw_api_version
 
     # generate logs
     cert_mqtt.generate_log_file(test, "reboot")

certificate/tests/cloud_connectivity/stress_test/stress_test.py

@@ -81,9 +81,8 @@ def run(test):
             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])
+        phase_pkts_received = [p[PAYLOAD] for p in phase_pkts_received]
+        test, received_pps = cert_common.stress_analysis(test, pps, generated_payloads, phase_pkts_received)
         results.extend([pps, received_pps])
         cert_mqtt.generate_log_file(test, str(pps))
 

certificate/tests/cloud_connectivity/uplink_test/uplink_test.py

@@ -24,10 +24,11 @@ def uplink_analysis(test, sent_pkts, received_pkts, pkt_type):
         return test
 
     # 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:
+    received_brgs = set([p[ALIAS_BRIDGE_ID] for p in received_pkts])
+    if len(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!")
+        test.add_phase_reason(pkt_type, f"Received packets from {len(received_brgs)} bridges instead of {NUM_OF_BRGS} bridges!")
+        utPrint(f"Received packets from {received_brgs} bridges instead of {NUM_OF_BRGS} bridges!", "RED")
         return test
 
     _sent_pkts = [p.get_pkt()[12:] for p in sent_pkts]

certificate/tests/datapath/aging_test/aging_test.py

@@ -105,11 +105,15 @@ def aging_analysis(test, datapath_module, pacer_interval, num_of_sim_tags):
     if test.rc == TEST_FAILED:
         return test
     utPrint(f"\nEnd of aging time pixels count: {second_floor_tags_ctr}\n", "BLUE")
-    if ((test.sterile_run and second_floor_tags_ctr != 0) or
-            (not test.sterile_run and second_floor_tags_ctr > TAGS_CTR_OVER_THRESHOLD * first_floor_tags_ctr)):
+    if test.sterile_run and second_floor_tags_ctr != 0:
         test.rc = TEST_FAILED
         test.add_reason("Pixel count is higher than expected. Looks like aging time is too long.\n"
-                        f"tags_ctr value: {second_peak_tags_ctr}\nFloor number of pixels: {second_floor_tags_ctr}")
+                        f"Number of pixels after aging time: {second_floor_tags_ctr}")
+    elif not test.sterile_run and (second_floor_tags_ctr > TAGS_CTR_OVER_THRESHOLD * first_floor_tags_ctr):
+        test.rc = TEST_FAILED
+        test.add_reason("Pixel count is higher than expected. Looks like aging time is too long.\n"
+                        f"Number of pixels after aging time: {second_floor_tags_ctr},"
+                        f" before tags simulation was: {second_peak_tags_ctr}\n")
     return test
 
 

certificate/tests/datapath/num_of_tags_test/num_of_tags_test.json

@@ -14,5 +14,5 @@
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
     "dataSimOnlyTest": 1,
-    "allSupportedValues": [500, 1000, 2500, 5000]
+    "allSupportedValues": [500, 1000, 2500, 4500]
 }

certificate/tests/datapath/num_of_tags_test/num_of_tags_test.py

@@ -51,9 +51,11 @@ def run(test):
         cert_config.send_brg_action(test, ag.ACTION_SEND_HB)
         test, mgmt_pkts = cert_common.scan_for_mgmt_pkts(test, [eval_pkt(f'Brg2GwHbV{test.active_brg.api_version}')])
         if not mgmt_pkts:
-            test.rc = TEST_FAILED
-            test.add_reason("Didn't find ACTION HB pkt")
-            break
+            reason = "Didn't find ACTION HB pkt"
+            utPrint(reason, "RED")
+            test.set_phase_rc(param.name, TEST_FAILED)
+            test.add_phase_reason(param.name, "Didn't find ACTION HB pkt")
+            continue
 
         num_of_tags_HB = mgmt_pkts[0][MGMT_PKT].pkt.tags_ctr
         print(f"Tags from HB: {num_of_tags_HB}\n ")
@@ -62,11 +64,13 @@ def run(test):
 
         # compare the numbers of tags that come from the brg, success in 95% from number of tags (value) or more.
         if num_of_tags < (param.value * 0.95):
-            test.add_reason(f"Received {num_of_tags} pixels, expected: {param.name} pixels!")
+            test.add_reason(f"Received {num_of_tags} different pixels, expected: {param.name} pixels!")
+            test.rc = TEST_FAILED
 
         # compare the counter tags in the HB packet
         if num_of_tags_HB < 0.95 * param.value or num_of_tags_HB > (param.value + 100):
-            test.add_reason(f"HB counter: {num_of_tags_HB}, expected: {param.name}!")
+            test.add_reason(f"HB counter num_of_tags: {num_of_tags_HB}, expected: {param.name}!")
+            test.rc = TEST_FAILED
         # param epilog
         time.sleep(10)
         cert_mqtt.generate_log_file(test, param.name)

certificate/tests/datapath/stress_gen3_test/stress_gen3_test.py

@@ -206,4 +206,7 @@ def run(test):
     # Re-enable unified packets deduplication
     cert_config.gw_action(test, f"{DEDUPLICATION_PKTS} 1")
 
+    # wait a few seconds to ensure bridge relaxed before next test
+    wait_time_n_print(60)
+
     return cert_common.test_epilog(test, revert_brgs=True, modules=[datapath_module])

certificate/tests/datapath/stress_test/stress_test.py

@@ -205,4 +205,7 @@ def run(test):
     # Re-enable unified packets deduplication
     cert_config.gw_action(test, f"{DEDUPLICATION_PKTS} 1")
 
+    # wait a few seconds to ensure bridge relaxed before next test
+    wait_time_n_print(60)
+
     return cert_common.test_epilog(test, revert_brgs=True, modules=[datapath_module])

gui_certificate/server.py

@@ -42,9 +42,7 @@ DEFAULT_CUSTOM_BROKER = {
     "brokerUrl": "mqtts://broker.hivemq.com",
     "username": "",
     "password": "",
-    "updateTopic": "update/wiliot/<gatewayId>",
-    "statusTopic": "status/wiliot/<gatewayId>",
-    "dataTopic": "data/wiliot/<gatewayId>"
+    "ownerId": ""
 }
 
 app = Flask(__name__)
@@ -496,12 +494,17 @@ def _write_custom_broker_config(form_data, cert_schema_title="cert_run") -> str:
         field_name = f"{field_prefix}{field}"
         value = form_data.get(field_name, "")
         
-        # Convert port to int if it's a number
         if field == "port":
+            # Convert port to int if it's a number
             try:
                 broker_config[field] = int(value) if value else DEFAULT_CUSTOM_BROKER[field]
             except (ValueError, TypeError):
                 broker_config[field] = DEFAULT_CUSTOM_BROKER[field]
+        elif field == "ownerId":
+            # Convert ownerId to topics
+            broker_config[CUSTOM_BROKER_UPDATE_TOPIC] = f'update/{value}/<{GW_ID}>'
+            broker_config[CUSTOM_BROKER_DATA_TOPIC] = f'data/{value}/<{GW_ID}>'
+            broker_config[CUSTOM_BROKER_STATUS_TOPIC] = f'status/{value}/<{GW_ID}>'
         else:
             broker_config[field] = value
     

{wiliot_certificate-4.5.0a4.dist-info → wiliot_certificate-4.5.0a6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wiliot_certificate
-Version: 4.5.0a4
+Version: 4.5.0a6
 Summary: A library for certifying Wiliot-compliant boards
 Author-email: Wiliot <support@wiliot.com>
 License-Expression: MIT
@@ -38,10 +38,10 @@ This python package includes the following tools:
  - Certification Wizard (`wlt-cert`)
  - Certificate CLI (`wlt-cert-cli`)
  - Tester Upgrade (`wlt-cert-tester-upgrade`)
- - Registration Certificate (`wlt-cert-reg`)
+ - Registration Certificate Test (`wlt-cert-reg`)
 
 # Versioning: 
-wiliot-certificate versions 4.5.x are compatible with firmware version >=4.5.0 (API VERSION: 13)
+wiliot-certificate versions 4.5.x are compatible with firmware version >=4.4.0 (API VERSION: 12)
 
 ## Installing wiliot-certificate
 ````commandline
@@ -55,7 +55,7 @@ wlt-cert
 ````
 This tool is the default to test and certify your device.
 It runs a setup wizard that walks you through the initialization steps before running the tests.
-You'll need a [validation schema](https://community.wiliot.com/customers/s/article/Validation-Schema), tester device and custom broker json file (more info [here](https://community.wiliot.com/customers/s/article/Wiliot-Certification)).
+You'll need a [validation schema](https://community.wiliot.com/customers/s/article/Validation-Schema) and a [tester device](https://community.wiliot.com/customers/s/article/Wiliot-Certification).
 Once set up it opens a terminal and tests your device.
 
 
@@ -87,10 +87,6 @@ Use -h for details on the arguments (see [Registration](https://community.wiliot
 ##### Cloud Connectivity & Misc
  - Board type registered within the Board Type Management system
  - Bridge OTA progress reporting
-##### Power management
-  - Functionality of energize and transmit in sleep mode
-##### Edge management
-  - Timing of heartbeat and interface packets 
 ##### Module Energy 2400
   - Functionality of energy pattern, output power and duty cycle
 ##### Module Energy SUB1G
@@ -98,12 +94,6 @@ Use -h for details on the arguments (see [Registration](https://community.wiliot
 ##### Module Datapath 
   - RSSI edge cases: -127 and 0 
   - Functionality of transmission pattern, output power
-  - Pacer interval with channel 10 and 500k modulation
-  - Pacer interval using GEN3 Pixels 
-  - Packet filter: the following configuration - DEBUG, TEMP & DEBUG, TEMPS & DEBUG & ADVANCE
-  - Rx rate feature with extended advertising 
-  - Functionality of adaptive pacer algorithm
-  - Supported Pixels for extended advertising and GEN3
 ##### Calibration 
   - Functionality of output power and interval calibration 
   - Functionality of calibration transmission patterns for the configuration STANDARD & EU & DISABLE

{wiliot_certificate-4.5.0a4.dist-info → wiliot_certificate-4.5.0a6.dist-info}/RECORD

@@ -1,19 +1,19 @@
 certificate/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-certificate/cert_common.py,sha256=M28Jt7ehM3K4KYc1ZdrRNMV0gtK4iiihPhF7bmpP_m0,72124
-certificate/cert_config.py,sha256=zgs0taYur_tKX18B8PHLREwrf1XWTUCVszCUzVkz-mY,22318
+certificate/cert_common.py,sha256=rY1Y2nvGu-AtYvyJUrMiJ9LHrkNhI0nmVcV3ZCrNiM4,72462
+certificate/cert_config.py,sha256=Z2F2EV6Ow0nVBrlBRkAM7H7dcyZtFU0eq8hNKPob4ss,22380
 certificate/cert_data_sim.py,sha256=Oe8sUaIh-NqLFr3QUkhcyUu8ZH0osy1VoOY3fRx-mmk,13785
-certificate/cert_defines.py,sha256=v1PTOAz6v9lTzGUoR6S5COlBcn7DyP8ds6pEmCa9S_Y,17386
-certificate/cert_gw_sim.py,sha256=c1OdfVWRphLL6ZA1J-TgSqwMrfckRyvm1lOxWqxIl_E,16641
-certificate/cert_mqtt.py,sha256=l7of-UGvZiVTHorq3SN8aKc4kESQKaLjElr8I6ndrxI,22445
-certificate/cert_prints.py,sha256=z8Bw3ZHiLr6yN3EbRkVvmUMkwLt6VNj0MUX1mUvdHQI,7025
+certificate/cert_defines.py,sha256=jmyAVA1ypy2VW9JNooiO7scQGSUPwpThfVcfTi3FXII,17496
+certificate/cert_gw_sim.py,sha256=mxa591grg-JhcSKXiqgBwjTm6xuqekVFEpwBaqD1lyU,17568
+certificate/cert_mqtt.py,sha256=kUYVoyMonbcos7s8BHulA54eX7z6WYU9hR3wsYz0UMg,22881
+certificate/cert_prints.py,sha256=uuaLjleRmbPVh-k0KDjyfIjQd0VtVIAe401UODBLLv8,7100
 certificate/cert_protobuf.py,sha256=j8Tmm86VXONMvSTBl4Tmwt5G1jJRcJg05nJj7YHbpoM,3824
 certificate/cert_results.py,sha256=Lux5UQGSZG_0wq1uSO7ETri-JrYT4nXNOHdriZUmcCg,30051
 certificate/cert_utils.py,sha256=ADPFJXLOZFzKtJoql3j1OKpkB9JgnJiv8VwEJW7kYJk,29038
 certificate/certificate.py,sha256=KYOtROsBIZE9vYZKtPMnU9LyvQQ60fXodi3WZqRMluA,9310
-certificate/certificate_cli.py,sha256=gQdvXkzcC9TScqOCqvfQxl1eOKWZ8jCRKALBpvlS2pc,5028
-certificate/certificate_eth_test_list.txt,sha256=xlfEd7AMDG1d30c6AxKUZg2uDfI5YtkqpRWEfYgJAwQ,6216
+certificate/certificate_cli.py,sha256=wd4X-ih6gPVGUWKLIXluIW40wYPJnMGfP_rD-dwPWk8,5030
+certificate/certificate_eth_test_list.txt,sha256=KxG08Ry2SuwHnq3ovGWEo4utxIIPkQoEzHdbksOQcuU,6216
 certificate/certificate_sanity_test_list.txt,sha256=JjpFxyxjWbylxnH8FyjPFgO2w-WaT3Nm0bcYhD0shhk,3487
-certificate/certificate_test_list.txt,sha256=O1nA_QUgFujppEQURlrMpfYh0jWXmU6JwgoI4ZLfzhs,6156
+certificate/certificate_test_list.txt,sha256=7hA9hrhhy0oLC1EPgpP7IvCkMdrQkdr0osmiJkYwKZ4,6156
 certificate/wlt_types.py,sha256=7RbsW-OudiHhNAay6nFGKtF4FrlAq91pm9yeIQRxddM,6047
 certificate/ag/wlt_cmd_if.html,sha256=eO-FYVrxVs5JdCblGaQLG9-0dZKt6YjbE9Ggz8bXRq4,16831
 certificate/ag/wlt_types_ag.py,sha256=cTYysTSdEh2IWY8tD3pipRhwKo1b194VSX64ctvgGQY,536839
@@ -30,34 +30,34 @@ certificate/tests/cloud_connectivity/acl_test/acl_test.py,sha256=NBC9E1h2agpKYEs
 certificate/tests/cloud_connectivity/brg_ota_test/brg_ota_test.json,sha256=0U1RIjBFsfGtl_nTabNzRRPQYJs3F4JIivKIImuR1Y8,850
 certificate/tests/cloud_connectivity/brg_ota_test/brg_ota_test.py,sha256=xqB65yWM754UfWF1N_h4bI4kuEajAqMvcdFjRu0OFfI,1873
 certificate/tests/cloud_connectivity/channel_scan_behaviour_test/channel_scan_behaviour_test.json,sha256=Sc4Xp3VPY9GjNKsQFcjAr9fyD9_MZMBfxsgpo31Jk-Y,755
-certificate/tests/cloud_connectivity/channel_scan_behaviour_test/channel_scan_behaviour_test.py,sha256=Q1VKsCofRImeOysN6ZweZcVLYHWf5t1_hgKh9VfZtRU,10179
+certificate/tests/cloud_connectivity/channel_scan_behaviour_test/channel_scan_behaviour_test.py,sha256=K6G1j4XKEbFWgPl_DWlbYUJw07I78EenJxFS60uQLek,10179
 certificate/tests/cloud_connectivity/connection_test/connection_test.json,sha256=xr-d-DnzbItkXE8oBTZ31Fr0huhILdxXTQFJyqd6FYc,939
-certificate/tests/cloud_connectivity/connection_test/connection_test.py,sha256=VMG3-c9BpWYzVvp3amKMh8THP5Tl_hGsLUG9eaS42aE,2456
+certificate/tests/cloud_connectivity/connection_test/connection_test.py,sha256=Gl8VWlbOQxdnvqPEUbAe4Wakk7CLE3byRFhJoxObqi4,2568
 certificate/tests/cloud_connectivity/deduplication_test/deduplication_test.json,sha256=-6va5_YT-IDdEJZjJUlV3L6CcGODPcLWgcZUE5Dv01k,710
-certificate/tests/cloud_connectivity/deduplication_test/deduplication_test.py,sha256=FUS572_B3U-EjGUJNkxFpQyOjzm7x3J5FH0Bass8EhQ,3514
+certificate/tests/cloud_connectivity/deduplication_test/deduplication_test.py,sha256=Dbnah1fhaidnwLbPj9qz1H_lKr4-3jg8BvN7dsNg3oQ,3342
 certificate/tests/cloud_connectivity/downlink_test/downlink_test.json,sha256=VR2EHtOLHuh0ETSbgRGOuorHcuJPKBkk1hwM_7g_Dj4,878
 certificate/tests/cloud_connectivity/downlink_test/downlink_test.py,sha256=73uszwCvY2Rkg71Rqmco-meYLNBuh0vBIPxAeDo7zoU,8508
 certificate/tests/cloud_connectivity/ext_adv_stress_test/ext_adv_stress_test.json,sha256=W0kAvLyzxUsaEKiuGu2Eq-Al5g-ov2zapFF3FXlgdq0,954
-certificate/tests/cloud_connectivity/ext_adv_stress_test/ext_adv_stress_test.py,sha256=-NFnFJ2PZxWalCg1umhP3KG_phidocJFhpH0j7Mu9xk,4291
+certificate/tests/cloud_connectivity/ext_adv_stress_test/ext_adv_stress_test.py,sha256=q68BmQtOtauiUgZAC2TK7XXjRLyDkeT9IkfQ5Q8ZewI,4293
 certificate/tests/cloud_connectivity/reboot_test/reboot_test.json,sha256=QZMqxrUul_jEvoQJKdWjzXxa_m49a3rVyDTDbREYhik,781
-certificate/tests/cloud_connectivity/reboot_test/reboot_test.py,sha256=h8Uhn6NQExb9pLRytrd7UvLO0ScxTOfM3sdCwSCWKqg,1924
+certificate/tests/cloud_connectivity/reboot_test/reboot_test.py,sha256=BWZU8NCWhkRor8tXe-crp25bN0aWcWqYL17qjkKU1Pg,2036
 certificate/tests/cloud_connectivity/registration_test/registration_test.json,sha256=fT-IHk0CRid8EDgo9bDtO7jl_1JDcVK0bQSHBz8CpZw,1039
 certificate/tests/cloud_connectivity/registration_test/registration_test.py,sha256=uzLwNQFffLJQhzuUx0l1-xsk7r0X1z4xBk7zjkzlTlE,15115
 certificate/tests/cloud_connectivity/registration_test/registration_test_cli.py,sha256=PA43jADoqfnkEwOzeggl6mmo5nIQT6M_8j32IIxhQb0,3141
 certificate/tests/cloud_connectivity/stress_test/stress_test.json,sha256=rXDA1AgdSgMdBZhDvKHyO4p1KoqJxDfKJzvwSVLcONA,804
-certificate/tests/cloud_connectivity/stress_test/stress_test.py,sha256=K68fvwvTIIxuQHPak6oJ_HLv0amsGEM1NbqyePSpI3A,4175
+certificate/tests/cloud_connectivity/stress_test/stress_test.py,sha256=rl63dFNFBb-9o6wqdQrLFAzCLAbDt29b_IliZMhHbp8,4177
 certificate/tests/cloud_connectivity/uplink_ext_adv_test/uplink_ext_adv_test.json,sha256=4yiEHa1sxz6-xnQDtaBU4JHNDsPZ_p9Jpgqpy8s9QJY,1326
 certificate/tests/cloud_connectivity/uplink_ext_adv_test/uplink_ext_adv_test.py,sha256=R6EvyRbBzfy3XjHrnR0HFSZHL7xM-ccDYZuBmrncIGU,4368
 certificate/tests/cloud_connectivity/uplink_test/uplink_test.json,sha256=F28h9EjUxLYOiYH1mk_o8hUqHyer4Mc7BhvfU4VnhYQ,955
-certificate/tests/cloud_connectivity/uplink_test/uplink_test.py,sha256=jEFkH6_UGiEcP4i3nyxYN2oqRQaJjiK165mbB2gF4kk,7227
+certificate/tests/cloud_connectivity/uplink_test/uplink_test.py,sha256=AuOnFAkowDtU2Wdkg4c2cCldazzTG05o4XUz8agHoOw,7339
 certificate/tests/datapath/aging_test/aging_test.json,sha256=n1LmPKJWzfSOmjNFMVMeIdFS59kteUDce6a55gEM4Zk,901
-certificate/tests/datapath/aging_test/aging_test.py,sha256=hxWlCd9XOJP9M14T9XRPpJ8_Af6SNaUs9ZDJNLRg7ms,6682
+certificate/tests/datapath/aging_test/aging_test.py,sha256=oBNdp0GMPSILEqEwPuv7nNOOCswyamn91BJIV2JCYDc,6943
 certificate/tests/datapath/event_ble5_test/event_ble5_test.json,sha256=oK-HyLS8Re_D4MYppi6ZehhJTMVZ2-iW4gwlGaRu4bg,944
 certificate/tests/datapath/event_ble5_test/event_ble5_test.py,sha256=BsCuVFFjL5U3s2cBxjeGygw5j9MmUWF51s_afmvyEII,4601
 certificate/tests/datapath/event_test/event_test.json,sha256=moxR8vxvTX5p2PyP4d1P9f-wFjJbERhFn0nJAZw8AgA,949
 certificate/tests/datapath/event_test/event_test.py,sha256=IigGoxk4rNM9CVRSnT0KWdEWg1CT2NZXyHd2SIIzqeA,3783
-certificate/tests/datapath/num_of_tags_test/num_of_tags_test.json,sha256=lho1x44X3MJDvKPX3ZouWIJPednp0MyTabcqhPaU9aE,805
-certificate/tests/datapath/num_of_tags_test/num_of_tags_test.py,sha256=Ecaf-8yQQX1ZybbgMstiNPrVhZz7-BSF4MSiUiE6tTc,3481
+certificate/tests/datapath/num_of_tags_test/num_of_tags_test.json,sha256=THXxkPXB27P7KEWk8us-kkTIs7kCuBixVcra-edPiFg,805
+certificate/tests/datapath/num_of_tags_test/num_of_tags_test.py,sha256=in7NrVYRF7l08INHf6w-_hRbIaJnqqyaqQtJpM698BA,3697
 certificate/tests/datapath/output_power_test/output_power_test.json,sha256=1B_glQf7GUgjdqnAwnKE2_iyinNGuW3mtiglp2XlLvQ,1449
 certificate/tests/datapath/output_power_test/output_power_test.py,sha256=09Ug3nhLm3SFTdfZnoKSN1wR5Dc9yRKbRlaNn7Gt9Rw,1704
 certificate/tests/datapath/pacer_interval_ble5_test/pacer_interval_ble5_test.json,sha256=5TIAiLQ5RRzRzYImh4Hk5iv0-skqdpuJALff3Z75j_s,948
@@ -87,9 +87,9 @@ certificate/tests/datapath/rx_rate_gen2_test/rx_rate_gen2_test.py,sha256=mNXskD7
 certificate/tests/datapath/rx_rate_gen3_test/rx_rate_gen3_test.json,sha256=vz2DOmPwgpBBNuFMKHm26zz_UX8eYK4vMF0zmm8TpXU,1423
 certificate/tests/datapath/rx_rate_gen3_test/rx_rate_gen3_test.py,sha256=MPztd0r9R36rnkx1EYRhK4xqELeqsqkduyohQQTukho,12016
 certificate/tests/datapath/stress_gen3_test/stress_gen3_test.json,sha256=hliFx-0HCLudJwzjkVIsLxeTRGxDE8nsnnEBxgOjeZE,1315
-certificate/tests/datapath/stress_gen3_test/stress_gen3_test.py,sha256=zqjNGFe_SSRrNE4fDPybpgWBwGJwQrO5A8Fphg4x6bg,10996
+certificate/tests/datapath/stress_gen3_test/stress_gen3_test.py,sha256=ZV7Rw5uRohzUeaQsosuI9UsjpSChZ-qHd43NTOZZV64,11090
 certificate/tests/datapath/stress_test/stress_test.json,sha256=oOrNKTZ1pObnQJuZfSCxORk_o9SVbg4_uEWghp7rQUA,1315
-certificate/tests/datapath/stress_test/stress_test.py,sha256=ZfztrKpL02wyEFM8plS04b9TpC-5HFUUD6WbCUPc7c0,10995
+certificate/tests/datapath/stress_test/stress_test.py,sha256=XiwBVHe3rMtvWHaBfBYStdDgvJs0zy6MNsxoaRL7YnM,11089
 certificate/tests/datapath/tx_repetition_test/tx_repetition_test.json,sha256=5WfRTpR0HBs_7zr8YNxSWAe9Njk8WV5NTtqloDajtII,994
 certificate/tests/datapath/tx_repetition_test/tx_repetition_test.py,sha256=nb1o8mge5QDSyw731fZbKyhmaSlvGjO1fnsYb-9jVfk,3642
 certificate/tests/edge_mgmt/action_blink_test/action_blink_test.json,sha256=tZJAxmSuYQg8KIPBytzB7QLh24SCkHycn5sLPAR1SX8,587
@@ -158,11 +158,11 @@ common/web/templates/parser.html,sha256=0J2WX5QTD_EZJUtmNq6--wrnpP0-I09iE3rB02eu
 common/web/templates/wlt_types.html,sha256=FKxlJ08H7IgNPdsT36RbpMKRw29t-tuwqGaQ4HHhBEM,432230
 gui_certificate/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gui_certificate/gui_certificate_cli.py,sha256=371nNCVmRtUePYKp_w-DVTr3C8hLAzKR2q5ZAMsaxt0,448
-gui_certificate/server.py,sha256=qlKlpgBSAQa9zlPR12k3rB2m0mAvxO9aZxUVgGLfoRE,60159
+gui_certificate/server.py,sha256=-4YETUzq_aDz-l4qreuF5mH0uBwKtFU7kUAncGuG_tM,60363
 gui_certificate/templates/cert_run.html,sha256=nnfolVZ2u1bsiH-u3vbKt1HCcP7CvAzWRZnJe-g3yyo,68803
-wiliot_certificate-4.5.0a4.dist-info/licenses/LICENSE,sha256=OL5ajUNVx888yC2ogol0BKwPRLdQAF1noGuQ7WrYiAA,1068
-wiliot_certificate-4.5.0a4.dist-info/METADATA,sha256=XWkz7Lm5XPljS47WzgtlGhaDZ-nCVfaLjS0mHLB8eEU,4015
-wiliot_certificate-4.5.0a4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-wiliot_certificate-4.5.0a4.dist-info/entry_points.txt,sha256=_wnYk2F4bFn9H7ZGRwYV6WcpK8a3WNon8K7Y5xusFz4,274
-wiliot_certificate-4.5.0a4.dist-info/top_level.txt,sha256=WF6PUfxJ5n2-DxcXTA4oFrTlV6PX_pOYkYaQDk4Mk3g,35
-wiliot_certificate-4.5.0a4.dist-info/RECORD,,
+wiliot_certificate-4.5.0a6.dist-info/licenses/LICENSE,sha256=OL5ajUNVx888yC2ogol0BKwPRLdQAF1noGuQ7WrYiAA,1068
+wiliot_certificate-4.5.0a6.dist-info/METADATA,sha256=q_ZhlDMTu5JkI4COHfkK-2-4WhLN2nQnTxc8YtvC5d8,3496
+wiliot_certificate-4.5.0a6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+wiliot_certificate-4.5.0a6.dist-info/entry_points.txt,sha256=_wnYk2F4bFn9H7ZGRwYV6WcpK8a3WNon8K7Y5xusFz4,274
+wiliot_certificate-4.5.0a6.dist-info/top_level.txt,sha256=WF6PUfxJ5n2-DxcXTA4oFrTlV6PX_pOYkYaQDk4Mk3g,35
+wiliot_certificate-4.5.0a6.dist-info/RECORD,,