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

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
 
@@ -165,17 +171,14 @@ def rep1_adaptive_pacer(test, param, datapath_module, num_of_sim_tags):
 
 def run(test):
     # Test prolog
-    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
+    datapath_module = test.active_brg.datapath
     test = cert_common.test_prolog(test)
     if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test, revert_brgs=True, modules=[datapath_module])
     # config GW deduplication pkts = 0
     print("Configuring GW with !deduplication_pkts 0")
     cert_config.gw_action(test, f"{DEDUPLICATION_PKTS} 0")
-    if test.rc == TEST_FAILED and test.exit_on_param_failure:
-        return cert_common.test_epilog(test, revert_gws=True)
-
-    STRESS_TEST_MAP = {"rep3": rep3, "rep2": rep2, "rep1": rep1, "rep1_adaptive_pacer": rep1_adaptive_pacer}
+    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_algo_test/tx_repetition_algo_test.py

@@ -100,7 +100,7 @@ def run(test):
     if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
 
-    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
+    datapath_module = test.active_brg.datapath
 
     print("Configuring GW")
     # Set packets deduplication off to count the number of pkts from the BRG

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

@@ -50,7 +50,7 @@ def tx_repetitions_analysis(test, repetitions):
 def run(test):
 
     fields = [BRG_TX_REPETITION, BRG_PKT_FILTER, BRG_RX_CHANNEL]
-    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
+    datapath_module = test.active_brg.datapath
 
     test = cert_common.test_prolog(test)
     if test.rc == TEST_FAILED:
@@ -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

@@ -34,26 +34,26 @@ LIS2DW12_NON_DEFAULT_SLEEP_DURATION = 35
 
 def get_brg_non_default_module_pkt(test, module):
     if 'Energy2400' in module.__name__:
