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

amd_debug/validator.py

@@ -1,4 +1,3 @@
-#!/usr/bin/python3
 # SPDX-License-Identifier: MIT
 
 import glob
@@ -290,13 +289,12 @@ class SleepValidator(AmdTool):
                 sys_name = pnp.sys_name
 
             name = name.replace('"', "")
-            devices.append(f"{name} [{sys_name}]: {wake_en}")
+            devices.append(f"{name}|{sys_name}|{wake_en}")
         devices.sort()
-        self.db.record_debug("Possible wakeup sources:")
+        debug_str = "Wakeup Source|Linux Device|Status\n"
         for dev in devices:
-            # set prefix if last device
-            prefix = "│ " if dev != devices[-1] else "└─"
-            self.db.record_debug(f"{prefix}{dev}")
+            debug_str += f"{dev}\n"
+        self.db.record_debug(debug_str)
 
     def capture_lid(self) -> None:
         """Capture lid state"""
@@ -319,6 +317,9 @@ class SleepValidator(AmdTool):
             actions = read_file(os.path.join(p, "actions"))
             message = f"{Headers.WokeFromIrq} {n} ({chip_name} {hw}-{name} {actions})"
             self.db.record_debug(message)
+            irq = int(n)
+            if irq and irq not in self.wakeup_irqs:
+                self.wakeup_irqs += [irq]
         except OSError:
             pass
         return True
@@ -436,7 +437,6 @@ class SleepValidator(AmdTool):
                 continue
             self.db.record_debug(
                 f"Woke up from input source {device} ({self.wakeup_count[device]}->{count})",
-                "💤",
             )
         self.wakeup_count = wakeup_count
 
@@ -444,11 +444,10 @@ class SleepValidator(AmdTool):
         """Check for hardware sleep state"""
         # try from kernel 6.4's suspend stats interface first because it works
         # even with kernel lockdown
-        if not self.hw_sleep_duration:
-            p = os.path.join("/", "sys", "power", "suspend_stats", "last_hw_sleep")
-            if os.path.exists(p):
-                self.hw_sleep_duration = int(read_file(p)) / 10**6
-        if not self.hw_sleep_duration:
+        p = os.path.join("/", "sys", "power", "suspend_stats", "last_hw_sleep")
+        if os.path.exists(p):
+            self.hw_sleep_duration = int(read_file(p)) / 10**6
+        if not os.path.exists(p) and not self.hw_sleep_duration:
             p = os.path.join("/", "sys", "kernel", "debug", "amd_pmc", "smu_fw_info")
             try:
                 val = read_file(p)
@@ -472,7 +471,7 @@ class SleepValidator(AmdTool):
                 self.db.record_debug(f"HW sleep statistics file {p} is missing")
         if not self.hw_sleep_duration:
             self.db.record_cycle_data("Did not reach hardware sleep state", "❌")
-        return self.hw_sleep_duration
+        return self.hw_sleep_duration > 0
 
     def capture_command_line(self):
         """Capture the kernel command line to debug"""
@@ -546,16 +545,6 @@ class SleepValidator(AmdTool):
 
     def analyze_kernel_log(self):
         """Analyze one of the lines from the kernel log"""
-        self.cycle_count = 0
-        self.upep = False
-        self.upep_microsoft = False
-        self.wakeup_irqs = []
-        self.idle_masks = []
-        self.acpi_errors = []
-        self.active_gpios = []
-        self.notify_devices = []
-        self.page_faults = []
-        self.irq1_workaround = False
         self.kernel_log.process_callback(self._analyze_kernel_log_line)
 
         if self.cycle_count:
@@ -585,7 +574,6 @@ class SleepValidator(AmdTool):
                     if bit_changed & BIT(bit):
                         self.db.record_debug(
                             f"Idle mask bit {bit} (0x{BIT(bit):x}) changed during suspend",
-                            "○",
                         )
         if self.upep:
             if self.upep_microsoft:
@@ -646,9 +634,20 @@ class SleepValidator(AmdTool):
 
     def post(self):
         """Post-process the suspend test results"""
