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

{brg_certificate → certificate}/tests/datapath/num_of_tags_test/num_of_tags_test.py

@@ -1,9 +1,11 @@
 
-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
+from certificate.cert_prints import *
+from certificate.cert_defines import *
+from certificate.wlt_types import *
+import certificate.cert_mqtt as cert_mqtt
+import certificate.cert_common as cert_common
+import certificate.cert_config as cert_config
+import certificate.cert_data_sim as cert_data_sim
 
 GW_CYCLE_TIME = 0.02  # GW sends BLE packet every 20 nsec
 
@@ -41,7 +43,7 @@ def run(test):
             pixel_sim_thread.stop()
             time.sleep(10)
 
-        cert_common.display_data(df, nfpkt=True, name_prefix=f"num_of_tags_{param.name}_", dir=test.dir)
+        cert_common.display_data(df, tbc=True, name_prefix=f"num_of_tags_{param.name}_", dir=test.dir)
 
         num_of_tags = len(df[TAG_ID].unique())
         print(f"Tags from DF: {num_of_tags}")
@@ -49,25 +51,29 @@ def run(test):
         cert_config.send_brg_action(test, ag.ACTION_SEND_HB)
         test, mgmt_pkts = cert_common.scan_for_mgmt_pkts(test, [eval_pkt(f'Brg2GwHbV{test.active_brg.api_version}')])
         if not mgmt_pkts:
-            test.rc = TEST_FAILED
-            test.add_reason("Didn't find ACTION HB pkt")
-            break
+            reason = "Didn't find ACTION HB pkt"
+            utPrint(reason, "RED")
+            test.set_phase_rc(param.name, TEST_FAILED)
+            test.add_phase_reason(param.name, "Didn't find ACTION HB pkt")
+            continue
 
         num_of_tags_HB = mgmt_pkts[0][MGMT_PKT].pkt.tags_ctr
         print(f"Tags from HB: {num_of_tags_HB}\n ")
 
-        cert_common.display_data(df, nfpkt=True, name_prefix=f"num_of_tags_{param.name}_", dir=test.dir)
+        cert_common.display_data(df, tbc=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):
-            test.add_reason(f"Received {num_of_tags} pixels, expected: {param.name} pixels!")
+            test.add_reason(f"Received {num_of_tags} different pixels, expected: {param.name} pixels!")
+            test.rc = TEST_FAILED
 
         # compare the counter tags in the HB packet
         if num_of_tags_HB < 0.95 * param.value or num_of_tags_HB > (param.value + 100):
-            test.add_reason(f"HB counter: {num_of_tags_HB}, expected: {param.name}!")
+            test.add_reason(f"HB counter num_of_tags: {num_of_tags_HB}, expected: {param.name}!")
+            test.rc = TEST_FAILED
         # param epilog
         time.sleep(10)
-        generate_log_file(test, param.name)
+        cert_mqtt.generate_log_file(test, param.name)
         field_functionality_pass_fail_print(test, "num_of_tags", value=param.name)
         test.set_phase_rc(param.name, test.rc)
         test.add_phase_reason(param.name, test.reason)

certificate/tests/datapath/output_power_test/output_power_test.json

@@ -0,0 +1,23 @@
+{
+    "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",
+    "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": 0,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 0,
+    "dataSimOnlyTest": 0,
+    "SupportedFromApiVersion": 13,
+    "allSupportedValues": ["OUTPUT_POWER_2_4_MAX", "OUTPUT_POWER_2_4_MAX_MINUS_2", "OUTPUT_POWER_2_4_MAX_MINUS_3",
+                           "OUTPUT_POWER_2_4_MAX_MINUS_4", "OUTPUT_POWER_2_4_MAX_MINUS_6", "OUTPUT_POWER_2_4_MAX_MINUS_7",
+                           "OUTPUT_POWER_2_4_MAX_MINUS_8", "OUTPUT_POWER_2_4_MAX_MINUS_10", "OUTPUT_POWER_2_4_MAX_MINUS_11",
+                           "OUTPUT_POWER_2_4_MAX_MINUS_12", "OUTPUT_POWER_2_4_MAX_MINUS_14", "OUTPUT_POWER_2_4_MAX_MINUS_15",
+                           "OUTPUT_POWER_2_4_MAX_MINUS_16", "OUTPUT_POWER_2_4_MAX_MINUS_18", "OUTPUT_POWER_2_4_MAX_MINUS_19",
+                           "OUTPUT_POWER_2_4_MAX_MINUS_20", "OUTPUT_POWER_2_4_MAX_MINUS_22", "OUTPUT_POWER_2_4_MAX_MINUS_23",
+                           "OUTPUT_POWER_2_4_MAX_MINUS_26"]
+}

