amd-debug-tools 0.2.3__py3-none-any.whl → 0.2.5__py3-none-any.whl

amd_debug/__init__.py

@@ -42,4 +42,4 @@ def launch_tool(tool_name):
         return tools[tool_name]()
     else:
         print(f"\033[91mUnknown exe: {tool_name}\033[0m")
-        return False
+        return 1

amd_debug/bios.py

@@ -122,7 +122,7 @@ def parse_args():
     return args
 
 
-def main():
+def main() -> None|int:
     """Main function"""
     args = parse_args()
     ret = False
@@ -135,4 +135,6 @@ def main():
     elif args.command == "version":
         print(version())
     show_log_info()
-    return ret
+    if ret is False:
+        return 1
+    return

amd_debug/installer.py

@@ -446,7 +446,7 @@ def parse_args():
     return parser.parse_args()
 
 
-def install_dep_superset() -> bool:
+def install_dep_superset() -> None|int:
     """Install all python supserset dependencies"""
     args = parse_args()
     tool = Installer(tool_debug=args.tool_debug)
@@ -465,4 +465,6 @@ def install_dep_superset() -> bool:
     if ret:
         print_color("All dependencies installed", "✅")
     show_log_info()
-    return ret
+    if ret is False:
+        return 1
+    return

amd_debug/kernel.py

@@ -115,24 +115,16 @@ def sscanf_bios_args(line):
 
             converted_args = []
             arg_index = 0
-            for specifier in format_specifiers:
+            for _specifier in format_specifiers:
                 if arg_index < len(arguments):
                     value = arguments[arg_index]
                     if value == "Unknown":
                         converted_args.append(-1)
-                    elif specifier.lower() == "x":
+                    else:
                         try:
                             converted_args.append(int(value, 16))
                         except ValueError:
                             return None
-                    else:  # Decimal conversion
-                        try:
-                            converted_args.append(int(value))
-                        except ValueError:
-                            try:
-                                converted_args.append(int(value, 16))
-                            except ValueError:
-                                return None
                     arg_index += 1
                 else:
                     break

amd_debug/prerequisites.py

@@ -595,6 +595,9 @@ class PrerequisiteValidator(AmdTool):
                 with open(target, "rb") as r:
                     r.seek(0x70)
                     found = struct.unpack("<I", r.read(4))[0] & BIT(21)
+            except FileNotFoundError:
+                self.db.record_prereq("FADT check unavailable", "🚦")
+                return True
             except PermissionError:
                 self.db.record_prereq("FADT check unavailable", "🚦")
                 return True
@@ -1142,26 +1145,13 @@ class PrerequisiteValidator(AmdTool):
                 found_iommu = True
                 debug_str += f"Found IOMMU {dev.sys_path}\n"
                 break
+
+            # User turned off IOMMU, no problems
             if not found_iommu:
                 self.db.record_prereq("IOMMU disabled", "✅")
                 return True
-            p = os.path.join("/", "sys", "firmware", "acpi", "tables", "IVRS")
-            with open(p, "rb") as f:
-                data = f.read()
-            if len(data) < 40:
-                raise ValueError(
-                    "IVRS table appears too small to contain virtualization info."
-                )
-            virt_info = struct.unpack_from("I", data, 36)[0]
-            debug_str += f"Virtualization info: 0x{virt_info:x}"
-            found_dmar = (virt_info & 0x2) != 0
-            self.db.record_debug(debug_str)
-            if not found_dmar:
-                self.db.record_prereq(
-                    "IOMMU is misconfigured: Pre-boot DMA protection not enabled", "❌"
-                )
-                self.failures += [DMArNotEnabled()]
-                return False
+
+            # Look for MSFT0201 in DSDT/SSDT
             for dev in self.pyudev.list_devices(subsystem="acpi"):
                 if "MSFT0201" in dev.sys_path:
                     found_acpi = True
@@ -1171,13 +1161,39 @@ class PrerequisiteValidator(AmdTool):
                 )
                 self.failures += [MissingIommuACPI("MSFT0201")]
                 return False
