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

certificate/tests/cloud_connectivity/uplink_ext_adv_test/uplink_ext_adv_test.py

@@ -0,0 +1,92 @@
+# This test verifies that the gateway correctly handles extended advertising packets
+# where a 31-byte payload is expanded to 31*7 bytes (217 bytes) containing the same payload repeated 7 times
+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_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)
+EXPECTED_REPEAT_COUNT = 7
+
+
+def ext_adv_analysis(test, pkts):
+    """
+    Analyze received packets to verify extended advertising scanning:
+    - Each 31-byte payload should be expanded to 217 bytes (31*7) (aggregated packet generated by the TESTER FW)
+    - The aggregated payload should contain the same 31-byte payload repeated 7 times
+    """
+    phase_run_print("Extended Advertising Analysis")
+
+    # Create list of expected expanded payloads (each payload repeated 7 times)
+    expected_payloads = [pkt.get_pkt()[12:] * EXPECTED_REPEAT_COUNT for pkt in pkts]
+
+    # Get received aggregated packets from MQTT
+    received_pkts_mqtt = cert_mqtt.get_all_aggregated_data_pkts(test.get_mqttc_by_target(DUT), indicator=EXT_ADV_TEST_INDICATOR)
+
+    if len(received_pkts_mqtt) == 0:
+        test.rc = TEST_FAILED
+        test.reason = "No packets were received from the gateway, make sure the gateway is able to receive aggregated \
+        packets with 7 31-byte payloads"
+        return test
+
+    # Count how many expected payloads were received
+    received_payloads = {pkt[AGGREGATED_PAYLOAD] for pkt in received_pkts_mqtt}
+    received_count = sum(expected_payload in received_payloads for expected_payload in expected_payloads)
+    expected_count = len(expected_payloads)
+
+    print(f'Expected payloads: {expected_count}, Received matching payloads: {received_count}')
+
+    if received_count < expected_count * 0.8:
+        test.rc = TEST_FAILED
+        print(f"Insufficient packets received: {received_count}/{expected_count} (expected at least 80%)")
+        test.reason = f"Insufficient packets received: {received_count}/{expected_count} (expected at least 80%)"
+    else:
+        test.rc = TEST_PASSED
+        print(f"Extended advertising validation passed: {received_count}/{expected_count} packets received")
+        test.reason = f"Extended advertising validation passed: {received_count}/{expected_count} packets received"
+    return test
+
+
+def run(test):
+    datapath_module = test.tester.internal_brg.datapath
+    test = cert_common.test_prolog(test)
+    if test.rc == TEST_FAILED:
+        return cert_common.test_epilog(test)
+
+    utPrint("Setting GW CERT TESTER to enable, to allow the TESTER transmit extended advertising packets", "GREEN")
+    cert_config.gw_action(test, f"{GW_CERT_TESTER} 1", target=TESTER)
+
+    # Configure the tester to transmit in extended advertising
+    utPrint('Configuring TESTER to transmit in extended advertising', "GREEN")
+    test = cert_config.brg_configure(test, fields=[BRG_PATTERN], values=[ag.DATAPATH_PATTERN_EXTENDED_ADV],
+                                     module=datapath_module, target=TESTER)[0]
+    time.sleep(1)
+
+    phase_run_print("Extended Advertising Gateway Scan Test")
+    test.flush_all_mqtt_packets()
+
+    # Generate packets with pixel header
+    # Each packet will have a 31-byte payload, the FW expands it to aggregated packet with 7 packets with the same payload
+    pkts, _ = cert_data_sim.brg_pkt_gen(num_of_pkts_per_brg=100, num_of_brgs=1, pkt_type=PIXELS_PKT,
+                                        indicator=EXT_ADV_TEST_INDICATOR)
+
+    # Send packets using GenericSimThread
+    sim_thread = cert_data_sim.GenericSimThread(test=test, pkts=pkts, send_single_cycle=True)
+    sim_thread.start()
+
+    # Wait for packets to be scanned and uploaded
+    mqtt_scan_wait(test, 20)
+
+    # Analyze the results
+    test = ext_adv_analysis(test, pkts)
+
+    test = cert_config.config_brg_defaults(test, modules=[datapath_module], target=TESTER)[0]
+    cert_mqtt.generate_log_file(test, "uplink_ext_adv_test")
+    field_functionality_pass_fail_print(test, "Extended advertising scanning")
+    cert_config.gw_action(test, f"{GW_CERT_TESTER} 0", target=TESTER)
+    return cert_common.test_epilog(test)

