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

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

@@ -1,31 +1,35 @@
 
-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
+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
 import time
 
 
+# input address value and return the TBC value in s
+def address2tbc(address):
+    if address == 0:
+        return 0
+    result = 64 / (256 - address)
+    return result
+
+
 def cal_scan_time(test, delay, pacer_interval):
-    # Calculate the scan time to ensure at least 5 packets are captured in data scan
+    # Calculate the scan time to ensure enough packets are captured in data scan
     # define the num of packet that you want to get
-    num_of_sending_pkt = 2  # actually it will be 3 because the first one always send
+    num_of_cycles = 5
     delay = delay / 1000
     if delay < pacer_interval:
-        scan_time = (pacer_interval * num_of_sending_pkt) + 10
-    elif pacer_interval <= delay:
-        scan_time = (delay * num_of_sending_pkt) + 10
-    # verify scan time value
-    if scan_time < (2 * pacer_interval):
-        print("scan time is too low in related to pacer interval")
-        test.rc == TEST_FAILED
-        test.add_reason("scan time is too low in related to pacer interval value")
+        scan_time = (pacer_interval * num_of_cycles) + 10
+    else:  # pacer_interval <= delay
+        scan_time = (delay * num_of_cycles) + 10
     return test, scan_time
 
 
-def scan_and_compare(test, pacer_interval, delay, expected_address_value):
+def scan_and_compare(test, pacer_interval, delay, expected_TBC_value):
 
     pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=1, duplicates=3, delay=delay, pkt_types=[0], pixels_type=GEN3)
     pixel_sim_thread.start()
@@ -33,7 +37,7 @@ def scan_and_compare(test, pacer_interval, delay, expected_address_value):
     df = cert_common.data_scan(test, scan_time=scan_time, brg_data=(not test.internal_brg), gw_data=test.internal_brg)
     pixel_sim_thread.stop()
     cert_mqtt.dump_pkts(test, log="rx_rate")
-    cert_common.display_data(df, tbc=True, nfpkt=True, rssi=True, dir=test.dir)
+    cert_common.display_data(df, tbc=True, rssi=True, dir=test.dir)
     # check if the dataframe is empty or not
     if len(df) <= 1:
         print("Df is empty")
@@ -53,19 +57,26 @@ def scan_and_compare(test, pacer_interval, delay, expected_address_value):
         if mid_index == 0:
             mid_index = 1
         print(f"Length of df: {length}, mid index: {mid_index}")
-        print(f"df:\n {df}")
-
+        # TODO: Logging print
+        # print(f"Df:\n {df}")
+        df[TBC] = df[TBC].apply(address2tbc)
+        print(f"Df after invert tbc:\n {df}")
         tag = df.iloc[0][TAG_ID]
-        # iloc [1:] to skip the first value of tbc_values which could be 0 sometimes.
-        actual_address_value = round(df.iloc[mid_index:][TBC].mean(), 2)  # extract the tbc value from df
-        print(f"\nactual address value: {actual_address_value}\nexpected address value: {expected_address_value}")
-        THRESHOLD_ADDRESS_VALUE = 5
-        # check if the actual address value is in the range of -+5 of the expected address value
-        if (actual_address_value < (expected_address_value - THRESHOLD_ADDRESS_VALUE) or
-                actual_address_value > (expected_address_value + THRESHOLD_ADDRESS_VALUE)):
-            print(f"\nAddress value for tag {tag} is {actual_address_value}, expected value: {expected_address_value}!\n")
+
+        actual_tbc_value = round(df.iloc[mid_index:][TBC].mean(), 3)
+        expected_tbc_value = round(expected_TBC_value, 3)
+        threshold = 0.1 * expected_tbc_value
+        print(f"Actual TBC value: {actual_tbc_value}")
+        print(f"Expected TBC value: {expected_tbc_value} range: [{expected_tbc_value - threshold}, {expected_tbc_value + threshold}]")
+
+        # Validate the received value is in 10% of the expected value
+        if not ((expected_tbc_value - threshold) <= actual_tbc_value <= (expected_tbc_value + threshold)):
             test.rc = TEST_FAILED
