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

certificate/tests/edge_mgmt/action_get_module_test/action_get_module_test.py

@@ -0,0 +1,42 @@
+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):
+    test = cert_common.test_prolog(test)
+    if test.rc == TEST_FAILED:
+        return cert_common.test_epilog(test)
+
+    if test.active_brg.board_type in POF_NOT_SUPPORTING_BOARD_TYPES:
+        test.rc = TEST_SKIPPED
+        return cert_common.test_epilog(test)
+    functionality_run_print("action_get_module")
+
+    # CHECK ONLY FOR ONE MODULE (ModuleDatapath) #
+    # send action
+    print("\nCHECK ONLY FOR ModuleDatapath\n")
+    cert_config.send_brg_action(test, ag.ACTION_GET_MODULE, datapath=1)
+    # analysis
+    test = cert_common.search_action_ack(test, ag.ACTION_GET_MODULE, datapath=1)
+    test = cert_common.scan_for_modules(test, [test.active_brg.datapath])
+    if test.rc == TEST_FAILED:
+        return cert_common.test_epilog(test)
+
+    # CHECK FOR ALL MODULES AT ONCE #
+    # send action
+    print("\nCHECK FOR ALL MODULES AT ONCE\n")
+    cert_config.send_brg_action(test, ag.ACTION_GET_MODULE, interface=1, datapath=1, energy2400=1,
+                                energy_sub1g=1, calibration=1, pwr_mgmt=1, ext_sensors=1, custom=1)
+    # analysis
+    test = cert_common.search_action_ack(test, ag.ACTION_GET_MODULE, interface=1, datapath=1, energy2400=1,
+                                         energy_sub1g=1, calibration=1, pwr_mgmt=1, ext_sensors=1, custom=1)
+    test = cert_common.scan_for_modules(test)
+
+    cert_mqtt.generate_log_file(test, "action_get_module")
+    field_functionality_pass_fail_print(test, "action_get_module")
+
+    return cert_common.test_epilog(test)

certificate/tests/edge_mgmt/action_get_pof_data_test/action_get_pof_data_test.json

@@ -0,0 +1,15 @@
+{
+    "name": "Get POF Data Action",
+    "module": "Edge Management",
+    "purpose": "Test get POF data action functionality",
+    "documentation": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Bridge-Modular-Architecture",
+    "initialCondition": "Bridge configured to defaults",
+    "procedure": ["Test prolog", "Send get POF data action and test bridge's response accordingly", "Test epilog"],
+    "expectedOutcome": "Bridge returned an ack for the action, and sent a POF data packet.",
+    "mandatory": 0,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 0,
+    "dataSimOnlyTest": 0,
+    "SupportedFromApiVersion": 12,
+    "allSupportedValues": []
+}

certificate/tests/edge_mgmt/action_get_pof_data_test/action_get_pof_data_test.py

@@ -0,0 +1,44 @@
+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):
+    test = cert_common.test_prolog(test)
+    if test.rc == TEST_FAILED:
+        return cert_common.test_epilog(test)
+
+    if test.active_brg.board_type in POF_NOT_SUPPORTING_BOARD_TYPES:
+        test.rc = TEST_SKIPPED
+        return cert_common.test_epilog(test)
+
+    functionality_run_print("action_get_pof_data")
+
+    # send action
+    cert_config.send_brg_action(test, ag.ACTION_GET_POF_DATA)
+    # analysis
+    test = cert_common.search_action_ack(test, ag.ACTION_GET_POF_DATA)
+    if test.rc == TEST_FAILED:
+        return cert_common.test_epilog(test)
+
+    found_packet = False
+    custom_pkts = cert_mqtt.get_all_custom_pkts(test)
+    for p in custom_pkts:
+        if ("{:02X}{:02X}{:02X}".format(p[UNIFIED_SENSOR_PKT].pkt.sensor_ad_type,
+                                        p[UNIFIED_SENSOR_PKT].pkt.sensor_uuid_msb,
+                                        p[UNIFIED_SENSOR_PKT].pkt.sensor_uuid_lsb) ==
+                f"{ag.SENSOR_SERVICE_ID_POF_DATA:06X}"):
+            print_pkt(p)
+            found_packet = True
+            break
+    if found_packet is False:
+        test.rc = TEST_FAILED
+        test.add_reason("Didn't find pof data packet.")
+
+    cert_mqtt.generate_log_file(test, "action_get_pof_data")
+    field_functionality_pass_fail_print(test, "action_get_pof_data")
+
+    return cert_common.test_epilog(test)

