tests.py 17 KB
Newer Older
Johannes Bechberger's avatar
Johannes Bechberger committed
1
2
from collections import namedtuple
import shutil
3
from typing import Optional, List, Tuple, T, Union, Dict
4
import collections
5
from mjtest.environment import Environment, TestMode, TEST_MODES, get_test_dirname
Johannes Bechberger's avatar
Johannes Bechberger committed
6
7
8
9
10
from os.path import join, exists, basename
import logging
import os
import multiprocessing
from mjtest.util.parallelism import available_cpu_count
11
from mjtest.util.utils import cprint, colored
Johannes Bechberger's avatar
Johannes Bechberger committed
12
13
from pprint import pprint
import shutil
Johannes Bechberger's avatar
Johannes Bechberger committed
14
import difflib
Johannes Bechberger's avatar
Johannes Bechberger committed
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

_LOG = logging.getLogger("tests")


RunResult = namedtuple("RunResult", ['count', 'failed'])


class TestSuite:
    """
    The whole set of tests.
    """

    def __init__(self, env: Environment):
        self.env = env
        self.test_cases = {} # type: Dict[str, List[TestCase]]
30
        self.correct_test_cases = collections.defaultdict(set) # type: Dict[str, Set[str]]
Johannes Bechberger's avatar
Johannes Bechberger committed
31
32
33
        self._load_test_cases()

    def _load_test_cases(self):
Johannes Bechberger's avatar
Johannes Bechberger committed
34
35
36
37
38
        types = [self.env.mode]#TEST_MODES#TEST_MODES[TEST_MODES.index(self.env.mode):]
        if self.env.ci_testing:
            types = TEST_MODES
        elif self.env.mode in TestMode.USE_TESTS_OF_OTHER:
            types += TestMode.USE_TESTS_OF_OTHER[self.env.mode]
Johannes Bechberger's avatar
Johannes Bechberger committed
39
40
41
42
        for type in types:
            self._load_test_case_type(type)

    def _load_test_case_type(self, type: str):
43
44
45
        dir = join(self.env.test_dir, get_test_dirname(type))
        if get_test_dirname(type) == "exec" and self.env.only_small_exec_tests:
            dir = join(dir, "small")
Johannes Bechberger's avatar
Johannes Bechberger committed
46
47
48
        if exists(dir):
            self._load_test_case_dir(type, dir)
        else:
Johannes Bechberger's avatar
Johannes Bechberger committed
49
            _LOG.info("Test folder {} doesn't exist".format(dir))
Johannes Bechberger's avatar
Johannes Bechberger committed
50
51
52
53
54
55

    def _load_test_case_dir(self, mode: str, dir: str):
        correct_test_cases = set()
        log_file = self._log_file_for_type(mode)
        if exists(log_file):
            with open(log_file) as f:
56
57
58
59
60
61
                correct_test_cases = set()
                for t in f.readlines():
                    t = t.strip()
                    if len(t) > 0:
                        self.correct_test_cases[mode].add(t)
                        correct_test_cases.add(t)
Johannes Bechberger's avatar
Johannes Bechberger committed
62
63
64
65
        m = mode
        if m != self.env.mode and self.env.mode in TestMode.USE_TESTS_OF_OTHER and \
            m in TestMode.USE_TESTS_OF_OTHER[self.env.mode]:
            m = self.env.mode
66
67
68
69
70
        file_names = []
        for root, dirs, files in os.walk(dir):
            base = os.path.relpath(root, dir)
            if dir == root:
                file_names.extend(files)
71
72
            elif base == ".preprocessed":
                continue
73
74
75
            else:
                file_names.extend(join(base, file) for file in files)
        for file in sorted(file_names):
76
            if not TestCase.has_valid_file_ending(self.env.mode, file):
Johannes Bechberger's avatar
Johannes Bechberger committed
77
78
79
80
                _LOG.debug("Skip file " + file)
            elif self.env.only_incorrect_tests and file in correct_test_cases:
                _LOG.info("Skip file {} as its test case was executed correctly the last run")
            else:
81
82
83
84
85
86
                file_path = join(dir, file)
                if self.env.has_to_preprocess(file_path) and self.env.is_lib_file(file_path):
                    _LOG.debug("Skip lib file '{}'".format(file))
                    continue
                preprocessed = self.env.preprocess(join(dir, file))
                test_case = TestCase.create_from_file(self.env, m, join(dir, file), preprocessed)
