wiliot-certificate 1.5.0a1__py3-none-any.whl → 1.5.2a1__py3-none-any.whl

brg_certificate/certificate_sanity_test_list.txt

@@ -1,9 +1,12 @@
 # The certificate should run for every bridge change
-# The setup will include 1 tested BRG + 1 GW connected with UART
-# python ut.py --gw SIM --brg <XXXXXXXXXXXX> --tl certificate_sanity_test_list.txt --data sim --port <COM_PORT>
+# The setup will include 1 tested BRG + 1 GW connected with UART or remotely
+# Run command example with COM PORT connection:
+# python brg_certificate_cli.py --gw SIM --brg <XXXXXXXXXXXX> --tl certificate_sanity_test_list.txt --data sim --port <COM_PORT>
+# Run command example with remote GW connection:
+# python brg_certificate_cli.py --gw <GWYYYYYYYYYYYY> --brg <XXXXXXXXXXXX> --tl certificate_sanity_test_list.txt --data sim
 
 # ------------- edge_mgmt -------------
-edge_mgmt/stat_test
+edge_mgmt/periodic_msgs_test
 edge_mgmt/actions_test ACTION_GW_HB ACTION_BLINK ACTION_SEND_HB ACTION_GET_BATTERY_SENSOR ACTION_GET_POF_DATA ACTION_PL_STATUS ACTION_GET_MODULE ACTION_REBOOT ACTION_RESTORE_DEFAULTS
 
 # ------------- energy2400 -------------
@@ -26,11 +29,15 @@ datapath/pkt_filter_test PKT_FILTER_DISABLE_FORWARDING PKT_FILTER_TEMP_PKT
 datapath/pkt_filter_gen3_test PKT_FILTER_DISABLE_FORWARDING PKT_FILTER_TEMP_PKT
 datapath/pkt_filter_ble5_test PKT_FILTER_DISABLE_FORWARDING PKT_FILTER_TEMP_PKT
 datapath/rx_channel_test RX_CHANNEL_37 RX_CHANNEL_38 RX_CHANNEL_10_250K RX_CHANNEL_10_500K
-datapath/num_of_tags_test 500
+datapath/aging_test low_pacer
 datapath/stress_gen3_test rep1_adaptive_pacer 
+datapath/num_of_tags_test 500
 
 
 # ------------- calibration -------------
 calibration/output_power_test -12 0 3
 calibration/interval_test 1 25 50
-calibration/pattern_test CALIBRATION_PATTERN_38_38_39 CALIBRATION_PATTERN_DISABLE_BEACON
+calibration/pattern_test CALIBRATION_PATTERN_38_38_39 CALIBRATION_PATTERN_DISABLE_BEACON
+
+# ------------- sensors -------------
+sensors/ext_sensor_test tag_data_only rssi_threshold snsr0_scrmbl_snsr1_no_scrmbl

brg_certificate/certificate_test_list.txt

@@ -1,10 +1,12 @@
 # The certificate should run for every bridge change
-# The setup will include 1 tested BRG + 1 GW connected with UART
-# Run command example:
-# python ut.py --gw SIM --brg <XXXXXXXXXXXX> --tl certificate_test_list.txt --data sim --port <COM_PORT>
+# The setup will include 1 tested BRG + 1 GW connected with UART or remotely
+# Run command example with COM PORT connection:
+# python brg_certificate_cli.py --gw SIM --brg <XXXXXXXXXXXX> --tl certificate_test_list.txt --data sim --port <COM_PORT>
+# Run command example with remote GW connection:
+# python brg_certificate_cli.py --gw <GWYYYYYYYYYYYY> --brg <XXXXXXXXXXXX> --tl certificate_test_list.txt --data sim
 
 # ------------- edge_mgmt -------------
-edge_mgmt/stat_test
+edge_mgmt/periodic_msgs_test
 edge_mgmt/actions_test ACTION_GW_HB ACTION_BLINK ACTION_SEND_HB ACTION_GET_BATTERY_SENSOR ACTION_GET_POF_DATA ACTION_PL_STATUS ACTION_GET_MODULE ACTION_REBOOT ACTION_RESTORE_DEFAULTS
 
 # ------------- energy2400 -------------
@@ -12,6 +14,8 @@ energy2400/pattern_test ENERGY_PATTERN_2_4_NO_ENERGIZING ENERGY_PATTERN_2_4_CHAN
 energy2400/output_power_test -12 -8 -4 0 2 3
 energy2400/duty_cycle_test 1 25 50 75
 energy2400/signal_indicator_test internal_brg rssi_threshold brg0_rx_brg1_tx brg0_none_brg1_rx brg0_rxtx_brg1_rxtx brg0_tx_brg1_none