certificate/tests/edge_mgmt/action_gw_hb_test/action_gw_hb_test.json

@@ -0,0 +1,16 @@
+{
+    "name": "GW Heartbeat Action",
+    "module": "Edge Management",
+    "purpose": "Test GW Heartbeat action functionality",
+    "documentation": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Bridge-Modular-Architecture",
+    "initialCondition": "Bridge configured to defaults",
+    "procedure": ["Test prolog", "Send GW HB action and test bridge's response accordingly", "Test epilog"],
+    "expectedOutcome": "Bridge sent a GW HB packet.",
+    "mandatory": 1,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 0,
+    "bridgeOnlyTest": 1,
+    "dataSimOnlyTest": 0,
+    "SupportedFromApiVersion": 12,
+    "allSupportedValues": []
+}

certificate/tests/edge_mgmt/action_gw_hb_test/action_gw_hb_test.py

@@ -0,0 +1,42 @@
+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 random
+
+
+def run(test):
+    test = cert_common.test_prolog(test)
+    if test.rc == TEST_FAILED:
+        return cert_common.test_epilog(test)
+
+    functionality_run_print("action_gw_hb")
+
+    # Create randomized 13 bytes hex to send as the gw
+    randomized_gw = ''.join(f'{b:02X}' for b in bytes([random.randint(0, 255) for _ in range(13)]))
+    randomized_gw = hex_str2int(randomized_gw)
+    # send action
+    cert_config.send_brg_action(test, ag.ACTION_GW_HB, gw_id=randomized_gw)
+    # analysis
+    gw_hb_pkt = eval_pkt(f'ActionGwHbV{test.active_brg.api_version}')
+    test, mgmt_pkts = cert_common.scan_for_mgmt_pkts(test, [gw_hb_pkt])
+    if not mgmt_pkts:
+        test.add_reason("Didn't find ACTION GW HB ACK pkts")
+        test.rc = TEST_FAILED
+    else:
+        for p in mgmt_pkts:
+            if p[MGMT_PKT].pkt.rssi == 0 or randomized_gw != p[MGMT_PKT].pkt.gw_id:
+                if p[MGMT_PKT].pkt.rssi == 0:
+                    print("ERROR: PKT RSSI is zero!")
+                    test.add_reason("RSSI is zero on the ACTION GW HB ACK pkt")
+                else:
+                    print(f"ERROR: GW ID does not match!\nGW_ID: {p[MGMT_PKT].pkt.gw_id}\nrandomized_gw: {randomized_gw}")
+                    test.add_reason("GW ID not found on the ACTION GW HB ACK pkt")
+                test.rc = TEST_FAILED
+
+    cert_mqtt.generate_log_file(test, "action_gw_hb")
+    field_functionality_pass_fail_print(test, "action_gw_hb")
+
+    return cert_common.test_epilog(test)

certificate/tests/edge_mgmt/action_reboot_test/action_reboot_test.json

@@ -0,0 +1,15 @@
+{
+    "name": "Reboot Action",
+    "module": "Edge Management",
+    "purpose": "Test rebot action functionality",
+    "documentation": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Bridge-Modular-Architecture",
+    "initialCondition": "Bridge configured to defaults",
+    "procedure": ["Test prolog", "Configure bridge to non-default configurations, send reboot action, and test bridge's response accordingly", "Test epilog"],
+    "expectedOutcome": "Bridge rebooted properly and kept its configurations.",
+    "mandatory": 1,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 0,
+    "dataSimOnlyTest": 0,
+    "SupportedFromApiVersion": 12,
+    "allSupportedValues": []
+}

certificate/tests/edge_mgmt/action_reboot_test/action_reboot_test.py

