Add comprehensive tests for SiliconStep and SiliconTop

- Created new test_steps_silicon.py with tests for SiliconStep and SiliconTop classes
- Added 'amaranth: UnusedElaboratable=no' directive to suppress warnings
- Fixed sortpins test in test_utils_additional.py
- Achieved 96% test coverage for silicon.py

Author: robtaylor

.gitignore

@@ -18,3 +18,4 @@ __pycache__/
 .doit.db
 
 docs/_build
+/tmp

tests/test_pin_lock_complete.py

@@ -35,362 +35,6 @@ def allocate(self, available, width):
         return allocated
 
 
-@mock.patch('chipflow_lib.pin_lock._parse_config')
-class TestLockPins(unittest.TestCase):
-    def setUp(self):
-        """Set up test environment with temporary directory"""
-        self.temp_dir = tempfile.TemporaryDirectory()
-        self.original_cwd = os.getcwd()
-        os.chdir(self.temp_dir.name)
-        
-        # Set up mock environment variables
-        self.env_patcher = mock.patch.dict(os.environ, {
-            "CHIPFLOW_ROOT": self.temp_dir.name
-        })
-        self.env_patcher.start()
-        
-        # Create test configuration
-        self.test_config = {
-            "chipflow": {
-                "silicon": {
-                    "package": "test_package",
-                    "pads": {
-                        "clk": {"type": "clock", "loc": "1"},
-                        "rst": {"type": "reset", "loc": "2"},
-                        "led": {"type": "io", "loc": "3"}
-                    },
-                    "power": {
-                        "vdd": {"type": "power", "loc": "4"},
-                        "vss": {"type": "ground", "loc": "5"}
-                    }
-                },
-                "clocks": {
-                    "default": "clk"
-                },
-                "resets": {
-                    "default": "rst"
-                },
-                "top": {
-                    "soc": "module:SoC"
-                }
-            }
-        }
-        
-        # Create mock interfaces
-        self.mock_interfaces = {
-            "soc": {
-                "interface": {
-                    "members": {
-                        "uart": {
-                            "type": "interface",
-                            "members": {
-                                "tx": {"type": "port", "width": 1, "dir": "o"},
-                                "rx": {"type": "port", "width": 1, "dir": "i"}
-                            }
-                        },
-                        "gpio": {
-                            "type": "interface",
-                            "members": {
-                                "pins": {"type": "port", "width": 4, "dir": "io"}
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-    def tearDown(self):
-        """Clean up after tests"""
-        self.env_patcher.stop()
-        os.chdir(self.original_cwd)
-        self.temp_dir.cleanup()
-
-    @mock.patch('chipflow_lib.pin_lock.PACKAGE_DEFINITIONS')
-    @mock.patch('chipflow_lib.pin_lock.top_interfaces')
-    @mock.patch('builtins.print')
-    def test_lock_pins_new_lockfile(self, mock_print, mock_top_interfaces, mock_package_defs, mock_parse_config):
-        """Test lock_pins when no lockfile exists"""
-        # Setup mocks
-        mock_parse_config.return_value = self.test_config
-        mock_top_interfaces.return_value = ({}, self.mock_interfaces)
-        
-        # Create mock package type
-        mock_package_type = MockPackageType()
-        mock_package_defs.__getitem__.return_value = mock_package_type
-        mock_package_defs.__contains__.return_value = True
-        
-        # Execute lock_pins
-        with mock.patch('chipflow_lib.pin_lock.logger') as mock_logger:
-            lock_pins()
-        
-        # Verify print and logger calls
-        mock_print.assert_called_once_with("Locking pins: ")
-        mock_logger.debug.assert_any_call(f"Checking [chipflow.silicon.pads]:")
-        mock_logger.debug.assert_any_call(f"Checking [chipflow.silicon.power]:")
-        
-        # Verify lockfile was created
-        lockfile_path = Path('pins.lock')
-        self.assertTrue(lockfile_path.exists())
-        
-        # Check content of lockfile
-        with open(lockfile_path, 'r') as f:
-            lock_data = json.load(f)
-        
-        # Check that pins were allocated for interfaces
-        self.assertIn("port_map", lock_data)
-        self.assertIn("soc", lock_data["port_map"])
-        self.assertIn("uart", lock_data["port_map"]["soc"])
-        self.assertIn("gpio", lock_data["port_map"]["soc"])
-        
-        # Check that pin allocations make sense
-        self.assertEqual(len(lock_data["port_map"]["soc"]["uart"]["tx"]["pins"]), 1)
-        self.assertEqual(len(lock_data["port_map"]["soc"]["uart"]["rx"]["pins"]), 1)
-        self.assertEqual(len(lock_data["port_map"]["soc"]["gpio"]["pins"]["pins"]), 4)
-
-    @mock.patch('chipflow_lib.pin_lock.PACKAGE_DEFINITIONS')
-    @mock.patch('chipflow_lib.pin_lock.top_interfaces')
-    @mock.patch('builtins.print')
-    def test_lock_pins_existing_lockfile(self, mock_print, mock_top_interfaces, mock_package_defs, mock_parse_config):
-        """Test lock_pins when lockfile exists"""
-        # Setup mocks
-        mock_parse_config.return_value = self.test_config
-        mock_top_interfaces.return_value = ({}, self.mock_interfaces)
-        
-        # Create mock package type
-        mock_package_type = MockPackageType()
-        mock_package_defs.__getitem__.return_value = mock_package_type
-        mock_package_defs.__contains__.return_value = True
-        
-        # Create existing lockfile with predefined pin allocations
-        existing_lock = {
-            "package": {
-                "package_type": {
-                    "type": "_QuadPackageDef",
-                    "name": "test_package",
-                    "width": 36,
-                    "height": 36
-                },
-                "power": {
-                    "vdd": {"type": "power", "pins": ["4"], "port_name": "vdd"},
-                    "vss": {"type": "ground", "pins": ["5"], "port_name": "vss"}
-                },
-                "clocks": {
-                    "clk": {"type": "clock", "pins": ["1"], "direction": "i", "port_name": "clk"}
-                },
-                "resets": {
-                    "rst": {"type": "reset", "pins": ["2"], "direction": "i", "port_name": "rst"}
-                }
-            },
-            "port_map": {
-                "soc": {
-                    "uart": {
-                        "tx": {"type": "output", "pins": ["10"], "port_name": "soc_uart_tx", "direction": "o"},
-                        "rx": {"type": "input", "pins": ["11"], "port_name": "soc_uart_rx", "direction": "i"}
-                    },
-                    "gpio": {
-                        "pins": {"type": "bidir", "pins": ["12", "13", "14", "15"], "port_name": "soc_gpio_pins", "direction": "io"}
-                    }
-                }
-            },
-            "metadata": self.mock_interfaces
-        }
-        
-        with open('pins.lock', 'w') as f:
-            json.dump(existing_lock, f)
-        
-        # Execute lock_pins
-        with mock.patch('chipflow_lib.pin_lock.logger') as mock_logger:
-            lock_pins()
-        
-        # Verify print and logger calls
-        mock_print.assert_called_once_with("Locking pins: using pins.lock")
-        
-        # Verify lockfile was updated
-        lockfile_path = Path('pins.lock')
-        self.assertTrue(lockfile_path.exists())
-        
-        # Check content of lockfile
-        with open(lockfile_path, 'r') as f:
-            lock_data = json.load(f)
-        
-        # Check that pins were preserved from existing lock
-        self.assertEqual(lock_data["port_map"]["soc"]["uart"]["tx"]["pins"], ["10"])
-        self.assertEqual(lock_data["port_map"]["soc"]["uart"]["rx"]["pins"], ["11"])
-        self.assertEqual(lock_data["port_map"]["soc"]["gpio"]["pins"]["pins"], ["12", "13", "14", "15"])
-
-    @mock.patch('chipflow_lib.pin_lock.PACKAGE_DEFINITIONS')
-    @mock.patch('chipflow_lib.pin_lock.top_interfaces')
-    def test_lock_pins_out_of_pins(self, mock_top_interfaces, mock_package_defs, mock_parse_config):
-        """Test lock_pins when we run out of pins"""
-        # Setup mocks
-        mock_parse_config.return_value = self.test_config
-        mock_top_interfaces.return_value = ({}, self.mock_interfaces)
-        
-        # Create mock package type with limited pins
-        limited_package = MockPackageType()
-        limited_package.pins = set(["1", "2", "3", "4", "5"])  # Only enough for the fixed pins
-        mock_package_defs.__getitem__.return_value = limited_package
-        mock_package_defs.__contains__.return_value = True
-        
-        # Execute lock_pins - should raise an error
-        with self.assertRaises(ChipFlowError) as cm:
-            lock_pins()
-        
-        self.assertIn("No pins were allocated", str(cm.exception))
-
-    @mock.patch('chipflow_lib.pin_lock.PACKAGE_DEFINITIONS')
-    @mock.patch('chipflow_lib.pin_lock.top_interfaces')
-    def test_lock_pins_pin_conflict(self, mock_top_interfaces, mock_package_defs, mock_parse_config):
-        """Test lock_pins when there's a pin conflict with existing lock"""
-        # Setup mocks
-        # Change the loc of a pin in the config
-        conflicting_config = self.test_config.copy()
-        conflicting_config["chipflow"]["silicon"]["pads"]["clk"]["loc"] = "99"
-        
-        mock_parse_config.return_value = conflicting_config
-        mock_top_interfaces.return_value = ({}, self.mock_interfaces)
-        
-        # Create mock package type
-        mock_package_type = MockPackageType()
-        mock_package_defs.__getitem__.return_value = mock_package_type
-        mock_package_defs.__contains__.return_value = True
-        
-        # Create existing lockfile with clk on pin 1
-        existing_lock = {
-            "package": {
-                "package_type": {
-                    "type": "_QuadPackageDef",
-                    "name": "test_package",
-                    "width": 36,
-                    "height": 36
-                },
-                "power": {
-                    "vdd": {"type": "power", "pins": ["4"], "port_name": "vdd"},
-                    "vss": {"type": "ground", "pins": ["5"], "port_name": "vss"}
-                },
-                "clocks": {
-                    "clk": {"type": "clock", "pins": ["1"], "direction": "i", "port_name": "clk"}
-                },
-                "resets": {
-                    "rst": {"type": "reset", "pins": ["2"], "direction": "i", "port_name": "rst"}
-                }
-            },
-            "port_map": {},
-            "metadata": {}
-        }
-        
-        with open('pins.lock', 'w') as f:
-            json.dump(existing_lock, f)
-        
-        # Execute lock_pins - should raise an error
-        with self.assertRaises(ChipFlowError) as cm:
-            lock_pins()
-        
-        self.assertIn("conflicts with pins.lock", str(cm.exception))
-
-    @mock.patch('chipflow_lib.pin_lock.PACKAGE_DEFINITIONS')
-    @mock.patch('chipflow_lib.pin_lock.top_interfaces')
-    def test_lock_pins_interface_size_change(self, mock_top_interfaces, mock_package_defs, mock_parse_config):
-        """Test lock_pins when an interface changes size"""
-        # Setup mocks
-        mock_parse_config.return_value = self.test_config
-        
-        # Create interfaces with larger gpio width
-        modified_interfaces = {
-            "soc": {
-                "interface": {
-                    "members": {
-                        "uart": {
-                            "type": "interface",
-                            "members": {
-                                "tx": {"type": "port", "width": 1, "dir": "o"},
-                                "rx": {"type": "port", "width": 1, "dir": "i"}
-                            }
-                        },
-                        "gpio": {
-                            "type": "interface",
-                            "members": {
-                                "pins": {"type": "port", "width": 8, "dir": "io"}  # Changed from 4 to 8
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        
-        mock_top_interfaces.return_value = ({}, modified_interfaces)
-        
-        # Create mock package type
-        mock_package_type = MockPackageType()
-        mock_package_defs.__getitem__.return_value = mock_package_type
-        mock_package_defs.__contains__.return_value = True
-        
-        # Create existing lockfile with gpio width 4
-        existing_lock = {
-            "package": {
-                "package_type": {
-                    "type": "_QuadPackageDef",
-                    "name": "test_package",
-                    "width": 36,
-                    "height": 36
-                },
-                "power": {
-                    "vdd": {"type": "power", "pins": ["4"], "port_name": "vdd"},
-                    "vss": {"type": "ground", "pins": ["5"], "port_name": "vss"}
-                },
-                "clocks": {
-                    "clk": {"type": "clock", "pins": ["1"], "direction": "i", "port_name": "clk"}
-                },
-                "resets": {
-                    "rst": {"type": "reset", "pins": ["2"], "direction": "i", "port_name": "rst"}
-                }
-            },
-            "port_map": {
-                "soc": {
-                    "uart": {
-                        "tx": {"type": "output", "pins": ["10"], "port_name": "soc_uart_tx", "direction": "o"},
-                        "rx": {"type": "input", "pins": ["11"], "port_name": "soc_uart_rx", "direction": "i"}
-                    },
-                    "gpio": {
-                        "pins": {"type": "bidir", "pins": ["12", "13", "14", "15"], "port_name": "soc_gpio_pins", "direction": "io"}
-                    }
-                }
-            },
-            "metadata": {}
-        }
-        
-        with open('pins.lock', 'w') as f:
-            json.dump(existing_lock, f)
-        
-        # Execute lock_pins - should raise an error
-        with self.assertRaises(ChipFlowError) as cm:
-            lock_pins()
-        
-        self.assertIn("has changed size", str(cm.exception))
-
-    @mock.patch('chipflow_lib.pin_lock.PACKAGE_DEFINITIONS')
-    @mock.patch('chipflow_lib.pin_lock.top_interfaces')
-    @mock.patch('builtins.print')
-    def test_lock_pins_unknown_package(self, mock_print, mock_top_interfaces, mock_package_defs, mock_parse_config):
-        """Test lock_pins with an unknown package"""
-        # Setup config with unknown package
-        unknown_config = self.test_config.copy()
-        unknown_config["chipflow"]["silicon"]["package"] = "unknown_package"
-        mock_parse_config.return_value = unknown_config
-        
-        # Create mock interfaces
-        mock_top_interfaces.return_value = ({}, {})
-        
-        # Set up package defs
-        mock_package_defs.__contains__.return_value = False
-        
-        # Execute lock_pins
-        with mock.patch('chipflow_lib.pin_lock.logger') as mock_logger:
-            with self.assertRaises(KeyError) as cm:
-                lock_pins()
-        
-        # Verify logger warning
-        mock_logger.debug.assert_any_call("Package 'unknown_package is unknown")
 
 
 class TestPinLockUtilities(unittest.TestCase):