""" 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): 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() _, process, _, _ = lldbutil.run_to_source_breakpoint( self, '// Break here', lldb.SBFileSpec("main.cpp")) self.assertState(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.do_test_variable_completion('frame variable') def test_dwim_print(self): self.build() _, process, _, _ = lldbutil.run_to_source_breakpoint( self, '// Break here', lldb.SBFileSpec("main.cpp")) self.assertState(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.do_test_variable_completion('dwim-print') def do_test_variable_completion(self, command): self.complete_from_to(f'{command} fo', f'{command} fooo') self.complete_from_to(f'{command} fooo.', f'{command} fooo.') self.complete_from_to(f'{command} fooo.dd', f'{command} fooo.dd') self.complete_from_to(f'{command} ptr_fooo->', f'{command} ptr_fooo->') self.complete_from_to(f'{command} ptr_fooo->dd', f'{command} ptr_fooo->dd') self.complete_from_to(f'{command} cont', f'{command} container') self.complete_from_to(f'{command} container.', f'{command} container.MemberVar') self.complete_from_to(f'{command} container.Mem', f'{command} container.MemberVar') self.complete_from_to(f'{command} ptr_cont', f'{command} ptr_container') self.complete_from_to(f'{command} ptr_container->', f'{command} ptr_container->MemberVar') self.complete_from_to(f'{command} ptr_container->Mem', f'{command} 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 " """ # 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 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 SIGPIP', 'process signal SIGPIPE') 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 = self.getSourceDir() + '/' 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) # 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 @add_test_categories(["watchpoint"]) 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.thr', '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_settings_set_can_complete_setting_enum_values(self): """Checks that we can complete the values of an enum setting.""" self.complete_from_to('settings set stop-disassembly-display ', ['never', 'always', 'no-debuginfo', 'no-source']) 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', '']]) 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 -o test') 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')