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

brg_certificate/tests/datapath/stress_test/stress_test.py

@@ -8,192 +8,186 @@ from brg_certificate.cert_gw_sim import DEDUPLICATION_PKTS
 import statistics
 import time
 
-def configure_pacer_n_times(test, num_of_times, pacer_interval, datapath_module):
-    test = cert_config.brg_configure(test, fields=[BRG_PACER_INTERVAL], values=[pacer_interval], module=datapath_module)[0]
-    if test.rc == TEST_FAILED:
-        for i in range(num_of_times):
-            if test.rc == TEST_PASSED:
-                return test
-            print(f"sleeping for 10 seconds before trying to configure pacer again\n")
-            time.sleep(10)
-            test = cert_config.brg_configure(test, fields=[BRG_PACER_INTERVAL], values=[pacer_interval], module=datapath_module)[0]
-        test.add_reason("Didn't succeed to configure after two attempts - No pkt was found!")
-    return test
 
-def metric_checking_HB(test, mgmt_type_list, tx_queue_expected, pacer_increment_expected):
+def metric_checking_HB(test, check, mgmt_type_list, tx_queue_expected, pacer_increment_expected):
     if not mgmt_type_list:
-        test.add_reason("\nDidn't find HB pkt, therefore will not check tx_queue and pacer increment\n")
-        print(f"Didn't find HB pkt, therefore will not check tx_queue and pacer increment")
+        test.add_reason("\nDidn't find HB pkt, therefore skip all checks\n")
+        print("Didn't find HB pkt, therefore will not check tx_queue and pacer increment")
     else:
-        #check tx queue 
+        # check tx queue
         watermarks = [pkt.tx_queue_watermark for pkt in mgmt_type_list]
         half_index = len(watermarks) // 2
         tx_queue_HB = statistics.mean(watermarks[half_index:])
         if not (tx_queue_expected[0] <= tx_queue_HB <= tx_queue_expected[1]):
-            test.add_reason(f"tx_queue: {tx_queue_HB}")
-            print(f"\ntx_queue value is wrong!\nexpected: {tx_queue_expected}, got: {tx_queue_HB}")
+            print(f"\ntx_queue: {tx_queue_HB} expected: {tx_queue_expected},")
         else:
-            test.add_reason(f"tx_queue: {tx_queue_HB}")
-            print(f"\ntx_queue from HB : {tx_queue_HB}\n")
-        
+            print(f"\ntx_queue from HB: {tx_queue_HB}\n")
+
         # check pacer increment
         pacer_increment_HB = [pkt.effective_pacer_increment for pkt in mgmt_type_list]
         average_pacer_increment_HB = statistics.mean(pacer_increment_HB)
         if not (pacer_increment_expected[0] <= average_pacer_increment_HB <= pacer_increment_expected[1]):
-            test.add_reason(f"pacer_increment:{average_pacer_increment_HB}")
             print(f"\npacer_increment value is wrong\nexpected: {pacer_increment_expected}\ngot: {average_pacer_increment_HB}")
+            if check:
+                test.rc = TEST_FAILED
+                test.add_reason(f"pacer_increment:{average_pacer_increment_HB}")
         else:
-            test.add_reason(f"pacer_increment: {average_pacer_increment_HB}")
             print(f"\naverage pacer_increment from HB: {average_pacer_increment_HB}\n")
+            if check:
+                test.add_reason(f"pacer_increment: {average_pacer_increment_HB}")
     return test
 
-def metric_checking_df(test, check,  pacer_interval, df, repetition_value_expected,  brg_latency_expected, num_of_pixels_expected):
+
+def metric_checking_df(test, check, pacer_interval, df, repetition_value_expected, brg_latency_expected, num_of_pixels_expected):
     if df.empty:
-        print(f" df is empty, therefore will not check repetitions, brg latency and num of tags")
+        print("Df is empty, therefore will not check repetitions, brg latency and num of tags")
         test.rc = TEST_FAILED
