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

amd_debug/sleep_report.py

@@ -5,6 +5,7 @@ import os
 import re
 import math
 from datetime import datetime, timedelta
+import numpy as np
 from tabulate import tabulate
 from jinja2 import Environment, FileSystemLoader
 import pandas as pd
@@ -73,6 +74,8 @@ def format_percent(val):
 
 def format_timedelta(val):
     """Format seconds as a nicer format"""
+    if math.isnan(val):
+        val = 0
     return str(timedelta(seconds=val))
 
 
@@ -97,8 +100,23 @@ class SleepReport(AmdTool):
         self.debug = report_debug
         self.format = fmt
         self.failures = []
-        self.df = self.db.report_summary_dataframe(self.since, self.until)
-        self.pre_process_dataframe()
+        if since and until:
+            self.df = self.db.report_summary_dataframe(self.since, self.until)
+            self.pre_process_dataframe()
+        else:
+            self.df = pd.DataFrame(
+                columns=[
+                    "t0",
+                    "t1",
+                    "requested",
+                    "hw",
+                    "b0",
+                    "b1",
+                    "full",
+                    "wake_irq",
+                    "gpio",
+                ]
+            )
         self.battery_svg = None
         self.hwsleep_svg = None
 
@@ -136,6 +154,7 @@ class SleepReport(AmdTool):
         self.df["Duration"] = self.df["t1"].apply(format_as_seconds) - self.df[
             "t0"
         ].apply(format_as_seconds)
+        self.df["Duration"] = self.df["Duration"].replace(0, np.nan)
         self.df["Hardware Sleep"] = (self.df["hw"] / self.df["Duration"]).apply(
             parse_hw_sleep
         )
@@ -187,7 +206,8 @@ class SleepReport(AmdTool):
                 format_watts
             )
 
-    def convert_gpio_dataframe(self, content):
+    def convert_table_dataframe(self, content):
+        """Convert a table like dataframe to an HTML table"""
         header = False
         rows = []
         for line in content.split("\n"):
@@ -196,17 +216,25 @@ class SleepReport(AmdTool):
                 if header:
                     continue
                 header = True
+            line = line.strip("│")
+            line = line.replace("├─", "└─")
             if "|" in line:
                 # first column missing '|'
                 rows.append(line.replace("\t", "|"))
         columns = [row.split("|") for row in rows]
         df = pd.DataFrame(columns[1:], columns=columns[0])
-        return df.to_html(index=False, table_id="gpio")
+        return df.to_html(index=False, justify="center", col_space=30)
 
     def get_prereq_data(self):
         """Get the prereq data"""
         prereq = []
         prereq_debug = []
+        tables = [
+            "int|active",
+            "ACPI name",
+            "PCI Slot",
+            "DMI|value",
+        ]
         ts = self.db.get_last_prereq_ts()
         if not ts:
             return [], "", []
@@ -216,23 +244,24 @@ class SleepReport(AmdTool):
         if self.debug:
             for row in self.db.report_debug(t0):
                 content = row[0]
-                if self.format == "html" and "int|active" in content:
-                    content = self.convert_gpio_dataframe(content)
-                prereq_debug.append(
-                    {"data": "{message}".format(message=content.strip())}
-                )
+                if self.format == "html" and [
+                    table for table in tables if table in content
+                ]:
+                    content = self.convert_table_dataframe(content)
+                prereq_debug.append({"data": f"{content.strip()}"})
         return prereq, t0, prereq_debug
 
     def get_cycle_data(self):
         """Get the cycle data"""
         cycles = []
         debug = []
+        tables = ["Wakeup Source"]
         num = 0
         for cycle in self.df["Start Time"]:
             if self.format == "html":
                 data = ""
                 for line in self.db.report_cycle_data(cycle).split("\n"):
-                    data += "<p>{line}</p>".format(line=line)
+                    data += f"<p>{line}</p>"
                 cycles.append({"cycle_num": num, "data": data})
             else:
                 cycles.append([num, self.db.report_cycle_data(cycle)])
@@ -240,7 +269,12 @@ class SleepReport(AmdTool):
                 messages = []
                 priorities = []
                 for row in self.db.report_debug(cycle):