@@ -0,0 +1,49 @@
+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):
+    test = cert_common.test_prolog(test)
+    if test.rc == TEST_FAILED:
+        return cert_common.test_epilog(test)
+
+    functionality_run_print("action_reboot")
+
+    # configure tester to listen to ch39 so we can receieve 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)
+    # non-default cfg
+    test = cert_common.brg_non_default_modules_cfg(test)
+    if test.rc == TEST_FAILED and test.exit_on_param_failure:
+        return cert_common.test_epilog(test, revert_brgs=True)
+    # sample non-default cfg_hash
+    test, non_default_hash = cert_common.get_cfg_hash(test)
+    if test.active_brg.cfg_hash == non_default_hash:
+        test.rc = TEST_FAILED
+        test.add_reason(f"Config failed default_hash==non_default==0x{non_default_hash:08X}")
+    if test.rc == TEST_FAILED:
+        return cert_common.test_epilog(test)
+    print(f"\nnon_default_hash: 0x{non_default_hash:08X}\n")
+    # send action
+    cert_config.send_brg_action(test, ag.ACTION_REBOOT)
+    # analysis
+    test = cert_common.reboot_config_analysis(test, expected_hash=non_default_hash, timeout=40)
+    # epilog
+    test = cert_config.config_brg_defaults(test)[0]
+    if test.rc == TEST_FAILED:
+        return cert_common.test_epilog(test)
+
+    # configure tester to listen to default channel again
+    test = cert_config.brg_configure(test, module=test.tester.internal_brg.datapath, target=TESTER)[0]
+
+    cert_mqtt.generate_log_file(test, "action_reboot")
+    field_functionality_pass_fail_print(test, "action_reboot")
+
+    return cert_common.test_epilog(test)

certificate/tests/edge_mgmt/action_restore_defaults_test/action_restore_defaults_test.json

@@ -0,0 +1,15 @@
+{
+    "name": "Restore Defaults Action",
+    "module": "Edge Management",
+    "purpose": "Test restore defaults action functionality",
+    "documentation": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Bridge-Modular-Architecture",
+    "initialCondition": "Bridge configured to defaults",
+    "procedure": ["Test prolog", "Configure bridge to non-default configurations, send restore defaults action, and test bridge's response accordingly", "Test epilog"],
+    "expectedOutcome": "Bridge rebooted properly and restored its default configurations.",
+    "mandatory": 1,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 0,
+    "dataSimOnlyTest": 0,
+    "SupportedFromApiVersion": 13,
+    "allSupportedValues": []
+}

certificate/tests/edge_mgmt/action_restore_defaults_test/action_restore_defaults_test.py