-            test.add_reason(f"Address value for tag {tag} is {actual_address_value} expected: {expected_address_value}!\n")
+            test.add_reason(f"TBC value for tag {tag}: got: {actual_tbc_value}, expected: {expected_tbc_value}!\n")
+            if actual_tbc_value < expected_tbc_value:
+                print(f" Actual TBC value: {actual_tbc_value} is less than expected TBC value: {expected_tbc_value}!\n")
+            if actual_tbc_value > (expected_tbc_value + threshold):
+                print(f" TBC value is higher than expected TBC value: {expected_tbc_value}!\n")
         if test.params == [mid_values] and delay == 1000:
             # checking 0 value in the first packet.
             first_row = df.iloc[0][TBC]
@@ -76,20 +87,22 @@ def scan_and_compare(test, pacer_interval, delay, expected_address_value):
     return test
 
 
-def mid_values(test, datapath_module):
-    # mid values - Sanity check: Generate packets with delays of 1, 5, and 0.5 seconds.
-    # Check address values 192, 243, and 128. Verify that the address value is 0 for the first packet.
-    SANITY_DELAY_ADDRESS_VALUES = {1000: 192, 5000: 243, 500: 128}
-    for delay, expected_address_value in SANITY_DELAY_ADDRESS_VALUES.items():
+def mid_values(test, _):
+    # Mid_values - Sanity check: Generate packets with delays of 1, 5, and 0.5 seconds.
+    # Verify that the correct TBC values are received and that the first packet's TBC is zero.
+
+    SANITY_DELAY_VALUES = [1000, 5000, 500]
+    for delay in SANITY_DELAY_VALUES:
         pacer_interval = 1
-        test = scan_and_compare(test, pacer_interval=pacer_interval, delay=delay, expected_address_value=expected_address_value)
-    time.sleep(2)
+        test = scan_and_compare(test, pacer_interval=pacer_interval, delay=delay, expected_TBC_value=(delay / 1000))
+    time.sleep(10)
     return test
 
 
 def diff_pacer(test, datapath_module):
-    # diff pacer - Generate packets with a 1-second delay and pacer intervals of 30 and 60. Ensure the address value remains 192.
-    SANITY_ADDRESS_VALUE = 192
+    # Diff_pacer - Generate packets with a 1-second delay and pacer intervals of 30 and 60.
+    # Ensure that the TBC value remains unchanged.
+
     PACER_INTERVAL_LIST = [30, 60]
     delay = 1000  # 1 sec
     for pacer_interval in PACER_INTERVAL_LIST:
@@ -97,41 +110,46 @@ def diff_pacer(test, datapath_module):
         if test.rc == TEST_FAILED:
             test.add_reason(f"Didn't succeed to config pacer interval {pacer_interval}")
             return test
-        test = scan_and_compare(test, pacer_interval=pacer_interval, delay=delay, expected_address_value=SANITY_ADDRESS_VALUE)
-    time.sleep(2)
+        test = scan_and_compare(test, pacer_interval=pacer_interval, delay=delay, expected_TBC_value=(delay / 1000))
+    time.sleep(10)
     return test
 
 
 def min_value(test, datapath_module):
-    # min_value -  Minimum value: Generate packets with a 0.1-second delay. Verify that the address value is 1.
-    MIN_ADDRESS_VALUE = 1
+    # Min_value - Minimum value: Generate packets with a 0.1-second delay.
+    # Verify the correct TBC value is received.
+    # NOTE: The min TBC value is 0.25 seconds.
+    MIN_ADDRESS_VALUE = 0.25
     pacer_interval = 1
     test = cert_config.brg_configure(test, fields=[BRG_PACER_INTERVAL], values=[pacer_interval], module=datapath_module)[0]
     if test.rc == TEST_FAILED:
         test.add_reason(f"Didn't succeed to config pacer interval {pacer_interval}")
         return test
     delay = 100
-    test = scan_and_compare(test, pacer_interval=pacer_interval, delay=delay, expected_address_value=MIN_ADDRESS_VALUE)
-    time.sleep(2)
+    test = scan_and_compare(test, pacer_interval=pacer_interval, delay=delay, expected_TBC_value=MIN_ADDRESS_VALUE)
+    time.sleep(10)
     return test
 
 
 def max_value(test, datapath_module):