certificate/tests/cloud_connectivity/uplink_test/uplink_test.json

@@ -0,0 +1,20 @@
+{
+    "name": "Gateway Uplink",
+    "module": "Cloud Connectivity",
+    "purpose": "Verify gateway BLE scans and MQTT uplinks across packet types",
+    "documentation": "https://community.wiliot.com/customers/s/article/Sending-Wiliot-Packets-to-the-Wiliot-Cloud",
+    "initialCondition": "Gateway configured to defaults",
+    "procedure": [
+        "Test prolog",
+        "Send packets for each preset packet type (mgmt, pixels, sensor, geolocation)",
+        "Analyze received packets: validate counts, JSON serialization structure (when enabled), sequential sequence IDs, and geolocation uploads",
+        "Test epilog"
+    ],
+    "expectedOutcome": "Received amount of packets matches the expected amount for each packet type and all additional validations pass as expected",
+    "mandatory": 1,
+    "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

@@ -0,0 +1,169 @@
+# 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 *
+from common.api_if.api_validation import api_validation
+import certificate.cert_common as cert_common
+import certificate.cert_mqtt as cert_mqtt
+import certificate.cert_data_sim as cert_data_sim
+import pandas as pd
+
+
+# DEFINES
+
+API_VALIDATION = "API Validation"
+UPLINK_TEST_INDICATOR = get_random_hex_str(6)
+NUM_OF_BRGS = 3
+
+
+# HELPER FUNCTIONS
+def uplink_analysis(test, sent_pkts, received_pkts, pkt_type):
+    if len(received_pkts) == 0:
+        test.set_phase_rc(pkt_type, TEST_FAILED)
+        test.add_phase_reason(pkt_type, "No packets were received!")
+        return test
+
+    # 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 = [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')
+    # Drop duplicates to count unique packets that were received
+    merged_df_unique = merged_df.drop_duplicates(subset=[PACKETS])
+    pkts_sent_count = len(sent_df)
+    pkts_received_count = len(merged_df_unique)
+
+    # Prints
+    print(f'Number of {pkt_type} packets sent: {pkts_sent_count}')
+    print(f'Number of {pkt_type} packets received: {pkts_received_count}')
+
+    # Check for division by zero
+    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
+
+    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')
+    else:
+        test.set_phase_rc(pkt_type, TEST_PASSED)
+        test.add_phase_reason(pkt_type, f'{percentage_received}% of {pkt_type} packets received')
+
+    return test
+
+
+def geolocation(test, all_messages_in_test):
+    phase_run_print(GEOLOCATION)
+    locations_list = []
+    locations_df = pd.DataFrame()
+    for message in all_messages_in_test:
+        message = message.body_ex
+        timestamp = message[TIMESTAMP]
+        if LOCATION in message.keys():
+            loc = message[LOCATION]
+            loc.update({TIMESTAMP: timestamp})
+            locations_list.append(loc)
+    num_unique_locs = 0
+    if test.get_phase_rc(GEOLOCATION) == TEST_SKIPPED:
+        pass
+    elif len(locations_list) == 0:
+        test.set_phase_rc(GEOLOCATION, TEST_FAILED)
+        test.add_phase_reason(GEOLOCATION, 'No coordinates were uploaded')
+    else:
+        test.set_phase_rc(GEOLOCATION, TEST_PASSED)
+        locations_df = pd.DataFrame(locations_list)
+        num_unique_locs = locations_df[['lat', 'lng']].drop_duplicates().shape[0]
+        print(f'Number of unique locations received: {num_unique_locs}')
+
+    # Export all stage data
+    csv_path = os.path.join(ARTIFACTS_DIR, test.dir, f'uplink_{GEOLOCATION}.csv')
+    locations_df.to_csv(csv_path)
+    print(f'\nLocations data saved - {csv_path}')
+    field_functionality_pass_fail_print(test.get_phase_by_name(GEOLOCATION), GEOLOCATION)
+
+    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)
+    all_data_messages_in_test = []
+    all_data_pkts = []
+    for param in test.params:
+        phase_run_print(f"Tested packet type = {param}")
+        dut_mqttc.flush_pkts()
+        # generate pkts and send them using data simulator
+        pkts = []
+        bridge_ids = []
+        if param.value == PIXELS_PKT:
+            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)
+        elif param.value == MGMT_PKT:
+            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)
+        # Generate both sensor data and side info sensor packets
+        elif param.value == SENSOR_PKT:
+            sensor_pkts, bridge_ids = 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,
+                                                   brgs_list=bridge_ids, pkt_type=SIDE_INFO_SENSOR_PKT, indicator=UPLINK_TEST_INDICATOR)
+            pkts = sensor_pkts + si_pkts
+        else:
+            test.rc = TEST_FAILED
+            test.reason = "Invalid test parameter!"
+            break
+
+        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=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)
+
+        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:
+            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)
+    test = cert_common.wiliot_pkts_validation(test, all_data_messages_in_test, all_data_pkts)
+
+    # Geolocation phase
+    if len(all_data_messages_in_test) == 0:
+        test.set_phase_rc(param.name, TEST_FAILED)
+        test.add_phase_reason(param.name, "No messages were received!")
+        return cert_common.test_epilog(test)
+    test = geolocation(test, all_data_messages_in_test)
+
+    return cert_common.test_epilog(test)