Johannes Bechberger's avatar
Johannes Bechberger committed
87
88
89
                if not test_case:
                    pass
                elif not test_case.can_run():
Johannes Bechberger's avatar
Johannes Bechberger committed
90
91
                    _LOG.debug("Skip test case '{}' because it isn't suited".format(test_case.name()))
                else:
Johannes Bechberger's avatar
Johannes Bechberger committed
92
93
94
95
96
                    if m not in self.test_cases:
                        self.test_cases[m] = []
                    self.test_cases[m].append(test_case)
        if m in self.test_cases and len(self.test_cases[m]) == 0:
            del self.test_cases[m]
Johannes Bechberger's avatar
Johannes Bechberger committed
97
98

    def _log_file_for_type(self, type: str):
99
        return join(self.env.test_dir, get_test_dirname(type), ".mjtest_correct_testcases_" + self.env.mode)
Johannes Bechberger's avatar
Johannes Bechberger committed
100
101

    def _add_correct_test_case(self, test_case: 'TestCase'):
102
        self.correct_test_cases[test_case.type].add(basename(test_case.file))
Johannes Bechberger's avatar
Johannes Bechberger committed
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

    def run(self) -> RunResult:
        ret = RunResult(0, 0)
        try:
            for mode in self.test_cases.keys():
                single_ret = RunResult(0, 0)
                if self.env.parallel:
                    single_ret = self._run_parallel(mode, available_cpu_count())
                else:
                    single_ret = self._run_sequential(mode)
                ret = RunResult(ret.count + single_ret.count, ret.failed + single_ret.failed)
        except BaseException:
            logging.exception("")
        finally:
            print("-" * 40)
            if ret.failed > 0:  # some tests failed
                print(colored("Ran {} tests, of which ".format(ret.count), "red") +
                      colored("{} failed.".format(ret.failed), "red", attrs=["bold"]))
            else:
                cprint("All {} run tests succeeded".format(ret.count), "green")
123
            if self.env.produce_reports and (self.env.produce_all_reports or ret.failed > 0):
124
                report_dir = self.env.report_dir + "." + ("successful" if ret.failed == 0 else "failed")
125
126
127
128
                try:
                    os.rename(self.env.report_dir, report_dir)
                except IOError:
                    pass
129
130
                print("A full report for each test can be found at {}".format(
                    os.path.relpath(report_dir)))
Johannes Bechberger's avatar
Johannes Bechberger committed
131
132
133
134
135
136
137

            return ret

    def _run_sequential(self, mode: str) -> RunResult:
        failed = 0
        count = 0
        for test_case in self.test_cases[mode]:
Johannes Bechberger's avatar
Johannes Bechberger committed
138
139
140
141
142
143
144
145
146
            try:
                ret = self._run_test_case(test_case)
                if ret is False or not ret.is_correct():
                    failed += 1
                else:
                    self._add_correct_test_case(test_case)
                count += 1
            except KeyboardInterrupt:
                return RunResult(count, failed)
Johannes Bechberger's avatar
Johannes Bechberger committed
147
148
149
150
        return RunResult(count, failed)

    def _func(self, test_case: 'TestCase'):
        ret = self._run_test_case(test_case)
Johannes Bechberger's avatar
Johannes Bechberger committed
151
        if ret is not False and ret.is_correct():
152
153
            return 0, test_case
        return 1, test_case
Johannes Bechberger's avatar
Johannes Bechberger committed
154
155
156
157

    def _run_parallel(self, mode: str, parallel_jobs: int) -> RunResult:
        pool = multiprocessing.Pool(parallel_jobs)
        rets = pool.map(self._func, self.test_cases[mode])
158
159
160
161
162
163
        result = RunResult(len(rets), sum(map(lambda x: x[0], rets)))
        for (suc, test_case) in rets:
            if suc == 0:
                self._add_correct_test_case(test_case)
        return result

