wiliot-certificate 1.5.1a1__py3-none-any.whl → 1.5.3a1__py3-none-any.whl

brg_certificate/tests/calibration/pattern_test/pattern_test.py

@@ -8,44 +8,43 @@ import brg_certificate.cert_config as cert_config
 def run(test):
 
     fields = [BRG_PATTERN]
-    calib_module = eval_pkt(f'ModuleCalibrationV{test.active_brg.api_version}')
-    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
+    calib_module = test.active_brg.calibration
+    datapath_module = test.active_brg.datapath
 
     test = cert_common.test_prolog(test)
     if test.rc == TEST_FAILED:
         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

@@ -1,8 +1,7 @@
 {
-    "name": "aging test",
-    "module": "datapath",
-    "purpose": ["verify the functionality of the aging process - Max (60, effective pacer interval)",
-                "verify an edge case - pi = 300"],
+    "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",
@@ -10,7 +9,7 @@
                   "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": "",
+    "expectedOutcome": "Aging mechanism works as expected for low and high pacer intervals",
     "mandatory": 1,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,

brg_certificate/tests/datapath/aging_test/aging_test.py

@@ -11,16 +11,19 @@ def send_get_HB(test):
     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
+        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
+        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):
 
@@ -33,92 +36,96 @@ def combination_func(test, datapath_module, pacer_interval, num_of_sim_tags, agi
         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)
+    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
+    sending_time = cycle_time * 4
     print(f"Simulator send pixels for {sending_time} sec")
     pixel_sim_thread.start()
     start_time = time.time()
-    # sending 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:  
+    for p in HB_list:
         ctr_tags_sending_time.append(p[MGMT_PKT].pkt.tags_ctr)
-    print (f"\nSimulator stop generating packets\n")
-    #TODO: logging print(debug)
+    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 
+
+    # 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):
+    while (time.time() - start_time) < (cycle_time * 3 + aging_time):
         HB_list = send_get_HB(test)
-        for p in HB_list:  
+        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)
+    # 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 
+
+    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(f"Start of deleting time, wait for zero value ")
+    # 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:  
+        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)
+                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   
+                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)
+    # 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. 
+        # 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) 
+    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) 
+    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}')
+    datapath_module = test.active_brg.datapath
     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)
@@ -132,4 +139,4 @@ def run(test):
             test.reset_result()
         time.sleep(5)
 
-    return cert_common.test_epilog(test, revert_brgs=True, revert_gws=False, modules=[datapath_module])
+    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,6 +1,6 @@
 {
-    "name": "num_of_tags_test",
-    "module": "datapath",
+    "name": "Supported Pixels",
+    "module": "Datapath",
     "purpose": "Test pixels handling in the bridge for different amount of pixels",
     "documentation": "<TEST_DOCUMENTATION_LINK>",
     "initialCondition": "Bridge & data simulator configured to defaults",

brg_certificate/tests/datapath/num_of_tags_test/num_of_tags_test.py

@@ -5,11 +5,12 @@ 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}')
+
+    datapath_module = test.active_brg.datapath
     print(f"values: {[param.value for param in test.params]}")
 
     test = cert_common.test_prolog(test)
@@ -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,6 +1,6 @@
 {
-    "name": "output_power_test",
-    "module": "datapath",
+    "name": "Output Power",
+    "module": "Datapath",
     "purpose": "Test configuration for all supported datapath output power values",
     "documentation": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Configuration",
     "initialCondition": "Bridge configured to defaults",

brg_certificate/tests/datapath/output_power_test/output_power_test.py

@@ -4,10 +4,11 @@ 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]
-    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
+    datapath_module = test.active_brg.datapath
 
     test = cert_common.test_prolog(test)
     if test.rc == TEST_FAILED:
@@ -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,7 +1,7 @@
 {
-    "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",
+    "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",

brg_certificate/tests/datapath/pacer_interval_ble5_test/pacer_interval_ble5_test.py

@@ -4,26 +4,29 @@ 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]
-    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
+    datapath_module = test.active_brg.datapath
 
     test = cert_common.test_prolog(test)
     if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
 
     for param in test.params:
