e1e7263d62daeb2158cf12d4bf2b0820e7751ac1
[lldb.git] / lldb / packages / Python / lldbsuite / test / lldbinline.py
1 from __future__ import print_function
2 from __future__ import absolute_import
3
4 # System modules
5 import os
6
7 # Third-party modules
8 import io
9
10 # LLDB modules
11 import lldb
12 from .lldbtest import *
13 from . import configuration
14 from . import lldbutil
15 from .decorators import *
16
17 def source_type(filename):
18     _, extension = os.path.splitext(filename)
19     return {
20         '.c': 'C_SOURCES',
21         '.cpp': 'CXX_SOURCES',
22         '.cxx': 'CXX_SOURCES',
23         '.cc': 'CXX_SOURCES',
24         '.m': 'OBJC_SOURCES',
25         '.mm': 'OBJCXX_SOURCES'
26     }.get(extension, None)
27
28
29 class CommandParser:
30
31     def __init__(self):
32         self.breakpoints = []
33
34     def parse_one_command(self, line):
35         parts = line.split('//%')
36
37         command = None
38         new_breakpoint = True
39
40         if len(parts) == 2:
41             command = parts[1].strip()  # take off whitespace
42             new_breakpoint = parts[0].strip() != ""
43
44         return (command, new_breakpoint)
45
46     def parse_source_files(self, source_files):
47         for source_file in source_files:
48             file_handle = io.open(source_file, encoding='utf-8')
49             lines = file_handle.readlines()
50             line_number = 0
51             # non-NULL means we're looking through whitespace to find
52             # additional commands
53             current_breakpoint = None
54             for line in lines:
55                 line_number = line_number + 1  # 1-based, so we do this first
56                 (command, new_breakpoint) = self.parse_one_command(line)
57
58                 if new_breakpoint:
59                     current_breakpoint = None
60
61                 if command is not None:
62                     if current_breakpoint is None:
63                         current_breakpoint = {}
64                         current_breakpoint['file_name'] = source_file
65                         current_breakpoint['line_number'] = line_number
66                         current_breakpoint['command'] = command
67                         self.breakpoints.append(current_breakpoint)
68                     else:
69                         current_breakpoint['command'] = current_breakpoint[
70                             'command'] + "\n" + command
71
72     def set_breakpoints(self, target):
73         for breakpoint in self.breakpoints:
74             breakpoint['breakpoint'] = target.BreakpointCreateByLocation(
75                 breakpoint['file_name'], breakpoint['line_number'])
76
77     def handle_breakpoint(self, test, breakpoint_id):
78         for breakpoint in self.breakpoints:
79             if breakpoint['breakpoint'].GetID() == breakpoint_id:
80                 test.execute_user_command(breakpoint['command'])
81                 return
82
83
84 class InlineTest(TestBase):
85
86     def getBuildDirBasename(self):
87         return self.__class__.__name__ + "." + self.testMethodName
88
89     def BuildMakefile(self):
90         makefilePath = self.getBuildArtifact("Makefile")
91         if os.path.exists(makefilePath):
92             return
93
94         categories = {}
95         for f in os.listdir(self.getSourceDir()):
96             t = source_type(f)
97             if t:
98                 if t in list(categories.keys()):
99                     categories[t].append(f)
100                 else:
101                     categories[t] = [f]
102
103         with open(makefilePath, 'w+') as makefile:
104             for t in list(categories.keys()):
105                 line = t + " := " + " ".join(categories[t])
106                 makefile.write(line + "\n")
107
108             if ('OBJCXX_SOURCES' in list(categories.keys())) or \
109                ('OBJC_SOURCES' in list(categories.keys())):
110                 makefile.write(
111                     "LDFLAGS = $(CFLAGS) -lobjc -framework Foundation\n")
112
113             if ('CXX_SOURCES' in list(categories.keys())):
114                 makefile.write("CXXFLAGS += -std=c++11\n")
115
116             makefile.write("include Makefile.rules\n")
117
118     def _test(self):
119         self.BuildMakefile()
120         self.build(dictionary=self._build_dict)
121         self.do_test()
122
123     @add_test_categories(["dts"])
124     def __test_with_dts(self):
125         self.using_dsym = False
126         self.BuildMakefile()
127         self.build()
128         self.do_test()
129     __test_with_dts.debug_info = "dts"
130
131     @add_test_categories(["dwz"])
132     def __test_with_dwz(self):
133         self.using_dsym = False
134         self.BuildMakefile()
135         self.build()
136         self.do_test()
137     __test_with_dwz.debug_info = "dwz"
138
139     def execute_user_command(self, __command):
140         exec(__command, globals(), locals())
141
142     def _get_breakpoint_ids(self, thread):
143         ids = set()
144         for i in range(0, thread.GetStopReasonDataCount(), 2):
145             ids.add(thread.GetStopReasonDataAtIndex(i))
146         self.assertGreater(len(ids), 0)
147         return sorted(ids)
148
149     def do_test(self):
150         exe = self.getBuildArtifact("a.out")
151         source_files = [f for f in os.listdir(self.getSourceDir())
152                         if source_type(f)]
153         target = self.dbg.CreateTarget(exe)
154
155         parser = CommandParser()
156         parser.parse_source_files(source_files)
157         parser.set_breakpoints(target)
158
159         process = target.LaunchSimple(None, None, self.get_process_working_directory())
160         self.assertIsNotNone(process, PROCESS_IS_VALID)
161
162         hit_breakpoints = 0
163
164         while lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint):
165             hit_breakpoints += 1
166             thread = lldbutil.get_stopped_thread(
167                 process, lldb.eStopReasonBreakpoint)
168             for bp_id in self._get_breakpoint_ids(thread):
169                 parser.handle_breakpoint(self, bp_id)
170             process.Continue()
171
172         self.assertTrue(hit_breakpoints > 0,
173                         "inline test did not hit a single breakpoint")
174         # Either the process exited or the stepping plan is complete.
175         self.assertTrue(process.GetState() in [lldb.eStateStopped,
176                                                lldb.eStateExited],
177                         PROCESS_EXITED)
178
179     def check_expression(self, expression, expected_result, use_summary=True):
180         value = self.frame().EvaluateExpression(expression)
181         self.assertTrue(value.IsValid(), expression + "returned a valid value")
182         if self.TraceOn():
183             print(value.GetSummary())
184             print(value.GetValue())
185         if use_summary:
186             answer = value.GetSummary()
187         else:
188             answer = value.GetValue()
189         report_str = "%s expected: %s got: %s" % (
190             expression, expected_result, answer)
191         self.assertTrue(answer == expected_result, report_str)
192
193
194 def ApplyDecoratorsToFunction(func, decorators):
195     tmp = func
196     if isinstance(decorators, list):
197         for decorator in decorators:
198             tmp = decorator(tmp)
199     elif hasattr(decorators, '__call__'):
200         tmp = decorators(tmp)
201     return tmp
202
203
204 def MakeInlineTest(__file, __globals, decorators=None, name=None,
205         build_dict=None):
206     # Adjust the filename if it ends in .pyc.  We want filenames to
207     # reflect the source python file, not the compiled variant.
208     if __file is not None and __file.endswith(".pyc"):
209         # Strip the trailing "c"
210         __file = __file[0:-1]
211
212     if name is None:
213         # Derive the test name from the current file name
214         file_basename = os.path.basename(__file)
215         name, _ = os.path.splitext(file_basename)
216
217     test_func = ApplyDecoratorsToFunction(InlineTest._test, decorators)
218     # Build the test case
219     test_class = type(name, (InlineTest,), dict(test=test_func,
220         name=name, _build_dict=build_dict))
221
222     # Add the test case to the globals, and hide InlineTest
223     __globals.update({name: test_class})
224
225     # Keep track of the original test filename so we report it
226     # correctly in test results.
227     test_class.test_filename = __file
228     test_class.mydir = TestBase.compute_mydir(__file)
229     return test_class