1from __future__ import print_function
2from __future__ import absolute_import
3
4# System modules
5import os
6
7# Third-party modules
8import io
9
10# LLDB modules
11import lldb
12from .lldbtest import *
13from . import configuration
14from . import lldbutil
15from .decorators import *
16
17def 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
29class 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
84class InlineTest(TestBase):
85    # Internal implementation
86
87    def BuildMakefile(self):
88        makefilePath = self.getBuildArtifact("Makefile")
89        if os.path.exists(makefilePath):
90            return
91
92        categories = {}
93
94        for f in os.listdir(self.getSourceDir()):
95            t = source_type(f)
96            if t:
97                if t in list(categories.keys()):
98                    categories[t].append(f)
99                else:
100                    categories[t] = [f]
101
102        makefile = open(makefilePath, 'w+')
103
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        makefile.write("\ncleanup:\n\trm -f Makefile *.d\n\n")
118        makefile.flush()
119        makefile.close()
120
121    def _test(self):
122        self.BuildMakefile()
123        self.build()
124        self.do_test()
125
126    def execute_user_command(self, __command):
127        exec(__command, globals(), locals())
128
129    def do_test(self):
130        exe = self.getBuildArtifact("a.out")
131        source_files = [f for f in os.listdir(self.getSourceDir())
132                        if source_type(f)]
133        target = self.dbg.CreateTarget(exe)
134
135        parser = CommandParser()
136        parser.parse_source_files(source_files)
137        parser.set_breakpoints(target)
138
139        process = target.LaunchSimple(None, None, self.get_process_working_directory())
140        self.assertIsNotNone(process, PROCESS_IS_VALID)
141
142        hit_breakpoints = 0
143
144        while lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint):
145            hit_breakpoints += 1
146            thread = lldbutil.get_stopped_thread(
147                process, lldb.eStopReasonBreakpoint)
148            breakpoint_id = thread.GetStopReasonDataAtIndex(0)
149            parser.handle_breakpoint(self, breakpoint_id)
150            process.Continue()
151
152        self.assertTrue(hit_breakpoints > 0,
153                        "inline test did not hit a single breakpoint")
154        # Either the process exited or the stepping plan is complete.
155        self.assertTrue(process.GetState() in [lldb.eStateStopped,
156                                               lldb.eStateExited],
157                        PROCESS_EXITED)
158
159    # Utilities for testcases
160
161    def check_expression(self, expression, expected_result, use_summary=True):
162        value = self.frame().EvaluateExpression(expression)
163        self.assertTrue(value.IsValid(), expression + "returned a valid value")
164        if self.TraceOn():
165            print(value.GetSummary())
166            print(value.GetValue())
167        if use_summary:
168            answer = value.GetSummary()
169        else:
170            answer = value.GetValue()
171        report_str = "%s expected: %s got: %s" % (
172            expression, expected_result, answer)
173        self.assertTrue(answer == expected_result, report_str)
174
175
176def ApplyDecoratorsToFunction(func, decorators):
177    tmp = func
178    if isinstance(decorators, list):
179        for decorator in decorators:
180            tmp = decorator(tmp)
181    elif hasattr(decorators, '__call__'):
182        tmp = decorators(tmp)
183    return tmp
184
185
186def MakeInlineTest(__file, __globals, decorators=None):
187    # Adjust the filename if it ends in .pyc.  We want filenames to
188    # reflect the source python file, not the compiled variant.
189    if __file is not None and __file.endswith(".pyc"):
190        # Strip the trailing "c"
191        __file = __file[0:-1]
192
193    # Derive the test name from the current file name
194    file_basename = os.path.basename(__file)
195
196    test_name, _ = os.path.splitext(file_basename)
197
198    test_func = ApplyDecoratorsToFunction(InlineTest._test, decorators)
199    # Build the test case
200    test_class = type(test_name, (InlineTest,), dict(test=test_func, name=test_name))
201
202    # Add the test case to the globals, and hide InlineTest
203    __globals.update({test_name: test_class})
204
205    # Keep track of the original test filename so we report it
206    # correctly in test results.
207    test_class.test_filename = __file
208    test_class.mydir = TestBase.compute_mydir(__file)
209    return test_class
210