wiliot-certificate 4.4.3__py3-none-any.whl → 4.5.0a1__py3-none-any.whl

brg_certificate/config/mosquitto.md

@@ -1,95 +0,0 @@
-
-## Downloading and Running a Mosquitto MQTT Broker Locally
-
-This guide will walk you through the process of downloading and running the Mosquitto MQTT broker on your local machine.
-
-__Step 1:__ Download Mosquitto
-
-For Windows:
-1. Visit the Mosquitto website download page: https://mosquitto.org/download/
-2. Download the latest Windows installer (mosquitto-{version}-install-windows-x64.exe).
-3. Run the installer and follow the installation steps.
-   - <strong style="color:red">IMPORTANT NOTE:</strong> Make sure to check the option to add Mosquitto to your system's PATH during installation!
-4. The default installation path is C:\Program Files\mosquitto.
-
-For Linux (Ubuntu/Debian):
-1. Open the terminal.
-2. Run the following commands to install Mosquitto and the client utilities:
-   ```bash
-   sudo apt update
-   sudo apt install mosquitto mosquitto-clients
-   ```
-
-For macOS:
-1. Install Homebrew if you don’t have it by running:
-   ```bash
-   /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
-   ```
-2. Run the following command to install Mosquitto:
-   ```bash
-   brew install mosquitto
-   ```
-
-__Step 2:__ Start the Mosquitto Broker
-
-For Windows:
-1. Open the Command Prompt or PowerShell.
-2. Navigate to the Mosquitto installation folder, if it’s not added to your PATH:
-   ```bash
-   cd "C:\Program Files\mosquitto"
-   ```
-3. Run the Mosquitto broker:
-   ```bash
-   mosquitto
-   ```
-
-For Linux (Ubuntu/Debian):
-1. Start the Mosquitto service:
-   ```bash
-   sudo systemctl start mosquitto
-   ```
-   Or, to run it manually for testing:
-   ```bash
-   mosquitto -v
-   ```
-
-For macOS:
-1. Start Mosquitto using the terminal:
-   ```bash
-   mosquitto -v
-   ```
-
-__Step 3:__ Test the Mosquitto Broker
-
-You can test the broker by publishing and subscribing to a topic.
-
-Open two terminal windows:
-
-1. In the first window (Subscriber):
-   ```bash
-   mosquitto_sub -t test/topic
-   ```
-
-2. In the second window (Publisher):
-   ```bash
-   mosquitto_pub -t test/topic -m "Hello, MQTT!"
-   ```
-
-If everything works correctly, you should see the message "Hello, MQTT!" in the subscriber window.
-
-__Step 4:__ Enable Mosquitto on Startup (Optional)
-
-For Linux (Ubuntu/Debian):
-To make Mosquitto start automatically on boot:
-```bash
-sudo systemctl enable mosquitto
-```
-
-__Step 5:__ Stop the Mosquitto Broker
-
-To stop the broker, use CTRL+C in the terminal where it’s running or stop the service:
-
-For Linux:
-```bash
-sudo systemctl stop mosquitto
-```

brg_certificate/config/wiliot-dev.json

@@ -1,10 +0,0 @@
-{
-    "customBroker" : true,
-    "port" : 8883,
-    "brokerUrl" : "mqtts://mqtt.us-east-2.dev.wiliot.cloud",
-    "username" : "wiliot",
-    "password" : "wiliot",
-    "updateTopic" : "update-test/wiliot/",
-    "statusTopic" : "status-test/wiliot/",
-    "dataTopic" : "data-test/wiliot/"
-}

brg_certificate/restore_brg.py

