wiliot-certificate 4.4.2__py3-none-any.whl → 4.5.0__py3-none-any.whl

brg_certificate/ag/wlt_types_ag_jsons/side_info_sensor.json

@@ -1,105 +0,0 @@
-{
-  "versions": [
-    {
-      "version": "0",
-      "packetFields": [
-        {
-          "name": "bridgeId",
-          "byteOffset": 5,
-          "byteLength": 6,
-          "bitOffset": 0,
-          "bitLength": 48,
-          "outType": "string"
-        },
-        {
-          "name": "nfpkt",
-          "byteOffset": 11,
-          "byteLength": 2,
-          "bitOffset": 0,
-          "bitLength": 16,
-          "outType": "uint"
-        },
-        {
-          "name": "rssi",
-          "byteOffset": 13,
-          "byteLength": 1,
-          "bitOffset": 0,
-          "bitLength": 8,
-          "outType": "uint"
-        },
-        {
-          "name": "sensorId",
-          "byteOffset": 15,
-          "byteLength": 6,
-          "bitOffset": 0,
-          "bitLength": 48,
-          "outType": "string"
-        },
-        {
-          "name": "sensorServiceId",
-          "byteOffset": 21,
-          "byteLength": 1,
-          "bitOffset": 0,
-          "bitLength": 8,
-          "outType": "uint"
-        },
-        {
-          "name": "sensorUuidMsb",
-          "byteOffset": 22,
-          "byteLength": 1,
-          "bitOffset": 0,
-          "bitLength": 8,
-          "outType": "uint"
-        },
-        {
-          "name": "sensorUuidLsb",
-          "byteOffset": 23,
-          "byteLength": 1,
-          "bitOffset": 0,
-          "bitLength": 8,
-          "outType": "uint"
-        },
-        {
-          "name": "apiVersion",
-          "byteOffset": 24,
-          "byteLength": 1,
-          "bitOffset": 4,
-          "bitLength": 4,
-          "outType": "uint"
-        },
-        {
-          "name": "scrambled",
-          "byteOffset": 24,
-          "byteLength": 1,
-          "bitOffset": 2,
-          "bitLength": 1,
-          "outType": "boolean"
-        },
-        {
-          "name": "embedded",
-          "byteOffset": 24,
-          "byteLength": 1,
-          "bitOffset": 1,
-          "bitLength": 1,
-          "outType": "boolean"
-        },
-        {
-          "name": "isSensor",
-          "byteOffset": 24,
-          "byteLength": 1,
-          "bitOffset": 0,
-          "bitLength": 1,
-          "outType": "boolean"
-        },
-        {
-          "name": "pktId",
-          "byteOffset": 25,
-          "byteLength": 4,
-          "bitOffset": 0,
-          "bitLength": 32,
-          "outType": "string"
-        }
-      ]
-    }
-  ]
-}

brg_certificate/ag/wlt_types_ag_jsons/signal_indicator_data.json

@@ -1,77 +0,0 @@
-{
-  "versions": [
-    {
-      "version": "1",
-      "packetFields": [
-        {
-          "name": "groupId",
-          "byteOffset": 2,
-          "byteLength": 3,
-          "bitOffset": 0,
-          "bitLength": 24,
-          "outType": "uint"
-        },
-        {
-          "name": "version",
-          "byteOffset": 5,
-          "byteLength": 1,
-          "bitOffset": 0,
-          "bitLength": 8,
-          "outType": "uint"
-        },
-        {
-          "name": "msgType",
-          "byteOffset": 6,
-          "byteLength": 1,
-          "bitOffset": 0,
-          "bitLength": 8,
-          "outType": "uint"
-        },
-        {
-          "name": "outputPower",
-          "byteOffset": 7,
-          "byteLength": 1,
-          "bitOffset": 0,
-          "bitLength": 8,
-          "outType": "int"
-        },
-        {
-          "name": "antennaType",
-          "byteOffset": 8,
-          "byteLength": 1,
-          "bitOffset": 0,
-          "bitLength": 8,
-          "outType": "uint",
-          "map": {
-            "0":"2_4 Antenna",
-            "1":"Sub1g Antenna"
-          }
-        },
-        {
-          "name": "txAntenna",
-          "byteOffset": 9,
-          "byteLength": 1,
-          "bitOffset": 0,
-          "bitLength": 8,
-          "outType": "uint"
-        },
-        {
-          "name": "rxAntenna",
-          "byteOffset": 10,
-          "byteLength": 1,
-          "bitOffset": 0,
-          "bitLength": 8,
-          "outType": "uint"
-        },
-        {
-          "name": "seqId",
-          "byteOffset": 11,
-          "byteLength": 1,
-          "bitOffset": 0,
-          "bitLength": 8,
-          "outType": "uint"
-        }
-      ]
-    }
-  ]
-}

