[lldb] Refactor the tab completion test utilities and document found bugs

[teemperor]

Summary

Nearly all of our tab completion tests are powered by lldbtest's complete_from_to which is expected to gather the tab completions LLDB provides and then check the result. While debugging a random failure in TestCompletion in b51321ccc894 I noticed how the semantics of complete_from_to are rather forgiving.

Just to recapitulate how LLDB completions work: LLDB's HandleCompletion function computes a list of strings that are all completions for the current command token (not the whole command line). The first string has a magic meaning as it's the common prefix of all provided completions that LLDB for some reason tries to compute for the client.

complete_from_to has some interesting approaches to testing HandleCompletion:

1. It runs HandleCompletion, looks at the output and then decides based on the output whether the caller wants to check the common prefix (the first magic element) or the rest of the list. This lead to the obscure bug in b51321ccc894. It seems really odd that a test function guesses based on the result what is the most likely thing the test actually wants to test.
2. The way one checks that a command has no completions is to do complete_from_to("cmd", "cmd"). This check is rather forgiving it seems as it apparently can't fail (at least there are several commands that are expected to fail but are magically passing in our test suit).
3. It actually just does substr search on the whole command line including the user input when checking results. One test didn't even specify a valid LLDB command but still passed as the function found the completion in the user input...
4. It contains a bunch of code for regex-based result matching but no one is actually doing that. This just causes that we have a bunch of workaround code to escape regex or turn this feature off.
5. The error messages on failure are really not useful and look like this: 'process attach -p 1' does not match expected result, got 'process attach -p 1' (that's a real error).

Given that the problem here is just matching a list of strings, I think we can really simplify this whole setup by just using normal asserts.

This patch replaces complete_from_to with three small test functions that just gather the completion strings and then use the normal assert* functions from Python's unittest. The test functions are for an exhaustive check of completions, a subset of completions (for tests where we the possible list of completions can change) and an explicit call to assert no completions.

• This means that we now get the really helpful error messages from the assert* functions (which even include diffs of what strings/characters are different).
• I completely removed the regex testing as no one is actually using it at the moment.
• I removed the whole approach of substr searching and we just use string equality to prevent bogus passes.
• Removed the requirement to specify the whole command that should be completed. The function also no longer searches the user input for 'expected' completions. This just made most calls to complete_from_to really verbose and lead to bogus passes.
• Removed my own test functions that I wrote for the expression completion test. Apparently I already run into this issue back then.
• Added FIXMEs to the checks that were incorrectly passing before now.

[teemperor]

lldb/test/API/commands/expression/completion/TestExprCompletion.py

112

Just realized I didn't re-add that feature yet to the new test function...

[JDevlieghere]

This is great, thanks for taking the time to fix all this.

lldb/packages/Python/lldbsuite/test/lldbtest.py

2259–2267

While you're here... can you document the magic values?

2293

Maybe add another assert that len(expected_completions) <= len(returned_completions)

[teemperor]

• Make the assert_completions_contains remove an element after it was found (to prevent finding the same element twice).
• Removed special assert for negative return codes.

[teemperor]

lldb/packages/Python/lldbsuite/test/lldbtest.py

2259–2267

Totally forgot I already removed them from the internal logic and I doubt anyone handled them in the SB API. So I just removed that assert as the one below should cover it.

2293

I'm not removing any matches element which should do the same trick but is even stricter (and generates has a nicer error message).

lldb/packages/Python/lldbsuite/test/lldbtest.py

def check_completion_with_desc(self, str_input, match_desc_pairs, enforce_order=False):
         if got_failure:
             error_msg += "Got the following " + str(num_matches) + " completions back:\n"
             for i in range(num_matches + 1):
                 match_candidate = match_strings.GetStringAtIndex(i)
                 description_candidate = description_strings.GetStringAtIndex(i)
                 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, cursor_pos = None):
+        """ Returns the list of completions for the given command input. The
+        completions are just the completed current token as it is returned
+        by HandleCompletion. cursor_pos is the position of the user cursor
+        in the given command (with 0 meaning the cursor is on the first character
+        and cursor_pos = len(command) meaning it's behind the last character.
+        The cursor_pos is by default behind the last character."""
         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])
+        if cursor_pos is None:
+            cursor_pos = len(command)
+        return_code = interp.HandleCompletion(command, cursor_pos, 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 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,
+                                 cursor_pos = None):
         """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")
+        given list of completions.
+        :param command The command string that should be completed.
+        :param expected_completions The list of completions that are expected.
+        :param cursor_pos See get_completion_list's cursor_pos parameter.
+        """
+
+        # 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, cursor_pos),
+                              "Returned incorrect command completions")
 