-        return cert_config.get_default_brg_pkt(test, pkt_type=eval_pkt(f'ModuleEnergy2400V{test.active_brg.api_version}'),
+        return cert_config.get_default_brg_pkt(test, pkt_type=test.active_brg.energy2400,
                                                duty_cycle=BRG_NON_DEFAULT_DUTY_CYCLE,
                                                output_power=BRG_NON_DEFAULT_OP_2_4, pattern=BRG_NON_DEFAULT_EP_2_4,
                                                signal_indicator_cycle=BRG_NON_DEFAULT_SIGNAL_INDICATOR_CYCLE_2_4,
                                                signal_indicator_rep=BRG_NON_DEFAULT_SIGNAL_INDICATOR_REP_2_4)
     elif 'EnergySub1G' in module.__name__:
-        return cert_config.get_default_brg_pkt(test, pkt_type=eval_pkt(f'ModuleEnergySub1GV{test.active_brg.api_version}'),
+        return cert_config.get_default_brg_pkt(test, pkt_type=test.active_brg.energy_sub1g,
                                                duty_cycle=BRG_NON_DEFAULT_DUTY_CYCLE,
                                                signal_indicator_cycle=BRG_NON_DEFAULT_SIGNAL_INDICATOR_CYCLE_SUB1G,
                                                signal_indicator_rep=BRG_NON_DEFAULT_SIGNAL_INDICATOR_REP_SUB1G)
     elif 'PwrMgmt' in module.__name__:
-        return cert_config.get_default_brg_pkt(test, pkt_type=eval_pkt(f'ModulePwrMgmtV{test.active_brg.api_version}'),
+        return cert_config.get_default_brg_pkt(test, pkt_type=test.active_brg.pwr_mgmt,
                                                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}'),
+        return cert_config.get_default_brg_pkt(test, pkt_type=test.active_brg.custom,
                                                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}'),
+        return cert_config.get_default_brg_pkt(test, pkt_type=test.active_brg.datapath,
                                                tx_repetition=BRG_NON_DEFAULT_TX_REPETITION,
                                                pkt_filter=BRG_NON_DEFAULT_PKT_FILTER,
                                                output_power=BRG_NON_DEFAULT_OP_2_4,
@@ -61,12 +61,12 @@ def get_brg_non_default_module_pkt(test, module):
                                                pacer_interval=BRG_NON_DEFAULT_PACER_INTERVAL,
                                                rssi_threshold=BRG_NON_DEFAULT_RSSI_THRESHOLD)
     elif 'Calibration' in module.__name__:
-        return cert_config.get_default_brg_pkt(test, pkt_type=eval_pkt(f'ModuleCalibrationV{test.active_brg.api_version}'),
+        return cert_config.get_default_brg_pkt(test, pkt_type=test.active_brg.calibration,
                                                output_power=BRG_NON_DEFAULT_CALIB_OUTPUT_POWER,
                                                interval=BRG_NON_DEFAULT_CALIB_INTERVAL,
                                                pattern=BRG_NON_DEFAULT_CALIB_PATTERN)
     elif 'ExtSensors' in module.__name__:
-        return cert_config.get_default_brg_pkt(test, pkt_type=eval_pkt(f'ModuleExtSensorsV{test.active_brg.api_version}'),
+        return cert_config.get_default_brg_pkt(test, pkt_type=test.active_brg.sensors,
                                                sensor0=ag.EXTERNAL_SENSORS_MINEWS1,
                                                sensor1=ag.EXTERNAL_SENSORS_VOLTAIC_BATT_LEVEL_DONGLE,
                                                rssi_threshold=BRG_NON_DEFAULT_RSSI_THRESHOLD,
@@ -253,7 +253,7 @@ def test_action_get_module(test):
     cert_config.send_brg_action(test, ag.ACTION_GET_MODULE, datapath=1)
     # analysis
     test = search_action_ack(test, ag.ACTION_GET_MODULE, datapath=1)
-    test = scan_for_modules(test, [eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')])
+    test = scan_for_modules(test, [test.active_brg.datapath])
     if test.rc == TEST_FAILED:
         return test
 
@@ -349,7 +349,7 @@ def test_action_restore_defaults(test):
                         if ag.MODULE_ENERGY_SUB1G in test.active_brg.sup_caps and cfg_once:
                             cfg_once = False
                             cfg_pkt = cert_config.get_default_brg_pkt(test,
-                                                                      eval_pkt(f'ModuleEnergySub1GV{test.active_brg.api_version}'),
+                                                                      test.active_brg.energy_sub1g,
                                                                       **{BRG_PATTERN: ag.SUB1G_ENERGY_PATTERN_ISRAEL})
                             test = cert_config.brg_configure(test, cfg_pkt=cfg_pkt)[0]
                             if test.rc == TEST_FAILED:
@@ -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/edge_mgmt/brg2brg_ota_ble5_test/brg2brg_ota_ble5_test.py

@@ -65,7 +65,7 @@ def run(test):
     utPrint(f"Configuring destination BRG {dest_brg.id_str} to RX Channel 10!")
     test.active_brg = dest_brg
     test = cert_config.brg_configure_ble5(test, fields=[BRG_RX_CHANNEL], values=[ag.RX_CHANNEL_10_250K],
-                                          module=eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}'))[0]
+                                          module=test.active_brg.datapath)[0]
     test.active_brg = src_brg
     time.sleep(5)
 

brg_certificate/tests/edge_mgmt/leds_test/leds_test.py

@@ -114,7 +114,7 @@ def run(test):
     # Energizing is OFF
     #  Default cfg for 2400 is 0 == no energizing so we only eliminating sub1g energizing
     utPrint("Configuring the BRG to no energizing in sub1g", "WARNING")
-    sub1g_module = eval_pkt(f'ModuleEnergySub1GV{test.active_brg.api_version}')
+    sub1g_module = test.active_brg.energy_sub1g
     test = cert_config.brg_configure(test, fields=[BRG_PATTERN], values=[ag.SUB1G_ENERGY_PATTERN_NO_ENERGIZING], module=sub1g_module)[0]
     if test.rc == TEST_FAILED and test.exit_on_param_failure:
         return cert_common.test_epilog(test, revert_brgs=True, modules=[sub1g_module])
@@ -190,7 +190,7 @@ def run(test):
     # ------------- Power management sleep & Keep Alive Mode ------------- #
     utPrint("Power management Sleep state & Keep Alive Mode check!", "HEADER")
     utPrint("Sending the BRG power management configuration in order to enter sleep state", "WARNING")
-    pwr_mgmt_module = eval_pkt(f'ModulePwrMgmtV{test.active_brg.api_version}')
+    pwr_mgmt_module = test.active_brg.pwr_mgmt
     test, wltpkt = cert_common.brg_pwr_mgmt_turn_on(test)
     if test.rc == TEST_FAILED and test.exit_on_param_failure:
         # Preventing leaving brg in pwr mgmt, protection for on that worked yet no ack was received

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

@@ -8,7 +8,7 @@ import brg_certificate.cert_config as cert_config
 def run(test):
 
     fields = [BRG_DUTY_CYCLE]
-    energy2400_module = eval_pkt(f'ModuleEnergy2400V{test.active_brg.api_version}')
+    energy2400_module = test.active_brg.energy2400
 
     test = cert_common.test_prolog(test)
     if test.rc == TEST_FAILED:
@@ -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

@@ -8,7 +8,7 @@ import brg_certificate.cert_config as cert_config
 def run(test):
 
     fields = [BRG_OUTPUT_POWER]
-    energy2400_module = eval_pkt(f'ModuleEnergy2400V{test.active_brg.api_version}')
+    energy2400_module = test.active_brg.energy2400
 
     test = cert_common.test_prolog(test)
     if test.rc == TEST_FAILED:
@@ -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

@@ -8,7 +8,7 @@ import brg_certificate.cert_config as cert_config
 def run(test):
 
     fields = [BRG_PATTERN]
-    energy2400_module = eval_pkt(f'ModuleEnergy2400V{test.active_brg.api_version}')
+    energy2400_module = test.active_brg.energy2400
 
     test = cert_common.test_prolog(test)
     if test.rc == TEST_FAILED:
@@ -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_ble5_10_250k_test/signal_indicator_ble5_10_250k_test.json

@@ -6,7 +6,7 @@
     "initialCondition": "Bridge configured to defaults",
     "procedure": ["Test prolog",
     "rssi_threshold - check the if rssi value is between 0 to -25.",
-    "brg0_rx_brg1_tx - one brg is transmitter and the second is receiver, we expect to get the same values from the receiver, according to the tx params",
+    "brg0_tx_brg1_rx - one brg is transmitter and the second is receiver, we expect to get the same values from the receiver, according to the tx params",
     "brg0_none_brg1_rx - One rx BRG without any tx BRG. We don't expect to see any signal indicator packets.",
     "brg0_rxtx_brg1_rxtx - Both BRG's will be configured to be transmitters and receivers, with different tx params for each one. we expect to see signal indicator packets from both BRG's, according to the tx params.",
     "brg0_tx_brg1_none - One BRG will be configured as signal indicator tx, but no rx, so we don't expect to receive signal indicator packets.",
@@ -16,5 +16,5 @@
     "multiBridgeTest": 1,
     "gwOnlyTest": 0,
     "internalBridge": 1,
-    "allSupportedValues": ["rssi_threshold", "brg0_rx_brg1_tx", "brg0_none_brg1_rx", "brg0_rxtx_brg1_rxtx", "brg0_tx_brg1_none"]
+    "allSupportedValues": ["rssi_threshold", "brg0_tx_brg1_rx", "brg0_none_brg1_rx", "brg0_rxtx_brg1_rxtx", "brg0_tx_brg1_none"]
 }