brg_certificate/ag/wlt_types_ag_jsons/unified_echo_ext_pkt.json

@@ -1,61 +0,0 @@
-{
-  "versions": [
-    {
-      "version": "0",
-      "packetFields": [
-        {
-          "name": "tbc",
-          "byteOffset": 37,
-          "byteLength": 1,
-          "bitOffset": 0,
-          "bitLength": 8,
-          "outType": "uint"
-        },
-        {
-          "name": "rssi",
-          "byteOffset": 38,
-          "byteLength": 1,
-          "bitOffset": 2,
-          "bitLength": 6,
-          "outType": "uint",
-          "calculations": [
-            {
-              "operator": "*",
-              "operand": 1
-            },
-            {
-              "operator": "+",
-              "operand": 40
-            }
-          ]
-        },
-        {
-          "name": "brgLatency",
-          "byteOffset": 38,
-          "byteLength": 1,
-          "bitOffset": 4,
-          "bitLength": 6,
-          "outType": "uint",
-          "calculations": [
-            {
-              "operator": "*",
-              "operand": 200
-            },
-            {
-              "operator": "+",
-              "operand": 0
-            }
-          ]
-        },
-        {
-          "name": "nfpkt",
-          "byteOffset": 39,
-          "byteLength": 1,
-          "bitOffset": 0,
-          "bitLength": 4,
-          "outType": "uint"
-        }
-      ]
-    }
-  ]
-}

brg_certificate/ag/wlt_types_ag_jsons/unified_echo_pkt.json

@@ -1,110 +0,0 @@
-{
-  "versions": [
-    {
-      "version": "1",
-      "packetFields": [
-        {
-          "name": "tbc",
-          "byteOffset": 15,
-          "byteLength": 1,
-          "bitOffset": 0,
-          "bitLength": 8,
-          "outType": "uint"
-        },
-        {
-          "name": "rssi",
-          "byteOffset": 16,
-          "byteLength": 1,
-          "bitOffset": 2,
-          "bitLength": 6,
-          "outType": "uint",
-          "calculations": [
-            {
-              "operator": "*",
-              "operand": 1
-            },
-            {
-              "operator": "+",
-              "operand": 40
-            }
-          ]
-        },
-        {
-          "name": "brgLatency",
-          "byteOffset": 16,
-          "byteLength": 1,
-          "bitOffset": 4,
-          "bitLength": 6,
-          "outType": "uint",
-          "calculations": [
-            {
-              "operator": "*",
-              "operand": 200
-            },
-            {
-              "operator": "+",
-              "operand": 0
-            }
-          ]
-        },
-        {
-          "name": "nfpkt",
-          "byteOffset": 17,
-          "byteLength": 1,
-          "bitOffset": 0,
-          "bitLength": 4,
-          "outType": "uint"
-        }
-      ]
-    },
-    {
-      "version": "0",
-      "packetFields": [
-        {
-          "name": "nfpkt",
-          "byteOffset": 15,
-          "byteLength": 1,
-          "bitOffset": 0,
-          "bitLength": 8,
-          "outType": "uint"
-        },
-        {
-          "name": "rssi",
-          "byteOffset": 16,
-          "byteLength": 1,
-          "bitOffset": 2,
-          "bitLength": 6,
-          "outType": "uint",
-          "calculations": [
-            {
-              "operator": "*",
-              "operand": 1
-            },
-            {
-              "operator": "+",
-              "operand": 40
-            }
-          ]
-        },
-        {
-          "name": "brgLatency",
-          "byteOffset": 16,
-          "byteLength": 1,
-          "bitOffset": 4,
-          "bitLength": 6,
-          "outType": "uint",
-          "calculations": [
-            {
-              "operator": "*",
-              "operand": 200
-            },
-            {
-              "operator": "+",
-              "operand": 0
-            }
-          ]
-        }
-      ]
-    }
-  ]
-}