-    # max value - Maximum value: Generate packets with a 70-second delay and a pacer interval of 80. Verify that the address value is 255.
-    MAX_ADDRESS_VALUE = 255
+    # Max_value - Maximum value: Generate packets with a 70-second delay and a pacer interval of 80.
+    # Verify the correct TBC value is received.
+    # NOTE: The max TBC value is 64 seconds.
+    MAX_TBC_VALUE = 64
     pacer_interval = 80
     test = cert_config.brg_configure(test, fields=[BRG_PACER_INTERVAL], values=[pacer_interval], module=datapath_module)[0]
     if test.rc == TEST_FAILED:
         test.add_reason(f"Didn't succeed to config pacer interval {pacer_interval}")
         return test
     delay = 70000
-    test = scan_and_compare(test, pacer_interval=pacer_interval, delay=delay, expected_address_value=MAX_ADDRESS_VALUE)
-    time.sleep(2)
+    test = scan_and_compare(test, pacer_interval=pacer_interval, delay=delay, expected_TBC_value=MAX_TBC_VALUE)
+    time.sleep(10)
     return test
 
 
 def diff_rate(test, datapath_module):
-    # diff rate - a filter: Generate packets with delay 1 and change to 5, according the delay change test the tolerance address value
+    # Diff_rate - alpha filter: Generate packets with delay 0.5 second and change to 3 seconds.
+    # Verify that the TBC value changes according to the delay, within the expected tolerance.
     pacer_interval = 1
     delay_duration = [[500, 5], [3000, 3]]
     first_delay = delay_duration[0][0]
@@ -148,41 +166,63 @@ def diff_rate(test, datapath_module):
     print(f"sleep for {time_sleep} sec\n")
     time.sleep(time_sleep)
     pixel_sim_thread.delay = second_delay
-    scan_time = sum(duration for _, duration in delay_duration) + 20
+    scan_time = sum(duration for _, duration in delay_duration) + 40
     df = cert_common.data_scan(test, scan_time=scan_time, brg_data=(not test.internal_brg), gw_data=test.internal_brg)
     pixel_sim_thread.stop()
     df = df[[TAG_ID, TBC]]
-    lenght = len(df)
-
+    # TODO: logging print
+    # print(f"df:\n {df}")
+    df[TBC] = df[TBC].apply(address2tbc)
     if len(df) <= 1:
         test.add_reason("Df is empty")
         test.rc = TEST_FAILED
         return test
     else:
         print(f"Df:\n {df}")
-    # NOTE: all next rows are specific for the values: delay 0.5 and 3, and in relation address values 128 and 235
-    # check if the last tbc value is as we expected  for delay 3 sec we need to get 235 according to LUT  table
+    # NOTE: all next rows are specific for the values: delay 0.5 and 3 sec.
+    # check if the last tbc value is as we expected  for delay 3 sec we need to get 235 according to LUT table
     # we define tolerance of +-10 units for address value
-
+    expected_second_tbc_value = second_delay / 1000
+    print(f"expected second tbc value: {expected_second_tbc_value}")
     # Most important check, verify it converges to the correct value
-    if df.iloc[-1][TBC] not in range(232, 237):
+    average_of_last_5_tbc_value = round(df.iloc[-5:][TBC].mean(), 3)
+    print(f"last tbc value: {average_of_last_5_tbc_value}")
+    THRESHOLD_MIN = 0.95
+    # NOTE: assume that there is time difference between SIM and GW
+    if test.tester.is_simulated():
+        THRESHOLD_MAX = 1.1
+    else:
+        THRESHOLD_MAX = 1.15
+    min_expected_tbc_value = round(expected_second_tbc_value * THRESHOLD_MIN, 3)
+    max_expected_tbc_value = round(expected_second_tbc_value * THRESHOLD_MAX, 3)
+
+    print(f"TBC value: {average_of_last_5_tbc_value}")
+    print(f"expected value [{min_expected_tbc_value},{max_expected_tbc_value}] according to delay:{second_delay / 1000} sec")
+    if not (min_expected_tbc_value <= average_of_last_5_tbc_value <= max_expected_tbc_value):
         test.rc = TEST_FAILED
