amd-debug-tools 0.2.1__tar.gz → 0.2.2__tar.gz

{amd_debug_tools-0.2.1 → amd_debug_tools-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amd-debug-tools
-Version: 0.2.1
+Version: 0.2.2
 Summary: debug tools for AMD systems
 Author-email: Mario Limonciello <superm1@kernel.org>
 License-Expression: MIT
@@ -125,8 +125,9 @@ The following optional arguments are supported for this command:
         --format FORMAT       Format of the report to produce (html, txt or md)
         --report-file         File to write the report to
         --tool-debug          Enable tool debug logging
-        --report-debug        Include debug messages in the report
-
+        --report-debug
+        --no-report-debug
+                              Include debug messages in report (WARNING: can significantly increase report size)
 If the tool is launched with an environment that can call `xdg-open`, the report
 will be opened in a browser.
 

{amd_debug_tools-0.2.1 → amd_debug_tools-0.2.2}/README.md

@@ -101,8 +101,9 @@ The following optional arguments are supported for this command:
         --format FORMAT       Format of the report to produce (html, txt or md)
         --report-file         File to write the report to
         --tool-debug          Enable tool debug logging
-        --report-debug        Include debug messages in the report
-
+        --report-debug
+        --no-report-debug
+                              Include debug messages in report (WARNING: can significantly increase report size)
 If the tool is launched with an environment that can call `xdg-open`, the report
 will be opened in a browser.
 

{amd_debug_tools-0.2.1 → amd_debug_tools-0.2.2}/src/amd_debug/common.py

@@ -14,6 +14,7 @@ import struct
 import subprocess
 import re
 import sys
+from ast import literal_eval
 from datetime import date, timedelta
 
 
@@ -278,6 +279,19 @@ def get_property_pyudev(properties, key, fallback=""):
         return ""
 
 
+def find_ip_version(base_path, kind, hw_ver) -> bool:
+    """Determine if an IP version is present on the system"""
+    b = os.path.join(base_path, "ip_discovery", "die", "0", kind, "0")
+    for key, expected_value in hw_ver.items():
+        p = os.path.join(b, key)
+        if not os.path.exists(p):
+            return False
+        v = int(read_file(p))
+        if v != expected_value:
+            return False
+    return True
+
+
 def read_msr(msr, cpu):
     """Read a Model-Specific Register (MSR) value from the CPU."""
     p = f"/dev/cpu/{cpu}/msr"
@@ -308,6 +322,16 @@ def running_ssh():
     return "SSH_CLIENT" in os.environ or "SSH_TTY" in os.environ
 
 
+def convert_string_to_bool(str_value) -> bool:
+    """convert a string to a boolean value"""
+    try:
+        value = literal_eval(str_value)
+    except (SyntaxError, ValueError):
+        value = None
+        sys.exit(f"Invalid entry: {str_value}")
+    return bool(value)
+
+
 def _git_describe() -> str:
     """Get the git description of the current commit"""
     try:

{amd_debug_tools-0.2.1 → amd_debug_tools-0.2.2}/src/amd_debug/failures.py

@@ -416,7 +416,7 @@ class LowHardwareSleepResidency(S0i3Failure):
         super().__init__()
         self.description = "System had low hardware sleep residency"
         self.explanation = (
-            f"The system was asleep for {timedelta(seconds=duration)}, but only spent {percent:.2%} "
+            f"The system was asleep for {timedelta(seconds=duration)}, but only spent {percent/100:.2%} "
             "of this time in a hardware sleep state.  In sleep cycles that are at least "
             "60 seconds long it's expected you spend above 90 percent of the cycle in "
             "hardware sleep."
@@ -586,3 +586,15 @@ class RogAllyMcuPowerSave(S0i3Failure):
             "The MCU powersave feature is disabled which will cause problems "
             "with the controller after suspend/resume."
         )
+
+
+class DmcubTooOld(S0i3Failure):
+    """DMCUB microcode is too old"""
+
+    def __init__(self, current, expected):
+        super().__init__()
+        self.description = "DMCUB microcode is too old"
+        self.explanation = (
+            f"The DMCUB microcode version {hex(current)} is older than the"
+            f"minimum suggested version {hex(expected)}."
+        )

{amd_debug_tools-0.2.1 → amd_debug_tools-0.2.2}/src/amd_debug/installer.py

@@ -26,6 +26,7 @@ class Headers:  # pylint: disable=too-few-public-methods
 
     MissingIasl = "ACPI extraction tool `iasl` is missing"
     MissingEdidDecode = "EDID decoding tool `edid-decode` is missing"
+    MissingDiEdidDecode = "EDID decoding tool `di-edid-decode` is missing"
     MissingEthtool = "Ethtool is missing"
     InstallAction = "Attempting to install"
     MissingFwupd = "Firmware update library `fwupd` is missing"
@@ -35,6 +36,7 @@ class Headers:  # pylint: disable=too-few-public-methods
     MissingTabulate = "Data library `tabulate` is missing"
     MissingJinja2 = "Template library `jinja2` is missing"
     MissingSeaborn = "Data visualization library `seaborn` is missing"
+    UnknownDistro = "No distro installation support available, install manually"
 
 
 class DistroPackage:
@@ -71,7 +73,8 @@ class DistroPackage:
                 return False
             installer = ["pacman", "-Sy", self.arch]
         else:
-            return False
+            print_color(Headers.UnknownDistro, "👀")
+            return True
 
         try:
             subprocess.check_call(installer)
@@ -188,6 +191,18 @@ class EdidDecodePackage(DistroPackage):
         )
 
 
