def add_compile_option(self, name, value): """ Add compile option """ SIMULATOR_FACTORY.check_compile_option(name, value) if name not in self._compile_options: self._compile_options[name] = copy(value) else: self._compile_options[name] += value
def get_compile_option(self, name): """ Return a copy of the compile option list """ SIMULATOR_FACTORY.check_compile_option_name(name) if name not in self._compile_options: self._compile_options[name] = [] return copy(self._compile_options[name])
def __init__( self, args, compile_builtins: Optional[bool] = True, vhdl_standard: Optional[str] = None, ): self._args = args self._configure_logging(args.log_level) self._output_path = str(Path(args.output_path).resolve()) if args.no_color: self._printer = NO_COLOR_PRINTER else: self._printer = COLOR_PRINTER def test_filter(name, attribute_names): keep = any(fnmatch(name, pattern) for pattern in args.test_patterns) if args.with_attributes is not None: keep = keep and set(args.with_attributes).issubset(attribute_names) if args.without_attributes is not None: keep = keep and set(args.without_attributes).isdisjoint(attribute_names) return keep self._test_filter = test_filter self._vhdl_standard: VHDLStandard = select_vhdl_standard(vhdl_standard) self._external_preprocessors = [] # type: ignore self._location_preprocessor = None self._check_preprocessor = None self._simulator_class = SIMULATOR_FACTORY.select_simulator() # Use default simulator options if no simulator was present if self._simulator_class is None: simulator_class = SimulatorInterface self._simulator_output_path = str(Path(self._output_path) / "none") else: simulator_class = self._simulator_class self._simulator_output_path = str( Path(self._output_path) / simulator_class.name ) self._create_output_path(args.clean) database = self._create_database() self._project = VCSTProject( database=database, depend_on_package_body=simulator_class.package_users_depend_on_bodies, ) self._test_bench_list = TestBenchList(database=database) self._builtins = Builtins(self, self._vhdl_standard, simulator_class) if compile_builtins: self.add_builtins()
def compile_standard_libraries(vunit_obj, output_path): """ Compile Xilinx standard libraries using Vivado TCL command """ done_token = join(output_path, "all_done.txt") simulator_class = SIMULATOR_FACTORY.select_simulator() if not exists(done_token): print("Compiling standard libraries into %s ..." % abspath(output_path)) simname = simulator_class.name # Vivado calls rivierapro for riviera if simname == "rivierapro": simname = "riviera" run_vivado( join(dirname(__file__), "tcl", "compile_standard_libs.tcl"), tcl_args=[ simname, simulator_class.find_prefix().replace("\\", "/"), output_path, ], ) else: print("Standard libraries already exists in %s, skipping" % abspath(output_path)) for library_name in ["unisim", "unimacro", "unifast", "secureip", "xpm"]: path = join(output_path, library_name) if exists(path): vunit_obj.add_external_library(library_name, path) with open(done_token, "w") as fptr: fptr.write("done")
def set_sim_option(self, name, value): """ Set sim option """ SIMULATOR_FACTORY.check_sim_option(name, value) self.sim_options[name] = copy(value)
# -*- coding: utf-8 -*- from os.path import join, dirname, abspath import subprocess from vunit.sim_if.ghdl import GHDLInterface from vunit.sim_if.factory import SIMULATOR_FACTORY from vunit import VUnit, VUnitCLI ################################################################################ ################################################################################ #Check simulator. print("=============================================") simname = SIMULATOR_FACTORY.select_simulator().name code_coverage = (simname == "ghdl" and \ (GHDLInterface.determine_backend("")=="gcc" or \ GHDLInterface.determine_backend("")=="GCC")) print("Simulator = " + simname) print("=============================================") ################################################################################ #VUnit instance. ui = VUnit.from_argv() #Add module sources. test_1_src_lib = ui.add_library("src_lib") test_1_src_lib.add_source_files("exampleRunpy_1.vhd") #Add tb sources. test_1_tb_lib = ui.add_library("tb_lib") test_1_tb_lib.add_source_files("tbVhdlVunitRunpy.vhd")
############################################################################## ############################################################################## #Check GHDL backend. code_coverage=False try: if( GHDLInterface.determine_backend("")=="gcc" or GHDLInterface.determine_backend("")=="GCC"): code_coverage=True else: code_coverage=False except: print("") #Check simulator. print ("=============================================") simulator_class = SIMULATOR_FACTORY.select_simulator() simname = simulator_class.name print (simname) if (simname == "modelsim"): f= open("modelsim.do","w+") f.write("add wave * \nlog -r /*\nvcd file\nvcd add -r /*\n") f.close() print ("=============================================") ############################################################################## ############################################################################## ############################################################################## #Add custom command line argument to standard CLI #Beware of conflicts with existing arguments cli = VUnitCLI()
def set_compile_option(self, name, value): """ Set compile option """ SIMULATOR_FACTORY.check_compile_option(name, value) self._compile_options[name] = copy(value)
def _create_argument_parser(description=None, for_documentation=False): """ Create the argument parser :param description: A custom short description of the command line tool :param for_documentation: When used for user guide documentation :returns: The created :mod:`argparse` parser object """ if description is None: description = "VUnit command line tool version %s" % version() if for_documentation: default_output_path = "./vunit_out" else: default_output_path = str(Path(os.getcwd()).resolve() / "vunit_out") parser = argparse.ArgumentParser(description=description) parser.add_argument( "test_patterns", metavar="tests", nargs="*", default="*", help="Tests to run" ) parser.add_argument( "--with-attributes", default=None, action="append", help="Only select tests with these attributes set", ) parser.add_argument( "--without-attributes", default=None, action="append", help="Only select tests without these attributes set", ) parser.add_argument( "-l", "--list", action="store_true", default=False, help="Only list all test cases", ) parser.add_argument( "-f", "--files", action="store_true", default=False, help="Only list all files in compile order", ) parser.add_argument( "--compile", action="store_true", default=False, help="Only compile project without running tests", ) parser.add_argument( "-m", "--minimal", action="store_true", default=False, help="Only compile files required for the (filtered) test benches", ) parser.add_argument( "-k", "--keep-compiling", action="store_true", default=False, help="Continue compiling even after errors only skipping files that depend on failed files", ) parser.add_argument( "--fail-fast", action="store_true", default=False, help="Stop immediately on first failing test", ) parser.add_argument( "--elaborate", action="store_true", default=False, help="Only elaborate test benches without running", ) parser.add_argument( "--clean", action="store_true", default=False, help="Remove output path first" ) parser.add_argument( "-o", "--output-path", default=default_output_path, help="Output path for compilation and simulation artifacts", ) parser.add_argument( "-x", "--xunit-xml", default=None, help="Xunit test report .xml file" ) parser.add_argument( "--xunit-xml-format", choices=["jenkins", "bamboo"], default="jenkins", help=( "Only valid with --xunit-xml argument. " "Defines where in the XML file the simulator output is stored on a failure. " '"jenkins" = Output stored in <system-out>, ' '"bamboo" = Output stored in <failure>.' ), ) parser.add_argument( "--exit-0", default=False, action="store_true", help=( "Exit with code 0 even if a test failed. " "Still exits with code 1 on fatal errors such as compilation failure" ), ) parser.add_argument( "--dont-catch-exceptions", default=False, action="store_true", help=( "Let exceptions bubble up all the way. " 'Useful when running with "python -m pdb".' ), ) parser.add_argument( "-v", "--verbose", action="store_true", default=False, help="Print test output immediately and not only when failure", ) parser.add_argument( "-q", "--quiet", action="store_true", default=False, help="Do not print test output even in the case of failure", ) parser.add_argument( "--no-color", action="store_true", default=False, help="Do not color output" ) parser.add_argument( "--log-level", default="warning", choices=["info", "error", "warning", "debug"], help=("Log level of VUnit internal python logging. " "Used for debugging"), ) parser.add_argument( "-p", "--num-threads", type=positive_int, default=1, help=( "Number of tests to run in parallel. " "Test output is not continuously written in verbose mode with p > 1" ), ) parser.add_argument( "-u", "--unique-sim", action="store_true", default=False, help="Do not re-use the same simulator process for running different test cases (slower)", ) parser.add_argument( "--export-json", default=None, help="Export project information to a JSON file." ) parser.add_argument("--version", action="version", version=version()) SIMULATOR_FACTORY.add_arguments(parser) return parser
from os.path import join, dirname from vunit import VUnit, VUnitCLI from vunit.sim_if.factory import SIMULATOR_FACTORY from run_support import run_with_compile_errors root = dirname(__file__) vhdl_standard = ("2019" if SIMULATOR_FACTORY.select_simulator().name == "rivierapro" else "2008") args = VUnitCLI().parse_args() # keep_going is a planned VUnit feature which adds support for dealing with testbenches # that don't compile if "keep_going" in args: args.keep_going = True ui = VUnit.from_args(args, vhdl_standard=vhdl_standard) vhdl_2008 = ui.add_library("vhdl_2008") vhdl_2019 = ui.add_library("vhdl_2019") vhdl_2008.add_source_files(join(root, "vhdl_2008", "*.vhd")) vhdl_2019.add_source_files(join(root, "vhdl_2019", "*.vhd")) if "keep_going" in args: ui.main() else: # Workaround while keep_going isn't supported run_with_compile_errors(ui, args, vhdl_standard)
from functools import reduce from vunit.test.report import TestReport, PASSED, FAILED from vunit import ostools ROOT = Path(__file__).resolve().parent def vunit_from_args(args, vhdl_standard): ui = VUnit.from_args(args, vhdl_standard=vhdl_standard) for std in ["2008", "2019"]: lib = f"vhdl_{std}" ui.add_library(lib).add_source_files(ROOT / lib / "*.vhd") return ui vhdl_standard = "2019" if SIMULATOR_FACTORY.select_simulator( ).name == "rivierapro" else "2008" args = VUnitCLI().parse_args() ui = vunit_from_args(args, vhdl_standard) # Run all tests in isolation to handle failure to compile args.minimal = True original_test_patterns = args.test_patterns test_report = TestReport() n_tests = 0 total_start_time = ostools.get_time() for tb in (ui.library("vhdl_2008").get_test_benches() + ui.library("vhdl_2019").get_test_benches()): tests = tb.get_tests() for test_name in [test.name for test in tests] if tests else ["all"]: full_test_name = f"{tb.library.name!s}.{tb.name!s}.{test_name!s}" if not reduce(