opencos-eda 0.2.52__py3-none-any.whl → 0.2.53__py3-none-any.whl

opencos/eda_config_defaults.yml

@@ -20,11 +20,33 @@ DEFAULT_HANDLERS:
   sweep       : opencos.commands.CommandSweep
   flist       : opencos.commands.CommandFList
   # These commands (waves, export, targets) do not require a tool, or
-  # will self determine the tool:
+  # will self determine the tool. See command_tool_is_optional in this config file.
   waves       : opencos.commands.CommandWaves
   export      : opencos.commands.CommandExport
   shell       : opencos.commands.CommandShell
   targets     : opencos.commands.CommandTargets
+  deps-help   : opencos.commands.CommandDepsHelp
+
+DEFAULT_HANDLERS_HELP:
+  sim:         Simulates a DEPS target.
+  elab:        Elaborates a DEPS target (lint, tool specific).
+  synth:       Synthesizes a DEPS target.
+  flist:       Create dependency from a DEPS target.
+  proj:        Create a project from a DEPS target for GUI sim/waves/debug.
+  multi:       Run multiple DEPS targets, serially or in parallel.
+  tools-multi: Same as 'multi' but run on all available tools, or specfied using --tools.
+  sweep:       Sweep one or more arguments across a range, serially or in parallel.
+  build:       Build for a board, creating a project and running build flow.
+  waves:       Opens waveform from prior simulation.
+  upload:      Uploads a finished design into hardware.
+  open:        Opens a project.
+  export:      Export files related to a target, tool independent.
+  shell:       Runs only commands for DEPS target (like sim or elab, but stops prior to tool).
+  targets:     List all possible targets given glob path.
+  lec:         Run equivalence on two designs.
+  deps-help:   Provide help about DEPS markup files, or schema using --verbose or --help.
+  help:        This help (without args), or i.e. "eda help sim" for specific help.
+
 
 
 defines: { } # Add these defines to every eda call
@@ -40,6 +62,7 @@ dep_command_enables:
 dep_tags_enables:
   with-tools:            true
   with-args:             true
+  with-commands:         true
   args:                  true
   replace-config-tools:  true
   additive-config-tools: true
@@ -83,6 +106,7 @@ command_tool_is_optional:
   - flist
   - export
   - targets
+  - deps-help
 
 
 tools:
@@ -234,6 +258,9 @@ tools:
       - 2555 # 2555 - assignment to input port myname
       - 2583 # 2583 - [SVCHK] - Extra checking for conflicts with always_comb and
              #        always_latch variables is done at vopt time.
+      - 13159 # 13159, 2685, 2718 are all related to module instance port default values.
+      - 2685
+      - 2718
     simulate-waivers:
       - 3009 # 3009: [TSCALE] - Module 'myname' does not have a timeunit/timeprecision
              #       specification in effect, but other modules do.
@@ -256,6 +283,9 @@ tools:
       - 2555 # 2555 - assignment to input port myname
       - 2583 # 2583 - [SVCHK] - Extra checking for conflicts with always_comb and
              #        always_latch variables is done at vopt time.
+      - 13159 # 13159, 2685, 2718 are all related to module instance port default values.
+      - 2685
+      - 2718
     simulate-waivers:
       - 3009 # 3009: [TSCALE] - Module 'myname' does not have a timeunit/timeprecision
              #       specification in effect, but other modules do.
@@ -295,6 +325,10 @@ tools:
       - "Cocotb test completed successfully!"
 
 
+  quartus:
+    defines:
+      OC_TOOL_QUARTUS: null
+
   vivado:
     sim-libraries:
       - xil_defaultlib
@@ -375,6 +409,16 @@ auto_tools_order:
       exe: gtkwave
       handlers: { }
 
+    quartus:
+      exe: quartus_sh
+      handlers:
+        synth: opencos.tools.quartus.CommandSynthQuartus
+        build: opencos.tools.quartus.CommandBuildQuartus
+        flist: opencos.tools.quartus.CommandFListQuartus
+        proj: opencos.tools.quartus.CommandProjQuartus
+        upload: opencos.tools.quartus.CommandUploadQuartus
+        open: opencos.tools.quartus.CommandOpenQuartus
+
     vivado:
       exe: vivado
       handlers:
@@ -425,8 +469,9 @@ auto_tools_order:
       exe: qrun
       requires_vsim_helper: True
       handlers:
-        elab: opencos.tools.queta.CommandElabQuesta
-        sim: opencos.tools.queta.CommandSimQuesta
+        elab: opencos.tools.questa.CommandElabQuesta
+        sim: opencos.tools.questa.CommandSimQuesta
+        flist: opencos.tools.questa.CommandFListQuesta
 
     riviera:
       exe: vsim
@@ -450,6 +495,7 @@ auto_tools_order:
       handlers:
         elab: opencos.tools.questa_fse.CommandElabQuestaFse
         sim:  opencos.tools.questa_fse.CommandSimQuestaFse
+        flist: opencos.tools.questa_fse.CommandFListQuestaFse
 
     iverilog:
       exe: iverilog

opencos/eda_extract_targets.py

@@ -10,68 +10,11 @@ import os
 from pathlib import Path
 
 from opencos.deps.deps_file import get_all_targets
+from opencos.utils.str_helpers import print_columns_manual
 
 PATH_LPREFIX = str(Path('.')) + os.path.sep
 
 
-def get_terminal_columns():
-    """
-    Retrieves the number of columns (width) of the terminal window.
-
-    Returns:
-        int: The number of columns in the terminal, or a default value (e.g., 80)
-             if the terminal size cannot be determined.
-    """
-    try:
-        size = os.get_terminal_size()
-        return size.columns
-    except OSError:
-        # Handle cases where the terminal size cannot be determined (e.g., not in a TTY)
-        return 80  # Default to 80 columns
-
-    return 80 # else default to 80.
-
-
-def print_columns_manual(data: list, num_columns: int = 4, auto_columns: bool = True) -> None:
-    """Prints a list of strings in columns, manually aligning them."""
-
-    if not data:
-        print()
-        return
-
-    _spacing = 2
-
-    # Calculate maximum width for each column
-    max_lengths = [0] * num_columns
-    max_item_len = 0
-    for i, item in enumerate(data):
-        col_index = i % num_columns
-        max_lengths[col_index] = max(max_lengths[col_index], len(item))
-        max_item_len = max(max_item_len, len(item))
-
-    if auto_columns and num_columns > 1:
-        window_cols = get_terminal_columns()
-        max_line_len = 0
-        for x in max_lengths:
-            max_line_len += x + _spacing
-        if max_line_len > window_cols:
-            # subtract a column (already >= 2):
-            print_columns_manual(data=data, num_columns=num_columns-1, auto_columns=True)
-            return
-        if max_line_len + max_item_len + _spacing < window_cols:
-            # add 1 more column if we're guaranteed to have room.
-            print_columns_manual(data=data, num_columns=num_columns+1, auto_columns=True)
-            return
-        # else continue
-
-    # Print data in columns
-    for i, item in enumerate(data):
-        col_index = i % num_columns
-        print(item.ljust(max_lengths[col_index] + _spacing), end="")  # Add padding
-        if col_index == num_columns - 1 or i == len(data) - 1:
-            print() # New line at the end of a row or end of data
-
-
 def get_path_and_pattern(partial_path: str = '', base_path=str(Path('.'))) -> (str, str):
     '''Returns tuple of (partial_path, partial_target or filter)'''
 

opencos/tests/helpers.py

@@ -12,6 +12,22 @@ from contextlib import redirect_stdout, redirect_stderr
 from opencos import eda
 from opencos import deps_schema
 from opencos.utils.markup_helpers import yaml_safe_load
+from opencos.utils import status_constants
+
+
+def eda_wrap_is_sim_fail(rc: int, quiet: bool = False) -> bool:
+    '''Because eda_wrap calls eda_main(..) and will continue running
+
+    after the first error, we may get a higher return code.'''
+    if not quiet:
+        print(f'eda_wrap_is_sim_fail({rc=})')
+    return rc in (
+        status_constants.EDA_COMMAND_MISSING_TOP,
+        status_constants.EDA_SIM_LOG_HAS_BAD_STRING,
+        status_constants.EDA_SIM_LOG_MISSING_MUST_STRING,
+        status_constants.EDA_EXEC_NONZERO_RETURN_CODE2,
+        status_constants.EDA_DEFAULT_ERROR
+    )
 
 def can_run_eda_command(*commands, config: dict) -> bool:
     '''Returns True if we have any installed tool that can run: eda <command>'''