@@ -1,61 +0,0 @@
-import sys
-import os
-sys.path.insert(0, os.path.abspath(".."))
-import argparse
-import brg_certificate.cert_common as cert_common
-from brg_certificate.cert_utils import *
-
-os.system('')
-
-def main():
-
-    parser = argparse.ArgumentParser(description='Process some integers.')
-    parser.add_argument('--brg', '-b', required=True, help='Bridge id to restore')
-    parser.add_argument('--gw', '-g', required=True, help='GW id to use')
-    args = parser.parse_args()
-    utPrint(str(args.__dict__))
-
-    mqttc = cert_mqtt.mqttc_init(args.gw, data="sim")
-    brg = Bridge(args.brg)
-    test = WltTest("", args.gw, mqttc, brg0=brg, server="prod")
-
-    utPrint(SEP)
-    utPrint(f"Getting GW {args.gw} Information", "BLUE")
-    response = cert_common.get_gw_info(test)
-    if response == NO_RESPONSE:
-        error = f"ERROR: Didn't get response from {args.gw} !"
-        utPrint(error, "red")
-        sys.exit(-1)
-    else:
-        if ENTRIES in response[GW_INFO]:
-            test.protobuf = True
-
-    utPrint(SEP)
-    utPrint(f"Getting BRG {brg.id_str} interface pkt", "BLUE")
-    test, _ = cert_common.get_module_if_pkt(test)
-    if test.rc == TEST_PASSED:
-        utPrint("Success! Done!", "green")
-        sys.exit(0)
-    else:
-        error = f"ERROR: Didn't get ModuleIfV{test.active_brg.api_version} from BRG:{brg.id_str}!"
-        utPrint(error, "red")
-        # Send restore defaults for 16 seconds
-        test.rc = TEST_PASSED
-        print(f"\nSending {ag.ACTIONS_DICT[ag.ACTION_RESTORE_DEFAULTS]}{test.active_brg.api_version} for 16 seconds")
-        action_pkt = cert_config.get_default_brg_pkt(test, pkt_type=eval_pkt(f'{ag.ACTIONS_DICT[ag.ACTION_RESTORE_DEFAULTS]}{test.active_brg.api_version}'))
-        cert_config.gw_downlink(test, raw_tx_data=action_pkt.dump(), max_retries=cert_config.BLE5_MAX_RETRIES*2)
-
-        print("Waiting for 16*2 seconds broadcast + 30 seconds reboot!")
-        for _ in range(16*2 + 30):
-            print_update_wait(1)
-        test, _ = cert_common.get_module_if_pkt(test)
-        if test.rc == TEST_PASSED:
-            utPrint("Success! Done!", "green")
-            sys.exit(0)
-        else:
-            error = f"ERROR: Still Didn't get ModuleIfV{test.active_brg.api_version} from BRG:{brg.id_str}!"
-            utPrint(error, "red")
-            sys.exit(-1)
-
-if __name__ == "__main__":
-    main()

brg_certificate/tests/calibration/output_power_test/output_power_test.json

@@ -1,16 +0,0 @@
-{
-    "name": "Output Power",
-    "module": "Calibration",
-    "purpose": "Test configuration for all supported calibration output power values",
-    "documentation": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Calibration-Module",
-    "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,
-    "internalBridge": 1,
-    "allSupportedValues": [-12, -8, -4, 0, 2, 3]
-}

brg_certificate/tests/calibration/output_power_test/output_power_test.py

@@ -1,28 +0,0 @@
-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
-
-
-def run(test):
-
-    fields = [BRG_OUTPUT_POWER]
-    calib_module = test.active_brg.calibration
-
-    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], module=calib_module)[0]
-        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, modules=[calib_module])

brg_certificate/tests/datapath/aging_test/aging_test.py

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

brg_certificate/tests/datapath/pacer_interval_tags_count_test/pacer_interval_tags_count_test.json

@@ -1,16 +0,0 @@
-{
-    "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",
-    "procedure": ["Test prolog",
-                  "For each supported value - Pacer interval configuration, Scan for pixel packets in the bridge & Compare maximal amount of received pixels to the amount received with different pacer interval value",
-                  "Test epilog and revert to defaults"],
-    "expectedOutcome": "All values configured successfully and no significant gaps between received amounts of pixels were found",
-    "mandatory": 1,
-    "multiBridgeTest": 0,
-    "gwOnlyTest": 0,
-    "internalBridge": 1,
-    "allSupportedValues": [1, 10, 15, 30]
-}

brg_certificate/tests/datapath/pacer_interval_tags_count_test/pacer_interval_tags_count_test.py