+energy2400/signal_indicator_ble5_10_500k_test internal_brg rssi_threshold brg0_rx_brg1_tx brg0_none_brg1_rx brg0_rxtx_brg1_rxtx brg0_tx_brg1_none
+energy2400/signal_indicator_ble5_10_250k_test internal_brg rssi_threshold brg0_rx_brg1_tx brg0_none_brg1_rx brg0_rxtx_brg1_rxtx brg0_tx_brg1_none
 
 # ------------- energy_sub1g -------------
 energy_sub1g/pattern_test SUB1G_ENERGY_PATTERN_NO_ENERGIZING SUB1G_ENERGY_PATTERN_SINGLE_TONE_915000 SUB1G_ENERGY_PATTERN_FCC_HOPPING SUB1G_ENERGY_PATTERN_SINGLE_TONE_917500 SUB1G_ENERGY_PATTERN_NZ_HOPPING
@@ -21,7 +25,7 @@ energy_sub1g/signal_indicator_test 60,4 100,3
 # ------------- datapath -------------
 datapath/rssi_threshold_test -80 -65 -10
 datapath/pattern_test DATAPATH_PATTERN_38_38_39 DATAPATH_PATTERN_EU_PATTERN
-datapath/tx_repetition_test 2 4
+datapath/tx_repetition_test 2 4 
 datapath/output_power_test -12 -8 -4 0 2 3
 datapath/pacer_interval_test 5 15 30 60
 datapath/pacer_interval_ble5_test 5 15 30 60
@@ -31,13 +35,19 @@ datapath/pkt_filter_ble5_test PKT_FILTER_RANDOM_FIRST_ARRIVING_PKT PKT_FILTER_DI
 datapath/rx_channel_test RX_CHANNEL_37 RX_CHANNEL_38 RX_CHANNEL_39 RX_CHANNEL_10_250K RX_CHANNEL_10_500K
 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/num_of_tags_test 2500
 datapath/pacer_interval_tags_count_test 1 10 15 30
 datapath/stress_test rep3 rep2 rep1 rep1_adaptive_pacer pixel_burst
 datapath/stress_gen3_test rep3 rep2 rep1 rep1_adaptive_pacer pixel_burst
+datapath/aging_test low_pacer high_pacer
+datapath/num_of_tags_test 5000
+
+# ------------- pwr_mgmt -------------
+pwr_mgmt/pwr_mgmt_test
 
 # ------------- calibration -------------
 calibration/output_power_test -12 -8 -4 0 2 3
 calibration/interval_test 1 25 50
 calibration/pattern_test CALIBRATION_PATTERN_38_38_39 CALIBRATION_PATTERN_STANDARD CALIBRATION_PATTERN_EU_PATTERN CALIBRATION_PATTERN_DISABLE_BEACON
 
+# ------------- sensors -------------
+sensors/ext_sensor_test tag_data_only rssi_threshold snsr0_no_scrmbl snsr1_scrmbl snsr0_scrmbl_snsr1_no_scrmbl snsr0_scrmbl_snsr1_scrmbl

brg_certificate/tests/calibration/interval_test/interval_test.json

@@ -1,13 +1,14 @@
 {
-    "name": "interval_test",
-    "module": "calibration",
+    "name": "Interval",
+    "module": "Calibration",
     "purpose": "Test configuration for all supported calibration interval values",
-    "documentaion": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Calibration-Module",
+    "documentation": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Calibration-Module",
     "initialCondition": "Bridge configured to defaults",
     "procedure": ["Test prolog", "Configurations", "Test epilog and revert to defaults"],
     "expectedOutcome": "All values configured successfully",
     "mandatory": 1,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
+    "internalBridge": 1,
     "allSupportedValues": [1, 25, 50, 100, 255]
 }

brg_certificate/tests/calibration/output_power_test/output_power_test.json

