"""
Test some lldb help commands.

See also CommandInterpreter::OutputFormattedHelpText().
"""


import os
import lldb
from lldbsuite.test.decorators import *
from lldbsuite.test.lldbtest import *
from lldbsuite.test import lldbutil


class HelpCommandTestCase(TestBase):
    @no_debug_info_test
    def test_simplehelp(self):
        """A simple test of 'help' command and its output."""
        self.expect("help", startstr="Debugger commands:")

        self.expect("help -a", matching=False, substrs=["next"])

        self.expect("help", matching=True, substrs=["next"])

    @no_debug_info_test
    def test_help_on_help(self):
        """Testing the help on the help facility."""
        self.expect(
            "help help",
            matching=True,
            substrs=["--hide-aliases", "--hide-user-commands"],
        )

    @no_debug_info_test
    def test_help_arch(self):
        """Test 'help arch' which should list of supported architectures."""
        self.expect("help arch", substrs=["arm", "i386", "x86_64"])

    @no_debug_info_test
    @swiftTest # Checks for the Swift version number in the output
    def test_help_version(self):
        """Test 'help version' and 'version' commands."""
        self.expect("help version", substrs=["Show the LLDB debugger version."])
        self.expect("version", patterns=["lldb( version|-[0-9]+).*\n"])

    @no_debug_info_test
    def test_help_should_not_crash_lldb(self):
        """Command 'help disasm' should not crash lldb."""
        self.runCmd("help disasm", check=False)
        self.runCmd("help unsigned-integer")

    @no_debug_info_test
    def test_help_memory_read_should_not_crash_lldb(self):
        """Command 'help memory read' should not crash lldb."""
        self.runCmd("help memory read", check=False)

    @no_debug_info_test
    def test_help_should_not_hang_emacsshell(self):
        """Command 'settings set term-width 0' should not hang the help command."""
        self.expect(
            "settings set term-width 0",
            COMMAND_FAILED_AS_EXPECTED,
            error=True,
            substrs=["error: 0 is out of range, valid values must be between"],
        )
        # self.runCmd("settings set term-width 0")
        self.expect("help", startstr="Debugger commands:")

    @no_debug_info_test
    def test_help_breakpoint_set(self):
        """Test that 'help breakpoint set' does not print out redundant lines of:
        'breakpoint set [-s <shlib-name>] ...'."""
        self.expect(
            "help breakpoint set",
            matching=False,
            substrs=["breakpoint set [-s <shlib-name>]"],
        )

    @no_debug_info_test
    def test_help_image_dump_symtab_should_not_crash(self):
        """Command 'help image dump symtab' should not crash lldb."""
        # 'image' is an alias for 'target modules'.
        self.expect("help image dump symtab", substrs=["dump symtab", "sort-order"])

    @no_debug_info_test
    def test_help_image_du_sym_is_ambiguous(self):
        """Command 'help image du sym' is ambiguous and spits out the list of candidates."""
        self.expect(
            "help image du sym",
            COMMAND_FAILED_AS_EXPECTED,
            error=True,
            substrs=["error: ambiguous command image du sym", "symfile", "symtab"],
        )

    @no_debug_info_test
    def test_help_image_du_line_should_work(self):
        """Command 'help image du line-table' is not ambiguous and should work."""
        # 'image' is an alias for 'target modules'.
        self.expect(
            "help image du line",
            substrs=["Dump the line table for one or more compilation units"],
        )

    @no_debug_info_test
    def test_help_image_list_shows_positional_args(self):
        """Command 'help image list' should describe positional args."""
        # 'image' is an alias for 'target modules'.
        self.expect("help image list", substrs=["<shlib-name> [...]"])

    @no_debug_info_test
    def test_help_target_variable_syntax(self):
        """Command 'help target variable' should display <variable-name> ..."""
        self.expect(
            "help target variable", substrs=["<variable-name> [<variable-name> [...]]"]
        )

    @no_debug_info_test
    def test_help_watchpoint_and_its_args(self):
        """Command 'help watchpoint', 'help watchpt-id', and 'help watchpt-id-list' should work."""
        self.expect("help watchpoint", substrs=["delete", "disable", "enable", "list"])
        self.expect("help watchpt-id", substrs=["<watchpt-id>"])
        self.expect("help watchpt-id-list", substrs=["<watchpt-id-list>"])

    @no_debug_info_test
    def test_help_watchpoint_set(self):
        """Test that 'help watchpoint set' prints out 'expression' and 'variable'
        as the possible subcommands."""
        self.expect(
            "help watchpoint set",
            substrs=["The following subcommands are supported:"],
            patterns=["expression +--", "variable +--"],
        )

    @no_debug_info_test
    def test_help_po_hides_options(self):
        """Test that 'help po' does not show all the options for expression"""
        self.expect(
            "help po",
            substrs=["--show-all-children", "--object-description"],
            matching=False,
        )

    @no_debug_info_test
    def test_help_run_hides_options(self):
        """Test that 'help run' does not show all the options for process launch"""
        self.expect("help run", substrs=["--arch", "--environment"], matching=False)

    @no_debug_info_test
    def test_help_next_shows_options(self):
        """Test that 'help next' shows all the options for thread step-over"""
        self.expect(
            "help next",
            substrs=["--step-out-avoids-no-debug", "--run-mode"],
            matching=True,
        )

    @no_debug_info_test
    def test_help_provides_alternatives(self):
        """Test that help on commands that don't exist provides information on additional help avenues"""
        self.expect(
            "help thisisnotadebuggercommand",
            substrs=[
                "'thisisnotadebuggercommand' is not a known command.",
                "Try 'help' to see a current list of commands.",
                "Try 'apropos thisisnotadebuggercommand' for a list of related commands.",
                "Try 'type lookup thisisnotadebuggercommand' for information on types, methods, functions, modules, etc.",
            ],
            error=True,
        )

        self.expect(
            "help process thisisnotadebuggercommand",
            substrs=[
                "'process thisisnotadebuggercommand' is not a known command.",
                "Try 'help' to see a current list of commands.",
                "Try 'apropos thisisnotadebuggercommand' for a list of related commands.",
                "Try 'type lookup thisisnotadebuggercommand' for information on types, methods, functions, modules, etc.",
            ],
        )

    @no_debug_info_test
    def test_custom_help_alias(self):
        """Test that aliases pick up custom help text."""

        def cleanup():
            self.runCmd("command unalias afriendlyalias", check=False)
            self.runCmd("command unalias averyfriendlyalias", check=False)

        self.addTearDownHook(cleanup)
        self.runCmd(
            'command alias --help "I am a friendly alias" -- afriendlyalias help'
        )
        self.expect(
            "help afriendlyalias", matching=True, substrs=["I am a friendly alias"]
        )
        self.runCmd(
            'command alias --long-help "I am a very friendly alias" -- averyfriendlyalias help'
        )
        self.expect(
            "help averyfriendlyalias",
            matching=True,
            substrs=["I am a very friendly alias"],
        )

    @no_debug_info_test
    def test_alias_prints_origin(self):
        """Test that 'help <unique_match_to_alias>' prints the alias origin."""

        def cleanup():
            self.runCmd("command unalias alongaliasname", check=False)

        self.addTearDownHook(cleanup)
        self.runCmd("command alias alongaliasname help")
        self.expect(
            "help alongaliasna",
            matching=True,
            substrs=["'alongaliasna' is an abbreviation for 'help'"],
        )

    @no_debug_info_test
    def test_hidden_help(self):
        self.expect("help -h", substrs=["_regexp-bt"])

    @no_debug_info_test
    def test_help_ambiguous(self):
        self.expect(
            "help g",
            substrs=[
                "Help requested with ambiguous command name, possible completions:",
                "gdb-remote",
                "gui",
            ],
        )

    @no_debug_info_test
    def test_help_unknown_flag(self):
        self.expect("help -z", error=True, substrs=["unknown or ambiguous option"])

    @no_debug_info_test
    def test_help_format_output(self):
        """Test that help output reaches TerminalWidth."""
        self.runCmd("settings set term-width 108")
        self.expect(
            "help format",
            matching=True,
            substrs=["<format> -- One of the format names"],
        )

    @no_debug_info_test
    def test_help_option_group_format_options_usage(self):
        """Test that help on commands that use OptionGroupFormat options provide relevant help specific to that command."""
        self.expect(
            "help memory read",
            matching=True,
            substrs=[
                "-f <format> ( --format <format> )",
                "Specify a format to be used for display.",
                "-s <byte-size> ( --size <byte-size> )",
                "The size in bytes to use when displaying with the selected format.",
            ],
        )

        self.expect(
            "help memory write",
            matching=True,
            substrs=[
                "-f <format> ( --format <format> )",
                "The format to use for each of the value to be written.",
                "-s <byte-size> ( --size <byte-size> )",
                "The size in bytes to write from input file or each value.",
            ],
        )

    @no_debug_info_test
    def test_help_shows_optional_short_options(self):
        """Test that optional short options are printed and that they are in
        alphabetical order with upper case options first."""
        self.expect(
            "help memory read", substrs=["memory read [-br]", "memory read [-AFLORTr]"]
        )
        self.expect(
            "help target modules lookup", substrs=["target modules lookup [-Airv]"]
        )

    @no_debug_info_test
    def test_help_shows_command_options_usage(self):
        """Test that we start the usage section with a specific line."""
        self.expect(
            "help memory read", substrs=["Command Options Usage:\n  memory read"]
        )

    @no_debug_info_test
    def test_help_detailed_information_spacing(self):
        """Test that we put a break between the usage and the options help lines,
        and between the options themselves."""
        self.expect(
            "help memory read",
            substrs=[
                "[<address-expression>]\n\n       -A ( --show-all-children )",
                # Starts with the end of the show-all-children line
                "to show.\n\n       -D",
            ],
        )

    @no_debug_info_test
    def test_help_detailed_information_ordering(self):
        """Test that we order options alphabetically, upper case first."""
        # You could test this with a simple regex like:
        # <upper case>.*<later upper case>.*<lower case>.*<later lower case>
        # Except that that could pass sometimes even with shuffled output.
        # This makes sure that doesn't happen.

        self.runCmd("help memory read")
        got = self.res.GetOutput()
        _, options_lines = got.split("Command Options Usage:")
        options_lines = options_lines.lstrip().splitlines()

        # Skip over "memory read [-xyz] lines.
        while "memory read" in options_lines[0]:
            options_lines.pop(0)
        # Plus the newline after that.
        options_lines.pop(0)

        short_options = []
        for line in options_lines:
            # Ignore line breaks and descriptions.
            # (not stripping the line here in case some line of the descriptions
            # happens to start with "-")
            if not line or not line.startswith("       -"):
                continue
            # This apears at the end after the options.
            if "This command takes options and free form arguments." in line:
                break
            line = line.strip()
            # The order of -- only options is not enforced so ignore their position.
            if not line.startswith("--"):
                # Save its short char name.
                short_options.append(line[1])

        self.assertEqual(
            sorted(short_options),
            short_options,
            "Short option help displayed in an incorrect order!",
        )

    @no_debug_info_test
    def test_help_show_tags(self):
        """Check that memory find and memory read have the --show-tags option
        but only memory read mentions binary output."""
        self.expect(
            "help memory read",
            patterns=[
                "--show-tags\n\s+Include memory tags in output "
                "\(does not apply to binary output\)."
            ],
        )
        self.expect(
            "help memory find",
            patterns=["--show-tags\n\s+Include memory tags in output."],
        )

    @no_debug_info_test
    def test_help_show_enum_values(self):
        """Check the help output for a argument type contains the enum values
        and their descriptions."""
        self.expect(
            "help <log-handler>",
            substrs=[
                "The log handle that will be used to write out log messages.",
                "default",
                "Use the default (stream) log handler",
                "stream",
                "Write log messages to the debugger output stream",
                "circular",
                "Write log messages to a fixed size circular buffer",
                "os",
                "Write log messages to the operating system log",
            ],
        )