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

certificate/tests/cloud_connectivity/brg_ota_test/brg_ota_test.py

@@ -3,13 +3,11 @@ from certificate.cert_prints import *
 from certificate.cert_defines import *
 from certificate.wlt_types import *
 from certificate.cert_utils import TESTER_FW_VERSIONS
-import certificate.cert_gw_sim as cert_gw_sim
+from certificate.cert_gw_sim import STOP_ADVERTISING, GW_SIM_RESET_TS
 import certificate.cert_common as cert_common
 import certificate.cert_config as cert_config
 import certificate.cert_mqtt as cert_mqtt
 
-BRG_OTA_HIGH_TIMEOUT = (60 * 10)
-
 
 def run(test):
     test = cert_common.test_prolog(test)
@@ -24,18 +22,18 @@ def run(test):
     desired_ver = TESTER_FW_VERSIONS[0] if target_brg.version != TESTER_FW_VERSIONS[0] else TESTER_FW_VERSIONS[1]
 
     # Initiate action
-    utPrint(f"Publishing OTA action to DUT: {test.dut.mqttc.update_topic}. Awaiting OTA.. (timeout is {BRG_OTA_HIGH_TIMEOUT} seconds)")
+    utPrint(f"Publishing OTA action to DUT: {test.dut.mqttc.update_topic}. Awaiting OTA.. (timeout is {VER_UPDATE_TIMEOUT} minutes)")
     # Set active_brg to be the tester, for reboot_config_analysis within brg_ota
     test.active_brg = target_brg
-    test = cert_config.brg_ota(test, ble_version=desired_ver, search_ack=True, target=TESTER, upgrader=DUT, timeout=BRG_OTA_HIGH_TIMEOUT)
+    test = cert_config.brg_ota(test, ble_version=desired_ver, search_ack=True, target=TESTER, upgrader=DUT)
 
     # Stop advertising on tester in case it just rebooted after getting OTA. So it is ready for next tests
-    cert_config.gw_action(test, cert_gw_sim.STOP_ADVERTISING, target=TESTER)
+    cert_config.gw_action(test, STOP_ADVERTISING, target=TESTER)
 
     cert_mqtt.generate_log_file(test, "brg_ota")
 
-    if test.rc == TEST_PASSED and cert_gw_sim.GW_SIM_RESET_TS is not None:
-        reboot_pkt_time = int((cert_gw_sim.GW_SIM_RESET_TS - test.start_time).total_seconds())
+    if test.rc == TEST_PASSED and GW_SIM_RESET_TS is not None:
+        reboot_pkt_time = int((GW_SIM_RESET_TS - test.start_time).total_seconds())
         test.reason = f"Reboot pkt received after {reboot_pkt_time} seconds"
 
     return cert_common.test_epilog(test)

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": "",
+    "documentation": "<TEST_DOCUMENTATION_LINK>",
     "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",
@@ -14,6 +14,5 @@
     "gwOnlyTest": 1,
     "dataSimOnlyTest": 1,
     "internalBridge": 1,
-    "SupportedFromApiVersion": 203,
     "allSupportedValues": []
 }

certificate/tests/cloud_connectivity/channel_scan_behaviour_test/channel_scan_behaviour_test.py

@@ -3,6 +3,7 @@ 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
@@ -17,7 +18,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 = get_random_hex_str(6)  # Unique identifier for the pkt sent
+SCAN_TEST_INDICATOR = cert_utils.get_random_hex_str(len=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
@@ -83,7 +84,6 @@ 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)
@@ -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 channels for {ADV_DURATION} seconds", "WARNING")
+    utPrint(f"Transmitting in parallel on all 3 main cahnnels 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.json

@@ -12,7 +12,6 @@
     "mandatory": 1,
     "multiBridgeTest": 0,
     "gwOnlyTest": 1,
-    "SupportedFromApiVersion": 203,
     "allSupportedValues": []
 
 }

