vunit-hdl 5.0.0.dev2__tar.gz → 5.0.0.dev3__tar.gz

{vunit_hdl-5.0.0.dev2 → vunit_hdl-5.0.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vunit_hdl
-Version: 5.0.0.dev2
+Version: 5.0.0.dev3
 Summary: VUnit is an open source unit testing framework for VHDL/SystemVerilog.
 Home-page: https://github.com/VUnit/vunit
 Author: Lars Asplund

{vunit_hdl-5.0.0.dev2 → vunit_hdl-5.0.0.dev3}/tests/acceptance/test_artificial.py

@@ -129,6 +129,7 @@ class TestVunitArtificial(unittest.TestCase):
                 ("passed", "lib.tb_magic_paths.Test magic paths are correct"),
                 ("passed", "lib.tb_with_define.test 1"),
                 ("failed", "lib.tb_fail_on_warning.fail"),
+                ("failed", "lib.tb_fail_on_warning_from_python.fail"),
                 ("failed", "lib.tb_fail_on_fatal_and_early_finish.fatal0"),
                 ("failed", "lib.tb_fail_on_fatal_and_early_finish.fatal1"),
                 ("failed", "lib.tb_fail_on_fatal_and_early_finish.finish0"),
@@ -144,6 +145,12 @@ class TestVunitArtificial(unittest.TestCase):
                 ("passed", "lib.tb_same_sim_some_fail.Test 1"),
                 ("failed", "lib.tb_same_sim_some_fail.Test 2"),
                 ("skipped", "lib.tb_same_sim_some_fail.Test 3"),
+                ("passed", "lib.tb_same_sim_from_python_all_pass.cfg.Test 1"),
+                ("passed", "lib.tb_same_sim_from_python_all_pass.cfg.Test 2"),
+                ("passed", "lib.tb_same_sim_from_python_all_pass.cfg.Test 3"),
+                ("passed", "lib.tb_same_sim_from_python_some_fail.Test 1"),
+                ("failed", "lib.tb_same_sim_from_python_some_fail.Test 2"),
+                ("skipped", "lib.tb_same_sim_from_python_some_fail.Test 3"),
                 ("passed", "lib.tb_with_runner.pass"),
                 ("failed", "lib.tb_with_runner.fail"),
             ],