@@ -1,13 +1,16 @@
 {
-    "name": "output_power_test",
-    "module": "calibration",
+    "name": "Output Power",
+    "module": "Calibration",
     "purpose": "Test configuration for all supported calibration output power values",
-    "documentaion": "<TEST_DOCUMENTATION_LINK>",
+    "documentation": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Calibration-Module",
     "initialCondition": "Bridge configured to defaults",
-    "procedure": ["Test prolog", "Configurations", "Test epilog and revert to defaults"],
+    "procedure": ["Test prolog",
+                  "For each supported value - configure the BRG and verify the value",
+                  "Test epilog and revert to defaults"],
     "expectedOutcome": "All values configured successfully",
     "mandatory": 1,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
-    "allSupportedValues": ["OUTPUT_POWER_2_4_NEG_12", "OUTPUT_POWER_2_4_NEG_8", "OUTPUT_POWER_2_4_NEG_4", "OUTPUT_POWER_2_4_POS_0", "OUTPUT_POWER_2_4_POS_2", "OUTPUT_POWER_2_4_POS_3"]
+    "internalBridge": 1,
+    "allSupportedValues": [-12, -8, -4, 0, 2, 3]
 }

brg_certificate/tests/calibration/pattern_test/pattern_test.json

@@ -1,13 +1,16 @@
 {
-    "name": "pattern_test",
-    "module": "calibration",
+    "name": "Pattern",
+    "module": "Calibration",
     "purpose": "Test configuration for all supported calibration pattern values",
-    "documentaion": "<TEST_DOCUMENTATION_LINK>",
+    "documentation": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Calibration-Module",
     "initialCondition": "Bridge configured to defaults",
-    "procedure": ["Test prolog", "Configurations and received packets sanity check (for specific patterns)", "Test epilog and revert to defaults"],
+    "procedure": ["Test prolog",
+                  "For each supported value - Configure the BRG and verify packet reception functionality (for specific patterns)",
+                  "Test epilog and revert to defaults"],
     "expectedOutcome": "All values configured successfully and packets received only on included channels. When configuring the brg to CALIBRATION_PATTERN_38_38_39 we configure the GW to rx channel 37 and make sure GW doesn't get any pixels",
     "mandatory": 1,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
+    "internalBridge": 1,
     "allSupportedValues": ["CALIBRATION_PATTERN_STANDARD", "CALIBRATION_PATTERN_38_38_39", "CALIBRATION_PATTERN_EU_PATTERN", "CALIBRATION_PATTERN_DISABLE_BEACON"]
 }

brg_certificate/tests/calibration/pattern_test/pattern_test.py

@@ -16,36 +16,35 @@ def run(test):
         return cert_common.test_epilog(test)
 
     for param in test.params:
-        if param.value == ag.CALIBRATION_PATTERN_38_38_39:
+        # A special verification for 38_38_39, which is irrelevant for bridge with cloud connectivity
+        if param.value == ag.CALIBRATION_PATTERN_38_38_39 and not cert_common.is_bcc_running(test):
             utPrint("\nCALIBRATION_PATTERN_38_38_39 was configured - checking the GW doesn't receive tag packets", "BLUE")
             # Config internal_brg's rx_channel to CHANNEL_37
             test = cert_config.internal_brg_configure(test, fields=[BRG_RX_CHANNEL], values=[ag.RX_CHANNEL_37], module=datapath_module)[0]
-            if test.rc == TEST_FAILED and test.exit_on_param_failure:
-                break
-            # Configure the BRG, wait=False
-            test = cert_config.brg_configure(test, fields=[BRG_PATTERN, BRG_CALIB_INTERVAL],
-                                             values=[param.value, 1], module=calib_module, wait=False)[0]
-            cert_common.wait_time_n_print(CLEAR_DATA_PATH_TIMEOUT)
-            # MQTT scan
-            if test.data == DATA_SIMULATION:
-                # start generating pkts and send them using data simulator
-                pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=10, duplicates=1, delay=100, pkt_types=[0])
-                pixel_sim_thread.start()
-            df = cert_common.data_scan(test, gw_data=True, brg_data=True, scan_time=(40))
-            if test.data == DATA_SIMULATION:
-                # stop generating pkts with data simulator and wait a few seconds for full flush
-                pixel_sim_thread.stop()
-                time.sleep(5)
+            if test.rc != TEST_FAILED:
+                # Configure the BRG, wait=False
+                test = cert_config.brg_configure(test, fields=[BRG_PATTERN, BRG_CALIB_INTERVAL],
+                                                 values=[param.value, 1], module=calib_module, wait=False)[0]
+                cert_common.wait_time_n_print(CLEAR_DATA_PATH_TIMEOUT)
+                # MQTT scan
+                if test.data == DATA_SIMULATION:
+                    # start generating pkts and send them using data simulator
+                    pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=10, duplicates=1, delay=100, pkt_types=[0])
+                    pixel_sim_thread.start()
+                df = cert_common.data_scan(test, gw_data=True, brg_data=True, scan_time=(40))
+                if test.data == DATA_SIMULATION:
+                    # stop generating pkts with data simulator and wait a few seconds for full flush
+                    pixel_sim_thread.stop()
+                    time.sleep(5)
 
