| """ |
| Test the lldb command line completion mechanism. |
| """ |
| |
| |
| |
| import os |
| from multiprocessing import Process |
| import lldb |
| from lldbsuite.test.decorators import * |
| from lldbsuite.test.lldbtest import * |
| from lldbsuite.test import lldbplatform |
| from lldbsuite.test import lldbutil |
| |
| |
| class CommandLineCompletionTestCase(TestBase): |
| |
| mydir = TestBase.compute_mydir(__file__) |
| |
| NO_DEBUG_INFO_TESTCASE = True |
| |
| @classmethod |
| def classCleanup(cls): |
| """Cleanup the test byproducts.""" |
| try: |
| os.remove("child_send.txt") |
| os.remove("child_read.txt") |
| except: |
| pass |
| |
| def test_at(self): |
| """Test that 'at' completes to 'attach '.""" |
| self.complete_from_to('at', 'attach ') |
| |
| def test_de(self): |
| """Test that 'de' completes to 'detach '.""" |
| self.complete_from_to('de', 'detach ') |
| |
| def test_frame_variable(self): |
| self.build() |
| self.main_source = "main.cpp" |
| self.main_source_spec = lldb.SBFileSpec(self.main_source) |
| |
| (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self, |
| '// Break here', self.main_source_spec) |
| self.assertEquals(process.GetState(), lldb.eStateStopped) |
| |
| # Since CommandInterpreter has been corrected to update the current execution |
| # context at the beginning of HandleCompletion, we're here explicitly testing |
| # the scenario where "frame var" is completed without any preceding commands. |
| |
| self.complete_from_to('frame variable fo', |
| 'frame variable fooo') |
| self.complete_from_to('frame variable fooo.', |
| 'frame variable fooo.') |
| self.complete_from_to('frame variable fooo.dd', |
| 'frame variable fooo.dd') |
| |
| self.complete_from_to('frame variable ptr_fooo->', |
| 'frame variable ptr_fooo->') |
| self.complete_from_to('frame variable ptr_fooo->dd', |
| 'frame variable ptr_fooo->dd') |
| |
| self.complete_from_to('frame variable cont', |
| 'frame variable container') |
| self.complete_from_to('frame variable container.', |
| 'frame variable container.MemberVar') |
| self.complete_from_to('frame variable container.Mem', |
| 'frame variable container.MemberVar') |
| |
| self.complete_from_to('frame variable ptr_cont', |
| 'frame variable ptr_container') |
| self.complete_from_to('frame variable ptr_container->', |
| 'frame variable ptr_container->MemberVar') |
| self.complete_from_to('frame variable ptr_container->Mem', |
| 'frame variable ptr_container->MemberVar') |
| |
| def test_process_attach_dash_dash_con(self): |
| """Test that 'process attach --con' completes to 'process attach --continue '.""" |
| self.complete_from_to( |
| 'process attach --con', |
| 'process attach --continue ') |
| |
| def test_process_launch_arch(self): |
| self.complete_from_to('process launch --arch ', |
| ['mips', |
| 'arm64']) |
| |
| def test_process_load(self): |
| self.build() |
| lldbutil.run_to_source_breakpoint(self, '// Break here', lldb.SBFileSpec("main.cpp")) |
| self.complete_from_to('process load Makef', 'process load Makefile') |
| |
| @skipUnlessPlatform(["linux"]) |
| def test_process_unload(self): |
| """Test the completion for "process unload <index>" """ |
| # This tab completion should not work without a running process. |
| self.complete_from_to('process unload ', |
| 'process unload ') |
| |
| self.build() |
| lldbutil.run_to_source_breakpoint(self, '// Break here', lldb.SBFileSpec("main.cpp")) |
| err = lldb.SBError() |
| self.process().LoadImage(lldb.SBFileSpec(self.getBuildArtifact("libshared.so")), err) |
| self.assertSuccess(err) |
| |
| self.complete_from_to('process unload ', |
| 'process unload 0') |
| |
| self.process().UnloadImage(0) |
| self.complete_from_to('process unload ', |
| 'process unload ') |
| |
| def test_process_plugin_completion(self): |
| subcommands = ['attach -P', 'connect -p', 'launch -p'] |
| |
| for subcommand in subcommands: |
| self.complete_from_to('process ' + subcommand + ' mac', |
| 'process ' + subcommand + ' mach-o-core') |
| |
| def completions_contain_str(self, input, needle): |
| interp = self.dbg.GetCommandInterpreter() |
| match_strings = lldb.SBStringList() |
| num_matches = interp.HandleCompletion(input, len(input), 0, -1, match_strings) |
| found_needle = False |
| for match in match_strings: |
| if needle in match: |
| found_needle = True |
| break |
| self.assertTrue(found_needle, "Returned completions: " + "\n".join(match_strings)) |
| |
| |
| @skipIfRemote |
| @skipIfReproducer |
| def test_common_completion_process_pid_and_name(self): |
| # The LLDB process itself and the process already attached to are both |
| # ignored by the process discovery mechanism, thus we need a process known |
| # to us here. |
| self.build() |
| server = self.spawnSubprocess( |
| self.getBuildArtifact("a.out"), |
| ["-x"], # Arg "-x" makes the subprocess wait for input thus it won't be terminated too early |
| install_remote=False) |
| self.assertIsNotNone(server) |
| pid = server.pid |
| |
| self.completions_contain('process attach -p ', [str(pid)]) |
| self.completions_contain('platform process attach -p ', [str(pid)]) |
| self.completions_contain('platform process info ', [str(pid)]) |
| |
| self.completions_contain_str('process attach -n ', "a.out") |
| self.completions_contain_str('platform process attach -n ', "a.out") |
| |
| def test_process_signal(self): |
| # The tab completion for "process signal" won't work without a running process. |
| self.complete_from_to('process signal ', |
| 'process signal ') |
| |
| # Test with a running process. |
| self.build() |
| self.main_source = "main.cpp" |
| self.main_source_spec = lldb.SBFileSpec(self.main_source) |
| lldbutil.run_to_source_breakpoint(self, '// Break here', self.main_source_spec) |
| |
| self.complete_from_to('process signal ', |
| 'process signal SIG') |
| self.complete_from_to('process signal SIGA', |
| ['SIGABRT', |
| 'SIGALRM']) |
| |
| def test_ambiguous_long_opt(self): |
| self.completions_match('breakpoint modify --th', |
| ['--thread-id', |
| '--thread-index', |
| '--thread-name']) |
| |
| def test_disassemble_dash_f(self): |
| self.completions_match('disassemble -F ', |
| ['default', |
| 'intel', |
| 'att']) |
| |
| def test_plugin_load(self): |
| self.complete_from_to('plugin load ', []) |
| |
| def test_log_enable(self): |
| self.complete_from_to('log enable ll', ['lldb']) |
| self.complete_from_to('log enable dw', ['dwarf']) |
| self.complete_from_to('log enable lldb al', ['all']) |
| self.complete_from_to('log enable lldb sym', ['symbol']) |
| |
| def test_log_enable(self): |
| self.complete_from_to('log disable ll', ['lldb']) |
| self.complete_from_to('log disable dw', ['dwarf']) |
| self.complete_from_to('log disable lldb al', ['all']) |
| self.complete_from_to('log disable lldb sym', ['symbol']) |
| |
| def test_log_list(self): |
| self.complete_from_to('log list ll', ['lldb']) |
| self.complete_from_to('log list dw', ['dwarf']) |
| self.complete_from_to('log list ll', ['lldb']) |
| self.complete_from_to('log list lldb dwa', ['dwarf']) |
| |
| def test_quoted_command(self): |
| self.complete_from_to('"set', |
| ['"settings" ']) |
| |
| def test_quoted_arg_with_quoted_command(self): |
| self.complete_from_to('"settings" "repl', |
| ['"replace" ']) |
| |
| def test_quoted_arg_without_quoted_command(self): |
| self.complete_from_to('settings "repl', |
| ['"replace" ']) |
| |
| def test_single_quote_command(self): |
| self.complete_from_to("'set", |
| ["'settings' "]) |
| |
| def test_terminated_quote_command(self): |
| # This should not crash, but we don't get any |
| # reasonable completions from this. |
| self.complete_from_to("'settings'", []) |
| |
| def test_process_launch_arch_arm(self): |
| self.complete_from_to('process launch --arch arm', |
| ['arm64']) |
| |
| def test_target_symbols_add_shlib(self): |
| # Doesn't seem to work, but at least it shouldn't crash. |
| self.complete_from_to('target symbols add --shlib ', []) |
| |
| def test_log_file(self): |
| # Complete in our source directory which contains a 'main.cpp' file. |
| src_dir = os.path.dirname(os.path.realpath(__file__)) + '/' |
| self.complete_from_to('log enable lldb expr -f ' + src_dir, |
| ['main.cpp']) |
| |
| def test_log_dir(self): |
| # Complete our source directory. |
| src_dir = os.path.dirname(os.path.realpath(__file__)) |
| self.complete_from_to('log enable lldb expr -f ' + src_dir, |
| [src_dir + os.sep], turn_off_re_match=True) |
| |
| # <rdar://problem/11052829> |
| def test_infinite_loop_while_completing(self): |
| """Test that 'process print hello\' completes to itself and does not infinite loop.""" |
| self.complete_from_to('process print hello\\', 'process print hello\\', |
| turn_off_re_match=True) |
| |
| def test_watchpoint_co(self): |
| """Test that 'watchpoint co' completes to 'watchpoint command '.""" |
| self.complete_from_to('watchpoint co', 'watchpoint command ') |
| |
| def test_watchpoint_command_space(self): |
| """Test that 'watchpoint command ' completes to ['add', 'delete', 'list'].""" |
| self.complete_from_to( |
| 'watchpoint command ', [ |
| 'add', 'delete', 'list']) |
| |
| def test_watchpoint_command_a(self): |
| """Test that 'watchpoint command a' completes to 'watchpoint command add '.""" |
| self.complete_from_to( |
| 'watchpoint command a', |
| 'watchpoint command add ') |
| |
| def test_watchpoint_set_ex(self): |
| """Test that 'watchpoint set ex' completes to 'watchpoint set expression '.""" |
| self.complete_from_to( |
| 'watchpoint set ex', |
| 'watchpoint set expression ') |
| |
| def test_watchpoint_set_var(self): |
| """Test that 'watchpoint set var' completes to 'watchpoint set variable '.""" |
| self.complete_from_to('watchpoint set var', 'watchpoint set variable ') |
| |
| def test_watchpoint_set_variable_foo(self): |
| self.build() |
| lldbutil.run_to_source_breakpoint(self, '// Break here', lldb.SBFileSpec("main.cpp")) |
| self.complete_from_to('watchpoint set variable fo', 'watchpoint set variable fooo') |
| # Only complete the first argument. |
| self.complete_from_to('watchpoint set variable fooo ', 'watchpoint set variable fooo ') |
| |
| def test_help_fi(self): |
| """Test that 'help fi' completes to ['file', 'finish'].""" |
| self.complete_from_to( |
| 'help fi', [ |
| 'file', 'finish']) |
| |
| def test_help_watchpoint_s(self): |
| """Test that 'help watchpoint s' completes to 'help watchpoint set '.""" |
| self.complete_from_to('help watchpoint s', 'help watchpoint set ') |
| |
| @expectedFailureNetBSD |
| def test_common_complete_watchpoint_ids(self): |
| subcommands = ['enable', 'disable', 'delete', 'modify', 'ignore'] |
| |
| # Completion should not work without a target. |
| for subcommand in subcommands: |
| self.complete_from_to('watchpoint ' + subcommand + ' ', |
| 'watchpoint ' + subcommand + ' ') |
| |
| # Create a process to provide a target and enable watchpoint setting. |
| self.build() |
| lldbutil.run_to_source_breakpoint(self, '// Break here', lldb.SBFileSpec("main.cpp")) |
| |
| self.runCmd('watchpoint set variable ptr_fooo') |
| for subcommand in subcommands: |
| self.complete_from_to('watchpoint ' + subcommand + ' ', ['1']) |
| |
| def test_settings_append_target_er(self): |
| """Test that 'settings append target.er' completes to 'settings append target.error-path'.""" |
| self.complete_from_to( |
| 'settings append target.er', |
| 'settings append target.error-path') |
| |
| def test_settings_insert_after_target_en(self): |
| """Test that 'settings insert-after target.env' completes to 'settings insert-after target.env-vars'.""" |
| self.complete_from_to( |
| 'settings insert-after target.env', |
| 'settings insert-after target.env-vars') |
| |
| def test_settings_insert_before_target_en(self): |
| """Test that 'settings insert-before target.env' completes to 'settings insert-before target.env-vars'.""" |
| self.complete_from_to( |
| 'settings insert-before target.env', |
| 'settings insert-before target.env-vars') |
| |
| def test_settings_replace_target_ru(self): |
| """Test that 'settings replace target.ru' completes to 'settings replace target.run-args'.""" |
| self.complete_from_to( |
| 'settings replace target.ru', |
| 'settings replace target.run-args') |
| |
| def test_settings_show_term(self): |
| self.complete_from_to( |
| 'settings show term-', |
| 'settings show term-width') |
| |
| def test_settings_list_term(self): |
| self.complete_from_to( |
| 'settings list term-', |
| 'settings list term-width') |
| |
| def test_settings_remove_term(self): |
| self.complete_from_to( |
| 'settings remove term-', |
| 'settings remove term-width') |
| |
| def test_settings_s(self): |
| """Test that 'settings s' completes to ['set', 'show'].""" |
| self.complete_from_to( |
| 'settings s', [ |
| 'set', 'show']) |
| |
| def test_settings_set_th(self): |
| """Test that 'settings set thread-f' completes to 'settings set thread-format'.""" |
| self.complete_from_to('settings set thread-f', 'settings set thread-format') |
| |
| def test_settings_s_dash(self): |
| """Test that 'settings set --g' completes to 'settings set --global'.""" |
| self.complete_from_to('settings set --g', 'settings set --global') |
| |
| def test_settings_clear_th(self): |
| """Test that 'settings clear thread-f' completes to 'settings clear thread-format'.""" |
| self.complete_from_to( |
| 'settings clear thread-f', |
| 'settings clear thread-format') |
| |
| def test_settings_set_ta(self): |
| """Test that 'settings set ta' completes to 'settings set target.'.""" |
| self.complete_from_to( |
| 'settings set target.ma', |
| 'settings set target.max-') |
| |
| def test_settings_set_target_exec(self): |
| """Test that 'settings set target.exec' completes to 'settings set target.exec-search-paths '.""" |
| self.complete_from_to( |
| 'settings set target.exec', |
| 'settings set target.exec-search-paths') |
| |
| def test_settings_set_target_pr(self): |
| """Test that 'settings set target.pr' completes to [ |
| 'target.prefer-dynamic-value', 'target.process.'].""" |
| self.complete_from_to('settings set target.pr', |
| ['target.prefer-dynamic-value', |
| 'target.process.']) |
| |
| def test_settings_set_target_process(self): |
| """Test that 'settings set target.process' completes to 'settings set target.process.'.""" |
| self.complete_from_to( |
| 'settings set target.process', |
| 'settings set target.process.') |
| |
| def test_settings_set_target_process_dot(self): |
| """Test that 'settings set target.process.t' completes to 'settings set target.process.thread.'.""" |
| self.complete_from_to( |
| 'settings set target.process.t', |
| 'settings set target.process.thread.') |
| |
| def test_settings_set_target_process_thread_dot(self): |
| """Test that 'settings set target.process.thread.' completes to [ |
| 'target.process.thread.step-avoid-regexp', 'target.process.thread.trace-thread'].""" |
| self.complete_from_to('settings set target.process.thread.', |
| ['target.process.thread.step-avoid-regexp', |
| 'target.process.thread.trace-thread']) |
| |
| def test_thread_plan_discard(self): |
| self.build() |
| (_, _, thread, _) = lldbutil.run_to_source_breakpoint(self, |
| 'ptr_foo', lldb.SBFileSpec("main.cpp")) |
| self.assertTrue(thread) |
| self.complete_from_to('thread plan discard ', 'thread plan discard ') |
| |
| source_path = os.path.join(self.getSourceDir(), "thread_plan_script.py") |
| self.runCmd("command script import '%s'"%(source_path)) |
| self.runCmd("thread step-scripted -C thread_plan_script.PushPlanStack") |
| self.complete_from_to('thread plan discard ', 'thread plan discard 1') |
| self.runCmd('thread plan discard 1') |
| |
| def test_target_space(self): |
| """Test that 'target ' completes to ['create', 'delete', 'list', |
| 'modules', 'select', 'stop-hook', 'variable'].""" |
| self.complete_from_to('target ', |
| ['create', |
| 'delete', |
| 'list', |
| 'modules', |
| 'select', |
| 'stop-hook', |
| 'variable']) |
| |
| def test_target_modules_dump_line_table(self): |
| """Tests source file completion by completing the line-table argument.""" |
| self.build() |
| self.dbg.CreateTarget(self.getBuildArtifact("a.out")) |
| self.complete_from_to('target modules dump line-table main.cp', |
| ['main.cpp']) |
| |
| def test_target_modules_load_aout(self): |
| """Tests modules completion by completing the target modules load argument.""" |
| self.build() |
| self.dbg.CreateTarget(self.getBuildArtifact("a.out")) |
| self.complete_from_to('target modules load a.ou', |
| ['a.out']) |
| |
| def test_target_modules_search_paths_insert(self): |
| # Completion won't work without a valid target. |
| self.complete_from_to("target modules search-paths insert ", "target modules search-paths insert ") |
| self.build() |
| target = self.dbg.CreateTarget(self.getBuildArtifact('a.out')) |
| self.assertTrue(target, VALID_TARGET) |
| self.complete_from_to("target modules search-paths insert ", "target modules search-paths insert ") |
| self.runCmd("target modules search-paths add a b") |
| self.complete_from_to("target modules search-paths insert ", "target modules search-paths insert 0") |
| # Completion only works for the first arg. |
| self.complete_from_to("target modules search-paths insert 0 ", "target modules search-paths insert 0 ") |
| |
| def test_target_create_dash_co(self): |
| """Test that 'target create --co' completes to 'target variable --core '.""" |
| self.complete_from_to('target create --co', 'target create --core ') |
| |
| def test_target_va(self): |
| """Test that 'target va' completes to 'target variable '.""" |
| self.complete_from_to('target va', 'target variable ') |
| |
| def test_common_completion_thread_index(self): |
| subcommands = ['continue', 'info', 'exception', 'select', |
| 'step-in', 'step-inst', 'step-inst-over', 'step-out', 'step-over', 'step-script'] |
| |
| # Completion should do nothing without threads. |
| for subcommand in subcommands: |
| self.complete_from_to('thread ' + subcommand + ' ', |
| 'thread ' + subcommand + ' ') |
| |
| self.build() |
| lldbutil.run_to_source_breakpoint(self, '// Break here', lldb.SBFileSpec("main.cpp")) |
| |
| # At least we have the thread at the index of 1 now. |
| for subcommand in subcommands: |
| self.complete_from_to('thread ' + subcommand + ' ', ['1']) |
| |
| def test_common_completion_type_category_name(self): |
| subcommands = ['delete', 'list', 'enable', 'disable', 'define'] |
| for subcommand in subcommands: |
| self.complete_from_to('type category ' + subcommand + ' ', ['default']) |
| self.complete_from_to('type filter add -w ', ['default']) |
| |
| def test_command_argument_completion(self): |
| """Test completion of command arguments""" |
| self.complete_from_to("watchpoint set variable -", ["-w", "-s"]) |
| self.complete_from_to('watchpoint set variable -w', 'watchpoint set variable -w ') |
| self.complete_from_to("watchpoint set variable --", ["--watch", "--size"]) |
| self.complete_from_to("watchpoint set variable --w", "watchpoint set variable --watch") |
| self.complete_from_to('watchpoint set variable -w ', ['read', 'write', 'read_write']) |
| self.complete_from_to("watchpoint set variable --watch ", ["read", "write", "read_write"]) |
| self.complete_from_to("watchpoint set variable --watch w", "watchpoint set variable --watch write") |
| self.complete_from_to('watchpoint set variable -w read_', 'watchpoint set variable -w read_write') |
| # Now try the same thing with a variable name (non-option argument) to |
| # test that getopts arg reshuffling doesn't confuse us. |
| self.complete_from_to("watchpoint set variable foo -", ["-w", "-s"]) |
| self.complete_from_to('watchpoint set variable foo -w', 'watchpoint set variable foo -w ') |
| self.complete_from_to("watchpoint set variable foo --", ["--watch", "--size"]) |
| self.complete_from_to("watchpoint set variable foo --w", "watchpoint set variable foo --watch") |
| self.complete_from_to('watchpoint set variable foo -w ', ['read', 'write', 'read_write']) |
| self.complete_from_to("watchpoint set variable foo --watch ", ["read", "write", "read_write"]) |
| self.complete_from_to("watchpoint set variable foo --watch w", "watchpoint set variable foo --watch write") |
| self.complete_from_to('watchpoint set variable foo -w read_', 'watchpoint set variable foo -w read_write') |
| |
| def test_command_script_delete(self): |
| self.runCmd("command script add -h test_desc -f none -s current usercmd1") |
| self.check_completion_with_desc('command script delete ', [['usercmd1', 'test_desc']]) |
| |
| def test_command_delete(self): |
| self.runCmd(r"command regex test_command s/^$/finish/ 's/([0-9]+)/frame select %1/'") |
| self.complete_from_to('command delete test_c', 'command delete test_command') |
| |
| def test_command_unalias(self): |
| self.complete_from_to('command unalias ima', 'command unalias image') |
| |
| def test_completion_description_commands(self): |
| """Test descriptions of top-level command completions""" |
| self.check_completion_with_desc("", [ |
| ["command", "Commands for managing custom LLDB commands."], |
| ["breakpoint", "Commands for operating on breakpoints (see 'help b' for shorthand.)"] |
| ]) |
| |
| self.check_completion_with_desc("pl", [ |
| ["platform", "Commands to manage and create platforms."], |
| ["plugin", "Commands for managing LLDB plugins."] |
| ]) |
| |
| # Just check that this doesn't crash. |
| self.check_completion_with_desc("comman", []) |
| self.check_completion_with_desc("non-existent-command", []) |
| |
| def test_completion_description_command_options(self): |
| """Test descriptions of command options""" |
| # Short options |
| self.check_completion_with_desc("breakpoint set -", [ |
| ["-h", "Set the breakpoint on exception catcH."], |
| ["-w", "Set the breakpoint on exception throW."] |
| ]) |
| |
| # Long options. |
| self.check_completion_with_desc("breakpoint set --", [ |
| ["--on-catch", "Set the breakpoint on exception catcH."], |
| ["--on-throw", "Set the breakpoint on exception throW."] |
| ]) |
| |
| # Ambiguous long options. |
| self.check_completion_with_desc("breakpoint set --on-", [ |
| ["--on-catch", "Set the breakpoint on exception catcH."], |
| ["--on-throw", "Set the breakpoint on exception throW."] |
| ]) |
| |
| # Unknown long option. |
| self.check_completion_with_desc("breakpoint set --Z", [ |
| ]) |
| |
| def test_common_completion_frame_index(self): |
| self.build() |
| lldbutil.run_to_source_breakpoint(self, '// Break here', lldb.SBFileSpec("main.cpp")) |
| |
| self.complete_from_to('frame select ', ['0']) |
| self.complete_from_to('thread backtrace -s ', ['0']) |
| |
| def test_frame_recognizer_delete(self): |
| self.runCmd("frame recognizer add -l py_class -s module_name -n recognizer_name") |
| self.check_completion_with_desc('frame recognizer delete ', [['0', 'py_class, module module_name, symbol recognizer_name']]) |
| |
| def test_platform_install_local_file(self): |
| self.complete_from_to('platform target-install main.cp', 'platform target-install main.cpp') |
| |
| @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489") |
| def test_symbol_name(self): |
| self.build() |
| self.dbg.CreateTarget(self.getBuildArtifact("a.out")) |
| self.complete_from_to('breakpoint set -n Fo', |
| 'breakpoint set -n Foo::Bar(int,\\ int)', |
| turn_off_re_match=True) |
| # No completion for Qu because the candidate is |
| # (anonymous namespace)::Quux(). |
| self.complete_from_to('breakpoint set -n Qu', '') |
| |
| def test_completion_type_formatter_delete(self): |
| self.runCmd('type filter add --child a Aoo') |
| self.complete_from_to('type filter delete ', ['Aoo']) |
| self.runCmd('type filter add --child b -x Boo') |
| self.complete_from_to('type filter delete ', ['Boo']) |
| |
| self.runCmd('type format add -f hex Coo') |
| self.complete_from_to('type format delete ', ['Coo']) |
| self.runCmd('type format add -f hex -x Doo') |
| self.complete_from_to('type format delete ', ['Doo']) |
| |
| self.runCmd('type summary add -c Eoo') |
| self.complete_from_to('type summary delete ', ['Eoo']) |
| self.runCmd('type summary add -x -c Foo') |
| self.complete_from_to('type summary delete ', ['Foo']) |
| |
| self.runCmd('type synthetic add Goo -l test') |
| self.complete_from_to('type synthetic delete ', ['Goo']) |
| self.runCmd('type synthetic add -x Hoo -l test') |
| self.complete_from_to('type synthetic delete ', ['Hoo']) |
| |
| @skipIf(archs=no_match(['x86_64'])) |
| def test_register_read_and_write_on_x86(self): |
| """Test the completion of the commands register read and write on x86""" |
| |
| # The tab completion for "register read/write" won't work without a running process. |
| self.complete_from_to('register read ', |
| 'register read ') |
| self.complete_from_to('register write ', |
| 'register write ') |
| |
| self.build() |
| self.main_source_spec = lldb.SBFileSpec("main.cpp") |
| lldbutil.run_to_source_breakpoint(self, '// Break here', self.main_source_spec) |
| |
| # test cases for register read |
| self.complete_from_to('register read ', |
| ['rax', |
| 'rbx', |
| 'rcx']) |
| self.complete_from_to('register read r', |
| ['rax', |
| 'rbx', |
| 'rcx']) |
| self.complete_from_to('register read ra', |
| 'register read rax') |
| # register read can take multiple register names as arguments |
| self.complete_from_to('register read rax ', |
| ['rax', |
| 'rbx', |
| 'rcx']) |
| # complete with prefix '$' |
| self.completions_match('register read $rb', |
| ['$rbx', |
| '$rbp']) |
| self.completions_match('register read $ra', |
| ['$rax']) |
| self.complete_from_to('register read rax $', |
| ['\$rax', |
| '\$rbx', |
| '\$rcx']) |
| self.complete_from_to('register read $rax ', |
| ['rax', |
| 'rbx', |
| 'rcx']) |
| |
| # test cases for register write |
| self.complete_from_to('register write ', |
| ['rax', |
| 'rbx', |
| 'rcx']) |
| self.complete_from_to('register write r', |
| ['rax', |
| 'rbx', |
| 'rcx']) |
| self.complete_from_to('register write ra', |
| 'register write rax') |
| self.complete_from_to('register write rb', |
| ['rbx', |
| 'rbp']) |
| # register write can only take exact one register name as argument |
| self.complete_from_to('register write rbx ', |
| []) |
| |
| def test_common_completion_target_stophook_ids(self): |
| subcommands = ['delete', 'enable', 'disable'] |
| |
| for subcommand in subcommands: |
| self.complete_from_to('target stop-hook ' + subcommand + ' ', |
| 'target stop-hook ' + subcommand + ' ') |
| |
| self.build() |
| self.dbg.CreateTarget(self.getBuildArtifact("a.out")) |
| self.runCmd('target stop-hook add test DONE') |
| |
| for subcommand in subcommands: |
| self.complete_from_to('target stop-hook ' + subcommand + ' ', |
| 'target stop-hook ' + subcommand + ' 1') |
| |
| # Completion should work only on the first argument. |
| for subcommand in subcommands: |
| self.complete_from_to('target stop-hook ' + subcommand + ' 1 ', |
| 'target stop-hook ' + subcommand + ' 1 ') |
| |
| def test_common_completion_type_language(self): |
| self.complete_from_to('type category -l ', ['c']) |
| |
| def test_target_modules_load_dash_u(self): |
| self.build() |
| target = self.dbg.CreateTarget(self.getBuildArtifact("a.out")) |
| self.complete_from_to('target modules load -u ', [target.GetModuleAtIndex(0).GetUUIDString()]) |
| |
| def test_complete_breakpoint_with_ids(self): |
| """These breakpoint subcommands should be completed with a list of breakpoint ids""" |
| |
| subcommands = ['enable', 'disable', 'delete', 'modify', 'name add', 'name delete', 'write'] |
| |
| # The tab completion here is unavailable without a target |
| for subcommand in subcommands: |
| self.complete_from_to('breakpoint ' + subcommand + ' ', |
| 'breakpoint ' + subcommand + ' ') |
| |
| self.build() |
| target = self.dbg.CreateTarget(self.getBuildArtifact('a.out')) |
| self.assertTrue(target, VALID_TARGET) |
| |
| bp = target.BreakpointCreateByName('main', 'a.out') |
| self.assertTrue(bp) |
| self.assertEqual(bp.GetNumLocations(), 1) |
| |
| for subcommand in subcommands: |
| self.complete_from_to('breakpoint ' + subcommand + ' ', |
| ['1']) |
| |
| bp2 = target.BreakpointCreateByName('Bar', 'a.out') |
| self.assertTrue(bp2) |
| self.assertEqual(bp2.GetNumLocations(), 1) |
| |
| for subcommand in subcommands: |
| self.complete_from_to('breakpoint ' + subcommand + ' ', |
| ['1', |
| '2']) |
| |
| for subcommand in subcommands: |
| self.complete_from_to('breakpoint ' + subcommand + ' 1 ', |
| ['1', |
| '2']) |
| |
| def test_complete_breakpoint_with_names(self): |
| self.build() |
| target = self.dbg.CreateTarget(self.getBuildArtifact('a.out')) |
| self.assertTrue(target, VALID_TARGET) |
| |
| # test breakpoint read dedicated |
| self.complete_from_to('breakpoint read -N ', 'breakpoint read -N ') |
| self.complete_from_to('breakpoint read -f breakpoints.json -N ', ['mm']) |
| self.complete_from_to('breakpoint read -f breakpoints.json -N n', 'breakpoint read -f breakpoints.json -N n') |
| self.complete_from_to('breakpoint read -f breakpoints_invalid.json -N ', 'breakpoint read -f breakpoints_invalid.json -N ') |
| |
| # test common breapoint name completion |
| bp1 = target.BreakpointCreateByName('main', 'a.out') |
| self.assertTrue(bp1) |
| self.assertEqual(bp1.GetNumLocations(), 1) |
| self.complete_from_to('breakpoint set -N n', 'breakpoint set -N n') |
| self.assertTrue(bp1.AddNameWithErrorHandling("nn")) |
| self.complete_from_to('breakpoint set -N ', 'breakpoint set -N nn') |
