wiliot-certificate 1.5.3a1__py3-none-any.whl → 4.4.0__py3-none-any.whl

brg_certificate/tests/datapath/rx_rate_gen3_test/rx_rate_gen3_test.py

@@ -11,7 +11,7 @@ import time
 def cal_scan_time(test, delay, pacer_interval):
     # Calculate the scan time to ensure at least 5 packets are captured in data scan
     # define the num of packet that you want to get
-    num_of_sending_pkt = 3  # actually it will be 3 because the first one always send
+    num_of_sending_pkt = 2  # actually it will be 3 because the first one always send
     delay = delay / 1000
     if delay < pacer_interval:
         scan_time = (pacer_interval * num_of_sending_pkt) + 10
@@ -34,8 +34,8 @@ def scan_and_compare(test, pacer_interval, delay, expected_address_value):
     pixel_sim_thread.stop()
     cert_mqtt.dump_pkts(test, log="rx_rate")
     cert_common.display_data(df, tbc=True, nfpkt=True, rssi=True, dir=test.dir)
-
-    if df.empty:
+    # check if the dataframe is empty or not
+    if len(df) <= 1:
         print("Df is empty")
         test.rc = TEST_FAILED
         test.add_reason("Df is empty")
@@ -48,11 +48,16 @@ def scan_and_compare(test, pacer_interval, delay, expected_address_value):
         print(f"Most common tag: {most_common_tag}")
         df = df[df[TAG_ID] == most_common_tag]
         df = df[[TAG_ID, TBC, PACKET_TYPE, DATETIME]]
+        length = len(df)
+        mid_index = int(length // 2)
+        if mid_index == 0:
+            mid_index = 1
+        print(f"Length of df: {length}, mid index: {mid_index}")
         print(f"df:\n {df}")
 
         tag = df.iloc[0][TAG_ID]
         # iloc [1:] to skip the first value of tbc_values which could be 0 sometimes.
-        actual_address_value = round(df.iloc[1:][TBC].mean(), 2)  # extract the tbc value from df
+        actual_address_value = round(df.iloc[mid_index:][TBC].mean(), 2)  # extract the tbc value from df
         print(f"\nactual address value: {actual_address_value}\nexpected address value: {expected_address_value}")
         THRESHOLD_ADDRESS_VALUE = 5
         # check if the actual address value is in the range of -+5 of the expected address value
@@ -128,29 +133,28 @@ def max_value(test, datapath_module):
 def diff_rate(test, datapath_module):
     # diff rate - a filter: Generate packets with delay 1 and change to 5, according the delay change test the tolerance address value
     pacer_interval = 1
-    delay = {500: 5, 3000: 30}  # key=delay and value = the duration it will be activated
-    first_delay = list(delay.keys())[0]
-    first_duration = list(delay.values())[0]
-    second_delay = list(delay.keys())[1]
-
+    delay_duration = [[500, 5], [3000, 3]]
+    first_delay = delay_duration[0][0]
+    first_duration = delay_duration[0][1]
+    second_delay = delay_duration[1][0]
     test = cert_config.brg_configure(test, fields=[BRG_PACER_INTERVAL], values=[pacer_interval], module=datapath_module)[0]
     if test.rc == TEST_FAILED:
         test.add_reason(f"Didn't succeed to config pacer interval {pacer_interval}")
         return test
-    pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=1, duplicates=3,
+    pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=1, duplicates=2,
                                                    delay=first_delay, pkt_types=[0], pixels_type=GEN3)
     pixel_sim_thread.start()
     time_sleep = first_duration - ((first_delay / 1000) / 2)
     print(f"sleep for {time_sleep} sec\n")
     time.sleep(time_sleep)
     pixel_sim_thread.delay = second_delay
-    print(f"changing delay value to {second_delay}\n")
-    scan_time = sum(delay.values()) + 20
+    scan_time = sum(duration for _, duration in delay_duration) + 20
     df = cert_common.data_scan(test, scan_time=scan_time, brg_data=(not test.internal_brg), gw_data=test.internal_brg)
     pixel_sim_thread.stop()
     df = df[[TAG_ID, TBC]]
+    lenght = len(df)
 
