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

brg_certificate/tests/datapath/pacer_interval_test/pacer_interval_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_PKT_FILTER, BRG_RX_CHANNEL]
@@ -14,7 +15,8 @@ def run(test):
         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,13 +1,16 @@
 {
-    "name": "pattern_test",
-    "module": "datapath",
-    "purpose": "Test configuration for all supported calibration pattern values",
-    "documentaion": "<TEST_DOCUMENTATION_LINK>",
+    "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",
-    "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": ["DATAPATH_PATTERN_STANDARD", "DATAPATH_PATTERN_38_38_39", "DATAPATH_PATTERN_EU_PATTERN"]
 }

brg_certificate/tests/datapath/pattern_test/pattern_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_PATTERN]
@@ -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,13 +1,19 @@
 {
-    "name": "pkt_filter_test",
-    "module": "datapath",
-    "purpose": "Test packet filter feature configuration and functionality in the bridge for different packet filters using BLE5",
-    "documentaion": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Pacing",
+    "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", "Packet filter & secondary BLE5 rx channel configuration", "Generate pixels packets & scan for packets in the bridge", "Compare pacer interval mean per pixel & packet type to the configured value", "Repeat for all given packet filter values", "Test epilog and revert to defaults"],
+    "procedure": ["Test prolog",
+                  "Packet filter & secondary BLE5 rx channel configuration",
+                  "Generate pixels packets & scan for packets in the bridge",
+                  "Compare pacer interval mean per pixel & packet type to the configured value",
+                  "Repeat for all given packet filter values",
+                  "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": ["PKT_FILTER_RANDOM_FIRST_ARRIVING_PKT", "PKT_FILTER_DISABLE_FORWARDING", "PKT_FILTER_TEMP_PKT", "PKT_FILTER_TEMP_AND_ADVANCED_PKTS", "PKT_FILTER_TEMP_ADVANCED_AND_DEBUG_PKTS"]
 }

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,13 +1,19 @@
 {
-    "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",
-    "documentaion": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Pacing",
+    "documentation": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Pacing",
     "initialCondition": "Bridge & data simulator configured to defaults",
-    "procedure": ["Test prolog", "Packet filter configuration", "Generate Gen3 pixels packets & scan for packets in the bridge", "Compare pacer interval mean per pixel & packet type to the configured value", "Repeat for all given packet filter values", "Test epilog and revert to defaults"],
+    "procedure": ["Test prolog",
+                  "Packet filter configuration",
+                  "Generate Gen3 pixels packets & scan for packets in the bridge",
+                  "Compare pacer interval mean per pixel & packet type to the configured value",
+                  "Repeat for all given packet filter values",
+                  "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": ["PKT_FILTER_RANDOM_FIRST_ARRIVING_PKT", "PKT_FILTER_DISABLE_FORWARDING", "PKT_FILTER_TEMP_PKT", "PKT_FILTER_TEMP_AND_ADVANCED_PKTS"]
 }

brg_certificate/tests/datapath/pkt_filter_gen3_test/pkt_filter_gen3_test.py

@@ -6,6 +6,7 @@ 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)
@@ -16,12 +17,13 @@ def run(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)

brg_certificate/tests/datapath/pkt_filter_test/pkt_filter_test.json

@@ -1,13 +1,19 @@
 {
-    "name": "pkt_filter_test",
-    "module": "datapath",
+    "name": "Packet Filter Gen2 Pixels",
+    "module": "Datapath",
     "purpose": "Test packet filter feature configuration and functionality in the bridge for different packet filters",
-    "documentaion": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Pacing",
+    "documentation": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Pacing",
     "initialCondition": "Bridge & data simulator configured to defaults",
-    "procedure": ["Test prolog", "Packet filter configuration", "Generate pixels packets & scan for packets in the bridge", "Compare pacer interval mean per pixel & packet type to the configured value", "Repeat for all given packet filter values", "Test epilog and revert to defaults"],
+    "procedure": ["Test prolog",
+                  "Packet filter configuration",
+                  "Generate pixels packets & scan for packets in the bridge",
+                  "Compare pacer interval mean per pixel & packet type to the configured value",
+                  "Repeat for all given packet filter values",
+                  "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": ["PKT_FILTER_RANDOM_FIRST_ARRIVING_PKT", "PKT_FILTER_DISABLE_FORWARDING", "PKT_FILTER_TEMP_PKT", "PKT_FILTER_TEMP_AND_ADVANCED_PKTS", "PKT_FILTER_TEMP_ADVANCED_AND_DEBUG_PKTS"]
 }

brg_certificate/tests/datapath/pkt_filter_test/pkt_filter_test.py

@@ -6,6 +6,7 @@ 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)
@@ -16,12 +17,13 @@ def run(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,17 +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,2])
+            pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=num_of_pixels,
+                                                           duplicates=2, delay=0, pkt_types=[0, 1, 2])
             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_{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)
-        # param epilog
+        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)

brg_certificate/tests/datapath/rssi_threshold_test/rssi_threshold_test.json

