Add comprehensive test suite for improved code coverage

- Added tests for core modules (__init__, cli, config, errors)
- Added tests for silicon platform components (SiliconPlatformPort, buffers, Heartbeat)
- Added tests for platform utilities (schema utils, package definitions, PortMap)
- Added basic tests for SimPlatform
- Improved overall test coverage significantly

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: robtaylor

chipflow_lib/steps/silicon.py

@@ -149,9 +149,10 @@ def submit(self, rtlil_path, *, dry_run=False):
                 logger.debug(f"padname={padname}, port={port}, loc={port.pins[0]}, "
                              f"dir={port.direction}, width={width}")
                 pads[padname] = {'loc': port.pins[0], 'type': port.direction.value}
- 
+
         # Use the Pydantic models to access configuration data
         silicon_model = self.config_model.chipflow.silicon
+        
         config = {
             "dependency_versions": dep_versions,
             "silicon": {

docs/chipflow-toml-guide.rst

@@ -11,7 +11,7 @@ Let's start with a typical example:
 .. testcode::
    :hide:
 
-   # Assert that example-chipflow.toml matches the current config schema. If 
+   # Assert that example-chipflow.toml matches the current config schema. If
    # this test fails, then its likely that the content in this file will need
    # to be updated.
    from chipflow_lib import _parse_config_file
@@ -108,7 +108,7 @@ Available pad rings
 silicon.pads
 ============
 
-The ``silicon.pads`` section lists special pads. In general you are unlikely to need to add to this. 
+The ``silicon.pads`` section lists special pads. In general you are unlikely to need to add to this.
 
 For each pad, there's a label which is used by our design, and what ``type`` and ``loc`` each pad should be.
 

tests/fixtures/mock_top.py

@@ -43,5 +43,5 @@ def elaborate(self, platform):
         m = Module()
         for inpin, outpin in zip(self.test1.members, self.test2.members):
             m.d.comb += inpin.eq(outpin)
- 
+
         return m

tests/test_buffers.py

@@ -14,49 +14,47 @@ class TestBuffers(unittest.TestCase):
     def test_io_buffer_mocked(self, mock_ffbuffer, mock_iobuffer):
         """Test that IOBuffer can be imported and mocked"""
         from chipflow_lib.platforms.silicon import IOBuffer
-        
+
         # Verify that the mock is working
         self.assertEqual(IOBuffer, mock_iobuffer)
-        
+
         # Create a mock port
         port = mock.Mock()
         port.invert = False
-        
+
         # Create a mock for the IOBuffer elaborate method
         module = Module()
         mock_iobuffer.return_value.elaborate.return_value = module
-        
+
         # Create an IOBuffer instance
         buffer = IOBuffer(io.Direction.Input, port)
-        
+
         # Elaborate the buffer
         result = buffer.elaborate(None)
-        
         # Verify the result
         self.assertEqual(result, module)
         mock_iobuffer.return_value.elaborate.assert_called_once()
 
     def test_ff_buffer_mocked(self, mock_ffbuffer, mock_iobuffer):
         """Test that FFBuffer can be imported and mocked"""
         from chipflow_lib.platforms.silicon import FFBuffer
-        
+
         # Verify that the mock is working
         self.assertEqual(FFBuffer, mock_ffbuffer)
-        
+
         # Create a mock port
         port = mock.Mock()
         port.invert = False
-        
+
         # Create a mock for the FFBuffer elaborate method
         module = Module()
         mock_ffbuffer.return_value.elaborate.return_value = module
-        
+
         # Create an FFBuffer instance
         buffer = FFBuffer(io.Direction.Input, port, i_domain="sync", o_domain="sync")
-        
+
         # Elaborate the buffer
         result = buffer.elaborate(None)
-        
         # Verify the result
         self.assertEqual(result, module)
         mock_ffbuffer.return_value.elaborate.assert_called_once()

tests/test_cli.py

@@ -15,7 +15,11 @@ class MockCommand:
     def build_cli_parser(self, parser):
         parser.add_argument("--option", help="Test option")
         parser.add_argument("action", choices=["valid", "error", "unexpected"])
+<<<<<<< HEAD
 
+=======
+
+>>>>>>> bd941c3 (Add comprehensive test suite for improved code coverage)
     def run_cli(self, args):
         if args.action == "error":
             raise ChipFlowError("Command error")
@@ -39,18 +43,32 @@ def test_run_success(self, mock_get_cls, mock_pin_command, mock_parse_config):
             }
         }
         mock_parse_config.return_value = mock_config