-    if df.empty:
+    if len(df) <= 1:
         test.add_reason("Df is empty")
         test.rc = TEST_FAILED
         return test
@@ -158,50 +162,46 @@ def diff_rate(test, datapath_module):
         print(f"Df:\n {df}")
     # NOTE: all next rows are specific for the values: delay 0.5 and 3, and in relation address values 128 and 235
     # check if the last tbc value is as we expected  for delay 3 sec we need to get 235 according to LUT  table
-    # we define tolerance of +-2 units for address value
+    # we define tolerance of +-10 units for address value
+
+    # Most important check, verify it converges to the correct value
     if df.iloc[-1][TBC] not in range(232, 237):
         test.rc = TEST_FAILED
         test.add_reason(f"TBC value: {df.iloc[-1][TBC]}, expected value [232,236]")
         print(f"TBC value: {df.iloc[-1][TBC]}, expected value [232,236] according to delay:{second_delay / 1000} sec")
-    # skip the first packet in case the second one is still from the last delay value
-    index = 0
-    if df.iloc[1][TBC] in range(232, 237):
-        index = 1
-
-    # verify the first tbc value
-    first_tbc = df.iloc[index][TBC]
-    if first_tbc not in range(120, 145):
-        test.rc = TEST_FAILED
-        test.add_reason(f"TBC value: {first_tbc}, expected value [120,144]")
-        print(f"TBC value of last packet before the delay change is wrong\n"
-              f"TBC value: {first_tbc}, expected value [120,144] according to delay:{first_delay / 1000} sec")
-
-    # check the first change of tbc value after delay changing which is verify the calculation of alpha filter
-    second_tbc = df.iloc[index + 1][TBC]
-    expected_address_value = 200
-    # 4 is equal to 0.09 sec error
-    threshold = 4  # 2 equal to 0.04 sec error
-    if not expected_address_value - threshold <= second_tbc <= expected_address_value + threshold:
+        return test
+    # for loop that skip the first row and check if somewhere there is the expected gap 130 to 200
+    result = False
+    for i in range(0, lenght - 1):
+        prev = df.iloc[i][TBC]
+        current = df.iloc[i + 1][TBC]
+        if prev in range(120, 140) and current in range(190, 210):
+            print(f"Found the gap between {prev} and {current}")
+            print(f"row {i}: {df.iloc[i][TBC]}")
+            print(f"row {i + 1}: {df.iloc[i + 1][TBC]}")
+            result = True
+    if not result:
         test.rc = TEST_FAILED
-        test.add_reason(f"TBC value: {second_tbc}, expected value [196,204]")
-        print(f"first change of address value is wrong.\n"
-              f"alpha filter probably is not define well\n"
-              f"TBC value: {second_tbc}, expected value [196,204]")
+        test.add_reason("Didn't find the correct gap according to alpha filter calculation")
     return test
 
 
 def run(test):
+
     # "Test prolog"
     datapath_module = test.active_brg.datapath
-    test = cert_common.test_prolog(test)
-    if test.rc == TEST_FAILED:
-        return cert_common.test_epilog(test)
 
+    test = cert_common.test_prolog(test)
     pacer_interval = 1
     test = cert_config.brg_configure(test, fields=[BRG_PACER_INTERVAL], values=[pacer_interval], module=datapath_module)[0]
     if test.rc == TEST_FAILED:
         test.add_reason(f"Didn't succeed to config pacer interval {pacer_interval}")
-        return test
+    name = test.phases[0].name
+    test.set_phase_rc(name, test.rc)
+    test.add_phase_reason(name, test.reason)
+
+    if test.rc == TEST_FAILED:
+        return cert_common.test_epilog(test)
 
     RX_RATE_TEST_MAP = {"mid_values": mid_values, "diff_pacer": diff_pacer, "min_value": min_value,
                         "max_value": max_value, "diff_rate": diff_rate}
@@ -212,9 +212,9 @@ def run(test):
         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()
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+        test.reset_result()  # reset result and continue to next param
 
     return cert_common.test_epilog(test)

brg_certificate/tests/datapath/stress_gen3_test/stress_gen3_test.json