+        self.cycle_count = 0
+        self.upep = False
+        self.upep_microsoft = False
+        self.wakeup_irqs = []
+        self.idle_masks = []
+        self.acpi_errors = []
+        self.active_gpios = []
+        self.notify_devices = []
+        self.page_faults = []
+        self.irq1_workaround = False
+
         checks = [
-            self.analyze_kernel_log,
             self.capture_wakeup_irq_data,
+            self.analyze_kernel_log,
             self.check_gpes,
             self.capture_lid,
             self.check_rtc_cmos,
@@ -663,10 +662,10 @@ class SleepValidator(AmdTool):
             check()
         self.db.record_cycle(
             self.requested_duration,
-            self.active_gpios,
-            self.wakeup_irqs,
-            self.kernel_duration,
-            self.hw_sleep_duration,
+            ",".join(str(gpio) for gpio in self.active_gpios),
+            ",".join(str(irq) for irq in self.wakeup_irqs),
+            int(self.kernel_duration),
+            int(self.hw_sleep_duration),
         )
 
     def prep(self):
@@ -705,6 +704,22 @@ class SleepValidator(AmdTool):
         else:
             print_color("No RTC device found, please manually wake system", "🚦")
 
+    def toggle_nvidia(self, value):
+        """Write to the NVIDIA suspend interface"""
+        p = os.path.join("/", "proc", "driver", "nvidia", "suspend")
+        if not os.path.exists(p):
+            return True
+        fd = os.open(p, os.O_WRONLY | os.O_SYNC)
+        try:
+            os.write(fd, value)
+        except OSError as e:
+            self.db.record_cycle_data(f"Failed to set {value} in NVIDIA {e}", "❌")
+            return False
+        finally:
+            os.close(fd)
+        self.db.record_debug(f"Wrote {value} to NVIDIA driver")
+        return True
+
     @pm_debugging
     def suspend_system(self):
         """Suspend the system using the dbus or sysfs interface"""
@@ -746,17 +761,23 @@ class SleepValidator(AmdTool):
                 self.db.record_cycle_data("Missing dbus", "❌")
                 return False
         else:
+            if not self.toggle_nvidia(b"suspend"):
+                return False
             old = get_wakeup_count()
+            p = os.path.join("/", "sys", "power", "state")
+            fd = os.open(p, os.O_WRONLY | os.O_SYNC)
             try:
-                p = os.path.join("/", "sys", "power", "state")
-                with open(p, "w", encoding="utf-8") as w:
-                    w.write("mem")
+                os.write(fd, b"mem")
             except OSError as e:
                 new = get_wakeup_count()
                 self.db.record_cycle_data(
                     f"Failed to set suspend state ({old} -> {new}): {e}", "❌"
                 )
                 return False
+            finally:
+                os.close(fd)
+            if not self.toggle_nvidia(b"resume"):
+                return False
             return True
 
     def unlock_session(self):
@@ -780,6 +801,7 @@ class SleepValidator(AmdTool):
 
     def run(self, duration, count, wait, rand, logind):
         """Run the suspend test"""
+        min_duration = 4
         if not count:
             return True
 
@@ -787,8 +809,13 @@ class SleepValidator(AmdTool):
             self.logind = True
 
         if rand:
+            if duration <= min_duration:
+                print_color(f"Invalid max duration {duration}", "❌")
+                self.db.sync()
+                self.report_cycle()
+                return False
             print_color(
-                f"Running {count} cycle random test with max duration of {duration}s and a max wait of {wait}s",
+                f"Running {count} cycle random test with min duration of {min_duration}s, max duration of {duration}s and a max wait of {wait}s",
                 "🗣️",
             )
         elif count > 1:
@@ -799,7 +826,7 @@ class SleepValidator(AmdTool):
             )
         for i in range(1, count + 1):
             if rand:
-                self.requested_duration = random.randint(1, duration)
+                self.requested_duration = random.randint(min_duration, duration)
                 requested_wait = random.randint(1, wait)
             else:
                 self.requested_duration = duration

amd_debug/wake.py

@@ -1,4 +1,3 @@
-#!/usr/bin/python3
 # SPDX-License-Identifier: MIT
 
 import os

amd_debug_tools-0.2.12.dist-info/METADATA

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: amd-debug-tools
+Version: 0.2.12
+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.12.dist-info/RECORD