-            # Analyze pass/fail
-            gw_tags_pkts = len(df.query('src_id == gw_id'))
-            brg_tags_pkts = len(df.query('src_id != gw_id'))
-            print(f"Found gw_tags_pkts={gw_tags_pkts}, brg_tags_pkts={brg_tags_pkts}")
-            if (gw_tags_pkts == 0 and test.data == DATA_REAL_TAGS) or brg_tags_pkts != 0:
-                test.rc = TEST_FAILED
-                test.add_reason(f"gw_tags_pkts={gw_tags_pkts} brg_tags_pkts={brg_tags_pkts} for BRG 38,38,39 calibration, "
-                                "and GW scanning on ch 37")
-                break
+                # Analyze pass/fail
+                gw_tags_pkts = len(df.query('src_id == gw_id'))
+                brg_tags_pkts = len(df.query('src_id != gw_id'))
+                print(f"Found gw_tags_pkts={gw_tags_pkts}, brg_tags_pkts={brg_tags_pkts}")
+                if (gw_tags_pkts == 0 and test.data == DATA_REAL_TAGS) or brg_tags_pkts != 0:
+                    test.rc = TEST_FAILED
+                    test.add_reason(f"gw_tags_pkts={gw_tags_pkts} brg_tags_pkts={brg_tags_pkts} for BRG 38,38,39 calibration, "
+                                    "and GW scanning on ch 37")
             # Revert internal_brg
             test = cert_config.internal_brg_configure(test, module=datapath_module)[0]
             generate_log_file(test, param.name)

brg_certificate/tests/datapath/aging_test/aging_test.json

@@ -0,0 +1,19 @@
+{
+    "name": "Pixels Aging",
+    "module": "Datapath",
+    "purpose": "verify the functionality of the aging mechanism in the bridge for low and high pacer intervals",
+    "documentation": [],
+    "initialCondition": "Bridge configured to defaults",
+    "procedure": ["Test prolog",
+                  "define simulation with 500 Tags with 0 delay(0.02 sec) ",
+                  "Low pacer - config pacer interval < 60, pi = 15, check ctr tags ,wait aging time, then expect to tags ctr = 0",
+                  "High pacer - config pacer interval > 60, pi = 300, check ctr tags ,wait aging time, then expect to tags ctr = 0",
+                  "Test epilog"],
+    "expectedOutcome": "Aging mechanism works as expected for low and high pacer intervals",
+    "mandatory": 1,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 0,
+    "internalBridge": 1,
+    "allSupportedValues": ["low_pacer", "high_pacer"]
+
+}

brg_certificate/tests/datapath/aging_test/aging_test.py

