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

brg_certificate/tests/datapath/rx_rate_gen3_test/rx_rate_gen3_test.json

@@ -1,9 +1,7 @@
 {
     "name": "rx_rate_gen3",
-    "module": "DataPath",
-    "purpose": [
-        "Verify the accuracy of the RX rate value"
-    ],
+    "module": "datapath",
+    "purpose": ["Verify the accuracy of the RX rate value"],
     "documentation": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Pacing",
     "initialCondition": "Bridge set to default configuration",
     "procedure": [
@@ -17,5 +15,6 @@
     "mandatory": 1,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
+    "internalBridge": 1,
     "allSupportedValues": ["mid_values", "diff_pacer", "min_value", "max_value", "diff_rate"]
 }

brg_certificate/tests/datapath/rx_rate_gen3_test/rx_rate_gen3_test.py

@@ -184,7 +184,7 @@ 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:
+    if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
     
     fields = [BRG_PACER_INTERVAL]

brg_certificate/tests/datapath/stress_gen3_test/stress_gen3_test.json

@@ -1,30 +1,22 @@
 {
     "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"
-    ],
+    "module": "datapath",
+    "purpose": ["verify the functionality of the bridge under stress conditions",
+                "verify that the algorithms 'adaptive repetition' and 'adaptive pacer' are working correctly"],
+    "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"
-    ],
+    "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, pacer increment = 0, num of tags = all tags",
+                  "rep 2 - config pacer interval 9, then check repetition value = 2, pacer increment = 0, num of tags = all tags",
+                  "rep 1 - config pacer interval 6, then check repetition value = 1, pacer increment = 0, num of tags = all tags",
+                  "rep 1 adaptive pacer - config pacer interval 1, then check repetition value = 1, pacer increment = 3 , num of tags = all tags",
+                  "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"]
-
+    "internalBridge": 0,
+    "allSupportedValues": ["rep3", "rep2", "rep1", "rep1_adaptive_pacer"]
 }

brg_certificate/tests/datapath/stress_gen3_test/stress_gen3_test.py

@@ -6,13 +6,11 @@ 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:
+    if test.rc == TEST_FAILED:
         for i in range(num_of_times):
             if test.rc == TEST_PASSED:
                 return test
@@ -32,16 +30,15 @@ def metric_checking_HB(test, mgmt_type_list, tx_queue_expected, pacer_increment_
         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 value is wrong!  expected: {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")
+            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.rc = TEST_FAILED
             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:
@@ -65,32 +62,30 @@ def metric_checking_df(test, check,  pacer_interval, df, repetition_value_expect
                 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}")
-    
+            if check:
+                test.add_reason(f"Repetition value: {average_payload_count}")
+                print(f"Repetition value is correct! got: {average_payload_count}")
+            else:
+                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
+        brg_latency_avg = round(df[BRG_LATENCY].mean(),2)
         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 
 
@@ -117,32 +112,37 @@ def combination_func(test, datapath_module, pacer_interval, num_of_sim_tags, rep
     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):
+def rep3(test, 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 , 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):
+def rep2(test, 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, 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])
     time.sleep(5)
     return test
 
-def rep1(test, datapath_module, num_of_sim_tags, pixel_sim_thread):
+def rep1(test, 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 , 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):
+def rep1_adaptive_pacer(test, 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 , 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"
+    #NOTE: I skipped this phase 
+    # "pixel_burst - 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)
@@ -171,7 +171,7 @@ 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:
+    if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
     #config GW deduplication pkts = 0  "
     print("Configuring GW with !deduplication_pkts 0")
@@ -179,14 +179,14 @@ def run(test):
     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=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)
+        test = STRESS_TEST_MAP[param.value](test, datapath_module, num_of_pixels)
         generate_log_file(test, param.name)
         field_functionality_pass_fail_print(test, param.name)
         test.set_phase_rc(param.name, test.rc)

brg_certificate/tests/datapath/stress_test/stress_test.json

@@ -1,30 +1,23 @@
 {
     "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"
-    ],
+    "module": "datapath",
+    "purpose": ["verify the functionality of the bridge under stress conditions",
+                "verify that the algorithms 'adaptive repetition' and 'adaptive pacer' are working correctly"],
+    "documentation": ["https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Relaying-data"],
     "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"
-    ],
+        "rep 3 - config pacer interval 15, then check repetition value = 3, pacer increment = 0, num of tags = all tags  ",
+        "rep 2 - config pacer interval 9, then check repetition value = 2, pacer increment = 0, num of tags = all tags",
+        "rep 1 - config pacer interval 6, then check repetition value = 1, pacer increment = 0, num of tags = all tags",
+        "rep 1 adaptive pacer - config pacer interval 1, then check repetition value = 1, pacer increment = 3 , num of tags = all tags", 
+        "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"]
+    "internalBridge": 1,
+    "allSupportedValues": ["rep3", "rep2", "rep1", "rep1_adaptive_pacer"]
 
 }

brg_certificate/tests/datapath/stress_test/stress_test.py

@@ -10,7 +10,7 @@ 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:
+    if test.rc == TEST_FAILED:
         for i in range(num_of_times):
             if test.rc == TEST_PASSED:
                 return test
