wiliot-certificate 1.3.0a1__py3-none-any.whl → 1.4.0a2__py3-none-any.whl

brg_certificate/tests/datapath/stress_gen3_test/stress_gen3_test.py

@@ -0,0 +1,203 @@
+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
+import statistics
+import datetime
+import sys
+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 and test.reason != TEST_SUCCESS:
+        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):
+    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")
+    else:
+        #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}")
+        else:
+            test.add_reason(f"tx_queue: {tx_queue_HB}")
+            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}")
+        else:
+            test.add_reason(f"pacer_increment: {average_pacer_increment_HB}")
+            print(f"\naverage pacer_increment from HB: {average_pacer_increment_HB}\n")
+    return test
+
+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")
+        test.rc = TEST_FAILED
+        test.add_reason(f"df is empty, therefore will not check repetitions, brg latency and num of tags")
+    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]:
+            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}")
+        else:
+            test.add_reason(f"Repetition value: {average_payload_count}")
+            print(f"Repetition value is correct! got: {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}")
+        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}")
+        else:
+            brg_latency_avg = round(df[BRG_LATENCY].mean(),2)
+            print(f"Average brg_latency: {brg_latency_avg}")
+    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 
+    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] 
+    print(f"result of first df\n")
+    check = False
+    test = metric_checking_df(test, check, pacer_interval, df, repetition_value_expected, brg_latency_expected, num_of_sim_tags)
+    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)
+    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")
+    check = True
+    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):
+    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])
+    time.sleep(5)
+    return test
+
+def rep2(test, datapath_module, num_of_sim_tags, pixel_sim_thread):
+    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])
+    time.sleep(5)
+    return test
+
+def rep1(test, datapath_module, num_of_sim_tags, pixel_sim_thread):
+    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])
+    time.sleep(5)
+    return test
+
+def rep1_adaptive_pacer(test, datapath_module, num_of_sim_tags, pixel_sim_thread):
+    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])
+    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"
+    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=GEN3)
+    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=GEN3)
+    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 or test.reason != TEST_SUCCESS:
+        return cert_common.test_epilog(test)
+    #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}
+    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=GEN3)
+    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)
+        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 and test.exit_on_param_failure:
+            break
+        else:
+            test.reset_result()
+        time.sleep(5)
+    pixel_sim_thread.stop()
+    # 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/datapath/stress_test/stress_test.json

@@ -0,0 +1,30 @@
+{
+    "name": "stress test",
+    "module": "DataPath",
+    "purpose": [
+        "verify the functionality of the bridge under stress conditions",
+        "verify that the algorithms 'adaptive repetition' and 'adaptive pacer' are working correctly",
+        "verify an edge case where the repetition stable and we got a lot of packets in short time"
+    ],
+    "documentation": [
+        "https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Relaying-data",
+        "add more links here - about adaptive repetition, adaptive pacer"
+    ],
+    "initialCondition": "Bridge configured to defaults",
+    "procedure": [
+        "Test prolog",
+        "define simulation with 200 packets with 0 delay(0.02 sec) ",
+        "rep 3 - config pacer interval 15, then check repetition value = 3, tx_queue = 0-20, pacer increment = 0, brg latency = 0, num of tags = all tags  ",
+        "rep 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",
+        "rep 1  - 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",
+        "rep 1 adaptive pacer - config pacer interval 1  , then check repetition value = 1, tx_queue > 60, pacer increment = 3 , brg latency > 300 , num of tags = all tags",
+        "pixels burst - config pacer interval 15, then add more 200 packets with 0 delay(0.02 sec), then check repetition value = 1 and not 2", 
+        "Test epilog"
+    ],
+    "expectedOutcome": "all metrics values will be as expected then the bridge is working correctly and the algorithms are working correctly",
+    "mandatory": 1,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 0,
+    "allSupportedValues": ["rep3", "rep2", "rep1", "rep1_adaptive_pacer", "pixels_burst"]
+
+}

brg_certificate/tests/datapath/stress_test/stress_test.py

@@ -0,0 +1,210 @@
+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
+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 and test.reason != TEST_SUCCESS:
+        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):
+    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")
+    else:
+        #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}")
+        else:
+            test.add_reason(f"tx_queue: {tx_queue_HB}")
+            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}")
+        else:
+            test.add_reason(f"pacer_increment: {average_pacer_increment_HB}")
+            print(f"\naverage pacer_increment from HB: {average_pacer_increment_HB}\n")
+    return test
+
+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")
+        test.rc = TEST_FAILED
+        test.add_reason(f"df is empty, therefore will not check repetitions, brg latency and num of tags")
+    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]:
+            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}")
+        else:
+            test.add_reason(f"Repetition value: {average_payload_count}")
+            print(f"Repetition value is correct! got: {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}")
+        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}")
+        else:
+            brg_latency_avg = round(df[BRG_LATENCY].mean(),2)
+            print(f"Average brg_latency: {brg_latency_avg}")
+    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 
+    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")
+    check = False
+    test = metric_checking_df(test, check, pacer_interval, df, repetition_value_expected, brg_latency_expected, num_of_sim_tags)
+    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)
+    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")
+    check = True
+    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])
+    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.
+    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])
+    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])
+    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 or test.reason != TEST_SUCCESS:
+        return cert_common.test_epilog(test)
+    #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}
+    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.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)
+        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 and test.exit_on_param_failure:
+            break
+        else:
+            test.reset_result()
+        time.sleep(5)
+    pixel_sim_thread.stop()
+    # 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/datapath/tx_repetition_algo_test/tx_repetition_algo_test.json

@@ -0,0 +1,13 @@
+{
+    "name": "tx_repetition_algo_test",
+    "module": "datapath",
+    "purpose": "Test the tx repetition adjustment algorithm",
+    "documentaion": "<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,
+    "allSupportedValues": []
+}

brg_certificate/tests/datapath/tx_repetition_algo_test/tx_repetition_algo_test.py

@@ -0,0 +1,113 @@
+# 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, statistics, 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 or test.reason != TEST_SUCCESS:
+        return cert_common.test_epilog(test)
+
+    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
+
+    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/datapath/tx_repetition_test/tx_repetition_test.json

@@ -0,0 +1,13 @@
+{
+    "name": "tx_repetition_test",
+    "module": "datapath",
+    "purpose": "Test tx repetition feature configuration and functionality in the bridge for different tx repetition values",
+    "documentaion": "<TEST_DOCUMENTATION_LINK>",
+    "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"],
+    "expectedOutcome": "All values configured successfully and actual repetitions found matching to the configured values",
+    "mandatory": 1,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 0,
+    "allSupportedValues": [1, 2, 3, 4, 5, 6]
+}

brg_certificate/tests/datapath/tx_repetition_test/tx_repetition_test.py

@@ -0,0 +1,79 @@
+# 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
+
+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
+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()
+    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
+    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)
+        return test
+    pkt_payload_counter = {}
+    for p in pkts:
+        cur_pkt = p[PAYLOAD]
+        if cur_pkt in pkt_payload_counter:
+            pkt_payload_counter[cur_pkt] += 1
+        else:
+            pkt_payload_counter[cur_pkt] = 1
+    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)
+    if (avg / float(repetitions)) <= TX_REPETITION_THRESHOLD or (avg / float(repetitions)) > 1:
+        test.rc = TEST_FAILED
+        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)
+    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+        return cert_common.test_epilog(test)
+
+    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)
+
+    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]
+        if test.rc == TEST_FAILED and test.exit_on_param_failure:
+            break
+        tx_repetitions_analysis(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 and test.exit_on_param_failure:
+            break
+        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])