+<<<<<<< HEAD
 
         mock_pin_cmd = MockCommand()
         mock_pin_command.return_value = mock_pin_cmd
 
         mock_test_cmd = MockCommand()
         mock_get_cls.return_value = lambda config: mock_test_cmd
 
+=======
+
+        mock_pin_cmd = MockCommand()
+        mock_pin_command.return_value = mock_pin_cmd
+
+        mock_test_cmd = MockCommand()
+        mock_get_cls.return_value = lambda config: mock_test_cmd
+
+>>>>>>> bd941c3 (Add comprehensive test suite for improved code coverage)
         # Capture stdout for assertion
         with mock.patch("sys.stdout") as mock_stdout:
             # Run with valid action
             run(["test", "valid"])
+<<<<<<< HEAD
 
+=======
+
+>>>>>>> bd941c3 (Add comprehensive test suite for improved code coverage)
             # No error message should be printed
             mock_stdout.write.assert_not_called()
 
@@ -68,18 +86,32 @@ def test_run_command_error(self, mock_get_cls, mock_pin_command, mock_parse_conf
             }
         }
         mock_parse_config.return_value = mock_config
+<<<<<<< HEAD
 
         mock_pin_cmd = MockCommand()
         mock_pin_command.return_value = mock_pin_cmd
 
         mock_test_cmd = MockCommand()
         mock_get_cls.return_value = lambda config: mock_test_cmd
 
+=======
+
+        mock_pin_cmd = MockCommand()
+        mock_pin_command.return_value = mock_pin_cmd
+
+        mock_test_cmd = MockCommand()
+        mock_get_cls.return_value = lambda config: mock_test_cmd
+
+>>>>>>> bd941c3 (Add comprehensive test suite for improved code coverage)
         # Capture stdout for assertion
         with mock.patch("builtins.print") as mock_print:
             # Run with error action
             run(["test", "error"])
+<<<<<<< HEAD
 
+=======
+
+>>>>>>> bd941c3 (Add comprehensive test suite for improved code coverage)
             # Error message should be printed
             mock_print.assert_called_once()
             self.assertIn("Error while executing `test error`", mock_print.call_args[0][0])
@@ -98,18 +130,32 @@ def test_run_unexpected_error(self, mock_get_cls, mock_pin_command, mock_parse_c
             }
         }
         mock_parse_config.return_value = mock_config
+<<<<<<< HEAD
 
         mock_pin_cmd = MockCommand()
         mock_pin_command.return_value = mock_pin_cmd
 
         mock_test_cmd = MockCommand()
         mock_get_cls.return_value = lambda config: mock_test_cmd
 
+=======
+
+        mock_pin_cmd = MockCommand()
+        mock_pin_command.return_value = mock_pin_cmd
+
+        mock_test_cmd = MockCommand()
+        mock_get_cls.return_value = lambda config: mock_test_cmd
+
+>>>>>>> bd941c3 (Add comprehensive test suite for improved code coverage)
         # Capture stdout for assertion
         with mock.patch("builtins.print") as mock_print:
             # Run with unexpected error action
             run(["test", "unexpected"])
+<<<<<<< HEAD
 
+=======
+
+>>>>>>> bd941c3 (Add comprehensive test suite for improved code coverage)
             # Error message should be printed
             mock_print.assert_called_once()
             self.assertIn("Error while executing `test unexpected`", mock_print.call_args[0][0])
@@ -128,6 +174,7 @@ def test_step_init_error(self, mock_pin_command, mock_parse_config):
             }
         }
         mock_parse_config.return_value = mock_config
+<<<<<<< HEAD
 
         mock_pin_cmd = MockCommand()
         mock_pin_command.return_value = mock_pin_cmd
@@ -139,6 +186,19 @@ def test_step_init_error(self, mock_pin_command, mock_parse_config):
             with self.assertRaises(ChipFlowError) as cm:
                 run(["test", "valid"])
 
+=======
+
+        mock_pin_cmd = MockCommand()
+        mock_pin_command.return_value = mock_pin_cmd
+
+        # Make _get_cls_by_reference raise an exception during step initialization
+        with mock.patch("chipflow_lib.cli._get_cls_by_reference") as mock_get_cls:
+            mock_get_cls.return_value = mock.Mock(side_effect=Exception("Init error"))
+
+            with self.assertRaises(ChipFlowError) as cm:
+                run(["test", "valid"])
+
+>>>>>>> bd941c3 (Add comprehensive test suite for improved code coverage)
             self.assertIn("Encountered error while initializing step", str(cm.exception))
 
     @mock.patch("chipflow_lib.cli._parse_config")
@@ -155,11 +215,16 @@ def test_build_parser_error(self, mock_get_cls, mock_pin_command, mock_parse_con
             }
         }
         mock_parse_config.return_value = mock_config