-        test.add_reason(f"TBC value: {df.iloc[-1][TBC]}, expected value [232,236]")
-        print(f"TBC value: {df.iloc[-1][TBC]}, expected value [232,236] according to delay:{second_delay / 1000} sec")
+        test.add_reason(f"TBC value: {average_of_last_5_tbc_value}, expected value {expected_second_tbc_value}")
         return test
-    # for loop that skip the first row and check if somewhere there is the expected gap 130 to 200
-    result = False
-    for i in range(0, lenght - 1):
-        prev = df.iloc[i][TBC]
-        current = df.iloc[i + 1][TBC]
-        if prev in range(120, 140) and current in range(190, 210):
-            print(f"Found the gap between {prev} and {current}")
-            print(f"row {i}: {df.iloc[i][TBC]}")
-            print(f"row {i + 1}: {df.iloc[i + 1][TBC]}")
-            result = True
-    if not result:
-        test.rc = TEST_FAILED
-        test.add_reason("Didn't find the correct gap according to alpha filter calculation")
+
+    # # TODO: we skip that part until we decide if there is a need to check the gap between the first and second tbc values
+    # # for loop that skip the first row and check if somewhere there is the expected gap 0.5 to 3 sec
+    # result = False
+    # expected_first_tbc_value = first_delay / 1000
+    # print(f"expected first tbc value: {expected_first_tbc_value}")
+    # expected_first_gap_tbc_value = round(address_2_tbc(200), 3)
+    # print(f"expected second tbc value: {expected_first_gap_tbc_value}")
+    # for i in range(0, length - 1):
+    #     prev = round(df.iloc[i][TBC],3)
+    #     current = round(df.iloc[i + 1][TBC],3)
+    #     print(f"prev: {prev}, current: {current}")
+    #     if expected_first_tbc_value*0.9 <= prev <= expected_first_tbc_value*1.1:
+    #       if expected_first_gap_tbc_value*0.9 <= current <= expected_first_gap_tbc_value*1.1:
+    #         print(f"Found the gap between {prev} and {current}")
+    #         print(f"row {i}: {df.iloc[i][TBC]}")
+    #         print(f"row {i + 1}: {df.iloc[i + 1][TBC]}")
+    #         result = True
+    # if not result:
+    #     test.rc = TEST_FAILED
+    #     test.add_reason("Didn't find the correct gap according to alpha filter calculation")
     return test
 
 
@@ -208,7 +248,7 @@ def run(test):
     for param in test.params:
         functionality_run_print(param.name)
         test = RX_RATE_TEST_MAP[param.value](test, datapath_module)
-        generate_log_file(test, param.name)
+        cert_mqtt.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)

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

@@ -2,8 +2,7 @@
     "name": "Stress Test Gen3 Pixels",
     "module": "Datapath",
     "purpose": "verify that the algorithms 'adaptive repetition' and 'adaptive pacer' are working correctly under stress conditions with Gen3 pixels",
-    "documentation": ["https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Relaying-data",
-                      "add more links here - about adaptive repetition, adaptive pacer"],
+    "documentation": ["https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Relaying-data"],
     "initialCondition": "Bridge configured to defaults",
     "procedure": ["Test prolog",
                   "Configure GW to allow packets duplications",
@@ -16,6 +15,8 @@
     "mandatory": 0,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
-    "internalBridge": 0,
+    "bridgeOnlyTest": 1,
+    "dataSimOnlyTest": 1,
+    "SupportedFromApiVersion": 12,
     "allSupportedValues": ["rep3", "rep2", "rep1"]
 }

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

@@ -1,10 +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
-import brg_certificate.cert_data_sim as cert_data_sim
-from brg_certificate.cert_gw_sim import DEDUPLICATION_PKTS
+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
+from certificate.cert_gw_sim import DEDUPLICATION_PKTS
 import statistics
 import time
 