@@ -1,73 +0,0 @@
-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
-
-
-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 = test.active_brg.datapath
-
-    test = cert_common.test_prolog(test)
-    if test.rc == TEST_FAILED:
-        return cert_common.test_epilog(test)
-
-    # Configure the GW to receive tags pkt
-    if test.internal_brg:
-        test = cert_config.brg_configure(test, fields=[BRG_RX_CHANNEL], values=[ag.RX_CHANNEL_37], module=datapath_module, wait=True)[0]
-        if test.rc == TEST_FAILED:
-            return cert_common.test_epilog(test, revert_gws=True)
-
-    num_of_pixels = 200
-    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=num_of_pixels, duplicates=3, delay=0, pkt_types=[0])
-        pixel_sim_thread.start()
-
-    tags_count_per_pacer = {}
-    for param in test.params:
-        test = cert_config.brg_configure(test, fields=fields, values=[param.value, 1], module=datapath_module)[0]
-        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
-        df = cert_common.data_scan(test, scan_time=120, brg_data=True)
-        cert_common.display_data(df, nfpkt=True, tbc=True, name_prefix=f"brg_pacer_tags_count_{param.name}_", dir=test.dir)
-        tags_count_per_pacer[param.value] = df[TAG_ID].nunique()
-        generate_log_file(test, param.name)
-        test.set_phase_rc(param.name, test.rc)
-        test.add_phase_reason(param.name, test.reason)
-        if test.rc == TEST_FAILED and test.exit_on_param_failure:
-            return cert_common.test_epilog(test, revert_brgs=True, revert_gws=test.internal_brg, modules=[datapath_module])
-        else:
-            test.reset_result()
-
-    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)
-
-    print("tags_count_per_pacer: ", tags_count_per_pacer)
-    max_count = max([tags_count_per_pacer[pacer] for pacer in tags_count_per_pacer])
-    for param in test.params:
-        if param.value not in tags_count_per_pacer:
-            test.set_phase_rc(param.name, TEST_FAILED)
-            test.add_phase_reason(param.name, f"param value {param.value} not found in tags_count_per_pacer")
-            continue  # Skip this param because the scan wasn't performed
-        if test.data == DATA_SIMULATION:
-            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
-        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]} "
-                                              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/tx_repetition_algo_test/tx_repetition_algo_test.json

@@ -1,17 +0,0 @@
-{
-    "name": "Tx Repetition Algorithm",
-    "module": "Datapath",
-    "purpose": "Test the tx repetition adjustment algorithm",
-    "documentation": "<TEST_DOCUMENTATION_LINK>",
-    "initialCondition": "Bridge configured to defaults",
-    "procedure": ["Test prolog",
-                  "Configure bridge tx repetition to 0 to activate tx repetition adjustment algorithm, and packets de-dupliction to 0 to enable analysis",
-                  "Scan for packets and examine tx repetitions auto adjustment over time",
-                  "Test epilog and revert to defaults"],
-    "expectedOutcome": "All configurations completed successfully and tx repetition algorithm works as expected",
-    "mandatory": 0,
-    "multiBridgeTest": 0,
-    "gwOnlyTest": 0,
-    "internalBridge": 1,
-    "allSupportedValues": []
-}

brg_certificate/tests/datapath/tx_repetition_algo_test/tx_repetition_algo_test.py