+<<<<<<< HEAD
 
+=======
+
+>>>>>>> bd941c3 (Add comprehensive test suite for improved code coverage)
         # Make pin command raise an error during build_cli_parser
         mock_pin_cmd = mock.Mock()
         mock_pin_cmd.build_cli_parser.side_effect = Exception("Parser error")
         mock_pin_command.return_value = mock_pin_cmd
+<<<<<<< HEAD
 
         mock_test_cmd = mock.Mock()
         mock_test_cmd.build_cli_parser.side_effect = Exception("Parser error")
@@ -168,6 +233,16 @@ def test_build_parser_error(self, mock_get_cls, mock_pin_command, mock_parse_con
         with self.assertRaises(ChipFlowError) as cm:
             run(["pin", "lock"])
 
+=======
+
+        mock_test_cmd = mock.Mock()
+        mock_test_cmd.build_cli_parser.side_effect = Exception("Parser error")
+        mock_get_cls.return_value = lambda config: mock_test_cmd
+
+        with self.assertRaises(ChipFlowError) as cm:
+            run(["pin", "lock"])
+
+>>>>>>> bd941c3 (Add comprehensive test suite for improved code coverage)
         self.assertIn("Encountered error while building CLI argument parser", str(cm.exception))
 
     @mock.patch("chipflow_lib.cli._parse_config")
@@ -184,6 +259,7 @@ def test_verbosity_flags(self, mock_get_cls, mock_pin_command, mock_parse_config
             }
         }
         mock_parse_config.return_value = mock_config
+<<<<<<< HEAD
 
         mock_pin_cmd = MockCommand()
         mock_pin_command.return_value = mock_pin_cmd
@@ -194,15 +270,34 @@ def test_verbosity_flags(self, mock_get_cls, mock_pin_command, mock_parse_config
         # Save original log level
         original_level = logging.getLogger().level
 
+=======
+
+        mock_pin_cmd = MockCommand()
+        mock_pin_command.return_value = mock_pin_cmd
+
+        mock_test_cmd = MockCommand()
+        mock_get_cls.return_value = lambda config: mock_test_cmd
+
+        # Save original log level
+        original_level = logging.getLogger().level
+
+>>>>>>> bd941c3 (Add comprehensive test suite for improved code coverage)
         try:
             # Test with -v
             with mock.patch("sys.stdout"):
                 run(["-v", "test", "valid"])
                 self.assertEqual(logging.getLogger().level, logging.INFO)
+<<<<<<< HEAD
 
             # Reset log level
             logging.getLogger().setLevel(original_level)
 
+=======
+
+            # Reset log level
+            logging.getLogger().setLevel(original_level)
+
+>>>>>>> bd941c3 (Add comprehensive test suite for improved code coverage)
             # Test with -v -v
             with mock.patch("sys.stdout"):
                 run(["-v", "-v", "test", "valid"])

tests/test_config.py

@@ -0,0 +1,22 @@
+# SPDX-License-Identifier: BSD-2-Clause
+import os
+import unittest
+from unittest import mock
+
+from chipflow_lib.config import get_dir_models, get_dir_software
+
+
+class TestConfig(unittest.TestCase):
+    def test_get_dir_models(self):
+        """Test get_dir_models returns the correct path"""
+        # Since we can't predict the absolute path, we'll check that it ends correctly
+        models_dir = get_dir_models()
+        self.assertTrue(models_dir.endswith("/chipflow_lib/models"))
+        self.assertTrue(os.path.isdir(models_dir))
+
+    def test_get_dir_software(self):
+        """Test get_dir_software returns the correct path"""
+        # Since we can't predict the absolute path, we'll check that it ends correctly
+        software_dir = get_dir_software()
+        self.assertTrue(software_dir.endswith("/chipflow_lib/software"))
+        self.assertTrue(os.path.isdir(software_dir))

tests/test_errors.py

@@ -0,0 +1,21 @@
+# SPDX-License-Identifier: BSD-2-Clause
+import unittest
+
+from chipflow_lib.errors import ChipFlowError
+
+
+class TestErrors(unittest.TestCase):
+    def test_chipflow_error(self):
+        """Test that ChipFlowError can be instantiated and raised"""
+        # Test instantiation
+        error = ChipFlowError("Test error message")
+        self.assertEqual(str(error), "Test error message")
+
+        # Test raising
+        with self.assertRaises(ChipFlowError) as cm:
+            raise ChipFlowError("Test raised error")
+
+        self.assertEqual(str(cm.exception), "Test raised error")
+
+        # Test inheritance
+        self.assertTrue(issubclass(ChipFlowError, Exception))