brg_certificate/brg_certificate.py

@@ -1,225 +0,0 @@
-
-# generic
-import sys
-import os
-sys.path.insert(0, os.path.abspath(".."))
-import webbrowser
-import glob
-import datetime
-import tabulate
-import threading
-# Local imports
-from brg_certificate.cert_defines import *
-from brg_certificate.cert_prints import *
-from brg_certificate.wlt_types import *
-from brg_certificate.cert_utils import *
-import brg_certificate.cert_results as cert_results
-import brg_certificate.cert_gw_sim as cert_gw_sim
-import brg_certificate.cert_mqtt as cert_mqtt
-import brg_certificate.cert_common as cert_common
-
-TEST_LIST_FW_UPDATE_FILE = "ut/fw_update_test_list.txt"
-CLEAN_PATTERNS = ['./tests/**/*.html', './tests/**/mqtt_log_*', './tests/**/*.pyc', './tests/**/*.csv']
-
-os.system('')
-
-def filter_tests(tests, run, drun):
-    if run:
-        tests = [t for t in tests if re.search(run, t.name)]
-    if drun:
-        tests = [t for t in tests if not re.search(drun, t.name)]
-    return tests
-
-def get_important_tests_info():
-    patterns = ["DISCONNECTED", "WLT_ERROR", "free heap size", "python_mqtt_disconnect"]
-    return "".join([l.strip(' "') for l in open(os.path.join(BASE_DIR, CERT_MQTT_LOG_FILE)).readlines() if any([p in l for p in patterns])])
-
-def skip_test_check(test, args):
-    skip_string = ""
-    if test.multi_brg and not test.brg1:
-        skip_string = f"Skipped {test.module_name} multi brg test because brg1 wasn't given"
-    elif (args.brg_cloud_connectivity or test.internal_brg) and not test.test_json[INTERNAL_BRG]:
-        skip_string = f"Skipped {test.module_name} because test is unable to run on an internal brg"
-    elif args.skip_internal and test.internal_brg:
-        skip_string = f"Skipped {test.module_name} for internal brg because skip_internal flag is set"
-    elif test.active_brg and not test.active_brg.is_sup_cap(test):
-        skip_string = f"Skipped {test.module_name} because {module2name(test.test_module)} module is not supported"
-    if skip_string:
-        utPrint(f"{SEP}{skip_string}{SEP}", "WARNING")
-        test.reason = skip_string
-        test.rc = TEST_SKIPPED
-    return test
-
-def tests_rtsa_update(tests):
-    # Init spectrum analyzer
-    rtsa_flag = False
-    for t in tests:
-        if "rtsa" in t.module_name:
-            if not rtsa_flag:
-                try:
-                    ut_te = load_module('ut_te.py', 'ut/ut_te/ut_te.py')
-                except:
-                    print("Unable to import UT's test equipment API (ut_te.py), check exceptions for necessary installations!")
-                try:
-                    myObjTE = ut_te.StationEquipment().GetTEObject()
-                    myRTSA = myObjTE['RTSA']
-                except:
-                    print("No test equipment available!")
-                rtsa_flag = True
-            t.rtsa = myRTSA
-
-def main(args):
-    args.gw = get_gw_id(args.gw)
-
-    utPrint(str(args.__dict__))
-    start_time = datetime.datetime.now()
-
-    # Clean
-    if os.path.exists(CERT_MQTT_LOG_FILE):
-        os.remove(CERT_MQTT_LOG_FILE)
-    if os.path.exists(DATA_SIM_LOG_FILE):
-        os.remove(DATA_SIM_LOG_FILE)
-    if args.clean:
-        for clean_pattern in CLEAN_PATTERNS:
-            for f in glob.glob(clean_pattern, recursive=True):
-                os.remove(f)
-        if not args.gw and not args.brg:
-            utPrint("Clean only - Done!")
-            sys.exit(0)
-
-    # Init mqtt client
-    if args.brg_cloud_connectivity:
-        # Mqtt client for tested device
-        mqttc = cert_mqtt.mqttc_init(args.brg_cloud_connectivity, data=args.data)
-        # Mqtt client for testing device
-        sim_mqttc = cert_mqtt.mqttc_init(args.gw, data=args.data)
-    else:
-        # Single mqtt client for a single device with cloud connectivity
-        mqttc = cert_mqtt.mqttc_init(args.gw, data=args.data)
-        sim_mqttc = mqttc
-
-
-    # Run Gateway Simulator in separated thread if exists
-    gw_sim_thread = None
-    if GW_SIM_PREFIX in args.gw:
-        gw_sim_thread = threading.Thread(target=cert_gw_sim.gw_sim_run, daemon = True, kwargs={'port':args.port, 'gw_id': args.gw,
-                                                                              'analyze_interference':args.analyze_interference})
-        gw_sim_thread.start()
-        sleep_time = (len(cert_gw_sim.CHANNELS_TO_ANALYZE) * 30) + 15 if args.analyze_interference else 10
-        time.sleep(sleep_time)
-
-    # Collecting the tests
-    if args.latest or args.rc:
-        test_list = TEST_LIST_FW_UPDATE_FILE
-    else:
-        test_list = args.tl
-
-    # Prepare GW
-    if gw_sim_thread:
-        if args.brg_cloud_connectivity:
-            # Prepare tested device
-            gw, internal_brg, gw_server, gw_version, protobuf = ut_prep_gw(args, mqttc, start_time)
-            # Prepare testing device
-            _, internal_brg_sim, _, _, _ = cert_gw_sim.prep_gw(args, sim_mqttc, start_time)
-        else:
-            # Prepare single device with cloud connectivity
-            gw, internal_brg, gw_server, gw_version, protobuf = cert_gw_sim.prep_gw(args, mqttc, start_time)
-    else:
-        if args.brg_cloud_connectivity:
-            # Prepare tested device
-            gw, internal_brg, gw_server, gw_version, protobuf = ut_prep_gw(args, mqttc, start_time)
-            # Prepare testing device
-            _, internal_brg_sim, _, _, _ = ut_prep_gw(args, sim_mqttc, start_time, tester_gw=True)
-        else:
-            # Prepare single device with cloud connectivity
-            gw, internal_brg, gw_server, gw_version, protobuf = ut_prep_gw(args, mqttc, start_time)
-
-    brg0, brg1 = None, None
-    if args.brg_cloud_connectivity:
-        brg0 = internal_brg
-        internal_brg = internal_brg_sim
-    elif args.brg:
-        brg0 = ut_prep_brg(args, mqttc, start_time, gw, args.brg, gw_server, protobuf)
-        if args.brg1:
-            brg1 = ut_prep_brg(args, mqttc, start_time, gw, args.brg1, gw_server, protobuf)
-
-    # Collecting the tests
-    tests = []
-    for l in open(os.path.join(BASE_DIR, test_list)).readlines():
-        if l.strip() and not l.strip().startswith("#"):
-            test = (WltTest(l.strip(), gw, mqttc, sim_mqttc=sim_mqttc, exit_on_param_failure=args.exit_on_param_failure, gw_lan=args.lan,
-                    gw_orig_versions={BLE_VERSION:gw_version[BLE_VERSION], WIFI_VERSION:gw_version[WIFI_VERSION]},
-                    server=gw_server, latest=args.latest, release_candidate=args.rc, private_setup=args.private_setup, internal_brg_obj=internal_brg,
-                    gw_sim=gw_sim_thread, data=args.data, port=args.port, protobuf=protobuf))
-            test.brg0 = brg0
-            test.brg1 = brg1
-            if test.internal_brg and test.multi_brg:
-                test.brg1 = internal_brg
-            elif test.internal_brg and not test.multi_brg:
-                test.brg0 = internal_brg
-            elif not test.internal_brg and not test.gw_only and not test.brg0:
-                continue
-            test.active_brg = test.brg0
-            tests += [test]
-    tests = filter_tests(tests=tests, run=args.run, drun=args.drun)
-
-    # Init spectrum analyzer
-    tests_rtsa_update(tests)
-
-    # Running the tests
-    utPrint(SEP)
-    utPrint("\n - ".join([f"\nRunning {len(tests)} tests:"] + [t.name if not t.internal_brg else f"{t.name} (internal brg)" for t in tests]))
-
-    failures, skipped = 0, 0
-    exit_on_test_failure = args.exit_on_test_failure
-    i = 0
-
-    for i, test in enumerate(tests):
-        test_module_name = load_module(f'{test.module_name}.py', f'{test.dir}/{test.module_name}.py')
-        test = skip_test_check(test, args)
-        if test.rc == TEST_SKIPPED:
-            for phase in test.phases:
-                phase.rc = TEST_SKIPPED
-            skipped += 1
-        else:
-            test = test_module_name.run(test)
-            test.update_overall_rc()
-        if test.rc == TEST_FAILED:
-            failures += 1
-            if "versions_test" in test.module_name and f"EXITING CERTIFICATE" in test.reason:
-                exit_on_test_failure = True
-        print(f"Test Duration: {test.duration}")
-        print(tabulate.tabulate([[i+1, i+1-(failures+skipped), skipped, failures, len(tests)]],
-                            headers=["FINISHED", "PASSED", "SKIPPED", "FAILED", "TOTAL"], tablefmt="pretty"))
-        cert_common.wait_time_n_print(2)
-        if exit_on_test_failure and test.rc == TEST_FAILED:
-            break
-
-    # Print results
-    print(SEP)
-    duration = (datetime.datetime.now()-start_time)
-    print("Tests duration: {}".format(str(duration).split(".")[0]))
-    brg_version = ''
-    if test.active_brg:
-        brg_version =  test.active_brg.version
-        print("Bridge version: {}".format(brg_version))
-    print(cert_results.generate_tests_table(tests))
-    print(tabulate.tabulate([[i+1, i+1-(failures+skipped), skipped, failures, len(tests)]],
-                            headers=["FINISHED", "PASSED", "SKIPPED", "FAILED", "TOTAL"], tablefmt="pretty"))
-
-    print(WIL_CERT_TEXT)
-    print_warn(get_important_tests_info())
-    print_pass_or_fail(not failures, f"Wiliot Certificate")
-
-    pipeline = cert_common.pipeline_running()
-    # brg = args.brg_cloud_connectivity if args.brg_cloud_connectivity else args.brg
-    cert_results.generate_results_files(html=True, pdf=True, failures=failures, skipped=skipped, start_time=start_time, duration=duration,
-                                        brg=test.active_brg, internal_brg=internal_brg, tests=tests, pipeline=pipeline)
-    if not pipeline:
-        webbrowser.open('file://' + os.path.realpath(os.path.join(BASE_DIR, UT_RESULT_FILE_PDF)))
-
-    if failures:
-        sys.exit(-1)
-
-if __name__ == '__main__':
-    main()