@@ -11,12 +11,11 @@
                   "rep 3 - config pacer interval 22, then check repetition value = 3, pacer increment = 0, num of tags = all tags",
                   "rep 2 - config pacer interval 12, then check repetition value = 2, pacer increment = 0, num of tags = all tags",
                   "rep 1 - config pacer interval 7, 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,
+    "mandatory": 0,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
     "internalBridge": 0,
-    "allSupportedValues": ["rep3", "rep2", "rep1", "rep1_adaptive_pacer"]
+    "allSupportedValues": ["rep3", "rep2", "rep1"]
 }

brg_certificate/tests/datapath/stress_gen3_test/stress_gen3_test.py

@@ -11,8 +11,13 @@ import time
 
 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 skip all checks\n")
-        print("Didn't find HB pkt, therefore will not check tx_queue and pacer increment")
+        if check:
+            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:
+            test.rc = TEST_PASSED  # skip the rc result if we didn't find HB pkt
+            print("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]
@@ -30,7 +35,7 @@ def metric_checking_HB(test, check, mgmt_type_list, tx_queue_expected, pacer_inc
             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}")
+                test.add_reason(f"pacer_increment: {average_pacer_increment_HB} expected: {pacer_increment_expected}")
         else:
             print(f"\naverage pacer_increment from HB: {average_pacer_increment_HB}\n")
             if check:
@@ -96,7 +101,7 @@ def combination_func(test, param, datapath_module, pacer_interval, num_of_sim_ta
             test = metric_checking_HB(test, check, hbs, tx_queue_expected, pacer_increment_expected)
             return test
         else:
-            # in case it failed because the repetition value.
+            # in case it failed because the repetition value. the reason has been added in the metric_checking_df function
             return test
 
     time.sleep(30)
@@ -107,8 +112,8 @@ def combination_func(test, param, datapath_module, pacer_interval, num_of_sim_ta
     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)
+    test = metric_checking_HB(test, check, hbs, tx_queue_expected, pacer_increment_expected)
     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)
@@ -117,8 +122,10 @@ def combination_func(test, param, datapath_module, pacer_interval, num_of_sim_ta
     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)
+    if param.name != "rep1":
+        check = False
+    test = metric_checking_HB(test, check, hbs, tx_queue_expected, pacer_increment_expected)
     return test
 
 
@@ -147,7 +154,7 @@ def rep1(test, param, datapath_module, num_of_sim_tags):
     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])
+                            pacer_increment_expected=[0, 25], brg_latency_expected=[200, 300])
     time.sleep(5)
     return test
 
@@ -172,10 +179,7 @@ def run(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}
+    STRESS_TEST_MAP = {"rep3": rep3, "rep2": rep2, "rep1": rep1}
     num_of_pixels = 300
     pixel_sim_thread = cert_data_sim.DataSimThread(test=test,
                                                    num_of_pixels=num_of_pixels,
@@ -192,11 +196,11 @@ def run(test):
         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)
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+        test.reset_result()  # reset result and continue to next param
+
     pixel_sim_thread.stop()
     # Re-enable unified packets deduplication
     cert_config.gw_action(test, f"{DEDUPLICATION_PKTS} 1")

brg_certificate/tests/datapath/stress_test/stress_test.json

@@ -11,12 +11,11 @@
                   "rep 3 - config pacer interval 22, then check repetition value = 3, pacer increment = 0, num of tags = all tags",
                   "rep 2 - config pacer interval 12, then check repetition value = 2, pacer increment = 0, num of tags = all tags",
                   "rep 1 - config pacer interval 7, 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,
+    "mandatory": 0,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
     "internalBridge": 0,
-    "allSupportedValues": ["rep3", "rep2", "rep1", "rep1_adaptive_pacer"]
+    "allSupportedValues": ["rep3", "rep2", "rep1"]
 }

brg_certificate/tests/datapath/stress_test/stress_test.py

@@ -11,8 +11,12 @@ import time
 
 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 skip all checks\n")