@@ -0,0 +1,142 @@
+from brg_certificate.cert_prints import *
+from brg_certificate.cert_defines import *
+from brg_certificate.wlt_types import *
+import brg_certificate.cert_common as cert_common
+import brg_certificate.cert_config as cert_config
+import brg_certificate.cert_data_sim as cert_data_sim
+
+
+def send_get_HB(test):
+    cert_config.send_brg_action(test, ag.ACTION_SEND_HB)
+    test, HB_list = cert_common.scan_for_mgmt_pkts(test, [eval_pkt(f'Brg2GwHbV{test.active_brg.api_version}')])
+    return HB_list
+
+
+def calculate_aging_time(pacer_interval):
+    return max(60, pacer_interval)
+
+
+def calculate_sending_time(duplicates, delay, num_of_sim_tags):
+    if delay <= 0.02:
+        return duplicates * 0.02 * num_of_sim_tags
+    else:
+        actual_delay = max(delay, duplicates * ag.PIXEL_SIM_MIN_CYCLE)
+        actual_delay = actual_delay / 1000
+        return actual_delay * num_of_sim_tags
+
+
+def combination_func(test, datapath_module, pacer_interval, num_of_sim_tags, aging_time):
+
+    test = cert_config.brg_configure(test, fields=[BRG_PACER_INTERVAL], values=[pacer_interval], module=datapath_module)[0]
+    if test.rc == TEST_FAILED and test.reason != TEST_PASSED:
+        for i in range(2):
+            if test.rc == TEST_PASSED:
+                return test
+            test = cert_config.brg_configure(test, fields=[BRG_PACER_INTERVAL], values=[pacer_interval], module=datapath_module)[0]
+        test = test.add_reason("Didn't succeed to configure after two attempts - No pkt was found!")
+        return test
+    duplication = 1
+    delay = 0
+    pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=num_of_sim_tags, duplicates=duplication, delay=delay,
+                                                   pkt_types=[0], pixels_type=GEN2)
+    cycle_time = calculate_sending_time(duplication, delay, num_of_sim_tags)
+    sending_time = cycle_time * 4
+    print(f"Simulator send pixels for {sending_time} sec")
+    pixel_sim_thread.start()
+    start_time = time.time()
+    # sending time
+    ctr_tags_sending_time = []
+    while (time.time() - start_time) < sending_time:
+        HB_list = send_get_HB(test)
+
+    pixel_sim_thread.stop()
+    for p in HB_list:
+        ctr_tags_sending_time.append(p[MGMT_PKT].pkt.tags_ctr)
+    print("\nSimulator stop generating packets\n")
+    # TODO: logging print(debug)
+    # print(f"ctr_tags_list: {ctr_tags_sending_time}\n")
+
+    # waiting time - until the aging value
+    # during of the aging time we expect to get the ctr_tags equal to the number of pixels
+    ctr_tags_aging_time = []
+    print(f"waiting for aging time of {aging_time} sec")
+    while (time.time() - start_time) < (cycle_time * 3 + aging_time):
+        HB_list = send_get_HB(test)
+        for p in HB_list:
+            ctr_tags_aging_time.append(p[MGMT_PKT].pkt.tags_ctr)
+    print(f"\naging time: {aging_time} passed\n")
+    # TODO: logging print(debug)
+    # print(f"ctr_tags_list: {ctr_tags_aging_time}\n")
+    start_aging_time = time.time()
+    ctr_tags_deleting_time = []
+
+    found_zero = 0
+    time_finding = 0
+    # stop after two HB packets, we expect to get the ctr_tags 0 in the second HB packet after the aging time
+    print("Start of deleting time, wait for zero value ")
+    while (time.time() - start_aging_time) <= 120:
+        test, HB_list = cert_common.scan_for_mgmt_pkts(test, [eval_pkt(f'Brg2GwHbV{test.active_brg.api_version}')])
+        for p in HB_list:
+            ctr_tags_deleting_time.append(p[MGMT_PKT].pkt.tags_ctr)
+            if p[MGMT_PKT].pkt.tags_ctr == 0:
+                found_zero = 1
+                time_finding = round(time.time() - start_aging_time, 2)
+                print(f"Finding time: {time_finding}")
+                print(f"Found zero value after {time_finding} sec")
+                break
+        if found_zero:
+            break
+    # sending time and the deleting time should be the same
+    print(f"Deleting time: {cycle_time} passed\n")
+    # TODO: logging print(debug)
+    # print(f"Ctr_tags_deleting_time: {ctr_tags_deleting_time}\n")
+
+    # expected to get the ctr_tags 0 in the second HB packet after the aging time
+    if found_zero == 0 or time_finding > 60:
+        test.rc = TEST_FAILED
+        test.add_reason("The last counter value is not zero")
+        print("The last counter value is not zero\n")
+    else:
+        # NOTE: because sometimes when it didn't find HB pkt it failed the test.
+        test.rc = TEST_PASSED
+    return test
+
+
+def low_pacer(test, datapath_module, num_of_sim_tags):
+    pacer_interval = 15
+    aging_time = calculate_aging_time(pacer_interval)
+    test = combination_func(test, datapath_module, pacer_interval=pacer_interval, num_of_sim_tags=num_of_sim_tags, aging_time=aging_time)
+    return test
+
+
+def high_pacer(test, datapath_module, num_of_sim_tags):
+    pacer_interval = 300
+    aging_time = calculate_aging_time(pacer_interval)
+    test = combination_func(test, datapath_module, pacer_interval=pacer_interval, num_of_sim_tags=num_of_sim_tags, aging_time=aging_time)
+    return test
+
+
+def run(test):
+    # Test prolog
+    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
+    test = cert_common.test_prolog(test)
+    if test.rc == TEST_FAILED:
+        return cert_common.test_epilog(test)
+
+    STRESS_TEST_MAP = {"low_pacer": low_pacer, "high_pacer": high_pacer}
+    num_of_pixels = 500
+
+    for param in test.params:
+        functionality_run_print(param.name)
+        test = STRESS_TEST_MAP[param.value](test, datapath_module, num_of_pixels)
+        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 and test.exit_on_param_failure:
+            break
+        else:
+            test.reset_result()
+        time.sleep(5)
+
+    return cert_common.test_epilog(test, revert_brgs=True, revert_gws=False, modules=[datapath_module])

