amd-debug-tools 0.2.7__py3-none-any.whl → 0.2.9__py3-none-any.whl

amd_debug_tools-0.2.9.dist-info/METADATA

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: amd-debug-tools
+Version: 0.2.9
+Summary: debug tools for AMD systems
+Author-email: Mario Limonciello <superm1@kernel.org>
+License-Expression: MIT
+Project-URL: Homepage, https://web.git.kernel.org/pub/scm/linux/kernel/git/superm1/amd-debug-tools.git/
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: dbus-fast
+Requires-Dist: pyudev
+Requires-Dist: packaging
+Requires-Dist: pandas
+Requires-Dist: jinja2
+Requires-Dist: tabulate
+Requires-Dist: seaborn
+Requires-Dist: cysystemd
+Requires-Dist: Jinja2
+Requires-Dist: matplotlib
+Requires-Dist: seaborn
+Dynamic: license-file
+
+# Helpful tools for debugging AMD Zen systems
+[![codecov](https://codecov.io/github/superm1/amd-debug-tools/graph/badge.svg?token=Z9WTBZADGT)](https://codecov.io/github/superm1/amd-debug-tools)
+[![PyPI](https://img.shields.io/pypi/v/amd-debug-tools.svg)](https://pypi.org/project/amd-debug-tools/)
+
+This repository hosts open tools that are useful for debugging issues on AMD systems.
+
+## Installation
+### Distro (Arch)
+`amd-debug-tools` has been [packaged for Arch Linux](https://archlinux.org/packages/extra/any/amd-debug-tools/) (and derivatives). You can install it using:
+
+    pacman -Sy amd-debug-tools
+
+### Using a python wheel (Generic)
+It is suggested to install tools in a virtual environment either using
+`pipx` or `python3 -m venv`.
+
+#### From PyPI
+`amd-debug-tools` is distributed as a python wheel, which is a
+binary package format for Python. To install from PyPI, run the following
+command:
+
+    pipx install amd-debug-tools
+
+### From source
+To build the package from source, you will need to the `python3-build`
+package natively installed by your distribution package manager. Then you
+can generate and install a wheel by running the following commands:
+
+    python3 -m build
+    pipx install dist/amd-debug-tools-*.whl
+
+### Ensuring path
+If you have not used a `pipx` environment before, you may need to run the following command
+to set up the environment:
+
+    pipx ensurepath
+
+This will add the `pipx` environment to your path.
+
+## Running in-tree
+Documentation about running directly from a git checkout is available [here](https://github.com/superm1/amd-debug-tools/blob/master/docs/in-tree.md).
+
+## Tools
+
+Each tool has its own individual documentation page:
+* [amd-s2idle](https://github.com/superm1/amd-debug-tools/blob/master/docs/amd-s2idle.md)
+* [amd-bios](https://github.com/superm1/amd-debug-tools/blob/master/docs/amd-bios.md)
+* [amd-pstate](https://github.com/superm1/amd-debug-tools/blob/master/docs/amd-pstate.md)
+* [amd-ttm](https://github.com/superm1/amd-debug-tools/blob/master/docs/amd-ttm.md)
+

amd_debug_tools-0.2.9.dist-info/RECORD

@@ -0,0 +1,47 @@
+launcher.py,sha256=M8kT9DtyZoQgZaKWDbSBu4jsS6tZF1gWko3sovNVyag,947
+test_acpi.py,sha256=wtS43Rz95h7YEEJBeFa6Mswaeo4syBZrw4hY8i0YbJY,3117
+test_batteries.py,sha256=nN5pfP5El7Whypq3HHEpW8bufdf5EWSTVGbayfNQYP4,3360
+test_bios.py,sha256=x_KLmQqGEbQhTugyWCHGXjGp2H1dCdhRz0kgw2Big8w,9276
+test_common.py,sha256=qOCouXyO-dhY_x_L8kyNyuP_c0bhHhlqPoc084_F6Xg,20757
+test_database.py,sha256=HAC4M4dyZBxskNFMfZn2kro6uT2-j0exjnto8-0OOnk,10042
+test_display.py,sha256=awC1-OEPG1aV34BH-MzrOWtAHHPfhCmnKRetas4AGNE,5813
+test_failures.py,sha256=H1UxXeVjhJs9-j9yas4vwAha676GX1Es7Kz8RN2B590,6845
+test_installer.py,sha256=tZpGUOY4ACgXU-cs1Z5RHSPY5INa3HhLmmuB2H4QrOc,10222
+test_kernel.py,sha256=2EXrLht5ZWdT4N5pb_F3zqZl9NEghjnDpcMGCMw3obI,7917
+test_launcher.py,sha256=8g8CBTvLX64Us4RmHtRPSdpV5E2kQFaudBl7VIsxLhE,1733
+test_prerequisites.py,sha256=SJk9y5zXdBmsNbtPMbBOHzkFsnuQF0j3BS6tdZ3ccTo,95944
+test_pstate.py,sha256=a9oAJ9-LANX32XNQhplz6Y75VNYc__QqoSBKIrwvANg,6058
+test_s2idle.py,sha256=FxsyujgX9Px3m56VzHNeA8yMTHmJiRLWxYt-fh1m5gw,33585
+test_sleep_report.py,sha256=ANuxYi_C1oSKAi4xUU2wBu4SwJtcZA7VPpazBe3_WUQ,6922
+test_ttm.py,sha256=QrCdRodQ_CD3nyDqKodb6yR158mgE0iIM5f1fV1Axu8,10515
+test_validator.py,sha256=bfFFB2V3hrZtxTruwrvcUyZjoh-dcDa2TPt-l6pAfTA,36476
+test_wake.py,sha256=6zi5GVFHQKU1sTWw3O5-aGriB9uu5713QLn4l2wjhpM,7152
+amd_debug/__init__.py,sha256=0VsbaXBas5gcwZ6vBbJg20-8qHNDo_BKFYzdb1Agfq4,1252
+amd_debug/acpi.py,sha256=_lnnAwTnAb4g8AW2BXwF45UY-WUmXIDpthhFLE5ENGo,3142
+amd_debug/battery.py,sha256=qd6bo1ssAPnEfPY2HCmJfFcwgYADrfoJkxFQWQyxKlU,3103
+amd_debug/bios.py,sha256=3dfE5yVoW0aZUN5osGKOtYF-RLOzUcH3ryA4yHZZoJA,4022
+amd_debug/common.py,sha256=OR0rCFkWWoGlRIdsPdJ0hBr9iQ_vXcjIAL3poZ9BTj8,12606
+amd_debug/database.py,sha256=kkl1iKIvekpVMc8M0xzo0iX3rc4yDaREyjCuLSnGuCk,11052
+amd_debug/display.py,sha256=XATsKPh2QDoJAbm5mAE1YNFdVuFEq3yS3dffEasEq8c,922
+amd_debug/failures.py,sha256=Sa2GEwhn8PImcIbZkHEPA2oCbuayTx9JheLaXBscz4I,23280
+amd_debug/installer.py,sha256=JNlqGWNgF5pYxzy2VJiphmP4gXg99F0f4TBy2xk1Tpg,14275
+amd_debug/kernel.py,sha256=w2y4syIMPd4OYXhPYrEmCDYnMBg9K16tK6iNwfzRVWU,11718
+amd_debug/prerequisites.py,sha256=f55y-DUCMQHPWSQRjJcP-J8qvGaNKbXUIBbyhOzUB1U,52632
+amd_debug/pstate.py,sha256=fGA-pKS1mzIrOa9fIqd_q3Y9DvMhuWmInq5GPAGc21k,9564
+amd_debug/s2idle-hook,sha256=LLiaqPtGd0qetu9n6EYxKHZaIdHpVQDONdOuSc0pfFg,1695
+amd_debug/s2idle.py,sha256=tj1_5g2adTScWfgaFAlH4NVjAse2jSCgOhpaOeWBYzk,13381
+amd_debug/sleep_report.py,sha256=JQDtd_y-78gXQN5o7O7h-hKosEOWZeTmnZBSepdeCEE,17298
+amd_debug/ttm.py,sha256=KoCY35jnU7Q2ZB0SO1nQmC_RsiCFwTWUzVmRbyUg0Lw,4660
+amd_debug/validator.py,sha256=OEpaIAnkZg_GF_MeU48YNj8Wcj45vEgT7edqgflsChM,34151
+amd_debug/wake.py,sha256=x33z60sOaukTlZTABKpvLJZVRk-kIe_o8XljtV3Q38Q,3917
+amd_debug/bash/amd-s2idle,sha256=g_cle1ElCJpwE4wcLezL6y-BdasDKTnNMhrtzKLE9ks,1142
+amd_debug/templates/html,sha256=JfGhpmHIB2C2GItdGI1kuC8uayqEVgrpQvAWAj35eZ4,14580
+amd_debug/templates/md,sha256=r8X2aehnH2gzj0WHYTZ5K9wAqC5y39i_3nkDORSC0uM,787
+amd_debug/templates/stdout,sha256=hyoOJ96K2dJfnWRWhyCuariLKbEHXvs9mstV_g5aMdI,469
+amd_debug/templates/txt,sha256=nNdsvbPFOhGdL7VA-_4k5aN3nB-6ouGQt6AsWst7T3w,649
+amd_debug_tools-0.2.9.dist-info/licenses/LICENSE,sha256=RBlZI6r3MRGzymI2VDX2iW__D2APDbMhu_Xg5t6BWeo,1066
+amd_debug_tools-0.2.9.dist-info/METADATA,sha256=4rIp2I7Oipo1o3hCRtw4CoCf3IliJjyJcUV6SnYhkrE,2772
+amd_debug_tools-0.2.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+amd_debug_tools-0.2.9.dist-info/entry_points.txt,sha256=hIskDz6k0_6q1qpqWCpVFsca_djxAqkLrUAwzAyEGuE,144
+amd_debug_tools-0.2.9.dist-info/top_level.txt,sha256=VvGkkY5I7O3HoLNrc2VfgjCA-to3PUjnnKd7juONaFw,243
+amd_debug_tools-0.2.9.dist-info/RECORD,,

test_common.py

@@ -4,13 +4,16 @@
 """
 This module contains unit tests for the common functions in the amd-debug-tools package.
 """
-from unittest.mock import patch, mock_open, call
+from unittest.mock import patch, mock_open, call, Mock
 
+import asyncio
+import builtins
 import logging
 import tempfile
 import unittest
 import os
 from platform import uname_result
+import sys
 
 
 from amd_debug.common import (
@@ -49,6 +52,7 @@ color_dict = {
     "○": Colors.OK,
     "💤": Colors.OK,
     "💯": Colors.UNDERLINE,
+    "🚫": Colors.UNDERLINE,
     "🗣️": Colors.HEADER,
 }
 
@@ -473,63 +477,84 @@ class TestCommon(unittest.TestCase):
         self.assertAlmostEqual(get_system_mem(), expected_gb)
         mock_file.assert_called_once_with("/proc/meminfo", "r", encoding="utf-8")
 
-    @patch("builtins.open", new_callable=mock_open, read_data="NoMemHere: 1234\n")
-    @patch("os.path.join", return_value="/proc/meminfo")
-    def test_get_system_mem_missing(self, _mock_join, _mock_file):
-        """Test get_system_mem raises ValueError if MemTotal is missing"""
-        with self.assertRaises(ValueError):
-            get_system_mem()
-
-    @patch("amd_debug.common.fatal_error")
-    def test_reboot_importerror(self, mock_fatal_error):
-        """Test reboot handles ImportError"""
-        with patch.dict("sys.modules", {"dbus": None}):
-            reboot()
-            mock_fatal_error.assert_called_once_with("Missing dbus")
-
-    @patch("amd_debug.common.fatal_error")
-    def test_reboot_dbus_exception(self, mock_fatal_error):
-        """Test reboot handles dbus.exceptions.DBusException"""
-
-        class DummyDBusException(Exception):
-            """Dummy exception"""
-
-        class DummyIntf:
-            """Dummy interface"""
+    def test_reboot_dbus_fast_success(self):
+        """Test reboot returns True when reboot_dbus_fast succeeds"""
 
-            def Reboot(self, _arg):  # pylint: disable=invalid-name
-                """Dummy Reboot method"""
-                raise DummyDBusException("fail")
-
-        class DummyObj:  # pylint: disable=too-few-public-methods
-            """Dummy object"""
-
-            def __init__(self):
+        # Create a mock loop that properly handles coroutines
+        def mock_run_until_complete(coro):
+            # Consume the coroutine to prevent the warning
+            try:
+                # Close the coroutine to prevent the warning
+                coro.close()
+            except (AttributeError, RuntimeError):
                 pass
+            return True
 
-        class DummyBus:  # pylint: disable=too-few-public-methods
-            """Dummy bus"""
+        mock_loop = Mock()
+        mock_loop.run_until_complete.side_effect = mock_run_until_complete
 
-            def get_object(self, *args, **kwargs):
-                """Dummy get_object method"""
-                return DummyObj()
+        with patch("amd_debug.common.asyncio.get_event_loop", return_value=mock_loop):
+            result = reboot()
+            self.assertTrue(result)
+            mock_loop.run_until_complete.assert_called_once()
 
-        class DummyDBus:
-            """Dummy dbus"""
+    @patch("asyncio.get_event_loop")
+    def test_reboot_dbus_fast_failure_and_dbus_success(self, mock_get_event_loop):
+        """Test reboot falls back to reboot_dbus when reboot_dbus_fast fails"""
 
-            class exceptions:  # pylint: disable=invalid-name
-                """Dummy exceptions"""
+        # Create a mock loop that properly handles coroutines
+        def mock_run_until_complete(coro):
+            # Consume the coroutine to prevent the warning
+            try:
+                coro.close()
+            except (AttributeError, RuntimeError):
+                pass
+            return False
+
+        mock_loop = Mock()
+        mock_loop.run_until_complete.side_effect = mock_run_until_complete
+        mock_get_event_loop.return_value = mock_loop
+
+        # Mock the dbus module to avoid ImportError in CI
+        mock_dbus = Mock()
+        mock_bus = Mock()
+        mock_obj = Mock()
+        mock_intf = Mock()
+
+        mock_dbus.SystemBus.return_value = mock_bus
+        mock_bus.get_object.return_value = mock_obj
+        mock_obj.get_interface.return_value = mock_intf
+        mock_dbus.Interface = Mock(return_value=mock_intf)
+
+        with patch.dict("sys.modules", {"dbus": mock_dbus}):
+            result = reboot()
+            self.assertTrue(result)
+
+    @patch("asyncio.get_event_loop")
+    def test_reboot_dbus_fast_failure_and_dbus_failure(self, mock_get_event_loop):
+        """Test reboot returns False when both reboot_dbus_fast and reboot_dbus fail"""
+
+        # Create a mock loop that properly handles coroutines
+        def mock_run_until_complete(coro):
+            # Consume the coroutine to prevent the warning
+            try:
+                coro.close()
+            except (AttributeError, RuntimeError):
+                pass
+            return False
 
-                DBusException = DummyDBusException
+        mock_loop = Mock()
+        mock_loop.run_until_complete.side_effect = mock_run_until_complete
+        mock_get_event_loop.return_value = mock_loop
 
-            def SystemBus(self):  # pylint: disable=invalid-name
-                """Dummy SystemBus method"""
-                return DummyBus()
+        # Mock the import to raise ImportError when dbus is imported
+        original_import = builtins.__import__
 
-            def Interface(self, _obj, _name):  # pylint: disable=invalid-name
-                """Dummy Interface method"""
-                return DummyIntf()
+        def mock_import(name, *args, **kwargs):
+            if name == "dbus":
+                raise ImportError("No module named 'dbus'")
+            return original_import(name, *args, **kwargs)
 
-        with patch.dict("sys.modules", {"dbus": DummyDBus()}):
-            reboot()
-            self.assertTrue(mock_fatal_error.called)
+        with patch("builtins.__import__", side_effect=mock_import):
+            result = reboot()
+            self.assertFalse(result)

test_database.py

@@ -255,7 +255,7 @@ class TestSleepDatabase(unittest.TestCase):
     def test_get_last_prereq_ts_no_data(self):
         """Test getting the last prereq timestamp when no data exists"""
         result = self.db.get_last_prereq_ts()
-        self.assertIsNone(result)
+        self.assertEqual(result, 0)
 
     def test_report_cycle_data(self):
         """Test reporting cycle data"""

test_display.py

@@ -40,7 +40,7 @@ class TestDisplay(unittest.TestCase):
         display = Display()
 
         # Verify the EDID paths are correctly set
-        expected_edid = {"card0": "/sys/devices/card0/edid"}
+        expected_edid = ["/sys/devices/card0/edid"]
         self.assertEqual(display.get_edid(), expected_edid)
         mock_context.assert_called_once()
 
@@ -54,7 +54,7 @@ class TestDisplay(unittest.TestCase):
         display = Display()
 
         # Verify the EDID dictionary is empty
-        self.assertEqual(display.get_edid(), {})
+        self.assertEqual(display.get_edid(), [])
 
     @patch("amd_debug.display.Context")
     def test_device_without_card(self, mock_context):
@@ -70,7 +70,7 @@ class TestDisplay(unittest.TestCase):
         display = Display()
 
         # Verify the EDID dictionary is empty
-        self.assertEqual(display.get_edid(), {})
+        self.assertEqual(display.get_edid(), [])
 
     @patch("amd_debug.display.Context")
     @patch("amd_debug.display.read_file")
@@ -94,7 +94,7 @@ class TestDisplay(unittest.TestCase):
         display = Display()
 
         # Verify the EDID dictionary is empty
-        self.assertEqual(display.get_edid(), {})
+        self.assertEqual(display.get_edid(), [])
 
     @patch("amd_debug.display.Context")
     @patch("amd_debug.display.read_file")
@@ -116,7 +116,7 @@ class TestDisplay(unittest.TestCase):
         display = Display()
 
         # Verify the EDID dictionary is empty
-        self.assertEqual(display.get_edid(), {})
+        self.assertEqual(display.get_edid(), [])
 
     @patch("amd_debug.display.Context")
     @patch("amd_debug.display.read_file")
@@ -140,4 +140,4 @@ class TestDisplay(unittest.TestCase):
         display = Display()
 
         # Verify the EDID dictionary is empty
-        self.assertEqual(display.get_edid(), {})
+        self.assertEqual(display.get_edid(), [])

test_installer.py

@@ -231,7 +231,7 @@ class TestInstaller(unittest.TestCase):
         self.installer.set_requirements("edid-decode")
         ret = self.installer.install_dependencies()
         _mock_check_call.assert_called_once_with(
-            ["dnf", "install", "-y", "libdisplay-info"]
+            ["dnf", "install", "-y", "libdisplay-info-tools"]
         )
         self.assertTrue(ret)
 

test_prerequisites.py

@@ -2035,3 +2035,180 @@ class TestPrerequisiteValidator(unittest.TestCase):
         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("builtins.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)
+        )

test_validator.py

@@ -264,7 +264,7 @@ class TestValidator(unittest.TestCase):
 
         # Validate debug messages
         mock_record_debug.assert_called_once_with(
-            "Woke up from input source /sys/devices/input0 (3->5)", "💤"
+            "Woke up from input source /sys/devices/input0 (3->5)"
         )
 
         # Stop patches
@@ -557,7 +557,7 @@ class TestValidator(unittest.TestCase):
             # Set attributes for record_cycle
             self.validator.requested_duration = 60
             self.validator.active_gpios = ["GPIO1"]
-            self.validator.wakeup_irqs = [5]
+            self.validator.wakeup_irqs = ["5"]
             self.validator.kernel_duration = 1.5
             self.validator.hw_sleep_duration = 1.0
 
@@ -580,10 +580,10 @@ class TestValidator(unittest.TestCase):
             # Assert record_cycle was called with correct arguments
             mock_record_cycle.assert_called_once_with(
                 self.validator.requested_duration,
-                self.validator.active_gpios,
-                self.validator.wakeup_irqs,
-                self.validator.kernel_duration,
-                self.validator.hw_sleep_duration,
+                ",".join(str(gpio) for gpio in self.validator.active_gpios),
+                ",".join(str(irq) for irq in self.validator.wakeup_irqs),
+                int(self.validator.kernel_duration),
+                int(self.validator.hw_sleep_duration),
             )
 
     def test_program_wakealarm(self):