Index: lldb/packages/Python/lldbsuite/test/lldbtest.py =================================================================== --- lldb/packages/Python/lldbsuite/test/lldbtest.py +++ lldb/packages/Python/lldbsuite/test/lldbtest.py @@ -2247,66 +2247,55 @@ error_msg += "[" + match_candidate + ":" + description_candidate + "] index " + str(i) + "\n" self.assertFalse(got_failure, error_msg) - def complete_exactly(self, str_input, patterns): - self.complete_from_to(str_input, patterns, True) - - def complete_from_to(self, str_input, patterns, turn_off_re_match=False): - """Test that the completion mechanism completes str_input to patterns, - where patterns could be a pattern-string or a list of pattern-strings""" - # Patterns should not be None in order to proceed. - self.assertFalse(patterns is None) - # And should be either a string or list of strings. Check for list type - # below, if not, make a list out of the singleton string. If patterns - # is not a string or not a list of strings, there'll be runtime errors - # later on. - if not isinstance(patterns, list): - patterns = [patterns] - + def get_completion_list(self, command): + """ Returns the list of completions for the given command input. The + completions are just the completed current token as it is returned + by HandleCompletion. """ interp = self.dbg.GetCommandInterpreter() match_strings = lldb.SBStringList() - num_matches = interp.HandleCompletion(str_input, len(str_input), 0, -1, match_strings) - common_match = match_strings.GetStringAtIndex(0) - if num_matches == 0: - compare_string = str_input - else: - if common_match != None and len(common_match) > 0: - compare_string = str_input + common_match - else: - compare_string = "" - for idx in range(1, num_matches+1): - compare_string += match_strings.GetStringAtIndex(idx) + "\n" - - for p in patterns: - if turn_off_re_match: - self.expect( - compare_string, msg=COMPLETION_MSG( - str_input, p, match_strings), exe=False, substrs=[p]) - else: - self.expect( - compare_string, msg=COMPLETION_MSG( - str_input, p, match_strings), exe=False, patterns=[p]) + return_code = interp.HandleCompletion(command, len(command), 0, -1, match_strings) + # match_strings is a 1-indexed list, so we have to remove the first + # element (which contains the common prefix of all completion results). + result = list(match_strings)[1:] + # Check the return code as negative return codes have special meaning. + self.assertGreaterEqual(return_code, 0, "Negative return codes have" + + " special meaning and are not supported yet.") + # Check that the return code equals the number of matches if positive. + self.assertEqual(return_code, len(result)) + return result - def completions_match(self, command, completions): + def assert_completions_equal(self, command, expected_completions): """Checks that the completions for the given command are equal to the given list of completions""" - interp = self.dbg.GetCommandInterpreter() - match_strings = lldb.SBStringList() - interp.HandleCompletion(command, len(command), 0, -1, match_strings) - # match_strings is a 1-indexed list, so we have to slice... - self.assertItemsEqual(completions, list(match_strings)[1:], - "List of returned completion is wrong") - def completions_contain(self, command, completions): + # We should always have at least one expected completion. Use + # assert_no_completions if a command is expected to produce no + # completions. + self.assertGreater(len(expected_completions), 0) + + self.assertItemsEqual(expected_completions, + self.get_completion_list(command), + "Returned incorrect command completions") + + def assert_completions_contain(self, command, expected_completions): """Checks that the completions for the given command contain the given list of completions.""" - interp = self.dbg.GetCommandInterpreter() - match_strings = lldb.SBStringList() - interp.HandleCompletion(command, len(command), 0, -1, match_strings) - for completion in completions: - # match_strings is a 1-indexed list, so we have to slice... - self.assertIn(completion, list(match_strings)[1:], + + # We should always have at least one expected completion. Use + # assert_no_completions if a command is expected to produce no + # completions. + self.assertGreater(len(expected_completions), 0) + + returned_completions = self.get_completion_list(command) + for expected_completion in expected_completions: + self.assertIn(expected_completion, returned_completions, "Couldn't find expected completion") + def assert_no_completions(self, command): + """Checks that the command does not produce any tab completions.""" + self.assertItemsEqual([], self.get_completion_list(command), + "Expected no command completions") + def filecheck( self, command, Index: lldb/test/API/commands/expression/completion/TestExprCompletion.py =================================================================== --- lldb/test/API/commands/expression/completion/TestExprCompletion.py +++ lldb/test/API/commands/expression/completion/TestExprCompletion.py @@ -22,174 +22,169 @@ self.dbg.CreateTarget(self.getBuildArtifact("a.out")) # Try the completion before we have a context to complete on. - self.assume_no_completions('expr some_expr') - self.assume_no_completions('expr ') - self.assume_no_completions('expr f') - + self.assert_no_completions('expr some_expr') + self.assert_no_completions('expr ') + self.assert_no_completions('expr f') (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self, '// Break here', self.main_source_spec) # Completing member functions - self.complete_exactly('expr some_expr.FooNoArgs', - 'expr some_expr.FooNoArgsBar()') - self.complete_exactly('expr some_expr.FooWithArgs', - 'expr some_expr.FooWithArgsBar(') - self.complete_exactly('expr some_expr.FooWithMultipleArgs', - 'expr some_expr.FooWithMultipleArgsBar(') - self.complete_exactly('expr some_expr.FooUnderscore', - 'expr some_expr.FooUnderscoreBar_()') - self.complete_exactly('expr some_expr.FooNumbers', - 'expr some_expr.FooNumbersBar1()') - self.complete_exactly('expr some_expr.StaticMemberMethod', - 'expr some_expr.StaticMemberMethodBar()') + self.assert_completions_contain('expr some_expr.FooNoArgs', + ['some_expr.FooNoArgsBar()']) + self.assert_completions_contain('expr some_expr.FooWithArgs', + ['some_expr.FooWithArgsBar(']) + self.assert_completions_contain('expr some_expr.FooWithMultipleArgs', + ['some_expr.FooWithMultipleArgsBar(']) + self.assert_completions_contain('expr some_expr.FooUnderscore', + ['some_expr.FooUnderscoreBar_()']) + self.assert_completions_contain('expr some_expr.FooNumbers', + ['some_expr.FooNumbersBar1()']) + self.assert_completions_contain('expr some_expr.StaticMemberMethod', + ['some_expr.StaticMemberMethodBar()']) # Completing static functions - self.complete_exactly('expr Expr::StaticMemberMethod', - 'expr Expr::StaticMemberMethodBar()') + self.assert_completions_contain('expr Expr::StaticMemberMethod', + ['Expr::StaticMemberMethodBar()']) # Completing member variables - self.complete_exactly('expr some_expr.MemberVariab', - 'expr some_expr.MemberVariableBar') + self.assert_completions_contain('expr some_expr.MemberVariab', + ['some_expr.MemberVariableBar']) # Multiple completions - self.completions_contain('expr some_expr.', - ['some_expr.FooNumbersBar1()', - 'some_expr.FooUnderscoreBar_()', - 'some_expr.FooWithArgsBar(', - 'some_expr.MemberVariableBar']) - - self.completions_contain('expr some_expr.Foo', - ['some_expr.FooNumbersBar1()', - 'some_expr.FooUnderscoreBar_()', - 'some_expr.FooWithArgsBar(']) - - self.completions_contain('expr ', - ['static_cast', - 'reinterpret_cast', - 'dynamic_cast']) - - self.completions_contain('expr 1 + ', - ['static_cast', - 'reinterpret_cast', - 'dynamic_cast']) + self.assert_completions_contain('expr some_expr.', + ['some_expr.FooNumbersBar1()', + 'some_expr.FooUnderscoreBar_()', + 'some_expr.FooWithArgsBar(', + 'some_expr.MemberVariableBar']) + + self.assert_completions_contain('expr some_expr.Foo', + ['some_expr.FooNumbersBar1()', + 'some_expr.FooUnderscoreBar_()', + 'some_expr.FooWithArgsBar(']) + + self.assert_completions_contain('expr ', + ['static_cast', + 'reinterpret_cast', + 'dynamic_cast']) + + self.assert_completions_contain('expr 1 + ', + ['static_cast', + 'reinterpret_cast', + 'dynamic_cast']) # Completion expr without spaces # This is a bit awkward looking for the user, but that's how # the completion API works at the moment. - self.completions_contain('expr 1+', - ['1+some_expr', "1+static_cast"]) + self.assert_completions_contain('expr 1+', + ['1+some_expr', "1+static_cast"]) # Test with spaces - self.complete_exactly('expr some_expr .FooNoArgs', - 'expr some_expr .FooNoArgsBar()') - self.complete_exactly('expr some_expr .FooNoArgs', - 'expr some_expr .FooNoArgsBar()') - self.complete_exactly('expr some_expr .FooNoArgs', - 'expr some_expr .FooNoArgsBar()') - self.complete_exactly('expr some_expr. FooNoArgs', - 'expr some_expr. FooNoArgsBar()') - self.complete_exactly('expr some_expr . FooNoArgs', - 'expr some_expr . FooNoArgsBar()') - self.complete_exactly('expr Expr :: StaticMemberMethod', - 'expr Expr :: StaticMemberMethodBar()') - self.complete_exactly('expr Expr ::StaticMemberMethod', - 'expr Expr ::StaticMemberMethodBar()') - self.complete_exactly('expr Expr:: StaticMemberMethod', - 'expr Expr:: StaticMemberMethodBar()') + self.assert_completions_contain('expr some_expr .FooNoArgs', + ['.FooNoArgsBar()']) + self.assert_completions_contain('expr some_expr .FooNoArgs', + ['.FooNoArgsBar()']) + self.assert_completions_contain('expr some_expr .FooNoArgs', + ['.FooNoArgsBar()']) + self.assert_completions_contain('expr some_expr. FooNoArgs', + ['FooNoArgsBar()']) + self.assert_completions_contain('expr some_expr . FooNoArgs', + ['FooNoArgsBar()']) + self.assert_completions_contain('expr Expr :: StaticMemberMethod', + ['StaticMemberMethodBar()']) + self.assert_completions_contain('expr Expr ::StaticMemberMethod', + ['::StaticMemberMethodBar()']) + self.assert_completions_contain('expr Expr:: StaticMemberMethod', + ['StaticMemberMethodBar()']) # Test that string literals don't break our parsing logic. - self.complete_exactly('expr const char *cstr = "some_e"; char c = *cst', - 'expr const char *cstr = "some_e"; char c = *cstr') - self.complete_exactly('expr const char *cstr = "some_e" ; char c = *cst', - 'expr const char *cstr = "some_e" ; char c = *cstr') + self.assert_completions_contain('expr const char *cstr = "some_e"; char c = *cst', + ['*cstr']) + self.assert_completions_contain('expr const char *cstr = "some_e" ; char c = *cst', + ['*cstr']) + # Requesting completions inside an incomplete string doesn't provide any # completions. - self.complete_exactly('expr const char *cstr = "some_e', - 'expr const char *cstr = "some_e') - - # Completing inside double dash should do nothing - self.assume_no_completions('expr -i0 -- some_expr.', 10) - self.assume_no_completions('expr -i0 -- some_expr.', 11) + self.assert_no_completions('expr const char *cstr = "some_e') # Test with expr arguments - self.complete_exactly('expr -i0 -- some_expr .FooNoArgs', - 'expr -i0 -- some_expr .FooNoArgsBar()') - self.complete_exactly('expr -i0 -- some_expr .FooNoArgs', - 'expr -i0 -- some_expr .FooNoArgsBar()') + self.assert_completions_contain('expr -i0 -- some_expr .FooNoArgs', + ['.FooNoArgsBar()']) + self.assert_completions_contain('expr -i0 -- some_expr .FooNoArgs', + ['.FooNoArgsBar()']) # Addrof and deref - self.complete_exactly('expr (*(&some_expr)).FooNoArgs', - 'expr (*(&some_expr)).FooNoArgsBar()') - self.complete_exactly('expr (*(&some_expr)) .FooNoArgs', - 'expr (*(&some_expr)) .FooNoArgsBar()') - self.complete_exactly('expr (* (&some_expr)) .FooNoArgs', - 'expr (* (&some_expr)) .FooNoArgsBar()') - self.complete_exactly('expr (* (& some_expr)) .FooNoArgs', - 'expr (* (& some_expr)) .FooNoArgsBar()') + self.assert_completions_contain('expr (*(&some_expr)).FooNoArgs', + ['(*(&some_expr)).FooNoArgsBar()']) + self.assert_completions_contain('expr (*(&some_expr)) .FooNoArgs', + ['.FooNoArgsBar()']) + self.assert_completions_contain('expr (* (&some_expr)) .FooNoArgs', + ['.FooNoArgsBar()']) + self.assert_completions_contain('expr (* (& some_expr)) .FooNoArgs', + ['.FooNoArgsBar()']) # Addrof and deref (part 2) - self.complete_exactly('expr (&some_expr)->FooNoArgs', - 'expr (&some_expr)->FooNoArgsBar()') - self.complete_exactly('expr (&some_expr) ->FooNoArgs', - 'expr (&some_expr) ->FooNoArgsBar()') - self.complete_exactly('expr (&some_expr) -> FooNoArgs', - 'expr (&some_expr) -> FooNoArgsBar()') - self.complete_exactly('expr (&some_expr)-> FooNoArgs', - 'expr (&some_expr)-> FooNoArgsBar()') + self.assert_completions_contain('expr (&some_expr)->FooNoArgs', + ['(&some_expr)->FooNoArgsBar()']) + self.assert_completions_contain('expr (&some_expr) ->FooNoArgs', + ['->FooNoArgsBar()']) + self.assert_completions_contain('expr (&some_expr) -> FooNoArgs', + ['FooNoArgsBar()']) + self.assert_completions_contain('expr (&some_expr)-> FooNoArgs', + ['FooNoArgsBar()']) # Builtin arg - self.complete_exactly('expr static_ca', - 'expr static_cast') + self.assert_completions_contain('expr static_ca', + ['static_cast']) # From other files - self.complete_exactly('expr fwd_decl_ptr->Hidden', - 'expr fwd_decl_ptr->HiddenMember') + self.assert_completions_contain('expr fwd_decl_ptr->Hidden', + ['fwd_decl_ptr->HiddenMemberName']) # Types - self.complete_exactly('expr LongClassNa', - 'expr LongClassName') - self.complete_exactly('expr LongNamespaceName::NestedCla', - 'expr LongNamespaceName::NestedClass') + self.assert_completions_contain('expr LongClassNa', + ['LongClassName']) + self.assert_completions_contain('expr LongNamespaceName::NestedCla', + ['LongNamespaceName::NestedClass']) # Namespaces - self.complete_exactly('expr LongNamespaceNa', - 'expr LongNamespaceName::') + self.assert_completions_contain('expr LongNamespaceNa', + ['LongNamespaceName::']) # Multiple arguments - self.complete_exactly('expr &some_expr + &some_e', - 'expr &some_expr + &some_expr') - self.complete_exactly('expr SomeLongVarNameWithCapitals + SomeLongVarName', - 'expr SomeLongVarNameWithCapitals + SomeLongVarNameWithCapitals') - self.complete_exactly('expr SomeIntVar + SomeIntV', - 'expr SomeIntVar + SomeIntVar') + self.assert_completions_contain('expr &some_expr + &some_e', + ['&some_expr']) + self.assert_completions_contain('expr SomeLongVarNameWithCapitals + SomeLongVarName', + ['SomeLongVarNameWithCapitals']) + self.assert_completions_contain('expr SomeIntVar + SomeIntV', + ['SomeIntVar']) # Multiple statements - self.complete_exactly('expr long LocalVariable = 0; LocalVaria', - 'expr long LocalVariable = 0; LocalVariable') + self.assert_completions_contain('expr long LocalVariable = 0; LocalVaria', + ['LocalVariable']) # Custom Decls - self.complete_exactly('expr auto l = [](int LeftHandSide, int bx){ return LeftHandS', - 'expr auto l = [](int LeftHandSide, int bx){ return LeftHandSide') - self.complete_exactly('expr struct LocalStruct { long MemberName; } ; LocalStruct S; S.Mem', - 'expr struct LocalStruct { long MemberName; } ; LocalStruct S; S.MemberName') + self.assert_completions_contain('expr auto l = [](int LeftHandSide, int bx){ return LeftHandS', + ['LeftHandSide']) + self.assert_completions_contain('expr struct LocalStruct { long MemberName; } ; LocalStruct S; S.Mem', + ['S.MemberName']) # Completing function call arguments - self.complete_exactly('expr some_expr.FooWithArgsBar(some_exp', - 'expr some_expr.FooWithArgsBar(some_expr') - self.complete_exactly('expr some_expr.FooWithArgsBar(SomeIntV', - 'expr some_expr.FooWithArgsBar(SomeIntVar') - self.complete_exactly('expr some_expr.FooWithMultipleArgsBar(SomeIntVar, SomeIntVa', - 'expr some_expr.FooWithMultipleArgsBar(SomeIntVar, SomeIntVar') + self.assert_completions_contain('expr some_expr.FooWithArgsBar(some_exp', + ['some_expr.FooWithArgsBar(some_expr']) + self.assert_completions_contain('expr some_expr.FooWithArgsBar(SomeIntV', + ['some_expr.FooWithArgsBar(SomeIntVar']) + self.assert_completions_contain('expr some_expr.FooWithMultipleArgsBar(SomeIntVar, SomeIntVa', + ['SomeIntVar']) # Function return values - self.complete_exactly('expr some_expr.Self().FooNoArgs', - 'expr some_expr.Self().FooNoArgsBar()') - self.complete_exactly('expr some_expr.Self() .FooNoArgs', - 'expr some_expr.Self() .FooNoArgsBar()') - self.complete_exactly('expr some_expr.Self(). FooNoArgs', - 'expr some_expr.Self(). FooNoArgsBar()') + self.assert_completions_contain('expr some_expr.Self().FooNoArgs', + ['some_expr.Self().FooNoArgsBar()']) + self.assert_completions_contain('expr some_expr.Self() .FooNoArgs', + ['.FooNoArgsBar()']) + self.assert_completions_contain('expr some_expr.Self(). FooNoArgs', + ['FooNoArgsBar()']) def test_expr_completion_with_descriptions(self): self.build() @@ -221,34 +216,3 @@ ["some_expr.FooUnderscoreBar_()", "int FooUnderscoreBar_()"], ["some_expr.FooWithMultipleArgsBar(", "int FooWithMultipleArgsBar(int, int)"], ], enforce_order = True) - - def assume_no_completions(self, str_input, cursor_pos = None): - interp = self.dbg.GetCommandInterpreter() - match_strings = lldb.SBStringList() - if cursor_pos is None: - cursor_pos = len(str_input) - num_matches = interp.HandleCompletion(str_input, cursor_pos, 0, -1, match_strings) - - available_completions = [] - for m in match_strings: - available_completions.append(m) - - self.assertEquals(num_matches, 0, "Got matches, but didn't expect any: " + str(available_completions)) - - def completions_contain(self, str_input, items): - interp = self.dbg.GetCommandInterpreter() - match_strings = lldb.SBStringList() - num_matches = interp.HandleCompletion(str_input, len(str_input), 0, -1, match_strings) - common_match = match_strings.GetStringAtIndex(0) - - for item in items: - found = False - for m in match_strings: - if m == item: - found = True - if not found: - # Transform match_strings to a python list with strings - available_completions = [] - for m in match_strings: - available_completions.append(m) - self.assertTrue(found, "Couldn't find completion " + item + " in completions " + str(available_completions)) Index: lldb/test/API/functionalities/completion/TestCompletion.py =================================================================== --- lldb/test/API/functionalities/completion/TestCompletion.py +++ lldb/test/API/functionalities/completion/TestCompletion.py @@ -29,12 +29,10 @@ pass def test_at(self): - """Test that 'at' completes to 'attach '.""" - self.complete_from_to('at', 'attach ') + self.assert_completions_equal('at', ['attach']) def test_de(self): - """Test that 'de' completes to 'detach '.""" - self.complete_from_to('de', 'detach ') + self.assert_completions_equal('de', ['detach']) def test_frame_variable(self): self.build() @@ -49,54 +47,46 @@ # 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') + self.assert_completions_equal('frame variable fo', ["fooo"]) + self.assert_no_completions('frame variable fooo.') + self.assert_no_completions('frame variable fooo.dd') + + self.assert_no_completions('frame variable ptr_fooo->') + self.assert_no_completions('frame variable ptr_fooo->dd') + + self.assert_completions_equal('frame variable cont', + ['container']) + self.assert_completions_equal('frame variable container.', + ['container.MemberVar']) + self.assert_completions_equal('frame variable container.Mem', + ['container.MemberVar']) + + self.assert_completions_equal('frame variable ptr_cont', + ['ptr_container']) + self.assert_completions_equal('frame variable ptr_container->', + ['ptr_container->MemberVar']) + self.assert_completions_equal('frame variable ptr_container->Mem', + ['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 ') + self.assert_completions_equal("process attach --con", ["--continue"]) def test_process_launch_arch(self): - self.complete_from_to('process launch --arch ', - ['mips', - 'arm64']) + self.assert_completions_contain('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') + self.assert_completions_equal('process load Makef', ['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.assert_no_completions('process unload ') self.build() lldbutil.run_to_source_breakpoint(self, '// Break here', lldb.SBFileSpec("main.cpp")) @@ -104,19 +94,17 @@ self.process().LoadImage(lldb.SBFileSpec(self.getBuildArtifact("libshared.so")), err) self.assertSuccess(err) - self.complete_from_to('process unload ', - 'process unload 0') + self.assert_completions_contain('process unload ', ["0"]) self.process().UnloadImage(0) - self.complete_from_to('process unload ', - 'process unload ') + # FIXME: This should be assert_no_completions. + self.assert_completions_contain('process unload ', ["0"]) 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') + self.assert_completions_equal('process ' + subcommand + ' mac', ["mach-o-core"]) def completions_contain_str(self, input, needle): interp = self.dbg.GetCommandInterpreter() @@ -143,17 +131,16 @@ 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.assert_completions_contain('process attach -p ', [str(pid)]) + self.assert_completions_contain('platform process attach -p ', [str(pid)]) + self.assert_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 ') + self.assert_no_completions('process signal ') # Test with a running process. self.build() @@ -161,142 +148,121 @@ 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']) + self.assert_completions_contain('process signal ', + ['SIGABRT', + 'SIGALRM']) def test_ambiguous_long_opt(self): - self.completions_match('breakpoint modify --th', - ['--thread-id', - '--thread-index', - '--thread-name']) + self.assert_completions_equal('breakpoint modify --th', + ['--thread-id', + '--thread-index', + '--thread-name']) def test_disassemble_dash_f(self): - self.completions_match('disassemble -F ', - ['default', - 'intel', - 'att']) + self.assert_completions_equal('disassemble -F ', + ['default', + 'intel', + 'att']) def test_plugin_load(self): - self.complete_from_to('plugin load ', []) + # Just completes files like the Makefile in the test directory. + self.assert_completions_contain('plugin load ', ['Makefile']) 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']) + self.assert_completions_equal('log enable ll', ['lldb']) + self.assert_completions_equal('log enable dw', ['dwarf']) + self.assert_completions_equal('log enable lldb al', ['all']) + self.assert_completions_equal('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']) + self.assert_completions_equal('log disable ll', ['lldb']) + self.assert_completions_equal('log disable dw', ['dwarf']) + self.assert_completions_equal('log disable lldb al', ['all']) + self.assert_completions_equal('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']) + self.assert_completions_equal('log list ll', ['lldb']) + self.assert_completions_equal('log list dw', ['dwarf']) + self.assert_completions_equal('log list ll', ['lldb']) + self.assert_completions_equal('log list lldb dwa', ['dwarf']) def test_quoted_command(self): - self.complete_from_to('"set', - ['"settings" ']) + self.assert_completions_equal('"set', ['settings']) def test_quoted_arg_with_quoted_command(self): - self.complete_from_to('"settings" "repl', - ['"replace" ']) + self.assert_completions_equal('"settings" "repl', ['replace']) def test_quoted_arg_without_quoted_command(self): - self.complete_from_to('settings "repl', - ['"replace" ']) + self.assert_completions_equal('settings "repl', ['replace']) def test_single_quote_command(self): - self.complete_from_to("'set", - ["'settings' "]) + self.assert_completions_equal("'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'", []) + self.assert_completions_equal("'settings'", ["settings"]) def test_process_launch_arch_arm(self): - self.complete_from_to('process launch --arch arm', - ['arm64']) + self.assert_completions_contain('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 ', []) + self.assert_no_completions('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']) + self.assert_completions_contain('log enable lldb expr -f ' + src_dir, + [os.path.join(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) + self.assert_completions_contain('log enable lldb expr -f ' + src_dir, + [src_dir + os.sep]) # 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) + self.assert_no_completions('process print hello\\') def test_watchpoint_co(self): - """Test that 'watchpoint co' completes to 'watchpoint command '.""" - self.complete_from_to('watchpoint co', 'watchpoint command ') + self.assert_completions_equal('watchpoint co', ['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']) + self.assert_completions_equal('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 ') + self.assert_completions_equal('watchpoint command a', + ["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 ') + self.assert_completions_equal('watchpoint set ex', ['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 ') + self.assert_completions_equal('watchpoint set var', ['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') + self.assert_completions_equal('watchpoint set variable fo', ['fooo']) # Only complete the first argument. - self.complete_from_to('watchpoint set variable fooo ', 'watchpoint set variable fooo ') + self.assert_no_completions('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']) + self.assert_completions_contain( '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 ') + self.assert_completions_contain('help watchpoint s', ['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 + ' ') + self.assert_no_completions('watchpoint ' + subcommand + ' ') # Create a process to provide a target and enable watchpoint setting. self.build() @@ -304,163 +270,126 @@ self.runCmd('watchpoint set variable ptr_fooo') for subcommand in subcommands: - self.complete_from_to('watchpoint ' + subcommand + ' ', ['1']) + self.assert_completions_equal('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') + self.assert_completions_equal('settings append target.er', + ['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') + self.assert_completions_equal('settings insert-after target.env', ['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') + self.assert_completions_equal( + 'settings insert-before target.env', ['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') + self.assert_completions_equal( + 'settings replace target.ru', ['target.run-args']) def test_settings_show_term(self): - self.complete_from_to( - 'settings show term-', - 'settings show term-width') + self.assert_completions_equal( + 'settings show term-', ['term-width']) def test_settings_list_term(self): - self.complete_from_to( - 'settings list term-', - 'settings list term-width') + self.assert_completions_equal( + 'settings list term-', ['term-width']) def test_settings_remove_term(self): - self.complete_from_to( - 'settings remove term-', - 'settings remove term-width') + self.assert_completions_equal('settings remove term-', ['term-width']) def test_settings_s(self): - """Test that 'settings s' completes to ['set', 'show'].""" - self.complete_from_to( - 'settings s', [ - 'set', 'show']) + self.assert_completions_equal('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') + self.assert_completions_equal('settings set thread-f', ['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') + self.assert_completions_equal('settings set --g', ['--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') + self.assert_completions_equal('settings clear thread-f', ['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-') + self.assert_completions_contain('settings set target.ma', ['target.max-children-count']) 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') + self.assert_completions_equal('settings set target.exec', ['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.']) + self.assert_completions_contain('settings set target.pr', + ['target.prefer-dynamic-value', + 'target.process.thread.step-avoid-regexp']) 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.') + self.assert_completions_contain('settings set target.process', + ['target.process.disable-memory-cache']) 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.') + self.assert_completions_contain('settings set target.process.t', + ['target.process.thread.step-out-avoid-nodebug']) 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']) + self.assert_completions_contain('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 ') + self.assert_no_completions('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.assert_completions_equal('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']) + self.assert_completions_contain('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']) + self.assert_completions_equal('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']) + self.assert_completions_equal('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.assert_no_completions("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.assert_no_completions("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") + self.assert_completions_equal("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 ") + self.assert_no_completions("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 ') + self.assert_completions_contain('target create --co', ['--core']) def test_target_va(self): """Test that 'target va' completes to 'target variable '.""" - self.complete_from_to('target va', 'target variable ') + self.assert_completions_equal('target va', ['variable']) def test_common_completion_thread_index(self): subcommands = ['continue', 'info', 'exception', 'select', @@ -468,42 +397,41 @@ # Completion should do nothing without threads. for subcommand in subcommands: - self.complete_from_to('thread ' + subcommand + ' ', - 'thread ' + subcommand + ' ') + self.assert_no_completions('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']) + self.assert_completions_equal('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']) + self.assert_completions_contain('type category ' + subcommand + ' ', ['default']) + self.assert_completions_contain('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') + self.assert_completions_contain("watchpoint set variable -", ['-w', '-s']) + self.assert_completions_equal('watchpoint set variable -w', ['-w']) + self.assert_completions_equal("watchpoint set variable --", ['--watch', '--size']) + self.assert_completions_equal("watchpoint set variable --w", ['--watch']) + self.assert_completions_equal('watchpoint set variable -w ', ['read', 'write', 'read_write']) + self.assert_completions_equal("watchpoint set variable --watch ", ['read', 'write', 'read_write']) + self.assert_completions_equal("watchpoint set variable --watch w", ['write']) + self.assert_completions_equal('watchpoint set variable -w read_', ['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') + self.assert_completions_contain("watchpoint set variable foo -", ['-w', '-s']) + self.assert_completions_equal('watchpoint set variable foo -w', ['-w']) + self.assert_completions_equal("watchpoint set variable foo --", ['--watch', '--size']) + self.assert_completions_equal("watchpoint set variable foo --w", ['--watch']) + self.assert_completions_equal('watchpoint set variable foo -w ', ['read', 'write', 'read_write']) + self.assert_completions_equal("watchpoint set variable foo --watch ", ['read', 'write', 'read_write']) + self.assert_completions_equal("watchpoint set variable foo --watch w", ['write']) + self.assert_completions_equal('watchpoint set variable foo -w read_', ['read_write']) def test_command_script_delete(self): self.runCmd("command script add -h test_desc -f none -s current usercmd1") @@ -511,10 +439,10 @@ 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') + self.assert_completions_equal('command delete test_c', ['test_command']) def test_command_unalias(self): - self.complete_from_to('command unalias ima', 'command unalias image') + self.assert_completions_equal('command unalias ima', ['image']) def test_completion_description_commands(self): """Test descriptions of top-level command completions""" @@ -560,138 +488,128 @@ 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']) + self.assert_completions_contain('frame select ', ['0']) + self.assert_completions_contain('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') + self.assert_completions_equal('platform target-install main.cp', ['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) + self.assert_completions_equal('breakpoint set -n Fo', + ['Foo::Bar(int, int)']) # No completion for Qu because the candidate is # (anonymous namespace)::Quux(). - self.complete_from_to('breakpoint set -n Qu', '') + self.assert_no_completions('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.assert_completions_contain('type filter delete ', ['Aoo']) self.runCmd('type filter add --child b -x Boo') - self.complete_from_to('type filter delete ', ['Boo']) + self.assert_completions_contain('type filter delete ', ['Boo']) self.runCmd('type format add -f hex Coo') - self.complete_from_to('type format delete ', ['Coo']) + self.assert_completions_contain('type format delete ', ['Coo']) self.runCmd('type format add -f hex -x Doo') - self.complete_from_to('type format delete ', ['Doo']) + self.assert_completions_contain('type format delete ', ['Doo']) self.runCmd('type summary add -c Eoo') - self.complete_from_to('type summary delete ', ['Eoo']) + self.assert_completions_contain('type summary delete ', ['Eoo']) self.runCmd('type summary add -x -c Foo') - self.complete_from_to('type summary delete ', ['Foo']) + self.assert_completions_contain('type summary delete ', ['Foo']) self.runCmd('type synthetic add Goo -l test') - self.complete_from_to('type synthetic delete ', ['Goo']) + self.assert_completions_contain('type synthetic delete ', ['Goo']) self.runCmd('type synthetic add -x Hoo -l test') - self.complete_from_to('type synthetic delete ', ['Hoo']) + self.assert_completions_contain('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.assert_no_completions('register read ') + self.assert_no_completions('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 ', + self.assert_completions_contain('register read ', ['rax', 'rbx', 'rcx']) - self.complete_from_to('register read r', + self.assert_completions_contain('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 ', + self.assert_completions_contain('register read rax ', ['rax', 'rbx', 'rcx']) # complete with prefix '$' - self.completions_match('register read $rb', + self.assert_completions_contain('register read $rb', ['$rbx', '$rbp']) - self.completions_match('register read $ra', + self.assert_completions_contain('register read $ra', ['$rax']) - self.complete_from_to('register read rax $', - ['\$rax', - '\$rbx', - '\$rcx']) - self.complete_from_to('register read $rax ', + self.assert_completions_contain('register read rax $', + ['$rax', + '$rbx', + '$rcx']) + self.assert_completions_contain('register read $rax ', ['rax', 'rbx', 'rcx']) # test cases for register write - self.complete_from_to('register write ', + self.assert_completions_contain('register write ', ['rax', 'rbx', 'rcx']) - self.complete_from_to('register write r', + self.assert_completions_contain('register write r', ['rax', 'rbx', 'rcx']) - self.complete_from_to('register write ra', - 'register write rax') - self.complete_from_to('register write rb', + self.assert_completions_contain('register write ra', + ['rax']) + self.assert_completions_contain('register write rb', ['rbx', 'rbp']) # register write can only take exact one register name as argument - self.complete_from_to('register write rbx ', - []) + self.assert_no_completions('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.assert_no_completions('target stop-hook ' + subcommand + ' ') self.build() self.dbg.CreateTarget(self.getBuildArtifact("a.out")) self.runCmd('target stop-hook add test DONE') + 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 ') + self.assert_completions_equal('target stop-hook ' + subcommand + ' ', ['1', '2']) + # FIXME: Completing multiple IDs should work too. def test_common_completion_type_language(self): - self.complete_from_to('type category -l ', ['c']) + self.assert_completions_contain('type category define -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()]) + self.assert_completions_contain('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""" @@ -700,8 +618,7 @@ # The tab completion here is unavailable without a target for subcommand in subcommands: - self.complete_from_to('breakpoint ' + subcommand + ' ', - 'breakpoint ' + subcommand + ' ') + self.assert_no_completions('breakpoint ' + subcommand + ' ') self.build() target = self.dbg.CreateTarget(self.getBuildArtifact('a.out')) @@ -712,20 +629,20 @@ self.assertEqual(bp.GetNumLocations(), 1) for subcommand in subcommands: - self.complete_from_to('breakpoint ' + subcommand + ' ', - ['1']) + self.assert_completions_contain('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 + ' ', + self.assert_completions_equal('breakpoint ' + subcommand + ' ', ['1', '2']) for subcommand in subcommands: - self.complete_from_to('breakpoint ' + subcommand + ' 1 ', + self.assert_completions_equal('breakpoint ' + subcommand + ' 1 ', ['1', '2']) @@ -735,15 +652,15 @@ 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 ') + self.assert_no_completions('breakpoint read -N ') + self.assert_completions_contain('breakpoint read -f breakpoints.json -N ', ['mm']) + self.assert_no_completions('breakpoint read -f breakpoints.json -N n') + self.assert_no_completions('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.assert_no_completions('breakpoint set -N n') self.assertTrue(bp1.AddNameWithErrorHandling("nn")) - self.complete_from_to('breakpoint set -N ', 'breakpoint set -N nn') + self.assert_completions_equal('breakpoint set -N ', ["nn"]) Index: lldb/test/API/functionalities/gdb_remote_client/TestGDBRemoteDiskFileCompletion.py =================================================================== --- lldb/test/API/functionalities/gdb_remote_client/TestGDBRemoteDiskFileCompletion.py +++ lldb/test/API/functionalities/gdb_remote_client/TestGDBRemoteDiskFileCompletion.py @@ -20,10 +20,10 @@ self.server.port) self.assertTrue(self.dbg.GetSelectedPlatform().IsConnected()) - self.complete_from_to('platform get-size ', ['test', '123']) - self.complete_from_to('platform get-file ', ['test', '123']) - self.complete_from_to('platform put-file foo ', ['test', '123']) - self.complete_from_to('platform file open ', ['test', '123']) - self.complete_from_to('platform settings -w ', ['test', '123']) + self.assert_completions_equal('platform get-size ', ['test', '123']) + self.assert_completions_equal('platform get-file ', ['test', '123']) + self.assert_completions_equal('platform put-file foo ', ['test', '123']) + self.assert_completions_equal('platform file open ', ['test', '123']) + self.assert_completions_equal('platform settings -w ', ['test', '123']) finally: self.dbg.GetSelectedPlatform().DisconnectRemote()