@@ -0,0 +1,102 @@
+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):
+    test = cert_common.test_prolog(test)
+    if test.rc == TEST_FAILED:
+        return cert_common.test_epilog(test)
+
+    functionality_run_print("action_restore_defaults")
+
+    # configure tester to listen to ch39 so we can receieve 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)
+    # non-default cfg
+    test = cert_common.brg_non_default_modules_cfg(test)
+    if test.rc == TEST_FAILED and test.exit_on_param_failure:
+        return cert_common.test_epilog(test, revert_brgs=True)
+    # sample non-default cfg_hash
+    test, non_default_hash = cert_common.get_cfg_hash(test)
+    if test.rc == TEST_FAILED:
+        # revert to defaults without restore_defaults action if action failed
+        test = cert_config.config_brg_defaults(test)[0]
+        return cert_common.test_epilog(test)
+    # send action
+    cert_config.send_brg_action(test, ag.ACTION_RESTORE_DEFAULTS)
+    # analysis
+    expected_hash = test.active_brg.cfg_hash
+    utPrint("Analyzing Restore Defaults", "BLUE")
+    # First 30 for wlt app start + 10 sec extra for brg to settle to recieve its get module action
+    wait_time_n_print(40, txt="Analyzing Restore Defaults")
+
+    start_time = datetime.datetime.now()
+    seq_ids = []
+    cfg_once = True
+    test.get_mqttc_by_target(DUT).flush_pkts()
+
+    utPrint(f"Get Interface Module from BRG {test.active_brg.id_str}")
+    cert_config.send_brg_action(test, ag.ACTION_GET_MODULE, interface=1)
+    test = cert_common.search_action_ack(test, ag.ACTION_GET_MODULE, interface=1)
+    if test.rc == TEST_FAILED:
+        return cert_common.test_epilog(test)
+
+    while True:
+        # scan for ModuleIf pkt of all api versions to support api version change on update
+        mgmt_types = [eval_pkt(f'ModuleIfV{test.active_brg.api_version}')]
+        pkts = cert_mqtt.get_brg2gw_mgmt_pkts(test.get_mqttc_by_target(DUT), test.active_brg, mgmt_types=mgmt_types)
+        for p in pkts:
+            if (not seq_ids or p[SEQUENCE_ID] not in seq_ids):
+                seq_ids.append(p[SEQUENCE_ID])
+                interface = p[MGMT_PKT].pkt
+                if interface:
+                    test.active_brg.api_version = interface.api_version
+                    print(f"\nGot pkt after {(datetime.datetime.now() - start_time).seconds} sec!")
+                    print(interface)
+                    received_hash = interface.cfg_hash
+                    print(f"\nexpected cfg_hash: 0x{expected_hash:08X}\n"
+                          f"received cfg_hash: 0x{received_hash:08X}\n"
+                          f"non_default_hash: 0x{non_default_hash:08X}")
+                    if received_hash == non_default_hash:
+                        # test.rc = TEST_FAILED
+                        test.add_reason("received_hash is equal to non_default_hash, ACTION_RESTORE_DEFAULTS was not received by the brg!")
+                        # return test
+                    elif received_hash == expected_hash:
+                        return cert_common.test_epilog(test)
+                    else:
+                        # Default SUB1G EP in the BRG is 0 and in the UT is 9
+                        # in order to allign BRG cfg to the one after ut.py start script
+                        # we should configure sub1g ep individually once after reboot in case cfg hash dont match
+                        if ag.MODULE_ENERGY_SUB1G in test.active_brg.sup_caps and cfg_once:
+                            cfg_once = False
+                            cfg_pkt = cert_config.get_default_brg_pkt(test,
+                                                                      test.active_brg.energy_sub1g,
+                                                                      **{BRG_PATTERN: ag.SUB1G_ENERGY_PATTERN_ISRAEL})
+                            test = cert_config.brg_configure(test, cfg_pkt=cfg_pkt)[0]
+                            if test.rc == TEST_FAILED:
+                                return cert_common.test_epilog(test)
+                            cert_config.send_brg_action(test, ag.ACTION_GET_MODULE, interface=1)
+        print_update_wait()
+
+        if (datetime.datetime.now() - start_time).seconds > DEFAULT_BRG_FIELD_UPDATE_TIMEOUT:
+            test.rc = TEST_FAILED
+            test.add_reason(f"Didn't receive expected ModuleIfV{test.active_brg.api_version} pkt "
+                            f"after {DEFAULT_BRG_FIELD_UPDATE_TIMEOUT} seconds!")
+            # revert to defaults without restore_defaults action if action failed
+            test = cert_config.config_brg_defaults(test)[0]
+            break
+
+    # configure tester to listen to default channel again
+    test = cert_config.brg_configure(test, module=test.tester.internal_brg.datapath, target=TESTER)[0]
+
+    cert_mqtt.generate_log_file(test, "action_restore_defaults")
+    field_functionality_pass_fail_print(test, "action_restore_defaults")
+
+    return cert_common.test_epilog(test)

certificate/tests/edge_mgmt/action_send_hb_test/action_send_hb_test.json

@@ -0,0 +1,15 @@
+{
+    "name": "Send Heartbeat Action",
+    "module": "Edge Management",
+    "purpose": "Test send Heartbeat action functionality",
+    "documentation": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Bridge-Modular-Architecture",
+    "initialCondition": "Bridge configured to defaults",
+    "procedure": ["Test prolog", "Send HB action and test bridge's response accordingly", "Test epilog"],
+    "expectedOutcome": "Bridge sent a HB packet.",
+    "mandatory": 1,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 0,
+    "dataSimOnlyTest": 0,
+    "SupportedFromApiVersion": 12,
+    "allSupportedValues": []
+}

certificate/tests/edge_mgmt/action_send_hb_test/action_send_hb_test.py