opencos/tests/test_eda.py

@@ -589,9 +589,15 @@ class TestDepsResolveErrorMessages(Helpers):
         assert rc > 1
         assert self.is_in_log(
             "Trying to resolve command-line target=./nope_target0: was not",
-            "found in deps_file=./DEPS.yml, possible targets in deps file = ['foo'",
+            "found in deps_file=./DEPS.yml",
             windows_path_support=True
         )
+        assert self.is_in_log(
+            "Targets available in deps_file=./DEPS.yml:",
+            windows_path_support=True
+        )
+        assert self.is_in_log(" foo")
+
 
     def test_cmd_line_bad1(self):
         '''EDA calling a non-existent target in DEPS file, with file that exists.'''
@@ -600,9 +606,14 @@ class TestDepsResolveErrorMessages(Helpers):
         assert rc > 1
         assert self.is_in_log(
             "Trying to resolve command-line target=./nope_target1: was not",
-            "found in deps_file=./DEPS.yml, possible targets in deps file = ['foo'",
+            "found in deps_file=./DEPS.yml",
+            windows_path_support=True
+        )
+        assert self.is_in_log(
+            "Targets available in deps_file=./DEPS.yml:",
             windows_path_support=True
         )
+        assert self.is_in_log(" foo")
 
     def test_cmd_line_bad2(self):
         '''EDA calling a non-existent file w/out DEPS'''

opencos/tests/test_tools.py

@@ -12,8 +12,9 @@ from opencos.tools.verilator import ToolVerilator
 from opencos.tools.vivado import ToolVivado
 from opencos.tools.cocotb import ToolCocotb
 from opencos.tests import helpers
-from opencos.tests.helpers import eda_wrap
+from opencos.tests.helpers import eda_wrap, eda_wrap_is_sim_fail
 from opencos.utils.markup_helpers import yaml_safe_load
+from opencos.utils import status_constants
 
 
 thispath = os.path.dirname(__file__)
@@ -97,6 +98,11 @@ list_of_deps_targets = [
     ('tb_dollar_err', False),
 ]
 
+list_of_added_sim_args = [
+    '',
+    '--gui --test-mode',
+]
+
 cannot_use_cocotb = 'cocotb' not in tools_loaded or \
     ('iverilog' not in tools_loaded and \
      'verilator' not in tools_loaded)
@@ -105,24 +111,32 @@ CANNOT_USE_COCOTB_REASON = 'requires cocotb in tools_loaded, and one of (iverilo
 @pytest.mark.parametrize("command", list_of_commands)
 @pytest.mark.parametrize("tool", list_of_tools)
 @pytest.mark.parametrize("target,sim_expect_pass", list_of_deps_targets)
-def test_err_fatal(command, tool, target, sim_expect_pass):
-    '''tests that: eda <sim|elab> --tool <parameter-tool> <parameter-target>
+@pytest.mark.parametrize("added_sim_args_str", list_of_added_sim_args)
+def test_sim_elab_tools_pass_or_fail(command, tool, target, sim_expect_pass, added_sim_args_str):
+    '''tests that: eda <sim|elab> --tool <parameter-tool> <parameter-args> <parameter-target>
 
     will correctly pass or fail depending on if it is supported or not.