-            # check that policy is bound to it
+
+            # Check that policy is bound to it
             for dev in self.pyudev.list_devices(subsystem="platform"):
                 if "MSFT0201" in dev.sys_path:
                     p = os.path.join(dev.sys_path, "iommu")
                     if not os.path.exists(p):
                         self.failures += [MissingIommuPolicy("MSFT0201")]
                         return False
+
+            # Check pre-boot DMA
+            p = os.path.join("/", "sys", "firmware", "acpi", "tables", "IVRS")
+            with open(p, "rb") as f:
+                data = f.read()
+            if len(data) < 40:
+                raise ValueError(
+                    "IVRS table appears too small to contain virtualization info."
+                )
+            virt_info = struct.unpack_from("I", data, 36)[0]
+            debug_str += f"IVRS: Virtualization info: 0x{virt_info:x}\n"
+            found_ivrs_dmar = (virt_info & 0x2) != 0
+
+            # check for MSFT0201 in IVRS (alternative to pre-boot DMA)
+            target_bytes = "MSFT0201".encode("utf-8")
+            found_ivrs_msft0201 = data.find(target_bytes) != -1
+            debug_str += f"IVRS: Found MSFT0201: {found_ivrs_msft0201}"
+
+            self.db.record_debug(debug_str)
+            if not found_ivrs_dmar and not found_ivrs_msft0201:
+                self.db.record_prereq(
+                    "IOMMU is misconfigured: Pre-boot DMA protection not enabled", "❌"
+                )
+                self.failures += [DMArNotEnabled()]
+                return False
             self.db.record_prereq("IOMMU properly configured", "✅")
         return True
 
@@ -1187,6 +1203,8 @@ class PrerequisiteValidator(AmdTool):
             return True
         if self.cpu_model not in [0x74, 0x78]:
             return True
+        if not self.smu_version:
+            return True
         if version.parse(self.smu_version) > version.parse("76.60.0"):
             return True
         if version.parse(self.smu_version) < version.parse("76.18.0"):

amd_debug/pstate.py

@@ -300,15 +300,17 @@ def parse_args():
     return parser.parse_args()
 
 
-def main():
+def main() -> None|int:
     """Main function"""
     args = parse_args()
     ret = False
     if args.command == "version":
         print(version())
-        return True
+        return
     elif args.command == "triage":
         triage = AmdPstateTriage(args.tool_debug)
         ret = triage.run()
     show_log_info()
-    return ret
+    if ret is False:
+        return 1
+    return

amd_debug/s2idle.py

@@ -120,7 +120,7 @@ def prompt_report_arguments(since, until, fname, fmt, report_debug) -> str:
     if report_debug is None:
         inp = (
             input(
-                f"{Headers.ReportDebugDescription} ({colorize_choices(Defaults.boolean_choices, "true")})? "
+                f"{Headers.ReportDebugDescription} ({colorize_choices(Defaults.boolean_choices, 'true')})? "
             )
             .lower()
             .capitalize()
@@ -394,7 +394,7 @@ def parse_args():
     return parser.parse_args()
 
 
-def main():
+def main() -> None|int:
     """Main function"""
     args = parse_args()
     ret = False
@@ -429,8 +429,10 @@ def main():
         )
     elif args.action == "version":
         print(version())
-        return True
+        return
     else:
         sys.exit("no action specified")
     show_log_info()
-    return ret
+    if ret is False:
+        return 1
+    return

amd_debug/validator.py

@@ -443,11 +443,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)