@@ -0,0 +1,45 @@
+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):
+    test = cert_common.test_prolog(test)
+    if test.rc == TEST_FAILED:
+        return cert_common.test_epilog(test)
+
+    functionality_run_print("action_send_hb")
+
+    # send action
+    cert_config.send_brg_action(test, ag.ACTION_SEND_HB)
+    # analysis
+    test, mgmt_pkts = cert_common.scan_for_mgmt_pkts(test, [eval_pkt(f'Brg2GwHbV{test.active_brg.api_version}')])
+    if not mgmt_pkts:
+        test.add_reason("Didn't find ACTION HB pkt")
+        test.rc = TEST_FAILED
+    elif test.active_brg.api_version >= ag.API_VERSION_V13:
+        utPrint("Got HB pkt", "GREEN")
+        algo_tx_rep_val = []
+        for p in mgmt_pkts:
+            algo_tx_rep_val.append(p[MGMT_PKT].pkt.algo_tx_rep)
+        if test.dut_is_combo() and any(val != 0 for val in algo_tx_rep_val):
+            invalid_vals = [val for val in algo_tx_rep_val if val != 0]
+            print(f"ERROR: tx_rep_algo yielded invalid value(s) {invalid_vals} instead of '0' for internal brg!")
+            test.add_reason("Internal's BRG tx_rep_algo isn't working as expected!")
+            test.rc = TEST_FAILED
+        elif test.dut_is_bridge() and any((val < 1 or val > 3) for val in algo_tx_rep_val):
+            invalid_vals = [val for val in algo_tx_rep_val if val < 1 or val > 3]
+            print(f"ERROR: tx_rep_algo yielded invalid value(s) {invalid_vals}!")
+            test.add_reason("BRG's tx_rep_algo isn't working as expected!")
+            test.rc = TEST_FAILED
+        print(f"tx_rep_algo yielded valid value(s) of - {algo_tx_rep_val}")
+    else:
+        utPrint("Got HB pkt, Skipping tx_rep_algo hb field check - API version < V13", "GREEN")
+
+    cert_mqtt.generate_log_file(test, "action_send_hb")
+    field_functionality_pass_fail_print(test, "action_send_hb")
+
+    return cert_common.test_epilog(test)

{brg_certificate → certificate}/tests/edge_mgmt/periodic_msgs_test/periodic_msgs_test.json

@@ -2,13 +2,14 @@
     "name": "Periodic Messages",
     "module": "Edge Management",
     "purpose": "Test periodic messages (heartbeat and interface) sent from the bridge",
-    "documentation": "<TEST_DOCUMENTATION_LINK>",
+    "documentation": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Bridge-Modular-Architecture",
     "initialCondition": "Bridge configured to defaults",
     "procedure": ["Test prolog", "Scan for heartbeat and interface packets", "Test epilog"],
     "expectedOutcome": "Both heartbeat and interface packets received from the bridge within 65 seconds",
     "mandatory": 1,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
-    "internalBridge": 1,
+    "dataSimOnlyTest": 0,
+    "SupportedFromApiVersion": 12,
     "allSupportedValues": []
 }

{brg_certificate → certificate}/tests/edge_mgmt/periodic_msgs_test/periodic_msgs_test.py

@@ -1,7 +1,8 @@
-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
+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
 
 BRG_PER_MSGS_SCAN_TIMEOUT = 65
 
@@ -13,18 +14,28 @@ def scan_for_brg_periodic_msgs(test, timeout=BRG_PER_MSGS_SCAN_TIMEOUT, only_hb=
         for pkt_type in found:
             if pkt_type != HB:
                 found[pkt_type] = True
-    else:  # flash pkts if only_hb=False
-        test.mqttc.flush_pkts()
+    else:  # flush pkts if only_hb=False
+        test.get_mqttc_by_target(DUT).flush_pkts()
 
     start_time = datetime.datetime.now()
     # Search for packets
     while not all(found.values()):
-        if (cert_mqtt.get_brg2gw_mgmt_pkts(test.mqttc, test, mgmt_types=[eval_pkt(f'Brg2GwHbV{test.active_brg.api_version}')]) and
-                not found[HB]):
+        mgmt_types = [eval_pkt(f'Brg2GwHbV{test.active_brg.api_version}')]
+        hb_pkts = cert_mqtt.get_brg2gw_mgmt_pkts(
+            test.get_mqttc_by_target(DUT),
+            test.active_brg,
+            mgmt_types=mgmt_types,
+        )
+        if hb_pkts and not found[HB]:
             found[HB] = True
             print(f"Got HB packet after {(datetime.datetime.now() - start_time).seconds} sec!")
-        if (cert_mqtt.get_brg2gw_mgmt_pkts(test.mqttc, test, mgmt_types=[eval_pkt(f'ModuleIfV{test.active_brg.api_version}')]) and
-                not found[MODULE_IF]):
+        mgmt_types = [eval_pkt(f'ModuleIfV{test.active_brg.api_version}')]
+        module_if_pkts = cert_mqtt.get_brg2gw_mgmt_pkts(
+            test.get_mqttc_by_target(DUT),
+            test.active_brg,
+            mgmt_types=mgmt_types,
+        )
+        if module_if_pkts and not found[MODULE_IF]:
             found[MODULE_IF] = True
             print(f"Got interface module packet after {(datetime.datetime.now() - start_time).seconds} sec!")
         print_update_wait()
@@ -43,6 +54,6 @@ def run(test):
         return cert_common.test_epilog(test)
 
     test = scan_for_brg_periodic_msgs(test)
-    generate_log_file(test, "periodic_msgs")
+    cert_mqtt.generate_log_file(test, "periodic_msgs")
 
     return cert_common.test_epilog(test)

{brg_certificate → certificate}/tests/energy2400/duty_cycle_test/duty_cycle_test.json

@@ -11,6 +11,7 @@
     "mandatory": 0,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
-    "internalBridge": 1,
+    "dataSimOnlyTest": 0,
+    "SupportedFromApiVersion": 12,
     "allSupportedValues": [1, 25, 50, 75]
 }