-        print("Didn't find HB pkt, therefore will not check tx_queue and pacer increment")
+        if check:
+            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:
+            test.rc = TEST_PASSED  # skip the rc result if we didn't find HB pkt
+            print("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]
@@ -30,7 +34,7 @@ def metric_checking_HB(test, check, mgmt_type_list, tx_queue_expected, pacer_inc
             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}")
+                test.add_reason(f"pacer_increment: {average_pacer_increment_HB} expected: {pacer_increment_expected}")
         else:
             print(f"\naverage pacer_increment from HB: {average_pacer_increment_HB}\n")
             if check:
@@ -96,7 +100,7 @@ def combination_func(test, param, datapath_module, pacer_interval, num_of_sim_ta
             test = metric_checking_HB(test, check, hbs, tx_queue_expected, pacer_increment_expected)
             return test
         else:
-            # in case it failed because the repetition value.
+            # in case it failed because the repetition value. the reason has been added in the metric_checking_df function
             return test
 
     time.sleep(30)
@@ -107,8 +111,8 @@ def combination_func(test, param, datapath_module, pacer_interval, num_of_sim_ta
     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)
+    test = metric_checking_HB(test, check, hbs, tx_queue_expected, pacer_increment_expected)
     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)
@@ -117,8 +121,10 @@ def combination_func(test, param, datapath_module, pacer_interval, num_of_sim_ta
     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)
+    if param.name != "rep1":
+        check = False
+    test = metric_checking_HB(test, check, hbs, tx_queue_expected, pacer_increment_expected)
     return test
 
 
@@ -147,7 +153,7 @@ def rep1(test, param, datapath_module, num_of_sim_tags):
     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])
+                            pacer_increment_expected=[0, 25], brg_latency_expected=[200, 300])
     time.sleep(5)
     return test
 
@@ -172,10 +178,7 @@ def run(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}
+    STRESS_TEST_MAP = {"rep3": rep3, "rep2": rep2, "rep1": rep1}
     num_of_pixels = 300
     pixel_sim_thread = cert_data_sim.DataSimThread(test=test,
                                                    num_of_pixels=num_of_pixels,
@@ -192,11 +195,11 @@ def run(test):
         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)
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+        test.reset_result()  # reset result and continue to next param
+
     pixel_sim_thread.stop()
     # Re-enable unified packets deduplication
     cert_config.gw_action(test, f"{DEDUPLICATION_PKTS} 1")

brg_certificate/tests/datapath/tx_repetition_test/tx_repetition_test.json

@@ -9,7 +9,7 @@
                   "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,
+    "mandatory": 0,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
     "internalBridge": 0,

brg_certificate/tests/datapath/tx_repetition_test/tx_repetition_test.py

@@ -58,24 +58,26 @@ def run(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
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+            else:
+                test.reset_result()   # reset result and continue to next param
+                continue
         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()
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+        test.reset_result()  # reset result and continue to next param
 
     # 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/edge_mgmt/actions_test/actions_test.json

@@ -6,7 +6,7 @@
     "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,
+    "mandatory": 0,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
     "internalBridge": 1,

brg_certificate/tests/edge_mgmt/actions_test/actions_test.py

@@ -388,9 +388,9 @@ def run(test):
         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()
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+        test.reset_result()  # reset result and continue to next param
 
     return cert_common.test_epilog(test)

brg_certificate/tests/energy2400/duty_cycle_test/duty_cycle_test.json

@@ -8,7 +8,7 @@
                   "For each supported value - configure the BRG and verify the value",
                   "Test epilog and revert to defaults"],
     "expectedOutcome": "All values configured successfully",
-    "mandatory": 1,
+    "mandatory": 0,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
     "internalBridge": 1,

brg_certificate/tests/energy2400/duty_cycle_test/duty_cycle_test.py

@@ -19,9 +19,9 @@ def run(test):
         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()
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+        test.reset_result()  # reset result and continue to next param
 
     return cert_common.test_epilog(test, revert_brgs=True, modules=[energy2400_module])

brg_certificate/tests/energy2400/output_power_test/output_power_test.json

@@ -8,7 +8,7 @@
                   "For each supported value - configure the BRG and verify the value",
                   "Test epilog and revert to defaults"],
     "expectedOutcome": "All values configured successfully",
-    "mandatory": 1,
+    "mandatory": 0,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
     "internalBridge": 1,

brg_certificate/tests/energy2400/output_power_test/output_power_test.py

@@ -20,9 +20,9 @@ def run(test):
         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()
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+        test.reset_result()  # reset result and continue to next param
 
     return cert_common.test_epilog(test, revert_brgs=True, modules=[energy2400_module])

