1"""
2Test using LLDB data formatters with frozen objects coming from the expression parser.
3"""
4
5
6
7import lldb
8from lldbsuite.test.decorators import *
9from lldbsuite.test.lldbtest import *
10from lldbsuite.test import lldbutil
11
12
13class ExprFormattersTestCase(TestBase):
14
15    mydir = TestBase.compute_mydir(__file__)
16
17    def setUp(self):
18        # Call super's setUp().
19        TestBase.setUp(self)
20        # Find the line number to break for main.cpp.
21        self.line = line_number('main.cpp',
22                                '// Stop here')
23
24    @skipIfFreeBSD  # llvm.org/pr24691 skipping to avoid crashing the test runner
25    @expectedFailureAll(
26        oslist=['freebsd'],
27        bugnumber='llvm.org/pr19011 Newer Clang omits C1 complete object constructor')
28    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
29    @skipIfTargetAndroid()  # skipping to avoid crashing the test runner
30    @expectedFailureAndroid('llvm.org/pr24691')  # we hit an assertion in clang
31    def test(self):
32        """Test expr + formatters for good interoperability."""
33        self.build()
34
35        # This is the function to remove the custom formats in order to have a
36        # clean slate for the next test case.
37        def cleanup():
38            self.runCmd('type summary clear', check=False)
39            self.runCmd('type synthetic clear', check=False)
40
41        # Execute the cleanup function during test case tear down.
42        self.addTearDownHook(cleanup)
43
44        """Test expr + formatters for good interoperability."""
45        self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
46
47        lldbutil.run_break_set_by_file_and_line(
48            self, "main.cpp", self.line, loc_exact=True)
49
50        self.runCmd("run", RUN_SUCCEEDED)
51        self.runCmd("command script import formatters.py")
52        self.runCmd("command script import foosynth.py")
53
54        if self.TraceOn():
55            self.runCmd("frame variable foo1 --show-types")
56            self.runCmd("frame variable foo1.b --show-types")
57            self.runCmd("frame variable foo1.b.b_ref --show-types")
58
59        self.filecheck("expression --show-types -- *(new_foo(47))", __file__,
60                '-check-prefix=EXPR-TYPES-NEW-FOO')
61        # EXPR-TYPES-NEW-FOO: (foo) ${{.*}} = {
62        # EXPR-TYPES-NEW-FOO-NEXT:   (int) a = 47
63        # EXPR-TYPES-NEW-FOO-NEXT:   (int *) a_ptr = 0x
64        # EXPR-TYPES-NEW-FOO-NEXT:   (bar) b = {
65        # EXPR-TYPES-NEW-FOO-NEXT:     (int) i = 94
66        # EXPR-TYPES-NEW-FOO-NEXT:     (int *) i_ptr = 0x
67        # EXPR-TYPES-NEW-FOO-NEXT:     (baz) b = {
68        # EXPR-TYPES-NEW-FOO-NEXT:       (int) h = 97
69        # EXPR-TYPES-NEW-FOO-NEXT:       (int) k = 99
70        # EXPR-TYPES-NEW-FOO-NEXT:     }
71        # EXPR-TYPES-NEW-FOO-NEXT:     (baz &) b_ref = 0x
72        # EXPR-TYPES-NEW-FOO-NEXT:   }
73        # EXPR-TYPES-NEW-FOO-NEXT: }
74
75
76        self.runCmd("type summary add -F formatters.foo_SummaryProvider3 foo")
77        self.filecheck("expression foo1", __file__, '-check-prefix=EXPR-FOO1opts')
78        # EXPR-FOO1opts: (foo) $
79        # EXPR-FOO1opts-SAME: a = 12
80        # EXPR-FOO1opts-SAME: a_ptr = {{[0-9]+}} -> 13
81        # EXPR-FOO1opts-SAME: i = 24
82        # EXPR-FOO1opts-SAME: i_ptr = {{[0-9]+}} -> 25
83        # EXPR-FOO1opts-SAME: b_ref = {{[0-9]+}}
84        # EXPR-FOO1opts-SAME: h = 27
85        # EXPR-FOO1opts-SAME: k = 29
86        # EXPR-FOO1opts-SAME: WITH_OPTS
87
88        self.runCmd("type summary delete foo")
89
90        self.runCmd("type summary add -F formatters.foo_SummaryProvider foo")
91
92        self.expect("expression new_int(12)",
93                    substrs=['(int *) $', ' = 0x'])
94
95        self.runCmd(
96            "type summary add -s \"${var%pointer} -> ${*var%decimal}\" \"int *\"")
97
98        self.expect("expression new_int(12)",
99                    substrs=['(int *) $', '= 0x', ' -> 12'])
100
101        self.expect("expression foo1.a_ptr",
102                    substrs=['(int *) $', '= 0x', ' -> 13'])
103
104        self.filecheck("expression foo1", __file__, '-check-prefix=EXPR-FOO1')
105        # EXPR-FOO1: (foo) $
106        # EXPR-FOO1-SAME: a = 12
107        # EXPR-FOO1-SAME: a_ptr = {{[0-9]+}} -> 13
108        # EXPR-FOO1-SAME: i = 24
109        # EXPR-FOO1-SAME: i_ptr = {{[0-9]+}} -> 25
110        # EXPR-FOO1-SAME: b_ref = {{[0-9]+}}
111        # EXPR-FOO1-SAME: h = 27
112        # EXPR-FOO1-SAME: k = 29
113
114        self.filecheck("expression --ptr-depth=1 -- new_foo(47)", __file__,
115                '-check-prefix=EXPR-PTR-DEPTH1')
116        # EXPR-PTR-DEPTH1: (foo *) $
117        # EXPR-PTR-DEPTH1-SAME: a = 47
118        # EXPR-PTR-DEPTH1-SAME: a_ptr = {{[0-9]+}} -> 48
119        # EXPR-PTR-DEPTH1-SAME: i = 94
120        # EXPR-PTR-DEPTH1-SAME: i_ptr = {{[0-9]+}} -> 95
121
122        self.filecheck("expression foo2", __file__, '-check-prefix=EXPR-FOO2')
123        # EXPR-FOO2: (foo) $
124        # EXPR-FOO2-SAME: a = 121
125        # EXPR-FOO2-SAME: a_ptr = {{[0-9]+}} -> 122
126        # EXPR-FOO2-SAME: i = 242
127        # EXPR-FOO2-SAME: i_ptr = {{[0-9]+}} -> 243
128        # EXPR-FOO2-SAME: h = 245
129        # EXPR-FOO2-SAME: k = 247
130
131        object_name = self.res.GetOutput()
132        object_name = object_name[7:]
133        object_name = object_name[0:object_name.find(' =')]
134
135        self.filecheck("frame variable foo2", __file__, '-check-prefix=VAR-FOO2')
136        # VAR-FOO2: (foo) foo2
137        # VAR-FOO2-SAME: a = 121
138        # VAR-FOO2-SAME: a_ptr = {{[0-9]+}} -> 122
139        # VAR-FOO2-SAME: i = 242
140        # VAR-FOO2-SAME: i_ptr = {{[0-9]+}} -> 243
141        # VAR-FOO2-SAME: h = 245
142        # VAR-FOO2-SAME: k = 247
143
144        # The object is the same as foo2, so use the EXPR-FOO2 checks.
145        self.filecheck("expression $" + object_name, __file__,
146                '-check-prefix=EXPR-FOO2')
147
148        self.runCmd("type summary delete foo")
149        self.runCmd(
150            "type synthetic add --python-class foosynth.FooSyntheticProvider foo")
151
152        self.expect("expression --show-types -- $" + object_name,
153                    substrs=['(foo) $', ' = {', '(int) *i_ptr = 243'])
154
155        self.runCmd("n")
156        self.runCmd("n")
157
158        self.runCmd("type synthetic delete foo")
159        self.runCmd("type summary add -F formatters.foo_SummaryProvider foo")
160
161        self.expect(
162            "expression foo2",
163            substrs=[
164                '(foo) $',
165                'a = 7777',
166                'a_ptr = ',
167                ' -> 122',
168                'i = 242',
169                'i_ptr = ',
170                ' -> 8888'])
171
172        self.expect("expression $" + object_name + '.a',
173                    substrs=['7777'])
174
175        self.expect("expression *$" + object_name + '.b.i_ptr',
176                    substrs=['8888'])
177
178        self.expect(
179            "expression $" +
180            object_name,
181            substrs=[
182                '(foo) $',
183                'a = 121',
184                'a_ptr = ',
185                ' -> 122',
186                'i = 242',
187                'i_ptr = ',
188                ' -> 8888',
189                'h = 245',
190                'k = 247'])
191
192        self.runCmd("type summary delete foo")
193        self.runCmd(
194            "type synthetic add --python-class foosynth.FooSyntheticProvider foo")
195
196        self.expect("expression --show-types -- $" + object_name,
197                    substrs=['(foo) $', ' = {', '(int) *i_ptr = 8888'])
198
199        self.runCmd("n")
200
201        self.runCmd("type synthetic delete foo")
202        self.runCmd("type summary add -F formatters.foo_SummaryProvider foo")
203
204        self.expect(
205            "expression $" +
206            object_name,
207            substrs=[
208                '(foo) $',
209                'a = 121',
210                'a_ptr = ',
211                ' -> 122',
212                'i = 242',
213                'i_ptr = ',
214                ' -> 8888',
215                'k = 247'])
216
217        process = self.dbg.GetSelectedTarget().GetProcess()
218        thread = process.GetThreadAtIndex(0)
219        frame = thread.GetSelectedFrame()
220
221        frozen = frame.EvaluateExpression("$" + object_name + ".a_ptr")
222
223        a_data = frozen.GetPointeeData()
224
225        error = lldb.SBError()
226        self.assertTrue(
227            a_data.GetUnsignedInt32(
228                error,
229                0) == 122,
230            '*a_ptr = 122')
231
232        ret = line_number("main.cpp", "Done initializing")
233        self.runCmd("thread until " + str(ret))
234
235        self.expect("frame variable numbers",
236                    substrs=['1', '2', '3', '4', '5'])
237
238        self.expect("expression numbers",
239                    substrs=['1', '2', '3', '4', '5'])
240
241        frozen = frame.EvaluateExpression("&numbers")
242
243        a_data = frozen.GetPointeeData(0, 1)
244
245        self.assertTrue(
246            a_data.GetUnsignedInt32(
247                error,
248                0) == 1,
249            'numbers[0] == 1')
250        self.assertTrue(
251            a_data.GetUnsignedInt32(
252                error,
253                4) == 2,
254            'numbers[1] == 2')
255        self.assertTrue(
256            a_data.GetUnsignedInt32(
257                error,
258                8) == 3,
259            'numbers[2] == 3')
260        self.assertTrue(
261            a_data.GetUnsignedInt32(
262                error,
263                12) == 4,
264            'numbers[3] == 4')
265        self.assertTrue(
266            a_data.GetUnsignedInt32(
267                error,
268                16) == 5,
269            'numbers[4] == 5')
270
271        frozen = frame.EvaluateExpression("numbers")
272
273        a_data = frozen.GetData()
274
275        self.assertTrue(
276            a_data.GetUnsignedInt32(
277                error,
278                0) == 1,
279            'numbers[0] == 1')
280        self.assertTrue(
281            a_data.GetUnsignedInt32(
282                error,
283                4) == 2,
284            'numbers[1] == 2')
285        self.assertTrue(
286            a_data.GetUnsignedInt32(
287                error,
288                8) == 3,
289            'numbers[2] == 3')
290        self.assertTrue(
291            a_data.GetUnsignedInt32(
292                error,
293                12) == 4,
294            'numbers[3] == 4')
295        self.assertTrue(
296            a_data.GetUnsignedInt32(
297                error,
298                16) == 5,
299            'numbers[4] == 5')
300