54c2687292
At the moment nearly every test calls something similar to
`self.dbg.CreateTarget(self.getBuildArtifact("a.out"))` and them sometimes
checks if the created target is actually valid with something like
`self.assertTrue(target.IsValid(), "some useless text")`.
Beside being really verbose the error messages generated by this pattern are
always just indicating that the target failed to be created but now why.
This patch introduces a helper function `createTestTarget` to our Test class
that creates the target with the much more verbose `CreateTarget` overload that
gives us back an SBError (with a fancy error). If the target couldn't be created
the function prints out the SBError that LLDB returned and asserts for us. It
also defaults to the "a.out" build artifact path that nearly all tests are using
to avoid to hardcode "a.out" in every test.
I converted a bunch of tests to the new function but I'll do the rest of the
test suite as follow ups.
Reviewed By: JDevlieghere
Differential Revision: https://reviews.llvm.org/D102771
255 lines
12 KiB
Python
255 lines
12 KiB
Python
"""
|
|
Test the lldb command line completion mechanism for the 'expr' command.
|
|
"""
|
|
|
|
|
|
import lldb
|
|
from lldbsuite.test.decorators import *
|
|
from lldbsuite.test.lldbtest import *
|
|
from lldbsuite.test import lldbplatform
|
|
from lldbsuite.test import lldbutil
|
|
|
|
class CommandLineExprCompletionTestCase(TestBase):
|
|
|
|
mydir = TestBase.compute_mydir(__file__)
|
|
|
|
NO_DEBUG_INFO_TESTCASE = True
|
|
|
|
def test_expr_completion(self):
|
|
self.build()
|
|
self.main_source = "main.cpp"
|
|
self.main_source_spec = lldb.SBFileSpec(self.main_source)
|
|
self.createTestTarget()
|
|
|
|
# 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')
|
|
|
|
|
|
(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()')
|
|
|
|
# Completing static functions
|
|
self.complete_exactly('expr Expr::StaticMemberMethod',
|
|
'expr Expr::StaticMemberMethodBar()')
|
|
|
|
# Completing member variables
|
|
self.complete_exactly('expr some_expr.MemberVariab',
|
|
'expr 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'])
|
|
|
|
# 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"])
|
|
|
|
# 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()')
|
|
|
|
# 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')
|
|
# 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)
|
|
|
|
# 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()')
|
|
|
|
# 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()')
|
|
|
|
# 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()')
|
|
|
|
# Builtin arg
|
|
self.complete_exactly('expr static_ca',
|
|
'expr static_cast')
|
|
|
|
# From other files
|
|
self.complete_exactly('expr fwd_decl_ptr->Hidden',
|
|
'expr fwd_decl_ptr->HiddenMember')
|
|
|
|
|
|
# Types
|
|
self.complete_exactly('expr LongClassNa',
|
|
'expr LongClassName')
|
|
self.complete_exactly('expr LongNamespaceName::NestedCla',
|
|
'expr LongNamespaceName::NestedClass')
|
|
|
|
# Namespaces
|
|
self.complete_exactly('expr LongNamespaceNa',
|
|
'expr 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')
|
|
|
|
# Multiple statements
|
|
self.complete_exactly('expr long LocalVariable = 0; LocalVaria',
|
|
'expr long LocalVariable = 0; 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')
|
|
|
|
# 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')
|
|
|
|
# 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()')
|
|
|
|
def test_expr_completion_with_descriptions(self):
|
|
self.build()
|
|
self.main_source = "main.cpp"
|
|
self.main_source_spec = lldb.SBFileSpec(self.main_source)
|
|
self.createTestTarget()
|
|
|
|
(target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
|
|
'// Break here', self.main_source_spec)
|
|
|
|
self.check_completion_with_desc("expr ", [
|
|
# builtin types have no description.
|
|
["int", ""],
|
|
["float", ""],
|
|
# VarDecls have their type as description.
|
|
["some_expr", "Expr &"],
|
|
], enforce_order = True)
|
|
self.check_completion_with_desc("expr some_expr.", [
|
|
# Functions have their signature as description.
|
|
["some_expr.~Expr()", "inline ~Expr()"],
|
|
["some_expr.operator=(", "inline Expr &operator=(const Expr &)"],
|
|
# FieldDecls have their type as description.
|
|
["some_expr.MemberVariableBar", "int"],
|
|
["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))
|