-        test = cert_config.brg_configure_ble5(test, fields=fields, values=[param.value, ag.RX_CHANNEL_10_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,6 +1,6 @@
 {
-    "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",
     "documentation": ["https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Pacing"],
     "initialCondition": "Bridge configured to defaults",

brg_certificate/tests/datapath/pacer_interval_tags_count_test/pacer_interval_tags_count_test.py

@@ -4,11 +4,12 @@ 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
 
     fields = [BRG_PACER_INTERVAL, BRG_TX_REPETITION]
-    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
+    datapath_module = test.active_brg.datapath
 
     test = cert_common.test_prolog(test)
     if test.rc == TEST_FAILED:
@@ -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,6 +1,6 @@
 {
-    "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",
     "documentation": ["https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Pacing"],
     "initialCondition": "Bridge & data simulator configured to defaults",

brg_certificate/tests/datapath/pacer_interval_test/pacer_interval_test.py

@@ -4,17 +4,19 @@ 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_PKT_FILTER, BRG_RX_CHANNEL]
-    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
+    datapath_module = test.active_brg.datapath
 
     test = cert_common.test_prolog(test)
     if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
 
     for param in test.params:
-        test = cert_config.brg_configure(test, fields=fields, values=[param.value, ag.PKT_FILTER_TEMP_PKT, ag.RX_CHANNEL_37], module=datapath_module)[0]
+        test = cert_config.brg_configure(test, fields=fields, values=[param.value, ag.PKT_FILTER_TEMP_PKT, ag.RX_CHANNEL_37],
+                                         module=datapath_module)[0]
         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:
@@ -28,7 +30,7 @@ def run(test):
             num_of_pixels = 10
             pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=num_of_pixels, duplicates=3, delay=100, pkt_types=[0])
             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/pattern_test/pattern_test.json

@@ -1,6 +1,6 @@
 {
-    "name": "pattern_test",
-    "module": "datapath",
+    "name": "Pattern",
+    "module": "Datapath",
     "purpose": "Test configuration for all supported communication pattern values",
     "documentation": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Configuration",
     "initialCondition": "Bridge configured to defaults",

brg_certificate/tests/datapath/pattern_test/pattern_test.py

@@ -4,10 +4,11 @@ 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_PATTERN]
-    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
+    datapath_module = test.active_brg.datapath
 
     test = cert_common.test_prolog(test)
     if test.rc == TEST_FAILED:
@@ -25,4 +26,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/pkt_filter_ble5_test/pkt_filter_ble5_test.json

@@ -1,7 +1,7 @@
 {
-    "name": "pkt_filter_test",
-    "module": "datapath",
-    "purpose": "Test packet filter feature configuration and functionality in the bridge for different packet filters using BLE5",
+    "name": "Packet Filter BLE5",
+    "module": "Datapath",
+    "purpose": "Test packet filter feature configuration and functionality in the bridge for different packet filters using BLE_5.0",
     "documentation": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Pacing",
     "initialCondition": "Bridge & data simulator configured to defaults",
     "procedure": ["Test prolog",

brg_certificate/tests/datapath/pkt_filter_ble5_test/pkt_filter_ble5_test.py

@@ -6,6 +6,7 @@ import brg_certificate.cert_config as cert_config
 
 PKT_FILTER_TEST_PACER_INTERVAL = 10
 
+
 def run(test):
 
     fields = [BRG_PKT_FILTER, BRG_RX_CHANNEL, BRG_PACER_INTERVAL]
@@ -15,12 +16,14 @@ def run(test):
     if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
 
-
     for param in test.params:
-        test = cert_config.brg_configure_ble5(test, fields=fields, values=[param.value, RX_CHANNEL_10_250K, PKT_FILTER_TEST_PACER_INTERVAL], module=datapath_module)[0]
+        test = cert_config.brg_configure_ble5(test, fields=fields,
+                                              values=[param.value, RX_CHANNEL_10_250K, PKT_FILTER_TEST_PACER_INTERVAL],
+                                              module=datapath_module)[0]
         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:
+            test.add_reason(f"Failed to configure BRG with {param.name} filter")
             break
         else:
             test.reset_result()
@@ -30,15 +33,19 @@ def run(test):
         if test.data == DATA_SIMULATION:
             # start generating pkts and send them using data simulator
             num_of_pixels = 5
-            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, brg_data=(not test.internal_brg), gw_data=test.internal_brg, scan_time=PKT_FILTER_TEST_PACER_INTERVAL*6, per_pkt_type=True, pkt_filter_cfg=param.value, flush_pkts=True)
+        df = cert_common.data_scan(test, brg_data=(not test.internal_brg), gw_data=test.internal_brg,
+                                   scan_time=PKT_FILTER_TEST_PACER_INTERVAL * 6, per_pkt_type=True,
+                                   pkt_filter_cfg=param.value, flush_pkts=True)
         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)
         cert_common.display_data(df, nfpkt=True, tbc=True, name_prefix=f"{param.name}_", dir=test.dir)
-        test = cert_common.pacing_analysis(test, pacer_interval=PKT_FILTER_TEST_PACER_INTERVAL, df=df, pkt_filter_cfg=param.value, num_of_pixels=num_of_pixels, is_ble5_test=True)
+        test = cert_common.pacing_analysis(test, pacer_interval=PKT_FILTER_TEST_PACER_INTERVAL, df=df, pkt_filter_cfg=param.value,
+                                           num_of_pixels=num_of_pixels, is_ble5_test=True)
         generate_log_file(test, param.name)
         field_functionality_pass_fail_print(test, fields[0], value=param.name)
         test.set_phase_rc(param.name, test.rc)

brg_certificate/tests/datapath/pkt_filter_gen3_test/pkt_filter_gen3_test.json

@@ -1,6 +1,6 @@
 {
-    "name": "pkt_filter_gen3_test",
-    "module": "datapath",
+    "name": "Packet Filter Gen3 Pixels",
+    "module": "Datapath",
     "purpose": "Test the packet filter feature configuration and functionality in the bridge for different packet filters with Gen3 data packets",
     "documentation": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Pacing",
     "initialCondition": "Bridge & data simulator configured to defaults",

brg_certificate/tests/datapath/pkt_filter_gen3_test/pkt_filter_gen3_test.py

@@ -6,22 +6,24 @@ import brg_certificate.cert_config as cert_config
 
 PKT_FILTER_TEST_PACER_INTERVAL = 10
 
+
 def run(test):
 
     # We add the field BRG_RX_CHANNEL so internal BRGs will be configured to channel 37 (default is 39)
     fields = [BRG_PKT_FILTER, BRG_RX_CHANNEL, BRG_PACER_INTERVAL]
-    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
+    datapath_module = test.active_brg.datapath
 
     test = cert_common.test_prolog(test)
     if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
 
-
     for param in test.params:
-        test = cert_config.brg_configure(test, fields=fields, values=[param.value, ag.RX_CHANNEL_37, PKT_FILTER_TEST_PACER_INTERVAL], module=datapath_module)[0]
+        test = cert_config.brg_configure(test, fields=fields, values=[param.value, ag.RX_CHANNEL_37, PKT_FILTER_TEST_PACER_INTERVAL],
+                                         module=datapath_module)[0]
         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:
+            test.add_reason(f"Failed to configure BRG with {param.name} filter")
             break
         else:
             test.reset_result()
@@ -32,16 +34,19 @@ def run(test):
         if test.data == DATA_SIMULATION:
             # start generating pkts and send them using data simulator
             num_of_pixels = 5
-            pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=num_of_pixels, duplicates=2, delay=0, pkt_types=[0,1], pixels_type=GEN3)
+            pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=num_of_pixels, duplicates=2, delay=0,
+                                                           pkt_types=[0, 1], pixels_type=GEN3)
             pixel_sim_thread.start()
-        df = cert_common.data_scan(test, brg_data=(not test.internal_brg), gw_data=test.internal_brg, scan_time=PKT_FILTER_TEST_PACER_INTERVAL*6, per_pkt_type=True,
-                                 pkt_filter_cfg=param.value, flush_pkts=True)
+        df = cert_common.data_scan(test, brg_data=(not test.internal_brg), gw_data=test.internal_brg,
+                                   scan_time=PKT_FILTER_TEST_PACER_INTERVAL * 6, per_pkt_type=True,
+                                   pkt_filter_cfg=param.value, flush_pkts=True)
         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)
         cert_common.display_data(df, nfpkt=True, tbc=True, name_prefix=f"pkt_filter_gen3_{param.name}_", dir=test.dir)
-        test = cert_common.pacing_analysis(test, pacer_interval=PKT_FILTER_TEST_PACER_INTERVAL, df=df, pkt_filter_cfg=param.value, num_of_pixels=num_of_pixels)
+        test = cert_common.pacing_analysis(test, pacer_interval=PKT_FILTER_TEST_PACER_INTERVAL, df=df, pkt_filter_cfg=param.value,
+                                           num_of_pixels=num_of_pixels)
         generate_log_file(test, param.name)
         field_functionality_pass_fail_print(test, fields[0], value=param.name)
         test.set_phase_rc(param.name, test.rc)