-                    messages.append(row[0])
+                    content = row[0]
+                    if self.format == "html" and [
+                        table for table in tables if table in content
+                    ]:
+                        content = self.convert_table_dataframe(content)
+                    messages.append(content)
                     priorities.append(get_log_priority(row[1]))
                 debug.append(
                     {"cycle_num": num, "messages": messages, "priorities": priorities}
@@ -265,58 +299,69 @@ class SleepReport(AmdTool):
             prereq, prereq_date, prereq_debug = self.get_prereq_data()
 
         # Load the cycle and/or debug data
-        cycles, debug = self.get_cycle_data()
-
-        self.post_process_dataframe()
-        failures = None
-        if self.format == "md":
-            summary = self.df.to_markdown(floatfmt=".02f")
-            cycle_data = tabulate(cycles, headers=["Cycle", "data"], tablefmt="pipe")
-            if self.failures:
-                failures = tabulate(
-                    self.failures,
-                    headers=["Cycle", "Problem", "Explanation"],
-                    tablefmt="pipe",
+        if not self.df.empty:
+            cycles, debug = self.get_cycle_data()
+
+            self.post_process_dataframe()
+            failures = None
+            if self.format == "md":
+                summary = self.df.to_markdown(floatfmt=".02f")
+                cycle_data = tabulate(
+                    cycles, headers=["Cycle", "data"], tablefmt="pipe"
                 )
-        elif self.format == "txt":
-            summary = tabulate(self.df, headers=self.df.columns, tablefmt="fancy_grid")
-            cycle_data = tabulate(
-                cycles, headers=["Cycle", "data"], tablefmt="fancy_grid"
-            )
-            if self.failures:
-                failures = tabulate(
-                    self.failures,
-                    headers=["Cycle", "Problem", "Explanation"],
-                    tablefmt="fancy_grid",
+                if self.failures:
+                    failures = tabulate(
+                        self.failures,
+                        headers=["Cycle", "Problem", "Explanation"],
+                        tablefmt="pipe",
+                    )
+            elif self.format == "txt":
+                summary = tabulate(
+                    self.df, headers=self.df.columns, tablefmt="fancy_grid"
+                )
+                cycle_data = tabulate(
+                    cycles, headers=["Cycle", "data"], tablefmt="fancy_grid"
                 )
-        elif self.format == "html":
-            summary = ""
-            row = 0
-            # we will use javascript to highlight the high values
-            for line in self.df.to_html(table_id="summary", render_links=True).split(
-                "\n"
-            ):
-                if "<tr>" in line:
-                    line = line.replace(
-                        "<tr>",
-                        '<tr class="row-low" onclick="pick_summary_cycle(%d)">' % row,
+                if self.failures:
+                    failures = tabulate(
+                        self.failures,
+                        headers=["Cycle", "Problem", "Explanation"],
+                        tablefmt="fancy_grid",
                     )
-                    row = row + 1
-                summary += line
-            cycle_data = cycles
-            failures = self.failures
-        # only show one cycle in stdout output even if we found more
-        else:
-            df = self.df.tail(1)
-            summary = tabulate(
-                df, headers=self.df.columns, tablefmt="fancy_grid", showindex=False
-            )
-            if cycles[-1][0] == df.index.start:
-                cycle_data = cycles[-1][-1]
+            elif self.format == "html":
+                summary = ""
+                row = 0
+                # we will use javascript to highlight the high values
+                for line in self.df.to_html(
+                    table_id="summary", render_links=True
+                ).split("\n"):
+                    if "<tr>" in line:
+                        line = line.replace(
+                            "<tr>",
+                            f'<tr class="row-low" onclick="pick_summary_cycle({row})">',
+                        )
+                        row = row + 1
+                    summary += line
+                cycle_data = cycles
+                failures = self.failures
+            # only show one cycle in stdout output even if we found more
             else:
-                cycle_data = None
-            if self.failures and self.failures[-1][0] == df.index.start:
-                failures = self.failures[-1][-1]
+                df = self.df.tail(1)
+                summary = tabulate(
+                    df, headers=self.df.columns, tablefmt="fancy_grid", showindex=False
+                )
+                if cycles[-1][0] == df.index.start:
+                    cycle_data = cycles[-1][-1]
+                else:
+                    cycle_data = None
+                if self.failures and self.failures[-1][0] == df.index.start:
+                    failures = self.failures[-1][-1]
+        else:
+            cycles = []
+            debug = []
+            cycle_data = []
+            summary = "No sleep cycles found in the database."
+            failures = None
 
         # let it burn
         context = {
@@ -333,7 +378,7 @@ class SleepReport(AmdTool):
             "failures": failures,
         }
         if self.fname:
-            with open(self.fname, "w") as f:
+            with open(self.fname, "w", encoding="utf-8") as f:
                 f.write(template.render(context))
             if "SUDO_UID" in os.environ:
                 os.chown(
@@ -345,30 +390,30 @@ class SleepReport(AmdTool):
 
     def build_battery_chart(self):
         """Build a battery chart using matplotlib and seaborn"""
-        import matplotlib.pyplot as plt
-        import seaborn as sns
-        import io
+        import matplotlib.pyplot as plt  # pylint: disable=import-outside-toplevel
+        import seaborn as sns  # pylint: disable=import-outside-toplevel
+        import io  # pylint: disable=import-outside-toplevel
 
         if "Battery Ave Rate" not in self.df.columns:
             return
 
         plt.set_loglevel("warning")
-        fig, ax1 = plt.subplots()
-        lns3 = ax1.plot(
+        _fig, ax1 = plt.subplots()
+        ax1.plot(
             self.df["Battery Ave Rate"], color="green", label="Charge/Discharge Rate"
         )
 
         ax2 = ax1.twinx()
-        lns1 = sns.barplot(
+        sns.barplot(
             x=self.df.index,
             y=self.df["Battery Delta"],
             color="grey",
             label="Battery Change",
             alpha=0.3,
         )
-        max = int(len(self.df.index) / 10)
-        if max:
-            ax1.set_xticks(range(0, len(self.df.index), max))
+        max_range = int(len(self.df.index) / 10)
+        if max_range:
+            ax1.set_xticks(range(0, len(self.df.index), max_range))
         ax1.set_xlabel("Cycle")
         ax1.set_ylabel("Rate (Watts)")
         ax2.set_ylabel("Battery Change (%)")
@@ -385,20 +430,20 @@ class SleepReport(AmdTool):
 
     def build_hw_sleep_chart(self):
         """Build the hardware sleep chart using matplotlib and seaborn"""
-        import matplotlib.pyplot as plt
-        import seaborn as sns
-        import io
+        import matplotlib.pyplot as plt  # pylint: disable=import-outside-toplevel
+        import seaborn as sns  # pylint: disable=import-outside-toplevel
+        import io  # pylint: disable=import-outside-toplevel
 
         plt.set_loglevel("warning")
-        fig, ax1 = plt.subplots()
-        lns3 = ax1.plot(
+        _fig, ax1 = plt.subplots()
+        ax1.plot(
             self.df["Hardware Sleep"],
             color="red",
             label="Hardware Sleep",
         )
 
         ax2 = ax1.twinx()
-        lns1 = sns.barplot(
+        sns.barplot(
             x=self.df.index,
             y=self.df["Duration"] / 60,
             color="grey",
@@ -406,9 +451,9 @@ class SleepReport(AmdTool):
             alpha=0.3,
         )
 
-        max = int(len(self.df.index) / 10)
-        if max:
-            ax1.set_xticks(range(0, len(self.df.index), max))
+        max_range = int(len(self.df.index) / 10)
+        if max_range:
+            ax1.set_xticks(range(0, len(self.df.index), max_range))
         ax1.set_xlabel("Cycle")
         ax1.set_ylabel("Percent")
         ax2.set_yscale("log")
@@ -427,15 +472,13 @@ class SleepReport(AmdTool):
     def run(self, inc_prereq=True):
         """Run the report"""
 
-        if self.df.empty:
-            raise ValueError(f"No data found between {self.since} and {self.until}")
-
         characters = print_temporary_message("Building report, please wait...")
 
-        # Build charts in the page for html format
-        if len(self.df.index) > 1 and self.format == "html":
-            self.build_battery_chart()
-            self.build_hw_sleep_chart()
+        if not self.df.empty:
+            # Build charts in the page for html format
+            if len(self.df.index) > 1 and self.format == "html":
+                self.build_battery_chart()
+                self.build_hw_sleep_chart()
 
         # Render the template using jinja
         msg = self.build_template(inc_prereq)

amd_debug/templates/html

@@ -42,12 +42,14 @@
         table,
         th,
         td {
-            border-width: 0;
+            border-width: 1;
+            border-collapse: collapse;
             table-layout: fixed;
             font-family: sans-serif;
             letter-spacing: 0.02em;
             color: #000000;
-            margin-bottom: 10px;
+            text-align: left;
+            padding: 3px;
         }
 
         .○ {

amd_debug/validator.py

@@ -290,13 +290,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"""
@@ -444,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)
@@ -747,16 +745,18 @@ class SleepValidator(AmdTool):
                 return False
         else:
             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)
             return True
 
     def unlock_session(self):
@@ -780,6 +780,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 +788,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 +805,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_tools-0.2.2.dist-info → amd_debug_tools-0.2.4.dist-info}/METADATA

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

amd_debug_tools-0.2.4.dist-info/RECORD

@@ -0,0 +1,45 @@
+launcher.py,sha256=M8kT9DtyZoQgZaKWDbSBu4jsS6tZF1gWko3sovNVyag,947
+test_acpi.py,sha256=wtS43Rz95h7YEEJBeFa6Mswaeo4syBZrw4hY8i0YbJY,3117
+test_batteries.py,sha256=nN5pfP5El7Whypq3HHEpW8bufdf5EWSTVGbayfNQYP4,3360
+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=80xVbidrbx8ixMt_x5Uvfn7nFnB637nX69yIZTifyuk,1511
+test_prerequisites.py,sha256=DiB2SkZJf7OFEta1SifoEHyszuvKOfjs967CsHE6rg4,83244
+test_pstate.py,sha256=a9oAJ9-LANX32XNQhplz6Y75VNYc__QqoSBKIrwvANg,6058
+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=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=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=tNWhlfxQEA30guk-fzMvcc237hf_PARVQuHaH3sTp4A,14287
+amd_debug/kernel.py,sha256=UAlxlXNuZxtHVtrfCmTp12YombVaUs4mizOxwuXTX2M,12038
+amd_debug/prerequisites.py,sha256=_SlRzYvWQpZt8VdioOAA2bMt1G9TbNs75swr60Yu1V4,50005
+amd_debug/pstate.py,sha256=lLRsayKi7KOXZCQ6Zjm2pNaobpjLXcgLHXZ9Zt40Fd4,9559
+amd_debug/s2idle-hook,sha256=LLiaqPtGd0qetu9n6EYxKHZaIdHpVQDONdOuSc0pfFg,1695
+amd_debug/s2idle.py,sha256=lr1wcuJcpvI5pL2gNHqrc7n5E7EYCztvaAYYFPMlGYk,13259
+amd_debug/sleep_report.py,sha256=hhqu711AKtjeYF2xmGcejyCyyPtmq4-gC_hROUCrC0g,17317
+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.4.dist-info/licenses/LICENSE,sha256=RBlZI6r3MRGzymI2VDX2iW__D2APDbMhu_Xg5t6BWeo,1066
+amd_debug_tools-0.2.4.dist-info/METADATA,sha256=jzff0ncunf8ZwS6z90_U577R4OEOlZyf3tVtGA8RHsg,6877
+amd_debug_tools-0.2.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+amd_debug_tools-0.2.4.dist-info/entry_points.txt,sha256=HC11T2up0pPfroAn6Pg5M2jOZXhkWIipToJ1YPTKqu8,116
+amd_debug_tools-0.2.4.dist-info/top_level.txt,sha256=XYjxExbUTEtiIlag_5iQvZSVOC1EIxhKM4NLklReQ0k,234
+amd_debug_tools-0.2.4.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_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"""