certificate/tests/cloud_connectivity/connection_test/connection_test.py

@@ -25,10 +25,19 @@ 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}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}"))
+        input(
+            f"{warning_prefix}Please plug GW back to power. "
+            f"Press enter when plugged{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)")
@@ -41,14 +50,12 @@ 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")
+    cert_mqtt.generate_log_file(test, "reboot")
 
     # Analyze results
     if gw_type is None:

certificate/tests/cloud_connectivity/downlink_test/downlink_test.json

@@ -15,7 +15,6 @@
     "multiBridgeTest": 0,
     "gwOnlyTest": 1,
     "dataSimOnlyTest": 0,
-    "SupportedFromApiVersion": 203,
     "allSupportedValues": []
 
 }

certificate/tests/cloud_connectivity/downlink_test/downlink_test.py

@@ -121,7 +121,10 @@ def report_and_results(test, sniffed_pkts):
         test.reason = 'No packets collected.'
         return
 
-    x_value = ('tx_max_duration', 'TX Max Duration')
+    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')
 
     # Create scatter with OLS trendline per channel
     fig = px.scatter(

certificate/tests/cloud_connectivity/ext_adv_stress_test/ext_adv_stress_test.json

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

certificate/tests/cloud_connectivity/ext_adv_stress_test/ext_adv_stress_test.py

@@ -12,7 +12,7 @@ import math
 
 
 # DEFINES
-STRESS_TEST_INDICATOR = get_random_hex_str(6)
+STRESS_TEST_INDICATOR = cert_utils.get_random_hex_str(len=6)
 
 DUPLICATES = 1
 ADVA_ASCII_LEN = 12
@@ -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 pps in ppses:
-        phase_run_print(f"PPS = {pps}")
+    for param in test.params:
+        phase_run_print(f"PPS = {param}")
         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,20 +74,17 @@ 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=str(pps))
+        cert_mqtt.dump_pkts(test, log=param.name)
         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
-        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))
 
+        test, percentage_received = 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)
+
+        test.set_phase_rc(param.name, test.rc)
+        test.add_phase_reason(param.name, test.reason)
         if test.rc == TEST_FAILED and test.exit_on_param_failure:
             break  # break the whole for loop and keep the test as failed
         test.reset_result()  # reset result and continue to next param
@@ -96,9 +93,6 @@ def run(test):
     cert_config.gw_action(test, f'{cert_gw_sim.BLE_SIM_INIT} 0', TESTER)
 
     # Generate stress test graphs
-    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")
+    cert_common.generate_graph_stress_test(test, results, data_pkts_received)
 
     return cert_common.test_epilog(test)

certificate/tests/cloud_connectivity/reboot_test/reboot_test.json

@@ -12,7 +12,6 @@
     "mandatory": 0,
     "multiBridgeTest": 0,
     "gwOnlyTest": 1,
-    "SupportedFromApiVersion": 203,
     "allSupportedValues": []
 
 }

certificate/tests/cloud_connectivity/reboot_test/reboot_test.py

@@ -33,11 +33,9 @@ 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/registration_test/registration_test.json

@@ -15,6 +15,5 @@
     "multiBridgeTest": 0,
     "gwOnlyTest": 1,
     "internalBridge": 0,
-    "SupportedFromApiVersion": 203,
     "allSupportedValues": ["registry", "online", "refresh"]
 }

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(html=True, pdf=True, failures=failures,
+    cert_results.generate_results_files(test.dut, test.tester, 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.json

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

certificate/tests/cloud_connectivity/stress_test/stress_test.py

@@ -12,7 +12,7 @@ import math
 
 
 # DEFINES
-STRESS_TEST_INDICATOR = get_random_hex_str(6)
+STRESS_TEST_INDICATOR = cert_utils.get_random_hex_str(len=6)
 
 DUPLICATES = 1
 ADVA_ASCII_LEN = 12
@@ -50,13 +50,14 @@ 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, 500]
+
     test_pkts_received = []
     data_pkts_received = []
     results = []
-    for pps in ppses:
-        phase_run_print(f"PPS = {pps}")
+    for param in test.params:
+        phase_run_print(f"PPS = {param}")
         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)