{brg_certificate → certificate}/tests/datapath/aging_test/aging_test.json

@@ -13,7 +13,8 @@
     "mandatory": 1,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
-    "internalBridge": 1,
+    "dataSimOnlyTest": 1,
+    "SupportedFromApiVersion": 12,
     "allSupportedValues": ["low_pacer", "high_pacer"]
 
 }

certificate/tests/datapath/aging_test/aging_test.py

@@ -0,0 +1,142 @@
+from certificate.cert_prints import *
+from certificate.cert_defines import *
+from certificate.wlt_types import *
+import certificate.cert_mqtt as cert_mqtt
+import certificate.cert_common as cert_common
+import certificate.cert_config as cert_config
+import certificate.cert_data_sim as cert_data_sim
+
+DEFAULT_NUM_OF_PIXELS = 300
+DEFAULT_DUPLICATES = 4
+DEFAULT_DELAY = 0
+HIGH_PACER_VALUE = 300
+LOW_PACER_VALUE = 15
+TAGS_CTR_UNDER_THRESHOLD = 0.9
+TAGS_CTR_OVER_THRESHOLD = 1.1
+TIME_OFFSET = 15
+
+
+def get_hb_pkt(test):
+    test.get_mqttc_by_target(DUT).flush_pkts()
+    cert_config.send_brg_action(test, ag.ACTION_SEND_HB)
+    test, hb_pkts = cert_common.scan_for_mgmt_pkts(test, [eval_pkt(f'Brg2GwHbV{test.active_brg.api_version}')])
+    tags_ctr = hb_pkts[-1][MGMT_PKT].pkt.tags_ctr if hb_pkts else 0
+    return test, tags_ctr
+
+
+def wait_in_reference_to_start_time(start_time, wait_time):
+    print(f"\nWaiting for {(wait_time - (time.time() - start_time)):.1f} seconds...")
+    while (time.time() - start_time) < wait_time:
+        print_update_wait()
+
+
+def wait_for_zero_pixels(test, wait_time=60):
+    for i in range(int(wait_time / 10)):
+        print(f"\nWaiting {wait_time - (i * 10)} more seconds for pixels table to clear")
+        wait_in_reference_to_start_time(time.time(), 10)
+        test, tags_ctr = get_hb_pkt(test)
+        # tags_ctr will be 0 if the tags table cleared OR if no hb was received - return in both cases
+        if tags_ctr > 0:
+            print(f"\nPixels count: {tags_ctr}")
+            continue
+        return test, tags_ctr
+    test.rc = TEST_FAILED
+    test.add_reason("Floor pixel count value is not zero, make sure there are no pixels (or other energizing devices) around!")
+    return test, tags_ctr
+
+
+def aging_analysis(test, datapath_module, pacer_interval, num_of_sim_tags):
+    # Get tags counter floor
+    test, first_floor_tags_ctr = get_hb_pkt(test)
+    if test.sterile_run and first_floor_tags_ctr > 0:
+        test, first_floor_tags_ctr = wait_for_zero_pixels(test)
+    if test.rc == TEST_FAILED:
+        return test
+    utPrint(f"\nPhase start pixels count: {first_floor_tags_ctr}\n", "BLUE")
+    # Configure bridge pacer interval
+    test = cert_config.brg_configure(test, fields=[BRG_PACER_INTERVAL], values=[pacer_interval], module=datapath_module)[0]
+    if test.rc == TEST_FAILED:
+        return test
+    # Simualtor pixel packets generation
+    cycle_time = DEFAULT_DUPLICATES * (cert_data_sim.PIXEL_SIM_MIN_CYCLE / 1000) * num_of_sim_tags
+    pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=num_of_sim_tags, duplicates=DEFAULT_DUPLICATES,
+                                                   delay=DEFAULT_DELAY, pkt_types=[0], pixels_type=GEN2)
+    sending_time = cycle_time  # Send one cycle of pixel pkts
+    print(f"Simulator starts sending pixel packets for {sending_time} sec")
+    pixel_sim_thread.start()
+    start_time = time.time()
+    wait_in_reference_to_start_time(start_time, wait_time=sending_time)
+    pixel_sim_thread.stop()
+    print("\nSimulator stopped sending pixel packets\n")
+    print(f"\nWaiting for a {TIME_OFFSET} seconds time offset\n")
+    time.sleep(TIME_OFFSET)
+    # Get tags counter peak
+    test, first_peak_tags_ctr = get_hb_pkt(test)
+    if test.rc == TEST_FAILED:
+        return test
+    utPrint(f"\nEnd of pixel simulation pixels count: {first_peak_tags_ctr}\n", "BLUE")
+    if first_peak_tags_ctr - first_floor_tags_ctr < TAGS_CTR_UNDER_THRESHOLD * DEFAULT_NUM_OF_PIXELS:
+        test.rc = TEST_FAILED
+        test.add_reason("Didn't count sufficient amount of pixels.\n"
+                        f"tags_ctr value: {first_peak_tags_ctr}\nNumber of simulated pixels: {DEFAULT_NUM_OF_PIXELS}")
+        return test
+
+    # Waiting the aging time
+    # Throuout the aging time until deletion starts we expect to get the tags_ctr equal to the number of pixels
+    aging_time = max(60, pacer_interval)
+    print(f"Waiting the aging time of {aging_time} seconds")
+
+    # (sending_time - cycle_time + aging_time) is the expected deletion time of the first simulated pixel
+    wait_in_reference_to_start_time(start_time, wait_time=(sending_time - cycle_time + aging_time) - TIME_OFFSET)
+    test, second_peak_tags_ctr = get_hb_pkt(test)
+    if test.rc == TEST_FAILED:
+        return test
+    utPrint(f"\nBefore deletion start pixels count: {second_peak_tags_ctr}\n", "BLUE")
+    if second_peak_tags_ctr < TAGS_CTR_UNDER_THRESHOLD * first_peak_tags_ctr:
+        test.rc = TEST_FAILED
+        test.add_reason("Pixel count is lower than expected. Looks like aging time is too short.\n"
+                        f"Found {second_peak_tags_ctr} tags in hb ctr, Previously got {first_peak_tags_ctr},\n"
+                        f"only {(100 * second_peak_tags_ctr / first_peak_tags_ctr):.1f}% of expected\n")
+        return test
+
+    # (sending_time + aging_time) is the expected deletion time of all simulated pixels
+    wait_in_reference_to_start_time(start_time, wait_time=(sending_time + aging_time) + TIME_OFFSET)
+    test, second_floor_tags_ctr = get_hb_pkt(test)
+    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:
+        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")
+    return test
+
+
+def run(test):
+    # Test prolog
+    datapath_module = test.active_brg.datapath
+    test = cert_common.test_prolog(test)
+    if test.rc == TEST_FAILED:
+        return cert_common.test_epilog(test)
+
+    AGING_TEST_MAP = {"low_pacer": LOW_PACER_VALUE, "high_pacer": HIGH_PACER_VALUE}
+
+    for param in test.params:
+        phase_run_print(param.name)
+        test = aging_analysis(test, datapath_module, pacer_interval=AGING_TEST_MAP[param.value],
+                              num_of_sim_tags=DEFAULT_NUM_OF_PIXELS)
+        cert_mqtt.generate_log_file(test, param.name)
+        field_functionality_pass_fail_print(test, param.name)
+        test.set_phase_rc(param.name, test.rc)
+        test.add_phase_reason(param.name, test.reason)
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+        test.reset_result()  # reset result and continue to next param
+
+    return cert_common.test_epilog(test, revert_brgs=True, modules=[datapath_module])