{brg_certificate → certificate}/tests/datapath/output_power_test/output_power_test.py

@@ -1,8 +1,9 @@
-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
+from certificate.cert_prints import *
+from certificate.cert_defines import *
+from certificate.wlt_types import *
+import certificate.cert_mqtt as cert_mqtt
+import certificate.cert_common as cert_common
+import certificate.cert_config as cert_config
 
 
 def run(test):
@@ -15,8 +16,18 @@ def run(test):
         return cert_common.test_epilog(test)
 
     for param in test.params:
+        if not cert_common.output_power_supported(test.active_brg.board_type, param.value):
+            # Skip this parameter if its value isn't supported by the board
+            test.rc = TEST_SKIPPED
+            cert_mqtt.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)
+            test.add_phase_reason(param.name, test.reason)
+            test.reset_result()  # reset result and continue to next param
+            continue
+
         test = cert_config.brg_configure(test, fields=fields, values=[param.value], module=datapath_module)[0]
-        generate_log_file(test, param.name)
+        cert_mqtt.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)
         test.add_phase_reason(param.name, test.reason)

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

@@ -11,6 +11,7 @@
     "mandatory": 0,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
-    "internalBridge": 1,
+    "dataSimOnlyTest": 0,
+    "SupportedFromApiVersion": 12,
     "allSupportedValues": [5, 15, 30, 60]
 }

{brg_certificate → certificate}/tests/datapath/pacer_interval_ble5_test/pacer_interval_ble5_test.py

@@ -1,22 +1,24 @@
-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
+from certificate.cert_prints import *
+from certificate.cert_defines import *
+from certificate.wlt_types import *
+import certificate.cert_mqtt as cert_mqtt
+import certificate.cert_common as cert_common
+import certificate.cert_config as cert_config
+import certificate.cert_data_sim as cert_data_sim
 
 
 def run(test):
 
     fields = [BRG_PACER_INTERVAL, BRG_RX_CHANNEL, BRG_PKT_FILTER]
-    datapath_module = test.active_brg.datapath
+    dut = cert_config.get_brg_by_target(test, DUT)
 
     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(test, fields=fields, values=[param.value, ag.RX_CHANNEL_10_500K, ag.PKT_FILTER_TEMP_PKT],
+                                         module=dut.datapath, ble5=test.dut_is_bridge())[0]
         if test.rc == TEST_FAILED:
             if test.exit_on_param_failure:
                 break  # break the whole for loop and keep the test as failed
@@ -36,9 +38,9 @@ def run(test):
             pixel_sim_thread.stop()
             time.sleep(5)
         cert_mqtt.dump_pkts(test, log=param.name)
-        cert_common.display_data(df, nfpkt=True, tbc=True, name_prefix=f"brg_pacer_{param.name}_", dir=test.dir)
+        cert_common.display_data(df, tbc=True, name_prefix=f"brg_pacer_{param.name}_", dir=test.dir)
         test = cert_common.pacing_analysis(test, df=df, pacer_interval=param.value, num_of_pixels=num_of_pixels)
-        generate_log_file(test, param.name)
+        cert_mqtt.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)
         test.add_phase_reason(param.name, test.reason)
@@ -47,4 +49,4 @@ def run(test):
                 break  # break the whole for loop and keep the test as failed
         test.reset_result()  # reset result and continue to next param
 
-    return cert_common.test_epilog(test, revert_brgs=True, revert_gws=test.internal_brg, modules=[datapath_module], ble5=True)
+    return cert_common.test_epilog(test, revert_brgs=True, revert_gws=test.internal_brg, modules=[dut.datapath], ble5=test.dut_is_bridge())

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

@@ -11,6 +11,7 @@
     "mandatory": 1,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
