wiliot-certificate 4.5.0a1__py3-none-any.whl → 4.5.0a3__py3-none-any.whl

certificate/tests/datapath/pkt_filter_brg2gw_ext_adv_test/pkt_filter_brg2gw_ext_adv_test.py

@@ -12,15 +12,16 @@ PKT_FILTER_TEST_PACER_INTERVAL = 4
 def run(test):
 
     fields = [BRG_PKT_FILTER, BRG_RX_CHANNEL, BRG_PACER_INTERVAL, BRG_PATTERN]
-    datapath_module = eval(f'ModuleDatapathV{test.active_brg.api_version}')
+    dut = cert_config.get_brg_by_target(test, DUT)
 
     test = cert_common.test_prolog(test)
     if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
 
-    test = cert_config.brg_configure_ble5(test, fields=fields, values=[PKT_FILTER_TEMP_AND_ADVANCED_PKTS,
-                                          RX_CHANNEL_10_500K, PKT_FILTER_TEST_PACER_INTERVAL,
-                                          DATAPATH_PATTERN_EXTENDED_ADV], module=datapath_module)[0]
+    test = cert_config.brg_configure(test, fields=fields,
+                                     values=[PKT_FILTER_TEMP_AND_ADVANCED_PKTS, RX_CHANNEL_10_500K,
+                                             PKT_FILTER_TEST_PACER_INTERVAL, DATAPATH_PATTERN_EXTENDED_ADV],
+                                     module=dut.datapath, ble5=test.dut_is_bridge())[0]
     if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
 
@@ -41,9 +42,10 @@ def run(test):
 
         # Configure the BRG to DATAPATH_PATTERN_EXTENDED_ADV_CH_10 if the GW listens to channel 10
         if param.value == RX_CHANNEL_10_500K:
-            test = cert_config.brg_configure_ble5(test, fields=fields, values=[PKT_FILTER_TEMP_AND_ADVANCED_PKTS,
-                                                  RX_CHANNEL_10_500K, PKT_FILTER_TEST_PACER_INTERVAL,
-                                                  DATAPATH_PATTERN_EXTENDED_ADV_CH_10], module=datapath_module)[0]
+            test = cert_config.brg_configure(test, fields=fields,
+                                             values=[PKT_FILTER_TEMP_AND_ADVANCED_PKTS, RX_CHANNEL_10_500K,
+                                                     PKT_FILTER_TEST_PACER_INTERVAL, DATAPATH_PATTERN_EXTENDED_ADV_CH_10],
+                                             module=dut.datapath, ble5=test.dut_is_bridge())[0]
             if test.rc == TEST_FAILED:
                 if test.exit_on_param_failure:
                     break  # break the whole for loop and keep the test as failed
@@ -80,4 +82,4 @@ def run(test):
         # Revert tester's rx channel
         test = cert_config.brg_configure(test, module=test.tester.internal_brg.datapath, target=TESTER)[0]
 
-    return cert_common.test_epilog(test, revert_brgs=True, modules=[datapath_module], ble5=True)
+    return cert_common.test_epilog(test, revert_brgs=True, modules=[dut.datapath], ble5=test.dut_is_bridge())

certificate/tests/datapath/rssi_threshold_test/rssi_threshold_test.json

@@ -2,7 +2,7 @@
     "name": "RSSI Threshold",
     "module": "Datapath",
     "purpose": "Test RSSI threshold configuration and functionality in the bridge",
