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

brg_certificate/cert_results.py

@@ -3,15 +3,15 @@ import tabulate
 import subprocess
 from reportlab.lib import colors
 from reportlab.lib.pagesizes import letter
-from reportlab.platypus import SimpleDocTemplate, Table, TableStyle, Paragraph, Spacer
-from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.platypus import SimpleDocTemplate, Table, TableStyle, Paragraph, Spacer, PageBreak, KeepTogether, Image
+from reportlab.lib.styles import ParagraphStyle
 from reportlab.lib.enums import TA_CENTER, TA_LEFT
 
 # Local imports
 import brg_certificate.cert_utils as cert_utils
 import brg_certificate.cert_prints as cert_prints
 from brg_certificate.cert_defines import BASE_DIR
-from brg_certificate.cert_defines import TEST_FAILED, TEST_SKIPPED, TEST_PASSED, TEST_INIT, UT_RESULT_FILE_HTML, UT_RESULT_FILE_PDF
+from brg_certificate.cert_defines import CERT_VERSION, TEST_FAILED, TEST_SKIPPED, TEST_PASSED, TEST_INIT, UT_RESULT_FILE_HTML, UT_RESULT_FILE_PDF
 
 
 ##################################
@@ -32,7 +32,7 @@ class TestResult:
         return self.name
 
 def generate_tests_table(tests=[], html=False):
-    headers = ["Module", "Test Name", "Device", "Result & Reason Breakdown", "Result", "Run Time"]
+    headers = ["Module", "Test Name", "Device", "Result Breakdown", "Result", "Run Time"]
     inner_format = "unsafehtml" if html else "simple"
     _pass_or_fail = pass_or_fail_html if html else pass_or_fail
     tests_results = []
@@ -40,7 +40,7 @@ def generate_tests_table(tests=[], html=False):
         brgs_to_print = (test.gw if not test.brg0 or test.gw_only else
                          (f"{test.brg0.id_str}\n{test.brg1.id_str}" if test.brg1 and test.multi_brg else test.brg0.id_str))
         inner_table = [[phase.name, _pass_or_fail(phase), phase.reason] for phase in test.phases]