-        test.add_reason(f"df is empty, therefore will not check repetitions, brg latency and num of tags")
+        test.add_reason("Df is empty, therefore skip all checks")
     else:
         print(f"result of pacer interval: {pacer_interval}\n")
         # check repetition value
         payload_counts_per_tag = df.groupby(TAG_ID)[PAYLOAD].value_counts()
         average_payload_count = round(payload_counts_per_tag.mean(), 2)
         if not repetition_value_expected[0] <= average_payload_count <= repetition_value_expected[1]:
+            print(f"Repetition value is wrong! \nexpected:{repetition_value_expected}\ngot: {average_payload_count}")
             if check:
                 test.rc = TEST_FAILED
-                test.add_reason(f"Repetition:{average_payload_count}, expected: {repetition_value_expected},")
-                print(f"Repetition value is wrong! \nexpected:{repetition_value_expected}\ngot: {average_payload_count}")
-            else:   
-                test.add_reason(f"Repetition:{average_payload_count}, expected: {repetition_value_expected},")
-                print(f"Repetition value is wrong! \nexpected:{repetition_value_expected}\ngot: {average_payload_count}")
+                test.add_reason(f"Repetition:{average_payload_count}, expected: {repetition_value_expected}")
         else:
-            test.add_reason(f"Repetition value: {average_payload_count}")
             print(f"Repetition value is correct! got: {average_payload_count}")
-    
+            if check:
+                test.add_reason(f"Repetition value: {average_payload_count}")
+
         # check num of tags, with tolerance of 5%
-        num_of_tags = len(df[TAG_ID].unique()) 
-        if not num_of_pixels_expected*0.95 <= num_of_tags <= num_of_pixels_expected*1.05:
-            test.add_reason(f"num of tags:  {num_of_tags}")
-            print(f"\n num of tags is not as expected\nexpected: {num_of_pixels_expected}, got: {num_of_tags}")
+        num_of_tags = len(df[TAG_ID].unique())
+        if not num_of_pixels_expected * 0.95 <= num_of_tags <= num_of_pixels_expected * 1.05:
+            print(f"\nnum of tags is not as expected\nexpected: {num_of_pixels_expected}, got: {num_of_tags}")
+            if check:
+                test.add_reason(f"num of tags:  {num_of_tags}")
         else:
-            test.add_reason(f"num of tags: {num_of_tags}")
             print(f"\nnum of tags from df: {num_of_tags}\n")
-        
-        #check brg_latency
-        if check:
-            brg_latency_avg = round(df[BRG_LATENCY].mean(),2)
-            if not (brg_latency_expected[0] <= brg_latency_avg <= brg_latency_expected[1]):
-                test.add_reason(f"brg_latency:{brg_latency_avg}")
-                print(f"Average brg_latency: {brg_latency_avg}")
-            else:
-                test.add_reason(f"brg_latency: {brg_latency_avg}")
-                print(f"Average brg_latency: {brg_latency_avg}")
+
+        # check brg_latency
+        brg_latency_avg = round(df[BRG_LATENCY].mean(), 2)
+        if not (brg_latency_expected[0] <= brg_latency_avg <= brg_latency_expected[1]):
+            print(f"Average brg_latency: {brg_latency_avg} , expected: {brg_latency_expected}")
         else:
-            brg_latency_avg = round(df[BRG_LATENCY].mean(),2)
             print(f"Average brg_latency: {brg_latency_avg}")
-    return test 
+    return test
+
+
+def combination_func(test, param, datapath_module, pacer_interval, num_of_sim_tags, repetition_value_expected,
+                     tx_queue_expected, pacer_increment_expected, brg_latency_expected):
+    test = cert_config.brg_configure(test, fields=[BRG_PACER_INTERVAL], values=[pacer_interval], module=datapath_module)[0]
+    if test.rc == TEST_FAILED:
+        print("Failed to configure pacer interval")
+        test.add_reason("Failed to configure pacer interval")
+        return test
+    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)
+        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]
+
+        check = True
+        test = metric_checking_df(test, check, pacer_interval, df, repetition_value_expected, brg_latency_expected, num_of_sim_tags)
+        if not test.rc == TEST_FAILED:
+            test = metric_checking_HB(test, check, hbs, tx_queue_expected, pacer_increment_expected)
+            return test
+        else:
+            # in case it failed because the repetition value.
+            return test
 
