-
Notifications
You must be signed in to change notification settings - Fork 1
/
run_tests.py
208 lines (148 loc) · 6.63 KB
/
run_tests.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
#!/usr/bin/env python
# coding=utf-8
import unittest
import os
from xml.dom import minidom
import pyser
from lib import logger, lexer, parser
from lib.exceptions import LexerError, ParserError, InterpreterError
class Test(object):
def __init__(self, code, result=None, file_path=None):
self.code = code
self.result = result
self.file_path = file_path
def run(self):
result = pyser.run(file_path=self.file_path,
code=self.code,
debug=False)
return int(result[0])
class TestCase(unittest.TestCase):
_verbosity = logger.Verbosity.INFO
def setUp(self):
logger.set_verbosity(self._verbosity)
logger.info('Running %s' % self)
logger.indent()
def tearDown(self):
logger.unindent()
logger.info('')
class LexerTest(TestCase):
def run_tests(self, tests):
for test in tests:
tokens = lexer.parse(test)
logger.info('Pyser Query: %s -> %s' % (test.replace('\n', ' '), tokens))
for token in tokens:
self.assert_(isinstance(token, lexer.Token))
def run_tests_negative(self, tests):
for test in tests:
logger.info('Pyser Query: %s' % test.strip())
logger.indent_push()
self.assertRaises(LexerError, lexer.parse, test)
logger.indent_pop()
def test_lexer(self):
tests = ["SELECT 1 + 1 * 1 (2+2)/3%5**2^5*(5/5)",
"SELECT MAX(C1,2) + MIN() COUNT COUNT EACH AS C2 FROM",
"SELECT 1 + 1 AS C1 FROM ( SELECT 1 AS FOO, 2 AS BAR )"]
self.run_tests(tests)
def test_negative(self):
tests = ["SELECT >",
"SELECT @@@ B",
"SELECT @ 2 - 1"]
self.run_tests_negative(tests)
def test_pyser_xml(self):
root = minidom.parse(os.path.join('test', 'metrics.xml'))
tests = []
for counter in root.getElementsByTagName('counter'):
tests.append(counter.getAttribute('comment'))
self.run_tests(tests)
class ParserTest(TestCase):
def run_tests(self, tests):
for test in tests:
root = parser.build_tree(lexer.parse(test))
logger.info('Pyser Query: %s -> %s' % (test, root))
def run_tests_negative(self, tests):
for test in tests:
logger.info('Pyser Query: %s' % test)
self.assertRaises(ParserError, parser.build_tree, lexer.parse(test))
def test_parser(self):
tests = ["SELECT 1 + 1 * 1",
"SELECT C1 + C2 FROM ( SELECT 4 AS C1, 1 AS C2 ) "]
self.run_tests(tests)
def test_negative(self):
tests = ["SELECT C2 FROM ( SELECT 5 AS C1"]
self.run_tests_negative(tests)
class InterpreterTest(TestCase):
def run_tests(self, tests):
for test in tests:
logger.info('%s == %s' % (test.code, test.result))
self.assertEqual(test.result, test.run())
def run_tests_negative(self, tests):
for test in tests:
logger.info('Pyser Query: %s' % test.code)
logger.indent_push()
self.assertRaises(InterpreterError, test.run)
logger.indent_pop()
def test_not_found(self):
tests = [Test("SELECT SUM COUNT EACH FROM ( SELECT DISTINCT EACH '[xyzw]+' FROM ( "
"SELECT 'dcl_issssnput\s+v\d+.[xyzw]+' ) )",
result=0)]
self.run_tests(tests)
def test_arithmetic_operations(self):
tests = [Test('SELECT 11 + 13', 24),
Test('SELECT 11 - 9', 2),
Test('SELECT 2 * 3', 6),
Test('SELECT 2 ^ 3', 8),
Test('SELECT 2 ** 3', 8),
Test('SELECT 8 / 4', 2),
Test('SELECT 10 % 6', 4)]
self.run_tests(tests)
def test_functions(self):
tests = [Test('SELECT MAX(10, 100)', 100),
Test('SELECT MIN(10, 100)', 10),
Test('SELECT REPLACE(1, 100) FROM ( SELECT MAX(0, 1) )', 100),
Test('SELECT SUM(1, 2, 3)', 6)]
self.run_tests(tests)
def test_identifiers(self):
tests = [Test('SELECT C1 FROM ( SELECT MAX(2, 50) AS C1 )', 50)]
self.run_tests(tests)
def test_labeled_arithmetic_operations(self):
tests = [Test('SELECT C1 + C2 FROM ( SELECT 5 AS C1, 2 AS C2 )', 7)]
self.run_tests(tests)
def test_labeled_functions(self):
tests = [Test('SELECT MAX(C1, C2) FROM ( SELECT 5 AS C1, 100 AS C2 )', 100)]
self.run_tests(tests)
def test_negative(self):
tests = [Test("SELECT C1 FROM ( SELECT 5 AS C2 )"),
Test("SELECT ("),
Test("SELECT ) C1 FROM ( SELECT 5 AS C1 )"),
Test("SELECT *")]
self.run_tests_negative(tests)
def test_html_entities(self):
tests = [Test("SELECT FOO + BAR * 4 FROM (SELECT 4 AS FOO, 3 AS BAR)",
result=16)]
self.run_tests(tests)
def test_backward_compatibility(self):
tests = [
Test("SELECT '\d+' FROM (SELECT '\[\d+\]' FROM (SELECT 'dcl_constantbuffer cb0\[\d+\]'))LIMIT 1",
file_path='test/PS.asm', result=18),
Test("SELECT SUM FROM (SELECT COUNT EACH DISTINCT EACH '[xyzw]+' "
"FROM (SELECT 'cb0\[\d+\].[xyzw]+' FROM (SELECT 'mad[ a-zA-Z0-9-,\.\[\]]+')))",
file_path='test/PS.asm', result=13),
Test("SELECT COUNT DISTINCT '\d+' FROM (SELECT '[xyzw]+\s+\d+' "
"FROM (SELECT '\/\/ [A-Z]+[a-zA-Z_]+\s+\d+[\s+\w+\d+]+$' FROM (SELECT 'Input.*Output')))",
file_path='test/PS.asm', result=8),
Test("SELECT SUM FROM (SELECT COUNT EACH DISTINCT EACH '[xyzw]+' "
"FROM (SELECT DISTINCT 'cb0\[\d+\]\.[xyzw]+' FROM (SELECT 'mad[ a-zA-Z0-9-,\.\[\]]+$')))",
file_path='test/PS.asm', result=10),
Test("SELECT COUNT FROM (SELECT '\/\/ [A-Z]+ [ \da-z0-9A-Z]+$'FROM (SELECT 'Input.*Output'))",
file_path='test/VS.asm', result=7),
Test("SELECT COUNT '\/\/ [A-Z]+ [ \da-z0-9A-Z]+$'FROM (SELECT 'Input.*\/\/.\/\/$')",
file_path='test/VS.asm', result=7),
Test("SELECT COUNT FROM (SELECT "
"'\/\/ [A-Z]+[a-zA-Z_]+\s+\d+\s+\w+\s+\d+\s+\w+\s+\w+\s+\w+\s*$'FROM (SELECT 'Output.*'))",
file_path='test/VS.asm', result=2),
Test("SELECT COUNT '\/\/ [A-Z]+[a-zA-Z_]+\s+\d+[\s\d\w]+$' FROM (SELECT 'Output.*\/\/$')",
file_path='test/VS.asm', result=2)
]
self.run_tests(tests)
if __name__ == '__main__':
unittest.main()