@@ -0,0 +1,47 @@
+launcher.py,sha256=M8kT9DtyZoQgZaKWDbSBu4jsS6tZF1gWko3sovNVyag,947
+test_acpi.py,sha256=1w5WjuTimgd6ru8FUi-dhOoX-7FsiVsAC42E6RZBcls,3125
+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=QP0lXVPCOG-UOGwEWFPIV9-fnfkglsF8NEjXP7P6HEs,12691
+test_kernel.py,sha256=QsggZOLEt78ID_l6JsHSffH4xzQaBSzSS0uCLaOxpAc,7949
+test_launcher.py,sha256=8g8CBTvLX64Us4RmHtRPSdpV5E2kQFaudBl7VIsxLhE,1733
+test_prerequisites.py,sha256=9OzUI3vZZmAu0yKBLjHRkjeJZufsi7AR8plDtN2ZBco,110642
+test_pstate.py,sha256=a9oAJ9-LANX32XNQhplz6Y75VNYc__QqoSBKIrwvANg,6058
+test_s2idle.py,sha256=BrNj4Bxov4LxpheKAeajCH3tJA_iW-Muy0vW2PRkoEk,34018
+test_sleep_report.py,sha256=ANuxYi_C1oSKAi4xUU2wBu4SwJtcZA7VPpazBe3_WUQ,6922
+test_ttm.py,sha256=QrCdRodQ_CD3nyDqKodb6yR158mgE0iIM5f1fV1Axu8,10515
+test_validator.py,sha256=8uhhP_Piwe4sp0HE-ZthDJWG-QdNxWmE2ICWtcGsA1w,36498
+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=sewb8L4D-p8HmbTIZVSlwbHdHJ3nO2zAG9otcwHpsqs,24382
+amd_debug/installer.py,sha256=BEsjl_sh8cUsbPsnGfoq3BntkDwJdMgsKmR54dzxkKA,14288
+amd_debug/kernel.py,sha256=w2y4syIMPd4OYXhPYrEmCDYnMBg9K16tK6iNwfzRVWU,11718
+amd_debug/prerequisites.py,sha256=tI_D_iyqNBGb3OmdvNfY5X36zen9Q6klYSm-Oi-ZHIY,54842
+amd_debug/pstate.py,sha256=fGA-pKS1mzIrOa9fIqd_q3Y9DvMhuWmInq5GPAGc21k,9564
+amd_debug/s2idle-hook,sha256=LLiaqPtGd0qetu9n6EYxKHZaIdHpVQDONdOuSc0pfFg,1695
+amd_debug/s2idle.py,sha256=73BngSl14f8MWiD8Rp4-QKSzu5-a3XxotDArJ_Y7c4E,13279
+amd_debug/sleep_report.py,sha256=JQDtd_y-78gXQN5o7O7h-hKosEOWZeTmnZBSepdeCEE,17298
+amd_debug/ttm.py,sha256=KoCY35jnU7Q2ZB0SO1nQmC_RsiCFwTWUzVmRbyUg0Lw,4660
+amd_debug/validator.py,sha256=VygKoP30psFkLIrZUUCdvauD_xB43867h2BnI-o8ODE,34271
+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.12.dist-info/licenses/LICENSE,sha256=RBlZI6r3MRGzymI2VDX2iW__D2APDbMhu_Xg5t6BWeo,1066
+amd_debug_tools-0.2.12.dist-info/METADATA,sha256=-HT90JLmuyiEcusEKIvBj1rTQouT28VMGAJOYMHsujg,2773
+amd_debug_tools-0.2.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+amd_debug_tools-0.2.12.dist-info/entry_points.txt,sha256=hIskDz6k0_6q1qpqWCpVFsca_djxAqkLrUAwzAyEGuE,144
+amd_debug_tools-0.2.12.dist-info/top_level.txt,sha256=VvGkkY5I7O3HoLNrc2VfgjCA-to3PUjnnKd7juONaFw,243
+amd_debug_tools-0.2.12.dist-info/RECORD,,

{amd_debug_tools-0.2.2.dist-info → amd_debug_tools-0.2.12.dist-info}/entry_points.txt

@@ -2,3 +2,4 @@
 amd-bios = amd_debug:amd_bios
 amd-pstate = amd_debug:amd_pstate
 amd-s2idle = amd_debug:amd_s2idle
+amd-ttm = amd_debug:amd_ttm

{amd_debug_tools-0.2.2.dist-info → amd_debug_tools-0.2.12.dist-info}/top_level.txt

@@ -14,5 +14,6 @@ test_prerequisites
 test_pstate
 test_s2idle
 test_sleep_report
+test_ttm
 test_validator
 test_wake

launcher.py

@@ -28,7 +28,6 @@ def main():
             f"Missing dependency: {e}\n"
             f"Run ./install_deps.py to install dependencies."
         )
-        return False
 
 
 if __name__ == "__main__":

test_acpi.py

