amd-debug-tools 0.2.2__py3-none-any.whl → 0.2.12__py3-none-any.whl

test_prerequisites.py

@@ -8,6 +8,7 @@ This module contains unit tests for the prerequisite functions in the amd-debug-
 import logging
 import unittest
 import subprocess
+import struct
 from unittest.mock import patch, MagicMock, mock_open
 
 from amd_debug.prerequisites import PrerequisiteValidator
@@ -143,6 +144,16 @@ class TestPrerequisiteValidator(unittest.TestCase):
         result = self.validator.check_port_pm_override()
         self.assertTrue(result)
 
+    @patch("amd_debug.prerequisites.version.parse")
+    def test_check_port_pm_override_smu_version_missing(self, mock_version_parse):
+        """Test check_port_pm_override with SMU version undefined"""
+        self.validator.cpu_family = 0x19
+        self.validator.cpu_model = 0x74
+        mock_version_parse.side_effect = lambda v: v if isinstance(v, str) else None
+        self.validator.smu_version = ""
+        result = self.validator.check_port_pm_override()
+        self.assertTrue(result)
+
     @patch("amd_debug.prerequisites.version.parse")
     def test_check_port_pm_override_smu_version_too_low(self, mock_version_parse):
         """Test check_port_pm_override with SMU version < 76.18.0"""
@@ -185,15 +196,18 @@ class TestPrerequisiteValidator(unittest.TestCase):
         new_callable=unittest.mock.mock_open,
         read_data=b"\x00" * 45,
     )
-    def test_check_iommu_no_dma_protection(self, _mock_open):
-        """Test check_iommu when DMA protection is not enabled"""
+    @patch("amd_debug.prerequisites.os.path.exists", return_value=True)
+    def test_check_iommu_no_dma_protection_no_msft0201(self, _mock_open, _mock_exists):
+        """Test check_iommu when DMA protection is not enabled and no MSFT0201 in IVRS"""
         self.validator.cpu_family = 0x1A
         self.validator.cpu_model = 0x20
         iommu_device = MagicMock(sys_path="/sys/devices/iommu")
+        acpi_device = MagicMock(sys_path="/sys/devices/acpi/MSFT0201")
+        platform_device = MagicMock(sys_path="/sys/devices/platform/MSFT0201")
         self.mock_pyudev.list_devices.side_effect = [
             [iommu_device],
-            [],
-            [],
+            [acpi_device],
+            [platform_device],
         ]
         result = self.validator.check_iommu()
         self.assertFalse(result)
@@ -204,6 +218,27 @@ class TestPrerequisiteValidator(unittest.TestCase):
             "IOMMU is misconfigured: Pre-boot DMA protection not enabled", "❌"
         )
 
+    @patch(
+        "amd_debug.prerequisites.open",
+        new_callable=unittest.mock.mock_open,
+        read_data=b"\x00" * 45 + "MSFT0201".encode("utf-8"),
+    )
+    @patch("amd_debug.prerequisites.os.path.exists", return_value=True)
+    def test_check_iommu_no_dma_protection_BUT_msft0201(self, _mock_open, _mock_exists):
+        """Test check_iommu when DMA protection is not enabled BUT MSFT0201 is in IVRS"""
+        self.validator.cpu_family = 0x1A
+        self.validator.cpu_model = 0x20
+        iommu_device = MagicMock(sys_path="/sys/devices/iommu")
+        acpi_device = MagicMock(sys_path="/sys/devices/acpi/MSFT0201")
+        platform_device = MagicMock(sys_path="/sys/devices/platform/MSFT0201")
+        self.mock_pyudev.list_devices.side_effect = [
+            [iommu_device],
+            [acpi_device],
+            [platform_device],
+        ]
+        result = self.validator.check_iommu()
+        self.assertTrue(result)
+
     @patch(
         "amd_debug.prerequisites.open",
         new_callable=unittest.mock.mock_open,
@@ -292,7 +327,7 @@ class TestPrerequisiteValidator(unittest.TestCase):
             BIT(9) | 1
         )  # Kernel warnings ignored, other taint present
         result = self.validator.check_taint()
-        self.assertFalse(result)
+        self.assertTrue(result)
         self.assertTrue(
             any(isinstance(f, TaintedKernel) for f in self.validator.failures)
         )
@@ -402,6 +437,176 @@ class TestPrerequisiteValidator(unittest.TestCase):
             "This CPU model does not support hardware sleep over s2idle", "❌"
         )
 
