TestCompletion.py

"""
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
    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.complete_from_to('process attach -p ', [str(pid)])
        self.complete_from_to('platform process attach -p ', [str(pid)])
        self.complete_from_to('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 ')

    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', '')

    @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')