Johannes Bechberger's avatar
Johannes Bechberger committed
164
165
166
167
168
169
170
171
172
173

    def _run_test_case(self, test_case: 'TestCase') -> Optional['TestResult']:
        try:
            ret = test_case.run()
            color = "green" if ret.is_correct() else "red"
            print(colored("[{result:7s}] {tc:40s}".format(
                result="SUCCESS" if ret.is_correct() else "FAIL",
                tc=test_case.name()), color, attrs=["bold"]) +
                  colored("" if ret.is_correct() else ret.short_message(), color))
            try:
174
                if self.env.produce_reports and (self.env.produce_all_reports or not ret.is_correct()):
175
176
177
178
                    if not exists(self.env.report_dir):
                        os.mkdir(self.env.report_dir)
                    rep_dir = join(self.env.report_dir, test_case.type)
                    if not exists(rep_dir):
179
180
181
182
                        try:
                            os.mkdir(rep_dir)
                        except IOError:
                            pass
183
184
                    suffix = ".correct" if ret.is_correct() else ".incorrect"
                    ret.store_at(join(rep_dir, test_case.short_name() + suffix))
185
186
187
                if self.env.output_incorrect_reports and not ret.is_correct():
                    print(colored("Report for failing test case {}".format(test_case.short_name()), "red", attrs=["bold"]))
                    print(colored(ret.long_message(), "red"))
Johannes Bechberger's avatar
Johannes Bechberger committed
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
                return ret
            except IOError:
                _LOG.exception("Caught i/o error while trying to store the report for '{}'"
                               .format(test_case.name()))
                return False
        except KeyboardInterrupt:
            raise
        except BaseException:
            _LOG.exception("At test case '{}'".format(test_case.short_name()))
            return False

    def store(self):
        for mode in self.correct_test_cases.keys():
            log_file = self._log_file_for_type(mode)
            try:
Johannes Bechberger's avatar
Johannes Bechberger committed
203
204
205
206
                try:
                    os.mkdir(os.path.dirname(log_file))
                except IOError:
                    pass
Johannes Bechberger's avatar
Johannes Bechberger committed
207
208
209
210
211
212
213
214
215
216
217
                with open(log_file, "w") as f:
                    f.write("\n".join(self.correct_test_cases[mode]))
            except IOError as e:
                _LOG.exception("Caught i/o error while storing {}".format(log_file))


class TestCase:
    """
    A single test case.
    """

Johannes Bechberger's avatar
Johannes Bechberger committed
218
    TEST_CASE_CLASSES = dict((k, []) for k in TEST_MODES)
Johannes Bechberger's avatar
Johannes Bechberger committed
219
    FILE_ENDINGS = []
Johannes Bechberger's avatar
Johannes Bechberger committed
220
    INVALID_FILE_ENDINGS = []
Johannes Bechberger's avatar
Johannes Bechberger committed
221

222
    def __init__(self, env: Environment, type: str, file: str, preprocessed_file: str):
Johannes Bechberger's avatar
Johannes Bechberger committed
223
224
225
        self.env = env
        self.type = type
        self.file = file
226
        self.preprocessed_file = preprocessed_file
Johannes Bechberger's avatar
Johannes Bechberger committed
227
228
229
230
231
232

    def should_succeed(self) -> bool:
        raise NotImplementedError()

    def can_run(self, mode: str = "") -> bool:
        mode = mode or self.env.mode
Johannes Bechberger's avatar
Johannes Bechberger committed
233
        same_mode = self.type == mode
234
        types = TEST_MODES[TEST_MODES.index(self.env.mode):]
235
        if self.env.ci_testing:
Johannes Bechberger's avatar
Johannes Bechberger committed
236
            return same_mode or \
237
238
239
                   (self.type in types and self.should_succeed()) or \
                   (self.type not in types and not self.should_succeed())
        else:
Johannes Bechberger's avatar
Johannes Bechberger committed
240
            return same_mode
Johannes Bechberger's avatar
Johannes Bechberger committed
241
242
243
244
245

    def run(self) -> 'TestResult':
        raise NotImplementedError()

    @classmethod
246
    def create_from_file(cls, env: Environment, mode: str, file: str, preprocessed_file: str) -> Optional['TestCase']:
247
        if cls.has_valid_file_ending(env.mode, file):
248
            return cls._test_case_class_for_file(env.mode, file)(env, mode, file, preprocessed_file)