@@ -1,13 +1,17 @@
 {
-    "name": "rssi_threshold_test",
-    "module": "datapath",
+    "name": "RSSI Threshold",
+    "module": "Datapath",
     "purpose": "Test RSSI threshold configuration and functionality in the bridge",
-    "documentaion": "TODO",
+    "documentation": "<TEST_DOCUMENTATION_LINK>",
     "initialCondition": "Bridge configured to defaults",
-    "procedure": ["Test prolog", "RSSI Threshold configuration", "Checking for packets violating RSSI threshold", "Test epilog and revert to defaults"],
+    "procedure": ["Test prolog",
+                  "RSSI Threshold configuration",
+                  "Checking for packets violating RSSI threshold",
+                  "Test epilog and revert to defaults"],
     "expectedOutcome": "RSSI Threshold configured successfully and no pixel packets with RSSI weaker than the threshold have been echoed.",
     "mandatory": 1,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
+    "internalBridge": 1,
     "allSupportedValues": ["-80", "-65", "-10"]
 }

brg_certificate/tests/datapath/rssi_threshold_test/rssi_threshold_test.py

@@ -4,27 +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 rssi_threshold_analysis(test, df, threshold):
     tags_count = len(list(df[TAG_ID].unique()))
 
     # Filter rows where RSSI is higher than threshold
-    low_rssi_df = df[df[RSSI] >= (-1)*threshold]
+    low_rssi_df = df[df[RSSI] >= (-1) * threshold]
 
     # Extract all tag IDs from those filtered rows
     low_rssi_tag_ids = low_rssi_df[TAG_ID].unique()
     failed_tags = len(low_rssi_tag_ids)
 
     if failed_tags:
-        test.rc =TEST_FAILED
-        print("Tag IDs with RSSI exceeding", (-1)*threshold, ":", low_rssi_tag_ids)
+        test.rc = TEST_FAILED
+        print("Tag IDs with RSSI exceeding", (-1) * threshold, ":", low_rssi_tag_ids)
 
     if test.rc == TEST_FAILED:
-        test.add_reason(f"{failed_tags}/{tags_count} tags rssi violating threshold of {(-1)*threshold}")
+        test.add_reason(f"{failed_tags}/{tags_count} tags rssi violating threshold of {(-1) * threshold}")
         print(test.reason)
     else:
         test.rc = TEST_PASSED
     return test
 
+
 def run(test):
 
     fields = [BRG_RSSI_THRESHOLD]
@@ -33,7 +35,7 @@ def run(test):
     test = cert_common.test_prolog(test)
     if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
-    
+
     # Configure the BRG with RSSI threshold and check for packets violating the threshold
     for param in test.params:
         functionality_run_print(f"test for RSSI threshold of {param.value}")

brg_certificate/tests/datapath/rx_channel_test/rx_channel_test.json

@@ -1,13 +1,16 @@
 {
-    "name": "rx_channel_test",
-    "module": "datapath",
+    "name": "Rx Channel",
+    "module": "Datapath",
     "purpose": "Test configuration for all supported datapath rx channel 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": ["RX_CHANNEL_37", "RX_CHANNEL_38", "RX_CHANNEL_39", "RX_CHANNEL_10_250K", "RX_CHANNEL_10_500K"]
 }

brg_certificate/tests/datapath/rx_channel_test/rx_channel_test.py

@@ -4,18 +4,22 @@ from brg_certificate.wlt_types import *
 import brg_certificate.cert_common as cert_common
 import brg_certificate.cert_config as cert_config
 
+
 def is_primary_channel(channel):
     if channel == ag.RX_CHANNEL_37 or channel == ag.RX_CHANNEL_38 or channel == ag.RX_CHANNEL_39:
         return True
     else:
         return False
 
+
 def run(test):
 
     fields = [BRG_RX_CHANNEL]
     print(test.params)
-    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
-    ble5_state =  False # We use this flag to know whether the BRG is currently in BLE5 mode and needs special configuration next time it is configured
+    datapath_module = cert_common.get_module_by_name(test.active_brg.modules, "Datapath")
+
+    # We use this flag to know whether the BRG is currently in BLE5 mode and needs special configuration next time it is configured
+    ble5_state = False
 
     test = cert_common.test_prolog(test)
     if test.rc == TEST_FAILED:
@@ -38,4 +42,4 @@ def run(test):
         else:
             test.reset_result()
 
-    return cert_common.test_epilog(test, revert_brgs=True, modules=[datapath_module], ble5=ble5_state)
+    return cert_common.test_epilog(test, revert_brgs=True, modules=[datapath_module], ble5=ble5_state)

brg_certificate/tests/datapath/rx_rate_gen2_test/rx_rate_gen2_test.json

@@ -1,9 +1,7 @@
 {
-    "name": "rx_rate_gen2",
-    "module": "DataPath",
-    "purpose": [
-        "Verify the accuracy of the RX rate value"
-    ],
+    "name": "Rx Rate Gen2 Pixels",
+    "module": "Datapath",
+    "purpose": "Verify the accuracy of the RX rate value",
     "documentation": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Pacing",
     "initialCondition": "Bridge set to default configuration",
     "procedure": [
@@ -17,5 +15,6 @@
     "mandatory": 1,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
+    "internalBridge": 1,
     "allSupportedValues": ["mid_values", "diff_pacer", "min_value", "max_value", "diff_rate"]
 }