+class DisplayInfoPackage(DistroPackage):
+    """display info package"""
+
+    def __init__(self):
+        super().__init__(
+            deb="libdisplay-info-bin",
+            rpm="libdisplay-info",
+            arch="libdisplay-info",
+            message=Headers.MissingDiEdidDecode,
+        )
+
+
 class FwupdPackage(DistroPackage):
     """Fwupd package"""
 
@@ -261,7 +276,19 @@ class Installer(AmdTool):
                 package = EthtoolPackage()
                 if not package.install():
                     return False
+        # can be satisified by either edid-decode or di-edid-decode
         if "edid-decode" in self.requirements:
+            try:
+                di_edid = (
+                    subprocess.call(
+                        ["di-edid-decode", "--help"],
+                        stdout=subprocess.DEVNULL,
+                        stderr=subprocess.DEVNULL,
+                    )
+                    == 255
+                )
+            except FileNotFoundError:
+                di_edid = False
             try:
                 edid = (
                     subprocess.call(
@@ -271,7 +298,12 @@ class Installer(AmdTool):
                 )
             except FileNotFoundError:
                 edid = False
-            if not edid:
+            if not di_edid and not edid:
+                # try to install di-edid-decode first
+                package = DisplayInfoPackage()
+                if package.install():
+                    return True
+                # fall back to edid-decode instead
                 package = EdidDecodePackage()
                 if not package.install():
                     return False

{amd_debug_tools-0.2.1 → amd_debug_tools-0.2.2}/src/amd_debug/prerequisites.py

@@ -26,6 +26,7 @@ from amd_debug.common import (
     apply_prefix_wrapper,
     BIT,
     clear_temporary_message,
+    find_ip_version,
     get_distro,
     get_pretty_distro,
     get_property_pyudev,
@@ -48,6 +49,7 @@ from amd_debug.failures import (
     DevSlpDiskIssue,
     DevSlpHostIssue,
     DMArNotEnabled,
+    DmcubTooOld,
     DmiNotSetup,
     FadtWrong,
     I2CHidBug,
@@ -134,20 +136,24 @@ class PrerequisiteValidator(AmdTool):
             return True
 
         for name, p in edids.items():
-            try:
-                cmd = ["edid-decode", p]
-                output = subprocess.check_output(cmd, stderr=subprocess.DEVNULL).decode(
-                    "utf-8"
-                )
-            except FileNotFoundError:
-                self.db.record_prereq(
-                    "edid-decode not installed, unable to decode EDID", "👀"
-                )
-                return True
-            except subprocess.CalledProcessError as e:
-                self.db.record_prereq(f"Failed to capture EDID table: {e.output}", "👀")
-                return False
-            self.db.record_debug(apply_prefix_wrapper(f"EDID for {name}:", output))
+            output = None
+            for cmd in ["di-edid-decode", "edid-decode"]:
+                try:
+                    cmd = ["edid-decode", p]
+                    output = subprocess.check_output(
+                        cmd, stderr=subprocess.DEVNULL
+                    ).decode("utf-8")
+                    break
+                except FileNotFoundError:
+                    self.db.record_debug(f"{cmd} not installed")
+                except subprocess.CalledProcessError as e:
+                    self.db.record_debug(
+                        f"failed to capture edid with {cmd}: {e.output}"
+                    )
+            if not output:
+                self.db.record_prereq("Failed to capture EDID table", "👀")
+            else:
+                self.db.record_debug(apply_prefix_wrapper(f"EDID for {name}:", output))
         return True
 
     def check_amdgpu(self):
@@ -395,6 +401,53 @@ class PrerequisiteValidator(AmdTool):
             )
         return True
 
+    def check_dpia_pg_dmcub(self):
+        """Check if DMUB is new enough to PG DPIA when no USB4 present"""
+        usb4_found = False
+        for device in self.pyudev.list_devices(subsystem="pci", PCI_CLASS="C0340"):
+            usb4_found = True
+            break
+        if usb4_found:
+            self.db.record_debug("USB4 routers found, no need to check DMCUB version")
+            return True
+        # Check if matching DCN present
+        for device in self.pyudev.list_devices(subsystem="pci"):
+            current = None
+            klass = device.properties.get("PCI_CLASS")
+            if klass not in ["30000", "38000"]:
+                continue
+            pci_id = device.properties.get("PCI_ID")
+            if not pci_id.startswith("1002"):
+                continue
+            hw_ver = {"major": 3, "minor": 5, "revision": 0}
+            if not find_ip_version(device.sys_path, "DMU", hw_ver):
+                continue
+
+            # DCN was found, lookup version from sysfs
+            p = os.path.join(device.sys_path, "fw_version", "dmcub_fw_version")
+            if os.path.exists(p):
+                current = int(read_file(p), 16)
+
+            # no sysfs, try to look for version from debugfs
+            if not current:
+                slot = device.properties["PCI_SLOT_NAME"]
+                p = os.path.join(
+                    "/", "sys", "kernel", "debug", "dri", slot, "amdgpu_firmware_info"
+                )
+                contents = read_file(p)
+                for line in contents.split("\n"):
+                    if not line.startswith("DMCUB"):
+                        continue
+                    current = int(line.split()[-1], 16)
+            if current:
+                expected = 0x09001B00
+                if current >= expected:
+                    return True
+                self.db.record_prereq("DMCUB Firmware is outdated", "❌")
+                self.failures += [DmcubTooOld(current, expected)]
+                return False
+        return True
+
     def check_usb4(self):
         """Check if the thunderbolt driver is loaded"""
         slots = []
@@ -698,9 +751,13 @@ class PrerequisiteValidator(AmdTool):
             interface = device.properties.get("INTERFACE")
             cmd = ["ethtool", interface]
             wol_supported = False
-            output = subprocess.check_output(cmd, stderr=subprocess.DEVNULL).decode(
-                "utf-8"
-            )
+            try:
+                output = subprocess.check_output(cmd, stderr=subprocess.DEVNULL).decode(
+                    "utf-8"
+                )
+            except FileNotFoundError:
+                self.db.record_prereq(f"ethtool is missing", "👀")
+                return True
             for line in output.split("\n"):
                 if "Supports Wake-on" in line:
                     val = line.split(":")[1].strip()
@@ -949,6 +1006,8 @@ class PrerequisiteValidator(AmdTool):
                         stderr=subprocess.DEVNULL,
                     )
                     self.db.record_debug_file(f"{prefix}.dsl")
+                except FileNotFoundError as e:
+                    self.db.record_prereq(f"Failed to capture ACPI table: {e}", "👀")
                 except subprocess.CalledProcessError as e:
                     self.db.record_prereq(
                         f"Failed to capture ACPI table: {e.output}", "👀"
@@ -1099,13 +1158,16 @@ class PrerequisiteValidator(AmdTool):
                 self.db.record_prereq("IOMMU disabled", "✅")
                 return True
             debug_str += "DMA protection:\n"
-            for dev in self.pyudev.list_devices(
-                subsystem="thunderbolt", DEVTYPE="thunderbolt_domain"
-            ):
-                p = os.path.join(dev.sys_path, "iommu_dma_protection")
-                v = int(read_file(p))
-                debug_str += f"\t{p}: {v}\n"
-                found_dmar = v == 1
+            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(
@@ -1205,6 +1267,7 @@ class PrerequisiteValidator(AmdTool):
                 self.check_smt,
                 self.check_iommu,
                 self.check_asus_rog_ally,
+                self.check_dpia_pg_dmcub,
             ]
 
         checks += [

{amd_debug_tools-0.2.1 → amd_debug_tools-0.2.2}/src/amd_debug/s2idle.py

@@ -9,6 +9,7 @@ import sqlite3
 
 from datetime import date, timedelta, datetime
 from amd_debug.common import (
+    convert_string_to_bool,
     colorize_choices,
     is_root,
     relaunch_sudo,
@@ -32,6 +33,7 @@ class Defaults:
     since = date.today() - timedelta(days=60)
     until = date.today() + timedelta(days=1)
     format_choices = ["txt", "md", "html", "stdout"]
+    boolean_choices = ["true", "false"]
 
 
 class Headers:
@@ -47,6 +49,7 @@ class Headers:
     FormatDescription = "What format to output the report in"
     MaxDurationDescription = "What is the maximum suspend cycle length (seconds)"
     MaxWaitDescription = "What is the maximum time between suspend cycles (seconds)"
+    ReportDebugDescription = "Enable debug output in report (increased size)"
 
 
 def display_report_file(fname, fmt) -> None:
@@ -85,7 +88,7 @@ def get_report_format() -> str:
     return "html"
 
 
-def prompt_report_arguments(since, until, fname, fmt) -> str:
+def prompt_report_arguments(since, until, fname, fmt, report_debug) -> str:
     """Prompt user for report configuration"""
     if not since:
         default = Defaults.since
@@ -114,7 +117,16 @@ def prompt_report_arguments(since, until, fname, fmt) -> str:
             fmt = get_report_format()
         if fmt not in Defaults.format_choices:
             sys.exit(f"Invalid format: {fmt}")
-    return [since, until, get_report_file(fname, fmt), fmt]
+    if report_debug is None:
+        inp = (
+            input(
+                f"{Headers.ReportDebugDescription} ({colorize_choices(Defaults.boolean_choices, "true")})? "
+            )
+            .lower()
+            .capitalize()
+        )
+        report_debug = True if not inp else convert_string_to_bool(inp)
+    return [since, until, get_report_file(fname, fmt), fmt, report_debug]
 
 
 def prompt_test_arguments(duration, wait, count, rand) -> list:
@@ -157,7 +169,9 @@ def prompt_test_arguments(duration, wait, count, rand) -> list:
 def report(since, until, fname, fmt, tool_debug, report_debug) -> bool:
     """Generate a report from previous sleep cycles"""
     try:
-        since, until, fname, fmt = prompt_report_arguments(since, until, fname, fmt)
+        since, until, fname, fmt, report_debug = prompt_report_arguments(
+            since, until, fname, fmt, report_debug
+        )
     except KeyboardInterrupt:
         sys.exit("\nReport generation cancelled")
     try:
@@ -209,8 +223,8 @@ def run_test_cycle(
         app = SleepValidator(tool_debug=debug, bios_debug=bios_debug)
         try:
             duration, wait, count = prompt_test_arguments(duration, wait, count, rand)
-            since, until, fname, fmt = prompt_report_arguments(
-                datetime.now().isoformat(), Defaults.until.isoformat(), fname, fmt
+            since, until, fname, fmt, report_debug = prompt_report_arguments(
+                datetime.now().isoformat(), Defaults.until.isoformat(), fname, fmt, True
             )
         except KeyboardInterrupt:
             sys.exit("\nTest cancelled")
@@ -229,7 +243,7 @@ def run_test_cycle(
             fname=fname,
             fmt=fmt,
             tool_debug=debug,
-            report_debug=True,
+            report_debug=report_debug,
         )
         app.run()
 
@@ -347,7 +361,7 @@ def parse_args():
     )
     report_cmd.add_argument(
         "--report-debug",
-        action="store_true",
+        action=argparse.BooleanOptionalAction,
         help="Include debug messages in report (WARNING: can significantly increase report size)",
     )
 

{amd_debug_tools-0.2.1 → amd_debug_tools-0.2.2}/src/amd_debug/sleep_report.py

@@ -432,8 +432,8 @@ class SleepReport(AmdTool):
 
         characters = print_temporary_message("Building report, please wait...")
 
-        # Build charts in the page for html and markdown formats
-        if len(self.df.index) > 1 and (self.format == "html" or self.format == "md"):
+        # 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()
 

{amd_debug_tools-0.2.1 → amd_debug_tools-0.2.2}/src/amd_debug/templates/md

@@ -28,12 +28,5 @@ Measured {{ prereq_date }}.
 ## Summary
 {{ summary }}
 
-{% if battery_svg %}
-{{ battery_svg | safe }}
-{% endif %}
-{% if hwsleep_svg %}
-{{ hwsleep_svg | safe }}
-{% endif %}
-
 ## Failures reported
 {{ failures }}

{amd_debug_tools-0.2.1 → amd_debug_tools-0.2.2}/src/amd_debug/validator.py

@@ -469,12 +469,10 @@ class SleepValidator(AmdTool):
                     )
                 return False
             except FileNotFoundError:
-                self.db.record_cycle_data("HW sleep statistics file missing", "❌")
-                return False
+                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 is not None
+        return self.hw_sleep_duration
 
     def capture_command_line(self):
         """Capture the kernel command line to debug"""
@@ -674,7 +672,7 @@ class SleepValidator(AmdTool):
     def prep(self):
         """Prepare the system for suspend testing"""
         self.last_suspend = datetime.now()
-        self.kernel_log.seek_tail()
+        self.kernel_log.seek_tail(self.last_suspend)
         self.db.start_cycle(self.last_suspend)
         self.kernel_duration = 0
         self.hw_sleep_duration = 0

{amd_debug_tools-0.2.1 → amd_debug_tools-0.2.2}/src/amd_debug_tools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amd-debug-tools
-Version: 0.2.1
+Version: 0.2.2
 Summary: debug tools for AMD systems
 Author-email: Mario Limonciello <superm1@kernel.org>
 License-Expression: MIT
@@ -125,8 +125,9 @@ The following optional arguments are supported for this command:
         --format FORMAT       Format of the report to produce (html, txt or md)
         --report-file         File to write the report to
         --tool-debug          Enable tool debug logging
-        --report-debug        Include debug messages in the report
-
+        --report-debug
+        --no-report-debug
+                              Include debug messages in report (WARNING: can significantly increase report size)
 If the tool is launched with an environment that can call `xdg-open`, the report
 will be opened in a browser.
 

{amd_debug_tools-0.2.1 → amd_debug_tools-0.2.2}/src/test_common.py

@@ -16,9 +16,11 @@ from platform import uname_result
 from amd_debug.common import (
     apply_prefix_wrapper,
     Colors,
+    convert_string_to_bool,
     colorize_choices,
     check_lockdown,
     compare_file,
+    find_ip_version,
     fatal_error,
     get_distro,
     get_log_priority,
@@ -330,3 +332,113 @@ class TestCommon(unittest.TestCase):
         default = "option1"
         expected_output = f"{Colors.OK}{default}{Colors.ENDC}"
         self.assertEqual(colorize_choices(choices, default), expected_output)
+
+    @patch("amd_debug.common.read_file")
+    @patch("os.path.exists")
+    def test_find_ip_version_found(self, mock_exists, mock_read_file):
+        """Test find_ip_version returns True when expected value is found"""
+        base_path = "/foo"
+        kind = "bar"
+        hw_ver = {"baz": 42}
+
+        # Simulate file exists and value matches
+        def exists_side_effect(path):
+            return True
+
+        mock_exists.side_effect = exists_side_effect
+        mock_read_file.return_value = "42"
+        result = find_ip_version(base_path, kind, hw_ver)
+        self.assertTrue(result)
+        b = os.path.join(base_path, "ip_discovery", "die", "0", kind, "0")
+        expected_path = os.path.join(b, "baz")
+        mock_exists.assert_any_call(expected_path)
+        mock_read_file.assert_any_call(expected_path)
+
+    @patch("amd_debug.common.read_file")
+    @patch("os.path.exists")
+    def test_find_ip_version_not_found_due_to_missing_file(
+        self, mock_exists, mock_read_file
+    ):
+        """Test find_ip_version returns False if file does not exist"""
+        base_path = "/foo"
+        kind = "bar"
+        hw_ver = {"baz": 42}
+        # Simulate file does not exist
+        mock_exists.return_value = False
+        result = find_ip_version(base_path, kind, hw_ver)
+        self.assertFalse(result)
+        b = os.path.join(base_path, "ip_discovery", "die", "0", kind, "0")
+        expected_path = os.path.join(b, "baz")
+        mock_exists.assert_any_call(expected_path)
+        mock_read_file.assert_not_called()
+
+    @patch("amd_debug.common.read_file")
+    @patch("os.path.exists")
+    def test_find_ip_version_not_found_due_to_value_mismatch(
+        self, mock_exists, mock_read_file
+    ):
+        """Test find_ip_version returns False if value does not match"""
+        base_path = "/foo"
+        kind = "bar"
+        hw_ver = {"baz": 42}
+        # Simulate file exists but value does not match
+        mock_exists.return_value = True
+        mock_read_file.return_value = "99"
+        result = find_ip_version(base_path, kind, hw_ver)
+        self.assertFalse(result)
+        b = os.path.join(base_path, "ip_discovery", "die", "0", kind, "0")
+        expected_path = os.path.join(b, "baz")
+        mock_exists.assert_any_call(expected_path)
+        mock_read_file.assert_any_call(expected_path)
+
+    @patch("amd_debug.common.read_file")
+    @patch("os.path.exists")
+    def test_find_ip_version_multiple_keys(self, mock_exists, mock_read_file):
+        """Test find_ip_version with multiple keys in hw_ver"""
+        base_path = "/foo"
+        kind = "bar"
+        hw_ver = {"baz": 42, "qux": 99}
+
+        # First key: file exists, value does not match
+        # Second key: file exists, value matches
+        def exists_side_effect(path):
+            return True
+
+        def read_file_side_effect(path):
+            if path.endswith("baz"):
+                return "0"
+            if path.endswith("qux"):
+                return "99"
+            return "0"
+
+        mock_exists.side_effect = exists_side_effect
+        mock_read_file.side_effect = read_file_side_effect
+        result = find_ip_version(base_path, kind, hw_ver)
+        self.assertFalse(result)
+
+    def test_convert_string_to_bool_true_values(self):
+        """Test convert_string_to_bool returns True for truthy string values"""
+        self.assertTrue(convert_string_to_bool("True"))
+        self.assertTrue(convert_string_to_bool("1"))
+        self.assertTrue(convert_string_to_bool("'nonempty'"))
+        self.assertTrue(convert_string_to_bool('"nonempty"'))
+
+    def test_convert_string_to_bool_false_values(self):
+        """Test convert_string_to_bool returns False for falsy string values"""
+        self.assertFalse(convert_string_to_bool("False"))
+        self.assertFalse(convert_string_to_bool("0"))
+        self.assertFalse(convert_string_to_bool("''"))
+        self.assertFalse(convert_string_to_bool('""'))
+        self.assertFalse(convert_string_to_bool("None"))
+
+    def test_convert_string_to_bool_invalid_syntax(self):
+        """Test convert_string_to_bool exits on invalid syntax"""
+        with patch("sys.exit") as mock_exit:
+            convert_string_to_bool("not_a_bool")
+            mock_exit.assert_called_once_with("Invalid entry: not_a_bool")
+
+    def test_convert_string_to_bool_invalid_value(self):
+        """Test convert_string_to_bool exits on invalid value"""
+        with patch("sys.exit") as mock_exit:
+            convert_string_to_bool("[unclosed_list")
+            mock_exit.assert_called_once_with("Invalid entry: [unclosed_list")