mirror of
https://github.com/Gericom/teak-llvm.git
synced 2025-06-22 13:05:52 -04:00
756b91dc14
This is a set of tests that were all marked as failing becuse of pr24489. The bug is not fixed (as in more of the tests that were marked this way are failing), but this set is passing. It is possible that some of them are false positives, but there's a large number of unexpectedly passing tests on Windows, so I am doing a bulk un-xfail to get the buildbot to green. llvm-svn: 349665
258 lines
12 KiB
Python
258 lines
12 KiB
Python
"""
|
|
Test the lldb command line completion mechanism for the 'expr' command.
|
|
"""
|
|
|
|
from __future__ import print_function
|
|
|
|
import random
|
|
import os
|
|
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))
|