@@ -30,16 +30,15 @@ def metric_checking_HB(test, mgmt_type_list, tx_queue_expected, pacer_increment_
         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 value is wrong!  expected: {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")
+            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.rc = TEST_FAILED
             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:
@@ -63,32 +62,30 @@ def metric_checking_df(test, check,  pacer_interval, df, repetition_value_expect
                 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}")
-    
+            if check:
+                test.add_reason(f"Repetition value: {average_payload_count}")
+                print(f"Repetition value is correct! got: {average_payload_count}")
+            else:
+                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
+        brg_latency_avg = round(df[BRG_LATENCY].mean(),2)
         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 
 
@@ -99,9 +96,6 @@ def combination_func(test, datapath_module, pacer_interval, num_of_sim_tags, rep
     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
@@ -118,29 +112,28 @@ def combination_func(test, datapath_module, pacer_interval, num_of_sim_tags, rep
     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):
+def rep3(test, 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 , 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):
+def rep2(test, 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, 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):
+def rep1(test, 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 , 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):
+def rep1_adaptive_pacer(test, 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 , 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])
@@ -148,8 +141,8 @@ def rep1_adaptive_pacer(test, datapath_module, num_of_sim_tags, pixel_sim_thread
     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 "
+    #NOTE: I skipped this phase 
+    # "pixel_burst - 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)
@@ -178,7 +171,7 @@ 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:
+    if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
     #config GW deduplication pkts = 0  "
     print("Configuring GW with !deduplication_pkts 0")
@@ -186,14 +179,14 @@ def run(test):
     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.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, 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)

brg_certificate/tests/datapath/tx_repetition_algo_test/tx_repetition_algo_test.json

@@ -2,12 +2,16 @@
     "name": "tx_repetition_algo_test",
     "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

@@ -92,7 +92,7 @@ def tx_rep_analysis(test):
 def run(test):
 
     test = cert_common.test_prolog(test)
-    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+    if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
 
     datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')

brg_certificate/tests/datapath/tx_repetition_test/tx_repetition_test.json

@@ -2,12 +2,16 @@
     "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>",
+    "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

@@ -52,7 +52,7 @@ def run(test):
     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:
+    if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
 
     print("Configuring GW with !deduplication_pkts 0")

brg_certificate/tests/edge_mgmt/actions_test/actions_test.json

@@ -2,12 +2,13 @@
     "name": "actions_test",
     "module": "edge_mgmt",
     "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

@@ -51,9 +51,9 @@ def get_brg_non_default_module_pkt(test, module):
                                                dynamic_keep_alive_scan=BRG_NON_DEFAULT_PWR_MGMT_KEEP_ALIVE_SCAN)
     elif 'Custom' in module.__name__:
         return cert_config.get_default_brg_pkt(test, pkt_type=eval_pkt(f'ModuleCustomV{test.active_brg.api_version}'),
-                                               state_threshold=LIS2DW12_NON_DEFAULT_STATE_THRESHOLD,
-                                               wake_up_duration=LIS2DW12_NON_DEFAULT_WAKE_UP_DURATION,
-                                               sleep_duration=LIS2DW12_NON_DEFAULT_SLEEP_DURATION)
+                                               motion_sensitivity_threshold=LIS2DW12_NON_DEFAULT_STATE_THRESHOLD,
+                                               s2d_transition_time=LIS2DW12_NON_DEFAULT_WAKE_UP_DURATION,
+                                               d2s_transition_time=LIS2DW12_NON_DEFAULT_SLEEP_DURATION)
     elif 'Datapath' in module.__name__:
         return cert_config.get_default_brg_pkt(test, pkt_type=eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}'),
                                                tx_repetition=BRG_NON_DEFAULT_TX_REPETITION,
@@ -183,26 +183,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:
@@ -412,7 +392,7 @@ ACTIONS_TEST_MAP = {ag.ACTION_GW_HB: test_action_gw_hb, ag.ACTION_BLINK: test_ac
 
 def run(test):
     test = cert_common.test_prolog(test)
-    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+    if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
 
     for param in test.params:

brg_certificate/tests/edge_mgmt/brg2brg_ota_ble5_test/brg2brg_ota_ble5_test.json

@@ -2,12 +2,13 @@
     "name": "brg2brg_ota_test",
     "module": "edge_mgmt",
     "purpose": "TODO",
-    "documentaion": "<TEST_DOCUMENTATION_LINK>",
+    "documentation": "<TEST_DOCUMENTATION_LINK>",
     "initialCondition": "TODO",
     "procedure": ["Test prolog", "TODO", "Test epilog"],
     "expectedOutcome": "TODO",
     "mandatory": 0,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
+    "internalBridge": 1,
     "allSupportedValues": ["BOOTLOADER", "APP"]
 }

brg_certificate/tests/edge_mgmt/brg2brg_ota_ble5_test/brg2brg_ota_ble5_test.py

@@ -42,7 +42,7 @@ def run(test):
         test.add_reason(BOARDS_MISMATCH)
         test.rc = TEST_FAILED
 
-    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+    if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test, revert_brgs=True)
 
     # Decide on source and destination bridges

brg_certificate/tests/edge_mgmt/brg2brg_ota_test/brg2brg_ota_test.json

@@ -2,12 +2,13 @@
     "name": "brg2brg_ota_test",
     "module": "edge_mgmt",
     "purpose": "TODO",
-    "documentaion": "<TEST_DOCUMENTATION_LINK>",
+    "documentation": "<TEST_DOCUMENTATION_LINK>",
     "initialCondition": "TODO",
     "procedure": ["Test prolog", "TODO", "Test epilog"],
     "expectedOutcome": "TODO",
     "mandatory": 0,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
+    "internalBridge": 1,
     "allSupportedValues": ["BOOTLOADER", "APP"]
 }

brg_certificate/tests/edge_mgmt/brg2brg_ota_test/brg2brg_ota_test.py

@@ -42,7 +42,7 @@ def run(test):
         test.add_reason(BOARDS_MISMATCH)
         test.rc = TEST_FAILED
 
-    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+    if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test, revert_brgs=True)
 
     # Decide on source and destination bridges

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",
+    "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": []
 }