-def combination_func(test, datapath_module, pacer_interval, num_of_sim_tags, repetition_value_expected, tx_queue_expected, pacer_increment_expected, brg_latency_expected):
-    test = configure_pacer_n_times(test, 2, pacer_interval, datapath_module)
     time.sleep(30)
-# first df 
+    # 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)
     test, hbs = cert_common.scan_for_mgmt_pkts(test, [eval_pkt(f'Brg2GwHbV{test.active_brg.api_version}')])
-    print(f"number of HB packets: {len(hbs)}") # TODO remove
-    for p in hbs: # TODO remove
-        print(f"WATERMARK:{p[MGMT_PKT].pkt.tx_queue_watermark}, pacer increment:{p[MGMT_PKT].pkt.effective_pacer_increment} ") # TODO remove
-    hbs = [p[MGMT_PKT].pkt for p in hbs] 
-    print(f"result of first df\n")
+    hbs = [p[MGMT_PKT].pkt for p in hbs]
+    print("result of first df\n")
     check = False
+    test = metric_checking_HB(test, check, hbs, tx_queue_expected, pacer_increment_expected)
     test = metric_checking_df(test, check, pacer_interval, df, repetition_value_expected, brg_latency_expected, num_of_sim_tags)
     time.sleep(30)
-# second df
+    # 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)
     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(f"result of second df\n")
+    hbs = [p[MGMT_PKT].pkt for p in hbs]
+    print("result of second df\n")
     check = True
+    test = metric_checking_HB(test, check, hbs, tx_queue_expected, pacer_increment_expected)
     test = metric_checking_df(test, check, pacer_interval, df, repetition_value_expected, brg_latency_expected, num_of_sim_tags)
-    test = metric_checking_HB(test, hbs, tx_queue_expected, pacer_increment_expected)
     return test
 
-def rep3(test, datapath_module, num_of_sim_tags, pixel_sim_thread):
-    # step 1 - config pacer interval=15 , then check repetition value = 3, tx_queue ~ 0, pacer increment ~ 0, brg latency ~ 0 , num of tags = all tags.
-    pacer_interval = 20 
-    test = combination_func(test, datapath_module, pacer_interval=pacer_interval, num_of_sim_tags=num_of_sim_tags, repetition_value_expected=[2,3], tx_queue_expected=[20,40], pacer_increment_expected=[0,2], brg_latency_expected=[0,10])
+
+def rep3(test, param, datapath_module, num_of_sim_tags):
+    # step 1 - config pacer interval=15 , then check repetition value = 3, tx_queue ~ 0, pacer increment ~ 0, brg latency ~ 0
+    pacer_interval = 22
+    test = combination_func(test, param, datapath_module, pacer_interval=pacer_interval, num_of_sim_tags=num_of_sim_tags,
+                            repetition_value_expected=[2, 3], tx_queue_expected=[20, 40],
+                            pacer_increment_expected=[0, 2], brg_latency_expected=[0, 10])
     time.sleep(5)
     return test
 
-def rep2(test, datapath_module, num_of_sim_tags, pixel_sim_thread):
-    #"step 2 - config pacer interval 9, then check repetition value = 2, tx_queue = 20-40, pacer increment = 0, brg latency = 0-200, num of tags = all tags"
-    pacer_interval = 15
-    test = combination_func(test, datapath_module, pacer_interval=pacer_interval, num_of_sim_tags=num_of_sim_tags, repetition_value_expected=[1.5,2.5], tx_queue_expected=[20,40], pacer_increment_expected=[0,2], brg_latency_expected=[10,200])
-    # for checking if it's affect of the running that df is empty.
+
+def rep2(test, param, datapath_module, num_of_sim_tags):
+    # step 2 - config pacer interval 9, then check repetition value = 2, tx_queue = 20-40, pacer increment = 0, brg latency = 0-200
+    pacer_interval = 12
+    test = combination_func(test, param, datapath_module, pacer_interval=pacer_interval, num_of_sim_tags=num_of_sim_tags,
+                            repetition_value_expected=[1.5, 2.5], tx_queue_expected=[20, 40],
+                            pacer_increment_expected=[0, 2], brg_latency_expected=[10, 200])
     time.sleep(5)
     return test
 