-    "internalBridge": 1,
+    "dataSimOnlyTest": 0,
+    "SupportedFromApiVersion": 12,
     "allSupportedValues": [5, 10, 15, 30, 60]
 }

{brg_certificate → certificate}/tests/datapath/pacer_interval_test/pacer_interval_test.py

@@ -1,8 +1,10 @@
-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
+from certificate.cert_prints import *
+from certificate.cert_defines import *
+from certificate.wlt_types import *
+import certificate.cert_mqtt as cert_mqtt
+import certificate.cert_common as cert_common
+import certificate.cert_config as cert_config
+import certificate.cert_data_sim as cert_data_sim
 
 
 def run(test):
@@ -38,9 +40,9 @@ def run(test):
             pixel_sim_thread.stop()
             time.sleep(5)
         cert_mqtt.dump_pkts(test, log=param.name)
-        cert_common.display_data(df, nfpkt=True, tbc=True, name_prefix=f"brg_pacer_{param.name}_", dir=test.dir)
+        cert_common.display_data(df, tbc=True, name_prefix=f"brg_pacer_{param.name}_", dir=test.dir)
         test = cert_common.pacing_analysis(test, df=df, pacer_interval=param.value, num_of_pixels=num_of_pixels)
-        generate_log_file(test, param.name)
+        cert_mqtt.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)
         test.add_phase_reason(param.name, test.reason)

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

@@ -11,6 +11,7 @@
     "mandatory": 0,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
-    "internalBridge": 1,
-    "allSupportedValues": ["DATAPATH_PATTERN_STANDARD", "DATAPATH_PATTERN_38_38_39", "DATAPATH_PATTERN_EU_PATTERN"]
+    "dataSimOnlyTest": 0,
+    "SupportedFromApiVersion": 12,
+    "allSupportedValues": ["DATAPATH_PATTERN_STANDARD", "DATAPATH_PATTERN_38_38_39", "DATAPATH_PATTERN_EU_PATTERN", "DATAPATH_PATTERN_EXTENDED_ADV", "DATAPATH_PATTERN_EXTENDED_ADV_38_39", "DATAPATH_PATTERN_EXTENDED_ADV_CH_10"]
 }

{brg_certificate → certificate}/tests/datapath/pattern_test/pattern_test.py

@@ -1,8 +1,9 @@
-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
+from certificate.cert_prints import *
+from certificate.cert_defines import *
+from certificate.wlt_types import *
+import certificate.cert_mqtt as cert_mqtt
+import certificate.cert_common as cert_common
+import certificate.cert_config as cert_config
 
 
 def run(test):
@@ -14,10 +15,17 @@ def run(test):
     if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
 
+    # configure tester to listen to ch39 so we can receive 38-38-39 and euro pattern packets
+    test = cert_config.brg_configure(test, fields=[BRG_RX_CHANNEL], values=[ag.RX_CHANNEL_39],
+                                     module=test.tester.internal_brg.datapath,
+                                     target=TESTER)[0]
+    if test.rc == TEST_FAILED:
+        return cert_common.test_epilog(test)
+
     for param in test.params:
         # Set brg cfg
         test = cert_config.brg_configure(test, fields=fields, values=[param.value], module=datapath_module)[0]
-        generate_log_file(test, param.name)
+        cert_mqtt.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)
         test.add_phase_reason(param.name, test.reason)
@@ -25,4 +33,8 @@ def run(test):
             if test.exit_on_param_failure:
                 break  # break the whole for loop and keep the test as failed
         test.reset_result()  # reset result and continue to next param
+
+    # configure tester to listen to default channel again
+    test = cert_config.brg_configure(test, module=test.tester.internal_brg.datapath, target=TESTER)[0]
+
     return cert_common.test_epilog(test, revert_brgs=True, modules=[datapath_module])

certificate/tests/datapath/pkt_filter_ble5_chl21_test/pkt_filter_ble5_chl21_test.json

@@ -0,0 +1,20 @@
+{
+    "name": "Packet Filter BLE5 Channel 21",
+    "module": "Datapath",
+    "purpose": "Test packet filter feature configuration and functionality in the bridge for different packet filters using BLE_5.0 channel 20",
+    "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"],
+    "expectedOutcome": "All values configured successfully and actual pacing found matching to the configured values",
+    "mandatory": 0,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 0,
+    "dataSimOnlyTest": 0,
+    "SupportedFromApiVersion": 13,
+    "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"]
+}