+    @patch("builtins.open", new_callable=mock_open)
+    @patch("amd_debug.prerequisites.read_file")
+    @patch("amd_debug.prerequisites.os.path.exists")
+    def test_check_cpu_limited_cores_single_ccd(
+        self, mock_path_exists, mock_read_file, mock_file_open
+    ):
+        """Test check_cpu with artificially limited CPUs on single-CCD system"""
+        self.validator.cpu_family = 0x19
+        self.validator.cpu_model = 0x74
+        mock_read_file.return_value = "7"  # kernel_max = 7 (8 cores)
+        mock_path_exists.return_value = True
+        # Simulate finding socket level at subleaf 1
+        # First call: subleaf 0, level_type = 1 (not socket)
+        # Second call: subleaf 1, level_type = 4 (socket level)
+        # Third call: read cpu_count from subleaf 1
+        mock_file_open.return_value.read.side_effect = [
+            struct.pack("4I", 0, 0, 0x100, 0),  # subleaf 0: level_type = 1 (thread)
+            struct.pack(
+                "4I", 0, 0, 0x400, 0
+            ),  # subleaf 1: level_type = 4 (socket) - FOUND
+            struct.pack("4I", 0, 16, 0, 0),  # subleaf 1: cpu_count = 16
+        ]
+        result = self.validator.check_cpu()
+        self.assertFalse(result)
+        self.assertTrue(
+            any(isinstance(f, LimitedCores) for f in self.validator.failures)
+        )
+        self.mock_db.record_prereq.assert_called_with(
+            "The kernel has been limited to 8 CPU cores, but the system has 16 cores",
+            "❌",
+        )
+
+    @patch("builtins.open", new_callable=mock_open)
+    @patch("amd_debug.prerequisites.read_file")
+    @patch("amd_debug.prerequisites.os.path.exists")
+    def test_check_cpu_limited_cores_multi_ccd(
+        self, mock_path_exists, mock_read_file, mock_file_open
+    ):
+        """Test check_cpu with multi-CCD system (tests socket-level counting)"""
+        self.validator.cpu_family = 0x19
+        self.validator.cpu_model = 0x74
+        mock_read_file.return_value = "15"  # kernel_max = 15 (16 cores)
+        mock_path_exists.return_value = True
+        # Simulate multi-CCD: iterate through levels to find socket
+        # subleaf 0: level_type = 1 (thread)
+        # subleaf 1: level_type = 2 (core)
+        # subleaf 2: level_type = 3 (complex/CCD)
+        # subleaf 3: level_type = 4 (socket) - FOUND
+        mock_file_open.return_value.read.side_effect = [
+            struct.pack("4I", 0, 0, 0x100, 0),  # subleaf 0: level_type = 1 (thread)
+            struct.pack("4I", 0, 0, 0x200, 0),  # subleaf 1: level_type = 2 (core)
+            struct.pack(
+                "4I", 0, 0, 0x300, 0
+            ),  # subleaf 2: level_type = 3 (complex/CCD)
+            struct.pack(
+                "4I", 0, 0, 0x400, 0
+            ),  # subleaf 3: level_type = 4 (socket) - FOUND
+            struct.pack("4I", 0, 32, 0, 0),  # subleaf 3: cpu_count = 32
+        ]
+        result = self.validator.check_cpu()
+        self.assertFalse(result)
+        self.assertTrue(
+            any(isinstance(f, LimitedCores) for f in self.validator.failures)
+        )
+        self.mock_db.record_prereq.assert_called_with(
+            "The kernel has been limited to 16 CPU cores, but the system has 32 cores",
+            "❌",
+        )
+
+    @patch("builtins.open", new_callable=mock_open)
+    @patch("amd_debug.prerequisites.read_file")
+    @patch("amd_debug.prerequisites.os.path.exists")
+    def test_check_cpu_not_limited(
+        self, mock_path_exists, mock_read_file, mock_file_open
+    ):
+        """Test check_cpu when CPUs are not artificially limited"""
+        self.validator.cpu_family = 0x19
+        self.validator.cpu_model = 0x74
+        mock_read_file.return_value = "31"  # kernel_max = 31 (32 cores)
+        mock_path_exists.return_value = True
+        # Simulate finding socket level
+        mock_file_open.return_value.read.side_effect = [
+            struct.pack("4I", 0, 0, 0x100, 0),  # subleaf 0: level_type = 1
+            struct.pack("4I", 0, 0, 0x400, 0),  # subleaf 1: level_type = 4 (socket)
+            struct.pack("4I", 0, 16, 0, 0),  # subleaf 1: cpu_count = 16
+        ]
+        result = self.validator.check_cpu()
+        self.assertTrue(result)
+        self.mock_db.record_debug.assert_called_with("CPU core count: 16 max: 32")
+
+    @patch("builtins.open", new_callable=mock_open)
+    @patch("amd_debug.prerequisites.read_file")
+    @patch("amd_debug.prerequisites.os.path.exists")
+    def test_check_cpu_socket_level_at_boundary(
+        self, mock_path_exists, mock_read_file, mock_file_open
+    ):
+        """Test check_cpu when socket level is found at the last checked subleaf"""
+        self.validator.cpu_family = 0x19
+        self.validator.cpu_model = 0x74
+        mock_read_file.return_value = "15"  # kernel_max = 15 (16 cores)
+        mock_path_exists.return_value = True
+        # Socket level found at subleaf 4 (last iteration)
+        mock_file_open.return_value.read.side_effect = [
+            struct.pack("4I", 0, 0, 0x100, 0),  # subleaf 0: level_type = 1
+            struct.pack("4I", 0, 0, 0x200, 0),  # subleaf 1: level_type = 2
+            struct.pack("4I", 0, 0, 0x300, 0),  # subleaf 2: level_type = 3
+            struct.pack("4I", 0, 0, 0x000, 0),  # subleaf 3: level_type = 0
+            struct.pack("4I", 0, 0, 0x400, 0),  # subleaf 4: level_type = 4 (socket)
+            struct.pack("4I", 0, 16, 0, 0),  # subleaf 4: cpu_count = 16
+        ]
+        result = self.validator.check_cpu()
+        self.assertTrue(result)
+        self.mock_db.record_prereq.assert_called_with(
+            "Unable to discover CPU topology, didn't find socket level", "🚦"
+        )
+
+    @patch("builtins.open", new_callable=mock_open)
+    @patch("amd_debug.prerequisites.read_file")
+    @patch("amd_debug.prerequisites.os.path.exists")
+    def test_check_cpu_socket_level_first_subleaf(
+        self, mock_path_exists, mock_read_file, mock_file_open
+    ):
+        """Test check_cpu when socket level is found at first subleaf"""
+        self.validator.cpu_family = 0x19
+        self.validator.cpu_model = 0x74
+        mock_read_file.return_value = "7"  # kernel_max = 7 (8 cores)
+        mock_path_exists.return_value = True
+        # Socket level found immediately at subleaf 0
+        mock_file_open.return_value.read.side_effect = [
+            struct.pack(
+                "4I", 0, 0, 0x400, 0
+            ),  # subleaf 0: level_type = 4 (socket) - FOUND
+            struct.pack("4I", 0, 8, 0, 0),  # subleaf 0: cpu_count = 8
+        ]
+        result = self.validator.check_cpu()
+        self.assertTrue(result)
+        self.mock_db.record_debug.assert_called_with("CPU core count: 8 max: 8")
+
+    @patch("builtins.open", side_effect=FileNotFoundError)
+    @patch("amd_debug.prerequisites.read_file")
+    @patch("amd_debug.prerequisites.os.path.exists")
+    def test_check_cpu_cpuid_file_not_found(
+        self, mock_path_exists, mock_read_file, mock_file_open
+    ):
+        """Test check_cpu when cpuid kernel module is not loaded"""
+        self.validator.cpu_family = 0x19
+        self.validator.cpu_model = 0x74
+        mock_read_file.return_value = "7"
+        mock_path_exists.return_value = False
+        result = self.validator.check_cpu()
+        self.assertFalse(result)
+        self.mock_db.record_prereq.assert_called_with(
+            "Unable to check CPU topology: cpuid kernel module not loaded", "❌"
+        )
+
+    @patch("builtins.open", side_effect=PermissionError)
+    @patch("amd_debug.prerequisites.read_file")
+    @patch("amd_debug.prerequisites.os.path.exists")
+    def test_check_cpu_cpuid_permission_error(
+        self, mock_path_exists, mock_read_file, mock_file_open
+    ):
+        """Test check_cpu when there is a permission error accessing cpuid"""
+        self.validator.cpu_family = 0x19
+        self.validator.cpu_model = 0x74
+        mock_read_file.return_value = "7"
+        mock_path_exists.return_value = True
+        result = self.validator.check_cpu()
+        self.assertTrue(result)
+        self.mock_db.record_prereq.assert_called_with("CPUID checks unavailable", "🚦")
+
     @patch("amd_debug.prerequisites.os.walk")
     @patch(
         "amd_debug.prerequisites.open",
@@ -500,9 +705,7 @@ class TestPrerequisiteValidator(unittest.TestCase):
         result = self.validator.map_acpi_path()
         self.assertTrue(result)
         self.mock_db.record_debug.assert_called_with(
-            "ACPI name: ACPI path [driver]\n"
-            "│ device1: mocked_path [driver]\n"
-            "└─device2: mocked_path [driver]\n"
+            "ACPI name | ACPI path | Kernel driver\ndevice1 | mocked_path | driver\ndevice2 | mocked_path | driver\n"
         )
 
     @patch("amd_debug.prerequisites.os.path.exists")
@@ -545,7 +748,7 @@ class TestPrerequisiteValidator(unittest.TestCase):
         result = self.validator.map_acpi_path()
         self.assertTrue(result)
         self.mock_db.record_debug.assert_called_with(
-            "ACPI name: ACPI path [driver]\n└─device1: mocked_path [None]\n"
+            "ACPI name | ACPI path | Kernel driver\ndevice1 | mocked_path | None\n"
         )
 
     @patch("amd_debug.prerequisites.read_file")
@@ -569,8 +772,7 @@ class TestPrerequisiteValidator(unittest.TestCase):
 
         self.validator.capture_pci_acpi()
         self.mock_db.record_debug.assert_called_with(
-            "PCI devices\n"
-            "└─0000:00:1f.0 : Intel Corporation ISA bridge [1234abcd] : mocked_acpi_path\n"
+            "PCI Slot | Vendor | Class | ID | ACPI path\n└─0000:00:1f.0 | Intel Corporation | ISA bridge | 1234abcd | mocked_acpi_path\n"
         )
 
     @patch("amd_debug.prerequisites.read_file")
@@ -593,8 +795,7 @@ class TestPrerequisiteValidator(unittest.TestCase):
 
         self.validator.capture_pci_acpi()
         self.mock_db.record_debug.assert_called_with(
-            "PCI devices\n"
-            "└─0000:01:00.0 : NVIDIA Corporation VGA compatible controller [5678efgh]\n"
+            "PCI Slot | Vendor | Class | ID | ACPI path\n└─0000:01:00.0 | NVIDIA Corporation | VGA compatible controller | 5678efgh | \n"
         )
 
     @patch("amd_debug.prerequisites.read_file")
@@ -628,9 +829,7 @@ class TestPrerequisiteValidator(unittest.TestCase):
 
         self.validator.capture_pci_acpi()
         self.mock_db.record_debug.assert_called_with(
-            "PCI devices\n"
-            "│ 0000:00:1f.0 : Intel Corporation ISA bridge [1234abcd] : mocked_acpi_path\n"
-            "└─0000:01:00.0 : NVIDIA Corporation VGA compatible controller [5678efgh] : mocked_acpi_path\n"
+            "PCI Slot | Vendor | Class | ID | ACPI path\n│ 0000:00:1f.0 | Intel Corporation | ISA bridge | 1234abcd | mocked_acpi_path\n└─0000:01:00.0 | NVIDIA Corporation | VGA compatible controller | 5678efgh | mocked_acpi_path\n"
         )
 
     def test_capture_pci_acpi_no_devices(self):
@@ -638,7 +837,9 @@ class TestPrerequisiteValidator(unittest.TestCase):
         self.mock_pyudev.list_devices.return_value = []
 
         self.validator.capture_pci_acpi()
-        self.mock_db.record_debug.assert_called_with("PCI devices\n")
+        self.mock_db.record_debug.assert_called_with(
+            "PCI Slot | Vendor | Class | ID | ACPI path\n"
+        )
 
     @patch("amd_debug.prerequisites.read_file")
     def test_check_aspm_default_policy(self, mock_read_file):
@@ -802,8 +1003,7 @@ class TestPrerequisiteValidator(unittest.TestCase):
         self.assertFalse(result)
         self.assertTrue(any(isinstance(f, FadtWrong) for f in self.validator.failures))
 
-    @patch("amd_debug.prerequisites.os.path.exists", return_value=False)
-    def test_check_fadt_file_not_found(self, mock_path_exists):
+    def test_check_fadt_file_not_found(self):
         """Test check_fadt when FADT file is not found"""
         self.mock_kernel_log.match_line.return_value = False
         result = self.validator.check_fadt()
@@ -1006,7 +1206,7 @@ class TestPrerequisiteValidator(unittest.TestCase):
             "MockVendor MockProduct (MockFamily)", "💻"
         )
         self.mock_db.record_debug.assert_called_with(
-            "DMI data:\nchassis_type: Desktop\n"
+            "DMI|value\nchassis_type| Desktop\n"
         )
 
     @patch("amd_debug.prerequisites.os.walk")