-def rep1(test, datapath_module, num_of_sim_tags, pixel_sim_thread):
-    # "step 3 - config pacer interval 6 , then check repetition value = 1, tx_queue 40-60, pacer increment ~ 0, brg latency 200-300 , num of tags = all tags"
-    pacer_interval = 9
-    test = combination_func(test, datapath_module, pacer_interval=pacer_interval, num_of_sim_tags=num_of_sim_tags, repetition_value_expected=[1,2], tx_queue_expected=[20,40], pacer_increment_expected=[0,2], brg_latency_expected=[200,300])
+
+def rep1(test, param, datapath_module, num_of_sim_tags):
+    # "step 3 - config pacer interval 6 , then check repetition value = 1, tx_queue 40-60, pacer increment ~ 0, brg latency 200-300
+    pacer_interval = 7
+    test = combination_func(test, param, datapath_module, pacer_interval=pacer_interval, num_of_sim_tags=num_of_sim_tags,
+                            repetition_value_expected=[1, 2], tx_queue_expected=[20, 40],
+                            pacer_increment_expected=[0, 2], brg_latency_expected=[200, 300])
     time.sleep(5)
     return test
 
-def rep1_adaptive_pacer(test, datapath_module, num_of_sim_tags, pixel_sim_thread):
-    # "step 4 - config pacer interval 1  , then check repetition value = 1, tx_queue > 60, pacer increment = 3 , brg latency > 300 , num of tags = all tags"
-    pacer_interval = 1 
-    test = combination_func(test, datapath_module, pacer_interval=pacer_interval, num_of_sim_tags=num_of_sim_tags, repetition_value_expected=[1,2], tx_queue_expected=[20,40], pacer_increment_expected=[2,20], brg_latency_expected=[300,1000])
+
+def rep1_adaptive_pacer(test, param, datapath_module, num_of_sim_tags):
+    # step 4 - config pacer interval 1, then check repetition value = 1, tx_queue > 60, pacer increment = 3, brg latency > 300
+    pacer_interval = 1
+
+    test = combination_func(test, param, datapath_module, pacer_interval=pacer_interval, num_of_sim_tags=num_of_sim_tags,
+                            repetition_value_expected=[1, 2], tx_queue_expected=[20, 40],
+                            pacer_increment_expected=[2, 50], brg_latency_expected=[300, 1000])
     time.sleep(5)
     return test
 
-def pixels_burst(test, datapath_module, num_of_sim_tags, pixel_sim_thread):
-    #NOTE: I had to change the pattern because there isn't option to increase the the pixels number in the same thread it will cause error "index out of bound"
-    # "step 5- config pacer interval 15 , then add more 200 packets with 0 delay(0.02 sec) , then check repetition value = 1 and not 2 "
-    pixel_sim_thread.stop()
-    pacer_interval = 15
-    test = configure_pacer_n_times(test, 2, pacer_interval, datapath_module)
-    pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=num_of_sim_tags, duplicates=1, delay=0, pkt_types=[0],pixels_type=GEN2)
-    pixel_sim_thread.start()
-    df = cert_common.data_scan(test, scan_time=180 , brg_data=(not test.internal_brg), gw_data=test.internal_brg)
-    check = True
-    test = metric_checking_df(test, check, pacer_interval, df, [2,3], [0,10], 200)
-    # we must have df, so we will try twice again to get it
-    if test.rc == TEST_FAILED:
-        for i in range(2):
-            if test.rc == TEST_PASSED:
-                break
-            df = cert_common.data_scan(test, scan_time=30 , brg_data=(not test.internal_brg), gw_data=test.internal_brg)
-            test =metric_checking_df(test, check, pacer_interval, df, [2,3], [0,10], 200)    
-    pixel_sim_thread.stop()
-    #change the number of pixels to 400, and check that the repetition value is 1 in short time 
-    pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=400, duplicates=1, delay=0, pkt_types=[0],pixels_type=GEN2)
-    pixel_sim_thread.start()
-    df = cert_common.data_scan(test, scan_time=30 , brg_data=(not test.internal_brg), gw_data=test.internal_brg)
-    test = metric_checking_df(test, check, pacer_interval, df, [1,2], [0,10], 400)    
-    pixel_sim_thread.stop()
-    return test
 
 def run(test):
     # Test prolog
     datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
     test = cert_common.test_prolog(test)
     if test.rc == TEST_FAILED:
