334 lines
14 KiB
Python
334 lines
14 KiB
Python
"""
|
|
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
|
|
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',
|
|
])
|
|
|