brg_certificate/tests/datapath/num_of_tags_test/num_of_tags_test.json

@@ -1,13 +1,18 @@
 {
-    "name": "num_of_tags_test",
-    "module": "datapath",
+    "name": "Supported Pixels",
+    "module": "Datapath",
     "purpose": "Test pixels handling in the bridge for different amount of pixels",
-    "documentaion": "<TEST_DOCUMENTATION_LINK>",
+    "documentation": "<TEST_DOCUMENTATION_LINK>",
     "initialCondition": "Bridge & data simulator configured to defaults",
-    "procedure": ["Test prolog", "Generate packets from the given amount of pixels & scan for packets in the bridge", "Compare received amount of pixels and the heartbeat pixels counter to the given value","Repeat for all given pixels amounts", "Test epilog and revert to defaults"],
+    "procedure": ["Test prolog",
+                  "Generate packets from the given amount of pixels & scan for packets in the bridge",
+                  "Compare received amount of pixels and the heartbeat pixels counter to the given value",
+                  "Repeat for all given pixels amounts",
+                  "Test epilog and revert to defaults"],
     "expectedOutcome": "All values configured successfully",
     "mandatory": 1,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
-    "allSupportedValues": [500, 1000, 2500]
+    "internalBridge": 1,
+    "allSupportedValues": [500, 1000, 2500, 5000]
 }

brg_certificate/tests/datapath/num_of_tags_test/num_of_tags_test.py

@@ -5,10 +5,11 @@ from brg_certificate.wlt_types import *
 import brg_certificate.cert_common as cert_common
 import brg_certificate.cert_config as cert_config
 
-GW_CYCLE_TIME = 0.02 # GW sends BLE packet every 20 nsec
+GW_CYCLE_TIME = 0.02  # GW sends BLE packet every 20 nsec
+
 
 def run(test):
-    
+
     datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
     print(f"values: {[param.value for param in test.params]}")
 
@@ -26,15 +27,15 @@ def run(test):
         test = cert_config.brg_configure(test, fields=[BRG_PACER_INTERVAL], values=[time_of_sending_pkts], module=datapath_module)[0]
         if test.rc == TEST_FAILED:
             return cert_common.test_epilog(test)
-    
 
         if test.data == DATA_SIMULATION:
             # start generating pkts and send them using data simulator
-            pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=param.value, duplicates=duplicates, delay=0, pkt_types=[0])
+            pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=param.value, duplicates=duplicates,
+                                                           delay=0, pkt_types=[0])
             pixel_sim_thread.start()
 
-        df = cert_common.data_scan(test, scan_time=time_of_sending_pkts+5, brg_data=(not test.internal_brg), gw_data=test.internal_brg)
-        
+        df = cert_common.data_scan(test, scan_time=time_of_sending_pkts + 5, brg_data=(not test.internal_brg), gw_data=test.internal_brg)
+
         if test.data == DATA_SIMULATION:
             # stop generating pkts with data simulator and wait a few seconds for full flush
             pixel_sim_thread.stop()
@@ -57,14 +58,14 @@ def run(test):
 
         cert_common.display_data(df, nfpkt=True, name_prefix=f"num_of_tags_{param.name}_", dir=test.dir)
 
-        # 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):
+        # 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.rc = TEST_FAILED
             test.add_reason(f"Found {num_of_tags} pixels instead of {param.name} pixels!")
             test.add_reason(f"Note - HB was {num_of_tags_HB}")
-            
-        # compare the counter tags in the HB packet 
-        if  num_of_tags_HB < param.value or num_of_tags_HB > (param.value + 100):
+
+        # compare the counter tags in the HB packet
+        if num_of_tags_HB < param.value or num_of_tags_HB > (param.value + 100):
             test.rc = TEST_FAILED
             test.add_reason(f"pixels counter in HB packet is  {num_of_tags_HB} instead of {param.name} pixels!")
             test.add_reason(f"Note - tag counter field = {num_of_tags}")

brg_certificate/tests/datapath/output_power_test/output_power_test.json

@@ -1,13 +1,16 @@
 {
-    "name": "output_power_test",
-    "module": "datapath",
+    "name": "Output Power",
+    "module": "Datapath",
     "purpose": "Test configuration for all supported datapath output power values",
-    "documentaion": "<TEST_DOCUMENTATION_LINK>",
+    "documentation": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Configuration",
     "initialCondition": "Bridge configured to defaults",
-    "procedure": ["Test prolog", "Configurations", "Test epilog and revert to defaults"],
+    "procedure": ["Test prolog",
+                  "For each supported value - configure the BRG and verify the value",
+                  "Test epilog and revert to defaults"],
     "expectedOutcome": "All values configured successfully",
     "mandatory": 1,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
+    "internalBridge": 1,
     "allSupportedValues": [-12, -8, -4, 0, 2, 3]
 }