-        return cert_common.test_epilog(test)
-    #config GW deduplication pkts = 0  "
+        return cert_common.test_epilog(test, revert_brgs=True, modules=[datapath_module])
+    # config GW deduplication pkts = 0
     print("Configuring GW with !deduplication_pkts 0")
     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)
 
-    STRESS_TEST_MAP = {"rep3":rep3, "rep2": rep2 ,"rep1": rep1,  "rep1_adaptive_pacer":rep1_adaptive_pacer, "pixels_burst":pixels_burst}
+    STRESS_TEST_MAP = {"rep3": rep3, "rep2": rep2, "rep1": rep1, "rep1_adaptive_pacer": rep1_adaptive_pacer}
     num_of_pixels = 300
-    pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=num_of_pixels, duplicates=1, delay=0, pkt_types=[0],pixels_type=GEN2)
+    pixel_sim_thread = cert_data_sim.DataSimThread(test=test,
+                                                   num_of_pixels=num_of_pixels,
+                                                   duplicates=1,
+                                                   delay=0,
+                                                   pkt_types=[0],
+                                                   pixels_type=GEN2)
     pixel_sim_thread.start()
     time.sleep(30)
     for param in test.params:
         functionality_run_print(param.name)
-        test = STRESS_TEST_MAP[param.value](test, datapath_module, num_of_pixels, pixel_sim_thread)
+        test = STRESS_TEST_MAP[param.value](test, param, 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)
@@ -207,4 +201,4 @@ def run(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])
+    return cert_common.test_epilog(test, revert_brgs=True, modules=[datapath_module])

brg_certificate/tests/datapath/tx_repetition_algo_test/tx_repetition_algo_test.json

@@ -1,13 +1,17 @@
 {
-    "name": "tx_repetition_algo_test",
-    "module": "datapath",
+    "name": "Tx Repetition Algorithm",
+    "module": "Datapath",
     "purpose": "Test the tx repetition adjustment algorithm",
-    "documentaion": "<TEST_DOCUMENTATION_LINK>",
+    "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"],
+    "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

@@ -6,13 +6,16 @@ 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, statistics, math
+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 = []
@@ -49,6 +52,7 @@ def track_tx_rep(test, sorted_database):
 
     return test, tx_reps
 
+
 def tx_rep_analysis(test):
     # Clear data path
     cert_common.wait_time_n_print(CLEAR_DATA_PATH_TIMEOUT)
@@ -60,7 +64,7 @@ def tx_rep_analysis(test):
     print("Found {} unified packets".format(len(pkts)))
 
     # Count payloads
-    pkt_payload_counter = {} # idx 0 - payload, idx 1 - payload ts
+    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:
@@ -89,6 +93,7 @@ def tx_rep_analysis(test):
     print(f"total counted tx_reps[{tx_reps}]")
     return test
 
+
 def run(test):
 
     test = cert_common.test_prolog(test)

brg_certificate/tests/datapath/tx_repetition_test/tx_repetition_test.json

