mirror of
https://github.com/Gericom/teak-llvm.git
synced 2025-06-22 04:55:50 -04:00
29872606d2
Summary: As discussed on lldb-dev, this patch moves some LLDB tests into a hierarchy that more closely resembles the commands we use in the LLDB interpreter. This patch should only move tests that use the command interpreter and shouldn't touch any tests that primarily test the SB API. Reviewers: #lldb, jfb, JDevlieghere Reviewed By: #lldb, JDevlieghere Subscribers: dexonsmith, arphaman, JDevlieghere, lldb-commits Tags: #lldb Differential Revision: https://reviews.llvm.org/D67033 llvm-svn: 370605
256 lines
12 KiB
Python
256 lines
12 KiB
Python
"""
|
|
Test the lldb command line completion mechanism for the 'expr' command.
|
|
"""
|
|
|
|
from __future__ import print_function
|
|
|
|
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.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')
|
|
|
|
|
|
(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.dbg.CreateTarget(self.getBuildArtifact("a.out"))
|
|
|
|
(target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
|
|
'// Break here', self.main_source_spec)
|
|
|
|
self.check_completion_with_desc("expr ", [
|
|
# VarDecls have their type as description.
|
|
["some_expr", "Expr &"],
|
|
# builtin types have no description.
|
|
["int", ""],
|
|
["float", ""]
|
|
])
|
|
self.check_completion_with_desc("expr some_expr.", [
|
|
# Functions have their signature as description.
|
|
["some_expr.Self()", "Expr &Self()"],
|
|
["some_expr.operator=(", "inline Expr &operator=(const Expr &)"],
|
|
["some_expr.FooNumbersBar1()", "int FooNumbersBar1()"],
|
|
["some_expr.StaticMemberMethodBar()", "static int StaticMemberMethodBar()"],
|
|
["some_expr.FooWithArgsBar(", "int FooWithArgsBar(int)"],
|
|
["some_expr.FooNoArgsBar()", "int FooNoArgsBar()"],
|
|
["some_expr.FooUnderscoreBar_()", "int FooUnderscoreBar_()"],
|
|
["some_expr.FooWithMultipleArgsBar(", "int FooWithMultipleArgsBar(int, int)"],
|
|
["some_expr.~Expr()", "inline ~Expr()"],
|
|
# FieldDecls have their type as description.
|
|
["some_expr.MemberVariableBar", "int"],
|
|
])
|
|
|
|
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))
|