-    "documentation": "<TEST_DOCUMENTATION_LINK>",
+    "documentation": "",
     "initialCondition": "Bridge configured to defaults",
     "procedure": ["Test prolog",
                   "RSSI Threshold configuration",

certificate/tests/energy2400/signal_indicator_ble5_test/signal_indicator_ble5_test.py

@@ -28,7 +28,6 @@ import certificate.cert_config as cert_config
 NUM_OF_SCANNING_CYCLE = 5
 DEFAULT_SCAN_TIME = 30
 SCAN_DELAY_TIME = 3
-BLE5_MAX_DURATION_SEC = ag.BLE5_PARAM_PRIMARY_CHANNEL_SCAN_CYCLE // 1000 + 1
 
 
 def test_rssi_threshold(test):
@@ -366,7 +365,7 @@ def run(test):
         else:
             test.reset_result()
 
-    # Revert DUT to defaults here and not in epilog
+    # Revert DUT and TESTER to defaults here and not in epilog
     test = cert_config.config_brg_defaults(test, modules=[dut.datapath], ble5=test.dut_is_bridge(), wait=test.dut_is_combo())[0]
     if test.rc == TEST_FAILED:
         test.add_reason("Failed to revert brg0 datapath to defaults")

certificate/tests/energy2400/signal_indicator_ext_adv_test/signal_indicator_ext_adv_test.json

@@ -1,20 +1,19 @@
 {
     "name": "Signal Indicator Extended Advertising",
     "module": "Energizer 2.4GHz",
-    "purpose": "verify Signal Indicator functionality when using bridge with extended advertising pattern",
+    "purpose": "Verify Signal Indicator functionality when using bridge with extended advertising pattern",
     "documentation": "https://community.wiliot.com/customers/s/article/Bridge-to-Bridge-Signal-Indicator",
     "initialCondition": "Bridge configured to defaults",
-    "procedure": ["Test prolog",
-    "rssi_threshold - check the if rssi value is between 0 to -25.",
-    "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.",
-    "Test epilog"],
+    "procedure": [
+        "Test prolog - Initialize test environment and configure bridges to defaults",
+        "ext_adv_rx37 - Configure DUT as Transmitter with extended advertising pattern and RX channel 37, and TESTER as Receiver and Analyze received signal indicator packets count, RX/TX antenna, output power, and RSSI values",
+        "ext_adv_rx10 - Configure DUT as Transmitter with extended advertising pattern and RX channel 10, and TESTER as Receiver and Analyze received signal indicator packets count, RX/TX antenna, output power, and RSSI values",
+        "Test epilog - Finalize test results and log outcomes"
+    ],
     "expectedOutcome": "All phases passed successfully!",
     "mandatory": 0,
     "multiBridgeTest": 1,
     "gwOnlyTest": 0,
     "dataSimOnlyTest": 0,
-    "allSupportedValues": ["rssi_threshold", "brg0_tx_brg1_rx", "brg0_none_brg1_rx", "brg0_rxtx_brg1_rxtx", "brg0_tx_brg1_none"]
+    "allSupportedValues": ["ext_adv_rx37", "ext_adv_rx10"]
 }

certificate/tests/energy2400/signal_indicator_ext_adv_test/signal_indicator_ext_adv_test.py

@@ -5,327 +5,167 @@ import certificate.cert_mqtt as cert_mqtt
 import certificate.cert_common as cert_common
 import certificate.cert_config as cert_config
 
-# Test Description:
-#   This test is to verify the functionality of both signal indicator tx (tx_brg) and rx (rx_brg) at BRG level.
-#   We will configure several signal indicator params during the test, and check the functionality of the signal indicator logic
-#   for each of them.
-#   It is important to execute the test with several setups: 2 Fanstel BRG's, 2 Minew BRG's and 1 Fanstel and 1 Minew BRG.
-#   At first, we will configure several tx signal indicator params and check for ack's, to verify all indicated params were
-#   received at the cloud.
-#   Then, we will examine the signal indicator end-2-end logic with both transmitter and receiver:
-#   phase 1 - One BRG will be configured as signal indicator tx, and the other as signal indicator rx, and we expect to see
-#   signal indicator packets only from the tx BRG, and according to the tx params (to check the repetition and cycle params).
-#   phase 2 - Same as phase 1, but with different tx params configured.
-#   phase 3 - One rx BRG without any tx BRG. We don't expect to see any signal indicator packets. This phase is to verify the
-#   brg module logic is working properly, and no tag packet is accidentally being treated as signal indicator packet.
-#   phase 4 - 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.
-#   phase 5 - One BRG will be configured as signal indicator tx, but no rx, so we don't expect to receive signal indicatopr packets.
-#   that way we can assure the logic within the receiver is not confused by the signal indicator uuid as external sensor.
-
-
 # Test MACROS #
 NUM_OF_SCANNING_CYCLE = 5
-DEFAULT_SCAN_TIME = 30
 SCAN_DELAY_TIME = 3
-BLE5_MAX_DURATION_SEC = ag.BLE5_PARAM_PRIMARY_CHANNEL_SCAN_CYCLE // 1000 + 1
 
 
-def test_rssi_threshold(test):
-    cycle, rep = 5, 4
-    rx_brg_ = test.brg1  # when internal_brg test this is the internal_brg
-    tx_brg_ = cert_config.get_brg_by_target(test, DUT)
-    rssi_threshold = -25
+def test_ext_adv_rx37(test):
+
+    dut = cert_config.get_brg_by_target(test, DUT)
+    tester = cert_config.get_brg_by_target(test, TESTER)
+    cycle, rep = 8, 4
 
-    utPrint(f"TX BRG with RX- cycle = {cycle}, repetition = {rep}\n", "BLUE")
-    # configuring receiver #
-    utPrint(f"Configuring BRG {rx_brg_.id_str} as Signal Indicator Receiver with RSSI Threshold of {rssi_threshold}", "BOLD")
-    is_ble5 = not test.internal_brg
-    test = cert_config.brg_configure(test=test, module=rx_brg_.sensors,
-                                     fields=[BRG_SENSOR0, BRG_RSSI_THRESHOLD],
-                                     values=[ag.EXTERNAL_SENSORS_SIGNAL_INDICATOR, rssi_threshold],
-                                     ble5=is_ble5, wait=True, target=BRG1)[0]
+    # Configuring DUT #
+    # configuring transmitter #
+    utPrint(f"Configuring DUT BRG {dut.id_str} as Signal Indicator Transmitter (cycle={cycle}, repetition={rep})", "BLUE")
+    test = cert_config.brg_configure(test=test, module=dut.energy2400,
+                                     fields=[BRG_SIGNAL_INDICATOR_CYCLE, BRG_SIGNAL_INDICATOR_REP],
+                                     values=[cycle, rep])[0]
     if test.rc == TEST_FAILED:
-        test.add_reason(f"BRG {rx_brg_.id_str}: didn't receive signal indicator receiver configuration!")
+        test.add_reason(f"DUT BRG {dut.id_str}: didn't receive signal indicator transmitter configuration!")
         return test
-    # configuring transmitter #
-    utPrint(f"Configuring BRG {tx_brg_.id_str} as Signal Indicator Transmitter", "BOLD")
-    wait = not test.internal_brg
-    test = cert_config.brg_configure(test=test, module=tx_brg_.energy2400, fields=[BRG_SIGNAL_INDICATOR_CYCLE, BRG_SIGNAL_INDICATOR_REP],
-                                     values=[cycle, rep], ble5=True, wait=wait)[0]
+    # configuring extended advertising and rx channel #
+    utPrint(f"Configuring DUT BRG {dut.id_str} with extended advertising and rx channel 37", "BLUE")
+    test = cert_config.brg_configure(test=test, module=dut.datapath,
+                                     fields=[BRG_RX_CHANNEL, BRG_PATTERN],
+                                     values=[ag.RX_CHANNEL_37, ag.DATAPATH_PATTERN_EXTENDED_ADV])[0]
     if test.rc == TEST_FAILED:
-        test.add_reason(f"BRG {tx_brg_.id_str}: didn't receive signal indicator transmitter configuration!")
+        test.add_reason(f"DUT BRG {dut.id_str}: didn't receive extended advertising and rx channel configuration!")
         return test
-    utPrint(f"BRG {tx_brg_.id_str} configured to be transmitter - cycle = {cycle},"
-            f"repetition = {rep}", "BOLD")
-    # phase analysis #
-    print_update_wait(BLE5_MAX_DURATION_SEC)  # BLE5 configuration can take up to BLE5_MAX_DURATION_SEC
-    cert_mqtt.mqtt_scan_n_create_log_file(test, (NUM_OF_SCANNING_CYCLE * cycle) + SCAN_DELAY_TIME, "rssi_threshold")
-    received_signal_ind_pkts = cert_common.get_all_sig_ind_pkts(test=test, rx_brg=rx_brg_, tx_brg=tx_brg_)
-    for p in received_signal_ind_pkts:
-        print(f"rssi value: {p[UNIFIED_SENSOR_PKT].pkt.rssi}")
-    rssi_threshold_viloation_pkts = [p for p in received_signal_ind_pkts if p[UNIFIED_SENSOR_PKT].pkt.rssi >= -1 * rssi_threshold]
-    if rssi_threshold_viloation_pkts:
-        test.rc = TEST_FAILED
-        test.add_reason(f"rssi_threshold phase failed - BRG {rx_brg_.id_str} echoed"
-                        f" {len(rssi_threshold_viloation_pkts)} signal indicator packets\n with RSSI weaker than {rssi_threshold}")
-    return test
-
-
-def test_brg0_tx_brg1_rx(test):
-
-    tx_brg_ = cert_config.get_brg_by_target(test, DUT)
-    rx_brg_ = test.brg1   # when internal_brg test this is the internal_brg
-    cycle, rep = 8, 4
 
-    utPrint(f"TX BRG with RX- cycle = {cycle}, repetition = {rep}\n", "BLUE")
-    # configuring receiver #
-    utPrint(f"Configuring BRG {rx_brg_.id_str} as Signal Indicator Receiver", "BOLD")
-    is_ble5 = not test.internal_brg
-    test = cert_config.brg_configure(test=test, module=rx_brg_.sensors,
-                                     fields=[BRG_SENSOR0],
-                                     values=[ag.EXTERNAL_SENSORS_SIGNAL_INDICATOR],
-                                     ble5=is_ble5, wait=True, target=BRG1)[0]
+    # configuring TESTER #
+    utPrint(f"Configuring TESTER BRG {tester.id_str} as Signal Indicator Receiver", "BLUE")
+    test = cert_config.brg_configure(test=test, module=tester.sensors, fields=[BRG_SENSOR0],
+                                     values=[ag.EXTERNAL_SENSORS_SIGNAL_INDICATOR], target=TESTER)[0]
     if test.rc == TEST_FAILED:
-        test.add_reason(f"BRG {rx_brg_.id_str}: didn't receive signal indicator receiver configuration!")
+        test.add_reason(f"TESTER BRG {tester.id_str}: didn't receive signal indicator receiver configuration!")
         return test
-    # configuring transmitter #
-    wait = not test.internal_brg
-    utPrint(f"Configuring BRG {tx_brg_.id_str} as Signal Indicator Transmitter", "BOLD")
-    test = cert_config.brg_configure(test=test, module=tx_brg_.energy2400,
-                                     fields=[BRG_SIGNAL_INDICATOR_CYCLE, BRG_SIGNAL_INDICATOR_REP],
-                                     values=[cycle, rep], ble5=True, wait=wait)[0]
+    utPrint(f"Configuring TESTER BRG {tester.id_str} with rx channel 37", "BLUE")
+    test = cert_config.brg_configure(test=test, module=tester.datapath, fields=[BRG_RX_CHANNEL],
+                                     values=[ag.RX_CHANNEL_37], target=TESTER)[0]
     if test.rc == TEST_FAILED:
-        test.add_reason(f"BRG {tx_brg_.id_str}: didn't receive signal indicator transmitter configuration!")
+        test.add_reason(f"TESTER BRG {tester.id_str}: didn't receive rx channel configuration!")
         return test
-    utPrint(f"BRG {tx_brg_.id_str} configured to be transmitter - cycle = {cycle},"
-            f"repetition = {rep}", "BOLD")
-    # phase analysis #
-    print_update_wait(BLE5_MAX_DURATION_SEC)  # BLE5 configuration can take up to BLE5_MAX_DURATION_SEC
-    cert_mqtt.mqtt_scan_n_create_log_file(test, (NUM_OF_SCANNING_CYCLE * cycle) + SCAN_DELAY_TIME, f"brg0_rx_brg1_tx_{cycle}_{rep}")
-    received_signal_ind_pkts = cert_common.get_all_sig_ind_pkts(test=test, rx_brg=rx_brg_, tx_brg=tx_brg_)
 
-    if cert_common.sig_ind_pkts_fail_analysis(tx_brg_, rx_brg_, NUM_OF_SCANNING_CYCLE, received_signal_ind_pkts):
+    # phase analysis #
+    cert_mqtt.mqtt_scan_n_create_log_file(test, (NUM_OF_SCANNING_CYCLE * cycle) + SCAN_DELAY_TIME,
+                                          f"tx_{cycle}_{rep}")
+    rec_sig_ind_pkts = cert_common.get_all_sig_ind_pkts(test=test, rx_brg=tester, tx_brg=dut)
+    if cert_common.sig_ind_pkts_fail_analysis(tx_brg=dut, rx_brg=tester, cycles=NUM_OF_SCANNING_CYCLE, received_pkts=rec_sig_ind_pkts):
         test.rc = TEST_FAILED
-        expected_signal_ind_pkts = cert_common.exp_sig_ind_pkts2(tx_brg_, rx_brg_, NUM_OF_SCANNING_CYCLE)
-        test.add_reason(f"brg0_rx_brg1_tx phase failed - BRG {rx_brg_.id_str} received wrong number of "
-                        f"signal indicator packets\nreceived {len(received_signal_ind_pkts)} packets, "
+        expected_signal_ind_pkts = cert_common.exp_sig_ind_pkts2(tester, dut, NUM_OF_SCANNING_CYCLE)
+        test.add_reason(f"tx phase failed - BRG {dut.id_str} received wrong number of "
+                        f"signal indicator packets\nreceived {len(rec_sig_ind_pkts)} packets, "
                         f"expected {expected_signal_ind_pkts} packets")
-        print(received_signal_ind_pkts)  # TODO: logging print(debug)
-        print([[p[TIMESTAMP], p[UNIFIED_SENSOR_PKT].pkt.signal_indicator_payload.rx_antenna] for p in received_signal_ind_pkts])
-
-    test = cert_common.rx_tx_antenna_check(test, received_signal_ind_pkts, tx_brg_, rx_brg_, NUM_OF_SCANNING_CYCLE)
-    test = cert_common.output_power_check(test, received_signal_ind_pkts, tx_brg_)
-    test = cert_common.rssi_check(test, received_signal_ind_pkts)
-
-    return test
-
-
-def test_brg0_none_brg1_rx(test):
-    cycle, rep = ag.BRG_DEFAULT_SIGNAL_INDICATOR_CYCLE, ag.BRG_DEFAULT_SIGNAL_INDICATOR_REP
-    tx_brg_ = cert_config.get_brg_by_target(test, DUT)
-    rx_brg_ = test.brg1  # when internal_brg test this is the internal_brg
-    utPrint(f"RX BRG without TX- cycle = {cycle}, repetition = {rep}\n", "BLUE")
-    # configuring receiver #
-    utPrint(f"Configuring BRG {rx_brg_.id_str} as Signal Indicator Receiver", "BOLD")
-    is_ble5 = not test.internal_brg
-    test = cert_config.brg_configure(test=test, module=rx_brg_.sensors,
-                                     fields=[BRG_SENSOR0],
-                                     values=[ag.EXTERNAL_SENSORS_SIGNAL_INDICATOR],
-                                     ble5=is_ble5, wait=True, target=BRG1)[0]
-    if test.rc == TEST_FAILED:
-        test.add_reason(f"BRG {rx_brg_.id_str}: didn't receive signal indicator receiver configuration!")
+        print(rec_sig_ind_pkts)  # TODO: logging print(debug)
+        print([[p[TIMESTAMP], p[UNIFIED_SENSOR_PKT].pkt.signal_indicator_payload.rx_antenna] for p in rec_sig_ind_pkts])
         return test
-    utPrint(f"BRG {rx_brg_.id_str} successfully configured as Signal Indicator Receiver\n", "BOLD")
 
-    # phase analysis #
-    print_update_wait(BLE5_MAX_DURATION_SEC)  # BLE5 configuration can take up to BLE5_MAX_DURATION_SEC
-    cert_mqtt.mqtt_scan_n_create_log_file(test, DEFAULT_SCAN_TIME, "brg0_none_brg1_rx")
-    expected_signal_ind_pkts = [0]
-    received_signal_ind_pkts = cert_common.get_all_sig_ind_pkts(test=test, rx_brg=rx_brg_, tx_brg=tx_brg_)
-    if len(received_signal_ind_pkts) not in expected_signal_ind_pkts:
-        test.rc = TEST_FAILED
-        test.add_reason(f"brg0_rx_brg1_tx phase failed - BRG {rx_brg_.id_str} received wrong number of "
-                        f"signal indicator packets\n received {len(received_signal_ind_pkts)} packets, "
-                        f"expected {expected_signal_ind_pkts} packets")
+    test = cert_common.rx_tx_antenna_check(test, rec_sig_ind_pkts, dut, tester, NUM_OF_SCANNING_CYCLE)
+    test = cert_common.output_power_check(test, rec_sig_ind_pkts, dut)
+    test = cert_common.rssi_check(test, rec_sig_ind_pkts)
 
     return test
 
 
-def test_brg0_rxtx_brg1_rxtx(test):
+def test_ext_adv_rx10(test):
 
-    if test.internal_brg:
-        # Can't scan on ble5 with internal brg because config won't be received
-        test.add_reason("skip for internal BRG")
-        test.rc = TEST_SKIPPED
-        return test
+    dut = cert_config.get_brg_by_target(test, DUT)
+    tester = cert_config.get_brg_by_target(test, TESTER)
+    cycle, rep = 8, 4
 
-    tx_cycle, tx_rep = 5, 4
-    rx_cycle, rx_rep = 5, 4
-    tx_brg_ = cert_config.get_brg_by_target(test, DUT)
-    rx_brg_ = test.brg1
-    utPrint("Both BRG's are transmitter and receivers, with different values\n", "BLUE")
-    # configuring first brg (tx_brg_) as receiver
-    utPrint(f"Configuring BRG {tx_brg_.id_str} as Signal Indicator Receiver", "BOLD")
-    test = cert_config.brg_configure(test=test, module=tx_brg_.sensors, fields=[BRG_SENSOR0],
-                                     values=[ag.EXTERNAL_SENSORS_SIGNAL_INDICATOR], ble5=True)[0]
-    if test.rc == TEST_FAILED and test.exit_on_param_failure:
-        test.add_reason(f"BRG {tx_brg_.id_str}: didn't receive signal indicator receiver configuration!")
+    # Configuring DUT #
+    # configuring transmitter #
+    utPrint(f"Configuring DUT BRG {dut.id_str} as Signal Indicator Transmitter (cycle={cycle}, repetition={rep})", "BLUE")
+    test = cert_config.brg_configure(test=test, module=dut.energy2400,
+                                     fields=[BRG_SIGNAL_INDICATOR_CYCLE, BRG_SIGNAL_INDICATOR_REP],
+                                     values=[cycle, rep])[0]
+    if test.rc == TEST_FAILED:
+        test.add_reason(f"DUT BRG {dut.id_str}: didn't receive signal indicator transmitter configuration!")
         return test
-    utPrint(f"BRG {tx_brg_.id_str} successfully configured as Signal Indicator Receiver\n", "BOLD")
-    # configuring first brg (tx_brg_) as transmitter
-    utPrint(f"Configuring BRG {tx_brg_.id_str} as Signal Indicator Transmitter", "BOLD")
-    test = cert_config.brg_configure(test=test, module=tx_brg_.energy2400, fields=[BRG_SIGNAL_INDICATOR_CYCLE, BRG_SIGNAL_INDICATOR_REP],
-                                     values=[tx_cycle, tx_rep], ble5=True)[0]
-    if test.rc == TEST_FAILED and test.exit_on_param_failure:
-        test.add_reason(f"BRG {tx_brg_.id_str}: didn't receive signal indicator transmitter configuration!")
+    # configuring extended advertising and rx channel #
+    utPrint(f"Configuring DUT BRG {dut.id_str} with extended advertising and rx channel 10", "BLUE")
+    test = cert_config.brg_configure(test=test, module=dut.datapath,
+                                     fields=[BRG_RX_CHANNEL, BRG_PATTERN],
+                                     values=[ag.RX_CHANNEL_10_500K, ag.DATAPATH_PATTERN_EXTENDED_ADV],
+                                     ble5=test.dut_is_bridge(), wait=test.dut_is_combo())[0]
+    if test.rc == TEST_FAILED:
+        test.add_reason(f"DUT BRG {dut.id_str}: didn't receive extended advertising and rx channel configuration!")
         return test
-    utPrint(f"BRG {tx_brg_.id_str} configured to be transmitter - cycle={tx_cycle}, repetition={tx_rep}", "BOLD")
+    if test.dut_is_bridge():
+        wait_time_n_print(BLE5_MAX_DURATION_SEC)  # BLE5 configuration can take up to BLE5_MAX_DURATION_SEC
 
-    # configuring second brg (rx_brg_) as receiver
-    utPrint(f"Configuring BRG {rx_brg_.id_str} as Signal Indicator Receiver", "BOLD")
-    test = cert_config.brg_configure(test=test, module=rx_brg_.sensors,
-                                     fields=[BRG_SENSOR0],
-                                     values=[ag.EXTERNAL_SENSORS_SIGNAL_INDICATOR],
-                                     ble5=True, target=BRG1)[0]
-    if test.rc == TEST_FAILED and test.exit_on_param_failure:
-        test.add_reason(f"BRG {rx_brg_.id_str}: didn't receive signal indicator receiver configuration!")
+    # configuring TESTER #
+    utPrint(f"Configuring TESTER BRG {tester.id_str} as Signal Indicator Receiver", "BLUE")
+    test = cert_config.brg_configure(test=test, module=tester.sensors, fields=[BRG_SENSOR0],
+                                     values=[ag.EXTERNAL_SENSORS_SIGNAL_INDICATOR], target=TESTER)[0]
+    if test.rc == TEST_FAILED:
+        test.add_reason(f"TESTER BRG {tester.id_str}: didn't receive signal indicator receiver configuration!")
         return test
-    utPrint(f"BRG {rx_brg_.id_str} successfully configured as Signal Indicator Receiver\n", "BOLD")
-
-    # configuring second brg (rx_brg_) as transmitter (already configured as rx)
-    utPrint(f"Configuring BRG {rx_brg_.id_str} as Signal Indicator Transmitter", "BOLD")
-    test = cert_config.brg_configure(test=test, module=rx_brg_.energy2400,
-                                     fields=[BRG_SIGNAL_INDICATOR_CYCLE, BRG_SIGNAL_INDICATOR_REP],
-                                     values=[rx_cycle, rx_rep],
-                                     ble5=True, target=BRG1)[0]
-    if test.rc == TEST_FAILED and test.exit_on_param_failure:
-        test.add_reason(f"BRG {rx_brg_.id_str}: didn't receive signal indicator transmitter configuration!")
+    utPrint(f"Configuring TESTER BRG {tester.id_str} with rx channel 10", "BLUE")
+    test = cert_config.brg_configure(test=test, module=tester.datapath, fields=[BRG_RX_CHANNEL],
+                                     values=[ag.RX_CHANNEL_10_500K], target=TESTER)[0]
+    if test.rc == TEST_FAILED:
+        test.add_reason(f"TESTER BRG {tester.id_str}: didn't receive rx channel configuration!")
         return test
-    utPrint(f"BRG {rx_brg_.id_str} configured to be transmitter - cycle={rx_cycle}, repetition={rx_rep}")
 
     # phase analysis #
-    print_update_wait(BLE5_MAX_DURATION_SEC)  # BLE5 configuration can take up to BLE5_MAX_DURATION_SEC
-    cert_mqtt.mqtt_scan_n_create_log_file(test, NUM_OF_SCANNING_CYCLE * max(tx_cycle, rx_cycle) + SCAN_DELAY_TIME, "brg0_rxtx_brg1_rxtx")
-
-    # Analyzing tx_brg_ performance as receiver
-    utPrint(f"Analyzing tx_brg {tx_brg_.id_str} performance as a Receiver\n", "BOLD")
-    received_signal_ind_pkts = cert_common.get_all_sig_ind_pkts(test=test, rx_brg=tx_brg_, tx_brg=rx_brg_)
-    if cert_common.sig_ind_pkts_fail_analysis(tx_brg_, rx_brg_, NUM_OF_SCANNING_CYCLE, received_signal_ind_pkts):
-        test.rc = TEST_FAILED
-        expected_signal_ind_pkts = cert_common.exp_sig_ind_pkts2(tx_brg_, rx_brg_, NUM_OF_SCANNING_CYCLE)
-        test.add_reason(f"brg0_rxtx_brg1_rxtx phase failed - BRG {tx_brg_.id_str} received wrong number of "
-                        f"signal indicator packets\nreceived {len(received_signal_ind_pkts)} packets, "
-                        f"expected {expected_signal_ind_pkts} packets")
-        print(received_signal_ind_pkts)  # TODO: logging print(debug)
-
-    # Analyzing rx_brg_ performance as receiver
-    utPrint(f"Analyzing rx_brg {rx_brg_.id_str} performance as a Receiver\n", "BOLD")
-    received_signal_ind_pkts = cert_common.get_all_sig_ind_pkts(test=test, rx_brg=rx_brg_, tx_brg=tx_brg_)
-    if cert_common.sig_ind_pkts_fail_analysis(tx_brg_, rx_brg_, NUM_OF_SCANNING_CYCLE, received_signal_ind_pkts):
+    cert_mqtt.mqtt_scan_n_create_log_file(test, (NUM_OF_SCANNING_CYCLE * cycle) + SCAN_DELAY_TIME,
+                                          f"tx_{cycle}_{rep}")
+    rec_sig_ind_pkts = cert_common.get_all_sig_ind_pkts(test=test, rx_brg=tester, tx_brg=dut)
+    if cert_common.sig_ind_pkts_fail_analysis(tx_brg=dut, rx_brg=tester, cycles=NUM_OF_SCANNING_CYCLE, received_pkts=rec_sig_ind_pkts):
         test.rc = TEST_FAILED
-        expected_signal_ind_pkts = cert_common.exp_sig_ind_pkts2(tx_brg_, rx_brg_, NUM_OF_SCANNING_CYCLE)
-        test.add_reason(f"brg0_rxtx_brg1_rxtx phase failed - BRG {rx_brg_.id_str} received wrong number of "
-                        f"signal indicator packets\n received {len(received_signal_ind_pkts)} packets, "
+        expected_signal_ind_pkts = cert_common.exp_sig_ind_pkts2(tester, dut, NUM_OF_SCANNING_CYCLE)
+        test.add_reason(f"tx phase failed - BRG {dut.id_str} received wrong number of "
+                        f"signal indicator packets\nreceived {len(rec_sig_ind_pkts)} packets, "
                         f"expected {expected_signal_ind_pkts} packets")
-        print(received_signal_ind_pkts)  # TODO: logging print(debug)
-    # NOTE: We skipped the antenna and output power checks for this phase
-    return test
-
-
-def test_brg0_tx_brg1_none(test):
-    # Tx BRG without rx. just waiting for packets to be sent from the transmitter and verify
-    # The receiver isn't receiving any signal indicator packets.
-    cycle, rep = 4, 3
-    tx_brg_ = cert_config.get_brg_by_target(test, DUT)
-    rx_brg_ = test.brg1  # when internal_brg test this is the internal_brg
-    utPrint(f"TX BRG without RX - cycle = {cycle}, repetition = {rep}\n", "BLUE")
-    # configuring transmitter #
-    utPrint(f"Configuring BRG {tx_brg_.id_str} as Signal Indicator Transmitter", "BOLD")
-    wait = not test.internal_brg
-    test = cert_config.brg_configure(test=test, module=tx_brg_.energy2400, fields=[BRG_SIGNAL_INDICATOR_CYCLE, BRG_SIGNAL_INDICATOR_REP],
-                                     values=[cycle, rep], ble5=True, wait=wait)[0]
-    if test.rc == TEST_FAILED:
-        test.add_reason(f"BRG {tx_brg_.id_str}: didn't receive signal indicator transmitter configuration!")
+        print(rec_sig_ind_pkts)  # TODO: logging print(debug)
+        print([[p[TIMESTAMP], p[UNIFIED_SENSOR_PKT].pkt.signal_indicator_payload.rx_antenna] for p in rec_sig_ind_pkts])
         return test
 
-    # phase analysis #
-    print_update_wait(BLE5_MAX_DURATION_SEC)  # BLE5 configuration can take up to BLE5_MAX_DURATION_SEC
-    cert_mqtt.mqtt_scan_n_create_log_file(test, (NUM_OF_SCANNING_CYCLE * cycle) + SCAN_DELAY_TIME, "brg0_tx_brg1_none")
-    expected_signal_ind_pkts = [0]
-    received_signal_ind_pkts = cert_common.get_all_sig_ind_pkts(test=test, rx_brg=rx_brg_, tx_brg=tx_brg_)
-    if len(received_signal_ind_pkts) not in expected_signal_ind_pkts:
-        test.rc = TEST_FAILED
-        test.add_reason(f"brg0_tx_brg1_none phase failed - received signal indicator packet from BRG"
-                        f"{rx_brg_.id_str}")
-    test = cert_common.output_power_check(test, received_signal_ind_pkts, tx_brg_)
+    test = cert_common.rx_tx_antenna_check(test, rec_sig_ind_pkts, dut, tester, NUM_OF_SCANNING_CYCLE)
+    test = cert_common.output_power_check(test, rec_sig_ind_pkts, dut)
+    test = cert_common.rssi_check(test, rec_sig_ind_pkts)
 
     return test
 
 
-SIGNAL_INDICATOR_TEST_MAP = {"rssi_threshold": test_rssi_threshold, "brg0_tx_brg1_rx": test_brg0_tx_brg1_rx,
-                             "brg0_none_brg1_rx": test_brg0_none_brg1_rx, "brg0_rxtx_brg1_rxtx": test_brg0_rxtx_brg1_rxtx,
-                             "brg0_tx_brg1_none": test_brg0_tx_brg1_none}
+SIGNAL_INDICATOR_TEST_MAP = {"ext_adv_rx37": test_ext_adv_rx37, "ext_adv_rx10": test_ext_adv_rx10}
 
 
 def run(test):
     # Test prolog
     test = cert_common.test_prolog(test)
 
-    for rx_channel in [ag.RX_CHANNEL_10_500K, ag.RX_CHANNEL_37]:
+    # Configure to rx channel and extended advertising pattern
+    dut = cert_config.get_brg_by_target(test, DUT)
+    tester = cert_config.get_brg_by_target(test, TESTER)
 
-        # Configure to rx channel and extended advertising pattern
-        brg_dut = cert_config.get_brg_by_target(test, DUT)
-        test = cert_config.brg_configure(test, fields=[BRG_RX_CHANNEL, BRG_PATTERN],
-                                         values=[rx_channel, ag.DATAPATH_PATTERN_EXTENDED_ADV],
-                                         module=brg_dut.datapath, ble5=True)[0]
-        if test.rc == TEST_FAILED:
-            return cert_common.test_epilog(test, revert_brgs=True,
-                                           modules=[brg_dut.datapath], ble5=True)
-        test = cert_config.brg_configure(test, fields=[BRG_RX_CHANNEL, BRG_PATTERN],
-                                         values=[rx_channel, ag.DATAPATH_PATTERN_EXTENDED_ADV],
-                                         module=test.brg1.datapath, target=BRG1)[0]
-        if test.rc == TEST_FAILED:
-            return cert_common.test_epilog(test, revert_brgs=True,
-                                           modules=[brg_dut.datapath],
-                                           brg1_modules=[test.brg1.datapath], ble5=True)
+    for param in test.params:
+        phase_run_print(param.name)
+        test = SIGNAL_INDICATOR_TEST_MAP[param.value](test)
+        cert_mqtt.generate_log_file(test, param.name)
+        field_functionality_pass_fail_print(test, param.name)
+        test.set_phase_rc(param.name, test.rc)
+        test.add_phase_reason(param.name, test.reason)
 
-        for param in test.params:
-            phase_run_print(param.name)
-            test = SIGNAL_INDICATOR_TEST_MAP[param.value](test)
-            cert_mqtt.generate_log_file(test, param.name)
-            field_functionality_pass_fail_print(test, param.name)
+        if test.rc == TEST_FAILED:
             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:
+            if test.exit_on_param_failure:
                 break
-            else:
-                test.reset_result()
+        else:
+            test.reset_result()
 
-            # Reset to defaults after every phase (don't fail the phase on that)
-            brg_dut = cert_config.get_brg_by_target(test, DUT)
-            test = cert_config.config_brg_defaults(test,
-                                                   modules=[brg_dut.energy2400, brg_dut.sensors],
-                                                   ble5=True, wait=False)[0]
-            # BLE5 configuration can take up to BLE5_MAX_DURATION_SEC, we configured 2 modules here
-            print_update_wait(2 * BLE5_MAX_DURATION_SEC)
-            if test.rc == TEST_FAILED:
-                test.add_reason("Failed to restore brg0 to defaults")
-            else:
-                test = cert_config.config_brg_defaults(test, modules=[test.brg1.energy2400, test.brg1.sensors], ble5=True, target=BRG1)[0]
-                # BLE5 configuration can take up to BLE5_MAX_DURATION_SEC, we configured 2 modules here
-                print_update_wait(2 * BLE5_MAX_DURATION_SEC)
-                if test.rc == TEST_FAILED:
-                    test.add_reason("Failed to restore brg0 to defaults")
-            if test.rc == TEST_FAILED:
-                test.set_phase_rc(param.name, test.rc)
-                test.add_phase_reason(param.name, test.reason)
-                if test.exit_on_param_failure:
-                    break
-            else:
-                test.reset_result()
+    # Revert DUT and TESTER to defaults here and not in epilog
+    test = cert_config.config_brg_defaults(test, modules=[dut.datapath, dut.energy2400],
+                                           ble5=test.dut_is_bridge(), wait=test.dut_is_combo())[0]
+    if test.rc == TEST_FAILED:
+        test.add_reason("Failed to revert dut to defaults")
+    else:
+        test = cert_config.config_brg_defaults(test, modules=[tester.datapath, tester.sensors], target=TESTER)[0]
+        if test.rc == TEST_FAILED:
+            test.add_reason("Failed to revert tester to defaults")
 
-    brg_dut = cert_config.get_brg_by_target(test, DUT)
-    return cert_common.test_epilog(test, revert_brgs=True,
-                                   modules=[brg_dut.datapath],
-                                   brg1_modules=[test.brg1.datapath], ble5=True)
+    return cert_common.test_epilog(test, revert_brgs=False)

certificate/tests/sensors/ext_sensor_test/ext_sensor_test.py

@@ -413,19 +413,14 @@ EXT_SENSOR_TEST_MAP = {"tag_data_only": test_tag_data_only,
 
 
 def run(test):
-    datapath_module = test.active_brg.datapath
-    ext_sensors_module = test.active_brg.sensors
+
     test = cert_common.test_prolog(test)
     # check for problems in prolog
     if test.rc == TEST_FAILED:
         test = cert_common.test_epilog(test)
         return test
 
-    # Adaptation of GW configuration for internal BRG test
-    if test.internal_brg:
-        test = cert_config.brg_configure(test, fields=[BRG_RX_CHANNEL], values=[ag.RX_CHANNEL_37], module=datapath_module, wait=True)[0]
-        if test.rc == TEST_FAILED and test.exit_on_param_failure:
-            return cert_common.test_epilog(test, revert_gws=True)
+    dut = cert_config.get_brg_by_target(test, DUT)
 
     # create csv file for the test
     in_pkts = create_csv_file_in(test)
@@ -439,7 +434,7 @@ def run(test):
 
     for param in test.params:
         phase_run_print(param.name)
-        test = EXT_SENSOR_TEST_MAP[param.value](test, param.name, ext_sensors_module)
+        test = EXT_SENSOR_TEST_MAP[param.value](test, param.name, dut.sensors)
         field_functionality_pass_fail_print(test, param.name)
         test.set_phase_rc(param.name, test.rc)
         test.add_phase_reason(param.name, test.reason)
@@ -452,4 +447,4 @@ def run(test):
     if test.data == DATA_SIMULATION:
         ble_sim_thread.stop()
 
-    return cert_common.test_epilog(test, revert_brgs=True, modules=[ext_sensors_module, datapath_module])
+    return cert_common.test_epilog(test, revert_brgs=True, modules=[dut.sensors, dut.datapath])

common/api_if/api_validation.py

@@ -23,7 +23,7 @@ def api_validation(test):
         utPrint("API validation is skipped for protobuf messages", "WARNING")
         api_validation_phase.rc = TEST_SKIPPED
         api_validation_phase.reason = "API validation is skipped for protobuf messages"
-        test.phases[-1:-1] = [api_validation_phase]
+        test.add_phase(api_validation_phase)
         return test
     else:
         def validate_message(message: dict, msg_type=MESSAGE_TYPES.DATA.value) -> tuple[bool, str]:
@@ -81,5 +81,5 @@ def api_validation(test):
             api_validation_phase.rc = TEST_FAILED
             api_validation_phase.reason = "API (JSON strcture) is invalid"
         field_functionality_pass_fail_print(api_validation_phase, API_VALIDATION)
-        test.phases[-1:-1] = [api_validation_phase]
+        test.add_phase(api_validation_phase)
         return test