certificate/tests/datapath/pkt_filter_ble5_chl21_test/pkt_filter_ble5_chl21_test.py

@@ -0,0 +1,61 @@
+from certificate.cert_prints import *
+from certificate.cert_defines import *
+from certificate.ag.wlt_types_ag import *
+import certificate.cert_mqtt as cert_mqtt
+import certificate.cert_common as cert_common
+import certificate.cert_config as cert_config
+import certificate.cert_data_sim as cert_data_sim
+
+PKT_FILTER_TEST_PACER_INTERVAL = 10
+
+
+def run(test):
+
+    fields = [BRG_PKT_FILTER, BRG_RX_CHANNEL, BRG_PACER_INTERVAL]
+    dut = cert_config.get_brg_by_target(test, DUT)
+
+    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, RX_CHANNEL_21, PKT_FILTER_TEST_PACER_INTERVAL],
+                                         module=dut.datapath, ble5=test.dut_is_bridge())[0]
+        test.set_phase_rc(param.name, test.rc)
+        test.add_phase_reason(param.name, test.reason)
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+            else:
+                test.reset_result()  # reset result and continue to next param
+                continue
+        wait_time_n_print(5, txt="Waiting datapath to clear")
+        num_of_pixels = 0
+        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,
+                                                           channel=SECONDARY_RX_CHANNEL_21)
+            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)
+        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, 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)
+        cert_mqtt.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)
+        test.add_phase_reason(param.name, test.reason)
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+        test.reset_result()  # reset result and continue to next param
+
+    return cert_common.test_epilog(test, revert_brgs=True, revert_gws=test.internal_brg, modules=[dut.datapath], ble5=test.dut_is_bridge())

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

@@ -14,6 +14,7 @@
     "mandatory": 0,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
-    "internalBridge": 1,
+    "dataSimOnlyTest": 0,
+    "SupportedFromApiVersion": 12,
     "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 → certificate}/tests/datapath/pkt_filter_ble5_test/pkt_filter_ble5_test.py

@@ -1,8 +1,10 @@
-from brg_certificate.cert_prints import *
-from brg_certificate.cert_defines import *
-from brg_certificate.ag.wlt_types_ag import *
-import brg_certificate.cert_common as cert_common
-import brg_certificate.cert_config as cert_config
+from certificate.cert_prints import *
+from certificate.cert_defines import *
+from certificate.ag.wlt_types_ag import *
+import certificate.cert_mqtt as cert_mqtt
+import certificate.cert_data_sim as cert_data_sim
+import certificate.cert_common as cert_common
+import certificate.cert_config as cert_config
 
 PKT_FILTER_TEST_PACER_INTERVAL = 10
 
@@ -10,16 +12,16 @@ PKT_FILTER_TEST_PACER_INTERVAL = 10
 def run(test):
 
     fields = [BRG_PKT_FILTER, BRG_RX_CHANNEL, BRG_PACER_INTERVAL]
-    datapath_module = eval(f'ModuleDatapathV{test.active_brg.api_version}')
+    dut = cert_config.get_brg_by_target(test, DUT)
 
     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, RX_CHANNEL_10_250K, PKT_FILTER_TEST_PACER_INTERVAL],
-                                              module=datapath_module)[0]
+        test = cert_config.brg_configure(test, fields=fields,
+                                         values=[param.value, RX_CHANNEL_10_500K, PKT_FILTER_TEST_PACER_INTERVAL],
+                                         module=dut.datapath, ble5=test.dut_is_bridge())[0]
         test.set_phase_rc(param.name, test.rc)
         test.add_phase_reason(param.name, test.reason)
         if test.rc == TEST_FAILED:
@@ -28,8 +30,7 @@ def run(test):
             else:
                 test.reset_result()  # reset result and continue to next param
                 continue
-        print("waiting 5 seconds for datapath to clear")
-        print_update_wait(5)
+        wait_time_n_print(5, txt="Waiting datapath to clear")
         num_of_pixels = 0
         if test.data == DATA_SIMULATION:
             # start generating pkts and send them using data simulator