brg_certificate/tests/datapath/output_power_test/output_power_test.py

@@ -4,6 +4,7 @@ from brg_certificate.wlt_types import *
 import brg_certificate.cert_common as cert_common
 import brg_certificate.cert_config as cert_config
 
+
 def run(test):
 
     fields = [BRG_OUTPUT_POWER]
@@ -24,4 +25,4 @@ def run(test):
         else:
             test.reset_result()
 
-    return cert_common.test_epilog(test, revert_brgs=True, modules=[datapath_module])
+    return cert_common.test_epilog(test, revert_brgs=True, modules=[datapath_module])

brg_certificate/tests/datapath/pacer_interval_ble5_test/pacer_interval_ble5_test.json

@@ -1,13 +1,16 @@
 {
-    "name": "pacer_interval_ble5_test",
-    "module": "datapath",
-    "purpose": "Test pacer interval feature configuration and functionality in the bridge with BLE5 packets for different pacer interval values",
-    "documentaion": "<TEST_DOCUMENTATION_LINK>",
+    "name": "Pacer Interval BLE5",
+    "module": "Datapath",
+    "purpose": "Test pacer interval feature configuration and functionality in the bridge with BLE_5.0 packets for different pacer interval values",
+    "documentation": ["https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Pacing"],
     "initialCondition": "Bridge & data simulator configured to defaults",
-    "procedure": ["Test prolog", "Pacer interval configuration", "Generate GEN3 pixels packets & scan for packets in the bridge", "Compare pacer interval mean per pixel to the configured value", "Repeat for all given pacer interval values", "Test epilog and revert to defaults"],
+    "procedure": ["Test prolog",
+                  "For each supported value - Configure the pacer interval, Generate GEN3 pixels packets & scan for packets in the bridge, Compare pacer interval mean per pixel to the configured value",
+                  "Test epilog and revert to defaults"],
     "expectedOutcome": "All values configured successfully and actual pacing found matching to the configured values",
     "mandatory": 1,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
+    "internalBridge": 1,
     "allSupportedValues": [5, 15, 30, 60]
 }

brg_certificate/tests/datapath/pacer_interval_ble5_test/pacer_interval_ble5_test.py

@@ -4,6 +4,7 @@ from brg_certificate.wlt_types import *
 import brg_certificate.cert_common as cert_common
 import brg_certificate.cert_config as cert_config
 
+
 def run(test):
 
     fields = [BRG_PACER_INTERVAL, BRG_RX_CHANNEL, BRG_PKT_FILTER]
@@ -14,16 +15,18 @@ def run(test):
         return cert_common.test_epilog(test)
 
     for param in test.params:
-        test = cert_config.brg_configure_ble5(test, fields=fields, values=[param.value, ag.RX_CHANNEL_10_250K, ag.PKT_FILTER_TEMP_PKT], module=datapath_module)[0]
+        test = cert_config.brg_configure_ble5(test, fields=fields, values=[param.value, ag.RX_CHANNEL_10_250K, ag.PKT_FILTER_TEMP_PKT],
+                                              module=datapath_module)[0]
         if test.rc == TEST_FAILED and test.exit_on_param_failure:
             break
         num_of_pixels = 0
         if test.data == DATA_SIMULATION:
             # start generating pkts and send them using data simulator
             num_of_pixels = 10
-            pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=num_of_pixels, duplicates=2, delay=0, pkt_types=[2], pixels_type=GEN3_EXTENDED)
+            pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=num_of_pixels, duplicates=2, delay=0,
+                                                           pkt_types=[2], pixels_type=GEN3_EXTENDED)
             pixel_sim_thread.start()
-        df = cert_common.data_scan(test, scan_time=param.value*4, brg_data=(not test.internal_brg), gw_data=test.internal_brg)
+        df = cert_common.data_scan(test, scan_time=param.value * 4, brg_data=(not test.internal_brg), gw_data=test.internal_brg)
         if test.data == DATA_SIMULATION:
             # stop generating pkts with data simulator and wait a few seconds for full flush
             pixel_sim_thread.stop()

brg_certificate/tests/datapath/pacer_interval_tags_count_test/pacer_interval_tags_count_test.json