certificate/tests/datapath/event_ble5_test/event_ble5_test.json

@@ -0,0 +1,17 @@
+{
+    "name": "Event Test BLE 5",
+    "module": "Datapath",
+    "purpose": "Test dynamic pacing for tags that had location events on BLE5 packets",
+    "documentation": ["https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Pacing"],
+    "initialCondition": "Bridge & data simulator configured to defaults",
+    "procedure": ["Test prolog",
+                  "for each supported value - Event Window configuration, Generate pixels packets & scan for packets in the bridge & Compare pacer interval mean per pixel to the simulated tag's pacing.",
+                  "Test epilog and revert to defaults"],
+    "expectedOutcome": "All values configured successfully and actual pacing found matching to the simulated tag's pacing.",
+    "mandatory": 0,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 0,
+    "dataSimOnlyTest": 1,
+    "SupportedFromApiVersion": 13,
+    "allSupportedValues": ["rssi_event", "new_tag_event_seconds", "new_tag_event_minutes", "temp_event", "tx_rate_event"]
+}

certificate/tests/datapath/event_ble5_test/event_ble5_test.py

@@ -0,0 +1,89 @@
+from certificate.cert_prints import *
+from certificate.cert_defines import *
+from certificate.wlt_types import *
+import certificate.cert_mqtt as cert_mqtt
+import certificate.cert_common as cert_common
+import certificate.cert_config as cert_config
+
+NEW_TAG_EVENT_SCAN_TIME = 100             # in seconds
+TAG_EVENT_SCAN_TIME = 60                 # in seconds
+RSSI_MOVEMENT_THRESHOLD = 15
+
+
+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,
+                                            ag.EVENT_TIME_UNIT_MINUTES, ble5_test=True,
+                                            pkt_filter_cfg=ag.PKT_FILTER_TEMP_AND_ADVANCED_PKTS)
+
+
+# In seconds phase we also test the dynamic pacer interval
+def test_new_tag_event_seconds(test, phase, datapath_module):
+    values = [ag.EVENT_TIME_UNIT_SECONDS, TEST_EVENT_WINDOW_SEC_CFG, ag.RX_CHANNEL_10_500K, ag.EVENT_TRIGGER_NEW_TAG,
+              DATA_SIM_EVENT_PACER_INTERVAL_TESTING]
+    return cert_common.run_event_test_phase(test, phase, datapath_module, values, NEW_TAG_EVENT_SCAN_TIME,
+                                            ag.EVENT_TIME_UNIT_SECONDS, ble5_test=True,
+                                            pkt_filter_cfg=ag.PKT_FILTER_TEMP_AND_ADVANCED_PKTS)
+
+
+def test_temp_event(test, phase, datapath_module):
+    values = [ag.EVENT_TIME_UNIT_SECONDS, TEST_TAG_EVENT_WINDOW_CFG, ag.RX_CHANNEL_10_500K, ag.EVENT_TRIGGER_TEMP_CHANGE, 0]
+    return cert_common.run_event_test_phase(test, phase, datapath_module, values, TAG_EVENT_SCAN_TIME, ag.EVENT_TIME_UNIT_SECONDS,
+                                            ble5_test=True, pkt_filter_cfg=ag.PKT_FILTER_TEMP_AND_ADVANCED_PKTS)
+
+
+def test_tx_rate_event(test, phase, datapath_module):
+    values = [ag.EVENT_TIME_UNIT_SECONDS, TEST_TAG_EVENT_WINDOW_CFG, ag.RX_CHANNEL_10_500K, ag.EVENT_TRIGGER_TX_RATE_CHANGE, 0]
+    return cert_common.run_event_test_phase(test, phase, datapath_module, values, TAG_EVENT_SCAN_TIME, ag.EVENT_TIME_UNIT_SECONDS,
+                                            ble5_test=True, pkt_filter_cfg=ag.PKT_FILTER_TEMP_AND_ADVANCED_PKTS)
+
+
+def test_rssi_event(test, phase, datapath_module):
+    values = [ag.EVENT_TIME_UNIT_SECONDS, TEST_TAG_EVENT_WINDOW_CFG, ag.RX_CHANNEL_10_250K, ag.EVENT_TRIGGER_RSSI_CHANGE, 0,
+              RSSI_MOVEMENT_THRESHOLD]
+    return cert_common.run_event_test_phase(test, phase, datapath_module, values, TAG_EVENT_SCAN_TIME, ag.EVENT_TIME_UNIT_SECONDS,
+                                            ble5_test=True, pkt_filter_cfg=ag.PKT_FILTER_TEMP_AND_ADVANCED_PKTS)
+
+
+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,
+                  "temp_event": test_temp_event, "tx_rate_event": test_tx_rate_event}
+
+
+def run(test):
+    # Test prolog
+    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)
+        cert_mqtt.generate_log_file(test, param.name)
+        field_functionality_pass_fail_print(test, param.name)
+        test.set_phase_rc(param.name, test.rc)
+        test.add_phase_reason(param.name, test.reason)
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+            else:
+                test.reset_result()  # reset result and continue to next param
+                continue
+
+        # 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]
+        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)
+            test.add_phase_reason(param.name, test.reason)
+            if test.exit_on_param_failure:
+                break
+        else:
+            test.reset_result()
+
+    return cert_common.test_epilog(test, revert_brgs=True, modules=[dut.datapath], ble5=test.dut_is_bridge())