@@ -91,7 +92,7 @@ def combination_func(test, param, datapath_module, pacer_interval, num_of_sim_ta
     if param.name == "rep1_adaptive_pacer":
         print(f"run phase: {param.name}")
         df = cert_common.data_scan(test, scan_time=30, brg_data=(not test.internal_brg), gw_data=test.internal_brg)
-        cert_common.display_data(df, nfpkt=True, tbc=True, name_prefix=f"stress_{pacer_interval}_", dir=test.dir)
+        cert_common.display_data(df, tbc=True, name_prefix=f"stress_{pacer_interval}_", dir=test.dir)
         test, hbs = cert_common.scan_for_mgmt_pkts(test, [eval_pkt(f'Brg2GwHbV{test.active_brg.api_version}')])
         hbs = [p[MGMT_PKT].pkt for p in hbs]
 
@@ -107,7 +108,7 @@ def combination_func(test, param, datapath_module, pacer_interval, num_of_sim_ta
     time.sleep(30)
     # first df
     df = cert_common.data_scan(test, scan_time=30, brg_data=(not test.internal_brg), gw_data=test.internal_brg)
-    cert_common.display_data(df, nfpkt=True, tbc=True, name_prefix=f"stress_{pacer_interval}_", dir=test.dir)
+    cert_common.display_data(df, tbc=True, name_prefix=f"stress_{pacer_interval}_", dir=test.dir)
     test, hbs = cert_common.scan_for_mgmt_pkts(test, [eval_pkt(f'Brg2GwHbV{test.active_brg.api_version}')])
     hbs = [p[MGMT_PKT].pkt for p in hbs]
     print("result of first df\n")
@@ -117,7 +118,7 @@ def combination_func(test, param, datapath_module, pacer_interval, num_of_sim_ta
     time.sleep(30)
     # second df
     df = cert_common.data_scan(test, scan_time=60, brg_data=(not test.internal_brg), gw_data=test.internal_brg)
-    cert_common.display_data(df, nfpkt=True, tbc=True, name_prefix=f"stress_{pacer_interval}_", dir=test.dir)
+    cert_common.display_data(df, tbc=True, name_prefix=f"stress_{pacer_interval}_", dir=test.dir)
     test, hbs = cert_common.scan_for_mgmt_pkts(test, [eval_pkt(f'Brg2GwHbV{test.active_brg.api_version}')])
     hbs = [p[MGMT_PKT].pkt for p in hbs]
     print("result of second df\n")
@@ -192,7 +193,7 @@ def run(test):
     for param in test.params:
         functionality_run_print(param.name)
         test = STRESS_TEST_MAP[param.value](test, param, datapath_module, num_of_pixels)
-        generate_log_file(test, param.name)
+        cert_mqtt.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)
@@ -205,4 +206,7 @@ def run(test):
     # Re-enable unified packets deduplication
     cert_config.gw_action(test, f"{DEDUPLICATION_PKTS} 1")
 
+    # wait a few seconds to ensure bridge relaxed before next test
+    wait_time_n_print(60)
+
     return cert_common.test_epilog(test, revert_brgs=True, modules=[datapath_module])

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

@@ -2,8 +2,7 @@
     "name": "Stress Test Gen2 Pixels",
     "module": "Datapath",
     "purpose": "verify that the algorithms 'adaptive repetition' and 'adaptive pacer' are working correctly under stress conditions with Gen3 pixels",
-    "documentation": ["https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Relaying-data",
-                      "add more links here - about adaptive repetition, adaptive pacer"],
+    "documentation": ["https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Relaying-data"],
     "initialCondition": "Bridge configured to defaults",
     "procedure": ["Test prolog",
                   "Configure GW to allow packets duplications",
@@ -16,6 +15,8 @@
     "mandatory": 0,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
-    "internalBridge": 0,
+    "bridgeOnlyTest": 1,
+    "dataSimOnlyTest": 1,
+    "SupportedFromApiVersion": 12,
     "allSupportedValues": ["rep3", "rep2", "rep1"]
 }

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

@@ -1,10 +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
-import brg_certificate.cert_data_sim as cert_data_sim
-from brg_certificate.cert_gw_sim import DEDUPLICATION_PKTS
+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
+from certificate.cert_gw_sim import DEDUPLICATION_PKTS
 import statistics
 import time
 
@@ -90,7 +91,7 @@ def combination_func(test, param, datapath_module, pacer_interval, num_of_sim_ta
     if param.name == "rep1_adaptive_pacer":
         print(f"run phase: {param.name}")
         df = cert_common.data_scan(test, scan_time=30, brg_data=(not test.internal_brg), gw_data=test.internal_brg)
-        cert_common.display_data(df, nfpkt=True, tbc=True, name_prefix=f"stress_{pacer_interval}_", dir=test.dir)
+        cert_common.display_data(df, tbc=True, name_prefix=f"stress_{pacer_interval}_", dir=test.dir)
         test, hbs = cert_common.scan_for_mgmt_pkts(test, [eval_pkt(f'Brg2GwHbV{test.active_brg.api_version}')])
         hbs = [p[MGMT_PKT].pkt for p in hbs]
 
@@ -106,7 +107,7 @@ def combination_func(test, param, datapath_module, pacer_interval, num_of_sim_ta
     time.sleep(30)
     # first df
     df = cert_common.data_scan(test, scan_time=30, brg_data=(not test.internal_brg), gw_data=test.internal_brg)
-    cert_common.display_data(df, nfpkt=True, tbc=True, name_prefix=f"stress_{pacer_interval}_", dir=test.dir)
+    cert_common.display_data(df, tbc=True, name_prefix=f"stress_{pacer_interval}_", dir=test.dir)
     test, hbs = cert_common.scan_for_mgmt_pkts(test, [eval_pkt(f'Brg2GwHbV{test.active_brg.api_version}')])
     hbs = [p[MGMT_PKT].pkt for p in hbs]
     print("result of first df\n")
@@ -116,7 +117,7 @@ def combination_func(test, param, datapath_module, pacer_interval, num_of_sim_ta
     time.sleep(30)
     # second df
     df = cert_common.data_scan(test, scan_time=60, brg_data=(not test.internal_brg), gw_data=test.internal_brg)
-    cert_common.display_data(df, nfpkt=True, tbc=True, name_prefix=f"stress_{pacer_interval}_", dir=test.dir)
+    cert_common.display_data(df, tbc=True, name_prefix=f"stress_{pacer_interval}_", dir=test.dir)
     test, hbs = cert_common.scan_for_mgmt_pkts(test, [eval_pkt(f'Brg2GwHbV{test.active_brg.api_version}')])
     hbs = [p[MGMT_PKT].pkt for p in hbs]
     print("result of second df\n")
@@ -191,7 +192,7 @@ def run(test):
     for param in test.params:
         functionality_run_print(param.name)
         test = STRESS_TEST_MAP[param.value](test, param, datapath_module, num_of_pixels)
-        generate_log_file(test, param.name)
+        cert_mqtt.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)
@@ -204,4 +205,7 @@ def run(test):
     # Re-enable unified packets deduplication
     cert_config.gw_action(test, f"{DEDUPLICATION_PKTS} 1")
 
+    # wait a few seconds to ensure bridge relaxed before next test
+    wait_time_n_print(60)
+
     return cert_common.test_epilog(test, revert_brgs=True, modules=[datapath_module])

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

@@ -12,6 +12,8 @@
     "mandatory": 0,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
-    "internalBridge": 0,
+    "bridgeOnlyTest": 1,
+    "dataSimOnlyTest": 0,
+    "SupportedFromApiVersion": 12,
     "allSupportedValues": [1, 2, 3, 4, 5, 6]
 }

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

@@ -1,34 +1,35 @@
 # This test will run on "params" mode when it gets parameters in its call - check config only
-# Otherwise it will run on "auto" mode - collect packets and analyse packets actual repetitions
+# Otherwise it will run on "auto" mode - collect packets and analyze packets actual repetitions
 
-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
-from brg_certificate.cert_gw_sim import DEDUPLICATION_PKTS
+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
+from certificate.cert_gw_sim import DEDUPLICATION_PKTS
 import statistics
 
 TX_REPETITION_THRESHOLD = 0.5
 
 
 def tx_repetitions_analysis(test, repetitions):
-    cert_common.wait_time_n_print(CLEAR_DATA_PATH_TIMEOUT)
-    test.mqttc.flush_pkts()
+    wait_time_n_print(CLEAR_DATA_PATH_TIMEOUT)
+    test.get_mqttc_by_target(DUT).flush_pkts()
     if test.data == DATA_SIMULATION:
         pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=15, duplicates=1, delay=100, pkt_types=[0])
         pixel_sim_thread.start()
     mqtt_scan_wait(test, 60)
     if test.data == DATA_SIMULATION:
         pixel_sim_thread.stop()  # stop generating pkts on data simulator
-        cert_common.wait_time_n_print(CLEAR_DATA_PATH_TIMEOUT)  # Wait for sim queue to free
+        wait_time_n_print(CLEAR_DATA_PATH_TIMEOUT)  # Wait for sim queue to free
     pkts = cert_mqtt.get_unified_data_pkts(test)
     print(f"Found {len(pkts)} packets")
     if len(pkts) == 0:
         test.rc = TEST_FAILED
         test.add_reason(f"For repetitions {repetitions} found 0 pkts!")
-        generate_log_file(test, repetitions)
+        cert_mqtt.generate_log_file(test, repetitions)
         return test
     pkt_payload_counter = {}
     for p in pkts:
@@ -37,7 +38,7 @@ def tx_repetitions_analysis(test, repetitions):
             pkt_payload_counter[cur_pkt] += 1
         else:
             pkt_payload_counter[cur_pkt] = 1
-    generate_log_file(test, repetitions)
+    cert_mqtt.generate_log_file(test, repetitions)
     avg = statistics.mean([pkt_payload_counter[p] for p in pkt_payload_counter])
     txt = f"For TX repetition = {repetitions}, average {round(avg, 3)} repetitions"
     print(txt)

certificate/tests/edge_mgmt/action_blink_test/action_blink_test.json

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

certificate/tests/edge_mgmt/action_blink_test/action_blink_test.py

@@ -0,0 +1,24 @@
+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_blink")
+
+    # send action
+    cert_config.send_brg_action(test, ag.ACTION_BLINK)
+    # analysis
+    test = cert_common.search_action_ack(test, ag.ACTION_BLINK)
+
+    cert_mqtt.generate_log_file(test, "action_blink")
+    field_functionality_pass_fail_print(test, "action_blink")
+
+    return cert_common.test_epilog(test)

certificate/tests/edge_mgmt/action_get_battery_sensor_test/action_get_battery_sensor_test.json

@@ -0,0 +1,15 @@
+{
+    "name": "Get Battery Sensor Action",
+    "module": "Edge Management",
+    "purpose": "Test get battery sensor 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 battery sensor action and test bridge's response accordingly", "Test epilog"],
+    "expectedOutcome": "Bridge returned an ack for the action, and sent a battery sensor data packet.",
+    "mandatory": 0,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 0,
+    "dataSimOnlyTest": 0,
+    "SupportedFromApiVersion": 12,
+    "allSupportedValues": []
+}

certificate/tests/edge_mgmt/action_get_battery_sensor_test/action_get_battery_sensor_test.py

@@ -0,0 +1,43 @@
+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 not in BATTERY_SENSOR_SUPPORTING_BOARD_TYPES:
+        test.rc = TEST_SKIPPED
+        return cert_common.test_epilog(test)
+    # prolog
+    functionality_run_print("action_get_battery_sensor")
+    # send action
+    cert_config.send_brg_action(test, ag.ACTION_GET_BATTERY_SENSOR)
+    # analysis
+    test = cert_common.search_action_ack(test, ag.ACTION_GET_BATTERY_SENSOR)
+    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_BATTERY_SENSOR:06X}"):
+            print_pkt(p)
+            found_packet = True
+            break
+    if found_packet is False:
+        test.rc = TEST_FAILED
+        test.add_reason("Didn't find battery sensor data packet")
+
+    cert_mqtt.generate_log_file(test, "action_get_battery_sensor")
+    field_functionality_pass_fail_print(test, "action_get_battery_sensor")
+
+    return cert_common.test_epilog(test)

certificate/tests/edge_mgmt/action_get_module_test/action_get_module_test.json

@@ -0,0 +1,15 @@
+{
+    "name": "Get Module Action",
+    "module": "Edge Management",
+    "purpose": "Test get module 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 module action - first for datapath, then for all modules, and test bridge's response accordingly", "Test epilog"],
+    "expectedOutcome": "Bridge returned an ack for the action, and sent all module packets",
+    "mandatory": 1,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 0,
+    "dataSimOnlyTest": 0,
+    "SupportedFromApiVersion": 12,
+    "allSupportedValues": []
+}