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

opencos/tests/test_eda.py

@@ -170,7 +170,7 @@ class TestsRequiresVerilator( # pylint: disable=too-many-public-methods
         assert res.stderr == b''
 
         res = subprocess.run(
-            [ './simulate_only.sh' ], stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+            [ './simulate.sh' ], stdout=subprocess.PIPE, stderr=subprocess.PIPE,
             check=True
         )
         rc = res.returncode
@@ -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

@@ -122,20 +122,12 @@ class CommandSimCocotb(CommandSim, ToolCocotb):
         util.safe_mkdirs(base=self.args['work-dir'], new_dirs=paths)
 
         # Write shell scripts
-        util.write_shell_command_file(
-            dirpath=self.args['work-dir'],
-            filename='cocotb_test.sh',
-            command_lists=self.cocotb_command_lists,
-            line_breaks=True
-        )
-
-        util.write_shell_command_file(
-            dirpath=self.args['work-dir'],
-            filename='all.sh',
-            command_lists=[
-                ['./pre_compile_dep_shell_commands.sh'],
-                ['./cocotb_test.sh'],
-            ]
+        self.write_sh_scripts_to_work_dir(
+            compile_lists=[],
+            elaborate_lists=[],
+            simulate_lists=self.cocotb_command_lists,
+            simulate_line_breaks=True,
+            simulate_sh_fname='cocotb_test.sh'
         )
 
     def _find_cocotb_test_files(self):
@@ -316,6 +308,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 +321,7 @@ def run_cocotb_test():
             defines=defines,
             parameters=parameters,
             build_dir="sim_build",
+            build_args=build_args,
         )
 
         # Run the test
@@ -398,6 +396,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)

opencos/tools/iverilog.py

@@ -84,32 +84,12 @@ class CommandSimIverilog(CommandSim, ToolIverilog):
 
         paths = ['logs']
         util.safe_mkdirs(base=self.args['work-dir'], new_dirs=paths)
-
-        util.write_shell_command_file(
-            dirpath=self.args['work-dir'],
-            filename='compile_only.sh',
-            command_lists=self.iverilog_command_lists,
-            line_breaks=True
-        )
-
-        util.write_shell_command_file(
-            dirpath=self.args['work-dir'],
-            filename='simulate_only.sh',
-            command_lists=self.iverilog_exec_command_lists
+        self.write_sh_scripts_to_work_dir(
+            compile_lists=self.iverilog_command_lists,
+            elaborate_lists=[],
+            simulate_lists=self.iverilog_exec_command_lists
         )
 
-        util.write_shell_command_file(
-            dirpath=self.args['work-dir'],
-            filename='all.sh',
-            command_lists = [
-                ['./pre_compile_dep_shell_commands.sh'],
-                ['./compile_only.sh'],
-                ['./simulate_only.sh'],
-            ]
-        )
-
-        self.write_eda_config_and_args()
-
     def compile(self):
         if self.args['stop-before-compile']:
             return