brg_certificate/brg_certificate_cli.py

@@ -1,63 +0,0 @@
-import sys
-import os
-sys.path.insert(0, os.path.abspath(".."))
-from argparse import ArgumentParser, RawDescriptionHelpFormatter
-from brg_certificate.cert_defines import DATA_REAL_TAGS, DATA_SIMULATION
-import brg_certificate.brg_certificate as brg_certificate
-TEST_LIST_DEFAULT_FILE = "certificate_test_list.txt"
-
-class BrgCertificateCLI:
-    """Bridge Certificate CLI."""
-    def __init__(self):
-        self.parser = ArgumentParser(
-            description="Bridge Certificate CLI",
-            epilog=
-            "run examples:\n"
-            "  Run command example with COM PORT connection:\n"
-            "  wlt-cert-brg --gw SIM --brg <XXXXXXXXXXXX> --port <COM_PORT>\n"
-            "  Run command example with remote GW connection:\n"
-            "  wlt-cert-brg --gw <YYYYYYYYYYYY> --brg <XXXXXXXXXXXX>\n"
-            "  Run command example for running datapath module tests only:\n"
-            "  wlt-cert-brg --gw <YYYYYYYYYYYY> --brg <XXXXXXXXXXXX> --run datapath\n"
-            "  Run command example with sanity test list:\n"
-            "  wlt-cert-brg --gw <YYYYYYYYYYYY> --brg <XXXXXXXXXXXX> --tl certificate_sanity_test_list.txt\n"
-            "  Run command example with COM PORT connection for bridge with cloud connectivity:\n"
-            "  wlt-cert-brg --gw SIM --brg_cloud_connectivity <XXXXXXXXXXXX> --tl certificate_bcc_test_list.txt --port <COM_PORT>\n"
-            "  Run command example with remote GW connection for bridge with cloud connectivity:\n"
-            "  wlt-cert-brg --gw <YYYYYYYYYYYY> --brg_cloud_connectivity <XXXXXXXXXXXX> --tl certificate_bcc_test_list.txt\n",
-            formatter_class=RawDescriptionHelpFormatter
-        )
-        self.parser.add_argument('--brg', '-b', default="", help='Bridge id to run on the tests')
-        self.parser.add_argument('--brg_cloud_connectivity', '-bcc', default="", help='Bridge with cloud connectivity id to run on the tests')
-        self.parser.add_argument('--brg1', '-b1', default="", help='Second bridge id to run on tests two bridges needed')
-        self.parser.add_argument('--gw', '-g', type=str, required=True, help='GW id to run on the test, SIM prefix is used for Gateway simulation')
-        self.parser.add_argument('--data', '-d', choices=[DATA_REAL_TAGS, DATA_SIMULATION], default=DATA_SIMULATION, help='Choose if data generated from real tags or by simulation')
-        self.parser.add_argument('--port', '-p', default='', help='Enable UT using UART connection for Gateway Simulation or Data Simulation')
-        self.parser.add_argument('--clean', default=False, action='store_true', help='Clean all logs')
-        self.parser.add_argument('--tl', type=str, help='Test list file to use', default=TEST_LIST_DEFAULT_FILE)
-        self.parser.add_argument('--run', type=str, help='String to filter tests to run')
-        self.parser.add_argument('--drun', type=str, help='String to filter tests not to run')
-        self.parser.add_argument('--exit_on_test_failure', default=False, action='store_true', help='Stop running the tests if a test failed')
-        self.parser.add_argument('--exit_on_param_failure', default=False, action='store_true', help='Sets exit_on_param_failure mode to true in order to prevent \
-                                 tests from continuing iteration over all possibilities in case of failure')
-        self.parser.add_argument('--analyze_interference', '-ai', default=False, action='store_true', help='Analyze interference before tests start \
-                        (relevant only for Gateway Simulator)')
-
-    def parse_args(self, args=None):
-        """Parse arguments and return them."""
-        return self.parser.parse_args(args)
-
-def main():
-    cli = BrgCertificateCLI()
-    args = cli.parse_args()
-    # Set extra args to defaults
-    args.server = "prod"
-    args.lan = False
-    args.latest = False
-    args.rc = False
-    args.private_setup = False
-    args.skip_internal = False
-    brg_certificate.main(args)
-
-if __name__ == '__main__':
-    main()