Johannes Bechberger's avatar
Johannes Bechberger committed
249
250
251
252
253
254
255
256
257
258
259
        return None

    def name(self):
        return "{}:{}".format(self.type, self.short_name())

    def short_name(self) -> str:
        raise NotImplementedError()

    @classmethod
    def _test_case_class_for_file(cls, type: str, file: str):
        for t in cls.TEST_CASE_CLASSES[type]:
Johannes Bechberger's avatar
Johannes Bechberger committed
260
261
            if any(file.endswith(e) for e in t.FILE_ENDINGS) and \
                    not any(file.endswith(e) for e in t.INVALID_FILE_ENDINGS):
Johannes Bechberger's avatar
Johannes Bechberger committed
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
                return t
        return False


    @classmethod
    def has_valid_file_ending(cls, type: str, file: str):
        return cls._test_case_class_for_file(type, file) != False


class TestResult:

    def __init__(self, test_case: TestCase, error_code: int):
        self.test_case = test_case
        self.error_code = error_code

    def is_correct(self) -> bool:
        return self.succeeded() == self.test_case.should_succeed()

    def succeeded(self) -> bool:
        return self.error_code == 0

    def store_at(self, file: str):
        with open(file, "w") as f:
            print(self.long_message(), file=f)

    def short_message(self) -> str:
        raise NotImplementedError()

    def long_message(self) -> str:
        raise NotImplementedError()


class BasicTestResult(TestResult):

Johannes Bechberger's avatar
Johannes Bechberger committed
296
297
    def __init__(self, test_case: TestCase, error_code: int, output: str = None, error_output: str = None,
                 incorrect_msg: str = "incorrect return code"):
Johannes Bechberger's avatar
Johannes Bechberger committed
298
        super().__init__(test_case, error_code)
Johannes Bechberger's avatar
Johannes Bechberger committed
299
        self._incorrect_msg = incorrect_msg
300
        self._contains_error_str = error_output is not None and "error" in error_output
Johannes Bechberger's avatar
Johannes Bechberger committed
301
302
        self.error_output = error_output
        self.output = output
303
        self.other_texts = [] # type: List[Tuple[str, str, bool]]
Johannes Bechberger's avatar
Johannes Bechberger committed
304
305
306
307
        if output:
            self.add_additional_text("Output", output)
        if error_output:
            self.add_additional_text("Error output", error_output)
Johannes Bechberger's avatar
Johannes Bechberger committed
308
309
310
311
312
313
314
315
316
317
318
319
320

    def is_correct(self):
        if self.succeeded():
            return super().is_correct()
        else:
            return super().is_correct() and self._contains_error_str

    def short_message(self) -> str:
        if self.is_correct():
            return "correct"
        else:
            if not self.succeeded() and not self.test_case.should_succeed() and not self._contains_error_str:
                return "the error output doesn't contain the word \"error\""
Johannes Bechberger's avatar
Johannes Bechberger committed
321
            return self._incorrect_msg
Johannes Bechberger's avatar
Johannes Bechberger committed
322
323

    def long_message(self) -> str:
324
        file_content = []
325
        with open(self.test_case.preprocessed_file, "r") as f:
326
            file_content = [line.rstrip() for line in f]
327
328
329
330
331
332
333
334
335
336
337
        others = []
        for title, content, long_text in self.other_texts:
            if long_text:
                others.append("""
{}:

{}

""".format(title, self._ident(content)))
            else:
                others.append("""{}: {}\n""".format(title, content))
Johannes Bechberger's avatar
Johannes Bechberger committed
338
339
340
341
342
343
344
        return """{}

Source file:

{}

Return code: {}
345
346

{}
Johannes Bechberger's avatar
Johannes Bechberger committed
347
""".format(self.short_message().capitalize(), self._ident(file_content), self.error_code,
348
349
350
351
352
353
354
           "\n".join(others))

    def add_additional_text(self, title: str, content: str):
        self.other_texts.append((title, content, True))

    def add_additional_text_line(self, title: str, content: str):
        self.other_texts.append((title, content, False))
Johannes Bechberger's avatar
Johannes Bechberger committed
355
356
357

    def _ident(self, text: Union[str,List[str]]) -> str:
        arr = text if isinstance(text, list) else text.split("\n")
358
359
360
361
        if len(arr) == 0 or text == "":
            return ""
        arr = ["[{:04d}]    {:s}".format(i + 1, l) for (i, l) in enumerate(arr)]
        return "\n".join(arr)