@@ -1,118 +0,0 @@
-# This test runs tx repetitions value = 0 to examine the algo
-# the BRG cfg is meant to stretch the BRG tx queue so the algo is actively changing the tx rep val
-
-from brg_certificate.cert_prints import *
-from brg_certificate.cert_defines import *
-from brg_certificate.wlt_types import *
-import brg_certificate.cert_common as cert_common
-import brg_certificate.cert_config as cert_config
-import os
-import statistics
-import math
-import matplotlib.pyplot as plt
-import plotly.graph_objects as go
-from brg_certificate.cert_gw_sim import DEDUPLICATION_PKTS
-
-SCAN_TIME = 60 * 30
-
-
-def track_tx_rep(test, sorted_database):
-    tx_reps = []
-    times = []
-    for rep in sorted_database:
-        val = sorted_database[rep]
-        tx_reps.append(val[0])
-        times.append(val[1])
-
-    # Plotting the graph
-    plt.plot(times, tx_reps)
-    plt.xlabel(f'Time (total of {SCAN_TIME} seconds)')
-    plt.ylabel('TX Repetitions')
-    plt.title('TX Rep Algo - pkts rep over time')
-    plt.grid(True)
-
-    # Close the Matplotlib plot
-    plt.close()
-
-    # Create a line plot
-    fig = go.Figure()
-    fig.add_trace(go.Scatter(x=times, y=tx_reps, mode='lines'))
-    # Add titles and labels
-    fig.update_layout(
-        title='TX Rep Algo - pkts rep over time',
-        xaxis_title=f'Time (total of {SCAN_TIME} seconds)',
-        yaxis_title='TX Repetitions',
-        showlegend=False,
-        template="plotly_white"
-    )
-
-    # Save the graph as an HTML file
-    html_file_path = os.path.join(test.dir, "tx_rep_algo_graph.html")
-    fig.write_html(html_file_path)
-
-    return test, tx_reps
-
-
-def tx_rep_analysis(test):
-    # Clear data path
-    cert_common.wait_time_n_print(CLEAR_DATA_PATH_TIMEOUT)
-    test.mqttc.flush_pkts()
-
-    # Collect pkts
-    mqtt_scan_wait(test, SCAN_TIME)
-    pkts = cert_mqtt.get_unified_data_pkts(test)
-    print("Found {} unified packets".format(len(pkts)))
-
-    # Count payloads
-    pkt_payload_counter = {}  # idx 0 - payload, idx 1 - payload ts
-    for p in pkts:
-        cur_pkt = p[PAYLOAD]
-        if cur_pkt in pkt_payload_counter:
-            pkt_payload_counter[cur_pkt] = (pkt_payload_counter[cur_pkt][0] + 1, pkt_payload_counter[cur_pkt][1])
-        else:
-            pkt_payload_counter[cur_pkt] = (1, p[TIMESTAMP])
-    generate_log_file(test, "0")
-
-    # Sort the data according to the time value
-    sorted_database = dict(sorted(pkt_payload_counter.items(), key=lambda item: item[1][1]))
-    test, tx_reps = track_tx_rep(test, sorted_database)
-
-    # Calculate total average, top val & min val
-    avg = statistics.mean(tx_reps)
-    ceil = math.ceil(avg)
-    floor = math.floor(avg)
-    print(f"Avraged {avg} repetitions. ceil[{ceil}] floor[{floor}]")
-
-    not_in_range = 0
-    for i in tx_reps:
-        if i > ceil or i < floor:
-            not_in_range += 1
-    if not_in_range:
-        test.rc = TEST_FAILED
-        test.add_reason(f"There are a total of {not_in_range} payloads outside the average (out of {len(tx_reps)})")
-    print(f"total counted tx_reps[{tx_reps}]")
-    return test
-
-
-def run(test):
-
-    test = cert_common.test_prolog(test)
-    if test.rc == TEST_FAILED:
-        return cert_common.test_epilog(test)
-
-    datapath_module = test.active_brg.datapath
-
-    print("Configuring GW")
-    # Set packets deduplication off to count the number of pkts from the BRG
-    cert_config.gw_action(test, f"{DEDUPLICATION_PKTS} 0")
-    if test.rc == TEST_FAILED and test.exit_on_param_failure:
-        return cert_common.test_epilog(test, revert_gws=True)
-
-    test = cert_config.brg_configure(test, fields=[BRG_TX_REPETITION, BRG_PACER_INTERVAL], values=[0, 1], module=datapath_module)[0]
-    if test.rc == TEST_FAILED and test.exit_on_param_failure:
-        return cert_common.test_epilog(test, revert_brgs=True, revert_gws=True, modules=[datapath_module])
-    test = tx_rep_analysis(test)
-
-    # Re-enable unified packets deduplication
-    cert_config.gw_action(test, f"{DEDUPLICATION_PKTS} 1")
-    return cert_common.test_epilog(test, revert_brgs=True, revert_gws=True, modules=[datapath_module])

brg_certificate/tests/edge_mgmt/actions_test/actions_test.json

@@ -1,14 +0,0 @@
-{
-    "name": "Bridge Actions",
-    "module": "Edge Management",
-    "purpose": "Test bridge actions functionality",
-    "documentation": "<TEST_DOCUMENTATION_LINK>",
-    "initialCondition": "Bridge configured to defaults",
-    "procedure": ["Test prolog", "Run all actions and test bridge's response accordingly", "Test epilog"],
-    "expectedOutcome": "Bridge responded as expected to all sent actions",
-    "mandatory": 0,
-    "multiBridgeTest": 0,
-    "gwOnlyTest": 0,
-    "internalBridge": 1,
-    "allSupportedValues": ["ACTION_GW_HB", "ACTION_BLINK", "ACTION_SEND_HB", "ACTION_GET_BATTERY_SENSOR" , "ACTION_GET_POF_DATA", "ACTION_PL_STATUS", "ACTION_GET_MODULE", "ACTION_REBOOT", "ACTION_RESTORE_DEFAULTS"]
-}