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

amd_debug_tools-0.2.2.dist-info/RECORD

@@ -0,0 +1,45 @@
+launcher.py,sha256=_Gs0W8tUB2wkTy5Nz4qEzG0VqQcnO7xuIQj0GwV_KbY,968
+test_acpi.py,sha256=wtS43Rz95h7YEEJBeFa6Mswaeo4syBZrw4hY8i0YbJY,3117
+test_batteries.py,sha256=nN5pfP5El7Whypq3HHEpW8bufdf5EWSTVGbayfNQYP4,3360
+test_bios.py,sha256=GBAXE_rXd2G-JE0XJ8AvYcF9Me6LTyQQQ8h0Ib3cpxQ,8981
+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=4Ltxx7vGU91b9MX1AtdPLS8iyWJBCNuEKCuO0nnEb_g,83381
+test_pstate.py,sha256=a9oAJ9-LANX32XNQhplz6Y75VNYc__QqoSBKIrwvANg,6058
+test_s2idle.py,sha256=-S3yymjprf3_LIgaPGWgzN9FmnyQG55dNc4xqWAF8Z8,32344
+test_sleep_report.py,sha256=R3cUPPT9r9q4q93xk6NFvi4ySgT5laqidk2SASuTWIo,5878
+test_validator.py,sha256=NeiX8kT5DiHiiB5lRSJkjIpV32UzaIrW5ljKLmFtBMk,30490
+test_wake.py,sha256=6zi5GVFHQKU1sTWw3O5-aGriB9uu5713QLn4l2wjhpM,7152
+amd_debug/__init__.py,sha256=aOtpIEKGLUStrh0e4qgilHW7HgF4Od-r9pOoZ87NwAM,1105
+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/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=Otv3YDu7Je4ljSifVmvjObGoOY4OvLIY20pw-v4Dqkw,22911
+amd_debug/installer.py,sha256=r6r_nVWv8qYdrqAvnAzQhRiS5unBDOkXsqUfHvFK8uM,14249
+amd_debug/kernel.py,sha256=xzAy-sDY5-sd4jxyU7EaBokS7YsvEjoWRuexaTJNRBc,11851
+amd_debug/prerequisites.py,sha256=bKJA9ztyapB8rxrNEgc-hxazw5Uh-sP5X0S7zplGA0c,50413
+amd_debug/pstate.py,sha256=akGdJkIxBp0bx3AeGv6ictNxwv8m0j9vQ2IZB0Jx3dM,9518
+amd_debug/s2idle-hook,sha256=LLiaqPtGd0qetu9n6EYxKHZaIdHpVQDONdOuSc0pfFg,1695
+amd_debug/s2idle.py,sha256=lzxLYZBcQllyqEMZfxYEUvQO3ArgVzwL5FHymzvZvSs,13281
+amd_debug/sleep_report.py,sha256=zgwcmSk7S8GAmPtPZJGP29Mr5bcWUBxwNL8HBubKs6Q,15516
+amd_debug/validator.py,sha256=fgG3D0k6DS9ArgzK1SuPUds1FNGoKf2asPUwWoyCsXE,33205
+amd_debug/wake.py,sha256=xT8WrFrN6voCmXWo5dsn4mQ7iR2QJxHrrYBd3EREG-Q,3936
+amd_debug/bash/amd-s2idle,sha256=g_cle1ElCJpwE4wcLezL6y-BdasDKTnNMhrtzKLE9ks,1142
+amd_debug/templates/html,sha256=tnpqHDZF5FfhC6YNRUfOG6Vn9ZtISFr10kEXSB476Mw,14518
+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.2.dist-info/licenses/LICENSE,sha256=RBlZI6r3MRGzymI2VDX2iW__D2APDbMhu_Xg5t6BWeo,1066
+amd_debug_tools-0.2.2.dist-info/METADATA,sha256=oZ5H5dL216bbAqtOF8VmvtqkqctPIf5iPibPCjjc1tQ,6877
+amd_debug_tools-0.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+amd_debug_tools-0.2.2.dist-info/entry_points.txt,sha256=HC11T2up0pPfroAn6Pg5M2jOZXhkWIipToJ1YPTKqu8,116
+amd_debug_tools-0.2.2.dist-info/top_level.txt,sha256=XYjxExbUTEtiIlag_5iQvZSVOC1EIxhKM4NLklReQ0k,234
+amd_debug_tools-0.2.2.dist-info/RECORD,,