@@ -183,7 +190,9 @@ EXPECTED_REPORT = (
     ("failed", "lib.tb_fail.all"),
     ("passed", "lib.tb_infinite_events.all"),
     ("failed", "lib.tb_fail_on_warning.all"),
-    ("passed", "lib.tb_no_fail_on_warning.all"),
+    ("failed", "lib.tb_fail_on_warning_from_python.all"),
+    ("passed", "lib.tb_no_fail_on_warning.cfg1"),
+    ("passed", "lib.tb_no_fail_on_warning.cfg2"),
     ("passed", "lib.tb_with_vhdl_runner.pass"),
     ("passed", "lib.tb_with_vhdl_runner.Test with spaces"),
     ("failed", "lib.tb_with_vhdl_runner.fail"),
@@ -197,6 +206,12 @@ EXPECTED_REPORT = (
     ("passed", "lib.tb_same_sim_some_fail.Test 1"),
     ("failed", "lib.tb_same_sim_some_fail.Test 2"),
     ("skipped", "lib.tb_same_sim_some_fail.Test 3"),
+    ("passed", "lib.tb_same_sim_from_python_all_pass.cfg.Test 1"),
+    ("passed", "lib.tb_same_sim_from_python_all_pass.cfg.Test 2"),
+    ("passed", "lib.tb_same_sim_from_python_all_pass.cfg.Test 3"),
+    ("passed", "lib.tb_same_sim_from_python_some_fail.Test 1"),
+    ("failed", "lib.tb_same_sim_from_python_some_fail.Test 2"),
+    ("skipped", "lib.tb_same_sim_from_python_some_fail.Test 3"),
     ("passed", "lib.tb_with_checks.Test passing check"),
     ("failed", "lib.tb_with_checks.Test failing check"),
     ("failed", "lib.tb_with_checks.Test non-stopping failing check"),

{vunit_hdl-5.0.0.dev2 → vunit_hdl-5.0.0.dev3}/tests/unit/test_test_bench.py

@@ -273,6 +273,24 @@ if run("Test_2")
         tests = self.create_tests(test_bench)
         self.assert_has_tests(tests, [("lib.tb_entity", ("lib.tb_entity.Test_1", "lib.tb_entity.Test_2"))])
 
+    @with_tempdir
+    def test_that_run_in_same_simulation_attribute_from_python_works(self, tempdir):
+        for value in [None, True]:
+            design_unit = Entity(
+                "tb_entity",
+                file_name=str(Path(tempdir) / "file.vhd"),
+                contents="""\
+if run("Test_1")
+if run("Test_2")
+--if run("Test_3")
+""",
+            )
+            design_unit.generic_names = ["runner_cfg"]
+            test_bench = TestBench(design_unit)
+            test_bench.set_attribute("run_all_in_same_sim", value)
+            tests = self.create_tests(test_bench)
+            self.assert_has_tests(tests, [("lib.tb_entity", ("lib.tb_entity.Test_1", "lib.tb_entity.Test_2"))])
+
     @with_tempdir
     def test_add_config(self, tempdir):
         design_unit = Entity("tb_entity", file_name=str(Path(tempdir) / "file.vhd"))
@@ -451,6 +469,22 @@ if run("Test 2")
         else:
             assert False, "RuntimeError not raised"
 
+    @with_tempdir
+    def test_error_on_global_attributes_from_python_on_tests(self, tempdir):
+        design_unit = Entity(
+            "tb_entity",
+            file_name=str(Path(tempdir) / "file.vhd"),
+            contents="""\
+if run("Test 1")
+if run("Test 2")
+""",
+        )
+        design_unit.generic_names = ["runner_cfg"]
+
+        test_bench = TestBench(design_unit)
+        test = test_bench.get_test_case("Test 1")
+        self.assertRaises(AttributeException, test.set_attribute, "run_all_in_same_sim", True)    
+
     @with_tempdir
     def test_test_information(self, tempdir):
         file_name = str(Path(tempdir) / "file.vhd")

{vunit_hdl-5.0.0.dev2 → vunit_hdl-5.0.0.dev3}/vunit/about.py

@@ -69,4 +69,4 @@ def version():
     return VERSION
 
 
-VERSION = "5.0.0.dev2"
+VERSION = "5.0.0.dev3"

{vunit_hdl-5.0.0.dev2 → vunit_hdl-5.0.0.dev3}/vunit/test/bench.py

@@ -184,13 +184,7 @@ class TestBench(ConfigurationVisitor):
                         f"{file_name!s} line {attr.location.lineno:d}"
                     )
 
-        attribute_names = [attr.name for attr in attributes]
-
         default_config = Configuration(DEFAULT_NAME, self.design_unit)
-
-        if "fail_on_warning" in attribute_names:
-            default_config.set_sim_option("vhdl_assert_stop_level", "warning")
-
         self._configs = OrderedDict({default_config.name: default_config})
 
         explicit_tests = [test for test in tests if test.is_explicit]
@@ -203,12 +197,68 @@ class TestBench(ConfigurationVisitor):
             assert len(tests) == 1
             self._implicit_test = tests[0]
 
-        self._individual_tests = "run_all_in_same_sim" not in attribute_names and len(explicit_tests) > 0
+        self._individual_tests = len(explicit_tests) > 0
         self._test_cases = [
             TestConfigurationVisitor(test, self.design_unit, self._individual_tests, default_config.copy())
             for test in explicit_tests
         ]
 
+        # This must be done after self._test_cases have been created such that run_all_in_same_sim can disable them
+        for attr in attributes:
+            self.set_attribute(attr.name, attr.value)
+
+    def set_attribute(self, name, value):
+        """
+        Set attributes except fail_on_warning and run_all_in_same_sim which have special meanings
+        """
+        if name == "fail_on_warning":
+            self.set_sim_option("vhdl_assert_stop_level", "warning" if value or value is None else "error")
+            return
+
+        if name == "run_all_in_same_sim":
+            run_all_in_same_sim = value or value is None
+            for test_case in self._test_cases:
+                test_case.enable_configuration = not run_all_in_same_sim
+
+            self._individual_tests = not run_all_in_same_sim and len(self._test_cases) > 0
+
+            return
+
+        super().set_attribute(name, value)
+
+    def add_config(  # pylint: disable=too-many-arguments
+        self,
+        name,
+        generics=None,
+        pre_config=None,
+        post_check=None,
+        sim_options=None,
+        attributes=None,
+        vhdl_configuration_name=None,
+    ):
+        """
+        Add a configuration copying unset fields from the default configuration.
+
+        fail_on_warning and run_all_in_same_sim have special meaning and are handled
+        separately.
+        """
+        if attributes:
+            if "fail_on_warning" in attributes:
+                value = attributes["fail_on_warning"]
+                self.set_sim_option("vhdl_assert_stop_level", "warning" if value or value is None else "error")
+                del attributes["fail_on_warning"]
+
+            if "run_all_in_same_sim" in attributes:
+                value = attributes["run_all_in_same_sim"]
+                run_all_in_same_sim = value or value is None
+                for test_case in self._test_cases:
+                    test_case.enable_configuration = not run_all_in_same_sim
+
+                self._individual_tests = not run_all_in_same_sim and len(self._test_cases) > 0
+                del attributes["run_all_in_same_sim"]
+
+        super().add_config(name, generics, pre_config, post_check, sim_options, attributes, vhdl_configuration_name)
+
 
 class FileLocation(object):
     """
@@ -315,7 +365,7 @@ class TestConfigurationVisitor(ConfigurationVisitor):
         ConfigurationVisitor.__init__(self, design_unit)
         self._test = test
         assert test.is_explicit
-        self._enable_configuration = enable_configuration
+        self.enable_configuration = enable_configuration
         self._configs = OrderedDict({default_config.name: default_config})
 
     @property
@@ -334,7 +384,7 @@ class TestConfigurationVisitor(ConfigurationVisitor):
         return self._configs[DEFAULT_NAME]
 
     def _check_enabled(self):
-        if not self._enable_configuration:
+        if not self.enable_configuration:
             raise RuntimeError("Individual test configuration is not possible with run_all_in_same_sim")
 
     def get_configuration_dicts(self):  # pylint: disable=arguments-differ

vunit_hdl-5.0.0.dev3/vunit/vhdl/logging/run.py

@@ -0,0 +1,203 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this file,
+# You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+# Copyright (c) 2014-2024, Lars Asplund lars.anders.asplund@gmail.com
+
+from os import getenv
+import glob
+from pathlib import Path
+from vunit import VUnit, VUnitCLI, location_preprocessor
+from math import log10, floor, ceil
+from random import seed, randint, random
+
+
+def main():
+    vhdl_2019 = getenv("VUNIT_VHDL_STANDARD") == "2019"
+    root = Path(__file__).parent
+
+    cli = VUnitCLI()
+    cli.parser.add_argument(
+        "--performance-iterations",
+        type=int,
+        default=1,
+        help="Number of iterations to run in performance tests",
+    )
+    cli.parser.add_argument(
+        "--random-iterations",
+        type=int,
+        default=1,
+        help="Number of randomized tests",
+    )
+    args = cli.parse_args()
+    ui = VUnit.from_args(args=args)
+    ui.add_vhdl_builtins()
+
+    vunit_lib = ui.library("vunit_lib")
+    files = glob.glob(str(root / "test" / "*.vhd"))
+    files.remove(str(root / "test" / "tb_location.vhd"))
+    vunit_lib.add_source_files(files)
+
+    preprocessor = location_preprocessor.LocationPreprocessor()
+    preprocessor.add_subprogram("print_pre_vhdl_2019_style")
+    preprocessor.remove_subprogram("info")
+    vunit_lib.add_source_files(root / "test" / "tb_location.vhd", preprocessors=[preprocessor])
+
+    if vhdl_2019:
+        testbenches = vunit_lib.get_source_files("*tb*")
+        testbenches.set_compile_option("rivierapro.vcom_flags", ["-dbg"])
+        ui.set_sim_option("rivierapro.vsim_flags", ["-filter RUNTIME_0375"])
+
+    vunit_lib.test_bench("tb_location").set_generic("vhdl_2019", vhdl_2019)
+
+    tb = vunit_lib.test_bench("tb_sim_time_formatting")
+    tb.set_generic("n_performance_iterations", args.performance_iterations)
+
+    test_vectors = []
+    native_unit_scaling = 0
+    auto_unit_scaling = -1
+    full_resolution = -1
+
+    test_name = "Test native unit"
+    test_vectors.append([test_name, f"no_decimals", 123456, native_unit_scaling, 0])
+
+    test_name = "Test units of differents scales wrt the resolution_limit"
+    for scaling in [1, 1000, 1000000, 1000000000]:
+        test_vectors.append([test_name, f"scaling={scaling}", 123456, scaling, 0])
+
+    test_name = "Test auto unit"
+    test_vectors.append([test_name, "three_integer_digits", 456789, auto_unit_scaling, 0])
+    test_vectors.append([test_name, "two_integer_digits", 56789, auto_unit_scaling, 0])
+    test_vectors.append([test_name, "one_integer_digit", 6789, auto_unit_scaling, 0])
+
+    test_name = "Test limiting number of decimals"
+    for n_decimals in range(3):
+        for scaling in [1, 1000, 1000000]:
+            test_vectors.append([test_name, f"n_decimals={n_decimals}_scaling={scaling}", 456789, scaling, n_decimals])
+        test_vectors.append(
+            [test_name, f"n_decimals={n_decimals}_native_unit", 456789, native_unit_scaling, n_decimals]
+        )
+        test_vectors.append([test_name, f"n_decimals={n_decimals}_auto_unit", 456789, auto_unit_scaling, n_decimals])
+    test_vectors.append([test_name, f"no significant digits among decimals", 456789, 1000000000, 3])
+    test_vectors.append([test_name, f"some significant digits among decimals", 456789, 1000000000, 4])
+
+    test_name = "Test full resolution"
+    for scaling in [1, 1000, 1000000, 1000000000]:
+        test_vectors.append([test_name, f"scaling={scaling}", 123456, scaling, full_resolution])
+    test_vectors.append([test_name, f"native_unit", 123456, native_unit_scaling, full_resolution])
+    test_vectors.append([test_name, f"auto_unit", 123456, auto_unit_scaling, full_resolution])
+
+    test_name = "Test trailing zeros"
+    for n_zeros in range(-1, -7, -1):
+        test_time = round(123456, n_zeros)
+        test_vectors.append([test_name, f"n_zeros={-n_zeros}", test_time, 1000, 3])
+
+    test_name = "Test zero"
+    test_vectors.append([test_name, "auto_with_all_decimals", 0, auto_unit_scaling, full_resolution])
+    test_vectors.append([test_name, "scaling_with_fix_decimals", 0, 1000, 2])
+    test_vectors.append([test_name, "scaling_with_no_decimals", 0, 1000, 0])
+
+    def calculate_generics(test_time, scaling, n_decimals):
+        auto_scaling = (
+            1 if test_time == 0 else int(10 ** (floor(log10(test_time) / 3) * 3) if scaling == auto_unit_scaling else 1)
+        )
+        resolved_scaling = scaling if scaling > 0 else 1 if scaling == native_unit_scaling else auto_scaling
+
+        test_time_str = str(test_time)
+        n_decimals_to_use = int(log10(resolved_scaling))
+        if n_decimals_to_use >= len(test_time_str):
+            test_time_str = "0" * (n_decimals_to_use - len(test_time_str) + 1) + test_time_str
+
+        if (n_decimals_to_use == 0) and (n_decimals <= 0):
+            expected = test_time_str
+        elif (n_decimals_to_use == 0) and (n_decimals > 0):
+            expected = test_time_str + "." + "0" * n_decimals
+        elif n_decimals == 0:
+            expected = test_time_str[: len(test_time_str) - n_decimals_to_use]
+        elif (n_decimals < 0) or (n_decimals == n_decimals_to_use):
+            expected = (
+                test_time_str[: len(test_time_str) - n_decimals_to_use]
+                + "."
+                + test_time_str[len(test_time_str) - n_decimals_to_use :]
+            )
+        elif n_decimals < n_decimals_to_use:
+            expected = (
+                test_time_str[: len(test_time_str) - n_decimals_to_use]
+                + "."
+                + test_time_str[
+                    len(test_time_str) - n_decimals_to_use : len(test_time_str) - n_decimals_to_use + n_decimals
+                ]
+            )
+        else:
+            expected = (
+                test_time_str[: len(test_time_str) - n_decimals_to_use]
+                + "."
+                + test_time_str[len(test_time_str) - n_decimals_to_use :]
+                + "0" * (n_decimals - n_decimals_to_use)
+            )
+
+        return auto_scaling, expected
+
+    for test_name, cfg_name, test_time, scaling, n_decimals in test_vectors:
+        test = tb.test(test_name)
+        auto_scaling, expected = calculate_generics(test_time, scaling, n_decimals)
+
+        test.add_config(
+            name=cfg_name,
+            generics=dict(
+                test_time=test_time,
+                scaling=scaling,
+                n_decimals=n_decimals,
+                expected=expected,
+                auto_scaling=auto_scaling,
+            ),
+        )
+
+    test = tb.test("Test random")
+    seed("A seed")
+    cfg_names = set()
+    iter = 0
+    while iter < args.random_iterations:
+        rnd = randint(0, 24)
+        if rnd == 0:
+            test_time = 0
+        elif rnd == 1:
+            test_time = 1
+        elif rnd == 2:
+            test_time = 2**31 - 1
+        else:
+            test_time = randint(1, 10 ** randint(1, 9))
+
+        rnd = randint(0, 2)
+        if rnd == 0:
+            scaling = native_unit_scaling
+        elif rnd == 1:
+            scaling = auto_unit_scaling
+        else:
+            scaling = 10 ** (3 * randint(0, 3))
+
+        n_decimals = full_resolution if randint(0, 1) == 0 else randint(0, 15)
+
+        cfg_name = f"{test_time}_{scaling}_{n_decimals}"
+        if cfg_name in cfg_names:
+            continue
+
+        cfg_names.add(cfg_name)
+        iter += 1
+        auto_scaling, expected = calculate_generics(test_time, scaling, n_decimals)
+        test.add_config(
+            name=cfg_name,
+            generics=dict(
+                test_time=test_time,
+                scaling=scaling,
+                n_decimals=n_decimals,
+                expected=expected,
+                auto_scaling=auto_scaling,
+            ),
+        )
+
+    ui.main()
+
+
+if __name__ == "__main__":
+    main()