@@ -44,10 +45,10 @@ def run(test):
             # 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)
+        cert_common.display_data(df, 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)
-        generate_log_file(test, param.name)
+        cert_mqtt.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)
         test.add_phase_reason(param.name, test.reason)
@@ -56,4 +57,4 @@ def run(test):
                 break  # break the whole for loop and keep the test as failed
         test.reset_result()  # reset result and continue to next param
 
-    return cert_common.test_epilog(test, revert_brgs=True, revert_gws=test.internal_brg, modules=[datapath_module], ble5=True)
+    return cert_common.test_epilog(test, revert_brgs=True, revert_gws=test.internal_brg, modules=[dut.datapath], ble5=test.dut_is_bridge())

certificate/tests/datapath/pkt_filter_brg2gw_ext_adv_test/pkt_filter_brg2gw_ext_adv_test.json

@@ -0,0 +1,19 @@
+{
+    "name": "Packet Filter BLE5 Using Bridge to Gateway Extended Advertising",
+    "module": "Datapath",
+    "purpose": "Test packet filter feature configuration and functionality in the bridge for different packet filters using BLE_5.0, while the bridge is transmitting in extended advertising",
+    "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 & pattern configuration to bridge to gateway extended advertising",
+                  "Generate pixels packets & scan for packets in the bridge",
+                  "Compare pacer interval mean per pixel & packet type 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": 0,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 0,
+    "dataSimOnlyTest": 0,
+    "SupportedFromApiVersion": 13,
+    "allSupportedValues": ["RX_CHANNEL_37", "RX_CHANNEL_38", "RX_CHANNEL_39", "RX_CHANNEL_10_500K"]
+}

certificate/tests/datapath/pkt_filter_brg2gw_ext_adv_test/pkt_filter_brg2gw_ext_adv_test.py

@@ -0,0 +1,85 @@
+from certificate.cert_prints import *
+from certificate.cert_defines import *
+from certificate.ag.wlt_types_ag import *
+import certificate.cert_mqtt as cert_mqtt
+import certificate.cert_data_sim as cert_data_sim
+import certificate.cert_common as cert_common
+import certificate.cert_config as cert_config
+
+PKT_FILTER_TEST_PACER_INTERVAL = 4
+
+
+def run(test):
+
+    fields = [BRG_PKT_FILTER, BRG_RX_CHANNEL, BRG_PACER_INTERVAL, BRG_PATTERN]
+    dut = cert_config.get_brg_by_target(test, DUT)
+
+    test = cert_common.test_prolog(test)
+    if test.rc == TEST_FAILED:
+        return cert_common.test_epilog(test)
+
+    test = cert_config.brg_configure(test, fields=fields,
+                                     values=[PKT_FILTER_TEMP_AND_ADVANCED_PKTS, RX_CHANNEL_10_500K,
+                                             PKT_FILTER_TEST_PACER_INTERVAL, DATAPATH_PATTERN_EXTENDED_ADV],
+                                     module=dut.datapath, ble5=test.dut_is_bridge())[0]
+    if test.rc == TEST_FAILED:
+        return cert_common.test_epilog(test)
+
+    for param in test.params:
+        # Configure tester's rx channel
+        test = cert_config.brg_configure(test, fields=[BRG_RX_CHANNEL],
+                                         values=[param.value],
+                                         module=test.tester.internal_brg.datapath,
+                                         target=TESTER)[0]
+        test.set_phase_rc(param.name, test.rc)
+        test.add_phase_reason(param.name, test.reason)
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+            else:
+                test.reset_result()  # reset result and continue to next param
+                continue
+
+        # Configure the BRG to DATAPATH_PATTERN_EXTENDED_ADV_CH_10 if the GW listens to channel 10
+        if param.value == RX_CHANNEL_10_500K:
+            test = cert_config.brg_configure(test, fields=fields,
+                                             values=[PKT_FILTER_TEMP_AND_ADVANCED_PKTS, RX_CHANNEL_10_500K,
+                                                     PKT_FILTER_TEST_PACER_INTERVAL, DATAPATH_PATTERN_EXTENDED_ADV_CH_10],
+                                             module=dut.datapath, ble5=test.dut_is_bridge())[0]
+            if test.rc == TEST_FAILED:
+                if test.exit_on_param_failure:
+                    break  # break the whole for loop and keep the test as failed
+            test.reset_result()  # reset result and continue to next param
+
+        wait_time_n_print(5, txt="Waiting datapath to clear")
+        num_of_pixels = 0
+        if test.data == DATA_SIMULATION:
+            # start generating pkts and send them using data simulator
+            num_of_pixels = 50
+            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 * 8, per_pkt_type=True,
+                                   pkt_filter_cfg=PKT_FILTER_TEMP_AND_ADVANCED_PKTS, 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, 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=PKT_FILTER_TEMP_AND_ADVANCED_PKTS,
+                                           num_of_pixels=num_of_pixels, is_ble5_test=True, ext_adv_brg2gw=True)
+        cert_mqtt.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)
+        test.add_phase_reason(param.name, test.reason)
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+        test.reset_result()  # reset result and continue to next param
+
+        # Revert tester's rx channel
+        test = cert_config.brg_configure(test, module=test.tester.internal_brg.datapath, target=TESTER)[0]
+
+    return cert_common.test_epilog(test, revert_brgs=True, modules=[dut.datapath], ble5=test.dut_is_bridge())

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