@@ -79,7 +79,7 @@ class TestAcpi(unittest.TestCase):
     def test_acpica_trace_no_acpi_debug(self):
         """Test AcpicaTracer class when ACPI tracing is not supported"""
         with patch("os.path.exists", return_value=False), patch(
-            "builtins.open", mock_open(read_data="foo")
+            "amd_debug.common.open", mock_open(read_data="foo")
         ):
             tracer = AcpicaTracer()
             self.assertFalse(tracer.supported)

test_bios.py

@@ -33,8 +33,14 @@ class TestAmdBios(unittest.TestCase):
     @patch("amd_debug.bios.minimum_kernel")
     @patch("amd_debug.bios.AcpicaTracer")
     @patch("amd_debug.bios.print_color")
+    @patch("subprocess.run")
     def test_set_tracing_enable(
-        self, _mock_print, mock_acpica_tracer, mock_minimum_kernel, mock_relaunch_sudo
+        self,
+        _mock_run,
+        _mock_print,
+        mock_acpica_tracer,
+        mock_minimum_kernel,
+        mock_relaunch_sudo,
     ):
         """Test enabling tracing"""
         mock_minimum_kernel.return_value = True
@@ -53,8 +59,14 @@ class TestAmdBios(unittest.TestCase):
     @patch("amd_debug.bios.minimum_kernel")
     @patch("amd_debug.bios.AcpicaTracer")
     @patch("amd_debug.bios.print_color")
+    @patch("subprocess.run")
     def test_set_tracing_disable(
-        self, _mock_print, mock_acpica_tracer, mock_minimum_kernel, mock_relaunch_sudo
+        self,
+        _mock_run,
+        _mock_print,
+        mock_acpica_tracer,
+        mock_minimum_kernel,
+        mock_relaunch_sudo,
     ):
         """Test disabling tracing"""
         mock_minimum_kernel.return_value = True
@@ -71,7 +83,10 @@ class TestAmdBios(unittest.TestCase):
 
     @patch("amd_debug.bios.sscanf_bios_args")
     @patch("amd_debug.bios.print_color")
-    def test_analyze_kernel_log_line(self, mock_print_color, mock_sscanf_bios_args):
+    @patch("subprocess.run")
+    def test_analyze_kernel_log_line(
+        self, _mock_run, mock_print_color, mock_sscanf_bios_args
+    ):
         """Test analyzing kernel log line"""
         mock_sscanf_bios_args.return_value = "BIOS argument found"
 
@@ -85,8 +100,9 @@ class TestAmdBios(unittest.TestCase):
 
     @patch("amd_debug.bios.sscanf_bios_args")
     @patch("amd_debug.bios.print_color")
+    @patch("subprocess.run")
     def test_analyze_kernel_log_line_no_bios_args(
-        self, mock_print_color, mock_sscanf_bios_args
+        self, _mock_run, mock_print_color, mock_sscanf_bios_args
     ):
         """Test analyzing kernel log line with no BIOS arguments"""
         mock_sscanf_bios_args.return_value = None
@@ -140,12 +156,12 @@ class TestAmdBios(unittest.TestCase):
         self.assertFalse(args.enable)
         self.assertTrue(args.disable)
 
-    @patch("sys.argv", ["bios.py", "version"])
+    @patch("sys.argv", ["bios.py", "--version"])
     def test_parse_args_version_command(self):
         """Test parse_args with version command"""
 
         args = parse_args()
-        self.assertEqual(args.command, "version")
+        self.assertTrue(args.version)
 
     @patch("sys.argv", ["bios.py"])
     @patch("argparse.ArgumentParser.print_help")
@@ -194,7 +210,7 @@ class TestAmdBios(unittest.TestCase):
         mock_amd_bios.assert_called_once_with(None, True)
         mock_app.set_tracing.assert_called_once_with(True)
         mock_show_log_info.assert_called_once()
-        self.assertTrue(result)
+        self.assertIsNone(result)
 
     @patch("amd_debug.bios.AmdBios")
     @patch("amd_debug.bios.parse_args")
@@ -217,7 +233,7 @@ class TestAmdBios(unittest.TestCase):
         mock_amd_bios.assert_called_once_with("test.log", True)
         mock_app.run.assert_called_once()
         mock_show_log_info.assert_called_once()
-        self.assertTrue(result)
+        self.assertIsNone(result)
 
     @patch("amd_debug.bios.parse_args")
     @patch("amd_debug.bios.version")
@@ -227,7 +243,7 @@ class TestAmdBios(unittest.TestCase):
         self, _mock_print, mock_show_log_info, mock_version, mock_parse_args
     ):
         """Test main function with version command"""
