2bab1738f3
All calls to operator new in this test fail for me with: ``` expression --show-types -- *(new foo(47))` Error output: error: Execution was interrupted, reason: internal c++ exception breakpoint(-6).. The process has been returned to the state before expression evaluation. ``` As calling operator new isn't the idea of this test, this patch moves that logic to the binary with some new_* utility functions and explicitly tests this logic in the constructor test (where we can isolate the failures and skip them on Linux).
301 lines
9.9 KiB
Python
301 lines
9.9 KiB
Python
"""
|
|
Test using LLDB data formatters with frozen objects coming from the expression parser.
|
|
"""
|
|
|
|
|
|
|
|
import lldb
|
|
from lldbsuite.test.decorators import *
|
|
from lldbsuite.test.lldbtest import *
|
|
from lldbsuite.test import lldbutil
|
|
|
|
|
|
class ExprFormattersTestCase(TestBase):
|
|
|
|
mydir = TestBase.compute_mydir(__file__)
|
|
|
|
def setUp(self):
|
|
# Call super's setUp().
|
|
TestBase.setUp(self)
|
|
# Find the line number to break for main.cpp.
|
|
self.line = line_number('main.cpp',
|
|
'// Stop here')
|
|
|
|
@skipIfFreeBSD # llvm.org/pr24691 skipping to avoid crashing the test runner
|
|
@expectedFailureNetBSD
|
|
@expectedFailureAll(
|
|
oslist=['freebsd'],
|
|
bugnumber='llvm.org/pr19011 Newer Clang omits C1 complete object constructor')
|
|
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
|
|
@skipIfTargetAndroid() # skipping to avoid crashing the test runner
|
|
@expectedFailureAndroid('llvm.org/pr24691') # we hit an assertion in clang
|
|
def test(self):
|
|
"""Test expr + formatters for good interoperability."""
|
|
self.build()
|
|
|
|
# This is the function to remove the custom formats in order to have a
|
|
# clean slate for the next test case.
|
|
def cleanup():
|
|
self.runCmd('type summary clear', check=False)
|
|
self.runCmd('type synthetic clear', check=False)
|
|
|
|
# Execute the cleanup function during test case tear down.
|
|
self.addTearDownHook(cleanup)
|
|
|
|
"""Test expr + formatters for good interoperability."""
|
|
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
|
|
|
|
lldbutil.run_break_set_by_file_and_line(
|
|
self, "main.cpp", self.line, loc_exact=True)
|
|
|
|
self.runCmd("run", RUN_SUCCEEDED)
|
|
self.runCmd("command script import formatters.py")
|
|
self.runCmd("command script import foosynth.py")
|
|
|
|
if self.TraceOn():
|
|
self.runCmd("frame variable foo1 --show-types")
|
|
self.runCmd("frame variable foo1.b --show-types")
|
|
self.runCmd("frame variable foo1.b.b_ref --show-types")
|
|
|
|
self.filecheck("expression --show-types -- *(new_foo(47))", __file__,
|
|
'-check-prefix=EXPR-TYPES-NEW-FOO')
|
|
# EXPR-TYPES-NEW-FOO: (foo) ${{.*}} = {
|
|
# EXPR-TYPES-NEW-FOO-NEXT: (int) a = 47
|
|
# EXPR-TYPES-NEW-FOO-NEXT: (int *) a_ptr = 0x
|
|
# EXPR-TYPES-NEW-FOO-NEXT: (bar) b = {
|
|
# EXPR-TYPES-NEW-FOO-NEXT: (int) i = 94
|
|
# EXPR-TYPES-NEW-FOO-NEXT: (int *) i_ptr = 0x
|
|
# EXPR-TYPES-NEW-FOO-NEXT: (baz) b = {
|
|
# EXPR-TYPES-NEW-FOO-NEXT: (int) h = 97
|
|
# EXPR-TYPES-NEW-FOO-NEXT: (int) k = 99
|
|
# EXPR-TYPES-NEW-FOO-NEXT: }
|
|
# EXPR-TYPES-NEW-FOO-NEXT: (baz &) b_ref = 0x
|
|
# EXPR-TYPES-NEW-FOO-NEXT: }
|
|
# EXPR-TYPES-NEW-FOO-NEXT: }
|
|
|
|
|
|
self.runCmd("type summary add -F formatters.foo_SummaryProvider3 foo")
|
|
self.filecheck("expression foo1", __file__, '-check-prefix=EXPR-FOO1opts')
|
|
# EXPR-FOO1opts: (foo) $
|
|
# EXPR-FOO1opts-SAME: a = 12
|
|
# EXPR-FOO1opts-SAME: a_ptr = {{[0-9]+}} -> 13
|
|
# EXPR-FOO1opts-SAME: i = 24
|
|
# EXPR-FOO1opts-SAME: i_ptr = {{[0-9]+}} -> 25
|
|
# EXPR-FOO1opts-SAME: b_ref = {{[0-9]+}}
|
|
# EXPR-FOO1opts-SAME: h = 27
|
|
# EXPR-FOO1opts-SAME: k = 29
|
|
# EXPR-FOO1opts-SAME: WITH_OPTS
|
|
|
|
self.runCmd("type summary delete foo")
|
|
|
|
self.runCmd("type summary add -F formatters.foo_SummaryProvider foo")
|
|
|
|
self.expect("expression new_int(12)",
|
|
substrs=['(int *) $', ' = 0x'])
|
|
|
|
self.runCmd(
|
|
"type summary add -s \"${var%pointer} -> ${*var%decimal}\" \"int *\"")
|
|
|
|
self.expect("expression new_int(12)",
|
|
substrs=['(int *) $', '= 0x', ' -> 12'])
|
|
|
|
self.expect("expression foo1.a_ptr",
|
|
substrs=['(int *) $', '= 0x', ' -> 13'])
|
|
|
|
self.filecheck("expression foo1", __file__, '-check-prefix=EXPR-FOO1')
|
|
# EXPR-FOO1: (foo) $
|
|
# EXPR-FOO1-SAME: a = 12
|
|
# EXPR-FOO1-SAME: a_ptr = {{[0-9]+}} -> 13
|
|
# EXPR-FOO1-SAME: i = 24
|
|
# EXPR-FOO1-SAME: i_ptr = {{[0-9]+}} -> 25
|
|
# EXPR-FOO1-SAME: b_ref = {{[0-9]+}}
|
|
# EXPR-FOO1-SAME: h = 27
|
|
# EXPR-FOO1-SAME: k = 29
|
|
|
|
self.filecheck("expression --ptr-depth=1 -- new_foo(47)", __file__,
|
|
'-check-prefix=EXPR-PTR-DEPTH1')
|
|
# EXPR-PTR-DEPTH1: (foo *) $
|
|
# EXPR-PTR-DEPTH1-SAME: a = 47
|
|
# EXPR-PTR-DEPTH1-SAME: a_ptr = {{[0-9]+}} -> 48
|
|
# EXPR-PTR-DEPTH1-SAME: i = 94
|
|
# EXPR-PTR-DEPTH1-SAME: i_ptr = {{[0-9]+}} -> 95
|
|
|
|
self.filecheck("expression foo2", __file__, '-check-prefix=EXPR-FOO2')
|
|
# EXPR-FOO2: (foo) $
|
|
# EXPR-FOO2-SAME: a = 121
|
|
# EXPR-FOO2-SAME: a_ptr = {{[0-9]+}} -> 122
|
|
# EXPR-FOO2-SAME: i = 242
|
|
# EXPR-FOO2-SAME: i_ptr = {{[0-9]+}} -> 243
|
|
# EXPR-FOO2-SAME: h = 245
|
|
# EXPR-FOO2-SAME: k = 247
|
|
|
|
object_name = self.res.GetOutput()
|
|
object_name = object_name[7:]
|
|
object_name = object_name[0:object_name.find(' =')]
|
|
|
|
self.filecheck("frame variable foo2", __file__, '-check-prefix=VAR-FOO2')
|
|
# VAR-FOO2: (foo) foo2
|
|
# VAR-FOO2-SAME: a = 121
|
|
# VAR-FOO2-SAME: a_ptr = {{[0-9]+}} -> 122
|
|
# VAR-FOO2-SAME: i = 242
|
|
# VAR-FOO2-SAME: i_ptr = {{[0-9]+}} -> 243
|
|
# VAR-FOO2-SAME: h = 245
|
|
# VAR-FOO2-SAME: k = 247
|
|
|
|
# The object is the same as foo2, so use the EXPR-FOO2 checks.
|
|
self.filecheck("expression $" + object_name, __file__,
|
|
'-check-prefix=EXPR-FOO2')
|
|
|
|
self.runCmd("type summary delete foo")
|
|
self.runCmd(
|
|
"type synthetic add --python-class foosynth.FooSyntheticProvider foo")
|
|
|
|
self.expect("expression --show-types -- $" + object_name,
|
|
substrs=['(foo) $', ' = {', '(int) *i_ptr = 243'])
|
|
|
|
self.runCmd("n")
|
|
self.runCmd("n")
|
|
|
|
self.runCmd("type synthetic delete foo")
|
|
self.runCmd("type summary add -F formatters.foo_SummaryProvider foo")
|
|
|
|
self.expect(
|
|
"expression foo2",
|
|
substrs=[
|
|
'(foo) $',
|
|
'a = 7777',
|
|
'a_ptr = ',
|
|
' -> 122',
|
|
'i = 242',
|
|
'i_ptr = ',
|
|
' -> 8888'])
|
|
|
|
self.expect("expression $" + object_name + '.a',
|
|
substrs=['7777'])
|
|
|
|
self.expect("expression *$" + object_name + '.b.i_ptr',
|
|
substrs=['8888'])
|
|
|
|
self.expect(
|
|
"expression $" +
|
|
object_name,
|
|
substrs=[
|
|
'(foo) $',
|
|
'a = 121',
|
|
'a_ptr = ',
|
|
' -> 122',
|
|
'i = 242',
|
|
'i_ptr = ',
|
|
' -> 8888',
|
|
'h = 245',
|
|
'k = 247'])
|
|
|
|
self.runCmd("type summary delete foo")
|
|
self.runCmd(
|
|
"type synthetic add --python-class foosynth.FooSyntheticProvider foo")
|
|
|
|
self.expect("expression --show-types -- $" + object_name,
|
|
substrs=['(foo) $', ' = {', '(int) *i_ptr = 8888'])
|
|
|
|
self.runCmd("n")
|
|
|
|
self.runCmd("type synthetic delete foo")
|
|
self.runCmd("type summary add -F formatters.foo_SummaryProvider foo")
|
|
|
|
self.expect(
|
|
"expression $" +
|
|
object_name,
|
|
substrs=[
|
|
'(foo) $',
|
|
'a = 121',
|
|
'a_ptr = ',
|
|
' -> 122',
|
|
'i = 242',
|
|
'i_ptr = ',
|
|
' -> 8888',
|
|
'k = 247'])
|
|
|
|
process = self.dbg.GetSelectedTarget().GetProcess()
|
|
thread = process.GetThreadAtIndex(0)
|
|
frame = thread.GetSelectedFrame()
|
|
|
|
frozen = frame.EvaluateExpression("$" + object_name + ".a_ptr")
|
|
|
|
a_data = frozen.GetPointeeData()
|
|
|
|
error = lldb.SBError()
|
|
self.assertTrue(
|
|
a_data.GetUnsignedInt32(
|
|
error,
|
|
0) == 122,
|
|
'*a_ptr = 122')
|
|
|
|
ret = line_number("main.cpp", "Done initializing")
|
|
self.runCmd("thread until " + str(ret))
|
|
|
|
self.expect("frame variable numbers",
|
|
substrs=['1', '2', '3', '4', '5'])
|
|
|
|
self.expect("expression numbers",
|
|
substrs=['1', '2', '3', '4', '5'])
|
|
|
|
frozen = frame.EvaluateExpression("&numbers")
|
|
|
|
a_data = frozen.GetPointeeData(0, 1)
|
|
|
|
self.assertTrue(
|
|
a_data.GetUnsignedInt32(
|
|
error,
|
|
0) == 1,
|
|
'numbers[0] == 1')
|
|
self.assertTrue(
|
|
a_data.GetUnsignedInt32(
|
|
error,
|
|
4) == 2,
|
|
'numbers[1] == 2')
|
|
self.assertTrue(
|
|
a_data.GetUnsignedInt32(
|
|
error,
|
|
8) == 3,
|
|
'numbers[2] == 3')
|
|
self.assertTrue(
|
|
a_data.GetUnsignedInt32(
|
|
error,
|
|
12) == 4,
|
|
'numbers[3] == 4')
|
|
self.assertTrue(
|
|
a_data.GetUnsignedInt32(
|
|
error,
|
|
16) == 5,
|
|
'numbers[4] == 5')
|
|
|
|
frozen = frame.EvaluateExpression("numbers")
|
|
|
|
a_data = frozen.GetData()
|
|
|
|
self.assertTrue(
|
|
a_data.GetUnsignedInt32(
|
|
error,
|
|
0) == 1,
|
|
'numbers[0] == 1')
|
|
self.assertTrue(
|
|
a_data.GetUnsignedInt32(
|
|
error,
|
|
4) == 2,
|
|
'numbers[1] == 2')
|
|
self.assertTrue(
|
|
a_data.GetUnsignedInt32(
|
|
error,
|
|
8) == 3,
|
|
'numbers[2] == 3')
|
|
self.assertTrue(
|
|
a_data.GetUnsignedInt32(
|
|
error,
|
|
12) == 4,
|
|
'numbers[3] == 4')
|
|
self.assertTrue(
|
|
a_data.GetUnsignedInt32(
|
|
error,
|
|
16) == 5,
|
|
'numbers[4] == 5')
|