{amd_debug_tools-0.2.0.dist-info → amd_debug_tools-0.2.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.3.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

amd_debug_tools-0.2.2.dist-info/top_level.txt

@@ -0,0 +1,18 @@
+amd_debug
+launcher
+test_acpi
+test_batteries
+test_bios
+test_common
+test_database
+test_display
+test_failures
+test_installer
+test_kernel
+test_launcher
+test_prerequisites
+test_pstate
+test_s2idle
+test_sleep_report
+test_validator
+test_wake

launcher.py

@@ -0,0 +1,35 @@
+#!/usr/bin/python3
+# SPDX-License-Identifier: MIT
+"""
+This module is a launcher for the AMD Debug Tools package. It is meant for
+launching various tools within the package without installation.
+"""
+
+import sys
+import os
+
+URL = "git://git.kernel.org/pub/scm/linux/kernel/git/superm1/amd-debug-tools.git"
+try:
+    import amd_debug
+    from amd_debug.common import fatal_error
+except ModuleNotFoundError:
+    sys.exit(
+        f"\033[91m{sys.argv[0]} can not be run standalone.\n"
+        f"\033[0m\033[94mCheck out the full branch from {URL}\033[0m"
+    )
+
+
+def main():
+    """Main function to launch the appropriate tool based on the script name."""
+    try:
+        return amd_debug.launch_tool(os.path.basename(sys.argv[0]))
+    except ModuleNotFoundError as e:
+        fatal_error(
+            f"Missing dependency: {e}\n"
+            f"Run ./install_deps.py to install dependencies."
+        )
+        return False
+
+
+if __name__ == "__main__":
+    sys.exit(main())

test_acpi.py

@@ -0,0 +1,90 @@
+#!/usr/bin/python3
+# SPDX-License-Identifier: MIT
+
+"""
+This module contains unit tests for the acpi functions in the amd-debug-tools package.
+"""
+from unittest.mock import patch, mock_open, call
+
+import logging
+import unittest
+
+from amd_debug.acpi import search_acpi_tables, AcpicaTracer, ACPI_METHOD
+
+
+class TestAcpi(unittest.TestCase):
+    """Test acpi functions"""
+
+    @classmethod
+    def setUpClass(cls):
+        logging.basicConfig(filename="/dev/null", level=logging.DEBUG)
+
+    def test_search_acpi_tables(self):
+        """Test search_acpi_tables function"""
+        pattern = "test_pattern"
+        bad_pattern = "bad_pattern"
+        mock_listdir = ["ABA", "SSDT1", "DSDT2", "SSDT3"]
+        mock_file_content = b"test_pattern"
+
+        with patch("os.listdir", return_value=mock_listdir), patch(
+            "builtins.open", mock_open(read_data=mock_file_content)
+        ):
+            result = search_acpi_tables(pattern)
+            self.assertTrue(result)
+
+        with patch("os.listdir", return_value=mock_listdir), patch(
+            "builtins.open", mock_open(read_data=mock_file_content)
+        ):
+            result = search_acpi_tables(bad_pattern)
+            self.assertFalse(result)
+
+        with patch("os.listdir", return_value=["OTHER1", "OTHER2"]), patch(
+            "builtins.open", mock_open(read_data=b"no_match")
+        ):
+            result = search_acpi_tables(pattern)
+            self.assertFalse(result)
+
+    def test_acpica_tracer_missing_bios(self):
+        """Test AcpicaTracer class when ACPI tracing is not supported"""
+
+        mock_listdir = ["SSDT1", "DSDT2", "SSDT3"]
+
+        with patch("os.listdir", return_value=mock_listdir), patch(
+            "builtins.open", mock_open(read_data=b"foo")
+        ), patch("os.path.exists", return_value=True):
+
+            tracer = AcpicaTracer()
+            self.assertTrue(tracer.supported)
+
+            self.assertFalse(tracer.trace_bios())
+
+    def test_acpica_tracer(self):
+        """Test AcpicaTracer class"""
+
+        mock_listdir = ["SSDT1", "DSDT2", "SSDT3"]
+        mock_file_content = bytes(ACPI_METHOD, "utf-8")
+
+        with patch("os.listdir", return_value=mock_listdir), patch(
+            "builtins.open", mock_open(read_data=mock_file_content)
+        ), patch("os.path.exists", return_value=True):
+
+            tracer = AcpicaTracer()
+            self.assertTrue(tracer.supported)
+
+            self.assertTrue(tracer.trace_notify())
+            self.assertTrue(tracer.trace_bios())
+            self.assertTrue(tracer.disable())
+            self.assertTrue(tracer.restore())
+
+    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")
+        ):
+            tracer = AcpicaTracer()
+            self.assertFalse(tracer.supported)
+
+            self.assertFalse(tracer.trace_notify())
+            self.assertFalse(tracer.trace_bios())
+            self.assertFalse(tracer.disable())
+            self.assertFalse(tracer.restore())