@@ -1,13 +1,17 @@
 {
-    "name": "tx_repetition_test",
-    "module": "datapath",
+    "name": "Tx Repetition",
+    "module": "Datapath",
     "purpose": "Test tx repetition feature configuration and functionality in the bridge for different tx repetition values",
-    "documentaion": "<TEST_DOCUMENTATION_LINK>",
+    "documentation": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Configuration",
     "initialCondition": "Bridge & data simulator configured to defaults",
-    "procedure": ["Test prolog", "Tx repetition configuration", "Generate pixels packets & scan for packets in the bridge", "Compare repetitions mean per packet to the configured value", "Repeat for all given tx repetition values", "Test epilog and revert to defaults"],
+    "procedure": ["Test prolog",
+                  "Disabling GW deduplication",
+                  "For each supported value - Configure TX repetitions, Generate pixels packets & scan for packets in the bridge, Compare repetitions mean per packet to the configured value",
+                  "Test epilog and revert to defaults"],
     "expectedOutcome": "All values configured successfully and actual repetitions found matching to the configured values",
     "mandatory": 1,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
+    "internalBridge": 0,
     "allSupportedValues": [1, 2, 3, 4, 5, 6]
 }

brg_certificate/tests/datapath/tx_repetition_test/tx_repetition_test.py

@@ -10,7 +10,8 @@ import brg_certificate.cert_data_sim as cert_data_sim
 from brg_certificate.cert_gw_sim import DEDUPLICATION_PKTS
 import statistics
 
-TX_REPETITION_THRESHOLD =  0.5
+TX_REPETITION_THRESHOLD = 0.5
+
 
 def tx_repetitions_analysis(test, repetitions):
     cert_common.wait_time_n_print(CLEAR_DATA_PATH_TIMEOUT)
@@ -20,8 +21,8 @@ def tx_repetitions_analysis(test, repetitions):
         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
+        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
     pkts = cert_mqtt.get_unified_data_pkts(test)
     print(f"Found {len(pkts)} packets")
     if len(pkts) == 0:
@@ -45,10 +46,10 @@ def tx_repetitions_analysis(test, repetitions):
         test.add_reason(txt)
     return test
 
+
 def run(test):
 
     fields = [BRG_TX_REPETITION, BRG_PKT_FILTER, BRG_RX_CHANNEL]
-
     datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
 
     test = cert_common.test_prolog(test)
@@ -61,7 +62,9 @@ def run(test):
         return cert_common.test_epilog(test, revert_gws=True)
 
     for param in test.params:
-        test = cert_config.brg_configure(test, fields=fields, values=[param.value, ag.PKT_FILTER_RANDOM_FIRST_ARRIVING_PKT, ag.RX_CHANNEL_37], module=datapath_module)[0]
+        test = cert_config.brg_configure(test, fields=fields,
+                                         values=[param.value, ag.PKT_FILTER_RANDOM_FIRST_ARRIVING_PKT, ag.RX_CHANNEL_37],
+                                         module=datapath_module)[0]
         if test.rc == TEST_FAILED and test.exit_on_param_failure:
             break
         tx_repetitions_analysis(test, param.name)
@@ -73,7 +76,6 @@ def run(test):
         else:
             test.reset_result()
 
-    
     # 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,13 +1,14 @@
 {
-    "name": "actions_test",
-    "module": "edge_mgmt",
+    "name": "Bridge Actions",
+    "module": "Edge Management",
     "purpose": "Test bridge actions functionality",
-    "documentaion": "<TEST_DOCUMENTATION_LINK>",
+    "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": 1,
     "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"]
 }

brg_certificate/tests/edge_mgmt/actions_test/actions_test.py

@@ -5,8 +5,6 @@ import brg_certificate.cert_common as cert_common
 import brg_certificate.cert_config as cert_config
 import random
 
-WATERMARK = "watermark"
-PACER_INC = "pacer_inc"
 BATTERY_SENSOR_SUPPORTING_BOARD_TYPES = [ag.BOARD_TYPE_MINEW_DUAL_BAND_V0, ag.BOARD_TYPE_ERM_V0,
                                          ag.BOARD_TYPE_ERM_V1, ag.BOARD_TYPE_KOAMTAC_V0]
 POF_NOT_SUPPORTING_BOARD_TYPES = [ag.BOARD_TYPE_FANSTEL_WIFI_V0, ag.BOARD_TYPE_FANSTEL_LAN_V0]
@@ -165,17 +163,7 @@ def test_action_blink(test):
 
 
 def test_action_send_hb(test):