-        result_breakdown_table = tabulate.tabulate(inner_table, headers=["Phase", "Result", "Reason"], tablefmt=inner_format)
+        result_breakdown_table = tabulate.tabulate(inner_table, headers=["Phase", "Result", "Notes"], tablefmt=inner_format)
         tests_results.append([cert_utils.module2name(test.test_module),
                               test.module_name if (not test.internal_brg or "gw" in test.module_name) else f"{test.module_name} (internal brg)",
                               brgs_to_print,
@@ -66,15 +66,15 @@ def get_update_status_from_log_file(log_file="update_log.txt"):
                 elif "ota_test failed!" in l:
                     update_status = "BRG OTA failed!"
                     break
-                elif "Wiliot UT PASSED!" in l:
+                elif "PASSED!" in l:
                     update_status = "GW and BRG versions were updated to latest successfully!"
                     break
-                elif "Update skipped!" in l:
+                elif "SKIPPED!" in l:
                     update_status = "GW and BRG versions update skipped!"
                     break
     return update_status
 
-def generate_results_files(html=True, pdf=True, failures=0, skipped=0, duration=0, brg_version='', tests=[], error=None, pipeline=False):
+def generate_results_files(html=True, pdf=True, failures=0, skipped=0, start_time=0, duration=0, brg='', brg_version='', gw_ble_version = '', gw_ble_mac='', tests=[], error=None, pipeline=False):
     # Generate HTML file
     if html:
         f = open(os.path.join(BASE_DIR, UT_RESULT_FILE_HTML), "w", encoding="utf-8")
@@ -85,7 +85,7 @@ def generate_results_files(html=True, pdf=True, failures=0, skipped=0, duration=
                                 stdout=subprocess.PIPE, shell=True, cwd=os.environ['BITBUCKET_CLONE_DIR'])
             output, err = p.communicate()
         if error:
-            f.write("<br><h1 style='color:#ab0000'>Wiliot UT Failed!</h1><br>")
+            f.write("<br><h1 style='color:#ab0000'>Wiliot Certificate Error!</h1><br>")
             if pipeline:
                 f.write("<hr>" + output.decode("utf-8") + "<br>")
                 f.write("<p><a href='https://bitbucket.org/wiliot/wiliot-nordic-firmware/commits/{}'>Commit page on bitbucket</a><hr>".format(os.environ['BITBUCKET_COMMIT']))
@@ -96,19 +96,26 @@ def generate_results_files(html=True, pdf=True, failures=0, skipped=0, duration=
                 f.write("Bridge version: {} <br><br>".format(brg_version))
         elif tests:
             if not failures and ("successfully!" in update_status or "skipped!" in update_status or not pipeline):
-                f.write("<br><h1 style='color:#00AB83'>Wiliot UT Passed!</h1>")
+                f.write("<br><h1 style='color:#00AB83'>Wiliot Certificate Passed!</h1>")
             else:
-                f.write("<br><h1 style='color:#ab0000'>Wiliot UT Failed!</h1>")
+                f.write("<br><h1 style='color:#ab0000'>Wiliot Certificate Failed!</h1>")
             if pipeline:
                 f.write("<hr>" + output.decode("utf-8") + "<br>")
                 f.write("<p><a href='https://bitbucket.org/wiliot/wiliot-nordic-firmware/commits/{}'>Commit page on bitbucket</a><hr>".format(os.environ['BITBUCKET_COMMIT']))
                 f.write(update_status + "<br><br>")
+            f.write("Run date: {} <br><br>".format(start_time.strftime('%d/%m/%Y, %H:%M:%S')))
             f.write("Tests duration: {} <br><br>".format(str(duration).split(".")[0]))
+            f.write("Certificate version: {} <br><br>".format(CERT_VERSION))
+            if gw_ble_mac:
+                f.write("BLE simulator mac: {} <br><br>".format(gw_ble_mac))
+            if gw_ble_version:
+                f.write("BLE simulator version: {} <br><br>".format(gw_ble_version))
+            f.write("Tested bridge ID: {} <br><br>".format(brg))
             if brg_version:
                 f.write("Bridge version: {} <br><br>".format(brg_version))
-        f.write(tabulate.tabulate([[len(tests)-(failures+skipped), skipped, failures, len(tests)]], headers=["PASSED", "SKIPPED", "FAILED", "TOTAL"], tablefmt="html"))
-        f.write(generate_tests_table(tests, html=True))
-        f.write("<br><br>")
+            f.write(tabulate.tabulate([[len(tests)-(failures+skipped), skipped, failures, len(tests)]], headers=["PASSED", "SKIPPED", "FAILED", "TOTAL"], tablefmt="html"))
+            f.write(generate_tests_table(tests, html=True))
+            f.write("<br><br>")
         if pipeline:
             f.write("<p><a href='https://bitbucket.org/wiliot/wiliot-nordic-firmware/pipelines/results/{}'>Build's page and artifacts on bitbucket</a></p><br><br>".format(os.environ['BITBUCKET_BUILD_NUMBER']))
         f.write("<img src='https://www.wiliot.com/src/img/svg/logo.svg' width='100' height='40' alt='Wiliot logo'>")
@@ -118,59 +125,79 @@ def generate_results_files(html=True, pdf=True, failures=0, skipped=0, duration=
     # Generate PDF file
     if pdf:
         doc = SimpleDocTemplate(os.path.join(BASE_DIR, UT_RESULT_FILE_PDF), pagesize=letter)
-        styles = getSampleStyleSheet()
-        elements = []
-        update_status = get_update_status_from_log_file()
+        doc.title = "Wiliot Certificate Results"
+        elements, hdr_page = [], []
+
+        # Add Wiliot Logo
+        img = Image(os.path.join(BASE_DIR, "../common", "wlt_logo.png"), width=100, height=40)  # Adjust size as needed
+        hdr_page.append(img)
+        hdr_page.append(Spacer(1, 20))
 
         # Title and Summary
         red_header = STYLES_PDF.get("RED_HEADER", ParagraphStyle("Default"))
         green_header = STYLES_PDF.get("GREEN_HEADER", ParagraphStyle("Default"))
         module_header = STYLES_PDF.get("MODULE_HEADER", ParagraphStyle("Default"))
         test_header = STYLES_PDF.get("TEST_HEADER", ParagraphStyle("Default"))
+        text_style = STYLES_PDF.get("BLACK_BOLD", ParagraphStyle("Default"))
         if error:
-            title = Paragraph("<b>Wiliot UT Failed!</b>", red_header)
-            elements.append(title)
-            elements.append(Paragraph(f"Error: {error}", styles['BodyText']))
+            title = Paragraph("<b>Wiliot Certificate Error!</b>", red_header)
+            hdr_page.append(title)
+            hdr_page.append(Spacer(1, 20))
+            hdr_page.append(Paragraph(f"{error}", text_style))
         else:
-            title = Paragraph("<b>Wiliot UT Passed!</b>", green_header) if not failures else Paragraph("<b>Wiliot UT Failed!</b>", red_header)
-            elements.append(title)
-        elements.append(Spacer(1, 50))
-
-        elements.append(Paragraph(f"Tests duration: {str(duration).split('.')[0]}", styles['BodyText']))
+            title = Paragraph("<b>Wiliot Certificate Passed!</b>", green_header) if not failures else Paragraph("<b>Wiliot Certificate Failed!</b>", red_header)
+            hdr_page.append(title)
+        hdr_page.append(Spacer(1, 20))
+        hdr_page.append(Paragraph(f"<b>Summary</b>", module_header))
+        hdr_page.append(Spacer(1, 20))
+        hdr_page.append(Paragraph(f"Run date: {start_time.strftime('%d/%m/%Y, %H:%M:%S')}", text_style))
+        hdr_page.append(Paragraph(f"Tests duration: {str(duration).split('.')[0]}", text_style))
+        hdr_page.append(Paragraph(f"Certificate version: {CERT_VERSION}", text_style))
+        if gw_ble_mac:
+            hdr_page.append(Paragraph(f"BLE simulator mac: {gw_ble_mac}", text_style))
+        if gw_ble_version:
+            hdr_page.append(Paragraph(f"BLE simulator version: {gw_ble_version}", text_style))
+        hdr_page.append(Paragraph(f"Tested bridge ID: {brg}", text_style))
         if brg_version:
-            elements.append(Paragraph(f"Bridge version: {brg_version}", styles['BodyText']))
-        elements.append(Paragraph(f"Update status: {update_status}", styles['BodyText']))
-        elements.append(Spacer(1, 20))
+            hdr_page.append(Paragraph(f"Tested bridge version: {brg_version}", text_style))
+        hdr_page.append(Spacer(1, 20))
 
-        # Summary Table
-        summary_data = [
+        # Count Table
+        count_data = [
             ["PASSED", "SKIPPED", "FAILED", "TOTAL"],
             [len(tests)-(failures+skipped), skipped, failures, len(tests)]
         ]
-        summary_table = Table(summary_data)
-        summary_table.setStyle(INNER_TABLE_STYLE)
-        elements.append(summary_table)
-        elements.append(Spacer(1, 20))
+        count_table = Table(count_data)
+        count_table.setStyle(INNER_TABLE_STYLE)
+        hdr_page.append(count_table)
+        hdr_page.append(Spacer(1, 20))
 
         # Test Results
         results_per_module = generate_results_per_module_for_pdf(tests=tests)
+        summary_data = []
         for module, test_results in results_per_module.items():
-            elements.append(Paragraph(f"<b>{module} Module</b>", module_header))
+            elements.append(Paragraph(f"<b>{module + ' Module' if module else 'Edge Management'}</b>", module_header))
             elements.append(Spacer(1, 20))
             for test_result in test_results:
-                elements.append(Paragraph(f"<b>{test_result.name}</b>", test_header))
-                elements.append(Spacer(1, 10))
+                group = []
+                summary_data += [[module, test_result.name, test_result.result, test_result.duration]]
+                group.append(Paragraph(f"<b>{test_result.name}</b>", test_header))
+                group.append(Spacer(1, 10))
 
-                elements.append(test_result.result)
-                elements.append(Spacer(1, 10))
+                group.append(test_result.result)
+                group.append(Spacer(1, 10))
 
-                elements.append(Paragraph(f"Tested Devices: {test_result.devices}", styles['BodyText']))
-                elements.append(Paragraph(f"Duration: {test_result.duration}", styles['BodyText']))
-                elements.append(Spacer(1, 10))
+                group.append(Paragraph(f"Tested Devices: {test_result.devices}", text_style))
+                group.append(Paragraph(f"Test duration: {test_result.duration}", text_style))
+                group.append(Spacer(1, 10))
 
-                elements.append(test_result.test_table)
-                elements.append(Spacer(1, 20))
-            elements.append(Spacer(1, 50))
+                group.append(test_result.test_table)
+                group.append(Spacer(1, 20))
+                elements.append(KeepTogether(group))
+            elements.append(PageBreak())
+        summary_table = Table([["Module", "Name", "Result", "Duration"]] + summary_data)
+        summary_table.setStyle(INNER_TABLE_STYLE)
+        elements = hdr_page + [summary_table, PageBreak()] + elements
 
         doc.build(elements)
 
@@ -199,46 +226,46 @@ HTML_START = """
     <head>
         <meta charset='utf-8'>
         <meta http-equiv='X-UA-Compatible' content='IE=edge'>
-        <title>UT RESULTS</title>
+        <title>Wiliot Certificate Results</title>
         <meta name='viewport' content='width=device-width, initial-scale=1'>
         <style>
-        html, body {
+        html, body {{
                 height: 100%;
-            }
+            }}
 
-            html {
+            html {{
                 display: table;
                 margin: auto;
-            }
+            }}
 
-            body {
+            body {{
                 display: table-cell;
                 vertical-align: middle;
-            }
-        table {
+            }}
+        table {{
             border-collapse: collapse;
             font-family: Tahoma, Geneva, sans-serif;
-        }
-        table td {
+        }}
+        table td {{
             padding: 15px;
-        }
-        table thead td {
+        }}
+        table thead td {{
             background-color: #54585d;
             color: #ffffff;
             font-weight: bold;
             font-size: 13px;
             border: 1px solid #54585d;
-        }
-        table tbody td {
+        }}
+        table tbody td {{
             color: #636363;
             border: 1px solid #dddfe1;
-        }
-        table tbody tr {
+        }}
+        table tbody tr {{
             background-color: #f9fafb;
-        }
-        table tbody tr:nth-child(odd) {
+        }}
+        table tbody tr:nth-child(odd) {{
             background-color: #ffffff;
-        }
+        }}
         </style>
     </head>
     <body>
@@ -254,9 +281,11 @@ HTML_END = """
 STYLES_PDF = {
     "GREEN_HEADER": ParagraphStyle("Green Header", fontName="Helvetica-Bold", fontSize=20, textColor=colors.green, alignment=TA_CENTER),
     "RED_HEADER": ParagraphStyle("Red Header", fontName="Helvetica-Bold", fontSize=20, textColor=colors.red, alignment=TA_CENTER),
-    "MODULE_HEADER": ParagraphStyle("Module Header", fontName="Helvetica-Bold", fontSize=16, textColor=colors.blue, alignment=TA_CENTER),
+    "MODULE_HEADER": ParagraphStyle("Module Header", fontName="Helvetica-Bold", fontSize=16, textColor=colors.navy, alignment=TA_CENTER),
     "TEST_HEADER": ParagraphStyle("Test Header", fontName="Helvetica-Bold", fontSize=12, textColor=colors.black, alignment=TA_CENTER),
-    "BLUE": ParagraphStyle("Blue", fontName="Helvetica-Bold", fontSize=9, textColor=colors.blue, splitLongWords=False, alignment=TA_CENTER),
+    "BLACK": ParagraphStyle("Black", fontName="Helvetica", fontSize=9, textColor=colors.black, splitLongWords=False, alignment=TA_CENTER, wordWrap = 'CJK'),
+    "BLACK_BOLD": ParagraphStyle("Black Bold", fontName="Helvetica-Bold", fontSize=9, textColor=colors.black, splitLongWords=False, alignment=TA_LEFT, wordWrap = 'CJK'),
+    "BLUE": ParagraphStyle("Blue", fontName="Helvetica-Bold", fontSize=9, textColor=colors.navy, splitLongWords=False, alignment=TA_CENTER),
     "CYAN": ParagraphStyle("Cyan", fontName="Helvetica-Bold", fontSize=9, textColor=colors.cyan, splitLongWords=False, alignment=TA_CENTER),
     "GREEN": ParagraphStyle("Green", fontName="Helvetica-Bold", fontSize=9, textColor=colors.green, splitLongWords=False, alignment=TA_CENTER),
     "WARNING": ParagraphStyle("Warning", fontName="Helvetica-Bold", fontSize=9, textColor=colors.gold, splitLongWords=False, alignment=TA_CENTER),
@@ -277,18 +306,19 @@ INNER_TABLE_STYLE = TableStyle([
                 ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
                 ('FONTSIZE', (0, 0), (-1, 0), 9),
                 ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
-                ('BACKGROUND', (0, 1), (-1, -1), colors.beige),
+                ('BACKGROUND', (0, 1), (-1, -1), colors.whitesmoke),
                 ('WORDWRAP', (0, 0), (-1, -1), False),
             ])
 
 def generate_results_per_module_for_pdf(tests=[]):
+    text_style = STYLES_PDF.get("BLACK", ParagraphStyle("Default"))
     results_per_module = {}
     for test in tests:
         name=test.module_name if (not test.internal_brg or "gw" in test.module_name) else f"{test.module_name} (internal brg)"
         devices_to_print = (test.gw if not test.brg0 or test.gw_only else
                         (f"{test.brg0.id_str}\n{test.brg1.id_str}" if test.brg1 and test.multi_brg else test.brg0.id_str))
-        inner_table = [[phase.name, pass_or_fail_pdf(phase), phase.reason] for phase in test.phases]
-        test_table = Table([["Phase", "Result", "Reason"]] + inner_table)
+        inner_table = [[Paragraph(phase.name, text_style), pass_or_fail_pdf(phase), Paragraph(phase.reason, text_style)] for phase in test.phases]
+        test_table = Table([["Phase", "Result", "Notes"]] + inner_table)
         test_table.setStyle(INNER_TABLE_STYLE)
         test_result = TestResult(name=name, devices_to_print=devices_to_print,
                                  test_table=test_table, result=pass_or_fail_pdf(test), duration=test.duration)

brg_certificate/cert_utils.py

@@ -43,7 +43,7 @@ def load_module(module_name, module_path, rel_path="."):
 def handle_error(error, start_time):
     utPrint(error, "red")
     duration = (datetime.datetime.now()-start_time)
-    cert_results.generate_results_files(html=True, pdf=True, duration=duration, error=error, pipeline=cert_common.pipeline_running())
+    cert_results.generate_results_files(html=True, pdf=True, start_time=start_time, duration=duration, error=error, pipeline=cert_common.pipeline_running())
     sys.exit(-1)
 
 ##################################
@@ -73,7 +73,7 @@ class WltTest:
             self.test_json = {}
             self.internal_brg = False
             self.multi_brg = False
-            self.phases = [Phase(PROLOG), Phase(TEST_BODY), Phase(EPILOG)]
+            self.phases = [Phase(PRE_CONFIG), Phase(TEST_BODY), Phase(RESTORE_CONFIG)]
             self.params = []
 
         self.gw = gw
@@ -83,7 +83,7 @@ class WltTest:
         self.brg0 = brg0
         self.brg1 = brg1
         self.rc = TEST_PASSED
-        self.reason = TEST_SUCCESS
+        self.reason = ""
         self.start_time = None
         self.end_time = None
         self.duration = None
@@ -105,7 +105,7 @@ class WltTest:
     def create_test_phases_and_params(self, line_params):
         self.params = []
         if len(self.test_json[ALL_SUPPORTED_VALUES]) > 0:
-            self.phases = [Phase(PROLOG)] + [Phase(param) for param in self.test_json[ALL_SUPPORTED_VALUES]] + [Phase(EPILOG)]
+            self.phases = [Phase(PRE_CONFIG)] + [Phase(param) for param in self.test_json[ALL_SUPPORTED_VALUES]] + [Phase(RESTORE_CONFIG)]
             for param_phase in self.phases:
                 param = Param(param_phase.name)
                 if (param.name in line_params or param.value in [eval_param(p) for p in line_params]):
@@ -120,7 +120,7 @@ class WltTest:
             if line_params:
                 error = f"ERROR: For {self.name} params exist in test_list but not in test_json!\nline_params:{line_params}"
                 handle_error(error, datetime.datetime.now())
-            self.phases = [Phase(PROLOG), Phase(TEST_BODY), Phase(EPILOG)]
+            self.phases = [Phase(PRE_CONFIG), Phase(TEST_BODY), Phase(RESTORE_CONFIG)]
 
     # Phase rc
     def set_phase_rc(self, phase_name, rc):
@@ -134,9 +134,7 @@ class WltTest:
     # Phase reason
     def add_phase_reason(self, phase_name, reason):
         phase = self.get_phase_by_name(phase_name)
-        if TEST_SUCCESS in phase.reason:
-            phase.reason = phase.reason.replace(TEST_SUCCESS, "")
-        else:
+        if phase.reason:
             phase.reason += "\n"
         if reason not in phase.reason:
             phase.reason += reason
@@ -158,7 +156,7 @@ class WltTest:
     
     def reset_result(self):
         self.rc = TEST_PASSED
-        self.reason = TEST_SUCCESS
+        self.reason = ""
 
     def get_seq_id(self):
         self.rand = (self.rand + 1) % 256
@@ -166,9 +164,7 @@ class WltTest:
 
     # TODO - remove when test reason is re-designed
     def add_reason(self, reason):
-        if TEST_SUCCESS in self.reason:
-            self.reason = self.reason.replace(TEST_SUCCESS, "")
-        else:
+        if self.reason:
             self.reason += "\n"
         if reason not in self.reason:
             self.reason += reason
@@ -180,7 +176,7 @@ class WltTest:
 # Phases
 ##################################
 class Phase:
-    def __init__(self, input=None, tested=True, rc=TEST_INIT, reason=TEST_SUCCESS):
+    def __init__(self, input=None, tested=True, rc=TEST_INIT, reason=""):
         self.name = str(input)
         self.tested = tested
         self.rc = rc
@@ -257,7 +253,7 @@ def cfg_brg_defaults_ret_after_fail(test):
 def handle_prep_brg_for_latest(test, interface, start_time):
     if test.rc == TEST_FAILED:
         utPrint(f"No ModuleIf pkts found, try again", "BLUE")
-        test.rc = TEST_SUCCESS
+        test.rc = ""
         test, interface = cert_common.get_module_if_pkt(test)
     if test.rc == TEST_FAILED:
         error = f"ERROR: No ModuleIf pkts found for 2 tries, couldn't perform OTA for bridge"

brg_certificate/restore_brg.py

@@ -1,4 +1,6 @@
+import sys
 import os
+sys.path.insert(0, os.path.abspath(".."))
 import argparse
 import brg_certificate.cert_common as cert_common
 from brg_certificate.cert_utils import *

brg_certificate/tests/calibration/interval_test/interval_test.py

@@ -11,7 +11,7 @@ def run(test):
     calib_module = eval_pkt(f'ModuleCalibrationV{test.active_brg.api_version}')
 
     test = cert_common.test_prolog(test)
-    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+    if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
     for param in test.params:
         test = cert_config.brg_configure(test, fields=fields, values=[param.value], module=calib_module)[0]

brg_certificate/tests/calibration/output_power_test/output_power_test.py

@@ -11,7 +11,7 @@ def run(test):
     calib_module = eval_pkt(f'ModuleCalibrationV{test.active_brg.api_version}')
 
     test = cert_common.test_prolog(test)
-    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+    if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
 
     for param in test.params:

brg_certificate/tests/calibration/pattern_test/pattern_test.py

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

brg_certificate/tests/datapath/adaptive_pacer_algo_test/adaptive_pacer_algo_test.py

@@ -24,15 +24,15 @@ def run(test):
     calib_module = eval_pkt(f'ModuleCalibrationV{test.active_brg.api_version}')
 
     test = cert_common.test_prolog(test)
-    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+    if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
 
     # Turn on adaptive pacer and set cfgs to help activating adaptive pacer algo
     test = cert_config.brg_configure(test, fields=fields, values=values, module=datapath_module)[0]
-    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+    if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test, revert_brgs=True, modules=[datapath_module])
     test = cert_config.brg_configure(test, fields=[BRG_CALIB_INTERVAL], values=[30], module=calib_module)[0]
-    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+    if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test, revert_brgs=True, modules=[calib_module])
 
     # Wait for tx rep algo to work & then activate pacing algo
@@ -70,7 +70,7 @@ def run(test):
     cert_common.display_data(df, nfpkt=True, pkt_cntr_diff=True, cer_per_tag=True, name_prefix=test.module_name, dir=test.dir)
 
     test = cert_common.pacing_analysis(test, df=df, pacer_interval=1+effective_pacer_increment)
-    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+    if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test, revert_brgs=True, modules=[datapath_module, calib_module])
 
     return cert_common.test_epilog(test, revert_brgs=True, modules=[datapath_module, calib_module])

brg_certificate/tests/datapath/num_of_tags_test/num_of_tags_test.py

@@ -13,7 +13,7 @@ def run(test):
     print(f"values: {[param.value for param in test.params]}")
 
     test = cert_common.test_prolog(test)
-    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+    if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
 
     duplicates = 3
@@ -24,7 +24,7 @@ def run(test):
         time_of_sending_pkts = duplicates * param.value * GW_CYCLE_TIME * 2
 
         test = cert_config.brg_configure(test, fields=[BRG_PACER_INTERVAL], values=[time_of_sending_pkts], module=datapath_module)[0]
-        if test.rc == TEST_FAILED and test.reason != TEST_SUCCESS:
+        if test.rc == TEST_FAILED:
             return cert_common.test_epilog(test)
     
 

brg_certificate/tests/datapath/output_power_test/output_power_test.py

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

brg_certificate/tests/datapath/pacer_interval_ble5_test/pacer_interval_ble5_test.py

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

brg_certificate/tests/datapath/pacer_interval_tags_count_test/pacer_interval_tags_count_test.py

@@ -11,13 +11,13 @@ def run(test):
     datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
 
     test = cert_common.test_prolog(test)
-    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+    if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
 
     # Configure the GW to receive tags pkt
     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 or test.reason != TEST_SUCCESS:
+        if test.rc == TEST_FAILED:
             return cert_common.test_epilog(test, revert_gws=True)
 
     num_of_pixels = 200

brg_certificate/tests/datapath/pacer_interval_test/pacer_interval_test.py

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

brg_certificate/tests/datapath/pattern_test/pattern_test.py

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

brg_certificate/tests/datapath/pkt_filter_ble5_test/pkt_filter_ble5_test.py

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

brg_certificate/tests/datapath/pkt_filter_gen3_test/pkt_filter_gen3_test.py

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

brg_certificate/tests/datapath/pkt_filter_test/pkt_filter_test.py

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

brg_certificate/tests/datapath/rssi_threshold_test/rssi_threshold_test.py

@@ -31,7 +31,7 @@ def run(test):
     datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
 
     test = cert_common.test_prolog(test)
-    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+    if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
     
     # Configure the BRG with RSSI threshold and check for packets violating the threshold

brg_certificate/tests/datapath/rx_channel_test/rx_channel_test.py

@@ -18,7 +18,7 @@ def run(test):
     ble5_state =  False # We use this flag to know whether the BRG is currently in BLE5 mode and needs special configuration next time it is configured
 
     test = cert_common.test_prolog(test)
-    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+    if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
 
     for param in test.params:

brg_certificate/tests/datapath/rx_rate_gen2_test/rx_rate_gen2_test.py

@@ -159,7 +159,7 @@ def run(test):
     # "Test prolog"
     datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
     test = cert_common.test_prolog(test)
-    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+    if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
     
     pacer_interval =1 

brg_certificate/tests/datapath/rx_rate_gen3_test/rx_rate_gen3_test.py

@@ -184,7 +184,7 @@ def run(test):
     # "Test prolog"
     datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
     test = cert_common.test_prolog(test)
-    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+    if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
     
     fields = [BRG_PACER_INTERVAL]

brg_certificate/tests/datapath/stress_gen3_test/stress_gen3_test.py

@@ -12,7 +12,7 @@ import time
 
 def configure_pacer_n_times(test, num_of_times, pacer_interval, datapath_module):
     test = cert_config.brg_configure(test, fields=[BRG_PACER_INTERVAL], values=[pacer_interval], module=datapath_module)[0]
-    if test.rc == TEST_FAILED and test.reason != TEST_SUCCESS:
+    if test.rc == TEST_FAILED:
         for i in range(num_of_times):
             if test.rc == TEST_PASSED:
                 return test
@@ -171,7 +171,7 @@ def run(test):
     # Test prolog
     datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
     test = cert_common.test_prolog(test)
-    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+    if test.rc == TEST_FAILED:
         return cert_common.test_epilog(test)
     #config GW deduplication pkts = 0  "
     print("Configuring GW with !deduplication_pkts 0")