test_batteries.py

@@ -0,0 +1,92 @@
+#!/usr/bin/python3
+# SPDX-License-Identifier: MIT
+
+"""
+This module contains unit tests for the battery functions in the amd-debug-tools package.
+"""
+import unittest
+import logging
+from unittest.mock import MagicMock, patch
+
+
+from amd_debug.battery import Batteries
+
+
+class TestBatteries(unittest.TestCase):
+    """Test battery functions"""
+
+    @classmethod
+    def setUpClass(cls):
+        logging.basicConfig(filename="/dev/null", level=logging.DEBUG)
+
+    @patch("amd_debug.battery.Context")
+    def setUp(self, mock_context):
+        """Set up a mock context for testing"""
+        self.mock_context = mock_context.return_value
+        self.batteries = Batteries()
+
+    def test_get_batteries(self):
+        """Test getting battery names"""
+        mock_device = MagicMock()
+        mock_device.device_path = "/devices/LNXSYSTM:00/device:00/PNP0C0A:00"
+        mock_device.properties = {"POWER_SUPPLY_NAME": "BAT0"}
+        self.mock_context.list_devices.return_value = [mock_device]
+
+        result = self.batteries.get_batteries()
+        self.assertEqual(result, ["BAT0"])
+
+    def test_get_energy_unit(self):
+        """Test getting energy unit for a battery"""
+        mock_device = MagicMock()
+        mock_device.device_path = "/devices/LNXSYSTM:00/device:00/PNP0C0A:00"
+        mock_device.properties = {
+            "POWER_SUPPLY_NAME": "BAT0",
+            "POWER_SUPPLY_ENERGY_NOW": "50000",
+        }
+        self.mock_context.list_devices.return_value = [mock_device]
+        result = self.batteries.get_energy_unit("BAT0")
+        self.assertEqual(result, "µWh")
+
+    def test_get_energy(self):
+        """Test getting current energy for a battery"""
+        mock_device = MagicMock()
+        mock_device.device_path = "/devices/LNXSYSTM:00/device:00/PNP0C0A:00"
+        mock_device.properties = {
+            "POWER_SUPPLY_NAME": "BAT0",
+            "POWER_SUPPLY_ENERGY_NOW": "50000",
+        }
+        self.mock_context.list_devices.return_value = [mock_device]
+        result = self.batteries.get_energy("BAT0")
+        self.assertEqual(result, "50000")
+
+    def test_get_energy_full(self):
+        """Test getting full energy for a battery"""
+        mock_device = MagicMock()
+        mock_device.device_path = "/devices/LNXSYSTM:00/device:00/PNP0C0A:00"
+        mock_device.properties = {
+            "POWER_SUPPLY_NAME": "BAT0",
+            "POWER_SUPPLY_ENERGY_FULL": "60000",
+        }
+        self.mock_context.list_devices.return_value = [mock_device]
+
+        result = self.batteries.get_energy_full("BAT0")
+        self.assertEqual(result, "60000")
+
+    def test_get_description_string(self):
+        """Test getting description string for a battery"""
+        mock_device = MagicMock()
+        mock_device.device_path = "/devices/LNXSYSTM:00/device:00/PNP0C0A:00"
+        mock_device.properties = {
+            "POWER_SUPPLY_NAME": "BAT0",
+            "POWER_SUPPLY_MANUFACTURER": "ACME",
+            "POWER_SUPPLY_MODEL_NAME": "SuperBattery",
+            "POWER_SUPPLY_ENERGY_FULL": "60000",
+            "POWER_SUPPLY_ENERGY_FULL_DESIGN": "80000",
+        }
+        self.mock_context.list_devices.return_value = [mock_device]
+
+        result = self.batteries.get_description_string("BAT0")
+        self.assertEqual(
+            result,
+            "Battery BAT0 (ACME SuperBattery) is operating at 75.00% of design",
+        )