{brg_certificate → certificate}/tests/energy2400/duty_cycle_test/duty_cycle_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,7 +16,7 @@ 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], module=energy2400_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)

certificate/tests/energy2400/output_power_test/output_power_test.json

@@ -0,0 +1,23 @@
+{
+    "name": "Output Power",
+    "module": "Energizer 2.4GHz",
+    "purpose": "Test configuration for all supported Energizer 2.4GHz output power values",
+    "documentation": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Energizing-2-4Ghz",
+    "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/energy2400/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=energy2400_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/energy2400/pattern_test/pattern_test.json

@@ -11,6 +11,7 @@
     "mandatory": 0,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
-    "internalBridge": 1,
+    "dataSimOnlyTest": 0,
+    "SupportedFromApiVersion": 12,
     "allSupportedValues": ["ENERGY_PATTERN_2_4_NO_ENERGIZING", "ENERGY_PATTERN_2_4_CHANNEL_37", "ENERGY_PATTERN_2_4_CHANNEL_38", "ENERGY_PATTERN_2_4_CHANNEL_39", "ENERGY_PATTERN_2_4_FREQ_2450", "ENERGY_PATTERN_2_4_FREQ_2454"]
 }

{brg_certificate → certificate}/tests/energy2400/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):
@@ -17,7 +18,7 @@ def run(test):
     for param in test.params:
         test = cert_config.brg_configure(test, fields=fields, values=[param.value], module=energy2400_module)[0]
         # param epilog
-        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)

certificate/tests/energy2400/signal_indicator_ble5_test/signal_indicator_ble5_test.json

@@ -0,0 +1,26 @@
+{
+    "name": "Signal Indicator BLE5",
+    "module": "Energizer 2.4GHz",
+    "purpose": "verify Energizer 2.4GHz signal indicator functionality for BLE_5.0 in CHANNEL_10",
+    "documentation": "https://community.wiliot.com/customers/s/article/Bridge-to-Bridge-Signal-Indicator",
+    "initialCondition": "Bridge configured to defaults",
+    "procedure": [
+        "Test prolog",
+        "Configure DUT and TESTER datapath to BLE5 RX channel 10 for the entire test, if DUT is a Bridge only, configure the tx pattern to be extended advertising channel 10 so the tester will receive the packets.",
+        "rssi_threshold - Configure DUT as Signal Indicator Receiver with RSSI threshold (e.g., -25 dBm); configure TESTER as Transmitter; scan and verify all received packets on DUT meet the RSSI threshold",
+        "rx - Configure DUT as Receiver and TESTER as Transmitter; scan and validate expected packet count in DUT; run antenna, output power, and RSSI checks",
+        "tx - Configure DUT as Transmitter; configure TESTER as Receiver; scan and validate expected packet count in TESTER; run antenna, output power, and RSSI checks",
+        "disable_tx - Keep DUT at defaults (TX disabled); configure TESTER as Receiver; scan default duration and verify zero signal indicator packets received",
+        "disable_rx - Keep DUT RX disabled (defaults); configure TESTER as Transmitter; scan and verify DUT receives zero signal indicator packets",
+        "rx_tx - Configure both DUT and TESTER as Signal Indicator RX and TX; scan and validate expected packet counts in both directions; note antenna/output power checks are skipped in this phase",
+        "Revert DUT and TESTER datapath modules to defaults",
+        "Test epilog"
+    ],
+    "expectedOutcome": "All phases passed successfully!",
+    "mandatory": 0,
+    "multiBridgeTest": 1,
+    "gwOnlyTest": 0,
+    "dataSimOnlyTest": 0,
+    "SupportedFromApiVersion": 13,
+    "allSupportedValues": ["rssi_threshold", "rx", "tx", "disable_tx", "disable_rx", "rx_tx"]
+}