@@ -72,20 +73,17 @@ 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=str(pps))
+        cert_mqtt.dump_pkts(test, log=param.name)
         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
-        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))
 
+        test, percentage_received = 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)
+
+        test.set_phase_rc(param.name, test.rc)
+        test.add_phase_reason(param.name, test.reason)
         if test.rc == TEST_FAILED and test.exit_on_param_failure:
             break  # break the whole for loop and keep the test as failed
         test.reset_result()  # reset result and continue to next param
@@ -93,9 +91,7 @@ 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)
 
-    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")
+    # Generate stress test graphs
+    cert_common.generate_graph_stress_test(test, results, data_pkts_received)
 
     return cert_common.test_epilog(test)

certificate/tests/cloud_connectivity/uplink_ext_adv_test/uplink_ext_adv_test.json

@@ -20,6 +20,5 @@
     "multiBridgeTest": 0,
     "gwOnlyTest": 1,
     "dataSimOnlyTest": 1,
-    "SupportedFromApiVersion": 206,
     "allSupportedValues": []
 }

certificate/tests/cloud_connectivity/uplink_ext_adv_test/uplink_ext_adv_test.py

@@ -4,13 +4,14 @@ 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 = get_random_hex_str(6)
+EXT_ADV_TEST_INDICATOR = cert_utils.get_random_hex_str(len=6)
 EXPECTED_REPEAT_COUNT = 7
 
 

certificate/tests/cloud_connectivity/uplink_test/uplink_test.json

@@ -15,6 +15,5 @@
     "multiBridgeTest": 0,
     "gwOnlyTest": 1,
     "dataSimOnlyTest": 1,
-    "SupportedFromApiVersion": 203,
     "allSupportedValues": ["mgmt_pkt", "pixels_pkt", "sensor_pkt", "geolocation"]
 }

certificate/tests/cloud_connectivity/uplink_test/uplink_test.py

@@ -4,6 +4,7 @@ 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
@@ -12,28 +13,24 @@ import pandas as pd
 # DEFINES
 
 API_VALIDATION = "API Validation"
-UPLINK_TEST_INDICATOR = get_random_hex_str(6)
+UPLINK_TEST_INDICATOR = cert_utils.get_random_hex_str(len=6)
 NUM_OF_BRGS = 3
 
 
 # HELPER FUNCTIONS
-def uplink_analysis(test, sent_pkts, received_pkts, pkt_type):
+def uplink_analysis(test, 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
+        return test, 0
 
-    # Verify packets were received from NUM_OF_BRGS bridges
-    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 {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 = []
+    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')
@@ -50,17 +47,16 @@ def uplink_analysis(test, sent_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
+        return test, 0
 
     percentage_received = round(pkts_received_count * 100 / pkts_sent_count)
 
     # PASS/FAIL logic
     if percentage_received < 80:
-        test.set_phase_rc(pkt_type, TEST_FAILED)
-        test.add_phase_reason(pkt_type, f'{percentage_received}% of {pkt_type} packets received')
+        test.rc = TEST_FAILED
+        test.reason = f"Insufficient amount of {pkt_type} packets were scanned & uploaded by the gateway"
     else:
-        test.set_phase_rc(pkt_type, TEST_PASSED)
-        test.add_phase_reason(pkt_type, f'{percentage_received}% of {pkt_type} packets received')
+        test.reason = f'{percentage_received}% of {pkt_type} packets received'
 
     return test
 
@@ -134,29 +130,25 @@ 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)
-        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, recieved_pkts, param.name)
+        test = uplink_analysis(test, pkts, [p[ALIAS_BRIDGE_ID] + p[PAYLOAD] for p in recieved_pkts], param.name)
 
         cert_mqtt.generate_log_file(test, param.name)
-        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:
+        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:
             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
-    test = api_validation(test)
+    if not test.dut.protobuf:
+        test = api_validation(test)
     test = cert_common.wiliot_pkts_validation(test, all_data_messages_in_test, all_data_pkts)
 
     # Geolocation phase

certificate/tests/datapath/aging_test/aging_test.json

@@ -14,7 +14,6 @@
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
     "dataSimOnlyTest": 1,
-    "SupportedFromApiVersion": 12,
     "allSupportedValues": ["low_pacer", "high_pacer"]
 
 }