+
+    Also tests for: non-gui, or --gui --test-mode (runs non-gui, but most python args will
+    be for --gui mode, signal logging, etc).
     '''
     if tool not in tools_loaded:
         pytest.skip(f"{tool=} skipped, {tools_loaded=}")
         return # skip/pass
 
+    added_args = []
+    if command == 'sim':
+        added_args = added_sim_args_str.split()
+
     relative_dir = "deps_files/test_err_fatal"
     os.chdir(os.path.join(thispath, relative_dir))
-    rc = eda.main(command, '--tool', tool, target)
+    rc = eda.main(command, '--tool', tool, *(added_args), target)
     print(f'{rc=}')
     if command != 'sim' or sim_expect_pass:
         # command='elab' should pass.
         assert rc == 0
     else:
-        assert rc > 0
+        assert eda_wrap_is_sim_fail(rc)
 
 
 @pytest.mark.skipif('vivado' not in tools_loaded, reason="requires vivado")
@@ -176,175 +190,188 @@ def test_vivado_tool_defines():
     assert data['defines']['OC_LIBRARY_ULTRASCALE_PLUS'] is None # key present, no value
 
 
-@pytest.mark.skipif(cannot_use_cocotb, reason=CANNOT_USE_COCOTB_REASON)
-def test_cocotb_tool_defines():
-    '''Test cocotb tool defines, configs, and integration.'''
+class TestCocotb:
+    '''Namespace class for cocotb tests'''
 
-    chdir_remove_work_dir('../../examples/cocotb')
+    @pytest.mark.skipif(cannot_use_cocotb, reason=CANNOT_USE_COCOTB_REASON)
+    def test_cocotb_tool_defines(self):
+        '''Test cocotb tool defines, configs, and integration.'''
 
-    # Test 0: Using eda multi:
-    rc = eda_wrap('multi', 'sim', '--tool=cocotb', '*test')
-    assert rc == 0
+        chdir_remove_work_dir('../../examples/cocotb')
 
-    # Test 1: basic cocotb sim command with Python runner (default)
-    rc = eda_wrap('sim', '--tool', 'cocotb', 'cocotb_counter_test')
-    assert rc == 0
+        # Test 0: Using eda multi:
+        rc = eda_wrap('multi', 'sim', '--tool=cocotb', '*test')
+        assert rc == 0
 
-    # Test 2: cocotb works with different simulators/configurations
-    rc = eda_wrap('sim', '--tool', 'cocotb', 'cocotb_counter_waves_test')
-    assert rc == 0
+        # Test 1: basic cocotb sim command with Python runner (default)
+        rc = eda_wrap('sim', '--tool', 'cocotb', 'cocotb_counter_test')
+        assert rc == 0
 
-    # Test 3: Makefile approach
-    rc = eda_wrap('sim', '--tool', 'cocotb', 'cocotb_counter_makefile_test')
-    assert rc == 0
+        # Test 2: cocotb works with different simulators/configurations
+        rc = eda_wrap('sim', '--tool', 'cocotb', 'cocotb_counter_waves_test')
+        assert rc == 0
 
-    # Test 4: cocotb-specific defines are set correctly
-    eda_config_yml_path = os.path.join(
-        os.getcwd(), 'eda.work', 'cocotb_counter_test.sim', 'eda_output_config.yml'
-    )
+        # Test 3: Makefile approach
+        rc = eda_wrap('sim', '--tool', 'cocotb', 'cocotb_counter_makefile_test')
+        assert rc == 0
 
-    data = yaml_safe_load(eda_config_yml_path)
-    assert 'args' in data
-    assert data['args'].get('top', '') == 'counter'
-    assert 'config' in data
-    assert 'eda_original_args' in data['config']
-    assert 'cocotb_counter_test' in data['config']['eda_original_args'] or \
-        './cocotb_counter_test' in data['config']['eda_original_args']
-    assert data.get('target', '') == 'cocotb_counter_test'
+        # Test 4: cocotb-specific defines are set correctly
+        eda_config_yml_path = os.path.join(
+            os.getcwd(), 'eda.work', 'cocotb_counter_test.sim', 'eda_output_config.yml'
+        )
 
-    assert 'defines' in data
-    assert 'OC_TOOL_COCOTB' in data['defines']
-    assert 'SIMULATION' in data['defines']
-    assert 'COCOTB' in data['defines']
+        data = yaml_safe_load(eda_config_yml_path)
+        assert 'args' in data
+        assert data['args'].get('top', '') == 'counter'
+        assert 'config' in data
+        assert 'eda_original_args' in data['config']
+        assert 'cocotb_counter_test' in data['config']['eda_original_args'] or \
+            './cocotb_counter_test' in data['config']['eda_original_args']
+        assert data.get('target', '') == 'cocotb_counter_test'
 
-    assert data['defines']['SIMULATION'] == 1
-    assert data['defines']['COCOTB'] == 1
-    assert data['defines']['OC_TOOL_COCOTB'] is None  # key present, no value
+        assert 'defines' in data
+        assert 'OC_TOOL_COCOTB' in data['defines']
+        assert 'SIMULATION' in data['defines']
+        assert 'COCOTB' in data['defines']
 
-    assert 'VERILATOR' not in data['defines']
-    assert 'SYNTHESIS' not in data['defines']
+        assert data['defines']['SIMULATION'] == 1
+        assert data['defines']['COCOTB'] == 1
+        assert data['defines']['OC_TOOL_COCOTB'] is None  # key present, no value
 
+        assert 'VERILATOR' not in data['defines']
+        assert 'SYNTHESIS' not in data['defines']
 
 
-@pytest.mark.parametrize("cocotb_simulator", ['verilator', 'iverilog'])
-@pytest.mark.parametrize("waves_arg", ["", "--waves"])
-@pytest.mark.skipif(cannot_use_cocotb, reason=CANNOT_USE_COCOTB_REASON)
-def test_cocotb_different_simulators(cocotb_simulator, waves_arg):
-    '''Test cocotb with different simulator configurations.'''
 
-    if cocotb_simulator not in tools_loaded:
-        pytest.skip(f"{cocotb_simulator=} skipped, {tools_loaded=}")
-        return #skip/bypass
+    @pytest.mark.parametrize("cocotb_simulator", ['verilator', 'iverilog'])
+    @pytest.mark.parametrize("waves_arg", ["", "--waves"])
+    @pytest.mark.skipif(cannot_use_cocotb, reason=CANNOT_USE_COCOTB_REASON)
+    def test_cocotb_different_simulators(self, cocotb_simulator, waves_arg):
+        '''Test cocotb with different simulator configurations.'''
 
-    chdir_remove_work_dir('../../examples/cocotb')
+        if cocotb_simulator not in tools_loaded:
+            pytest.skip(f"{cocotb_simulator=} skipped, {tools_loaded=}")
+            return #skip/bypass
 
-    rc = eda_wrap(
-        'sim', '--tool', 'cocotb',
-        f'--cocotb-simulator={cocotb_simulator}',
-        waves_arg,
-        'cocotb_counter_test',
-    )
-    assert rc == 0
+        chdir_remove_work_dir('../../examples/cocotb')
 
+        rc = eda_wrap(
+            'sim', '--tool', 'cocotb',
+            f'--cocotb-simulator={cocotb_simulator}',
+            waves_arg,
+            'cocotb_counter_test',
+        )
+        assert rc == 0
 
 
-@pytest.mark.skipif(cannot_use_cocotb, reason=CANNOT_USE_COCOTB_REASON)
-def test_cocotb_tool_instantiation():
-    '''Test that ToolCocotb can be instantiated and has correct properties.'''
 
-    tool = ToolCocotb(config={})
+    @pytest.mark.skipif(cannot_use_cocotb, reason=CANNOT_USE_COCOTB_REASON)
+    def test_cocotb_tool_instantiation(self):
+        '''Test that ToolCocotb can be instantiated and has correct properties.'''
 
-    # version detection works
-    version = tool.get_versions()
-    assert version, "Should return a non-empty version string"
-    assert isinstance(version, str)
+        tool = ToolCocotb(config={})
 
-    # tool defines
-    tool.set_tool_defines()
-    defines = tool.defines
-    assert 'SIMULATION' in defines
-    assert 'COCOTB' in defines
-    assert 'OC_TOOL_COCOTB' in defines
-    assert defines['SIMULATION'] == 1
-    assert defines['COCOTB'] == 1
+        # version detection works
+        version = tool.get_versions()
+        assert version, "Should return a non-empty version string"
+        assert isinstance(version, str)
 
+        # tool defines
+        tool.set_tool_defines()
+        defines = tool.defines
+        assert 'SIMULATION' in defines
+        assert 'COCOTB' in defines
+        assert 'OC_TOOL_COCOTB' in defines
+        assert defines['SIMULATION'] == 1
+        assert defines['COCOTB'] == 1
 
 
-@pytest.mark.skipif(cannot_use_cocotb, reason=CANNOT_USE_COCOTB_REASON)
-def test_cocotb_failure_cases():
-    '''Test cocotb failure scenarios to ensure proper error handling.'''
 
-    chdir_remove_work_dir('../../examples/cocotb')
+    @pytest.mark.skipif(cannot_use_cocotb, reason=CANNOT_USE_COCOTB_REASON)
+    def test_cocotb_failure_cases(self):
+        '''Test cocotb failure scenarios to ensure proper error handling.'''
 
-    # Test 1: missing test files should fail gracefully
-    rc = eda_wrap('sim', '--tool', 'cocotb', 'counter')  # Just HDL, no test files
-    assert rc > 1, "Should fail when no cocotb test files are found"
+        chdir_remove_work_dir('../../examples/cocotb')
 
-    # Test 2: non-existent target should fail
-    rc = eda_wrap('sim', '--tool', 'cocotb', 'nonexistent_target')
-    assert rc > 1, "Should fail for non-existent target"
+        # Test 1: missing test files should fail gracefully
+        rc = eda_wrap('sim', '--tool', 'cocotb', 'counter')  # Just HDL, no test files
+        assert rc == status_constants.EDA_DEPS_TARGET_NOT_FOUND, \
+            "Should fail when no cocotb test files are found"
 
-    # Test 3: invalid cocotb test module should fail
-    rc = eda_wrap(
-        'sim', '--tool', 'cocotb',
-        '--cocotb-test-module=nonexistent_test',
-        'cocotb_counter_test',
-    )
-    assert rc > 1, "Should fail with invalid test module"
+        # Test 2: non-existent target should fail
+        rc = eda_wrap('sim', '--tool', 'cocotb', 'nonexistent_target')
+        assert rc in (
+            status_constants.EDA_DEPS_TARGET_NOT_FOUND,
+            # b/c we run eda_wrap, eda.main will continue to run after first error.
+            status_constants.EDA_COMMAND_MISSING_TOP
+        ), "Should fail for non-existent target"
 
+        # Test 3: invalid cocotb test module should fail
+        rc = eda_wrap(
+            'sim', '--tool', 'cocotb',
+            '--cocotb-test-module=nonexistent_test',
+            'cocotb_counter_test',
+        )
+        assert eda_wrap_is_sim_fail(rc), \
+            f"Should fail with invalid test module {rc=}"
 
-@pytest.mark.skipif(cannot_use_cocotb, reason=CANNOT_USE_COCOTB_REASON)
-def test_cocotb_missing_dependencies():
-    '''Test cocotb behavior when dependencies are missing.'''
 
-    # Test missing cocotb installation (simulate by checking error handling)
-    tool = ToolCocotb(config={})
-    version = tool.get_versions()
-    assert version, "Should return version when cocotb is properly installed"
+    @pytest.mark.skipif(cannot_use_cocotb, reason=CANNOT_USE_COCOTB_REASON)
+    def test_cocotb_missing_dependencies(self):
+        '''Test cocotb behavior when dependencies are missing.'''
 
-    # Test tool defines are properly set even with minimal config
-    tool.set_tool_defines()
-    defines = tool.defines
-    assert 'SIMULATION' in defines
-    assert 'COCOTB' in defines
-    assert 'OC_TOOL_COCOTB' in defines
+        # Test missing cocotb installation (simulate by checking error handling)
+        tool = ToolCocotb(config={})
+        version = tool.get_versions()
+        assert version, "Should return version when cocotb is properly installed"
 
+        # Test tool defines are properly set even with minimal config
+        tool.set_tool_defines()
+        defines = tool.defines
+        assert 'SIMULATION' in defines
+        assert 'COCOTB' in defines
+        assert 'OC_TOOL_COCOTB' in defines
 
-@pytest.mark.skipif(cannot_use_cocotb, reason=CANNOT_USE_COCOTB_REASON)
-def test_cocotb_invalid_simulator():
-    '''Test cocotb with invalid simulator configuration.'''
 
-    chdir_remove_work_dir('../../examples/cocotb')
+    @pytest.mark.skipif(cannot_use_cocotb, reason=CANNOT_USE_COCOTB_REASON)
+    def test_cocotb_invalid_simulator(self):
+        '''Test cocotb with invalid simulator configuration.'''
 
-    rc = eda_wrap(
-        'sim', '--tool', 'cocotb',
-        '--cocotb-simulator=invalid_sim',
-        'cocotb_counter_test',
-    )
-    assert rc > 1, "Should fail with invalid simulator"
+        chdir_remove_work_dir('../../examples/cocotb')
 
-@pytest.mark.skipif(cannot_use_cocotb, reason=CANNOT_USE_COCOTB_REASON)
-def test_cocotb_malformed_hdl():
-    '''Test cocotb with malformed HDL files.'''
+        rc = eda_wrap(
+            'sim', '--tool', 'cocotb',
+            '--cocotb-simulator=invalid_sim',
+            'cocotb_counter_test',
+        )
+        assert eda_wrap_is_sim_fail(rc), \
+            f"Should fail with invalid simulator {rc=}"
 
-    chdir_remove_work_dir('../../lib/tests')
+    @pytest.mark.skipif(cannot_use_cocotb, reason=CANNOT_USE_COCOTB_REASON)
+    def test_cocotb_malformed_hdl(self):
+        '''Test cocotb with malformed HDL files.'''
 
-    # Test with a target that has syntax errors - should fail during compilation
-    rc = eda_wrap(
-        'sim', '--tool', 'cocotb',
-        '--cocotb-test-module=test_counter',
-        'tb_dollar_fatal',
-    )
+        chdir_remove_work_dir('../../lib/tests')
 
-    assert rc > 1, "Should fail with malformed HDL or failing test assertions"
+        # Test with a target that has syntax errors - should fail during compilation
+        rc = eda_wrap(
+            'sim', '--tool', 'cocotb',
+            '--cocotb-test-module=test_counter',
+            'tb_dollar_fatal',
+        )
 
+        # eda_wrap may continue to errors beyond normal sim fails:
+        assert eda_wrap_is_sim_fail(rc) or \
+            f"Should fail with malformed HDL or failing test assertions {rc=}"
 
-@pytest.mark.skipif(cannot_use_cocotb, reason=CANNOT_USE_COCOTB_REASON)
-def test_cocotb_test_failures():
-    '''Test that cocotb properly reports test failures.'''
 
-    chdir_remove_work_dir('../../examples/cocotb')
+    @pytest.mark.skipif(cannot_use_cocotb, reason=CANNOT_USE_COCOTB_REASON)
+    def test_cocotb_test_failures(self):
+        '''Test that cocotb properly reports test failures.'''
 
-    # Intentionally failing cocotb tests
-    rc = eda_wrap('sim', '--tool', 'cocotb', 'cocotb_failure_test')
-    assert rc > 1, "Should fail when cocotb tests contain assertion failures"
+        chdir_remove_work_dir('../../examples/cocotb')
+
+        # Intentionally failing cocotb tests
+        rc = eda_wrap('sim', '--tool', 'cocotb', 'cocotb_failure_test')
+        assert eda_wrap_is_sim_fail(rc), \
+            f"Should fail when cocotb tests contain assertion failures {rc=}"

opencos/tools/cocotb.py

@@ -316,6 +316,11 @@ def run_cocotb_test():
         # Get the runner for the specified simulator
         runner = get_runner(simulator)
 
+        build_args = []
+        
+        if simulator == "verilator":
+            build_args.extend({list(self.args.get('verilate-args', []))!r})
+
         # Build the design
         runner.build(
             sources=sources,
@@ -324,6 +329,7 @@ def run_cocotb_test():
             defines=defines,
             parameters=parameters,
             build_dir="sim_build",
+            build_args=build_args,
         )
 
         # Run the test
@@ -398,6 +404,9 @@ MODULE = {test_module}
                     define_args.append(f'-D{k}={sanitize_defines_for_sh(v)}')
             makefile_content += 'COMPILE_ARGS += ' + ' '.join(define_args) + '\n'
 
+        if self.args['cocotb-simulator'] == 'verilator' and self.args.get('verilate-args'):
+            makefile_content += 'COMPILE_ARGS += ' + ' '.join(self.args['verilate-args']) + '\n'
+
         makefile_content += '''
 # Waves support
 ifeq ($(WAVES),1)