• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1# Copyright (c) 2020 Valve Corporation
2#
3# SPDX-License-Identifier: MIT
4
5import re
6import sys
7import os.path
8import struct
9import string
10import copy
11from math import floor
12
13if os.isatty(sys.stdout.fileno()):
14    set_red = "\033[31m"
15    set_green = "\033[1;32m"
16    set_normal = "\033[0m"
17else:
18    set_red = ''
19    set_green = ''
20    set_normal = ''
21
22initial_code = '''
23import re
24
25def insert_code(code):
26    insert_queue.append(CodeCheck(code, current_position))
27
28def insert_pattern(pattern):
29    insert_queue.append(PatternCheck(pattern, False, current_position))
30
31def vector_gpr(prefix, name, size, align):
32    insert_code(f'{name} = {name}0')
33    for i in range(size):
34        insert_code(f'{name}{i} = {name}0 + {i}')
35    insert_code(f'success = {name}0 + {size - 1} == {name}{size - 1}')
36    insert_code(f'success = {name}0 % {align} == 0')
37    return f'{prefix}[#{name}0:#{name}{size - 1}]'
38
39def sgpr_vector(name, size, align):
40    return vector_gpr('s', name, size, align)
41
42funcs.update({
43    's64': lambda name: vector_gpr('s', name, 2, 2),
44    's96': lambda name: vector_gpr('s', name, 3, 2),
45    's128': lambda name: vector_gpr('s', name, 4, 4),
46    's256': lambda name: vector_gpr('s', name, 8, 4),
47    's512': lambda name: vector_gpr('s', name, 16, 4),
48})
49for i in range(2, 14):
50    funcs['v%d' % (i * 32)] = lambda name: vector_gpr('v', name, i, 1)
51
52def _match_func(names):
53    for name in names.split(' '):
54        insert_code(f'funcs["{name}"] = lambda _: {name}')
55    return ' '.join(f'${name}' for name in names.split(' '))
56
57funcs['match_func'] = _match_func
58
59def search_re(pattern):
60    global success
61    success = re.search(pattern, output.read_line()) != None and success
62
63'''
64
65class Check:
66    def __init__(self, data, position):
67        self.data = data.rstrip()
68        self.position = position
69
70    def run(self, state):
71        pass
72
73class CodeCheck(Check):
74    def run(self, state):
75        indent = 0
76        first_line = [l for l in self.data.split('\n') if l.strip() != ''][0]
77        indent_amount = len(first_line) - len(first_line.lstrip())
78        indent = first_line[:indent_amount]
79        new_lines = []
80        for line in self.data.split('\n'):
81            if line.strip() == '':
82                new_lines.append('')
83                continue
84            if line[:indent_amount] != indent:
85                state.result.log += 'unexpected indent in code check:\n'
86                state.result.log += self.data + '\n'
87                return False
88            new_lines.append(line[indent_amount:])
89        code = '\n'.join(new_lines)
90
91        try:
92            exec(code, state.g)
93            state.result.log += state.g['log']
94            state.g['log'] = ''
95        except BaseException as e:
96            state.result.log += 'code check at %s raised exception:\n' % self.position
97            state.result.log += code + '\n'
98            state.result.log += str(e)
99            return False
100        if not state.g['success']:
101            state.result.log += 'code check at %s failed:\n' % self.position
102            state.result.log += code + '\n'
103            return False
104        return True
105
106class StringStream:
107    class Pos:
108        def __init__(self):
109            self.line = 1
110            self.column = 1
111
112    def __init__(self, data, name):
113        self.name = name
114        self.data = data
115        self.offset = 0
116        self.pos = StringStream.Pos()
117
118    def reset(self):
119        self.offset = 0
120        self.pos = StringStream.Pos()
121
122    def peek(self, num=1):
123        return self.data[self.offset:self.offset+num]
124
125    def peek_test(self, chars):
126        c = self.peek(1)
127        return c != '' and c in chars
128
129    def read(self, num=4294967296):
130        res = self.peek(num)
131        self.offset += len(res)
132        for c in res:
133            if c == '\n':
134                self.pos.line += 1
135                self.pos.column = 1
136            else:
137                self.pos.column += 1
138        return res
139
140    def get_line(self, num):
141        return self.data.split('\n')[num - 1].rstrip()
142
143    def read_line(self):
144        line = ''
145        while self.peek(1) not in ['\n', '']:
146            line += self.read(1)
147        self.read(1)
148        return line
149
150    def skip_whitespace(self, inc_line):
151        chars = [' ', '\t'] + (['\n'] if inc_line else [])
152        while self.peek(1) in chars:
153            self.read(1)
154
155    def get_number(self):
156        num = ''
157        while self.peek() in string.digits:
158            num += self.read(1)
159        return num
160
161    def check_identifier(self):
162        return self.peek_test(string.ascii_letters + '_')
163
164    def get_identifier(self):
165        res = ''
166        if self.check_identifier():
167            while self.peek_test(string.ascii_letters + string.digits + '_'):
168                res += self.read(1)
169        return res
170
171def format_error_lines(at, line_num, column_num, ctx, line):
172    pred = '%s line %d, column %d of %s: "' % (at, line_num, column_num, ctx)
173    return [pred + line + '"',
174            '-' * (column_num - 1 + len(pred)) + '^']
175
176class MatchResult:
177    def __init__(self, pattern):
178        self.success = True
179        self.func_res = None
180        self.pattern = pattern
181        self.pattern_pos = StringStream.Pos()
182        self.output_pos = StringStream.Pos()
183        self.fail_message = ''
184
185    def set_pos(self, pattern, output):
186        self.pattern_pos.line = pattern.pos.line
187        self.pattern_pos.column = pattern.pos.column
188        self.output_pos.line = output.pos.line
189        self.output_pos.column = output.pos.column
190
191    def fail(self, msg):
192        self.success = False
193        self.fail_message = msg
194
195    def format_pattern_pos(self):
196        pat_pos = self.pattern_pos
197        pat_line = self.pattern.get_line(pat_pos.line)
198        res = format_error_lines('at', pat_pos.line, pat_pos.column, 'pattern', pat_line)
199        func_res = self.func_res
200        while func_res:
201            pat_pos = func_res.pattern_pos
202            pat_line = func_res.pattern.get_line(pat_pos.line)
203            res += format_error_lines('in', pat_pos.line, pat_pos.column, func_res.pattern.name, pat_line)
204            func_res = func_res.func_res
205        return '\n'.join(res)
206
207def do_match(g, pattern, output, skip_lines, in_func=False):
208    assert(not in_func or not skip_lines)
209
210    if not in_func:
211        output.skip_whitespace(False)
212    pattern.skip_whitespace(False)
213
214    old_g = copy.copy(g)
215    old_g_keys = list(g.keys())
216    res = MatchResult(pattern)
217    escape = False
218    while True:
219        res.set_pos(pattern, output)
220
221        c = pattern.read(1)
222        fail = False
223        if c == '':
224            if not in_func:
225                while output.peek() in [' ', '\t']:
226                    output.read(1)
227                if output.read(1) not in ['', '\n']:
228                    res.fail('expected end of output')
229
230            if res.success:
231               break
232        elif output.peek() == '':
233            res.fail('unexpected end of output')
234        elif c == '\\':
235            escape = True
236            continue
237        elif c == '\n':
238            old_line = output.pos.line
239            output.skip_whitespace(True)
240            if output.pos.line == old_line:
241                res.fail('expected newline in output')
242        elif not escape and c == '#':
243            num = output.get_number()
244            if num == '':
245                res.fail('expected number in output')
246            elif pattern.check_identifier():
247                name = pattern.get_identifier()
248                if name in g and int(num) != g[name]:
249                    res.fail('unexpected number for \'%s\': %d (expected %d)' % (name, int(num), g[name]))
250                elif name != '_':
251                    g[name] = int(num)
252        elif not escape and c == '$':
253            name = pattern.get_identifier()
254
255            val = ''
256            while not output.peek_test(string.whitespace):
257                val += output.read(1)
258
259            if name in g and val != g[name]:
260                res.fail('unexpected value for \'%s\': \'%s\' (expected \'%s\')' % (name, val, g[name]))
261            elif name != '_':
262                g[name] = val
263        elif not escape and c == '%' and pattern.check_identifier():
264            if output.read(1) != '%':
265                res.fail('expected \'%\' in output')
266            else:
267                num = output.get_number()
268                if num == '':
269                    res.fail('expected number in output')
270                else:
271                    name = pattern.get_identifier()
272                    if name in g and int(num) != g[name]:
273                        res.fail('unexpected number for \'%s\': %d (expected %d)' % (name, int(num), g[name]))
274                    elif name != '_':
275                        g[name] = int(num)
276        elif not escape and c == '@' and pattern.check_identifier():
277            name = pattern.get_identifier()
278            args = ''
279            if pattern.peek_test('('):
280                pattern.read(1)
281                while pattern.peek() not in ['', ')']:
282                    args += pattern.read(1)
283                assert(pattern.read(1) == ')')
284            func_res = g['funcs'][name](args)
285            match_res = do_match(g, StringStream(func_res, 'expansion of "%s(%s)"' % (name, args)), output, False, True)
286            if not match_res.success:
287                res.func_res = match_res
288                res.output_pos = match_res.output_pos
289                res.fail(match_res.fail_message)
290        elif not escape and c == ' ':
291            while pattern.peek_test(' '):
292                pattern.read(1)
293
294            read_whitespace = False
295            while output.peek_test(' \t'):
296                output.read(1)
297                read_whitespace = True
298            if not read_whitespace:
299                res.fail('expected whitespace in output, got %r' % (output.peek(1)))
300        else:
301            outc = output.peek(1)
302            if outc != c:
303                res.fail('expected %r in output, got %r' % (c, outc))
304            else:
305                output.read(1)
306        if not res.success:
307            if skip_lines and output.peek() != '':
308                g.clear()
309                g.update(old_g)
310                res.success = True
311                output.read_line()
312                pattern.reset()
313                output.skip_whitespace(False)
314                pattern.skip_whitespace(False)
315            else:
316                return res
317
318        escape = False
319
320    return res
321
322class PatternCheck(Check):
323    def __init__(self, data, search, position):
324        Check.__init__(self, data, position)
325        self.search = search
326
327    def run(self, state):
328        pattern_stream = StringStream(self.data.rstrip(), 'pattern')
329        res = do_match(state.g, pattern_stream, state.g['output'], self.search)
330        if not res.success:
331            state.result.log += 'pattern at %s failed: %s\n' % (self.position, res.fail_message)
332            state.result.log += res.format_pattern_pos() + '\n\n'
333            if not self.search:
334                out_line = state.g['output'].get_line(res.output_pos.line)
335                state.result.log += '\n'.join(format_error_lines('at', res.output_pos.line, res.output_pos.column, 'output', out_line))
336            else:
337                state.result.log += 'output was:\n'
338                state.result.log += state.g['output'].data.rstrip() + '\n'
339            return False
340        return True
341
342class CheckState:
343    def __init__(self, result, variant, checks, output):
344        self.result = result
345        self.variant = variant
346        self.checks = checks
347
348        self.checks.insert(0, CodeCheck(initial_code, None))
349        self.insert_queue = []
350
351        self.g = {'success': True, 'funcs': {}, 'insert_queue': self.insert_queue,
352                  'variant': variant, 'log': '', 'output': StringStream(output, 'output'),
353                  'CodeCheck': CodeCheck, 'PatternCheck': PatternCheck,
354                  'current_position': ''}
355
356class TestResult:
357    def __init__(self, expected):
358        self.result = ''
359        self.expected = expected
360        self.log = ''
361
362def check_output(result, variant, checks, output):
363    state = CheckState(result, variant, checks, output)
364
365    while len(state.checks):
366        check = state.checks.pop(0)
367        state.current_position = check.position
368        if not check.run(state):
369            result.result = 'failed'
370            return
371
372        for check in state.insert_queue[::-1]:
373            state.checks.insert(0, check)
374        state.insert_queue.clear()
375
376    result.result = 'passed'
377    return
378
379def parse_check(variant, line, checks, pos):
380    if line.startswith(';'):
381        line = line[1:]
382        if len(checks) and isinstance(checks[-1], CodeCheck):
383            checks[-1].data += '\n' + line
384        else:
385            checks.append(CodeCheck(line, pos))
386    elif line.startswith('!'):
387        checks.append(PatternCheck(line[1:], False, pos))
388    elif line.startswith('>>'):
389        checks.append(PatternCheck(line[2:], True, pos))
390    elif line.startswith('~'):
391        end = len(line)
392        start = len(line)
393        for c in [';', '!', '>>']:
394            if line.find(c) != -1 and line.find(c) < end:
395                end = line.find(c)
396        if end != len(line):
397            match = re.match(line[1:end], variant)
398            if match and match.end() == len(variant):
399                parse_check(variant, line[end:], checks, pos)
400
401def parse_test_source(test_name, variant, fname):
402    in_test = False
403    test = []
404    expected_result = 'passed'
405    line_num = 1
406    for line in open(fname, 'r').readlines():
407        if line.startswith('BEGIN_TEST(%s)' % test_name):
408            in_test = True
409        elif line.startswith('BEGIN_TEST_TODO(%s)' % test_name):
410            in_test = True
411            expected_result = 'todo'
412        elif line.startswith('BEGIN_TEST_FAIL(%s)' % test_name):
413            in_test = True
414            expected_result = 'failed'
415        elif line.startswith('END_TEST'):
416            in_test = False
417        elif in_test:
418            test.append((line_num, line.strip()))
419        line_num += 1
420
421    checks = []
422    for line_num, check in [(line_num, l[2:]) for line_num, l in test if l.startswith('//')]:
423         parse_check(variant, check, checks, 'line %d of %s' % (line_num, os.path.split(fname)[1]))
424
425    return checks, expected_result
426
427def parse_and_check_test(test_name, variant, test_file, output, current_result):
428    checks, expected = parse_test_source(test_name, variant, test_file)
429
430    result = TestResult(expected)
431    if len(checks) == 0:
432        result.result = 'empty'
433        result.log = 'no checks found'
434    elif current_result != None:
435        result.result, result.log = current_result
436    else:
437        check_output(result, variant, checks, output)
438        if result.result == 'failed' and expected == 'todo':
439            result.result = 'todo'
440
441    return result
442
443def print_results(results, output, expected):
444    results = {name: result for name, result in results.items() if result.result == output}
445    results = {name: result for name, result in results.items() if (result.result == result.expected) == expected}
446
447    if not results:
448        return 0
449
450    print('%s tests (%s):' % (output, 'expected' if expected else 'unexpected'))
451    for test, result in results.items():
452        color = '' if expected else set_red
453        print('   %s%s%s' % (color, test, set_normal))
454        if result.log.strip() != '':
455            for line in result.log.rstrip().split('\n'):
456                print('      ' + line.rstrip())
457    print('')
458
459    return len(results)
460
461def get_cstr(fp):
462    res = b''
463    while True:
464        c = fp.read(1)
465        if c == b'\x00':
466            return res.decode('utf-8')
467        else:
468            res += c
469
470if __name__ == "__main__":
471   results = {}
472
473   stdin = sys.stdin.buffer
474   while True:
475       packet_type = stdin.read(4)
476       if packet_type == b'':
477           break;
478
479       test_name = get_cstr(stdin)
480       test_variant = get_cstr(stdin)
481       if test_variant != '':
482           full_name = test_name + '/' + test_variant
483       else:
484           full_name = test_name
485
486       test_source_file = get_cstr(stdin)
487       current_result = None
488       if ord(stdin.read(1)):
489           current_result = (get_cstr(stdin), get_cstr(stdin))
490       code_size = struct.unpack("=L", stdin.read(4))[0]
491       code = stdin.read(code_size).decode('utf-8')
492
493       results[full_name] = parse_and_check_test(test_name, test_variant, test_source_file, code, current_result)
494
495   result_types = ['passed', 'failed', 'todo', 'empty']
496   num_expected = 0
497   num_unexpected = 0
498   for t in result_types:
499       num_expected += print_results(results, t, True)
500   for t in result_types:
501       num_unexpected += print_results(results, t, False)
502   num_expected_skipped = print_results(results, 'skipped', True)
503   num_unexpected_skipped = print_results(results, 'skipped', False)
504
505   num_unskipped = len(results) - num_expected_skipped - num_unexpected_skipped
506   color = set_red if num_unexpected else set_green
507   print('%s%d (%.0f%%) of %d unskipped tests had an expected result%s' % (color, num_expected, floor(num_expected / num_unskipped * 100), num_unskipped, set_normal))
508   if num_unexpected_skipped:
509       print('%s%d tests had been unexpectedly skipped%s' % (set_red, num_unexpected_skipped, set_normal))
510
511   if num_unexpected:
512       sys.exit(1)
513