-    def completions_contain(self, command, completions):
+    def assert_completions_contain(self, command, expected_completions,
+                                   cursor_pos = None):
         """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:],
-                          "Couldn't find expected completion")
+        list of completions.
+        :param command The command string that should be completed.
+        :param expected_completions The list of completions that are expected.
+        :param cursor_pos See get_completion_list's cursor_pos parameter.
+        """
+
+        # 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, cursor_pos)
+        remaining_completions = returned_completions[:]
+
+        for expected_completion in expected_completions:
+            self.assertIn(expected_completion, remaining_completions,
+                          "Couldn't find expected completion in remaining" +
+                          "completions. All returned completions were: " +
+                          str(returned_completions))
+            # Remove completion that we can't find it again in the following
+            # iterations.
+            remaining_completions.remove(expected_completion)
+
+    def assert_no_completions(self, command, cursor_pos = None):
+        """Checks that the command does not produce any tab completions.
+        :param command The command string that should be completed.
+        :param cursor_pos See get_completion_list's cursor_pos parameter.
+        """
+        self.assertItemsEqual([], self.get_completion_list(command, cursor_pos),
+                              "Expected no command completions")
 
     def filecheck(
             self,
             command,
             check_file,
             filecheck_options = '',
             expect_cmd_failure = False):
         # Run the command.

lldb/test/API/commands/expression/completion/TestExprCompletion.py

class CommandLineExprCompletionTestCase(TestBase):
 
     def test_expr_completion(self):
         self.build()
         self.main_source = "main.cpp"
         self.main_source_spec = lldb.SBFileSpec(self.main_source)
         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.',
+        self.assert_completions_contain('expr some_expr.',
                                         ['some_expr.FooNumbersBar1()',
                                          'some_expr.FooUnderscoreBar_()',
                                          'some_expr.FooWithArgsBar(',
                                          'some_expr.MemberVariableBar'])
 
-        self.completions_contain('expr some_expr.Foo',
+        self.assert_completions_contain('expr some_expr.Foo',
                                         ['some_expr.FooNumbersBar1()',
                                          'some_expr.FooUnderscoreBar_()',
                                          'some_expr.FooWithArgsBar('])
 
-        self.completions_contain('expr ',
+        self.assert_completions_contain('expr ',
                                         ['static_cast',
                                          'reinterpret_cast',
                                          'dynamic_cast'])
 
-        self.completions_contain('expr 1 + ',
+        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+',
+        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'])
+
+        # Completing inside double dash should do nothing.
+        self.assert_no_completions("expr -i0 -- some_expr.", cursor_pos=10)
+        self.assert_no_completions("expr -i0 -- some_expr.", cursor_pos=11)
+
         # 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()
         self.main_source = "main.cpp"
         self.main_source_spec = lldb.SBFileSpec(self.main_source)
         self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
 
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
def test_expr_completion_with_descriptions(self):
             ["some_expr.StaticMemberMethodBar()", "static int StaticMemberMethodBar()"],
             ["some_expr.Self()", "Expr &Self()"],
             ["some_expr.FooNoArgsBar()", "int FooNoArgsBar()"],
             ["some_expr.FooWithArgsBar(", "int FooWithArgsBar(int)"],
             ["some_expr.FooNumbersBar1()", "int FooNumbersBar1()"],
             ["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))

lldb/test/API/functionalities/completion/TestCompletion.py

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 ')
+        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()
         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')
+        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 ',
+        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 <index>" """
         # 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"))
         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.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()
-        match_strings = lldb.SBStringList()
-        num_matches = interp.HandleCompletion(input, len(input), 0, -1, match_strings)
+        match_strings = self.get_completion_list(input)
         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))
-
+        self.assertTrue(found_needle, "Returned completions: " + str(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.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()
         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',
+        self.assert_completions_contain('process signal ',
                                         ['SIGABRT',
                                         'SIGALRM'])
 
     def test_ambiguous_long_opt(self):
-        self.completions_match('breakpoint modify --th',
+        self.assert_completions_equal('breakpoint modify --th',
                                       ['--thread-id',
                                       '--thread-index',
                                       '--thread-name'])
 
     def test_disassemble_dash_f(self):
-        self.completions_match('disassemble -F ',
+        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])
 
     # <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)
+        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()
         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'])
+            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',
+        self.assert_completions_contain('settings set target.pr',
                                         ['target.prefer-dynamic-value',
-                               'target.process.'])
+                                        '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.',
+        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 ',
+        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',
+        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',
+        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',
                        '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.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")
         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')
+        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"""
         self.check_completion_with_desc("", [
             ["command", "Commands for managing custom LLDB commands."],
             ["breakpoint", "Commands for operating on breakpoints (see 'help b' for shorthand.)"]
         ])
 
def test_completion_description_command_options(self):
         # 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'])
+        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"""
 
         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.assert_no_completions('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 + ' ',
+            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'])
 
     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 ')
+        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"])

lldb/test/API/functionalities/gdb_remote_client/TestGDBRemoteDiskFileCompletion.py

def test_autocomplete_request(self):
         self.server.responder = Responder()
 
         try:
             self.runCmd("platform select remote-gdb-server")
             self.runCmd("platform connect connect://localhost:%d" %
                         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()