-    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
-    # config brg to get a non zero value in the tx_queue_watermark parameter
-    test = cert_config.brg_configure(test, fields=[BRG_PACER_INTERVAL, BRG_TX_REPETITION], values=[1, 6], module=datapath_module)[0]
-    if test.rc == TEST_FAILED:
-        return cert_config.config_brg_defaults(test=test, modules=[datapath_module])[0]
 
-    if not test.internal_brg:
-        # sleep to let some pkts wait in queue
-        wait = 10
-        print(f"waiting for {wait} secs to fill up the brg queue")
-        cert_common.wait_time_n_print(wait)
     # send action
     cert_config.send_brg_action(test, ag.ACTION_SEND_HB)
     # analysis
@@ -183,30 +171,6 @@ def test_action_send_hb(test):
     if not mgmt_pkts:
         test.add_reason("Didn't find ACTION HB pkt")
         test.rc = TEST_FAILED
-    else:
-        for p in mgmt_pkts:
-            found = {WATERMARK: False, PACER_INC: False}
-            # effective_pacer_increment should be 0 when the default value for adaptice_pacer is set (OFF)
-            if not p[MGMT_PKT].pkt.effective_pacer_increment:
-                found[PACER_INC] = True
-                # Skip check for internal brg
-                if test.internal_brg:
-                    found[WATERMARK] = True
-                    break
-                # tx_queue_watermark should not be 0 when brg queue is under stress
-                elif p[MGMT_PKT].pkt.tx_queue_watermark:
-                    found[WATERMARK] = True
-                    break
-        if not found[WATERMARK]:
-            test.rc = TEST_FAILED
-            test.add_reason(f"tx_queue_watermark ({p[MGMT_PKT].pkt.tx_queue_watermark}) at the BRG HB pkt is zero")
-        if not found[PACER_INC]:
-            test.rc = TEST_FAILED
-            test.add_reason(f"effective_pacer_increment ({p[MGMT_PKT].pkt.effective_pacer_increment}) at the BRG HB pkt is not zero")
-    test = cert_config.config_brg_defaults(test=test, modules=[datapath_module])[0]
-    # queue can be full so need to wait a few seconds
-    if not test.internal_brg:
-        cert_common.wait_time_n_print(5)
     return test
 
 
@@ -228,7 +192,7 @@ def test_action_get_battery_sensor(test):
     scan_time = ACTION_SI_PKT_TIMEOUT
     found_packet = False
     while ((datetime.datetime.now() - start_time).seconds <= scan_time):
-        custom_pkts = cert_mqtt.get_all_custom_pkts(test.mqttc, test)
+        custom_pkts = cert_mqtt.get_all_custom_pkts(test)
         for p in custom_pkts:
             if p[SENSOR_UUID] == f"{ag.SENSOR_SERVICE_ID_BATTERY_SENSOR:06X}":
                 print_pkt(p)
@@ -259,7 +223,7 @@ def test_action_get_pof_data(test):
     scan_time = ACTION_SI_PKT_TIMEOUT
     found_packet = False
     while ((datetime.datetime.now() - start_time).seconds <= scan_time):
-        custom_pkts = cert_mqtt.get_all_custom_pkts(test.mqttc, test)
+        custom_pkts = cert_mqtt.get_all_custom_pkts(test)
         for p in custom_pkts:
             if p[SENSOR_UUID] == f"{ag.SENSOR_SERVICE_ID_POF_DATA:06X}":
                 print_pkt(p)

brg_certificate/tests/edge_mgmt/brg2brg_ota_ble5_test/brg2brg_ota_ble5_test.json