@@ -14,6 +14,7 @@
     "mandatory": 0,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
-    "internalBridge": 1,
+    "dataSimOnlyTest": 0,
+    "SupportedFromApiVersion": 12,
     "allSupportedValues": ["PKT_FILTER_RANDOM_FIRST_ARRIVING_PKT", "PKT_FILTER_DISABLE_FORWARDING", "PKT_FILTER_TEMP_PKT", "PKT_FILTER_TEMP_AND_ADVANCED_PKTS"]
 }

{brg_certificate → certificate}/tests/datapath/pkt_filter_gen3_test/pkt_filter_gen3_test.py

@@ -1,8 +1,10 @@
-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
+from certificate.cert_prints import *
+from certificate.cert_defines import *
+from certificate.wlt_types import *
+import certificate.cert_mqtt as cert_mqtt
+import certificate.cert_data_sim as cert_data_sim
+import certificate.cert_common as cert_common
+import certificate.cert_config as cert_config
 
 PKT_FILTER_TEST_PACER_INTERVAL = 10
 
@@ -28,8 +30,7 @@ def run(test):
             else:
                 test.reset_result()  # reset result and continue to next param
                 continue
-        print("waiting 5 seconds for datapath to clear")
-        print_update_wait(5)
+        wait_time_n_print(5, txt="Waiting datapath to clear")
 
         num_of_pixels = 0
         if test.data == DATA_SIMULATION:
@@ -45,10 +46,10 @@ def run(test):
             # 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)
+        cert_common.display_data(df, 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)
-        generate_log_file(test, param.name)
+        cert_mqtt.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)
         test.add_phase_reason(param.name, test.reason)

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

@@ -14,6 +14,7 @@
     "mandatory": 0,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
-    "internalBridge": 1,
+    "dataSimOnlyTest": 0,
+    "SupportedFromApiVersion": 12,
     "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 → certificate}/tests/datapath/pkt_filter_test/pkt_filter_test.py

@@ -1,8 +1,10 @@
-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
+from certificate.cert_prints import *
+from certificate.cert_defines import *
+from certificate.wlt_types import *
+import certificate.cert_mqtt as cert_mqtt
+import certificate.cert_data_sim as cert_data_sim
+import certificate.cert_common as cert_common
+import certificate.cert_config as cert_config
 
 PKT_FILTER_TEST_PACER_INTERVAL = 10
 
@@ -28,8 +30,7 @@ def run(test):
             else:
                 test.reset_result()  # reset result and continue to next param
                 continue
-        print("waiting 5 seconds for datapath to clear")
-        print_update_wait(5)
+        wait_time_n_print(5, txt="Waiting datapath to clear")
 
         num_of_pixels = 0
         if test.data == DATA_SIMULATION:
@@ -45,10 +46,10 @@ def run(test):
             # 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)
+        cert_common.display_data(df, 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)
-        generate_log_file(test, param.name)
+        cert_mqtt.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)
         test.add_phase_reason(param.name, test.reason)