@@ -1,13 +1,16 @@
 {
-    "name": "pacer_interval_test",
-    "module": "datapath",
+    "name": "Pacer Interval Pixels Count",
+    "module": "Datapath",
     "purpose": "Test pixels handling in the bridge for different pacer interval values",
-    "documentaion": "<TEST_DOCUMENTATION_LINK>",
+    "documentation": ["https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Pacing"],
     "initialCondition": "Bridge configured to defaults",
-    "procedure": ["Test prolog", "Pacer interval configuration", "Scan for pixel packets in the bridge", "Compare maximal amount of received pixels to the amount received with different pacer interval value", "Repeat for all given pacer interval values", "Test epilog and revert to defaults"],
+    "procedure": ["Test prolog",
+                  "For each supported value - Pacer interval configuration, Scan for pixel packets in the bridge & Compare maximal amount of received pixels to the amount received with different pacer interval value",
+                  "Test epilog and revert to defaults"],
     "expectedOutcome": "All values configured successfully and no significant gaps between received amounts of pixels were found",
     "mandatory": 1,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
+    "internalBridge": 1,
     "allSupportedValues": [1, 10, 15, 30]
 }

brg_certificate/tests/datapath/pacer_interval_tags_count_test/pacer_interval_tags_count_test.py

@@ -4,6 +4,7 @@ from brg_certificate.wlt_types import *
 import brg_certificate.cert_common as cert_common
 import brg_certificate.cert_config as cert_config
 
+
 def run(test):
     pacer_threshold = PACER_INTERVAL_THRESHOLD_HIGH if test.private_setup else PACER_INTERVAL_THRESHOLD
 
@@ -52,12 +53,14 @@ def run(test):
     max_count = max([tags_count_per_pacer[pacer] for pacer in tags_count_per_pacer])
     for param in test.params:
         if test.data == DATA_SIMULATION:
-            if tags_count_per_pacer[param.value] != num_of_pixels:
+            if tags_count_per_pacer[param.value] < num_of_pixels * 0.99 or tags_count_per_pacer[param.value] > num_of_pixels * 1.01:
                 test.set_phase_rc(param.name, TEST_FAILED)
                 test.add_phase_reason(param.name, f"received_tags={tags_count_per_pacer[param.value]} num_of_pixels={num_of_pixels}")
-        # make sure minimal received tags number is more than minimal threshold (precentile from max) (diff of less than 3 tags will be accepted anyway)
+        # make sure minimal received tags number is more than minimal threshold (precentile from max)
+        # diff of less than 3 tags will be accepted anyway
         elif tags_count_per_pacer[param.value] < (pacer_threshold * max_count) and (max_count - tags_count_per_pacer[param.value]) > 3:
             test.set_phase_rc(param.name, TEST_FAILED)
-            test.add_phase_reason(param.name, f"received_tags={tags_count_per_pacer[param.value]} max_tags={max_count} less than {int(pacer_threshold * 100)}%")
+            test.add_phase_reason(param.name, f"received_tags={tags_count_per_pacer[param.value]} "
+                                              f"max_tags={max_count} less than {int(pacer_threshold * 100)}%")
 
     return cert_common.test_epilog(test, revert_brgs=True, revert_gws=test.internal_brg, modules=[datapath_module])

brg_certificate/tests/datapath/pacer_interval_test/pacer_interval_test.json

@@ -1,13 +1,16 @@
 {
-    "name": "pacer_interval_test",
-    "module": "datapath",
+    "name": "Pacer Interval",
+    "module": "Datapath",
     "purpose": "Test pacer interval feature configuration and functionality in the bridge for different pacer interval values",
-    "documentaion": "<TEST_DOCUMENTATION_LINK>",
+    "documentation": ["https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Pacing"],
     "initialCondition": "Bridge & data simulator configured to defaults",
-    "procedure": ["Test prolog", "Pacer interval configuration", "Generate pixels packets & scan for packets in the bridge", "Compare pacer interval mean per pixel to the configured value", "Repeat for all given pacer interval values", "Test epilog and revert to defaults"],
+    "procedure": ["Test prolog",
+                  "for each supported value - Pacer interval configuration, Generate pixels packets & scan for packets in the bridge & Compare pacer interval mean per pixel to the configured value",
+                  "Test epilog and revert to defaults"],
     "expectedOutcome": "All values configured successfully and actual pacing found matching to the configured values",
     "mandatory": 1,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
+    "internalBridge": 1,
     "allSupportedValues": [5, 10, 15, 30, 60]
 }