Johannes Bechberger's avatar
Johannes Bechberger committed
362

Johannes Bechberger's avatar
Johannes Bechberger committed
363
364
365

class BasicDiffTestResult(BasicTestResult):

366
367
    def __init__(self, test_case: TestCase, error_code: int, output: str, error_output: str, expected_output: str,
                 short_error_message: str = None):
Johannes Bechberger's avatar
Johannes Bechberger committed
368
369
        super().__init__(test_case, error_code, output, error_output)
        self.expected_output = expected_output
370
        self._is_output_correct = self.expected_output.strip() == self.output.strip()
Johannes Bechberger's avatar
Johannes Bechberger committed
371
372
373
374
375
        if self.is_correct():
            self.add_additional_text("Expected and actual output", self.output)
        elif self.succeeded() and self.test_case.should_succeed():
            self.add_additional_text("Diff[expected output, actual output]", self._output_diff())
            self.add_additional_text("Expected output", self.expected_output)
376
        self.short_error_message = short_error_message
377
            #self.add_additional_text("Actual output", self.output)
Johannes Bechberger's avatar
Johannes Bechberger committed
378
379
380
381
382
383
384
385

    def is_correct(self):
        if self.succeeded():
            return super().is_correct() and self.is_output_correct()
        else:
            return super().is_correct() and self._contains_error_str

    def _output_diff(self) -> str:
386
        return "".join(difflib.Differ().compare(self.expected_output.splitlines(True), self.output.splitlines(True)))
Johannes Bechberger's avatar
Johannes Bechberger committed
387
388
389
390
391
392
393
394

    def is_output_correct(self) -> str:
        return self._is_output_correct

    def short_message(self) -> str:
        if self.is_correct():
            return "correct"
        else:
395
396
            if self.short_error_message:
                return self.short_error_message
Johannes Bechberger's avatar
Johannes Bechberger committed
397
398
399
400
401
402
403
            if not self.succeeded() and not self.test_case.should_succeed() and not self._contains_error_str:
                return "the error output doesn't contain the word \"error\""
            if self.succeeded() and self.test_case.should_succeed():
                return "the actual output differs from the expected"
            return "incorrect return code"


Johannes Bechberger's avatar
Johannes Bechberger committed
404
405
406
407
408
409
class DiffTest(TestCase):

    FILE_ENDINGS = [".invalid.mj", ".valid.mj", ".mj"]
    OUTPUT_FILE_ENDING = ".out"
    MODE = TestMode.ast

410
411
    def __init__(self, env: Environment, type: str, file: str, preprocessed_file: str):
        super().__init__(env, type, file, preprocessed_file)
Johannes Bechberger's avatar
Johannes Bechberger committed
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
        self._should_succeed = not file.endswith(".invalid.mj")
        self._expected_output_file = file + self.OUTPUT_FILE_ENDING
        self._has_expected_output_file = exists(self._expected_output_file)

    def should_succeed(self) -> bool:
        return self._should_succeed

    def short_name(self) -> str:
        return basename(self.file)

    def run(self) -> BasicDiffTestResult:
        out, err, rtcode = self.env.run_mj_command(self.MODE, self.file)
        exp_out = ""
        if rtcode == 0 and self.should_succeed():
            if self._has_expected_output_file and self.type == self.MODE and self.env.mode == self.MODE:
                with open(self._expected_output_file, "r") as f:
                    exp_out = f.read()
            #else:
            #    _LOG.error("Expected output file for test case {}:{} is missing.".format(self.MODE, self.short_name()))
        if self.type == self.MODE and self.env.mode == self.MODE:
            return BasicDiffTestResult(self, rtcode, out.decode(), err.decode(), exp_out)
        return BasicTestResult(self, rtcode, out.decode(), err.decode())


class LexerDiffTest(DiffTest):

    MODE = TestMode.lexer

TestCase.TEST_CASE_CLASSES[TestMode.lexer].append(LexerDiffTest)
Johannes Bechberger's avatar
Johannes Bechberger committed
441
442

import mjtest.test.syntax_tests
443
import mjtest.test.ast_tests
Johannes Bechberger's avatar
Johannes Bechberger committed
444
import mjtest.test.semantic_tests
445
import mjtest.test.exec_tests