tests.py 16.6 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
Johannes Bechberger's avatar
Johannes Bechberger committed
5 6 7 8 9 10
from mjtest.environment import Environment, TestMode, TEST_MODES
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 43 44 45 46 47
        for type in types:
            self._load_test_case_type(type)


    def _load_test_case_type(self, type: str):
        dir = join(self.env.test_dir, type)
        if exists(dir):
            self._load_test_case_dir(type, dir)
        else:
Johannes Bechberger's avatar
Johannes Bechberger committed
48
            _LOG.info("Test folder {} doesn't exist".format(dir))
Johannes Bechberger's avatar
Johannes Bechberger committed
49 50 51 52 53 54

    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:
55 56 57 58 59 60
                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
61 62 63 64
        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
65 66 67 68 69
        file_names = []
        for root, dirs, files in os.walk(dir):
            base = os.path.relpath(root, dir)
            if dir == root:
                file_names.extend(files)
70 71
            elif base == ".preprocessed":
                continue
72 73 74
            else:
                file_names.extend(join(base, file) for file in files)
        for file in sorted(file_names):
75
            if not TestCase.has_valid_file_ending(self.env.mode, file):
Johannes Bechberger's avatar
Johannes Bechberger committed
76 77 78 79
                _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:
80 81 82 83 84 85
                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
86 87 88
                if not test_case:
                    pass
                elif not test_case.can_run():
Johannes Bechberger's avatar
Johannes Bechberger committed
89 90
                    _LOG.debug("Skip test case '{}' because it isn't suited".format(test_case.name()))
                else:
Johannes Bechberger's avatar
Johannes Bechberger committed
91 92 93 94 95
                    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
96 97

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

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

    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")
122
            if self.env.produce_reports and (self.env.produce_all_reports or ret.failed > 0):
123
                report_dir = self.env.report_dir + "." + ("successful" if ret.failed == 0 else "failed")
124 125 126 127
                try:
                    os.rename(self.env.report_dir, report_dir)
                except IOError:
                    pass
128 129
                print("A full report for each test can be found at {}".format(
                    os.path.relpath(report_dir)))
Johannes Bechberger's avatar
Johannes Bechberger committed
130 131 132 133 134 135 136

            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
137 138 139 140 141 142 143 144 145
            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
146 147 148 149
        return RunResult(count, failed)

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

    def _run_parallel(self, mode: str, parallel_jobs: int) -> RunResult:
        pool = multiprocessing.Pool(parallel_jobs)
        rets = pool.map(self._func, self.test_cases[mode])
157 158 159 160 161 162
        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
163 164 165 166 167 168 169 170 171 172

    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:
173
                if self.env.produce_reports and (self.env.produce_all_reports or not ret.is_correct()):
174 175 176 177
                    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):
178 179 180 181
                        try:
                            os.mkdir(rep_dir)
                        except IOError:
                            pass
182 183
                    suffix = ".correct" if ret.is_correct() else ".incorrect"
                    ret.store_at(join(rep_dir, test_case.short_name() + suffix))
184 185 186
                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
187 188 189 190 191 192 193 194 195 196 197 198 199 200 201
                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
202 203 204 205
                try:
                    os.mkdir(os.path.dirname(log_file))
                except IOError:
                    pass
Johannes Bechberger's avatar
Johannes Bechberger committed
206 207 208 209 210 211 212 213 214 215 216
                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
217
    TEST_CASE_CLASSES = dict((k, []) for k in TEST_MODES)
Johannes Bechberger's avatar
Johannes Bechberger committed
218
    FILE_ENDINGS = []
Johannes Bechberger's avatar
Johannes Bechberger committed
219
    INVALID_FILE_ENDINGS = []
Johannes Bechberger's avatar
Johannes Bechberger committed
220

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

    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
232
        same_mode = self.type == mode
233
        types = TEST_MODES[TEST_MODES.index(self.env.mode):]
234
        if self.env.ci_testing:
Johannes Bechberger's avatar
Johannes Bechberger committed
235
            return same_mode or \
236 237 238
                   (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
239
            return same_mode
Johannes Bechberger's avatar
Johannes Bechberger committed
240 241 242 243 244

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

    @classmethod
245
    def create_from_file(cls, env: Environment, mode: str, file: str, preprocessed_file: str) -> Optional['TestCase']:
246
        if cls.has_valid_file_ending(env.mode, file):
247
            return cls._test_case_class_for_file(env.mode, file)(env, mode, file, preprocessed_file)
Johannes Bechberger's avatar
Johannes Bechberger committed
248 249 250 251 252 253 254 255 256 257 258
        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
259 260
            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
261 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
                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
295 296
    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
297
        super().__init__(test_case, error_code)
Johannes Bechberger's avatar
Johannes Bechberger committed
298
        self._incorrect_msg = incorrect_msg
299
        self._contains_error_str = error_output is not None and "error" in error_output
Johannes Bechberger's avatar
Johannes Bechberger committed
300 301
        self.error_output = error_output
        self.output = output
302
        self.other_texts = [] # type: List[Tuple[str, str, bool]]
Johannes Bechberger's avatar
Johannes Bechberger committed
303 304 305 306
        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
307 308 309 310 311 312 313 314 315 316 317 318 319

    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
320
            return self._incorrect_msg
Johannes Bechberger's avatar
Johannes Bechberger committed
321 322

    def long_message(self) -> str:
323
        file_content = []
324
        with open(self.test_case.preprocessed_file, "r") as f:
325
            file_content = [line.rstrip() for line in f]
326 327 328 329 330 331 332 333 334 335 336
        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
337 338 339 340 341 342 343
        return """{}

Source file:

{}

Return code: {}
344 345

{}
Johannes Bechberger's avatar
Johannes Bechberger committed
346
""".format(self.short_message().capitalize(), self._ident(file_content), self.error_code,
347 348 349 350 351 352 353
           "\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
354 355 356

    def _ident(self, text: Union[str,List[str]]) -> str:
        arr = text if isinstance(text, list) else text.split("\n")
357 358 359 360
        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
361

Johannes Bechberger's avatar
Johannes Bechberger committed
362 363 364 365 366 367

class BasicDiffTestResult(BasicTestResult):

    def __init__(self, test_case: TestCase, error_code: int, output: str, error_output: str, expected_output: str):
        super().__init__(test_case, error_code, output, error_output)
        self.expected_output = expected_output
368
        self._is_output_correct = self.expected_output.strip() == self.output.strip()
Johannes Bechberger's avatar
Johannes Bechberger committed
369 370 371 372 373
        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)
374
            #self.add_additional_text("Actual output", self.output)
Johannes Bechberger's avatar
Johannes Bechberger committed
375 376 377 378 379 380 381 382

    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:
383
        return "".join(difflib.Differ().compare(self.expected_output.splitlines(True), self.output.splitlines(True)))
Johannes Bechberger's avatar
Johannes Bechberger committed
384 385 386 387 388 389 390 391 392 393 394 395 396 397 398

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

    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\""
            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
399 400 401 402 403 404
class DiffTest(TestCase):

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

405 406
    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
407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435
        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
436 437

import mjtest.test.syntax_tests
438
import mjtest.test.ast_tests
Johannes Bechberger's avatar
Johannes Bechberger committed
439
import mjtest.test.semantic_tests
440
import mjtest.test.exec_tests