{amd_debug_tools-0.2.3.dist-info → amd_debug_tools-0.2.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amd-debug-tools
-Version: 0.2.3
+Version: 0.2.5
 Summary: debug tools for AMD systems
 Author-email: Mario Limonciello <superm1@kernel.org>
 License-Expression: MIT

{amd_debug_tools-0.2.3.dist-info → amd_debug_tools-0.2.5.dist-info}/RECORD

@@ -1,45 +1,45 @@
-launcher.py,sha256=_Gs0W8tUB2wkTy5Nz4qEzG0VqQcnO7xuIQj0GwV_KbY,968
+launcher.py,sha256=M8kT9DtyZoQgZaKWDbSBu4jsS6tZF1gWko3sovNVyag,947
 test_acpi.py,sha256=wtS43Rz95h7YEEJBeFa6Mswaeo4syBZrw4hY8i0YbJY,3117
 test_batteries.py,sha256=nN5pfP5El7Whypq3HHEpW8bufdf5EWSTVGbayfNQYP4,3360
-test_bios.py,sha256=GBAXE_rXd2G-JE0XJ8AvYcF9Me6LTyQQQ8h0Ib3cpxQ,8981
+test_bios.py,sha256=ZPqI5X0QpEJBNJP-i5gNZzlbOlVSpznH4uv34esSqD8,8984
 test_common.py,sha256=fb16Oilh5ga6VgF-UgBj6azoYzZnPrS7KpECQ3nCwlg,16335
 test_database.py,sha256=q5ZjI5u20f7ki6iCY5o1iPi0YOvPz1_W0LTDraU8mN4,10040
 test_display.py,sha256=hHggv-zBthF1BlwWWSjzAm7BBw1DWcElwil5xAuz87g,5822
 test_failures.py,sha256=H1UxXeVjhJs9-j9yas4vwAha676GX1Es7Kz8RN2B590,6845
 test_installer.py,sha256=oDMCvaKqqAWjTggltacnasQ-s1gyUvXPDcNrCUGnux4,10216
-test_kernel.py,sha256=RW-eLbae02Bhwfu1cegqA1pTj6AS5IqD5lLe-6T0Rjo,7871
-test_launcher.py,sha256=govYHL0Cpj9d5msteV5SfR7Covft31rJuzRkDeytHcY,1461
-test_prerequisites.py,sha256=VXN822W-7ZZHXZkJYH5MeKsDVBC-ttUZggYlcoPjVyM,83335
+test_kernel.py,sha256=xw7zpLcZjiRLWvO7vyHQ03_CjmKd_Np8ULhc-WhUV6A,7872
+test_launcher.py,sha256=80xVbidrbx8ixMt_x5Uvfn7nFnB637nX69yIZTifyuk,1511
+test_prerequisites.py,sha256=5fHtdMSGMf7sjDykIUfOP2h7XOAe-jNhJoZ0Vll5B58,84982
 test_pstate.py,sha256=a9oAJ9-LANX32XNQhplz6Y75VNYc__QqoSBKIrwvANg,6058
-test_s2idle.py,sha256=6NaqGp9VOLr_Tr3KczSvfSo3M882aYEbSvRV9xvUMcA,33534
+test_s2idle.py,sha256=YpFGpH84xvjI9mY6uBSKapa74hZnG8ZwBShXsJXpmyQ,33540
 test_sleep_report.py,sha256=ANuxYi_C1oSKAi4xUU2wBu4SwJtcZA7VPpazBe3_WUQ,6922
 test_validator.py,sha256=-MfrWfhwef_aRqOSD_dJGhH0shsghhtOBgzeijzyLW4,33975
 test_wake.py,sha256=6zi5GVFHQKU1sTWw3O5-aGriB9uu5713QLn4l2wjhpM,7152
-amd_debug/__init__.py,sha256=aOtpIEKGLUStrh0e4qgilHW7HgF4Od-r9pOoZ87NwAM,1105
+amd_debug/__init__.py,sha256=3wZxCDY3KPpfIxMz4vGmp6jUAB2GF4VTK4Xb86vy8c4,1101
 amd_debug/acpi.py,sha256=fkD3Sov8cRT5ryPlakRlT7Z9jiCLT9x_MPWxt3xU_tc,3161
 amd_debug/battery.py,sha256=WN-6ys9PHCZIwg7PdwyBOa62GjBp8WKG0v1YZt5_W5s,3122
-amd_debug/bios.py,sha256=wmPKDsTZeQqsHjWpv-YHdgRNlCtFdzHQ6jJf0H3hjN8,3971
+amd_debug/bios.py,sha256=nVIDYqyyKiIO21nyS8lV-qB3ypBJOSIKIuVYFOVoBuw,4017
 amd_debug/common.py,sha256=H9tIRlRFOMwe0d3f2-vXQeK2rJl5Z1WJzkpQM9ivpOc,10347
 amd_debug/database.py,sha256=GkRg3cmaNceyQ2_hy0MBAlMbnTDPHo2co2o4ObWpnQg,10621
 amd_debug/display.py,sha256=5L9x9tI_UoulHpIvuxuVASRtdXta7UCW_JjTb5StEB0,953
 amd_debug/failures.py,sha256=z4O4Q-akv3xYGssSZFCqE0cDE4P9F_aw1hxil3McoD4,22910
-amd_debug/installer.py,sha256=r6r_nVWv8qYdrqAvnAzQhRiS5unBDOkXsqUfHvFK8uM,14249
-amd_debug/kernel.py,sha256=UAlxlXNuZxtHVtrfCmTp12YombVaUs4mizOxwuXTX2M,12038
-amd_debug/prerequisites.py,sha256=r4_IFTL-1YcPptlt6Nump7iscRx1bBCGF33hqNQB0X0,49867
-amd_debug/pstate.py,sha256=akGdJkIxBp0bx3AeGv6ictNxwv8m0j9vQ2IZB0Jx3dM,9518
+amd_debug/installer.py,sha256=tNWhlfxQEA30guk-fzMvcc237hf_PARVQuHaH3sTp4A,14287
+amd_debug/kernel.py,sha256=HpX-QRh8tgkvqKnExfo2JrYqfcbMY8GNgDrC2VVV0Oc,11638
+amd_debug/prerequisites.py,sha256=E5_VpRd2mHiNYQBf13JqsoA5iiJS13wxcH3RERS_qJw,50502
+amd_debug/pstate.py,sha256=lLRsayKi7KOXZCQ6Zjm2pNaobpjLXcgLHXZ9Zt40Fd4,9559
 amd_debug/s2idle-hook,sha256=LLiaqPtGd0qetu9n6EYxKHZaIdHpVQDONdOuSc0pfFg,1695
-amd_debug/s2idle.py,sha256=Ei5ONnJyHz9aQbstRZYnofhJ_sJOAOZQxLgIuWfvcng,13218
+amd_debug/s2idle.py,sha256=lr1wcuJcpvI5pL2gNHqrc7n5E7EYCztvaAYYFPMlGYk,13259
 amd_debug/sleep_report.py,sha256=hhqu711AKtjeYF2xmGcejyCyyPtmq4-gC_hROUCrC0g,17317
-amd_debug/validator.py,sha256=nZ5UpvvsABw4yTea_pZ8DHaLbSoM5VHz3uvlrdWAb34,33444
+amd_debug/validator.py,sha256=-rPqPnYAM1Vevw7vxIbGNPKo1bCRo48IpCBi3Y72-Cw,33419
 amd_debug/wake.py,sha256=xT8WrFrN6voCmXWo5dsn4mQ7iR2QJxHrrYBd3EREG-Q,3936
 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.3.dist-info/licenses/LICENSE,sha256=RBlZI6r3MRGzymI2VDX2iW__D2APDbMhu_Xg5t6BWeo,1066
-amd_debug_tools-0.2.3.dist-info/METADATA,sha256=-DdxkPvWEXMifkgAjfyNIpleo_rHFPIH8nS6v3AWJTk,6877
-amd_debug_tools-0.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-amd_debug_tools-0.2.3.dist-info/entry_points.txt,sha256=HC11T2up0pPfroAn6Pg5M2jOZXhkWIipToJ1YPTKqu8,116
-amd_debug_tools-0.2.3.dist-info/top_level.txt,sha256=XYjxExbUTEtiIlag_5iQvZSVOC1EIxhKM4NLklReQ0k,234
-amd_debug_tools-0.2.3.dist-info/RECORD,,
+amd_debug_tools-0.2.5.dist-info/licenses/LICENSE,sha256=RBlZI6r3MRGzymI2VDX2iW__D2APDbMhu_Xg5t6BWeo,1066
+amd_debug_tools-0.2.5.dist-info/METADATA,sha256=Dkhw4XQncTgjECNEa3Nk6HCYBzqa5lPAS_IbIli7cvA,6877
+amd_debug_tools-0.2.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+amd_debug_tools-0.2.5.dist-info/entry_points.txt,sha256=HC11T2up0pPfroAn6Pg5M2jOZXhkWIipToJ1YPTKqu8,116
+amd_debug_tools-0.2.5.dist-info/top_level.txt,sha256=XYjxExbUTEtiIlag_5iQvZSVOC1EIxhKM4NLklReQ0k,234
+amd_debug_tools-0.2.5.dist-info/RECORD,,

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_bios.py

@@ -194,7 +194,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 +217,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")
@@ -235,7 +235,7 @@ 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")
@@ -247,4 +247,4 @@ class TestAmdBios(unittest.TestCase):
 
         mock_parse_args.assert_called_once()
         mock_show_log_info.assert_called_once()
-        self.assertFalse(result)
+        self.assertEqual(result, 1)

test_kernel.py

@@ -85,7 +85,7 @@ class TestKernelLog(unittest.TestCase):
 
         # test a real post code line
         line = 'ex_trace_args: "  POST CODE: %X  ACPI TIMER: %X  TIME: %d.%d ms\\n", b0003f33, 83528798, 0, 77, 0, 0'
-        expected_output = "POST CODE: B0003F33  ACPI TIMER: 83528798  TIME: 0.77 ms"
+        expected_output = "POST CODE: B0003F33  ACPI TIMER: 83528798  TIME: 0.119 ms"
         result = sscanf_bios_args(line)
         self.assertEqual(result, expected_output)
 

test_launcher.py

@@ -26,10 +26,11 @@ class TestLauncher(unittest.TestCase):
         """Test launching as unknown exe"""
 
         with patch("builtins.print") as mock_print:
-            amd_debug.launch_tool("unknown_exe.py")
+            result = amd_debug.launch_tool("unknown_exe.py")
             mock_print.assert_called_once_with(
                 "\033[91mUnknown exe: unknown_exe.py\033[0m"
             )
+            self.assertIsNotNone(result)
 
     def test_launcher_amd_s2idle(self):
         """Test launching amd_s2idle"""

test_prerequisites.py

@@ -143,6 +143,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 +195,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 +217,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,
@@ -798,8 +832,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()

test_s2idle.py

@@ -180,7 +180,7 @@ class TestMainFunction(unittest.TestCase):
             mock_report.assert_called_once_with(
                 "2023-01-01", "2023-02-01", None, "html", False, False
             )
-            self.assertTrue(result)
+            self.assertIsNone(result)
 
     @patch("amd_debug.s2idle.relaunch_sudo")
     @patch("amd_debug.s2idle.run_test_cycle")
@@ -207,7 +207,7 @@ class TestMainFunction(unittest.TestCase):
             mock_test.assert_called_once_with(
                 None, None, "5", "txt", None, False, False, False, False, False
             )
-            self.assertTrue(result)
+            self.assertIsNone(result)
 
     @patch("amd_debug.s2idle.version")
     def test_main_version(self, mock_version):
@@ -220,7 +220,7 @@ class TestMainFunction(unittest.TestCase):
                 result = main()
                 mock_version.assert_called_once()
                 mock_print.assert_called_once_with("1.0.0")
-                self.assertTrue(result)
+                self.assertIsNone(result)
 
     def test_main_no_action(self):
         """Test main function with no action specified"""