-        mock_parse_args.return_value = argparse.Namespace(command="version")
+        mock_parse_args.return_value = argparse.Namespace(version=True, command=None)
         mock_version.return_value = "1.0.0"
 
         result = main()
@@ -235,16 +251,18 @@ class TestAmdBios(unittest.TestCase):
         mock_parse_args.assert_called_once()
         mock_version.assert_called_once()
         mock_show_log_info.assert_called_once()
-        self.assertEqual(result, False)
+        self.assertEqual(result, 1)
 
     @patch("amd_debug.bios.parse_args")
     @patch("amd_debug.bios.show_log_info")
     def test_main_invalid_command(self, mock_show_log_info, mock_parse_args):
         """Test main function with an invalid command"""
-        mock_parse_args.return_value = argparse.Namespace(command="invalid")
+        mock_parse_args.return_value = argparse.Namespace(
+            version=False, command="invalid"
+        )
 
         result = main()
 
         mock_parse_args.assert_called_once()
         mock_show_log_info.assert_called_once()
-        self.assertFalse(result)
+        self.assertEqual(result, 1)

test_common.py

@@ -4,17 +4,21 @@
 """
 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 (
     apply_prefix_wrapper,
+    bytes_to_gb,
     Colors,
     convert_string_to_bool,
     colorize_choices,
@@ -22,12 +26,15 @@ from amd_debug.common import (
     compare_file,
     find_ip_version,
     fatal_error,
+    gb_to_pages,
     get_distro,
     get_log_priority,
     get_pretty_distro,
+    get_system_mem,
     is_root,
     minimum_kernel,
     print_color,
+    reboot,
     run_countdown,
     systemd_in_use,
     running_ssh,
@@ -45,6 +52,7 @@ color_dict = {
     "○": Colors.OK,
     "💤": Colors.OK,
     "💯": Colors.UNDERLINE,
+    "🚫": Colors.UNDERLINE,
     "🗣️": Colors.HEADER,
 }
 
@@ -442,3 +450,111 @@ class TestCommon(unittest.TestCase):
         with patch("sys.exit") as mock_exit:
             convert_string_to_bool("[unclosed_list")
             mock_exit.assert_called_once_with("Invalid entry: [unclosed_list")
+
+    def test_bytes_to_gb(self):
+        """Test bytes_to_gb conversion"""
+        # 4096 bytes should be 4096*4096/(1024*1024*1024) GB
+        self.assertAlmostEqual(bytes_to_gb(1), 4096 / (1024 * 1024 * 1024))
+        self.assertAlmostEqual(bytes_to_gb(0), 0)
+        self.assertAlmostEqual(bytes_to_gb(1024), 1024 * 4096 / (1024 * 1024 * 1024))
+
+    def test_gb_to_pages(self):
+        """Test gb_to_pages conversion"""
+        # 1 GB should be int(1 * (1024*1024*1024) / 4096)
+        self.assertEqual(gb_to_pages(1), int((1024 * 1024 * 1024) / 4096))
+        self.assertEqual(gb_to_pages(0), 0)
+        self.assertEqual(gb_to_pages(2), int(2 * (1024 * 1024 * 1024) / 4096))
+
+    @patch(
+        "builtins.open",
+        new_callable=mock_open,
+        read_data="MemTotal:       16384516 kB\n",
+    )
+    @patch("os.path.join", return_value="/proc/meminfo")
+    def test_get_system_mem_valid(self, _mock_join, mock_file):
+        """Test get_system_mem returns correct value"""
+        expected_gb = 16384516 / (1024 * 1024)
+        self.assertAlmostEqual(get_system_mem(), expected_gb)
+        mock_file.assert_called_once_with("/proc/meminfo", "r", encoding="utf-8")
+
+    def test_reboot_dbus_fast_success(self):
+        """Test reboot returns True when reboot_dbus_fast succeeds"""
+
+        # 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
+
+        mock_loop = Mock()
+        mock_loop.run_until_complete.side_effect = mock_run_until_complete
+
+        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()
+
+    @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"""
+
+        # 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
+
+        mock_loop = Mock()
+        mock_loop.run_until_complete.side_effect = mock_run_until_complete
+        mock_get_event_loop.return_value = mock_loop
+
+        # Mock the import to raise ImportError when dbus is imported
+        original_import = builtins.__import__
+
+        def mock_import(name, *args, **kwargs):
+            if name == "dbus":
+                raise ImportError("No module named 'dbus'")
+            return original_import(name, *args, **kwargs)
+
+        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"""