@@ -1,13 +1,20 @@
 {
-    "name": "brg2brg_ota_test",
-    "module": "edge_mgmt",
-    "purpose": "TODO",
-    "documentaion": "<TEST_DOCUMENTATION_LINK>",
-    "initialCondition": "TODO",
-    "procedure": ["Test prolog", "TODO", "Test epilog"],
-    "expectedOutcome": "TODO",
+    "name": "Bridge to Bridge OTA BLE5",
+    "module": "Edge Management",
+    "purpose": "Verify BRG2BRG OTA firmware/bootloader version upgrade functionality using BLE_5.0.",
+    "documentation": "<TEST_DOCUMENTATION_LINK>",
+    "initialCondition": "1 GW and 2 BRG's (source, destination) from the same type connected to the GW - the source BRG  posses the newer firmware/bootloader version, and the destination BRG posses older firmware/bootloader version.",
+    "procedure": ["Test prolog",
+                  "Verify initial conditions - same board type, different firmware/bootloader versions",
+                  "Determine the source & destination BRG according to version",
+                  "Configure destination BRG rx channel to BLE_5.0 channel (channel 10)",
+                  "Send brg2brg ota message to the source BRG - initiate brg2brg ota",
+                  "Verify destination BRG firmware/bootloader version upgrade through module IF packet",
+                  "Test epilog"],
+    "expectedOutcome": "Destination BRG firmware/bootloader version is upgraded to the source BRG firmware/bootloader version.",
     "mandatory": 0,
-    "multiBridgeTest": 0,
+    "multiBridgeTest": 1,
     "gwOnlyTest": 0,
+    "internalBridge": 0,
     "allSupportedValues": ["BOOTLOADER", "APP"]
 }

brg_certificate/tests/edge_mgmt/brg2brg_ota_test/brg2brg_ota_test.json

@@ -1,13 +1,19 @@
 {
-    "name": "brg2brg_ota_test",
-    "module": "edge_mgmt",
-    "purpose": "TODO",
-    "documentaion": "<TEST_DOCUMENTATION_LINK>",
-    "initialCondition": "TODO",
-    "procedure": ["Test prolog", "TODO", "Test epilog"],
-    "expectedOutcome": "TODO",
+    "name": "Bridge to Bridge OTA",
+    "module": "Edge Management",
+    "purpose": "Verify BRG2BRG OTA firmware/bootloader version upgrade functionality",
+    "documentation": "<TEST_DOCUMENTATION_LINK>",
+    "initialCondition": "1 GW and 2 BRG's (source, destination) from the same type connected to the GW - the source BRG  posses the newer firmware/bootloader version, and the destination BRG posses older firmware/bootloader version.",
+    "procedure": ["Test prolog",
+                  "Verify initial conditions - same board type, different firmware/bootloader versions",
+                  "Determine the source & destination BRG according to version",
+                  "Send brg2brg ota message to the source BRG - initiate brg2brg ota",
+                  "Verify destination BRG firmware/bootloader version upgrade through module IF packet",
+                  "Test epilog"],
+    "expectedOutcome": "Destination BRG firmware/bootloader version is upgraded to the source BRG firmware/bootloader version.",
     "mandatory": 0,
-    "multiBridgeTest": 0,
+    "multiBridgeTest": 1,
     "gwOnlyTest": 0,
+    "internalBridge": 0,
     "allSupportedValues": ["BOOTLOADER", "APP"]
 }

brg_certificate/tests/edge_mgmt/leds_test/leds_test.json

@@ -1,13 +1,17 @@
 {
-    "name": "leds_test",
-    "module": "edge_mgmt",
-    "purpose": "TODO",
-    "documentaion": "<TEST_DOCUMENTATION_LINK>",
-    "initialCondition": "TODO",
-    "procedure": ["Test prolog", "TODO", "Test epilog"],
-    "expectedOutcome": "TODO",
+    "name": "LEDs Behaviour",
+    "module": "Edge Management",
+    "purpose": "Test the behavior and indications of LEDs during different operational states.",
+    "documentation": "<TEST_DOCUMENTATION_LINK>",
+    "initialCondition": "Bridge configured to defaults",
+    "procedure": ["Test prolog", 
+                  "pre-stage to verify connection to a GW and associate LED color with capability",
+                  "Test LED behavior during different operational states and behaviors - Advertising, Energizing, Echoing, KEEP_ALIVE, blink action & power management",
+                  "Test epilog"],
+    "expectedOutcome": "LEDs behave as expected during all operational states and behaviors",
     "mandatory": 0,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
+    "internalBridge": 1,
     "allSupportedValues": []
 }