brg_certificate/tests/energy2400/pattern_test/pattern_test.json

@@ -8,7 +8,7 @@
                   "For each supported value - configure the BRG and verify the value",
                   "Test epilog and revert to defaults"],
     "expectedOutcome": "All values configured successfully",
-    "mandatory": 1,
+    "mandatory": 0,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
     "internalBridge": 1,

brg_certificate/tests/energy2400/pattern_test/pattern_test.py

@@ -21,9 +21,9 @@ def run(test):
         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()
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+        test.reset_result()  # reset result and continue to next param
 
     return cert_common.test_epilog(test, revert_brgs=True, modules=[energy2400_module])

brg_certificate/tests/energy2400/signal_indicator_test/signal_indicator_test.py

@@ -249,10 +249,12 @@ def run(test):
         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()
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+            else:
+                test.reset_result()  # reset result and continue to next param
+                continue
 
         # Reset to defaults after every phase (don't fail the phase on that)
         test = cert_config.config_brg_defaults(test, modules=[test.brg0.energy2400, test.brg0.sensors])[0]

brg_certificate/tests/energy_sub1g/duty_cycle_test/duty_cycle_test.json

@@ -8,7 +8,7 @@
                   "For each supported value - configure the BRG and verify the value",
                   "Test epilog and revert to defaults"],
     "expectedOutcome": "All values configured successfully",
-    "mandatory": 1,
+    "mandatory": 0,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
     "internalBridge": 1,

brg_certificate/tests/energy_sub1g/duty_cycle_test/duty_cycle_test.py

@@ -20,9 +20,9 @@ def run(test):
         field_functionality_pass_fail_print(test, fields, 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()
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+        test.reset_result()  # reset result and continue to next param
 
     return cert_common.test_epilog(test, revert_brgs=True, modules=[sub1g_module])

brg_certificate/tests/energy_sub1g/pattern_test/pattern_test.json

@@ -8,7 +8,7 @@
                   "For each supported value - configure the BRG and verify the value",
                   "Test epilog and revert to defaults"],
     "expectedOutcome": "All values configured successfully",
-    "mandatory": 1,
+    "mandatory": 0,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
     "internalBridge": 1,

brg_certificate/tests/energy_sub1g/pattern_test/pattern_test.py

@@ -19,9 +19,9 @@ def run(test):
         field_functionality_pass_fail_print(test, fields, 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()
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+        test.reset_result()  # reset result and continue to next param
 
     return cert_common.test_epilog(test, revert_brgs=True, modules=[sub1g_module])

brg_certificate/tests/energy_sub1g/signal_indicator_test/signal_indicator_test.json

@@ -8,7 +8,7 @@
                   "For each supported value - configure the BRG and verify the value",
                   "Test epilog and revert to defaults"],
     "expectedOutcome": "All values configured successfully",
-    "mandatory": 1,
+    "mandatory": 0,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
     "internalBridge": 1,

brg_certificate/tests/energy_sub1g/signal_indicator_test/signal_indicator_test.py

@@ -20,9 +20,9 @@ def run(test):
         generate_log_file(test, param_name)
         test.set_phase_rc(param.name, test.rc)
         test.add_phase_reason(param.name, test.reason)
-        if test.rc == TEST_FAILED and test.exit_on_param_failure:
-            break
-        else:
-            test.reset_result()
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+        test.reset_result()  # reset result and continue to next param
 
     return cert_common.test_epilog(test, revert_brgs=True, modules=[sub1g_module])

brg_certificate/tests/sensors/ext_sensor_test/ext_sensor_test.json

@@ -2,7 +2,7 @@
     "name": "External Sensors",
     "module": "BLE Sensor",
     "purpose": "Verify the external_sensor module functionality - configuration, data collection and data transmission.",
-    "documentation": "<TEST_DOCUMENTATION_LINK>",
+    "documentation": "<https://community.wiliot.com/customers/s/article/Wiliot-Network-Bridge-Modular-Architecture>",
     "initialCondition": "Bridge configured to defaults",
     "procedure": ["Test prolog",
     "tag_data_only - No external sensor configured, only tag data is expected.",