test_bios.py

@@ -0,0 +1,250 @@
+#!/usr/bin/python3
+# SPDX-License-Identifier: MIT
+
+"""
+This module contains unit tests for the bios tool in the amd-debug-tools package.
+"""
+import argparse
+import logging
+import unittest
+from unittest.mock import patch, MagicMock
+
+from amd_debug.bios import AmdBios, parse_args, main
+
+
+class TestAmdBios(unittest.TestCase):
+    """Test AmdBios class"""
+
+    @classmethod
+    def setUpClass(cls):
+        logging.basicConfig(filename="/dev/null", level=logging.DEBUG)
+
+    @patch("amd_debug.bios.get_kernel_log")
+    def test_init(self, mock_get_kernel_log):
+        """Test initialization of AmdBios class"""
+        mock_kernel_log = MagicMock()
+        mock_get_kernel_log.return_value = mock_kernel_log
+
+        app = AmdBios("test_input", debug=True)
+
+        self.assertEqual(app.kernel_log, mock_kernel_log)
+
+    @patch("amd_debug.bios.relaunch_sudo")
+    @patch("amd_debug.bios.minimum_kernel")
+    @patch("amd_debug.bios.AcpicaTracer")
+    @patch("amd_debug.bios.print_color")
+    def test_set_tracing_enable(
+        self, _mock_print, mock_acpica_tracer, mock_minimum_kernel, mock_relaunch_sudo
+    ):
+        """Test enabling tracing"""
+        mock_minimum_kernel.return_value = True
+        mock_tracer = MagicMock()
+        mock_acpica_tracer.return_value = mock_tracer
+        mock_tracer.trace_bios.return_value = True
+
+        app = AmdBios(None, debug=False)
+        result = app.set_tracing(enable=True)
+
+        mock_relaunch_sudo.assert_called_once()
+        mock_tracer.trace_bios.assert_called_once()
+        self.assertTrue(result)
+
+    @patch("amd_debug.bios.relaunch_sudo")
+    @patch("amd_debug.bios.minimum_kernel")
+    @patch("amd_debug.bios.AcpicaTracer")
+    @patch("amd_debug.bios.print_color")
+    def test_set_tracing_disable(
+        self, _mock_print, mock_acpica_tracer, mock_minimum_kernel, mock_relaunch_sudo
+    ):
+        """Test disabling tracing"""
+        mock_minimum_kernel.return_value = True
+        mock_tracer = MagicMock()
+        mock_acpica_tracer.return_value = mock_tracer
+        mock_tracer.disable.return_value = True
+
+        app = AmdBios(None, debug=False)
+        result = app.set_tracing(enable=False)
+
+        mock_relaunch_sudo.assert_called_once()
+        mock_tracer.disable.assert_called_once()
+        self.assertTrue(result)
+
+    @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):
+        """Test analyzing kernel log line"""
+        mock_sscanf_bios_args.return_value = "BIOS argument found"
+
+        app = AmdBios(None, debug=False)
+        app._analyze_kernel_log_line(  # pylint: disable=protected-access
+            "test log line", priority="INFO"
+        )
+
+        mock_sscanf_bios_args.assert_called_once_with("test log line")
+        mock_print_color.assert_called_once_with("BIOS argument found", "🖴")
+
+    @patch("amd_debug.bios.sscanf_bios_args")
+    @patch("amd_debug.bios.print_color")
+    def test_analyze_kernel_log_line_no_bios_args(
+        self, mock_print_color, mock_sscanf_bios_args
+    ):
+        """Test analyzing kernel log line with no BIOS arguments"""
+        mock_sscanf_bios_args.return_value = None
+
+        app = AmdBios(None, debug=False)
+        app._analyze_kernel_log_line(  # pylint: disable=protected-access
+            "[123.456] test log line", priority="INFO"
+        )
+
+        mock_sscanf_bios_args.assert_called_once_with("[123.456] test log line")
+        mock_print_color.assert_called_once_with("test log line", "INFO")
+
+    @patch("amd_debug.bios.get_kernel_log")
+    def test_run(self, _mock_run):
+        """Test run method"""
+        mock_kernel_log = MagicMock()
+        app = AmdBios(None, debug=False)
+        app.kernel_log = mock_kernel_log
+
+        app.run()
+
+        mock_kernel_log.process_callback.assert_called_once_with(
+            app._analyze_kernel_log_line  # pylint: disable=protected-access
+        )
+
+    @patch("sys.argv", ["bios.py", "parse", "--input", "test.log", "--tool-debug"])
+    def test_parse_args_parse_command(self):
+        """Test parse_args with parse command"""
+
+        args = parse_args()
+        self.assertEqual(args.command, "parse")
+        self.assertEqual(args.input, "test.log")
+        self.assertTrue(args.tool_debug)
+
+    @patch("sys.argv", ["bios.py", "trace", "--enable", "--tool-debug"])
+    def test_parse_args_trace_enable(self):
+        """Test parse_args with trace enable command"""
+
+        args = parse_args()
+        self.assertEqual(args.command, "trace")
+        self.assertTrue(args.enable)
+        self.assertFalse(args.disable)
+        self.assertTrue(args.tool_debug)
+
+    @patch("sys.argv", ["bios.py", "trace", "--disable"])
+    def test_parse_args_trace_disable(self):
+        """Test parse_args with trace disable command"""
+
+        args = parse_args()
+        self.assertEqual(args.command, "trace")
+        self.assertFalse(args.enable)
+        self.assertTrue(args.disable)
+
+    @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")
+
+    @patch("sys.argv", ["bios.py"])
+    @patch("argparse.ArgumentParser.print_help")
+    @patch("sys.exit")
+    def test_parse_args_no_arguments(self, mock_exit, mock_print_help):
+        """Test parse_args with no arguments"""
+
+        parse_args()
+        mock_print_help.assert_called_once()
+        mock_exit.assert_called_once_with(1)
+
+    @patch("sys.argv", ["bios.py", "trace", "--enable", "--disable"])
+    @patch("sys.exit")
+    def test_parse_args_conflicting_trace_arguments(self, mock_exit):
+        """Test parse_args with conflicting trace arguments"""
+
+        parse_args()
+        mock_exit.assert_called_once_with("can't set both enable and disable")
+
+    @patch("sys.argv", ["bios.py", "trace"])
+    @patch("sys.exit")
+    def test_parse_args_missing_trace_arguments(self, mock_exit):
+        """Test parse_args with missing trace arguments"""
+
+        parse_args()
+        mock_exit.assert_called_once_with("must set either enable or disable")
+
+    @patch("amd_debug.bios.AmdBios")
+    @patch("amd_debug.bios.parse_args")
+    @patch("amd_debug.bios.version")
+    @patch("amd_debug.bios.show_log_info")
+    def test_main_trace_command(
+        self, mock_show_log_info, _mock_version, mock_parse_args, mock_amd_bios
+    ):
+        """Test main function with trace command"""
+        mock_app = MagicMock()
+        mock_amd_bios.return_value = mock_app
+        mock_parse_args.return_value = argparse.Namespace(
+            command="trace", enable=True, disable=False, tool_debug=True
+        )
+        mock_app.set_tracing.return_value = True
+
+        result = main()
+
+        mock_parse_args.assert_called_once()
+        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)
+
+    @patch("amd_debug.bios.AmdBios")
+    @patch("amd_debug.bios.parse_args")
+    @patch("amd_debug.bios.version")
+    @patch("amd_debug.bios.show_log_info")
+    def test_main_parse_command(
+        self, mock_show_log_info, _mock_version, mock_parse_args, mock_amd_bios
+    ):
+        """Test main function with parse command"""
+        mock_app = MagicMock()
+        mock_amd_bios.return_value = mock_app
+        mock_parse_args.return_value = argparse.Namespace(
+            command="parse", input="test.log", tool_debug=True
+        )
+        mock_app.run.return_value = True
+
+        result = main()
+
+        mock_parse_args.assert_called_once()
+        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)
+
+    @patch("amd_debug.bios.parse_args")
+    @patch("amd_debug.bios.version")
+    @patch("amd_debug.bios.show_log_info")
+    @patch("amd_debug.bios.print")
+    def test_main_version_command(
+        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_version.return_value = "1.0.0"
+
+        result = main()
+
+        mock_parse_args.assert_called_once()
+        mock_version.assert_called_once()
+        mock_show_log_info.assert_called_once()
+        self.assertEqual(result, False)
+
+    @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")
+
+        result = main()
+
+        mock_parse_args.assert_called_once()
+        mock_show_log_info.assert_called_once()
+        self.assertFalse(result)