@@ -1034,7 +1234,7 @@ class TestPrerequisiteValidator(unittest.TestCase):
         self.mock_db.record_prereq.assert_called_with(
             "MockVendor MockProduct (MockFamily)", "💻"
         )
-        self.mock_db.record_debug.assert_called_with("DMI data:\n")
+        self.mock_db.record_debug.assert_called_with("DMI|value\n")
 
     @patch("amd_debug.prerequisites.os.walk")
     @patch("amd_debug.prerequisites.read_file")
@@ -1083,7 +1283,7 @@ class TestPrerequisiteValidator(unittest.TestCase):
 
     @patch("amd_debug.prerequisites.os.path.exists")
     @patch(
-        "builtins.open",
+        "amd_debug.prerequisites.open",
         new_callable=unittest.mock.mock_open,
         read_data="ignore_wake_value",
     )
@@ -1098,7 +1298,11 @@ class TestPrerequisiteValidator(unittest.TestCase):
         )
 
     @patch("amd_debug.prerequisites.os.path.exists")
-    @patch("builtins.open", new_callable=unittest.mock.mock_open, read_data="(null)")
+    @patch(
+        "amd_debug.prerequisites.open",
+        new_callable=unittest.mock.mock_open,
+        read_data="(null)",
+    )
     def test_capture_disabled_pins_with_null_values(self, _mock_open, mock_path_exists):
         mock_path_exists.side_effect = (
             lambda path: "ignore_wake" in path or "ignore_interrupt" in path
@@ -1710,9 +1914,6 @@ class TestPrerequisiteValidator(unittest.TestCase):
         ]
         result = self.validator.check_storage()
         self.assertTrue(result)