certificate/tests/datapath/event_test/event_test.json

@@ -0,0 +1,17 @@
+{
+    "name": "Event Test",
+    "module": "Datapath",
+    "purpose": "Test dynamic pacing 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",
+                  "for each supported value - Event Window configuration, Generate pixels packets & scan for packets in the bridge & Compare pacer interval mean per pixel to the simulated tag's pacing.",
+                  "Test epilog and revert to defaults"],
+    "expectedOutcome": "All values configured successfully and actual pacing found matching to the simulated tag's pacing.",
+    "mandatory": 0,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 0,
+    "dataSimOnlyTest": 1,
+    "SupportedFromApiVersion": 13,
+    "allSupportedValues": ["rssi_event", "new_tag_event_seconds", "new_tag_event_minutes", "temp_event", "tx_rate_event"]
+}

certificate/tests/datapath/event_test/event_test.py

@@ -0,0 +1,80 @@
+from certificate.cert_prints import *
+from certificate.cert_defines import *
+from certificate.wlt_types import *
+import certificate.cert_mqtt as cert_mqtt
+import certificate.cert_common as cert_common
+import certificate.cert_config as cert_config
+
+NEW_TAG_EVENT_SCAN_TIME = 100             # in seconds
+TAG_EVENT_SCAN_TIME = 60                 # in seconds
+RSSI_MOVEMENT_THRESHOLD = 15
+
+
+def test_new_tag_event_minutes(test, phase, datapath_module):
+    values = [ag.EVENT_TIME_UNIT_MINUTES, TEST_EVENT_WINDOW_MIN_CFG, ag.RX_CHANNEL_37, ag.EVENT_TRIGGER_NEW_TAG, 0]
+    return cert_common.run_event_test_phase(test, phase, datapath_module, values, NEW_TAG_EVENT_SCAN_TIME, ag.EVENT_TIME_UNIT_MINUTES)
+
+
+# In seconds phase we also test the dynamic pacer interval
+def test_new_tag_event_seconds(test, phase, datapath_module):
+    values = [ag.EVENT_TIME_UNIT_SECONDS, TEST_EVENT_WINDOW_SEC_CFG, ag.RX_CHANNEL_37, ag.EVENT_TRIGGER_NEW_TAG,
+              DATA_SIM_EVENT_PACER_INTERVAL_TESTING]
+    return cert_common.run_event_test_phase(test, phase, datapath_module, values, NEW_TAG_EVENT_SCAN_TIME, ag.EVENT_TIME_UNIT_SECONDS)
+
+
+def test_temp_event(test, phase, datapath_module):
+    values = [ag.EVENT_TIME_UNIT_SECONDS, TEST_TAG_EVENT_WINDOW_CFG, ag.RX_CHANNEL_37, ag.EVENT_TRIGGER_TEMP_CHANGE, 0]
+    return cert_common.run_event_test_phase(test, phase, datapath_module, values, TAG_EVENT_SCAN_TIME, ag.EVENT_TIME_UNIT_SECONDS)
+
+
+def test_tx_rate_event(test, phase, datapath_module):
+    values = [ag.EVENT_TIME_UNIT_SECONDS, TEST_TAG_EVENT_WINDOW_CFG, ag.RX_CHANNEL_37, ag.EVENT_TRIGGER_TX_RATE_CHANGE, 0]
+    return cert_common.run_event_test_phase(test, phase, datapath_module, values, TAG_EVENT_SCAN_TIME, ag.EVENT_TIME_UNIT_SECONDS)
+
+
+def test_rssi_event(test, phase, datapath_module):
+    values = [ag.EVENT_TIME_UNIT_SECONDS, TEST_TAG_EVENT_WINDOW_CFG, ag.RX_CHANNEL_37, ag.EVENT_TRIGGER_RSSI_CHANGE, 0,
+              RSSI_MOVEMENT_THRESHOLD]
+    return cert_common.run_event_test_phase(test, phase, datapath_module, values, TAG_EVENT_SCAN_TIME, ag.EVENT_TIME_UNIT_SECONDS)
+
+
+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,
+                  "temp_event": test_temp_event, "tx_rate_event": test_tx_rate_event}
+
+
+def run(test):
+    # Test prolog
+    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)
+        cert_mqtt.generate_log_file(test, param.name)
+        field_functionality_pass_fail_print(test, param.name)
+        test.set_phase_rc(param.name, test.rc)
+        test.add_phase_reason(param.name, test.reason)
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+            else:
+                test.reset_result()  # reset result and continue to next param
+                continue
+
+        # Reset to defaults after every phase (don't fail the phase on that)
+        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")
+
+        if test.rc == TEST_FAILED:
+            test.set_phase_rc(param.name, test.rc)
+            test.add_phase_reason(param.name, test.reason)
+            if test.exit_on_param_failure:
+                break
+        else:
+            test.reset_result()
+
+    return cert_common.test_epilog(test, revert_brgs=True, modules=[dut.datapath])

{brg_certificate → 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",
@@ -13,6 +13,7 @@
     "mandatory": 1,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
-    "internalBridge": 1,
-    "allSupportedValues": [500, 1000, 2500, 5000]
+    "dataSimOnlyTest": 1,
+    "SupportedFromApiVersion": 12,
+    "allSupportedValues": ["dynamic_parameters", 1000]
 }