certificate/tests/datapath/aging_test/aging_test.py

@@ -105,15 +105,11 @@ 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:
+    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)):
         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}")
-    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")
+                        f"tags_ctr value: {second_peak_tags_ctr}\nFloor number of pixels: {second_floor_tags_ctr}")
     return test
 
 

certificate/tests/datapath/event_ble5_test/event_ble5_test.json

@@ -1,7 +1,7 @@
 {
     "name": "Event Test BLE 5",
     "module": "Datapath",
-    "purpose": "Test dynamic pacing for tags that had location events on BLE5 packets",
+    "purpose": "Test pacing disable (later dynamic pacing)",
     "documentation": ["https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Pacing"],
     "initialCondition": "Bridge & data simulator configured to defaults",
     "procedure": ["Test prolog",
@@ -12,6 +12,5 @@
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
     "dataSimOnlyTest": 1,
-    "SupportedFromApiVersion": 13,
-    "allSupportedValues": ["rssi_event", "new_tag_event_seconds", "new_tag_event_minutes", "temp_event", "tx_rate_event"]
+    "allSupportedValues": ["rssi_event", "new_tag_event_seconds", "new_tag_event_minutes", "new_tag_event_hours", "temp_event", "tx_rate_event"]
 }

certificate/tests/datapath/event_ble5_test/event_ble5_test.py

@@ -7,9 +7,17 @@ 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,
@@ -46,7 +54,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_minutes": test_new_tag_event_minutes, "new_tag_event_hours": test_new_tag_event_hours,
                   "temp_event": test_temp_event, "tx_rate_event": test_tx_rate_event}
 
 
@@ -55,11 +63,10 @@ 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, dut.datapath)
+        test = EVENT_TEST_MAP[param.value](test, param.name, test.active_brg.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)
@@ -72,11 +79,10 @@ 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=[dut.datapath], ble5=test.dut_is_bridge())[0]
+        test = cert_config.config_brg_defaults(test, modules=[test.active_brg.datapath], ble5=True)[0]
+        print_update_wait(2 * BLE5_MAX_DURATION_SEC)
         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)
@@ -86,4 +92,4 @@ def run(test):
         else:
             test.reset_result()
 
-    return cert_common.test_epilog(test, revert_brgs=True, modules=[dut.datapath], ble5=test.dut_is_bridge())
+    return cert_common.test_epilog(test, revert_brgs=True, modules=[test.active_brg.datapath], ble5=True)

certificate/tests/datapath/event_test/event_test.json

@@ -1,7 +1,7 @@
 {
     "name": "Event Test",
     "module": "Datapath",
-    "purpose": "Test dynamic pacing for tags that had location events",
+    "purpose": "Test pacing disable for tags that had location events",
     "documentation": ["https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Pacing"],
     "initialCondition": "Bridge & data simulator configured to defaults",
     "procedure": ["Test prolog",
@@ -12,6 +12,5 @@
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
     "dataSimOnlyTest": 1,
-    "SupportedFromApiVersion": 13,
-    "allSupportedValues": ["rssi_event", "new_tag_event_seconds", "new_tag_event_minutes", "temp_event", "tx_rate_event"]
+    "allSupportedValues": ["rssi_event", "new_tag_event_seconds", "new_tag_event_minutes", "new_tag_event_hours", "temp_event", "tx_rate_event"]
 }