-        self.mock_db.record_debug.assert_called_with(
-            "New enough kernel to avoid NVME check"
-        )
 
     def test_check_storage_no_kernel_log(self):
         """Test check_storage when kernel log is unavailable"""
@@ -1933,3 +2134,405 @@ class TestPrerequisiteValidator(unittest.TestCase):
         result = self.validator.check_dpia_pg_dmcub()
         self.assertTrue(result)
         self.mock_db.record_prereq.assert_not_called()
+
+    @patch("amd_debug.prerequisites.os.path.exists")
+    def test_capture_nvidia_version_file_missing(self, mock_exists):
+        """Test capture_nvidia when /proc/driver/nvidia/version does not exist"""
+        mock_exists.side_effect = lambda p: False if "version" in p else True
+        result = self.validator.capture_nvidia()
+        self.assertTrue(result)
+        self.mock_db.record_debug_file.assert_not_called()
+        self.mock_db.record_prereq.assert_not_called()
+
+    @patch("amd_debug.prerequisites.os.path.exists")
+    def test_capture_nvidia_gpus_dir_missing(self, mock_exists):
+        """Test capture_nvidia when /proc/driver/nvidia/gpus does not exist"""
+
+        def exists_side_effect(path):
+            if "version" in path:
+                return True
+            if "gpus" in path:
+                return False
+            return True
+
+        mock_exists.side_effect = exists_side_effect
+        result = self.validator.capture_nvidia()
+        self.assertTrue(result)
+        self.mock_db.record_debug_file.assert_called_once_with(
+            "/proc/driver/nvidia/version"
+        )
+        self.mock_db.record_prereq.assert_not_called()
+
+    @patch("amd_debug.prerequisites.os.walk")
+    @patch("amd_debug.prerequisites.os.path.exists")
+    def test_capture_nvidia_success(self, mock_exists, mock_walk):
+        """Test capture_nvidia when NVIDIA GPU files are present and readable"""
+        mock_exists.side_effect = lambda p: True
+        mock_walk.return_value = [
+            ("/proc/driver/nvidia/gpus/0000:01:00.0", [], ["info", "power"])
+        ]
+        result = self.validator.capture_nvidia()
+        self.assertTrue(result)
+        self.mock_db.record_debug_file.assert_any_call("/proc/driver/nvidia/version")
+        self.mock_db.record_debug.assert_any_call("NVIDIA info")
+        self.mock_db.record_debug_file.assert_any_call(
+            "/proc/driver/nvidia/gpus/0000:01:00.0/info"
+        )
+        self.mock_db.record_debug.assert_any_call("NVIDIA power")
+        self.mock_db.record_debug_file.assert_any_call(
+            "/proc/driver/nvidia/gpus/0000:01:00.0/power"
+        )
+
+    @patch("amd_debug.prerequisites.os.walk")
+    @patch("amd_debug.prerequisites.os.path.exists")
+    def test_capture_nvidia_permission_error_on_version(self, mock_exists, mock_walk):
+        """Test capture_nvidia when PermissionError occurs reading version file"""
+        mock_exists.side_effect = lambda p: True if "version" in p else False
+        self.mock_db.record_debug_file.side_effect = PermissionError
+        result = self.validator.capture_nvidia()
+        self.assertTrue(result)
+        self.mock_db.record_prereq.assert_called_with(
+            "NVIDIA GPU version not readable", "👀"
+        )
+
+    @patch("amd_debug.prerequisites.os.walk")
+    @patch("amd_debug.prerequisites.os.path.exists")
+    def test_capture_nvidia_permission_error_on_gpu_file(self, mock_exists, mock_walk):
+        """Test capture_nvidia when PermissionError occurs reading a GPU file"""
+        mock_exists.side_effect = lambda p: True
+        mock_walk.return_value = [
+            ("/proc/driver/nvidia/gpus/0000:01:00.0", [], ["info"])
+        ]
+        self.mock_db.record_debug_file.side_effect = [None, PermissionError]
+        result = self.validator.capture_nvidia()
+        self.assertTrue(result)
+        self.mock_db.record_debug.assert_any_call("NVIDIA info")
+        self.mock_db.record_prereq.assert_called_with(
+            "NVIDIA GPU {f} not readable", "👀"
+        )
+
+    @patch("amd_debug.prerequisites.os.walk")
+    @patch(
+        "builtins.open",
+        new_callable=unittest.mock.mock_open,
+        read_data=b"C1 state info",
+    )
+    def test_capture_cstates_single_file(self, mock_open, mock_walk):
+        """Test capture_cstates with a single cpuidle file"""
+        mock_walk.return_value = [
+            ("/sys/bus/cpu/devices/cpu0/cpuidle", [], ["state1"]),
+        ]
+        self.validator.capture_cstates()
+        self.mock_db.record_debug.assert_called_with(
+            "ACPI C-state information\n└─/sys/bus/cpu/devices/cpu0/cpuidle/state1: C1 state info"
+        )
+
+    @patch("amd_debug.prerequisites.os.walk")
+    @patch("builtins.open", new_callable=mock_open)
+    def test_capture_cstates_multiple_files(self, mock_open_func, mock_walk):
+        """Test capture_cstates with multiple cpuidle files"""
+        # Setup mock file reads for two files
+        file_contents = {
+            "/sys/bus/cpu/devices/cpu0/cpuidle/state1": b"C1 info",
+            "/sys/bus/cpu/devices/cpu0/cpuidle/state2": b"C2 info",
+        }
+
+        def side_effect(path, mode="rb"):
+            mock_file = mock_open(read_data=file_contents[path])()
+            return mock_file
+
+        mock_open_func.side_effect = side_effect
+        mock_walk.return_value = [
+            ("/sys/bus/cpu/devices/cpu0/cpuidle", [], ["state1", "state2"]),
+        ]
+        self.validator.capture_cstates()
+        # The prefix logic is based on order, so check for both lines
+        debug_call = self.mock_db.record_debug.call_args[0][0]
+        self.assertIn("/sys/bus/cpu/devices/cpu0/cpuidle/state1: C1 info", debug_call)
+        self.assertIn("/sys/bus/cpu/devices/cpu0/cpuidle/state2: C2 info", debug_call)
+        self.assertTrue(debug_call.startswith("ACPI C-state information\n"))
+
+    @patch("amd_debug.prerequisites.os.walk")
+    @patch("builtins.open", new_callable=mock_open, read_data=b"")
+    def test_capture_cstates_empty_files(self, _mock_open, mock_walk):
+        """Test capture_cstates with empty cpuidle files"""
+        mock_walk.return_value = [
+            ("/sys/bus/cpu/devices/cpu0/cpuidle", [], ["state1"]),
+        ]
+        self.validator.capture_cstates()
+        self.mock_db.record_debug.assert_called_with(
+            "ACPI C-state information\n└─/sys/bus/cpu/devices/cpu0/cpuidle/state1: "
+        )
+
+    @patch("amd_debug.prerequisites.os.walk")
+    @patch("amd_debug.prerequisites.open", side_effect=PermissionError)
+    def test_capture_cstates_permission_error(self, _mock_open, mock_walk):
+        """Test capture_cstates when reading cpuidle files raises PermissionError"""
+        mock_walk.return_value = [
+            ("/sys/bus/cpu/devices/cpu0/cpuidle", [], ["state1"]),
+        ]
+        with self.assertRaises(PermissionError):
+            self.validator.capture_cstates()
+        self.mock_db.record_debug.assert_not_called()
+
+    @patch("amd_debug.prerequisites.os.walk")
+    def test_capture_cstates_no_files(self, mock_walk):
+        """Test capture_cstates when no cpuidle files are present"""
+        mock_walk.return_value = [
+            ("/sys/bus/cpu/devices/cpu0/cpuidle", [], []),
+        ]
+        self.validator.capture_cstates()
+        self.mock_db.record_debug.assert_called_with("ACPI C-state information\n")
+
+    @patch("amd_debug.prerequisites.read_file")
+    def test_check_pinctrl_amd_driver_loaded_with_missing_file_error(
+        self, mock_read_file
+    ):
+        """Test check_pinctrl_amd when the driver is loaded but debug file is missing"""
+        mock_read_file.side_effect = FileNotFoundError
+        self.mock_pyudev.list_devices.return_value = [
+            MagicMock(properties={"DRIVER": "amd_gpio"})
+        ]
+
+        result = self.validator.check_pinctrl_amd()
+        self.assertTrue(result)
+        self.mock_db.record_prereq.assert_called_with(
+            "GPIO debugfs not available", "👀"
+        )
+
+    def test_check_amdgpu_no_devices(self):
+        """Test check_amdgpu when no PCI devices are found"""
+        self.mock_pyudev.list_devices.return_value = []
+        result = self.validator.check_amdgpu()
+        self.assertFalse(result)
+        self.mock_db.record_prereq.assert_called_with("Integrated GPU not found", "❌")
+        self.assertTrue(any(isinstance(f, MissingGpu) for f in self.validator.failures))
+
+    def test_check_amdgpu_non_amd_devices(self):
+        """Test check_amdgpu when PCI devices are present but not AMD GPUs"""
+        self.mock_pyudev.list_devices.return_value = [
+            MagicMock(
+                properties={
+                    "PCI_CLASS": "30000",
+                    "PCI_ID": "8086abcd",
+                    "DRIVER": "i915",
+                }
+            ),
+        ]
+        result = self.validator.check_amdgpu()
+        self.assertFalse(result)
+        self.mock_db.record_prereq.assert_called_with("Integrated GPU not found", "❌")
+        self.assertTrue(any(isinstance(f, MissingGpu) for f in self.validator.failures))
+
+    def test_check_amdgpu_driver_not_loaded(self):
+        """Test check_amdgpu when AMD GPU is present but driver is not loaded"""
+        self.mock_pyudev.list_devices.return_value = [
+            MagicMock(
+                properties={"PCI_CLASS": "20000", "PCI_ID": "1111abcd", "DRIVER": None}
+            ),
+            MagicMock(
+                properties={"PCI_CLASS": "30000", "PCI_ID": "1002abcd", "DRIVER": None}
+            ),
+        ]
+        result = self.validator.check_amdgpu()
+        self.assertFalse(result)
+        self.mock_db.record_prereq.assert_called_with(
+            "GPU driver `amdgpu` not loaded", "❌"
+        )
+        self.assertTrue(
+            any(isinstance(f, MissingAmdgpu) for f in self.validator.failures)
+        )
+
+    def test_check_amdgpu_driver_loaded(self):
+        """Test check_amdgpu when AMD GPU is present and driver is loaded"""
+        self.mock_pyudev.list_devices.return_value = [
+            MagicMock(
+                properties={
+                    "PCI_CLASS": "30000",
+                    "PCI_ID": "1002abcd",
+                    "DRIVER": "amdgpu",
+                    "PCI_SLOT_NAME": "0000:01:00.0",
+                }
+            ),
+        ]
+        result = self.validator.check_amdgpu()
+        self.assertTrue(result)
+        self.mock_db.record_prereq.assert_called_with(
+            "GPU driver `amdgpu` bound to 0000:01:00.0", "✅"
+        )
+
+    def test_check_amdgpu_multiple_devices_mixed(self):
+        """Test check_amdgpu with multiple devices, one with driver loaded, one without"""
+        self.mock_pyudev.list_devices.return_value = [
+            MagicMock(
+                properties={
+                    "PCI_CLASS": "30000",
+                    "PCI_ID": "1002abcd",
+                    "DRIVER": "amdgpu",
+                    "PCI_SLOT_NAME": "0000:01:00.0",
+                }
+            ),
+            MagicMock(
+                properties={"PCI_CLASS": "30000", "PCI_ID": "1002abcd", "DRIVER": None}
+            ),
+        ]
+        result = self.validator.check_amdgpu()
+        self.assertFalse(result)
+        self.mock_db.record_prereq.assert_any_call(
+            "GPU driver `amdgpu` bound to 0000:01:00.0", "✅"
+        )
+        self.mock_db.record_prereq.assert_any_call(
+            "GPU driver `amdgpu` not loaded", "❌"
+        )
+        self.assertTrue(
+            any(isinstance(f, MissingAmdgpu) for f in self.validator.failures)
+        )
+
+    @patch("amd_debug.prerequisites.os.path.exists")
+    @patch("amd_debug.prerequisites.os.readlink")
+    def test_check_isp4_no_devices(self, _mock_readlink, _mock_path_exists):
+        """Test check_isp4 when no ISP4 camera devices are found"""
+        self.mock_pyudev.list_devices.return_value = []
+        result = self.validator.check_isp4()
+        self.assertTrue(result)
+        self.mock_db.record_prereq.assert_not_called()
+
+    @patch("amd_debug.prerequisites.os.path.exists")
+    @patch("amd_debug.prerequisites.os.readlink")
+    def test_check_isp4_device_without_path(self, _mock_readlink, mock_path_exists):
+        """Test check_isp4 when ACPI device exists but path file is missing"""
+        mock_path_exists.return_value = False
+        self.mock_pyudev.list_devices.return_value = [
+            MagicMock(sys_path="/sys/devices/acpi/OMNI5C10:00", sys_name="OMNI5C10:00")
+        ]
+        result = self.validator.check_isp4()
+        self.assertTrue(result)
+        self.mock_db.record_prereq.assert_not_called()
+
+    @patch("amd_debug.prerequisites.os.path.exists")
+    @patch("amd_debug.prerequisites.os.readlink")
+    def test_check_isp4_driver_not_bound(self, _mock_readlink, mock_path_exists):
+        """Test check_isp4 when ISP4 driver is not bound to the device"""
+        mock_path_exists.side_effect = lambda p: "path" in p
+        self.mock_pyudev.list_devices.return_value = [
+            MagicMock(sys_path="/sys/devices/acpi/OMNI5C10:00", sys_name="OMNI5C10:00")
+        ]
+        result = self.validator.check_isp4()
+        self.assertFalse(result)
+        self.mock_db.record_prereq.assert_called_with(
+            "ISP4 platform camera driver 'amd-isp4' not bound to OMNI5C10:00", "❌"
+        )
+        self.assertTrue(
+            any(
+                isinstance(f, MissingIsp4PlatformDriver)
+                for f in self.validator.failures
+            )
+        )
+
+    @patch("amd_debug.prerequisites.os.path.exists")
+    @patch(
+        "amd_debug.prerequisites.os.readlink",
+        return_value="/sys/devices/platform/drivers/amd-isp4",
+    )
+    def test_check_isp4_driver_bound_but_module_not_loaded(
+        self, _mock_readlink, mock_path_exists
+    ):
+        """Test check_isp4 when driver is bound but amd_capture module is not loaded"""
+
+        def exists_side_effect(path):
+            if "path" in path or "driver" in path:
+                return True
+            if "amd_capture" in path:
+                return False
+            return True
+
+        mock_path_exists.side_effect = exists_side_effect
+        self.mock_pyudev.list_devices.return_value = [
+            MagicMock(sys_path="/sys/devices/acpi/OMNI5C10:00", sys_name="OMNI5C10:00")
+        ]
+        result = self.validator.check_isp4()
+        self.assertFalse(result)
+        self.mock_db.record_prereq.assert_any_call(
+            "ISP4 platform camera driver 'amd-isp4' bound to OMNI5C10:00", "✅"
+        )
+        self.mock_db.record_prereq.assert_any_call(
+            "Camera driver module 'amd_capture' not loaded", "❌"
+        )
+        self.assertTrue(
+            any(isinstance(f, MissingAmdCaptureModule) for f in self.validator.failures)
+        )
+
+    @patch("amd_debug.prerequisites.os.path.exists")
+    @patch(
+        "amd_debug.prerequisites.os.readlink",
+        return_value="/sys/devices/platform/drivers/amd-isp4",
+    )
+    def test_check_isp4_fully_configured(self, _mock_readlink, mock_path_exists):
+        """Test check_isp4 when ISP4 is fully configured with driver and module"""
+        mock_path_exists.return_value = True
+        self.mock_pyudev.list_devices.return_value = [
+            MagicMock(sys_path="/sys/devices/acpi/OMNI5C10:00", sys_name="OMNI5C10:00")
+        ]
+        result = self.validator.check_isp4()
+        self.assertTrue(result)
+        self.mock_db.record_prereq.assert_any_call(
+            "ISP4 platform camera driver 'amd-isp4' bound to OMNI5C10:00", "✅"
+        )
+        self.mock_db.record_prereq.assert_any_call(
+            "Camera driver module 'amd_capture' loaded", "✅"
+        )
+
+    @patch("amd_debug.prerequisites.os.path.exists")
+    @patch(
+        "amd_debug.prerequisites.os.readlink",
+        return_value="/sys/devices/platform/drivers/other-driver",
+    )
+    def test_check_isp4_wrong_driver(self, _mock_readlink, mock_path_exists):
+        """Test check_isp4 when wrong driver is bound to the device"""
+        mock_path_exists.side_effect = lambda p: "path" in p or "driver" in p
+        self.mock_pyudev.list_devices.return_value = [
+            MagicMock(sys_path="/sys/devices/acpi/OMNI5C10:00", sys_name="OMNI5C10:00")
+        ]
+        result = self.validator.check_isp4()
+        self.assertFalse(result)
+        self.mock_db.record_prereq.assert_called_with(
+            "ISP4 platform camera driver 'amd-isp4' not bound to OMNI5C10:00", "❌"
+        )
+        self.assertTrue(
+            any(
+                isinstance(f, MissingIsp4PlatformDriver)
+                for f in self.validator.failures
+            )
+        )
+
+    @patch("amd_debug.prerequisites.os.path.exists")
+    @patch(
+        "amd_debug.prerequisites.os.readlink",
+        return_value="/sys/devices/platform/drivers/amd-isp4",
+    )
+    def test_check_isp4_multiple_devices(self, _mock_readlink, mock_path_exists):
+        """Test check_isp4 with multiple ISP4 camera devices"""
+        mock_path_exists.return_value = True
+        self.mock_pyudev.list_devices.return_value = [
+            MagicMock(sys_path="/sys/devices/acpi/OMNI5C10:00", sys_name="OMNI5C10:00"),
+            MagicMock(sys_path="/sys/devices/acpi/OMNI5C10:01", sys_name="OMNI5C10:01"),
+        ]
+        result = self.validator.check_isp4()
+        self.assertTrue(result)
+        self.mock_db.record_prereq.assert_any_call(
+            "ISP4 platform camera driver 'amd-isp4' bound to OMNI5C10:00", "✅"
+        )
+        self.mock_db.record_prereq.assert_any_call(
+            "ISP4 platform camera driver 'amd-isp4' bound to OMNI5C10:01", "✅"
+        )
+
+    @patch("amd_debug.prerequisites.os.path.exists")
+    def test_check_isp4_device_not_starting_with_omni5c10(self, mock_path_exists):
+        """Test check_isp4 when ACPI devices don't match OMNI5C10 pattern"""
+        mock_path_exists.return_value = True
+        self.mock_pyudev.list_devices.return_value = [
+            MagicMock(sys_path="/sys/devices/acpi/OTHER:00", sys_name="OTHER:00")
+        ]
+        result = self.validator.check_isp4()
+        self.assertTrue(result)
+        self.mock_db.record_prereq.assert_not_called()